<h2>Editing File: /usr/lib/python3.6/site-packages/firewall/core/io/direct.py</h2><form method='post'><textarea name='content' class='file-edit'># -*- coding: utf-8 -*-
#
# Copyright (C) 2011-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;.
#

import xml.sax as sax
import os
import io
import shutil

from firewall import config
from firewall.fw_types import LastUpdatedOrderedDict
from firewall.functions import splitArgs, joinArgs, u2b_if_py2
from firewall.core.io.io_object import IO_Object, IO_Object_ContentHandler, \
    IO_Object_XMLGenerator
from firewall.core.logger import log
from firewall.core import ipXtables
from firewall.core import ebtables
from firewall import errors
from firewall.errors import FirewallError


class direct_ContentHandler(IO_Object_ContentHandler):
    def __init__(self, item):
        IO_Object_ContentHandler.__init__(self, item)
        self.direct = False

    def startElement(self, name, attrs):
        IO_Object_ContentHandler.startElement(self, name, attrs)
        self.item.parser_check_element_attrs(name, attrs)

        if name == &quot;direct&quot;:
            if self.direct:
                raise FirewallError(errors.PARSE_ERROR,
                                    &quot;More than one direct tag.&quot;)
            self.direct = True

        elif name == &quot;chain&quot;:
            if not self.direct:
                log.error(&quot;Parse Error: chain outside of direct&quot;)
                return
            ipv = attrs[&quot;ipv&quot;]
            table = attrs[&quot;table&quot;]
            chain = attrs[&quot;chain&quot;]
            self.item.add_chain(u2b_if_py2(ipv), u2b_if_py2(table),
                                u2b_if_py2(chain))

        elif name == &quot;rule&quot;:
            if not self.direct:
                log.error(&quot;Parse Error: rule outside of direct&quot;)
                return
            ipv = attrs[&quot;ipv&quot;]
            if ipv not in [ &quot;ipv4&quot;, &quot;ipv6&quot;, &quot;eb&quot; ]:
                raise FirewallError(errors.INVALID_IPV,
                                    &quot;'%s' not from {'ipv4'|'ipv6'|'eb'}&quot; % ipv)
            table = attrs[&quot;table&quot;]
            chain = attrs[&quot;chain&quot;]
            try:
                priority = int(attrs[&quot;priority&quot;])
            except ValueError:
                log.error(&quot;Parse Error: %s is not a valid priority&quot; %
                          attrs[&quot;priority&quot;])
                return
            self._rule = [ u2b_if_py2(ipv), u2b_if_py2(table),
                           u2b_if_py2(chain), priority ]

        elif name == &quot;passthrough&quot;:
            if not self.direct:
                log.error(&quot;Parse Error: command outside of direct&quot;)
                return
            ipv = attrs[&quot;ipv&quot;]
            self._passthrough = [ u2b_if_py2(ipv) ]

        else:
            log.error('Unknown XML element %s' % name)
            return

    def endElement(self, name):
        IO_Object_ContentHandler.endElement(self, name)

        if name == &quot;rule&quot;:
            if self._element:
                # add arguments
                self._rule.append([ u2b_if_py2(x)
                                    for x in splitArgs(self._element) ])
                self.item.add_rule(*self._rule)
            else:
                log.error(&quot;Error: rule does not have any arguments, ignoring.&quot;)
            self._rule = None
        elif name == &quot;passthrough&quot;:
            if self._element:
                # add arguments
                self._passthrough.append([ u2b_if_py2(x)
                                           for x in splitArgs(self._element) ])
                self.item.add_passthrough(*self._passthrough)
            else:
                log.error(&quot;Error: passthrough does not have any arguments, &quot; +
                          &quot;ignoring.&quot;)
            self._passthrough = None

class Direct(IO_Object):
    &quot;&quot;&quot; Direct class &quot;&quot;&quot;

    IMPORT_EXPORT_STRUCTURE = (
        # chain: [ ipv, table, [ chain ] ]
        ( &quot;chains&quot;, [ ( &quot;&quot;, &quot;&quot;, &quot;&quot; ), ], ),                   # a(sss)
        # rule: [ ipv, table, chain, [ priority, [ arg ] ] ]
        ( &quot;rules&quot;, [ ( &quot;&quot;, &quot;&quot;, &quot;&quot;, 0, [ &quot;&quot; ] ), ], ),         # a(sssias)
        # passthrough: [ ipv, [ [ arg ] ] ]
        ( &quot;passthroughs&quot;, [ ( &quot;&quot;, [ &quot;&quot; ]), ], ),              # a(sas)
        )
    DBUS_SIGNATURE = '(a(sss)a(sssias)a(sas))'
    PARSER_REQUIRED_ELEMENT_ATTRS = {
        &quot;direct&quot;: None,
        &quot;chain&quot;: [ &quot;ipv&quot;, &quot;table&quot;, &quot;chain&quot; ],
        &quot;rule&quot;: [ &quot;ipv&quot;, &quot;table&quot;, &quot;chain&quot;, &quot;priority&quot; ],
        &quot;passthrough&quot;: [ &quot;ipv&quot; ]
        }
    PARSER_OPTIONAL_ELEMENT_ATTRS = {
        }

    def __init__(self, filename):
        super(Direct, self).__init__()
        self.filename = filename
        self.chains = LastUpdatedOrderedDict()
        self.rules = LastUpdatedOrderedDict()
        self.passthroughs = LastUpdatedOrderedDict()

    def _check_config(self, conf, item, all_conf):
        pass
        # check arg lists

    def export_config(self):
        ret = [ ]
        x = [ ]
        for key in self.chains:
            for chain in self.chains[key]:
                x.append(tuple(list(key) + list([chain])))
        ret.append(x)
        x = [ ]
        for key in self.rules:
            for rule in self.rules[key]:
                x.append(tuple((key[0], key[1], key[2], rule[0],
                                list(rule[1]))))
        ret.append(x)
        x = [ ]
        for key in self.passthroughs:
            for rule in self.passthroughs[key]:
                x.append(tuple((key, list(rule))))
        ret.append(x)
        return tuple(ret)

    def import_config(self, conf):
        self.cleanup()
        self.check_config(conf)
        for i,(element,dummy) in enumerate(self.IMPORT_EXPORT_STRUCTURE):
            if element == &quot;chains&quot;:
                for x in conf[i]:
                    self.add_chain(*x)
            if element == &quot;rules&quot;:
                for x in conf[i]:
                    self.add_rule(*x)
            if element == &quot;passthroughs&quot;:
                for x in conf[i]:
                    self.add_passthrough(*x)

    def cleanup(self):
        self.chains.clear()
        self.rules.clear()
        self.passthroughs.clear()

    def output(self):
        print(&quot;chains&quot;)
        for key in self.chains:
            print(&quot;  (%s, %s): %s&quot; % (key[0], key[1],
                                      &quot;,&quot;.join(self.chains[key])))
        print(&quot;rules&quot;)
        for key in self.rules:
            print(&quot;  (%s, %s, %s):&quot; % (key[0], key[1], key[2]))
            for (priority,args) in self.rules[key]:
                print(&quot;    (%d, ('%s'))&quot; % (priority, &quot;','&quot;.join(args)))
        print(&quot;passthroughs&quot;)
        for key in self.passthroughs:
            print(&quot;  %s:&quot; % (key))
            for args in self.passthroughs[key]:
                print(&quot;    ('%s')&quot; % (&quot;','&quot;.join(args)))

    def _check_ipv(self, ipv):
        ipvs = ['ipv4', 'ipv6', 'eb']
        if ipv not in ipvs:
            raise FirewallError(errors.INVALID_IPV,
                                &quot;'%s' not in '%s'&quot; % (ipv, ipvs))

    def _check_ipv_table(self, ipv, table):
        self._check_ipv(ipv)

        tables = ipXtables.BUILT_IN_CHAINS.keys() if ipv in ['ipv4', 'ipv6'] \
                                         else ebtables.BUILT_IN_CHAINS.keys()
        if table not in tables:
            raise FirewallError(errors.INVALID_TABLE,
                                &quot;'%s' not in '%s'&quot; % (table, tables))

    # chains

    def add_chain(self, ipv, table, chain):
        self._check_ipv_table(ipv, table)
        key = (ipv, table)
        if key not in self.chains:
            self.chains[key] = [ ]
        if chain not in self.chains[key]:
            self.chains[key].append(chain)
        else:
            log.warning(&quot;Chain '%s' for table '%s' with ipv '%s' &quot; % \
                        (chain, table, ipv) + &quot;already in list, ignoring&quot;)

    def remove_chain(self, ipv, table, chain):
        self._check_ipv_table(ipv, table)
        key = (ipv, table)
        if key in self.chains and chain in self.chains[key]:
            self.chains[key].remove(chain)
            if len(self.chains[key]) == 0:
                del self.chains[key]
        else:
            raise ValueError( \
                &quot;Chain '%s' with table '%s' with ipv '%s' not in list&quot; % \
                (chain, table, ipv))

    def query_chain(self, ipv, table, chain):
        self._check_ipv_table(ipv, table)
        key = (ipv, table)
        return (key in self.chains and chain in self.chains[key])

    def get_chains(self, ipv, table):
        self._check_ipv_table(ipv, table)
        key = (ipv, table)
        if key in self.chains:
            return self.chains[key]
        else:
            raise ValueError(&quot;No chains for table '%s' with ipv '%s'&quot; % \
                             (table, ipv))

    def get_all_chains(self):
        return self.chains

    # rules

    def add_rule(self, ipv, table, chain, priority, args):
        self._check_ipv_table(ipv, table)
        key = (ipv, table, chain)
        if key not in self.rules:
            self.rules[key] = LastUpdatedOrderedDict()
        value = (priority, tuple(args))
        if value not in self.rules[key]:
            self.rules[key][value] = priority
        else:
            log.warning(&quot;Rule '%s' for table '%s' and chain '%s' &quot; % \
                        (&quot;',&quot;.join(args), table, chain) +
                        &quot;with ipv '%s' and priority %d &quot; % (ipv, priority) +
                        &quot;already in list, ignoring&quot;)

    def remove_rule(self, ipv, table, chain, priority, args):
        self._check_ipv_table(ipv, table)
        key = (ipv, table, chain)
        value = (priority, tuple(args))
        if key in self.rules and value in self.rules[key]:
            del self.rules[key][value]
            if len(self.rules[key]) == 0:
                del self.rules[key]
        else:
            raise ValueError(&quot;Rule '%s' for table '%s' and chain '%s' &quot; % \
                (&quot;',&quot;.join(args), table, chain) + \
                &quot;with ipv '%s' and priority %d not in list&quot; % (ipv, priority))

    def remove_rules(self, ipv, table, chain):
        self._check_ipv_table(ipv, table)
        key = (ipv, table, chain)
        if key in self.rules:
            for value in self.rules[key].keys():
                del self.rules[key][value]
            if len(self.rules[key]) == 0:
                del self.rules[key]

    def query_rule(self, ipv, table, chain, priority, args):
        self._check_ipv_table(ipv, table)
        key = (ipv, table, chain)
        value = (priority, tuple(args))
        return (key in self.rules and value in self.rules[key])

    def get_rules(self, ipv, table, chain):
        self._check_ipv_table(ipv, table)
        key = (ipv, table, chain)
        if key in self.rules:
            return self.rules[key]
        else:
            raise ValueError(&quot;No rules for table '%s' and chain '%s' &quot; %\
                             (table, chain) + &quot;with ipv '%s'&quot; % (ipv))

    def get_all_rules(self):
        return self.rules

#    # passthrough
#
    def add_passthrough(self, ipv, args):
        self._check_ipv(ipv)
        if ipv not in self.passthroughs:
            self.passthroughs[ipv] = [ ]
        if args not in self.passthroughs[ipv]:
            self.passthroughs[ipv].append(args)
        else:
            log.warning(&quot;Passthrough '%s' for ipv '%s'&quot; % \
                        (&quot;',&quot;.join(args), ipv) + &quot;already in list, ignoring&quot;)

    def remove_passthrough(self, ipv, args):
        self._check_ipv(ipv)
        if ipv in self.passthroughs and args in self.passthroughs[ipv]:
            self.passthroughs[ipv].remove(args)
            if len(self.passthroughs[ipv]) == 0:
                del self.passthroughs[ipv]
        else:
            raise ValueError(&quot;Passthrough '%s' for ipv '%s'&quot; % \
                             (&quot;',&quot;.join(args), ipv) + &quot;not in list&quot;)

    def query_passthrough(self, ipv, args):
        self._check_ipv(ipv)
        return ipv in self.passthroughs and args in self.passthroughs[ipv]

    def get_passthroughs(self, ipv):
        self._check_ipv(ipv)
        if ipv in self.passthroughs:
            return self.passthroughs[ipv]
        else:
            raise ValueError(&quot;No passthroughs for ipv '%s'&quot; % (ipv))

    def get_all_passthroughs(self):
        return self.passthroughs

    # read

    def read(self):
        self.cleanup()
        if not self.filename.endswith(&quot;.xml&quot;):
            raise FirewallError(errors.INVALID_NAME,
                                &quot;'%s' is missing .xml suffix&quot; % self.filename)
        handler = direct_ContentHandler(self)
        parser = sax.make_parser()
        parser.setContentHandler(handler)
        with open(self.filename, &quot;rb&quot;) as f:
            source = sax.InputSource(None)
            source.setByteStream(f)
            try:
                parser.parse(source)
            except sax.SAXParseException as msg:
                raise FirewallError(errors.INVALID_TYPE,
                                    &quot;Not a valid file: %s&quot; % \
                                    msg.getException())

    def write(self):
        if os.path.exists(self.filename):
            try:
                shutil.copy2(self.filename, &quot;%s.old&quot; % self.filename)
            except Exception as msg:
                raise IOError(&quot;Backup of '%s' failed: %s&quot; % (self.filename, msg))

        if not os.path.exists(config.ETC_FIREWALLD):
            os.mkdir(config.ETC_FIREWALLD, 0o750)

        f = io.open(self.filename, mode='wt', encoding='UTF-8')
        handler = IO_Object_XMLGenerator(f)
        handler.startDocument()

        # start whitelist element
        handler.startElement(&quot;direct&quot;, { })
        handler.ignorableWhitespace(&quot;\n&quot;)

        # chains
        for key in self.chains:
            (ipv, table) = key
            for chain in self.chains[key]:
                handler.ignorableWhitespace(&quot;  &quot;)
                handler.simpleElement(&quot;chain&quot;, { &quot;ipv&quot;: ipv, &quot;table&quot;: table,
                                                 &quot;chain&quot;: chain })
                handler.ignorableWhitespace(&quot;\n&quot;)

        # rules
        for key in self.rules:
            (ipv, table, chain) = key
            for (priority, args) in self.rules[key]:
                if len(args) &lt; 1:
                    continue
                handler.ignorableWhitespace(&quot;  &quot;)
                handler.startElement(&quot;rule&quot;, { &quot;ipv&quot;: ipv, &quot;table&quot;: table,
                                               &quot;chain&quot;: chain,
                                               &quot;priority&quot;: &quot;%d&quot; % priority })
                handler.ignorableWhitespace(sax.saxutils.escape(joinArgs(args)))
                handler.endElement(&quot;rule&quot;)
                handler.ignorableWhitespace(&quot;\n&quot;)

        # passthroughs
        for ipv in self.passthroughs:
            for args in self.passthroughs[ipv]:
                if len(args) &lt; 1:
                    continue
                handler.ignorableWhitespace(&quot;  &quot;)
                handler.startElement(&quot;passthrough&quot;, { &quot;ipv&quot;: ipv })
                handler.ignorableWhitespace(sax.saxutils.escape(joinArgs(args)))
                handler.endElement(&quot;passthrough&quot;)
                handler.ignorableWhitespace(&quot;\n&quot;)

        # end zone element
        handler.endElement(&quot;direct&quot;)
        handler.ignorableWhitespace(&quot;\n&quot;)
        handler.endDocument()
        f.close()
        del handler
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flib%2Fpython3.6%2Fsite-packages%2Ffirewall%2Fcore%2Fio'>Back to Directory</a>