<h2>File Contents: //lib/python3.6/site-packages/firewall/server/config.py</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//lib/python3.6/site-packages/firewall/server/config.py'><textarea name='file_content' rows='10' cols='50'># -*- coding: utf-8 -*-
#
# Copyright (C) 2010-2016 Red Hat, Inc.
#
# Authors:
# Thomas Woerner &lt;twoerner@redhat.com&gt;
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see &lt;http://www.gnu.org/licenses/&gt;.

# force use of pygobject3 in python-slip
from gi.repository import GObject
import sys
sys.modules['gobject'] = GObject
import os

import dbus
import dbus.service
import slip.dbus
import slip.dbus.service

from firewall import config
from firewall.core.base import DEFAULT_ZONE_TARGET
from firewall.core.watcher import Watcher
from firewall.core.logger import log
from firewall.server.decorators import handle_exceptions, \
    dbus_handle_exceptions, dbus_service_method
from firewall.server.config_icmptype import FirewallDConfigIcmpType
from firewall.server.config_service import FirewallDConfigService
from firewall.server.config_zone import FirewallDConfigZone
from firewall.server.config_policy import FirewallDConfigPolicy
from firewall.server.config_ipset import FirewallDConfigIPSet
from firewall.server.config_helper import FirewallDConfigHelper
from firewall.core.io.icmptype import IcmpType
from firewall.core.io.ipset import IPSet
from firewall.core.io.helper import Helper
from firewall.core.io.lockdown_whitelist import LockdownWhitelist
from firewall.core.io.direct import Direct
from firewall.dbus_utils import dbus_to_python, \
    command_of_sender, context_of_sender, uid_of_sender, user_of_uid, \
    dbus_introspection_prepare_properties, \
    dbus_introspection_add_properties
from firewall import errors
from firewall.errors import FirewallError

############################################################################
#
# class FirewallDConfig
#
############################################################################

class FirewallDConfig(slip.dbus.service.Object):
    &quot;&quot;&quot;FirewallD main class&quot;&quot;&quot;

    persistent = True
    &quot;&quot;&quot; Make FirewallD persistent. &quot;&quot;&quot;
    default_polkit_auth_required = config.dbus.PK_ACTION_CONFIG
    &quot;&quot;&quot; Use config.dbus.PK_ACTION_INFO as a default &quot;&quot;&quot;

    @handle_exceptions
    def __init__(self, conf, *args, **kwargs):
        super(FirewallDConfig, self).__init__(*args, **kwargs)
        self.config = conf
        self.busname = args[0]
        self.path = args[1]
        self._init_vars()
        self.watcher = Watcher(self.watch_updater, 5)
        self.watcher.add_watch_dir(config.FIREWALLD_IPSETS)
        self.watcher.add_watch_dir(config.ETC_FIREWALLD_IPSETS)
        self.watcher.add_watch_dir(config.FIREWALLD_ICMPTYPES)
        self.watcher.add_watch_dir(config.ETC_FIREWALLD_ICMPTYPES)
        self.watcher.add_watch_dir(config.FIREWALLD_HELPERS)
        self.watcher.add_watch_dir(config.ETC_FIREWALLD_HELPERS)
        self.watcher.add_watch_dir(config.FIREWALLD_SERVICES)
        self.watcher.add_watch_dir(config.ETC_FIREWALLD_SERVICES)
        self.watcher.add_watch_dir(config.FIREWALLD_ZONES)
        self.watcher.add_watch_dir(config.ETC_FIREWALLD_ZONES)
        self.watcher.add_watch_dir(config.FIREWALLD_POLICIES)
        self.watcher.add_watch_dir(config.ETC_FIREWALLD_POLICIES)
        # Add watches for combined zone directories
        if os.path.exists(config.ETC_FIREWALLD_ZONES):
            for filename in sorted(os.listdir(config.ETC_FIREWALLD_ZONES)):
                path = &quot;%s/%s&quot; % (config.ETC_FIREWALLD_ZONES, filename)
                if os.path.isdir(path):
                    self.watcher.add_watch_dir(path)
        self.watcher.add_watch_file(config.LOCKDOWN_WHITELIST)
        self.watcher.add_watch_file(config.FIREWALLD_DIRECT)
        self.watcher.add_watch_file(config.FIREWALLD_CONF)

        dbus_introspection_prepare_properties(self,
                                              config.dbus.DBUS_INTERFACE_CONFIG,
                                              { &quot;CleanupOnExit&quot;: &quot;readwrite&quot;,
                                                &quot;CleanupModulesOnExit&quot;: &quot;readwrite&quot;,
                                                &quot;IPv6_rpfilter&quot;: &quot;readwrite&quot;,
                                                &quot;Lockdown&quot;: &quot;readwrite&quot;,
                                                &quot;MinimalMark&quot;: &quot;readwrite&quot;,
                                                &quot;IndividualCalls&quot;: &quot;readwrite&quot;,
                                                &quot;LogDenied&quot;: &quot;readwrite&quot;,
                                                &quot;AutomaticHelpers&quot;: &quot;readwrite&quot;,
                                                &quot;FirewallBackend&quot;: &quot;readwrite&quot;,
                                                &quot;FlushAllOnReload&quot;: &quot;readwrite&quot;,
                                                &quot;RFC3964_IPv4&quot;: &quot;readwrite&quot;,
                                                &quot;AllowZoneDrifting&quot;: &quot;readwrite&quot;,
                                              })

    @handle_exceptions
    def _init_vars(self):
        self.ipsets = [ ]
        self.ipset_idx = 0
        self.icmptypes = [ ]
        self.icmptype_idx = 0
        self.services = [ ]
        self.service_idx = 0
        self.zones = [ ]
        self.zone_idx = 0
        self.helpers = [ ]
        self.helper_idx = 0
        self.policy_objects = [ ]
        self.policy_object_idx = 0

        for ipset in self.config.get_ipsets():
            self._addIPSet(self.config.get_ipset(ipset))
        for icmptype in self.config.get_icmptypes():
            self._addIcmpType(self.config.get_icmptype(icmptype))
        for service in self.config.get_services():
            self._addService(self.config.get_service(service))
        for zone in self.config.get_zones():
            self._addZone(self.config.get_zone(zone))
        for helper in self.config.get_helpers():
            self._addHelper(self.config.get_helper(helper))
        for policy in self.config.get_policy_objects():
            self._addPolicy(self.config.get_policy_object(policy))

    @handle_exceptions
    def __del__(self):
        pass

    @handle_exceptions
    def reload(self):
        while len(self.ipsets) &gt; 0:
            item = self.ipsets.pop()
            item.unregister()
            del item
        while len(self.icmptypes) &gt; 0:
            item = self.icmptypes.pop()
            item.unregister()
            del item
        while len(self.services) &gt; 0:
            item = self.services.pop()
            item.unregister()
            del item
        while len(self.zones) &gt; 0:
            item = self.zones.pop()
            item.unregister()
            del item
        while len(self.helpers) &gt; 0:
            item = self.helpers.pop()
            item.unregister()
            del item
        while len(self.policy_objects) &gt; 0:
            item = self.policy_objects.pop()
            item.unregister()
            del item
        self._init_vars()

    @handle_exceptions
    def watch_updater(self, name):
        if name == config.FIREWALLD_CONF:
            old_props = self.GetAll(config.dbus.DBUS_INTERFACE_CONFIG)
            log.debug1(&quot;config: Reloading firewalld config file '%s'&quot;,
                       config.FIREWALLD_CONF)
            try:
                self.config.update_firewalld_conf()
            except Exception as msg:
                log.error(&quot;Failed to load firewalld.conf file '%s': %s&quot; % \
                          (name, msg))
                return
            props = self.GetAll(config.dbus.DBUS_INTERFACE_CONFIG).copy()
            for key in list(props.keys()):
                if key in old_props and old_props[key] == props[key]:
                    del props[key]
            if len(props) &gt; 0:
                self.PropertiesChanged(config.dbus.DBUS_INTERFACE_CONFIG,
                                       props, [])
            return

        if (name.startswith(config.FIREWALLD_ICMPTYPES) or \
            name.startswith(config.ETC_FIREWALLD_ICMPTYPES)) and \
           name.endswith(&quot;.xml&quot;):
            try:
                (what, obj) = self.config.update_icmptype_from_path(name)
            except Exception as msg:
                log.error(&quot;Failed to load icmptype file '%s': %s&quot; % (name, msg))
                return
            if what == &quot;new&quot;:
                self._addIcmpType(obj)
            elif what == &quot;remove&quot;:
                self.removeIcmpType(obj)
            elif what == &quot;update&quot;:
                self._updateIcmpType(obj)

        elif (name.startswith(config.FIREWALLD_SERVICES) or \
              name.startswith(config.ETC_FIREWALLD_SERVICES)) and \
             name.endswith(&quot;.xml&quot;):
            try:
                (what, obj) = self.config.update_service_from_path(name)
            except Exception as msg:
                log.error(&quot;Failed to load service file '%s': %s&quot; % (name, msg))
                return
            if what == &quot;new&quot;:
                self._addService(obj)
            elif what == &quot;remove&quot;:
                self.removeService(obj)
            elif what == &quot;update&quot;:
                self._updateService(obj)

        elif name.startswith(config.FIREWALLD_ZONES) or \
             name.startswith(config.ETC_FIREWALLD_ZONES):
            if name.endswith(&quot;.xml&quot;):
                try:
                    (what, obj) = self.config.update_zone_from_path(name)
                except Exception as msg:
                    log.error(&quot;Failed to load zone file '%s': %s&quot; % (name, msg))
                    return
                if what == &quot;new&quot;:
                    self._addZone(obj)
                elif what == &quot;remove&quot;:
                    self.removeZone(obj)
                elif what == &quot;update&quot;:
                    self._updateZone(obj)
            elif name.startswith(config.ETC_FIREWALLD_ZONES):
                # possible combined zone base directory
                _name = name.replace(config.ETC_FIREWALLD_ZONES, &quot;&quot;).strip(&quot;/&quot;)
                if len(_name) &lt; 1 or &quot;/&quot; in _name:
                    # if there is a / in x, then it is a sub sub directory
                    # ignore it
                    return
                if os.path.isdir(name):
                    if not self.watcher.has_watch(name):
                        self.watcher.add_watch_dir(name)
                elif self.watcher.has_watch(name):
                    self.watcher.remove_watch(name)

        elif (name.startswith(config.FIREWALLD_IPSETS) or \
              name.startswith(config.ETC_FIREWALLD_IPSETS)) and \
             name.endswith(&quot;.xml&quot;):
            try:
                (what, obj) = self.config.update_ipset_from_path(name)
            except Exception as msg:
                log.error(&quot;Failed to load ipset file '%s': %s&quot; % (name,
                                                                  msg))

                return
            if what == &quot;new&quot;:
                self._addIPSet(obj)
            elif what == &quot;remove&quot;:
                self.removeIPSet(obj)
            elif what == &quot;update&quot;:
                self._updateIPSet(obj)

        elif (name.startswith(config.FIREWALLD_HELPERS) or \
              name.startswith(config.ETC_FIREWALLD_HELPERS)) and \
             name.endswith(&quot;.xml&quot;):
            try:
                (what, obj) = self.config.update_helper_from_path(name)
            except Exception as msg:
                log.error(&quot;Failed to load helper file '%s': %s&quot; % (name,
                                                                  msg))

                return
            if what == &quot;new&quot;:
                self._addHelper(obj)
            elif what == &quot;remove&quot;:
                self.removeHelper(obj)
            elif what == &quot;update&quot;:
                self._updateHelper(obj)

        elif name == config.LOCKDOWN_WHITELIST:
            try:
                self.config.update_lockdown_whitelist()
            except Exception as msg:
                log.error(&quot;Failed to load lockdown whitelist file '%s': %s&quot; % \
                          (name, msg))
                return
            self.LockdownWhitelistUpdated()

        elif name == config.FIREWALLD_DIRECT:
            try:
                self.config.update_direct()
            except Exception as msg:
                log.error(&quot;Failed to load direct rules file '%s': %s&quot; % (name,
                                                                         msg))
                return
            self.Updated()

        elif (name.startswith(config.FIREWALLD_POLICIES) or \
              name.startswith(config.ETC_FIREWALLD_POLICIES)) and \
             name.endswith(&quot;.xml&quot;):
            try:
                (what, obj) = self.config.update_policy_object_from_path(name)
            except Exception as msg:
                log.error(&quot;Failed to load policy file '%s': %s&quot; % (name, msg))
                return
            if what == &quot;new&quot;:
                self._addPolicy(obj)
            elif what == &quot;remove&quot;:
                self.removePolicy(obj)
            elif what == &quot;update&quot;:
                self._updatePolicy(obj)

    @handle_exceptions
    def _addIcmpType(self, obj):
        # TODO: check for idx overflow
        config_icmptype = FirewallDConfigIcmpType(
            self, self.config, obj, self.icmptype_idx, self.busname,
            &quot;%s/%d&quot; % (config.dbus.DBUS_PATH_CONFIG_ICMPTYPE,
                       self.icmptype_idx))
        self.icmptypes.append(config_icmptype)
        self.icmptype_idx += 1
        self.IcmpTypeAdded(obj.name)
        return config_icmptype

    @handle_exceptions
    def _updateIcmpType(self, obj):
        for icmptype in self.icmptypes:
            if icmptype.obj.name == obj.name and \
                    icmptype.obj.path == obj.path and \
                    icmptype.obj.filename == obj.filename:
                icmptype.obj = obj
                icmptype.Updated(obj.name)

    @handle_exceptions
    def removeIcmpType(self, obj):
        index = 7 # see IMPORT_EXPORT_STRUCTURE in class Zone(IO_Object)
        for zone in self.zones:
            settings = zone.getSettings()
            # if this IcmpType is used in a zone remove it from that zone first
            if obj.name in settings[index]:
                settings[index].remove(obj.name)
                zone.obj = self.config.set_zone_config(zone.obj, settings)
                zone.Updated(zone.obj.name)

        for policy in self.policy_objects:
            settings = policy.getSettings()
            # if this IcmpType is used in a policy remove it from that policy first
            if &quot;icmp_blocks&quot; in settings and obj.name in settings[&quot;icmp_blocks&quot;]:
                settings[&quot;icmp_blocks&quot;].remove(obj.name)
                policy.obj = self.config.set_policy_object_config_dict(policy.obj, settings)
                policy.Updated(policy.obj.name)

        for icmptype in self.icmptypes:
            if icmptype.obj == obj:
                icmptype.Removed(obj.name)
                icmptype.unregister()
                self.icmptypes.remove(icmptype)
                del icmptype

    @handle_exceptions
    def _addService(self, obj):
        # TODO: check for idx overflow
        config_service = FirewallDConfigService(
            self, self.config, obj, self.service_idx, self.busname,
            &quot;%s/%d&quot; % (config.dbus.DBUS_PATH_CONFIG_SERVICE, self.service_idx))
        self.services.append(config_service)
        self.service_idx += 1
        self.ServiceAdded(obj.name)
        return config_service

    @handle_exceptions
    def _updateService(self, obj):
        for service in self.services:
            if service.obj.name == obj.name and \
                    service.obj.path == obj.path and \
                    service.obj.filename == obj.filename:
                service.obj = obj
                service.Updated(obj.name)

    @handle_exceptions
    def removeService(self, obj):
        index = 5 # see IMPORT_EXPORT_STRUCTURE in class Zone(IO_Object)
        for zone in self.zones:
            settings = zone.getSettings()
            # if this Service is used in a zone remove it from that zone first
            if obj.name in settings[index]:
                settings[index].remove(obj.name)
                zone.obj = self.config.set_zone_config(zone.obj, settings)
                zone.Updated(zone.obj.name)

        for policy in self.policy_objects:
            settings = policy.getSettings()
            # if this Service is used in a policy remove it from that policy first
            if &quot;services&quot; in settings and obj.name in settings[&quot;services&quot;]:
                settings[&quot;services&quot;].remove(obj.name)
                policy.obj = self.config.set_policy_object_config_dict(policy.obj, settings)
                policy.Updated(policy.obj.name)

        for service in self.services:
            if service.obj == obj:
                service.Removed(obj.name)
                service.unregister()
                self.services.remove(service)
                del service

    @handle_exceptions
    def _addZone(self, obj):
        # TODO: check for idx overflow
        config_zone = FirewallDConfigZone(
            self, self.config, obj, self.zone_idx, self.busname,
            &quot;%s/%d&quot; % (config.dbus.DBUS_PATH_CONFIG_ZONE, self.zone_idx))
        self.zones.append(config_zone)
        self.zone_idx += 1
        self.ZoneAdded(obj.name)
        return config_zone

    @handle_exceptions
    def _updateZone(self, obj):
        for zone in self.zones:
            if zone.obj.name == obj.name and zone.obj.path == obj.path and \
                    zone.obj.filename == obj.filename:
                zone.obj = obj
                zone.Updated(obj.name)

    @handle_exceptions
    def removeZone(self, obj):
        for zone in self.zones:
            if zone.obj == obj:
                zone.Removed(obj.name)
                zone.unregister()
                self.zones.remove(zone)
                del zone

    @handle_exceptions
    def _addPolicy(self, obj):
        # TODO: check for idx overflow
        config_policy = FirewallDConfigPolicy(
            self, self.config, obj, self.policy_object_idx, self.busname,
            &quot;%s/%d&quot; % (config.dbus.DBUS_PATH_CONFIG_POLICY, self.policy_object_idx))
        self.policy_objects.append(config_policy)
        self.policy_object_idx += 1
        self.PolicyAdded(obj.name)
        return config_policy

    @handle_exceptions
    def _updatePolicy(self, obj):
        for policy in self.policy_objects:
            if policy.obj.name == obj.name and policy.obj.path == obj.path and \
                    policy.obj.filename == obj.filename:
                policy.obj = obj
                policy.Updated(obj.name)

    @handle_exceptions
    def removePolicy(self, obj):
        for policy in self.policy_objects:
            if policy.obj == obj:
                policy.Removed(obj.name)
                policy.unregister()
                self.policy_objects.remove(policy)
                del policy

    @handle_exceptions
    def _addIPSet(self, obj):
        # TODO: check for idx overflow
        config_ipset = FirewallDConfigIPSet(
            self, self.config, obj, self.ipset_idx, self.busname,
            &quot;%s/%d&quot; % (config.dbus.DBUS_PATH_CONFIG_IPSET, self.ipset_idx))
        self.ipsets.append(config_ipset)
        self.ipset_idx += 1
        self.IPSetAdded(obj.name)
        return config_ipset

    @handle_exceptions
    def _updateIPSet(self, obj):
        for ipset in self.ipsets:
            if ipset.obj.name == obj.name and ipset.obj.path == obj.path and \
                    ipset.obj.filename == obj.filename:
                ipset.obj = obj
                ipset.Updated(obj.name)

    @handle_exceptions
    def removeIPSet(self, obj):
        for ipset in self.ipsets:
            if ipset.obj == obj:
                ipset.Removed(obj.name)
                ipset.unregister()
                self.ipsets.remove(ipset)
                del ipset

    # access check

    @handle_exceptions
    def _addHelper(self, obj):
        # TODO: check for idx overflow
        config_helper = FirewallDConfigHelper(
            self, self.config, obj, self.helper_idx, self.busname,
            &quot;%s/%d&quot; % (config.dbus.DBUS_PATH_CONFIG_HELPER, self.helper_idx))
        self.helpers.append(config_helper)
        self.helper_idx += 1
        self.HelperAdded(obj.name)
        return config_helper

    @handle_exceptions
    def _updateHelper(self, obj):
        for helper in self.helpers:
            if helper.obj.name == obj.name and helper.obj.path == obj.path and \
                    helper.obj.filename == obj.filename:
                helper.obj = obj
                helper.Updated(obj.name)

    @handle_exceptions
    def removeHelper(self, obj):
        for helper in self.helpers:
            if helper.obj == obj:
                helper.Removed(obj.name)
                helper.unregister()
                self.helpers.remove(helper)
                del helper

    # access check

    @dbus_handle_exceptions
    def accessCheck(self, sender):
        if self.config.lockdown_enabled():
            if sender is None:
                log.error(&quot;Lockdown not possible, sender not set.&quot;)
                return
            bus = dbus.SystemBus()
            context = context_of_sender(bus, sender)
            if self.config.access_check(&quot;context&quot;, context):
                return
            uid = uid_of_sender(bus, sender)
            if self.config.access_check(&quot;uid&quot;, uid):
                return
            user = user_of_uid(uid)
            if self.config.access_check(&quot;user&quot;, user):
                return
            command = command_of_sender(bus, sender)
            if self.config.access_check(&quot;command&quot;, command):
                return
            raise FirewallError(errors.ACCESS_DENIED, &quot;lockdown is enabled&quot;)

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    # P R O P E R T I E S

    @dbus_handle_exceptions
    def _get_property(self, prop):
        if prop not in [ &quot;DefaultZone&quot;, &quot;MinimalMark&quot;, &quot;CleanupOnExit&quot;,
                         &quot;CleanupModulesOnExit&quot;, &quot;Lockdown&quot;, &quot;IPv6_rpfilter&quot;,
                         &quot;IndividualCalls&quot;, &quot;LogDenied&quot;, &quot;AutomaticHelpers&quot;,
                         &quot;FirewallBackend&quot;, &quot;FlushAllOnReload&quot;, &quot;RFC3964_IPv4&quot;,
                         &quot;AllowZoneDrifting&quot; ]:
            raise dbus.exceptions.DBusException(
                &quot;org.freedesktop.DBus.Error.InvalidArgs: &quot;
                &quot;Property '%s' does not exist&quot; % prop)

        value = self.config.get_firewalld_conf().get(prop)

        if prop == &quot;DefaultZone&quot;:
            if value is None:
                value = config.FALLBACK_ZONE
            return dbus.String(value)
        elif prop == &quot;MinimalMark&quot;:
            if value is None:
                value = config.FALLBACK_MINIMAL_MARK
            else:
                value = int(value)
            return dbus.Int32(value)
        elif prop == &quot;CleanupOnExit&quot;:
            if value is None:
                value = &quot;yes&quot; if config.FALLBACK_CLEANUP_ON_EXIT else &quot;no&quot;
            return dbus.String(value)
        elif prop == &quot;CleanupModulesOnExit&quot;:
            if value is None:
                value = &quot;yes&quot; if config.FALLBACK_CLEANUP_MODULES_ON_EXIT else &quot;no&quot;
            return dbus.String(value)
        elif prop == &quot;Lockdown&quot;:
            if value is None:
                value = &quot;yes&quot; if config.FALLBACK_LOCKDOWN else &quot;no&quot;
            return dbus.String(value)
        elif prop == &quot;IPv6_rpfilter&quot;:
            if value is None:
                value = &quot;yes&quot; if config.FALLBACK_IPV6_RPFILTER else &quot;no&quot;
            return dbus.String(value)
        elif prop == &quot;IndividualCalls&quot;:
            if value is None:
                value = &quot;yes&quot; if config.FALLBACK_INDIVIDUAL_CALLS else &quot;no&quot;
            return dbus.String(value)
        elif prop == &quot;LogDenied&quot;:
            if value is None:
                value = config.FALLBACK_LOG_DENIED
            return dbus.String(value)
        elif prop == &quot;AutomaticHelpers&quot;:
            if value is None:
                value = config.FALLBACK_AUTOMATIC_HELPERS
            return dbus.String(value)
        elif prop == &quot;FirewallBackend&quot;:
            if value is None:
                value = config.FALLBACK_FIREWALL_BACKEND
            return dbus.String(value)
        elif prop == &quot;FlushAllOnReload&quot;:
            if value is None:
                value = &quot;yes&quot; if config.FALLBACK_FLUSH_ALL_ON_RELOAD else &quot;no&quot;
            return dbus.String(value)
        elif prop == &quot;RFC3964_IPv4&quot;:
            if value is None:
                value = &quot;yes&quot; if config.FALLBACK_RFC3964_IPV4 else &quot;no&quot;
            return dbus.String(value)
        elif prop == &quot;AllowZoneDrifting&quot;:
            if value is None:
                value = &quot;yes&quot; if config.FALLBACK_ALLOW_ZONE_DRIFTING else &quot;no&quot;
            return dbus.String(value)

    @dbus_handle_exceptions
    def _get_dbus_property(self, prop):
        if prop == &quot;DefaultZone&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;MinimalMark&quot;:
            return dbus.Int32(self._get_property(prop))
        elif prop == &quot;CleanupOnExit&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;CleanupModulesOnExit&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;Lockdown&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;IPv6_rpfilter&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;IndividualCalls&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;LogDenied&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;AutomaticHelpers&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;FirewallBackend&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;FlushAllOnReload&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;RFC3964_IPv4&quot;:
            return dbus.String(self._get_property(prop))
        elif prop == &quot;AllowZoneDrifting&quot;:
            return dbus.String(self._get_property(prop))
        else:
            raise dbus.exceptions.DBusException(
                &quot;org.freedesktop.DBus.Error.InvalidArgs: &quot;
                &quot;Property '%s' does not exist&quot; % prop)

    @dbus_service_method(dbus.PROPERTIES_IFACE, in_signature='ss',
                         out_signature='v')
    @dbus_handle_exceptions
    def Get(self, interface_name, property_name, sender=None): # pylint: disable=W0613
        # get a property
        interface_name = dbus_to_python(interface_name, str)
        property_name = dbus_to_python(property_name, str)
        log.debug1(&quot;config.Get('%s', '%s')&quot;, interface_name, property_name)

        if interface_name == config.dbus.DBUS_INTERFACE_CONFIG:
            return self._get_dbus_property(property_name)
        elif interface_name in [ config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                                 config.dbus.DBUS_INTERFACE_CONFIG_POLICIES ]:
            raise dbus.exceptions.DBusException(
                &quot;org.freedesktop.DBus.Error.InvalidArgs: &quot;
                &quot;Property '%s' does not exist&quot; % property_name)
        else:
            raise dbus.exceptions.DBusException(
                &quot;org.freedesktop.DBus.Error.UnknownInterface: &quot;
                &quot;Interface '%s' does not exist&quot; % interface_name)

        return self._get_dbus_property(property_name)

    @dbus_service_method(dbus.PROPERTIES_IFACE, in_signature='s',
                         out_signature='a{sv}')
    @dbus_handle_exceptions
    def GetAll(self, interface_name, sender=None): # pylint: disable=W0613
        interface_name = dbus_to_python(interface_name, str)
        log.debug1(&quot;config.GetAll('%s')&quot;, interface_name)

        ret = { }
        if interface_name == config.dbus.DBUS_INTERFACE_CONFIG:
            for x in [ &quot;DefaultZone&quot;, &quot;MinimalMark&quot;, &quot;CleanupOnExit&quot;,
                       &quot;CleanupModulesOnExit&quot;, &quot;Lockdown&quot;, &quot;IPv6_rpfilter&quot;,
                       &quot;IndividualCalls&quot;, &quot;LogDenied&quot;, &quot;AutomaticHelpers&quot;,
                       &quot;FirewallBackend&quot;, &quot;FlushAllOnReload&quot;, &quot;RFC3964_IPv4&quot;,
                       &quot;AllowZoneDrifting&quot; ]:
                ret[x] = self._get_property(x)
        elif interface_name in [ config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                                 config.dbus.DBUS_INTERFACE_CONFIG_POLICIES ]:
            pass
        else:
            raise dbus.exceptions.DBusException(
                &quot;org.freedesktop.DBus.Error.UnknownInterface: &quot;
                &quot;Interface '%s' does not exist&quot; % interface_name)

        return dbus.Dictionary(ret, signature=&quot;sv&quot;)

    @slip.dbus.polkit.require_auth(config.dbus.PK_ACTION_CONFIG)
    @dbus_service_method(dbus.PROPERTIES_IFACE, in_signature='ssv')
    @dbus_handle_exceptions
    def Set(self, interface_name, property_name, new_value, sender=None):
        interface_name = dbus_to_python(interface_name, str)
        property_name = dbus_to_python(property_name, str)
        new_value = dbus_to_python(new_value)
        log.debug1(&quot;config.Set('%s', '%s', '%s')&quot;, interface_name,
                   property_name, new_value)
        self.accessCheck(sender)

        if interface_name == config.dbus.DBUS_INTERFACE_CONFIG:
            if property_name in [ &quot;CleanupOnExit&quot;, &quot;Lockdown&quot;, &quot;CleanupModulesOnExit&quot;,
                                  &quot;IPv6_rpfilter&quot;, &quot;IndividualCalls&quot;,
                                  &quot;LogDenied&quot;,
                                  &quot;FirewallBackend&quot;, &quot;FlushAllOnReload&quot;,
                                  &quot;RFC3964_IPv4&quot;, &quot;AllowZoneDrifting&quot; ]:
                if property_name in [ &quot;CleanupOnExit&quot;, &quot;Lockdown&quot;, &quot;CleanupModulesOnExit&quot;,
                                      &quot;IPv6_rpfilter&quot;, &quot;IndividualCalls&quot; ]:
                    if new_value.lower() not in [ &quot;yes&quot;, &quot;no&quot;,
                                                  &quot;true&quot;, &quot;false&quot; ]:
                        raise FirewallError(errors.INVALID_VALUE,
                                            &quot;'%s' for %s&quot; % \
                                            (new_value, property_name))
                if property_name == &quot;LogDenied&quot;:
                    if new_value not in config.LOG_DENIED_VALUES:
                        raise FirewallError(errors.INVALID_VALUE,
                                            &quot;'%s' for %s&quot; % \
                                            (new_value, property_name))
                if property_name == &quot;FirewallBackend&quot;:
                    if new_value not in config.FIREWALL_BACKEND_VALUES:
                        raise FirewallError(errors.INVALID_VALUE,
                                            &quot;'%s' for %s&quot; % \
                                            (new_value, property_name))
                if property_name == &quot;FlushAllOnReload&quot;:
                    if new_value.lower() not in [&quot;yes&quot;, &quot;true&quot;, &quot;no&quot;, &quot;false&quot;]:
                        raise FirewallError(errors.INVALID_VALUE,
                                            &quot;'%s' for %s&quot; % \
                                            (new_value, property_name))
                if property_name == &quot;RFC3964_IPv4&quot;:
                    if new_value.lower() not in [&quot;yes&quot;, &quot;true&quot;, &quot;no&quot;, &quot;false&quot;]:
                        raise FirewallError(errors.INVALID_VALUE,
                                            &quot;'%s' for %s&quot; % \
                                            (new_value, property_name))
                if property_name == &quot;AllowZoneDrifting&quot;:
                    if new_value.lower() not in [&quot;yes&quot;, &quot;true&quot;, &quot;no&quot;, &quot;false&quot;]:
                        raise FirewallError(errors.INVALID_VALUE,
                                            &quot;'%s' for %s&quot; % \
                                            (new_value, property_name))

                self.config.get_firewalld_conf().set(property_name, new_value)
                self.config.get_firewalld_conf().write()
                self.PropertiesChanged(interface_name,
                                       { property_name: new_value }, [ ])
            elif property_name in [&quot;MinimalMark&quot;, &quot;AutomaticHelpers&quot;]:
                # deprecated fields. Ignore setting them.
                pass
            else:
                raise dbus.exceptions.DBusException(
                    &quot;org.freedesktop.DBus.Error.InvalidArgs: &quot;
                    &quot;Property '%s' does not exist&quot; % property_name)
        elif interface_name in [ config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                                 config.dbus.DBUS_INTERFACE_CONFIG_POLICIES ]:
            raise dbus.exceptions.DBusException(
                &quot;org.freedesktop.DBus.Error.InvalidArgs: &quot;
                &quot;Property '%s' does not exist&quot; % property_name)
        else:
            raise dbus.exceptions.DBusException(
                &quot;org.freedesktop.DBus.Error.UnknownInterface: &quot;
                &quot;Interface '%s' does not exist&quot; % interface_name)

    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature='sa{sv}as')
    def PropertiesChanged(self, interface_name, changed_properties,
                          invalidated_properties):
        interface_name = dbus_to_python(interface_name, str)
        changed_properties = dbus_to_python(changed_properties)
        invalidated_properties = dbus_to_python(invalidated_properties)
        log.debug1(&quot;config.PropertiesChanged('%s', '%s', '%s')&quot;,
                   interface_name, changed_properties, invalidated_properties)

    @slip.dbus.polkit.require_auth(config.dbus.PK_ACTION_INFO)
    @dbus_service_method(dbus.INTROSPECTABLE_IFACE, out_signature='s')
    @dbus_handle_exceptions
    def Introspect(self, sender=None): # pylint: disable=W0613
        log.debug2(&quot;config.Introspect()&quot;)

        data = super(FirewallDConfig, self).Introspect(self.path,
                                                       self.busname.get_bus())
        return dbus_introspection_add_properties(
            self, data, config.dbus.DBUS_INTERFACE_CONFIG)

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    # policies

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         out_signature=LockdownWhitelist.DBUS_SIGNATURE)
    @dbus_handle_exceptions
    def getLockdownWhitelist(self, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.policies.getLockdownWhitelist()&quot;)
        return self.config.get_policies().lockdown_whitelist.export_config()

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature=LockdownWhitelist.DBUS_SIGNATURE)
    @dbus_handle_exceptions
    def setLockdownWhitelist(self, settings, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.policies.setLockdownWhitelist(...)&quot;)
        settings = dbus_to_python(settings)
        self.config.get_policies().lockdown_whitelist.import_config(settings)
        self.config.get_policies().lockdown_whitelist.write()
        self.LockdownWhitelistUpdated()

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES)
    @dbus_handle_exceptions
    def LockdownWhitelistUpdated(self):
        log.debug1(&quot;config.policies.LockdownWhitelistUpdated()&quot;)

    # command

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s')
    @dbus_handle_exceptions
    def addLockdownWhitelistCommand(self, command, sender=None):
        command = dbus_to_python(command)
        log.debug1(&quot;config.policies.addLockdownWhitelistCommand('%s')&quot;, command)
        self.accessCheck(sender)
        settings = list(self.getLockdownWhitelist())
        if command in settings[0]:
            raise FirewallError(errors.ALREADY_ENABLED, command)
        settings[0].append(command)
        self.setLockdownWhitelist(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s')
    @dbus_handle_exceptions
    def removeLockdownWhitelistCommand(self, command, sender=None):
        command = dbus_to_python(command)
        log.debug1(&quot;config.policies.removeLockdownWhitelistCommand('%s')&quot;,
                   command)
        self.accessCheck(sender)
        settings = list(self.getLockdownWhitelist())
        if command not in settings[0]:
            raise FirewallError(errors.NOT_ENABLED, command)
        settings[0].remove(command)
        self.setLockdownWhitelist(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s', out_signature='b')
    @dbus_handle_exceptions
    def queryLockdownWhitelistCommand(self, command, sender=None): # pylint: disable=W0613
        command = dbus_to_python(command)
        log.debug1(&quot;config.policies.queryLockdownWhitelistCommand('%s')&quot;,
                   command)
        return command in self.getLockdownWhitelist()[0]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         out_signature='as')
    @dbus_handle_exceptions
    def getLockdownWhitelistCommands(self, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.policies.getLockdownWhitelistCommands()&quot;)
        return self.getLockdownWhitelist()[0]

    # context

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s')
    @dbus_handle_exceptions
    def addLockdownWhitelistContext(self, context, sender=None):
        context = dbus_to_python(context)
        log.debug1(&quot;config.policies.addLockdownWhitelistContext('%s')&quot;, context)
        self.accessCheck(sender)
        settings = list(self.getLockdownWhitelist())
        if context in settings[1]:
            raise FirewallError(errors.ALREADY_ENABLED, context)
        settings[1].append(context)
        self.setLockdownWhitelist(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s')
    @dbus_handle_exceptions
    def removeLockdownWhitelistContext(self, context, sender=None):
        context = dbus_to_python(context)
        log.debug1(&quot;config.policies.removeLockdownWhitelistContext('%s')&quot;,
                   context)
        self.accessCheck(sender)
        settings = list(self.getLockdownWhitelist())
        if context not in settings[1]:
            raise FirewallError(errors.NOT_ENABLED, context)
        settings[1].remove(context)
        self.setLockdownWhitelist(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s', out_signature='b')
    @dbus_handle_exceptions
    def queryLockdownWhitelistContext(self, context, sender=None): # pylint: disable=W0613
        context = dbus_to_python(context)
        log.debug1(&quot;config.policies.queryLockdownWhitelistContext('%s')&quot;,
                   context)
        return context in self.getLockdownWhitelist()[1]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         out_signature='as')
    @dbus_handle_exceptions
    def getLockdownWhitelistContexts(self, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.policies.getLockdownWhitelistContexts()&quot;)
        return self.getLockdownWhitelist()[1]

    # user

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s')
    @dbus_handle_exceptions
    def addLockdownWhitelistUser(self, user, sender=None):
        user = dbus_to_python(user)
        log.debug1(&quot;config.policies.addLockdownWhitelistUser('%s')&quot;, user)
        self.accessCheck(sender)
        settings = list(self.getLockdownWhitelist())
        if user in settings[2]:
            raise FirewallError(errors.ALREADY_ENABLED, user)
        settings[2].append(user)
        self.setLockdownWhitelist(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s')
    @dbus_handle_exceptions
    def removeLockdownWhitelistUser(self, user, sender=None):
        user = dbus_to_python(user)
        log.debug1(&quot;config.policies.removeLockdownWhitelistUser('%s')&quot;, user)
        self.accessCheck(sender)
        settings = list(self.getLockdownWhitelist())
        if user not in settings[2]:
            raise FirewallError(errors.NOT_ENABLED, user)
        settings[2].remove(user)
        self.setLockdownWhitelist(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='s', out_signature='b')
    @dbus_handle_exceptions
    def queryLockdownWhitelistUser(self, user, sender=None): # pylint: disable=W0613
        user = dbus_to_python(user)
        log.debug1(&quot;config.policies.queryLockdownWhitelistUser('%s')&quot;, user)
        return user in self.getLockdownWhitelist()[2]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         out_signature='as')
    @dbus_handle_exceptions
    def getLockdownWhitelistUsers(self, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.policies.getLockdownWhitelistUsers()&quot;)
        return self.getLockdownWhitelist()[2]

    # uid

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='i')
    @dbus_handle_exceptions
    def addLockdownWhitelistUid(self, uid, sender=None):
        uid = dbus_to_python(uid)
        log.debug1(&quot;config.policies.addLockdownWhitelistUid(%d)&quot;, uid)
        self.accessCheck(sender)
        settings = list(self.getLockdownWhitelist())
        if uid in settings[3]:
            raise FirewallError(errors.ALREADY_ENABLED, uid)
        settings[3].append(uid)
        self.setLockdownWhitelist(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='i')
    @dbus_handle_exceptions
    def removeLockdownWhitelistUid(self, uid, sender=None):
        uid = dbus_to_python(uid)
        log.debug1(&quot;config.policies.removeLockdownWhitelistUid(%d)&quot;, uid)
        self.accessCheck(sender)
        settings = list(self.getLockdownWhitelist())
        if uid not in settings[3]:
            raise FirewallError(errors.NOT_ENABLED, uid)
        settings[3].remove(uid)
        self.setLockdownWhitelist(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         in_signature='i', out_signature='b')
    @dbus_handle_exceptions
    def queryLockdownWhitelistUid(self, uid, sender=None): # pylint: disable=W0613
        uid = dbus_to_python(uid)
        log.debug1(&quot;config.policies.queryLockdownWhitelistUid(%d)&quot;, uid)
        return uid in self.getLockdownWhitelist()[3]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_POLICIES,
                         out_signature='ai')
    @dbus_handle_exceptions
    def getLockdownWhitelistUids(self, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.policies.getLockdownWhitelistUids()&quot;)
        return self.getLockdownWhitelist()[3]

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    # I P S E T S

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='ao')
    @dbus_handle_exceptions
    def listIPSets(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;list ipsets objects paths
        &quot;&quot;&quot;
        log.debug1(&quot;config.listIPSets()&quot;)
        return self.ipsets

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='as')
    @dbus_handle_exceptions
    def getIPSetNames(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;get ipset names
        &quot;&quot;&quot;
        log.debug1(&quot;config.getIPSetNames()&quot;)
        ipsets = [ ]
        for obj in self.ipsets:
            ipsets.append(obj.obj.name)
        return sorted(ipsets)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, in_signature='s',
                         out_signature='o')
    @dbus_handle_exceptions
    def getIPSetByName(self, ipset, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;object path of ipset with given name
        &quot;&quot;&quot;
        ipset = dbus_to_python(ipset, str)
        log.debug1(&quot;config.getIPSetByName('%s')&quot;, ipset)
        for obj in self.ipsets:
            if obj.obj.name == ipset:
                return obj
        raise FirewallError(errors.INVALID_IPSET, ipset)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG,
                         in_signature='s'+IPSet.DBUS_SIGNATURE,
                         out_signature='o')
    @dbus_handle_exceptions
    def addIPSet(self, ipset, settings, sender=None):
        &quot;&quot;&quot;add ipset with given name and settings
        &quot;&quot;&quot;
        ipset = dbus_to_python(ipset, str)
        settings = dbus_to_python(settings)
        log.debug1(&quot;config.addIPSet('%s')&quot;, ipset)
        self.accessCheck(sender)
        obj = self.config.new_ipset(ipset, settings)
        config_ipset = self._addIPSet(obj)
        return config_ipset

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG, signature='s')
    @dbus_handle_exceptions
    def IPSetAdded(self, ipset):
        ipset = dbus_to_python(ipset, str)
        log.debug1(&quot;config.IPSetAdded('%s')&quot; % (ipset))

    # I C M P T Y P E S

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='ao')
    @dbus_handle_exceptions
    def listIcmpTypes(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;list icmptypes objects paths
        &quot;&quot;&quot;
        log.debug1(&quot;config.listIcmpTypes()&quot;)
        return self.icmptypes

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='as')
    @dbus_handle_exceptions
    def getIcmpTypeNames(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;get icmptype names
        &quot;&quot;&quot;
        log.debug1(&quot;config.getIcmpTypeNames()&quot;)
        icmptypes = [ ]
        for obj in self.icmptypes:
            icmptypes.append(obj.obj.name)
        return sorted(icmptypes)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, in_signature='s',
                         out_signature='o')
    @dbus_handle_exceptions
    def getIcmpTypeByName(self, icmptype, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;object path of icmptype with given name
        &quot;&quot;&quot;
        icmptype = dbus_to_python(icmptype, str)
        log.debug1(&quot;config.getIcmpTypeByName('%s')&quot;, icmptype)
        for obj in self.icmptypes:
            if obj.obj.name == icmptype:
                return obj
        raise FirewallError(errors.INVALID_ICMPTYPE, icmptype)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG,
                         in_signature='s'+IcmpType.DBUS_SIGNATURE,
                         out_signature='o')
    @dbus_handle_exceptions
    def addIcmpType(self, icmptype, settings, sender=None):
        &quot;&quot;&quot;add icmptype with given name and settings
        &quot;&quot;&quot;
        icmptype = dbus_to_python(icmptype, str)
        settings = dbus_to_python(settings)
        log.debug1(&quot;config.addIcmpType('%s')&quot;, icmptype)
        self.accessCheck(sender)
        obj = self.config.new_icmptype(icmptype, settings)
        config_icmptype = self._addIcmpType(obj)
        return config_icmptype

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG, signature='s')
    @dbus_handle_exceptions
    def IcmpTypeAdded(self, icmptype):
        log.debug1(&quot;config.IcmpTypeAdded('%s')&quot; % (icmptype))

    # S E R V I C E S

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='ao')
    @dbus_handle_exceptions
    def listServices(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;list services objects paths
        &quot;&quot;&quot;
        log.debug1(&quot;config.listServices()&quot;)
        return self.services

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='as')
    @dbus_handle_exceptions
    def getServiceNames(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;get service names
        &quot;&quot;&quot;
        log.debug1(&quot;config.getServiceNames()&quot;)
        services = [ ]
        for obj in self.services:
            services.append(obj.obj.name)
        return sorted(services)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, in_signature='s',
                         out_signature='o')
    @dbus_handle_exceptions
    def getServiceByName(self, service, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;object path of service with given name
        &quot;&quot;&quot;
        service = dbus_to_python(service, str)
        log.debug1(&quot;config.getServiceByName('%s')&quot;, service)
        for obj in self.services:
            if obj.obj.name == service:
                return obj
        raise FirewallError(errors.INVALID_SERVICE, service)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG,
                         in_signature='s(sssa(ss)asa{ss}asa(ss))',
                         out_signature='o')
    @dbus_handle_exceptions
    def addService(self, service, settings, sender=None):
        &quot;&quot;&quot;add service with given name and settings
        &quot;&quot;&quot;
        service = dbus_to_python(service, str)
        settings = dbus_to_python(settings)
        log.debug1(&quot;config.addService('%s')&quot;, service)
        self.accessCheck(sender)
        obj = self.config.new_service(service, settings)
        config_service = self._addService(obj)
        return config_service

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG,
                         in_signature='sa{sv}',
                         out_signature='o')
    @dbus_handle_exceptions
    def addService2(self, service, settings, sender=None):
        &quot;&quot;&quot;add service with given name and settings
        &quot;&quot;&quot;
        service = dbus_to_python(service, str)
        settings = dbus_to_python(settings)
        log.debug1(&quot;config.addService2('%s')&quot;, service)
        self.accessCheck(sender)
        obj = self.config.new_service_dict(service, settings)
        config_service = self._addService(obj)
        return config_service

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG, signature='s')
    @dbus_handle_exceptions
    def ServiceAdded(self, service):
        log.debug1(&quot;config.ServiceAdded('%s')&quot; % (service))

    # Z O N E S

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='ao')
    @dbus_handle_exceptions
    def listZones(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;list zones objects paths
        &quot;&quot;&quot;
        log.debug1(&quot;config.listZones()&quot;)
        return self.zones

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='as')
    @dbus_handle_exceptions
    def getZoneNames(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;get zone names
        &quot;&quot;&quot;
        log.debug1(&quot;config.getZoneNames()&quot;)
        zones = [ ]
        for obj in self.zones:
            zones.append(obj.obj.name)
        return sorted(zones)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, in_signature='s',
                         out_signature='o')
    @dbus_handle_exceptions
    def getZoneByName(self, zone, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;object path of zone with given name
        &quot;&quot;&quot;
        zone = dbus_to_python(zone, str)
        log.debug1(&quot;config.getZoneByName('%s')&quot;, zone)
        for obj in self.zones:
            if obj.obj.name == zone:
                return obj
        raise FirewallError(errors.INVALID_ZONE, zone)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, in_signature='s',
                         out_signature='s')
    @dbus_handle_exceptions
    def getZoneOfInterface(self, iface, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;name of zone the given interface belongs to
        &quot;&quot;&quot;
        iface = dbus_to_python(iface, str)
        log.debug1(&quot;config.getZoneOfInterface('%s')&quot;, iface)
        ret = []
        for obj in self.zones:
            if iface in obj.obj.interfaces:
                ret.append(obj.obj.name)
        if len(ret) &gt; 1:
            # Even it shouldn't happen, it's actually possible that
            # the same interface is in several zone XML files
            return &quot; &quot;.join(ret) + \
                &quot;  (ERROR: interface '%s' is in %s zone XML files, can be only in one)&quot; % \
                (iface, len(ret))
        return ret[0] if ret else &quot;&quot;

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, in_signature='s',
                         out_signature='s')
    @dbus_handle_exceptions
    def getZoneOfSource(self, source, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;name of zone the given source belongs to
        &quot;&quot;&quot;
        source = dbus_to_python(source, str)
        log.debug1(&quot;config.getZoneOfSource('%s')&quot;, source)
        ret = []
        for obj in self.zones:
            if source in obj.obj.sources:
                ret.append(obj.obj.name)
        if len(ret) &gt; 1:
            # Even it shouldn't happen, it's actually possible that
            # the same source is in several zone XML files
            return &quot; &quot;.join(ret) + \
                &quot;  (ERROR: source '%s' is in %s zone XML files, can be only in one)&quot; % \
                (source, len(ret))
        return ret[0] if ret else &quot;&quot;

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG,
                         in_signature=&quot;s(sssbsasa(ss)asba(ssss)asasasasa(ss)b)&quot;,
                         out_signature='o')
    @dbus_handle_exceptions
    def addZone(self, zone, settings, sender=None):
        &quot;&quot;&quot;add zone with given name and settings
        &quot;&quot;&quot;
        zone = dbus_to_python(zone, str)
        settings = dbus_to_python(settings)
        log.debug1(&quot;config.addZone('%s')&quot;, zone)
        self.accessCheck(sender)
        if settings[4] == &quot;default&quot;:
            # convert to list, fix target, convert back to tuple
            _settings = list(settings)
            _settings[4] = DEFAULT_ZONE_TARGET
            settings = tuple(_settings)
        obj = self.config.new_zone(zone, settings)
        config_zone = self._addZone(obj)
        return config_zone

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG,
                         in_signature=&quot;sa{sv}&quot;,
                         out_signature='o')
    @dbus_handle_exceptions
    def addZone2(self, zone, settings, sender=None):
        &quot;&quot;&quot;add zone with given name and settings
        &quot;&quot;&quot;
        zone = dbus_to_python(zone, str)
        settings = dbus_to_python(settings)
        log.debug1(&quot;config.addZone('%s')&quot;, zone)
        self.accessCheck(sender)
        if &quot;target&quot; in settings and settings[&quot;target&quot;] == &quot;default&quot;:
            settings[&quot;target&quot;] = DEFAULT_ZONE_TARGET
        obj = self.config.new_zone_dict(zone, settings)
        config_zone = self._addZone(obj)
        return config_zone

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG, signature='s')
    @dbus_handle_exceptions
    def ZoneAdded(self, zone):
        log.debug1(&quot;config.ZoneAdded('%s')&quot; % (zone))

    # policies

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='ao')
    @dbus_handle_exceptions
    def listPolicies(self, sender=None):
        &quot;&quot;&quot;list policies objects paths
        &quot;&quot;&quot;
        log.debug1(&quot;config.listPolicies()&quot;)
        return self.policy_objects

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='as')
    @dbus_handle_exceptions
    def getPolicyNames(self, sender=None):
        &quot;&quot;&quot;get policy names
        &quot;&quot;&quot;
        log.debug1(&quot;config.getPolicyNames()&quot;)
        policies = [ ]
        for obj in self.policy_objects:
            policies.append(obj.obj.name)
        return sorted(policies)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, in_signature='s',
                         out_signature='o')
    @dbus_handle_exceptions
    def getPolicyByName(self, policy, sender=None):
        &quot;&quot;&quot;object path of policy with given name
        &quot;&quot;&quot;
        policy = dbus_to_python(policy, str)
        log.debug1(&quot;config.getPolicyByName('%s')&quot;, policy)
        for obj in self.policy_objects:
            if obj.obj.name == policy:
                return obj
        raise FirewallError(errors.INVALID_POLICY, policy)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG,
                         in_signature=&quot;sa{sv}&quot;,
                         out_signature='o')
    @dbus_handle_exceptions
    def addPolicy(self, policy, settings, sender=None):
        &quot;&quot;&quot;add policy with given name and settings
        &quot;&quot;&quot;
        policy = dbus_to_python(policy, str)
        settings = dbus_to_python(settings)
        log.debug1(&quot;config.addPolicy('%s')&quot;, policy)
        self.accessCheck(sender)
        obj = self.config.new_policy_object_dict(policy, settings)
        config_policy = self._addPolicy(obj)
        return config_policy

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG, signature='s')
    @dbus_handle_exceptions
    def PolicyAdded(self, policy):
        log.debug1(&quot;config.PolicyAdded('%s')&quot; % (policy))

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    # H E L P E R S

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='ao')
    @dbus_handle_exceptions
    def listHelpers(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;list helpers objects paths
        &quot;&quot;&quot;
        log.debug1(&quot;config.listHelpers()&quot;)
        return self.helpers

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, out_signature='as')
    @dbus_handle_exceptions
    def getHelperNames(self, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;get helper names
        &quot;&quot;&quot;
        log.debug1(&quot;config.getHelperNames()&quot;)
        helpers = [ ]
        for obj in self.helpers:
            helpers.append(obj.obj.name)
        return sorted(helpers)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG, in_signature='s',
                         out_signature='o')
    @dbus_handle_exceptions
    def getHelperByName(self, helper, sender=None): # pylint: disable=W0613
        &quot;&quot;&quot;object path of helper with given name
        &quot;&quot;&quot;
        helper = dbus_to_python(helper, str)
        log.debug1(&quot;config.getHelperByName('%s')&quot;, helper)
        for obj in self.helpers:
            if obj.obj.name == helper:
                return obj
        raise FirewallError(errors.INVALID_HELPER, helper)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG,
                         in_signature='s'+Helper.DBUS_SIGNATURE,
                         out_signature='o')
    @dbus_handle_exceptions
    def addHelper(self, helper, settings, sender=None):
        &quot;&quot;&quot;add helper with given name and settings
        &quot;&quot;&quot;
        helper = dbus_to_python(helper, str)
        settings = dbus_to_python(settings)
        log.debug1(&quot;config.addHelper('%s')&quot;, helper)
        self.accessCheck(sender)
        obj = self.config.new_helper(helper, settings)
        config_helper = self._addHelper(obj)
        return config_helper

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG, signature='s')
    @dbus_handle_exceptions
    def HelperAdded(self, helper):
        helper = dbus_to_python(helper, str)
        log.debug1(&quot;config.HelperAdded('%s')&quot; % (helper))

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    # DIRECT

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         out_signature=Direct.DBUS_SIGNATURE)
    @dbus_handle_exceptions
    def getSettings(self, sender=None): # pylint: disable=W0613
        # returns list ipv, table, list of chains
        log.debug1(&quot;config.direct.getSettings()&quot;)
        return self.config.get_direct().export_config()

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature=Direct.DBUS_SIGNATURE)
    @dbus_handle_exceptions
    def update(self, settings, sender=None): # pylint: disable=W0613
        # returns list ipv, table, list of chains
        log.debug1(&quot;config.direct.update()&quot;)
        settings = dbus_to_python(settings)
        self.config.get_direct().import_config(settings)
        self.config.get_direct().write()
        self.Updated()

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT)
    @dbus_handle_exceptions
    def Updated(self):
        log.debug1(&quot;config.direct.Updated()&quot;)

    # chain

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sss')
    @dbus_handle_exceptions
    def addChain(self, ipv, table, chain, sender=None):
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        chain = dbus_to_python(chain)
        log.debug1(&quot;config.direct.addChain('%s', '%s', '%s')&quot; % \
                   (ipv, table, chain))
        self.accessCheck(sender)
        idx = tuple((ipv, table, chain))
        settings = list(self.getSettings())
        if idx in settings[0]:
            raise FirewallError(errors.ALREADY_ENABLED,
                                &quot;chain '%s' already is in '%s:%s'&quot; % \
                                (chain, ipv, table))
        settings[0].append(idx)
        self.update(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sss')
    @dbus_handle_exceptions
    def removeChain(self, ipv, table, chain, sender=None):
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        chain = dbus_to_python(chain)
        log.debug1(&quot;config.direct.removeChain('%s', '%s', '%s')&quot; % \
                   (ipv, table, chain))
        self.accessCheck(sender)
        idx = tuple((ipv, table, chain))
        settings = list(self.getSettings())
        if idx not in settings[0]:
            raise FirewallError(errors.NOT_ENABLED,
                                &quot;chain '%s' is not in '%s:%s'&quot; % (chain, ipv,
                                                                  table))
        settings[0].remove(idx)
        self.update(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sss', out_signature='b')
    @dbus_handle_exceptions
    def queryChain(self, ipv, table, chain, sender=None): # pylint: disable=W0613
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        chain = dbus_to_python(chain)
        log.debug1(&quot;config.direct.queryChain('%s', '%s', '%s')&quot; % \
                   (ipv, table, chain))
        idx = tuple((ipv, table, chain))
        return idx in self.getSettings()[0]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='ss', out_signature='as')
    @dbus_handle_exceptions
    def getChains(self, ipv, table, sender=None): # pylint: disable=W0613
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        log.debug1(&quot;config.direct.getChains('%s', '%s')&quot; % (ipv, table))
        ret = [ ]
        for idx in self.getSettings()[0]:
            if idx[0] == ipv and idx[1] == table:
                ret.append(idx[2])
        return ret

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='', out_signature='a(sss)')
    @dbus_handle_exceptions
    def getAllChains(self, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.direct.getAllChains()&quot;)
        return self.getSettings()[0]

    # rule

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sssias')
    @dbus_handle_exceptions
    def addRule(self, ipv, table, chain, priority, args, sender=None): # pylint: disable=R0913
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        chain = dbus_to_python(chain)
        priority = dbus_to_python(priority)
        args = dbus_to_python(args)
        log.debug1(&quot;config.direct.addRule('%s', '%s', '%s', %d, '%s')&quot; % \
                   (ipv, table, chain, priority, &quot;','&quot;.join(args)))
        self.accessCheck(sender)
        idx = (ipv, table, chain, priority, args)
        settings = list(self.getSettings())
        if idx in settings[1]:
            raise FirewallError(errors.ALREADY_ENABLED,
                                &quot;rule '%s' already is in '%s:%s:%s'&quot; % \
                                (args, ipv, table, chain))
        settings[1].append(idx)
        self.update(tuple(settings))

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sssias')
    @dbus_handle_exceptions
    def removeRule(self, ipv, table, chain, priority, args, sender=None): # pylint: disable=R0913
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        chain = dbus_to_python(chain)
        priority = dbus_to_python(priority)
        args = dbus_to_python(args)
        log.debug1(&quot;config.direct.removeRule('%s', '%s', '%s', %d, '%s')&quot; % \
                   (ipv, table, chain, priority, &quot;','&quot;.join(args)))
        self.accessCheck(sender)
        idx = (ipv, table, chain, priority, args)
        settings = list(self.getSettings())
        if idx not in settings[1]:
            raise FirewallError(errors.NOT_ENABLED,
                                &quot;rule '%s' is not in '%s:%s:%s'&quot; % \
                                (args, ipv, table, chain))
        settings[1].remove(idx)
        self.update(tuple(settings))

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sssias', out_signature='b')
    @dbus_handle_exceptions
    def queryRule(self, ipv, table, chain, priority, args, sender=None): # pylint: disable=W0613,R0913
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        chain = dbus_to_python(chain)
        priority = dbus_to_python(priority)
        args = dbus_to_python(args)
        log.debug1(&quot;config.direct.queryRule('%s', '%s', '%s', %d, '%s')&quot; % \
                   (ipv, table, chain, priority, &quot;','&quot;.join(args)))
        idx = (ipv, table, chain, priority, args)
        return idx in self.getSettings()[1]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sss')
    @dbus_handle_exceptions
    def removeRules(self, ipv, table, chain, sender=None):
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        chain = dbus_to_python(chain)
        log.debug1(&quot;config.direct.removeRules('%s', '%s', '%s')&quot; % \
                   (ipv, table, chain, ))
        self.accessCheck(sender)
        settings = list(self.getSettings())
        for rule in settings[1][:]:
            if (ipv, table, chain) == (rule[0], rule[1], rule[2]):
                settings[1].remove(rule)
        self.update(tuple(settings))

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sss', out_signature='a(ias)')
    @dbus_handle_exceptions
    def getRules(self, ipv, table, chain, sender=None): # pylint: disable=W0613
        ipv = dbus_to_python(ipv)
        table = dbus_to_python(table)
        chain = dbus_to_python(chain)
        log.debug1(&quot;config.direct.getRules('%s', '%s', '%s')&quot; % \
                   (ipv, table, chain))
        ret = [ ]
        for idx in self.getSettings()[1]:
            if idx[0] == ipv and idx[1] == table and idx[2] == chain:
                ret.append((idx[3], idx[4]))
        return ret

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='', out_signature='a(sssias)')
    @dbus_handle_exceptions
    def getAllRules(self, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.direct.getAllRules()&quot;)
        return self.getSettings()[1]

    # passthrough

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sas')
    @dbus_handle_exceptions
    def addPassthrough(self, ipv, args, sender=None):
        ipv = dbus_to_python(ipv)
        args = dbus_to_python(args)
        log.debug1(&quot;config.direct.addPassthrough('%s', '%s')&quot; % \
                   (ipv, &quot;','&quot;.join(args)))
        self.accessCheck(sender)
        idx = (ipv, args)
        settings = list(self.getSettings())
        if idx in settings[2]:
            raise FirewallError(errors.ALREADY_ENABLED,
                                &quot;passthrough '%s', '%s'&quot; % (ipv, args))
        settings[2].append(idx)
        self.update(settings)


    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sas')
    @dbus_handle_exceptions
    def removePassthrough(self, ipv, args, sender=None):
        ipv = dbus_to_python(ipv)
        args = dbus_to_python(args)
        log.debug1(&quot;config.direct.removePassthrough('%s', '%s')&quot; % \
                   (ipv, &quot;','&quot;.join(args)))
        self.accessCheck(sender)
        idx = (ipv, args)
        settings = list(self.getSettings())
        if idx not in settings[2]:
            raise FirewallError(errors.NOT_ENABLED,
                                &quot;passthrough '%s', '%s'&quot; % (ipv, args))
        settings[2].remove(idx)
        self.update(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='sas', out_signature='b')
    @dbus_handle_exceptions
    def queryPassthrough(self, ipv, args, sender=None): # pylint: disable=W0613
        ipv = dbus_to_python(ipv)
        args = dbus_to_python(args)
        log.debug1(&quot;config.direct.queryPassthrough('%s', '%s')&quot; % \
                   (ipv, &quot;','&quot;.join(args)))
        idx = (ipv, args)
        return idx in self.getSettings()[2]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         in_signature='s', out_signature='aas')
    @dbus_handle_exceptions
    def getPassthroughs(self, ipv, sender=None): # pylint: disable=W0613
        ipv = dbus_to_python(ipv)
        log.debug1(&quot;config.direct.getPassthroughs('%s')&quot; % (ipv))
        ret = [ ]
        for idx in self.getSettings()[2]:
            if idx[0] == ipv:
                ret.append(idx[1])
        return ret

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_DIRECT,
                         out_signature='a(sas)')
    @dbus_handle_exceptions
    def getAllPassthroughs(self, sender=None): # pylint: disable=W0613
        log.debug1(&quot;config.direct.getAllPassthroughs()&quot;)
        return self.getSettings()[2]
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Flib%2Fpython3.6%2Fsite-packages%2Ffirewall%2Fserver'>⬅ Back to Directory</a>