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

&quot;&quot;&quot;ipset io XML handler, reader, writer&quot;&quot;&quot;

__all__ = [ &quot;IPSet&quot;, &quot;ipset_reader&quot;, &quot;ipset_writer&quot; ]

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

from firewall import config
from firewall.functions import checkIP, checkIP6, checkIPnMask, \
    checkIP6nMask, u2b_if_py2, check_mac, check_port, checkInterface, \
    checkProtocol
from firewall.core.io.io_object import PY2, IO_Object, \
    IO_Object_ContentHandler, IO_Object_XMLGenerator
from firewall.core.ipset import IPSET_TYPES, IPSET_CREATE_OPTIONS
from firewall.core.icmp import check_icmp_name, check_icmp_type_code, \
    check_icmpv6_name, check_icmpv6_type_code
from firewall.core.logger import log
from firewall import errors
from firewall.errors import FirewallError

class IPSet(IO_Object):
    IMPORT_EXPORT_STRUCTURE = (
        ( &quot;version&quot;,  &quot;&quot; ),              # s
        ( &quot;short&quot;, &quot;&quot; ),                 # s
        ( &quot;description&quot;, &quot;&quot; ),           # s
        ( &quot;type&quot;, &quot;&quot; ),                  # s
        ( &quot;options&quot;, { &quot;&quot;: &quot;&quot;, }, ),     # a{ss}
        ( &quot;entries&quot;, [ &quot;&quot; ], ),          # as
    )
    DBUS_SIGNATURE = '(ssssa{ss}as)'
    ADDITIONAL_ALNUM_CHARS = [ &quot;_&quot;, &quot;-&quot;, &quot;:&quot;, &quot;.&quot; ]
    PARSER_REQUIRED_ELEMENT_ATTRS = {
        &quot;short&quot;: None,
        &quot;description&quot;: None,
        &quot;ipset&quot;: [ &quot;type&quot; ],
        &quot;option&quot;: [ &quot;name&quot; ],
        &quot;entry&quot;: None,
    }
    PARSER_OPTIONAL_ELEMENT_ATTRS = {
        &quot;ipset&quot;: [ &quot;version&quot; ],
        &quot;option&quot;: [ &quot;value&quot; ],
    }

    def __init__(self):
        super(IPSet, self).__init__()
        self.version = &quot;&quot;
        self.short = &quot;&quot;
        self.description = &quot;&quot;
        self.type = &quot;&quot;
        self.entries = [ ]
        self.options = { }
        self.applied = False

    def cleanup(self):
        self.version = &quot;&quot;
        self.short = &quot;&quot;
        self.description = &quot;&quot;
        self.type = &quot;&quot;
        del self.entries[:]
        self.options.clear()
        self.applied = False

    def encode_strings(self):
        &quot;&quot;&quot; HACK. I haven't been able to make sax parser return
            strings encoded (because of python 2) instead of in unicode.
            Get rid of it once we throw out python 2 support.&quot;&quot;&quot;
        self.version = u2b_if_py2(self.version)
        self.short = u2b_if_py2(self.short)
        self.description = u2b_if_py2(self.description)
        self.type = u2b_if_py2(self.type)
        self.options = { u2b_if_py2(k):u2b_if_py2(v)
                         for k, v in self.options.items() }
        self.entries = [ u2b_if_py2(e) for e in self.entries ]

    @staticmethod
    def check_entry(entry, options, ipset_type):
        family = &quot;ipv4&quot;
        if &quot;family&quot; in options:
            if options[&quot;family&quot;] == &quot;inet6&quot;:
                family = &quot;ipv6&quot;

        if not ipset_type.startswith(&quot;hash:&quot;):
            raise FirewallError(errors.INVALID_IPSET,
                                &quot;ipset type '%s' not usable&quot; % ipset_type)
        flags = ipset_type[5:].split(&quot;,&quot;)
        items = entry.split(&quot;,&quot;)

        if len(flags) != len(items) or len(flags) &lt; 1:
            raise FirewallError(
                errors.INVALID_ENTRY,
                &quot;entry '%s' does not match ipset type '%s'&quot; % \
                (entry, ipset_type))

        for i in range(len(flags)):
            flag = flags[i]
            item = items[i]

            if flag == &quot;ip&quot;:
                if &quot;-&quot; in item and family == &quot;ipv4&quot;:
                    # IP ranges only with plain IPs, no masks
                    if i &gt; 1:
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid address '%s' in '%s'[%d]&quot; % \
                            (item, entry, i))
                    splits = item.split(&quot;-&quot;)
                    if len(splits) != 2:
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid address range '%s' in '%s' for %s (%s)&quot; % \
                            (item, entry, ipset_type, family))
                    for _split in splits:
                        if (family == &quot;ipv4&quot; and not checkIP(_split)) or \
                           (family == &quot;ipv6&quot; and not checkIP6(_split)):
                            raise FirewallError(
                                errors.INVALID_ENTRY,
                                &quot;invalid address '%s' in '%s' for %s (%s)&quot; % \
                                (_split, entry, ipset_type, family))
                else:
                    # IPs with mask only allowed in the first
                    # position of the type
                    if family == &quot;ipv4&quot;:
                        if item == &quot;0.0.0.0&quot;:
                            raise FirewallError(
                                errors.INVALID_ENTRY,
                                &quot;invalid address '%s' in '%s' for %s (%s)&quot; % \
                                (item, entry, ipset_type, family))
                        if i == 0:
                            ip_check = checkIPnMask
                        else:
                            ip_check = checkIP
                    else:
                        ip_check = checkIP6
                    if not ip_check(item):
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid address '%s' in '%s' for %s (%s)&quot; % \
                            (item, entry, ipset_type, family))
            elif flag == &quot;net&quot;:
                if &quot;-&quot; in item:
                    # IP ranges only with plain IPs, no masks
                    splits = item.split(&quot;-&quot;)
                    if len(splits) != 2:
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid address range '%s' in '%s' for %s (%s)&quot; % \
                            (item, entry, ipset_type, family))
                    # First part can only be a plain IP
                    if (family == &quot;ipv4&quot; and not checkIP(splits[0])) or \
                       (family == &quot;ipv6&quot; and not checkIP6(splits[0])):
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid address '%s' in '%s' for %s (%s)&quot; % \
                            (splits[0], entry, ipset_type, family))
                    # Second part can also have a mask
                    if (family == &quot;ipv4&quot; and not checkIPnMask(splits[1])) or \
                       (family == &quot;ipv6&quot; and not checkIP6nMask(splits[1])):
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid address '%s' in '%s' for %s (%s)&quot; % \
                            (splits[1], entry, ipset_type, family))
                else:
                    # IPs with mask allowed in all positions, but no /0
                    if item.endswith(&quot;/0&quot;):
                        if not (family == &quot;ipv6&quot; and i == 0 and
                                ipset_type == &quot;hash:net,iface&quot;):
                            raise FirewallError(
                                errors.INVALID_ENTRY,
                                &quot;invalid address '%s' in '%s' for %s (%s)&quot; % \
                                (item, entry, ipset_type, family))
                    if (family == &quot;ipv4&quot; and not checkIPnMask(item)) or \
                       (family == &quot;ipv6&quot; and not checkIP6nMask(item)):
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid address '%s' in '%s' for %s (%s)&quot; % \
                            (item, entry, ipset_type, family))
            elif flag == &quot;mac&quot;:
                # ipset does not allow to add 00:00:00:00:00:00
                if not check_mac(item) or item == &quot;00:00:00:00:00:00&quot;:
                    raise FirewallError(
                        errors.INVALID_ENTRY,
                        &quot;invalid mac address '%s' in '%s'&quot; % (item, entry))
            elif flag == &quot;port&quot;:
                if &quot;:&quot; in item:
                    splits = item.split(&quot;:&quot;)
                    if len(splits) != 2:
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid port '%s'&quot; % (item))
                    if splits[0] == &quot;icmp&quot;:
                        if family != &quot;ipv4&quot;:
                            raise FirewallError(
                                errors.INVALID_ENTRY,
                                &quot;invalid protocol for family '%s' in '%s'&quot; % \
                                (family, entry))
                        if not check_icmp_name(splits[1]) and &quot;/&quot; not in splits[1]:
                            raise FirewallError(
                                errors.INVALID_ENTRY,
                                &quot;invalid icmp type '%s' in '%s'&quot; % \
                                (splits[1], entry))
                        else:
                            (_type, _code) = splits[1].split(&quot;/&quot;)
                            if not check_icmp_type_code(_type, _code):
                                raise FirewallError(
                                    errors.INVALID_ENTRY,
                                    &quot;invalid icmp type '%s' in '%s'&quot;
                                    % (splits[1], entry),
                                )
                    elif splits[0] in [ &quot;icmpv6&quot;, &quot;ipv6-icmp&quot; ]:
                        if family != &quot;ipv6&quot;:
                            raise FirewallError(
                                errors.INVALID_ENTRY,
                                &quot;invalid protocol for family '%s' in '%s'&quot; % \
                                (family, entry))
                        if not check_icmpv6_name(splits[1]) and &quot;/&quot; not in splits[1]:
                            raise FirewallError(
                                errors.INVALID_ENTRY,
                                &quot;invalid icmpv6 type '%s' in '%s'&quot; % \
                                (splits[1], entry))
                        else:
                            (_type, _code) = splits[1].split(&quot;/&quot;)
                            if not check_icmpv6_type_code(_type, _code):
                                raise FirewallError(
                                    errors.INVALID_ENTRY,
                                    &quot;invalid icmpv6 type '%s' in '%s'&quot;
                                    % (splits[1], entry),
                                )
                    elif splits[0] not in [ &quot;tcp&quot;, &quot;sctp&quot;, &quot;udp&quot;, &quot;udplite&quot; ] \
                       and not checkProtocol(splits[0]):
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid protocol '%s' in '%s'&quot; % (splits[0],
                                                               entry))
                    elif not check_port(splits[1]):
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid port '%s'in '%s'&quot; % (splits[1], entry))
                else:
                    if not check_port(item):
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid port '%s' in '%s'&quot; % (item, entry))
            elif flag == &quot;mark&quot;:
                if item.startswith(&quot;0x&quot;):
                    try:
                        int_val = int(item, 16)
                    except ValueError:
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid mark '%s' in '%s'&quot; % (item, entry))
                else:
                    try:
                        int_val = int(item)
                    except ValueError:
                        raise FirewallError(
                            errors.INVALID_ENTRY,
                            &quot;invalid mark '%s' in '%s'&quot; % (item, entry))
                if int_val &lt; 0 or int_val &gt; 4294967295:
                    raise FirewallError(
                        errors.INVALID_ENTRY,
                        &quot;invalid mark '%s' in '%s'&quot; % (item, entry))
            elif flag == &quot;iface&quot;:
                if not checkInterface(item) or len(item) &gt; 15:
                    raise FirewallError(
                        errors.INVALID_ENTRY,
                        &quot;invalid interface '%s' in '%s'&quot; % (item, entry))
            else:
                raise FirewallError(errors.INVALID_IPSET,
                                    &quot;ipset type '%s' not usable&quot; % ipset_type)

    def _check_config(self, config, item, all_config):
        if item == &quot;type&quot;:
            if config not in IPSET_TYPES:
                raise FirewallError(errors.INVALID_TYPE,
                                    &quot;'%s' is not valid ipset type&quot; % config)
        if item == &quot;options&quot;:
            for key in config.keys():
                if key not in IPSET_CREATE_OPTIONS:
                    raise FirewallError(errors.INVALID_IPSET,
                                        &quot;ipset invalid option '%s'&quot; % key)
                if key in [ &quot;timeout&quot;, &quot;hashsize&quot;, &quot;maxelem&quot; ]:
                    try:
                        int_value = int(config[key])
                    except ValueError:
                        raise FirewallError(
                            errors.INVALID_VALUE,
                            &quot;Option '%s': Value '%s' is not an integer&quot; % \
                            (key, config[key]))
                    if int_value &lt; 0:
                        raise FirewallError(
                            errors.INVALID_VALUE,
                            &quot;Option '%s': Value '%s' is negative&quot; % \
                            (key, config[key]))
                elif key == &quot;family&quot; and \
                     config[key] not in [ &quot;inet&quot;, &quot;inet6&quot; ]:
                    raise FirewallError(errors.INVALID_FAMILY, config[key])

    def import_config(self, config):
        if &quot;timeout&quot; in config[4] and config[4][&quot;timeout&quot;] != &quot;0&quot;:
            if len(config[5]) != 0:
                raise FirewallError(errors.IPSET_WITH_TIMEOUT)
        for entry in config[5]:
            IPSet.check_entry(entry, config[4], config[3])
        super(IPSet, self).import_config(config)

# PARSER

class ipset_ContentHandler(IO_Object_ContentHandler):
    def startElement(self, name, attrs):
        IO_Object_ContentHandler.startElement(self, name, attrs)
        self.item.parser_check_element_attrs(name, attrs)
        if name == &quot;ipset&quot;:
            if &quot;type&quot; in attrs:
                if attrs[&quot;type&quot;] not in IPSET_TYPES:
                    raise FirewallError(errors.INVALID_TYPE, &quot;%s&quot; % attrs[&quot;type&quot;])
                self.item.type = attrs[&quot;type&quot;]
            if &quot;version&quot; in attrs:
                self.item.version = attrs[&quot;version&quot;]
        elif name == &quot;short&quot;:
            pass
        elif name == &quot;description&quot;:
            pass
        elif name == &quot;option&quot;:
            value = &quot;&quot;
            if &quot;value&quot; in attrs:
                value = attrs[&quot;value&quot;]

            if attrs[&quot;name&quot;] not in \
               [ &quot;family&quot;, &quot;timeout&quot;, &quot;hashsize&quot;, &quot;maxelem&quot; ]:
                raise FirewallError(
                    errors.INVALID_OPTION,
                    &quot;Unknown option '%s'&quot; % attrs[&quot;name&quot;])
            if self.item.type == &quot;hash:mac&quot; and attrs[&quot;name&quot;] in [ &quot;family&quot; ]:
                raise FirewallError(
                    errors.INVALID_OPTION,
                    &quot;Unsupported option '%s' for type '%s'&quot; % \
                    (attrs[&quot;name&quot;], self.item.type))
            if attrs[&quot;name&quot;] in [ &quot;family&quot;, &quot;timeout&quot;, &quot;hashsize&quot;, &quot;maxelem&quot; ] \
               and not value:
                raise FirewallError(
                    errors.INVALID_OPTION,
                    &quot;Missing mandatory value of option '%s'&quot; % attrs[&quot;name&quot;])
            if attrs[&quot;name&quot;] in [ &quot;timeout&quot;, &quot;hashsize&quot;, &quot;maxelem&quot; ]:
                try:
                    int_value = int(value)
                except ValueError:
                    raise FirewallError(
                        errors.INVALID_VALUE,
                        &quot;Option '%s': Value '%s' is not an integer&quot; % \
                        (attrs[&quot;name&quot;], value))
                if int_value &lt; 0:
                    raise FirewallError(
                        errors.INVALID_VALUE,
                        &quot;Option '%s': Value '%s' is negative&quot; % \
                        (attrs[&quot;name&quot;], value))
            if attrs[&quot;name&quot;] == &quot;family&quot; and value not in [ &quot;inet&quot;, &quot;inet6&quot; ]:
                raise FirewallError(errors.INVALID_FAMILY, value)
            if attrs[&quot;name&quot;] not in self.item.options:
                self.item.options[attrs[&quot;name&quot;]] = value
            else:
                log.warning(&quot;Option %s already set, ignoring.&quot;, attrs[&quot;name&quot;])
        # nothing to do for entry and entries here

    def endElement(self, name):
        IO_Object_ContentHandler.endElement(self, name)
        if name == &quot;entry&quot;:
            self.item.entries.append(self._element)

def ipset_reader(filename, path):
    ipset = IPSet()
    if not filename.endswith(&quot;.xml&quot;):
        raise FirewallError(errors.INVALID_NAME,
                            &quot;'%s' is missing .xml suffix&quot; % filename)
    ipset.name = filename[:-4]
    ipset.check_name(ipset.name)
    ipset.filename = filename
    ipset.path = path
    ipset.builtin = False if path.startswith(config.ETC_FIREWALLD) else True
    ipset.default = ipset.builtin
    handler = ipset_ContentHandler(ipset)
    parser = sax.make_parser()
    parser.setContentHandler(handler)
    name = &quot;%s/%s&quot; % (path, filename)
    with open(name, &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_IPSET,
                                &quot;not a valid ipset file: %s&quot; % \
                                msg.getException())
    del handler
    del parser
    if &quot;timeout&quot; in ipset.options and ipset.options[&quot;timeout&quot;] != &quot;0&quot; and \
       len(ipset.entries) &gt; 0:
        # no entries visible for ipsets with timeout
        log.warning(&quot;ipset '%s': timeout option is set, entries are ignored&quot;,
                    ipset.name)
        del ipset.entries[:]
    i = 0
    entries_set = set()
    while i &lt; len(ipset.entries):
        if ipset.entries[i] in entries_set:
            log.warning(&quot;Entry %s already set, ignoring.&quot;, ipset.entries[i])
            ipset.entries.pop(i)
        else:
            try:
                ipset.check_entry(ipset.entries[i], ipset.options, ipset.type)
            except FirewallError as e:
                log.warning(&quot;%s, ignoring.&quot;, e)
                ipset.entries.pop(i)
            else:
                entries_set.add(ipset.entries[i])
                i += 1
    del entries_set
    if PY2:
        ipset.encode_strings()

    return ipset

def ipset_writer(ipset, path=None):
    _path = path if path else ipset.path

    if ipset.filename:
        name = &quot;%s/%s&quot; % (_path, ipset.filename)
    else:
        name = &quot;%s/%s.xml&quot; % (_path, ipset.name)

    if os.path.exists(name):
        try:
            shutil.copy2(name, &quot;%s.old&quot; % name)
        except Exception as msg:
            log.error(&quot;Backup of file '%s' failed: %s&quot;, name, msg)

    dirpath = os.path.dirname(name)
    if dirpath.startswith(config.ETC_FIREWALLD) and not os.path.exists(dirpath):
        if not os.path.exists(config.ETC_FIREWALLD):
            os.mkdir(config.ETC_FIREWALLD, 0o750)
        os.mkdir(dirpath, 0o750)

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

    # start ipset element
    attrs = { &quot;type&quot;: ipset.type }
    if ipset.version and ipset.version != &quot;&quot;:
        attrs[&quot;version&quot;] = ipset.version
    handler.startElement(&quot;ipset&quot;, attrs)
    handler.ignorableWhitespace(&quot;\n&quot;)

    # short
    if ipset.short and ipset.short != &quot;&quot;:
        handler.ignorableWhitespace(&quot;  &quot;)
        handler.startElement(&quot;short&quot;, { })
        handler.characters(ipset.short)
        handler.endElement(&quot;short&quot;)
        handler.ignorableWhitespace(&quot;\n&quot;)

    # description
    if ipset.description and ipset.description != &quot;&quot;:
        handler.ignorableWhitespace(&quot;  &quot;)
        handler.startElement(&quot;description&quot;, { })
        handler.characters(ipset.description)
        handler.endElement(&quot;description&quot;)
        handler.ignorableWhitespace(&quot;\n&quot;)

    # options
    for key,value in ipset.options.items():
        handler.ignorableWhitespace(&quot;  &quot;)
        if value != &quot;&quot;:
            handler.simpleElement(&quot;option&quot;, { &quot;name&quot;: key, &quot;value&quot;: value })
        else:
            handler.simpleElement(&quot;option&quot;, { &quot;name&quot;: key })
        handler.ignorableWhitespace(&quot;\n&quot;)

    # entries
    for entry in ipset.entries:
        handler.ignorableWhitespace(&quot;  &quot;)
        handler.startElement(&quot;entry&quot;, { })
        handler.characters(entry)
        handler.endElement(&quot;entry&quot;)
        handler.ignorableWhitespace(&quot;\n&quot;)

    # end ipset element
    handler.endElement('ipset')
    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>