<h2>Edit File: seobject.py</h2><form method="post"><textarea name="content" rows="20" cols="80"># Copyright (C) 2005-2013 Red Hat
# see file &#039;COPYING&#039; for use and warranty information
#
# semanage is a tool for managing SELinux configuration files
#
#    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, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
#                                        02111-1307  USA
#
#

import pwd
import grp
import selinux
import os
import re
import sys
import stat
import socket
from semanage import *
PROGNAME = &quot;selinux-python&quot;
import sepolicy
from setools.policyrep import SELinuxPolicy
from setools.typequery import TypeQuery
import ipaddress

try:
    import gettext
    kwargs = {}
    if sys.version_info &lt; (3,):
        kwargs[&#039;unicode&#039;] = True
    t = gettext.translation(PROGNAME,
                    localedir=&quot;/usr/share/locale&quot;,
                    **kwargs,
                    fallback=True)
    _ = t.gettext
except:
    try:
        import builtins
        builtins.__dict__[&#039;_&#039;] = str
    except ImportError:
        import __builtin__
        __builtin__.__dict__[&#039;_&#039;] = unicode

import syslog

file_types = {}
file_types[&quot;&quot;] = SEMANAGE_FCONTEXT_ALL
file_types[&quot;all files&quot;] = SEMANAGE_FCONTEXT_ALL
file_types[&quot;a&quot;] = SEMANAGE_FCONTEXT_ALL
file_types[&quot;regular file&quot;] = SEMANAGE_FCONTEXT_REG
file_types[&quot;--&quot;] = SEMANAGE_FCONTEXT_REG
file_types[&quot;f&quot;] = SEMANAGE_FCONTEXT_REG
file_types[&quot;-d&quot;] = SEMANAGE_FCONTEXT_DIR
file_types[&quot;directory&quot;] = SEMANAGE_FCONTEXT_DIR
file_types[&quot;d&quot;] = SEMANAGE_FCONTEXT_DIR
file_types[&quot;-c&quot;] = SEMANAGE_FCONTEXT_CHAR
file_types[&quot;character device&quot;] = SEMANAGE_FCONTEXT_CHAR
file_types[&quot;c&quot;] = SEMANAGE_FCONTEXT_CHAR
file_types[&quot;-b&quot;] = SEMANAGE_FCONTEXT_BLOCK
file_types[&quot;block device&quot;] = SEMANAGE_FCONTEXT_BLOCK
file_types[&quot;b&quot;] = SEMANAGE_FCONTEXT_BLOCK
file_types[&quot;-s&quot;] = SEMANAGE_FCONTEXT_SOCK
file_types[&quot;socket&quot;] = SEMANAGE_FCONTEXT_SOCK
file_types[&quot;s&quot;] = SEMANAGE_FCONTEXT_SOCK
file_types[&quot;-l&quot;] = SEMANAGE_FCONTEXT_LINK
file_types[&quot;l&quot;] = SEMANAGE_FCONTEXT_LINK
file_types[&quot;symbolic link&quot;] = SEMANAGE_FCONTEXT_LINK
file_types[&quot;p&quot;] = SEMANAGE_FCONTEXT_PIPE
file_types[&quot;-p&quot;] = SEMANAGE_FCONTEXT_PIPE
file_types[&quot;named pipe&quot;] = SEMANAGE_FCONTEXT_PIPE

file_type_str_to_option = {&quot;all files&quot;: &quot;a&quot;,
                           &quot;regular file&quot;: &quot;f&quot;,
                           &quot;directory&quot;: &quot;d&quot;,
                           &quot;character device&quot;: &quot;c&quot;,
                           &quot;block device&quot;: &quot;b&quot;,
                           &quot;socket&quot;: &quot;s&quot;,
                           &quot;symbolic link&quot;: &quot;l&quot;,
                           &quot;named pipe&quot;: &quot;p&quot;}

ftype_to_audit = {&quot;&quot;: &quot;any&quot;,
                  &quot;a&quot; : &quot;any&quot;,
                  &quot;b&quot;: &quot;block&quot;,
                  &quot;c&quot;: &quot;char&quot;,
                  &quot;d&quot;: &quot;dir&quot;,
                  &quot;f&quot;: &quot;file&quot;,
                  &quot;l&quot;: &quot;symlink&quot;,
                  &quot;p&quot;: &quot;pipe&quot;,
                  &quot;s&quot;: &quot;socket&quot;}

try:
    import audit
    #test if audit module is enabled
    audit.audit_close(audit.audit_open())

    class logger:

        def __init__(self):
            self.audit_fd = audit.audit_open()
            self.log_list = []
            self.log_change_list = []

        def log(self, msg, name=&quot;&quot;, sename=&quot;&quot;, serole=&quot;&quot;, serange=&quot;&quot;, oldsename=&quot;&quot;, oldserole=&quot;&quot;, oldserange=&quot;&quot;):

            sep = &quot;-&quot;
            if sename != oldsename:
                msg += sep + &quot;sename&quot;
                sep = &quot;,&quot;
            if serole != oldserole:
                msg += sep + &quot;role&quot;
                sep = &quot;,&quot;
            if serange != oldserange:
                msg += sep + &quot;range&quot;
                sep = &quot;,&quot;

            self.log_list.append([self.audit_fd, audit.AUDIT_ROLE_ASSIGN, sys.argv[0], str(msg), name, 0, sename, serole, serange, oldsename, oldserole, oldserange, &quot;&quot;, &quot;&quot;, &quot;&quot;])

        def log_remove(self, msg, name=&quot;&quot;, sename=&quot;&quot;, serole=&quot;&quot;, serange=&quot;&quot;, oldsename=&quot;&quot;, oldserole=&quot;&quot;, oldserange=&quot;&quot;):
            self.log_list.append([self.audit_fd, audit.AUDIT_ROLE_REMOVE, sys.argv[0], str(msg), name, 0, sename, serole, serange, oldsename, oldserole, oldserange, &quot;&quot;, &quot;&quot;, &quot;&quot;])

        def log_change(self, msg):
            self.log_change_list.append([self.audit_fd, audit.AUDIT_USER_MAC_CONFIG_CHANGE, str(msg), &quot;semanage&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;])

        def commit(self, success):
            for l in self.log_list:
                audit.audit_log_semanage_message(*(l + [success]))
            for l in self.log_change_list:
                audit.audit_log_user_comm_message(*(l + [success]))

            self.log_list = []
            self.log_change_list = []
except (OSError, ImportError):
    class logger:

        def __init__(self):
            self.log_list = []

        def log(self, msg, name=&quot;&quot;, sename=&quot;&quot;, serole=&quot;&quot;, serange=&quot;&quot;, oldsename=&quot;&quot;, oldserole=&quot;&quot;, oldserange=&quot;&quot;):
            message = &quot; %s name=%s&quot; % (msg, name)
            if sename != &quot;&quot;:
                message += &quot; sename=&quot; + sename
            if oldsename != &quot;&quot;:
                message += &quot; oldsename=&quot; + oldsename
            if serole != &quot;&quot;:
                message += &quot; role=&quot; + serole
            if oldserole != &quot;&quot;:
                message += &quot; old_role=&quot; + oldserole
            if serange != &quot;&quot; and serange is not None:
                message += &quot; MLSRange=&quot; + serange
            if oldserange != &quot;&quot; and oldserange is not None:
                message += &quot; old_MLSRange=&quot; + oldserange
            self.log_list.append(message)

        def log_remove(self, msg, name=&quot;&quot;, sename=&quot;&quot;, serole=&quot;&quot;, serange=&quot;&quot;, oldsename=&quot;&quot;, oldserole=&quot;&quot;, oldserange=&quot;&quot;):
            self.log(msg, name, sename, serole, serange, oldsename, oldserole, oldserange)

        def log_change(self, msg):
            self.log_list.append(&quot; %s&quot; % msg)

        def commit(self, success):
            if success == 1:
                message = &quot;Successful: &quot;
            else:
                message = &quot;Failed: &quot;
            for l in self.log_list:
                syslog.syslog(syslog.LOG_INFO, message + l)


class nulllogger:

    def log(self, msg, name=&quot;&quot;, sename=&quot;&quot;, serole=&quot;&quot;, serange=&quot;&quot;, oldsename=&quot;&quot;, oldserole=&quot;&quot;, oldserange=&quot;&quot;):
        pass

    def log_remove(self, msg, name=&quot;&quot;, sename=&quot;&quot;, serole=&quot;&quot;, serange=&quot;&quot;, oldsename=&quot;&quot;, oldserole=&quot;&quot;, oldserange=&quot;&quot;):
        pass

    def log_change(self, msg):
        pass

    def commit(self, success):
        pass


def validate_level(raw):
    sensitivity = &quot;s[0-9]*&quot;
    category = &quot;c[0-9]*&quot;
    cat_range = category + r&quot;(\.&quot; + category + &quot;)?&quot;
    categories = cat_range + r&quot;(\,&quot; + cat_range + &quot;)*&quot;
    reg = sensitivity + &quot;(-&quot; + sensitivity + &quot;)?&quot; + &quot;(:&quot; + categories + &quot;)?&quot;
    return re.search(&quot;^&quot; + reg + &quot;$&quot;, raw)


def translate(raw, prepend=1):
    filler = &quot;a:b:c:&quot;
    if prepend == 1:
        context = &quot;%s%s&quot; % (filler, raw)
    else:
        context = raw
    (rc, trans) = selinux.selinux_raw_to_trans_context(context)
    if rc != 0:
        return raw
    if prepend:
        trans = trans[len(filler):]
    if trans == &quot;&quot;:
        return raw
    else:
        return trans


def untranslate(trans, prepend=1):
    filler = &quot;a:b:c:&quot;
    if prepend == 1:
        context = &quot;%s%s&quot; % (filler, trans)
    else:
        context = trans

    (rc, raw) = selinux.selinux_trans_to_raw_context(context)
    if rc != 0:
        return trans
    if prepend:
        raw = raw[len(filler):]
    if raw == &quot;&quot;:
        return trans
    else:
        return raw


class semanageRecords:
    transaction = False
    handle = None
    store = None
    args = None

    def __init__(self, args = None):
        global handle
        if args:
            # legacy code - args was store originally
            if isinstance(args, str):
                self.store = args
            else:
                self.args = args
        self.noreload = getattr(args, &quot;noreload&quot;, False)
        if not self.store:
            self.store = getattr(args, &quot;store&quot;, &quot;&quot;)

        self.sh = self.get_handle(self.store)

        rc, localstore = selinux.selinux_getpolicytype()
        if self.store == &quot;&quot; or self.store == localstore:
            self.mylog = logger()
        else:
            sepolicy.load_store_policy(self.store)
            selinux.selinux_set_policy_root(&quot;%s%s&quot; % (selinux.selinux_path(), self.store))
            self.mylog = nulllogger()

    def set_reload(self, load):
        self.noreload = not load

    def get_handle(self, store):
        global is_mls_enabled

        if semanageRecords.handle:
            return semanageRecords.handle

        handle = semanage_handle_create()
        if not handle:
            raise ValueError(_(&quot;Could not create semanage handle&quot;))

        if not semanageRecords.transaction and store != &quot;&quot;:
            semanage_select_store(handle, store, SEMANAGE_CON_DIRECT)
            semanageRecords.store = store

        if not semanage_is_managed(handle):
            semanage_handle_destroy(handle)
            raise ValueError(_(&quot;SELinux policy is not managed or store cannot be accessed.&quot;))

        rc = semanage_access_check(handle)
        if rc &lt; SEMANAGE_CAN_READ:
            semanage_handle_destroy(handle)
            raise ValueError(_(&quot;Cannot read policy store.&quot;))

        rc = semanage_connect(handle)
        if rc &lt; 0:
            semanage_handle_destroy(handle)
            raise ValueError(_(&quot;Could not establish semanage connection&quot;))

        is_mls_enabled = semanage_mls_enabled(handle)
        if is_mls_enabled &lt; 0:
            semanage_handle_destroy(handle)
            raise ValueError(_(&quot;Could not test MLS enabled status&quot;))

        semanageRecords.handle = handle
        return semanageRecords.handle

    def deleteall(self):
        raise ValueError(_(&quot;Not yet implemented&quot;))

    def start(self):
        if semanageRecords.transaction:
            raise ValueError(_(&quot;Semanage transaction already in progress&quot;))
        self.begin()
        semanageRecords.transaction = True

    def begin(self):
        if semanageRecords.transaction:
            return
        rc = semanage_begin_transaction(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not start semanage transaction&quot;))

    def customized(self):
        raise ValueError(_(&quot;Not yet implemented&quot;))

    def commit(self):
        if semanageRecords.transaction:
            return

        if self.noreload:
            semanage_set_reload(self.sh, 0)
        rc = semanage_commit(self.sh)
        if rc &lt; 0:
            self.mylog.commit(0)
            raise ValueError(_(&quot;Could not commit semanage transaction&quot;))
        self.mylog.commit(1)

    def finish(self):
        if not semanageRecords.transaction:
            raise ValueError(_(&quot;Semanage transaction not in progress&quot;))
        semanageRecords.transaction = False
        self.commit()


class moduleRecords(semanageRecords):

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)

    def get_all(self):
        l = []
        (rc, mlist, number) = semanage_module_list_all(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list SELinux modules&quot;))

        for i in range(number):
            mod = semanage_module_list_nth(mlist, i)

            rc, name = semanage_module_info_get_name(self.sh, mod)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not get module name&quot;))

            rc, enabled = semanage_module_info_get_enabled(self.sh, mod)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not get module enabled&quot;))

            rc, priority = semanage_module_info_get_priority(self.sh, mod)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not get module priority&quot;))

            rc, lang_ext = semanage_module_info_get_lang_ext(self.sh, mod)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not get module lang_ext&quot;))

            l.append((name, enabled, priority, lang_ext))

        # sort the list so they are in name order, but with higher priorities coming first
        l.sort(key=lambda t: t[3], reverse=True)
        l.sort(key=lambda t: t[0])
        return l

    def customized(self):
        all = self.get_all()
        if len(all) == 0:
            return []
        return [&quot;-d %s&quot; % x[0] for x in [t for t in all if t[1] == 0]]

    def list(self, heading=1, locallist=0):
        all = self.get_all()
        if len(all) == 0:
            return

        if heading:
            print(&quot;\n%-25s %-9s %s\n&quot; % (_(&quot;Module Name&quot;), _(&quot;Priority&quot;), _(&quot;Language&quot;)))
        for t in all:
            if t[1] == 0:
                disabled = _(&quot;Disabled&quot;)
            else:
                if locallist:
                    continue
                disabled = &quot;&quot;
            print(&quot;%-25s %-9s %-5s %s&quot; % (t[0], t[2], t[3], disabled))

    def add(self, file, priority):
        if not os.path.exists(file):
            raise ValueError(_(&quot;Module does not exist: %s &quot;) % file)

        rc = semanage_set_default_priority(self.sh, priority)
        if rc &lt; 0:
            raise ValueError(_(&quot;Invalid priority %d (needs to be between 1 and 999)&quot;) % priority)

        rc = semanage_module_install_file(self.sh, file)
        if rc &gt;= 0:
            self.commit()

    def set_enabled(self, module, enable):
        for m in module.split():
            rc, key = semanage_module_key_create(self.sh)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not create module key&quot;))

            rc = semanage_module_key_set_name(self.sh, key, m)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set module key name&quot;))

            rc = semanage_module_set_enabled(self.sh, key, enable)
            if rc &lt; 0:
                if enable:
                    raise ValueError(_(&quot;Could not enable module %s&quot;) % m)
                else:
                    raise ValueError(_(&quot;Could not disable module %s&quot;) % m)
        self.commit()

    def delete(self, module, priority):
        rc = semanage_set_default_priority(self.sh, priority)
        if rc &lt; 0:
            raise ValueError(_(&quot;Invalid priority %d (needs to be between 1 and 999)&quot;) % priority)

        for m in module.split():
            rc = semanage_module_remove(self.sh, m)
            if rc &lt; 0 and rc != -2:
                raise ValueError(_(&quot;Could not remove module %s (remove failed)&quot;) % m)

        self.commit()

    def deleteall(self):
        l = [x[0] for x in [t for t in self.get_all() if t[1] == 0]]
        for m in l:
            self.set_enabled(m, True)


class dontauditClass(semanageRecords):

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)

    def toggle(self, dontaudit):
        if dontaudit not in [&quot;on&quot;, &quot;off&quot;]:
            raise ValueError(_(&quot;dontaudit requires either &#039;on&#039; or &#039;off&#039;&quot;))
        self.begin()
        semanage_set_disable_dontaudit(self.sh, dontaudit == &quot;off&quot;)
        self.commit()


class permissiveRecords(semanageRecords):

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)

    def get_all(self):
        l = []
        (rc, mlist, number) = semanage_module_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list SELinux modules&quot;))

        for i in range(number):
            mod = semanage_module_list_nth(mlist, i)
            name = semanage_module_get_name(mod)
            if name and name.startswith(&quot;permissive_&quot;):
                l.append(name.split(&quot;permissive_&quot;)[1])
        return l

    def customized(self):
        return [&quot;-a %s&quot; % x for x in sorted(self.get_all())]

    def list(self, heading=1, locallist=0):
        all = [y[&quot;name&quot;] for y in [x for x in sepolicy.info(sepolicy.TYPE) if x[&quot;permissive&quot;]]]
        if len(all) == 0:
            return

        if heading:
            print(&quot;\n%-25s\n&quot; % (_(&quot;Builtin Permissive Types&quot;)))
        customized = self.get_all()
        for t in all:
            if t not in customized:
                print(t)

        if len(customized) == 0:
            return

        if heading:
            print(&quot;\n%-25s\n&quot; % (_(&quot;Customized Permissive Types&quot;)))
        for t in customized:
            print(t)

    def add(self, type):
        name = &quot;permissive_%s&quot; % type
        modtxt = &quot;(typepermissive %s)&quot; % type

        rc = semanage_module_install(self.sh, modtxt, len(modtxt), name, &quot;cil&quot;)
        if rc &gt;= 0:
            self.commit()

        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set permissive domain %s (module installation failed)&quot;) % name)

    def delete(self, name):
        for n in name.split():
            rc = semanage_module_remove(self.sh, &quot;permissive_%s&quot; % n)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not remove permissive domain %s (remove failed)&quot;) % name)

        self.commit()

    def deleteall(self):
        l = self.get_all()
        if len(l) &gt; 0:
            all = &quot; &quot;.join(l)
            self.delete(all)


class loginRecords(semanageRecords):

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)
        self.oldsename = None
        self.oldserange = None
        self.sename = None
        self.serange = None

    def __add(self, name, sename, serange):
        rec, self.oldsename, self.oldserange = selinux.getseuserbyname(name)
        if sename == &quot;&quot;:
            sename = &quot;user_u&quot;

        userrec = seluserRecords(self.args)
        range, (rc, oldserole) = userrec.get(self.oldsename)
        range, (rc, serole) = userrec.get(sename)

        if is_mls_enabled == 1:
            if serange != &quot;&quot;:
                serange = untranslate(serange)
            else:
                serange = range

        (rc, k) = semanage_seuser_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        if name[0] == &#039;%&#039;:
            try:
                grp.getgrnam(name[1:])
            except:
                raise ValueError(_(&quot;Linux Group %s does not exist&quot;) % name[1:])
        else:
            try:
                pwd.getpwnam(name)
            except:
                raise ValueError(_(&quot;Linux User %s does not exist&quot;) % name)

        (rc, u) = semanage_seuser_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create login mapping for %s&quot;) % name)

        rc = semanage_seuser_set_name(self.sh, u, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set name for %s&quot;) % name)

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            rc = semanage_seuser_set_mlsrange(self.sh, u, serange)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set MLS range for %s&quot;) % name)

        rc = semanage_seuser_set_sename(self.sh, u, sename)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set SELinux user for %s&quot;) % name)

        rc = semanage_seuser_modify_local(self.sh, k, u)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add login mapping for %s&quot;) % name)

        semanage_seuser_key_free(k)
        semanage_seuser_free(u)

    def add(self, name, sename, serange):
        try:
            self.begin()
            # Add a new mapping, or modify an existing one
            if self.__exists(name):
                print(_(&quot;Login mapping for %s is already defined, modifying instead&quot;) % name)
                self.__modify(name, sename, serange)
            else:
                self.__add(name, sename, serange)
            self.commit()
        except ValueError as error:
            raise error

    # check if login mapping for given user exists
    def __exists(self, name):
        (rc, k) = semanage_seuser_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        (rc, exists) = semanage_seuser_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if login mapping for %s is defined&quot;) % name)
        semanage_seuser_key_free(k)

        return exists

    def __modify(self, name, sename=&quot;&quot;, serange=&quot;&quot;):
        rec, self.oldsename, self.oldserange = selinux.getseuserbyname(name)
        if sename == &quot;&quot; and serange == &quot;&quot;:
            raise ValueError(_(&quot;Requires seuser or serange&quot;))

        userrec = seluserRecords(self.args)
        range, (rc, oldserole) = userrec.get(self.oldsename)

        if sename != &quot;&quot;:
            range, (rc, serole) = userrec.get(sename)
        else:
            serole = oldserole

        if serange != &quot;&quot;:
            self.serange = serange
        else:
            self.serange = range

        (rc, k) = semanage_seuser_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        (rc, exists) = semanage_seuser_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if login mapping for %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;Login mapping for %s is not defined&quot;) % name)

        (rc, u) = semanage_seuser_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query seuser for %s&quot;) % name)

        self.oldserange = semanage_seuser_get_mlsrange(u)
        self.oldsename = semanage_seuser_get_sename(u)
        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            semanage_seuser_set_mlsrange(self.sh, u, untranslate(serange))

        if sename != &quot;&quot;:
            semanage_seuser_set_sename(self.sh, u, sename)
            self.sename = sename
        else:
            self.sename = self.oldsename

        rc = semanage_seuser_modify_local(self.sh, k, u)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify login mapping for %s&quot;) % name)

        semanage_seuser_key_free(k)
        semanage_seuser_free(u)

    def modify(self, name, sename=&quot;&quot;, serange=&quot;&quot;):
        try:
            self.begin()
            self.__modify(name, sename, serange)
            self.commit()
        except ValueError as error:
            raise error

    def __delete(self, name):
        rec, self.oldsename, self.oldserange = selinux.getseuserbyname(name)
        userrec = seluserRecords(self.args)
        range, (rc, oldserole) = userrec.get(self.oldsename)

        (rc, k) = semanage_seuser_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        (rc, exists) = semanage_seuser_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if login mapping for %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;Login mapping for %s is not defined&quot;) % name)

        (rc, exists) = semanage_seuser_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if login mapping for %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;Login mapping for %s is defined in policy, cannot be deleted&quot;) % name)

        rc = semanage_seuser_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete login mapping for %s&quot;) % name)

        semanage_seuser_key_free(k)

        rec, self.sename, self.serange = selinux.getseuserbyname(&quot;__default__&quot;)
        range, (rc, serole) = userrec.get(self.sename)

    def delete(self, name):
        try:
            self.begin()
            self.__delete(name)
            self.commit()

        except ValueError as error:
            raise error

    def deleteall(self):
        (rc, ulist) = semanage_seuser_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list login mappings&quot;))

        try:
            self.begin()
            for u in ulist:
                self.__delete(semanage_seuser_get_name(u))
            self.commit()
        except ValueError as error:
            raise error

    def get_all_logins(self):
        ddict = {}
        self.logins_path = selinux.selinux_policy_root() + &quot;/logins&quot;
        for path, dirs, files in os.walk(self.logins_path):
            if path == self.logins_path:
                for name in files:
                    try:
                        fd = open(path + &quot;/&quot; + name)
                        rec = fd.read().rstrip().split(&quot;:&quot;)
                        fd.close()
                        ddict[name] = (rec[1], rec[2], rec[0])
                    except IndexError:
                        pass
        return ddict

    def get_all(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.ulist) = semanage_seuser_list_local(self.sh)
        else:
            (rc, self.ulist) = semanage_seuser_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list login mappings&quot;))

        for u in self.ulist:
            name = semanage_seuser_get_name(u)
            ddict[name] = (semanage_seuser_get_sename(u), semanage_seuser_get_mlsrange(u), &quot;*&quot;)
        return ddict

    def customized(self):
        l = []
        ddict = self.get_all(True)
        for k in sorted(ddict.keys()):
            if ddict[k][1]:
                l.append(&quot;-a -s %s -r &#039;%s&#039; %s&quot; % (ddict[k][0], ddict[k][1], k))
            else:
                l.append(&quot;-a -s %s %s&quot; % (ddict[k][0], k))
        return l

    def list(self, heading=1, locallist=0):
        ddict = self.get_all(locallist)
        ldict = self.get_all_logins()
        lkeys = sorted(ldict.keys())
        keys = sorted(ddict.keys())
        if len(keys) == 0 and len(lkeys) == 0:
            return

        if is_mls_enabled == 1:
            if heading:
                print(&quot;\n%-20s %-20s %-20s %s\n&quot; % (_(&quot;Login Name&quot;), _(&quot;SELinux User&quot;), _(&quot;MLS/MCS Range&quot;), _(&quot;Service&quot;)))
            for k in keys:
                u = ddict[k]
                print(&quot;%-20s %-20s %-20s %s&quot; % (k, u[0], translate(u[1]), u[2]))
            if len(lkeys):
                print(&quot;\nLocal customization in %s&quot; % self.logins_path)

            for k in lkeys:
                u = ldict[k]
                print(&quot;%-20s %-20s %-20s %s&quot; % (k, u[0], translate(u[1]), u[2]))
        else:
            if heading:
                print(&quot;\n%-25s %-25s\n&quot; % (_(&quot;Login Name&quot;), _(&quot;SELinux User&quot;)))
            for k in keys:
                print(&quot;%-25s %-25s&quot; % (k, ddict[k][0]))


class seluserRecords(semanageRecords):

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)

    def get(self, name):
        (rc, k) = semanage_user_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)
        (rc, exists) = semanage_user_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if SELinux user %s is defined&quot;) % name)
        (rc, u) = semanage_user_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query user for %s&quot;) % name)
        serange = semanage_user_get_mlsrange(u)
        serole = semanage_user_get_roles(self.sh, u)
        semanage_user_key_free(k)
        semanage_user_free(u)
        return serange, serole

    def __add(self, name, roles, selevel, serange, prefix):
        if is_mls_enabled == 1:
            if serange == &quot;&quot;:
                serange = &quot;s0&quot;
            else:
                serange = untranslate(serange)

            if selevel == &quot;&quot;:
                selevel = &quot;s0&quot;
            else:
                selevel = untranslate(selevel)

        if len(roles) &lt; 1:
            raise ValueError(_(&quot;You must add at least one role for %s&quot;) % name)

        (rc, k) = semanage_user_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        (rc, u) = semanage_user_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create SELinux user for %s&quot;) % name)

        rc = semanage_user_set_name(self.sh, u, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set name for %s&quot;) % name)

        for r in roles:
            rc = semanage_user_add_role(self.sh, u, r)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not add role {role} for {name}&quot;).format(role=r, name=name))

        if is_mls_enabled == 1:
            rc = semanage_user_set_mlsrange(self.sh, u, serange)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set MLS range for %s&quot;) % name)

            rc = semanage_user_set_mlslevel(self.sh, u, selevel)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set MLS level for %s&quot;) % name)
        rc = semanage_user_set_prefix(self.sh, u, prefix)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add prefix {prefix} for {role}&quot;).format(role=r, prefix=prefix))
        (rc, key) = semanage_user_key_extract(self.sh, u)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not extract key for %s&quot;) % name)

        rc = semanage_user_modify_local(self.sh, k, u)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add SELinux user %s&quot;) % name)

        semanage_user_key_free(k)
        semanage_user_free(u)
        self.mylog.log(&quot;seuser&quot;, sename=name, serole=&quot;,&quot;.join(roles), serange=serange)

    def add(self, name, roles, selevel, serange, prefix):
        try:
            self.begin()
            if self.__exists(name):
                print(_(&quot;SELinux user %s is already defined, modifying instead&quot;) % name)
                self.__modify(name, roles, selevel, serange, prefix)
            else:
                self.__add(name, roles, selevel, serange, prefix)
            self.commit()
        except ValueError as error:
            self.mylog.commit(0)
            raise error

    def __exists(self, name):
        (rc, k) = semanage_user_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        (rc, exists) = semanage_user_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if SELinux user %s is defined&quot;) % name)
        semanage_user_key_free(k)

        return exists

    def __modify(self, name, roles=[], selevel=&quot;&quot;, serange=&quot;&quot;, prefix=&quot;&quot;):
        oldserole = &quot;&quot;
        oldserange = &quot;&quot;
        newroles = &quot; &quot;.join(roles)
        if prefix == &quot;&quot; and len(roles) == 0 and serange == &quot;&quot; and selevel == &quot;&quot;:
            if is_mls_enabled == 1:
                raise ValueError(_(&quot;Requires prefix, roles, level or range&quot;))
            else:
                raise ValueError(_(&quot;Requires prefix or roles&quot;))

        (rc, k) = semanage_user_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        (rc, exists) = semanage_user_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if SELinux user %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;SELinux user %s is not defined&quot;) % name)

        (rc, u) = semanage_user_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query user for %s&quot;) % name)

        oldserange = semanage_user_get_mlsrange(u)
        (rc, rlist) = semanage_user_get_roles(self.sh, u)
        if rc &gt;= 0:
            oldserole = &quot; &quot;.join(rlist)

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            semanage_user_set_mlsrange(self.sh, u, untranslate(serange))
        if (is_mls_enabled == 1) and (selevel != &quot;&quot;):
            semanage_user_set_mlslevel(self.sh, u, untranslate(selevel))

        if prefix != &quot;&quot;:
            semanage_user_set_prefix(self.sh, u, prefix)

        if len(roles) != 0:
            for r in rlist:
                if r not in roles:
                    semanage_user_del_role(u, r)
            for r in roles:
                if r not in rlist:
                    semanage_user_add_role(self.sh, u, r)

        rc = semanage_user_modify_local(self.sh, k, u)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify SELinux user %s&quot;) % name)

        semanage_user_key_free(k)
        semanage_user_free(u)

        role = &quot;,&quot;.join(newroles.split())
        oldserole = &quot;,&quot;.join(oldserole.split())
        self.mylog.log(&quot;seuser&quot;, sename=name, oldsename=name, serole=role, serange=serange, oldserole=oldserole, oldserange=oldserange)

    def modify(self, name, roles=[], selevel=&quot;&quot;, serange=&quot;&quot;, prefix=&quot;&quot;):
        try:
            self.begin()
            self.__modify(name, roles, selevel, serange, prefix)
            self.commit()
        except ValueError as error:
            self.mylog.commit(0)
            raise error

    def __delete(self, name):
        (rc, k) = semanage_user_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        (rc, exists) = semanage_user_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if SELinux user %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;SELinux user %s is not defined&quot;) % name)

        (rc, exists) = semanage_user_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if SELinux user %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;SELinux user %s is defined in policy, cannot be deleted&quot;) % name)

        (rc, u) = semanage_user_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query user for %s&quot;) % name)
        oldserange = semanage_user_get_mlsrange(u)
        (rc, rlist) = semanage_user_get_roles(self.sh, u)
        oldserole = &quot;,&quot;.join(rlist)

        rc = semanage_user_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete SELinux user %s&quot;) % name)

        semanage_user_key_free(k)
        semanage_user_free(u)

        self.mylog.log_remove(&quot;seuser&quot;, oldsename=name, oldserange=oldserange, oldserole=oldserole)

    def delete(self, name):
        try:
            self.begin()
            self.__delete(name)
            self.commit()

        except ValueError as error:
            self.mylog.commit(0)
            raise error

    def deleteall(self):
        (rc, ulist) = semanage_user_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list login mappings&quot;))

        try:
            self.begin()
            for u in ulist:
                self.__delete(semanage_user_get_name(u))
            self.commit()
        except ValueError as error:
            self.mylog.commit(0)
            raise error

    def get_all(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.ulist) = semanage_user_list_local(self.sh)
        else:
            (rc, self.ulist) = semanage_user_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list SELinux users&quot;))

        for u in self.ulist:
            name = semanage_user_get_name(u)
            (rc, rlist) = semanage_user_get_roles(self.sh, u)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not list roles for user %s&quot;) % name)

            roles = &quot; &quot;.join(rlist)
            ddict[semanage_user_get_name(u)] = (semanage_user_get_prefix(u), semanage_user_get_mlslevel(u), semanage_user_get_mlsrange(u), roles)

        return ddict

    def customized(self):
        l = []
        ddict = self.get_all(True)
        for k in sorted(ddict.keys()):
            if ddict[k][1] or ddict[k][2]:
                l.append(&quot;-a -L %s -r %s -R &#039;%s&#039; %s&quot; % (ddict[k][1], ddict[k][2], ddict[k][3], k))
            else:
                l.append(&quot;-a -R &#039;%s&#039; %s&quot; % (ddict[k][3], k))
        return l

    def list(self, heading=1, locallist=0):
        ddict = self.get_all(locallist)
        if len(ddict) == 0:
            return
        keys = sorted(ddict.keys())

        if is_mls_enabled == 1:
            if heading:
                print(&quot;\n%-15s %-10s %-10s %-30s&quot; % (&quot;&quot;, _(&quot;Labeling&quot;), _(&quot;MLS/&quot;), _(&quot;MLS/&quot;)))
                print(&quot;%-15s %-10s %-10s %-30s %s\n&quot; % (_(&quot;SELinux User&quot;), _(&quot;Prefix&quot;), _(&quot;MCS Level&quot;), _(&quot;MCS Range&quot;), _(&quot;SELinux Roles&quot;)))
            for k in keys:
                print(&quot;%-15s %-10s %-10s %-30s %s&quot; % (k, ddict[k][0], translate(ddict[k][1]), translate(ddict[k][2]), ddict[k][3]))
        else:
            if heading:
                print(&quot;%-15s %s\n&quot; % (_(&quot;SELinux User&quot;), _(&quot;SELinux Roles&quot;)))
            for k in keys:
                print(&quot;%-15s %s&quot; % (k, ddict[k][3]))


class portRecords(semanageRecords):

    valid_types = []

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)
        try:
            self.valid_types = list(list(sepolicy.info(sepolicy.ATTRIBUTE, &quot;port_type&quot;))[0][&quot;types&quot;])
        except RuntimeError:
            pass

    def __genkey(self, port, proto):
        protocols = {&quot;tcp&quot;: SEMANAGE_PROTO_TCP,
                     &quot;udp&quot;: SEMANAGE_PROTO_UDP,
                     &quot;sctp&quot;: SEMANAGE_PROTO_SCTP,
                     &quot;dccp&quot;: SEMANAGE_PROTO_DCCP}

        if proto in protocols.keys():
            proto_d = protocols[proto]
        else:
            raise ValueError(_(&quot;Protocol has to be one of udp, tcp, dccp or sctp&quot;))
        if port == &quot;&quot;:
            raise ValueError(_(&quot;Port is required&quot;))

        if isinstance(port, str):
            ports = port.split(&#039;-&#039;, 1)
        else:
            ports = (port,)

        if len(ports) == 1:
            high = low = int(ports[0])
        else:
            low = int(ports[0])
            high = int(ports[1])

        if high &gt; 65535:
            raise ValueError(_(&quot;Invalid Port&quot;))

        (rc, k) = semanage_port_key_create(self.sh, low, high, proto_d)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for {proto}/{port}&quot;).format(proto=proto, port=port))
        return (k, proto_d, low, high)

    def __add(self, port, proto, serange, type):
        if is_mls_enabled == 1:
            if serange == &quot;&quot;:
                serange = &quot;s0&quot;
            else:
                serange = untranslate(serange)

        if type == &quot;&quot;:
            raise ValueError(_(&quot;Type is required&quot;))

        type = sepolicy.get_real_type_name(type)

        if type not in self.valid_types:
            raise ValueError(_(&quot;Type %s is invalid, must be a port type&quot;) % type)

        (k, proto_d, low, high) = self.__genkey(port, proto)

        (rc, p) = semanage_port_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create port for {proto}/{port}&quot;).format(proto=proto, port=port))

        semanage_port_set_proto(p, proto_d)
        semanage_port_set_range(p, low, high)
        (rc, con) = semanage_context_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create context for {proto}/{port}&quot;).format(proto=proto, port=port))

        rc = semanage_context_set_user(self.sh, con, &quot;system_u&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set user in port context for {proto}/{port}&quot;).format(proto=proto, port=port))

        rc = semanage_context_set_role(self.sh, con, &quot;object_r&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set role in port context for {proto}/{port}&quot;).format(proto=proto, port=port))

        rc = semanage_context_set_type(self.sh, con, type)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set type in port context for {proto}/{port}&quot;).format(proto=proto, port=port))

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            rc = semanage_context_set_mls(self.sh, con, serange)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set mls fields in port context for {proto}/{port}&quot;).format(proto=proto, port=port))

        rc = semanage_port_set_con(self.sh, p, con)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set port context for {proto}/{port}&quot;).format(proto=proto, port=port))

        rc = semanage_port_modify_local(self.sh, k, p)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add port {proto}/{port}&quot;).format(proto=proto, port=port))

        semanage_context_free(con)
        semanage_port_key_free(k)
        semanage_port_free(p)

        self.mylog.log_change(&quot;resrc=port op=add lport=%s proto=%s tcontext=%s:%s:%s:%s&quot; % (port, socket.getprotobyname(proto), &quot;system_u&quot;, &quot;object_r&quot;, type, serange))

    def add(self, port, proto, serange, type):
        self.begin()
        if self.__exists(port, proto):
            print(_(&quot;Port {proto}/{port} already defined, modifying instead&quot;).format(proto=proto, port=port))
            self.__modify(port, proto, serange, type)
        else:
            self.__add(port, proto, serange, type)
        self.commit()

    def __exists(self, port, proto):
        (k, proto_d, low, high) = self.__genkey(port, proto)

        (rc, exists) = semanage_port_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if port {proto}/{port} is defined&quot;).format(proto=proto, port=port))
        semanage_port_key_free(k)

        return exists

    def __modify(self, port, proto, serange, setype):
        if serange == &quot;&quot; and setype == &quot;&quot;:
            if is_mls_enabled == 1:
                raise ValueError(_(&quot;Requires setype or serange&quot;))
            else:
                raise ValueError(_(&quot;Requires setype&quot;))

        setype = sepolicy.get_real_type_name(setype)
        if setype and setype not in self.valid_types:
            raise ValueError(_(&quot;Type %s is invalid, must be a port type&quot;) % setype)

        (k, proto_d, low, high) = self.__genkey(port, proto)

        (rc, exists) = semanage_port_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if port {proto}/{port} is defined&quot;).format(proto=proto, port=port))
        if not exists:
            raise ValueError(_(&quot;Port {proto}/{port} is not defined&quot;).format(proto=proto, port=port))

        (rc, p) = semanage_port_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query port {proto}/{port}&quot;).format(proto=proto, port=port))

        con = semanage_port_get_con(p)

        if is_mls_enabled == 1:
            if serange == &quot;&quot;:
                serange = &quot;s0&quot;
            else:
                semanage_context_set_mls(self.sh, con, untranslate(serange))
        if setype != &quot;&quot;:
            semanage_context_set_type(self.sh, con, setype)

        rc = semanage_port_modify_local(self.sh, k, p)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify port {proto}/{port}&quot;).format(proto=proto, port=port))

        semanage_port_key_free(k)
        semanage_port_free(p)

        self.mylog.log_change(&quot;resrc=port op=modify lport=%s proto=%s tcontext=%s:%s:%s:%s&quot; % (port, socket.getprotobyname(proto), &quot;system_u&quot;, &quot;object_r&quot;, setype, serange))

    def modify(self, port, proto, serange, setype):
        self.begin()
        self.__modify(port, proto, serange, setype)
        self.commit()

    def deleteall(self):
        (rc, plist) = semanage_port_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list the ports&quot;))

        self.begin()

        for port in plist:
            proto = semanage_port_get_proto(port)
            proto_str = semanage_port_get_proto_str(proto)
            low = semanage_port_get_low(port)
            high = semanage_port_get_high(port)
            port_str = &quot;%s-%s&quot; % (low, high)

            (k, proto_d, low, high) = self.__genkey(port_str, proto_str)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not create a key for %s&quot;) % port_str)

            rc = semanage_port_del_local(self.sh, k)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not delete the port %s&quot;) % port_str)
            semanage_port_key_free(k)

            if low == high:
                port_str = low

            self.mylog.log_change(&quot;resrc=port op=delete lport=%s proto=%s&quot; % (port_str, socket.getprotobyname(proto_str)))

        self.commit()

    def __delete(self, port, proto):
        (k, proto_d, low, high) = self.__genkey(port, proto)
        (rc, exists) = semanage_port_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if port {proto}/{port} is defined&quot;).format(proto=proto, port=port))
        if not exists:
            raise ValueError(_(&quot;Port {proto}/{port} is not defined&quot;).format(proto=proto, port=port))

        (rc, exists) = semanage_port_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if port {proto}/{port} is defined&quot;).format(proto=proto, port=port))
        if not exists:
            raise ValueError(_(&quot;Port {proto}/{port} is defined in policy, cannot be deleted&quot;).format(proto=proto, port=port))

        rc = semanage_port_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete port {proto}/{port}&quot;).format(proto=proto, port=port))

        semanage_port_key_free(k)

        self.mylog.log_change(&quot;resrc=port op=delete lport=%s proto=%s&quot; % (port, socket.getprotobyname(proto)))

    def delete(self, port, proto):
        self.begin()
        self.__delete(port, proto)
        self.commit()

    def get_all(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.plist) = semanage_port_list_local(self.sh)
        else:
            (rc, self.plist) = semanage_port_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list ports&quot;))

        for port in self.plist:
            con = semanage_port_get_con(port)
            ctype = semanage_context_get_type(con)
            level = semanage_context_get_mls(con)
            proto = semanage_port_get_proto(port)
            proto_str = semanage_port_get_proto_str(proto)
            low = semanage_port_get_low(port)
            high = semanage_port_get_high(port)
            ddict[(low, high, proto_str)] = (ctype, level)
        return ddict

    def get_all_by_type(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.plist) = semanage_port_list_local(self.sh)
        else:
            (rc, self.plist) = semanage_port_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list ports&quot;))

        for port in self.plist:
            con = semanage_port_get_con(port)
            ctype = semanage_context_get_type(con)
            proto = semanage_port_get_proto(port)
            proto_str = semanage_port_get_proto_str(proto)
            low = semanage_port_get_low(port)
            high = semanage_port_get_high(port)
            if (ctype, proto_str) not in ddict.keys():
                ddict[(ctype, proto_str)] = []
            if low == high:
                ddict[(ctype, proto_str)].append(&quot;%d&quot; % low)
            else:
                ddict[(ctype, proto_str)].append(&quot;%d-%d&quot; % (low, high))
        return ddict

    def customized(self):
        l = []
        ddict = self.get_all(True)
        for k in sorted(ddict.keys()):
            port = k[0] if k[0] == k[1] else &quot;%s-%s&quot; % (k[0], k[1])
            if ddict[k][1]:
                l.append(&quot;-a -t %s -r &#039;%s&#039; -p %s %s&quot; % (ddict[k][0], ddict[k][1], k[2], port))
            else:
                l.append(&quot;-a -t %s -p %s %s&quot; % (ddict[k][0], k[2], port))
        return l

    def list(self, heading=1, locallist=0):
        ddict = self.get_all_by_type(locallist)
        if len(ddict) == 0:
            return
        keys = sorted(ddict.keys())

        if heading:
            print(&quot;%-30s %-8s %s\n&quot; % (_(&quot;SELinux Port Type&quot;), _(&quot;Proto&quot;), _(&quot;Port Number&quot;)))
        for i in keys:
            rec = &quot;%-30s %-8s &quot; % i
            rec += &quot;%s&quot; % ddict[i][0]
            for p in ddict[i][1:]:
                rec += &quot;, %s&quot; % p
            print(rec)

class ibpkeyRecords(semanageRecords):

    valid_types = []

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)
        try:
            q = TypeQuery(SELinuxPolicy(sepolicy.get_store_policy(self.store)), attrs=[&quot;ibpkey_type&quot;])
            self.valid_types = sorted(str(t) for t in q.results())
        except:
            pass

    def __genkey(self, pkey, subnet_prefix):
        if subnet_prefix == &quot;&quot;:
            raise ValueError(_(&quot;Subnet Prefix is required&quot;))

        pkeys = pkey.split(&quot;-&quot;)
        if len(pkeys) == 1:
            high = low = int(pkeys[0], 0)
        else:
            low = int(pkeys[0], 0)
            high = int(pkeys[1], 0)

        if high &gt; 65535:
            raise ValueError(_(&quot;Invalid Pkey&quot;))

        (rc, k) = semanage_ibpkey_key_create(self.sh, subnet_prefix, low, high)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))
        return (k, subnet_prefix, low, high)

    def __add(self, pkey, subnet_prefix, serange, type):
        if is_mls_enabled == 1:
            if serange == &quot;&quot;:
                serange = &quot;s0&quot;
            else:
                serange = untranslate(serange)

        if type == &quot;&quot;:
            raise ValueError(_(&quot;Type is required&quot;))

        type = sepolicy.get_real_type_name(type)

        if type not in self.valid_types:
            raise ValueError(_(&quot;Type %s is invalid, must be a ibpkey type&quot;) % type)

        (k, subnet_prefix, low, high) = self.__genkey(pkey, subnet_prefix)

        (rc, p) = semanage_ibpkey_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create ibpkey for {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        semanage_ibpkey_set_subnet_prefix(self.sh, p, subnet_prefix)
        semanage_ibpkey_set_range(p, low, high)
        (rc, con) = semanage_context_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create context for {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        rc = semanage_context_set_user(self.sh, con, &quot;system_u&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set user in ibpkey context for {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        rc = semanage_context_set_role(self.sh, con, &quot;object_r&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set role in ibpkey context for {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        rc = semanage_context_set_type(self.sh, con, type)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set type in ibpkey context for {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            rc = semanage_context_set_mls(self.sh, con, serange)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set mls fields in ibpkey context for {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        rc = semanage_ibpkey_set_con(self.sh, p, con)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set ibpkey context for {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        rc = semanage_ibpkey_modify_local(self.sh, k, p)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add ibpkey {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        semanage_context_free(con)
        semanage_ibpkey_key_free(k)
        semanage_ibpkey_free(p)

    def add(self, pkey, subnet_prefix, serange, type):
        self.begin()
        if self.__exists(pkey, subnet_prefix):
            print(_(&quot;ibpkey {subnet_prefix}/{pkey} already defined, modifying instead&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))
            self.__modify(pkey, subnet_prefix, serange, type)
        else:
            self.__add(pkey, subnet_prefix, serange, type)
        self.commit()

    def __exists(self, pkey, subnet_prefix):
        (k, subnet_prefix, low, high) = self.__genkey(pkey, subnet_prefix)

        (rc, exists) = semanage_ibpkey_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if ibpkey {subnet_prefix}/{pkey} is defined&quot;).formnat(subnet_prefix=subnet_prefix, pkey=pkey))
        semanage_ibpkey_key_free(k)

        return exists

    def __modify(self, pkey, subnet_prefix, serange, setype):
        if serange == &quot;&quot; and setype == &quot;&quot;:
            if is_mls_enabled == 1:
                raise ValueError(_(&quot;Requires setype or serange&quot;))
            else:
                raise ValueError(_(&quot;Requires setype&quot;))

        setype = sepolicy.get_real_type_name(setype)

        if setype and setype not in self.valid_types:
            raise ValueError(_(&quot;Type %s is invalid, must be a ibpkey type&quot;) % setype)

        (k, subnet_prefix, low, high) = self.__genkey(pkey, subnet_prefix)

        (rc, exists) = semanage_ibpkey_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if ibpkey {subnet_prefix}/{pkey} is defined&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))
        if not exists:
            raise ValueError(_(&quot;ibpkey {subnet_prefix}/{pkey} is not defined&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        (rc, p) = semanage_ibpkey_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query ibpkey {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        con = semanage_ibpkey_get_con(p)

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            semanage_context_set_mls(self.sh, con, untranslate(serange))
        if setype != &quot;&quot;:
            semanage_context_set_type(self.sh, con, setype)

        rc = semanage_ibpkey_modify_local(self.sh, k, p)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify ibpkey {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        semanage_ibpkey_key_free(k)
        semanage_ibpkey_free(p)

    def modify(self, pkey, subnet_prefix, serange, setype):
        self.begin()
        self.__modify(pkey, subnet_prefix, serange, setype)
        self.commit()

    def deleteall(self):
        (rc, plist) = semanage_ibpkey_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list the ibpkeys&quot;))

        self.begin()

        for ibpkey in plist:
            (rc, subnet_prefix) = semanage_ibpkey_get_subnet_prefix(self.sh, ibpkey)
            low = semanage_ibpkey_get_low(ibpkey)
            high = semanage_ibpkey_get_high(ibpkey)
            pkey_str = &quot;%s-%s&quot; % (low, high)
            (k, subnet_prefix, low, high) = self.__genkey(pkey_str, subnet_prefix)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not create a key for %s&quot;) % pkey_str)

            rc = semanage_ibpkey_del_local(self.sh, k)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not delete the ibpkey %s&quot;) % pkey_str)
            semanage_ibpkey_key_free(k)

        self.commit()

    def __delete(self, pkey, subnet_prefix):
        (k, subnet_prefix, low, high) = self.__genkey(pkey, subnet_prefix)
        (rc, exists) = semanage_ibpkey_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if ibpkey {subnet_prefix}/{pkey} is defined&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))
        if not exists:
            raise ValueError(_(&quot;ibpkey {subnet_prefix}/{pkey} is not defined&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        (rc, exists) = semanage_ibpkey_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if ibpkey {subnet_prefix}/{pkey} is defined&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))
        if not exists:
            raise ValueError(_(&quot;ibpkey {subnet_prefix}/{pkey} is defined in policy, cannot be deleted&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        rc = semanage_ibpkey_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete ibpkey {subnet_prefix}/{pkey}&quot;).format(subnet_prefix=subnet_prefix, pkey=pkey))

        semanage_ibpkey_key_free(k)

    def delete(self, pkey, subnet_prefix):
        self.begin()
        self.__delete(pkey, subnet_prefix)
        self.commit()

    def get_all(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.plist) = semanage_ibpkey_list_local(self.sh)
        else:
            (rc, self.plist) = semanage_ibpkey_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list ibpkeys&quot;))

        for ibpkey in self.plist:
            con = semanage_ibpkey_get_con(ibpkey)
            ctype = semanage_context_get_type(con)
            if ctype == &quot;reserved_ibpkey_t&quot;:
                continue
            level = semanage_context_get_mls(con)
            (rc, subnet_prefix) = semanage_ibpkey_get_subnet_prefix(self.sh, ibpkey)
            low = semanage_ibpkey_get_low(ibpkey)
            high = semanage_ibpkey_get_high(ibpkey)
            ddict[(low, high, subnet_prefix)] = (ctype, level)
        return ddict

    def get_all_by_type(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.plist) = semanage_ibpkey_list_local(self.sh)
        else:
            (rc, self.plist) = semanage_ibpkey_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list ibpkeys&quot;))

        for ibpkey in self.plist:
            con = semanage_ibpkey_get_con(ibpkey)
            ctype = semanage_context_get_type(con)
            (rc, subnet_prefix) = semanage_ibpkey_get_subnet_prefix(self.sh, ibpkey)
            low = semanage_ibpkey_get_low(ibpkey)
            high = semanage_ibpkey_get_high(ibpkey)
            if (ctype, subnet_prefix) not in ddict.keys():
                ddict[(ctype, subnet_prefix)] = []
            if low == high:
                ddict[(ctype, subnet_prefix)].append(&quot;0x%x&quot; % low)
            else:
                ddict[(ctype, subnet_prefix)].append(&quot;0x%x-0x%x&quot; % (low, high))
        return ddict

    def customized(self):
        l = []
        ddict = self.get_all(True)

        for k in sorted(ddict.keys()):
            port = k[0] if k[0] == k[1] else &quot;%s-%s&quot; % (k[0], k[1])
            if ddict[k][1]:
                l.append(&quot;-a -t %s -r &#039;%s&#039; -x %s %s&quot; % (ddict[k][0], ddict[k][1], k[2], port))
            else:
                l.append(&quot;-a -t %s -x %s %s&quot; % (ddict[k][0], k[2], port))
        return l

    def list(self, heading=1, locallist=0):
        ddict = self.get_all_by_type(locallist)
        keys = ddict.keys()
        if len(keys) == 0:
            return

        if heading:
            print(&quot;%-30s %-18s %s\n&quot; % (_(&quot;SELinux IB Pkey Type&quot;), _(&quot;Subnet_Prefix&quot;), _(&quot;Pkey Number&quot;)))
        for i in sorted(keys):
            rec = &quot;%-30s %-18s &quot; % i
            rec += &quot;%s&quot; % ddict[i][0]
            for p in ddict[i][1:]:
                rec += &quot;, %s&quot; % p
            print(rec)

class ibendportRecords(semanageRecords):

    valid_types = []

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)
        try:
            q = TypeQuery(SELinuxPolicy(sepolicy.get_store_policy(self.store)), attrs=[&quot;ibendport_type&quot;])
            self.valid_types = set(str(t) for t in q.results())
        except:
            pass

    def __genkey(self, ibendport, ibdev_name):
        if ibdev_name == &quot;&quot;:
            raise ValueError(_(&quot;IB device name is required&quot;))

        port = int(ibendport)

        if port &gt; 255 or port &lt; 1:
            raise ValueError(_(&quot;Invalid Port Number&quot;))

        (rc, k) = semanage_ibendport_key_create(self.sh, ibdev_name, port)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for ibendport {ibdev_name}/{ibendport}&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))
        return (k, ibdev_name, port)

    def __add(self, ibendport, ibdev_name, serange, type):
        if is_mls_enabled == 1:
            if serange == &quot;&quot;:
                serange = &quot;s0&quot;
            else:
                serange = untranslate(serange)

        if type == &quot;&quot;:
            raise ValueError(_(&quot;Type is required&quot;))

        type = sepolicy.get_real_type_name(type)

        if type not in self.valid_types:
            raise ValueError(_(&quot;Type %s is invalid, must be an ibendport type&quot;) % type)
        (k, ibendport, port) = self.__genkey(ibendport, ibdev_name)

        (rc, p) = semanage_ibendport_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create ibendport for {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

        semanage_ibendport_set_ibdev_name(self.sh, p, ibdev_name)
        semanage_ibendport_set_port(p, port)
        (rc, con) = semanage_context_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create context for {ibendport}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

        rc = semanage_context_set_user(self.sh, con, &quot;system_u&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set user in ibendport context for {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

        rc = semanage_context_set_role(self.sh, con, &quot;object_r&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set role in ibendport context for {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

        rc = semanage_context_set_type(self.sh, con, type)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set type in ibendport context for {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            rc = semanage_context_set_mls(self.sh, con, serange)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set mls fields in ibendport context for {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

        rc = semanage_ibendport_set_con(self.sh, p, con)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set ibendport context for {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

        rc = semanage_ibendport_modify_local(self.sh, k, p)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add ibendport {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

        semanage_context_free(con)
        semanage_ibendport_key_free(k)
        semanage_ibendport_free(p)

    def add(self, ibendport, ibdev_name, serange, type):
        self.begin()
        if self.__exists(ibendport, ibdev_name):
            print(_(&quot;ibendport {ibdev_name}/{port} already defined, modifying instead&quot;).format(ibdev_name=ibdev_name, port=port))
            self.__modify(ibendport, ibdev_name, serange, type)
        else:
            self.__add(ibendport, ibdev_name, serange, type)
        self.commit()

    def __exists(self, ibendport, ibdev_name):
        (k, ibendport, port) = self.__genkey(ibendport, ibdev_name)

        (rc, exists) = semanage_ibendport_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if ibendport {ibdev_name}/{port} is defined&quot;).format(ibdev_name=ibdev_name, port=port))
        semanage_ibendport_key_free(k)

        return exists

    def __modify(self, ibendport, ibdev_name, serange, setype):
        if serange == &quot;&quot; and setype == &quot;&quot;:
            if is_mls_enabled == 1:
                raise ValueError(_(&quot;Requires setype or serange&quot;))
            else:
                raise ValueError(_(&quot;Requires setype&quot;))

        setype = sepolicy.get_real_type_name(setype)

        if setype and setype not in self.valid_types:
            raise ValueError(_(&quot;Type %s is invalid, must be an ibendport type&quot;) % setype)

        (k, ibdev_name, port) = self.__genkey(ibendport, ibdev_name)

        (rc, exists) = semanage_ibendport_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if ibendport {ibdev_name}/{ibendport} is defined&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))
        if not exists:
            raise ValueError(_(&quot;ibendport {ibdev_name}/{ibendport} is not defined&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))

        (rc, p) = semanage_ibendport_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query ibendport {ibdev_name}/{ibendport}&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))

        con = semanage_ibendport_get_con(p)

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            semanage_context_set_mls(self.sh, con, untranslate(serange))
        if setype != &quot;&quot;:
            semanage_context_set_type(self.sh, con, setype)

        rc = semanage_ibendport_modify_local(self.sh, k, p)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify ibendport {ibdev_name}/{ibendport}&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))

        semanage_ibendport_key_free(k)
        semanage_ibendport_free(p)

    def modify(self, ibendport, ibdev_name, serange, setype):
        self.begin()
        self.__modify(ibendport, ibdev_name, serange, setype)
        self.commit()

    def deleteall(self):
        (rc, plist) = semanage_ibendport_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list the ibendports&quot;))

        self.begin()

        for ibendport in plist:
            (rc, ibdev_name) = semanage_ibendport_get_ibdev_name(self.sh, ibendport)
            port = semanage_ibendport_get_port(ibendport)
            (k, ibdev_name, port) = self.__genkey(str(port), ibdev_name)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not create a key for {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))

            rc = semanage_ibendport_del_local(self.sh, k)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not delete the ibendport {ibdev_name}/{port}&quot;).format(ibdev_name=ibdev_name, port=port))
            semanage_ibendport_key_free(k)

        self.commit()

    def __delete(self, ibendport, ibdev_name):
        (k, ibdev_name, port) = self.__genkey(ibendport, ibdev_name)
        (rc, exists) = semanage_ibendport_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if ibendport {ibdev_name}/{ibendport} is defined&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))
        if not exists:
            raise ValueError(_(&quot;ibendport {ibdev_name}/{ibendport} is not defined&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))

        (rc, exists) = semanage_ibendport_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if ibendport {ibdev_name}/{ibendport} is defined&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))
        if not exists:
            raise ValueError(_(&quot;ibendport {ibdev_name}/{ibendport} is defined in policy, cannot be deleted&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))

        rc = semanage_ibendport_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete ibendport {ibdev_name}/{ibendport}&quot;).format(ibdev_name=ibdev_name, ibendport=ibendport))

        semanage_ibendport_key_free(k)

    def delete(self, ibendport, ibdev_name):
        self.begin()
        self.__delete(ibendport, ibdev_name)
        self.commit()

    def get_all(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.plist) = semanage_ibendport_list_local(self.sh)
        else:
            (rc, self.plist) = semanage_ibendport_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list ibendports&quot;))

        for ibendport in self.plist:
            con = semanage_ibendport_get_con(ibendport)
            ctype = semanage_context_get_type(con)
            if ctype == &quot;reserved_ibendport_t&quot;:
                continue
            level = semanage_context_get_mls(con)
            (rc, ibdev_name) = semanage_ibendport_get_ibdev_name(self.sh, ibendport)
            port = semanage_ibendport_get_port(ibendport)
            ddict[(port, ibdev_name)] = (ctype, level)
        return ddict

    def get_all_by_type(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.plist) = semanage_ibendport_list_local(self.sh)
        else:
            (rc, self.plist) = semanage_ibendport_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list ibendports&quot;))

        for ibendport in self.plist:
            con = semanage_ibendport_get_con(ibendport)
            ctype = semanage_context_get_type(con)
            (rc, ibdev_name) = semanage_ibendport_get_ibdev_name(self.sh, ibendport)
            port = semanage_ibendport_get_port(ibendport)
            if (ctype, ibdev_name) not in ddict.keys():
                ddict[(ctype, ibdev_name)] = []
            ddict[(ctype, ibdev_name)].append(&quot;0x%x&quot; % port)
        return ddict

    def customized(self):
        l = []
        ddict = self.get_all(True)

        for k in sorted(ddict.keys()):
            if ddict[k][1]:
                l.append(&quot;-a -t %s -r &#039;%s&#039; -z %s %s&quot; % (ddict[k][0], ddict[k][1], k[1], k[0]))
            else:
                l.append(&quot;-a -t %s -z %s %s&quot; % (ddict[k][0], k[1], k[0]))
        return l

    def list(self, heading=1, locallist=0):
        ddict = self.get_all_by_type(locallist)
        keys = ddict.keys()
        if len(keys) == 0:
            return

        if heading:
            print(&quot;%-30s %-18s %s\n&quot; % (_(&quot;SELinux IB End Port Type&quot;), _(&quot;IB Device Name&quot;), _(&quot;Port Number&quot;)))
        for i in sorted(keys):
            rec = &quot;%-30s %-18s &quot; % i
            rec += &quot;%s&quot; % ddict[i][0]
            for p in ddict[i][1:]:
                rec += &quot;, %s&quot; % p
            print(rec)

class nodeRecords(semanageRecords):

    valid_types = []

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)
        self.protocol = [&quot;ipv4&quot;, &quot;ipv6&quot;]
        try:
            self.valid_types = list(list(sepolicy.info(sepolicy.ATTRIBUTE, &quot;node_type&quot;))[0][&quot;types&quot;])
        except RuntimeError:
            pass

    def validate(self, addr, mask, protocol):
        newaddr = addr
        newmask = mask
        newprotocol = &quot;&quot;

        if addr == &quot;&quot;:
            raise ValueError(_(&quot;Node Address is required&quot;))

        # verify that (addr, mask) is either a IP address (without a mask) or a valid network mask
        if len(mask) == 0 or mask[0] == &quot;/&quot;:
            i = ipaddress.ip_network(addr + mask)
            newaddr = str(i.network_address)
            newmask = str(i.netmask)
            protocol = &quot;ipv%d&quot; % i.version

        try:
            newprotocol = self.protocol.index(protocol)
        except:
            raise ValueError(_(&quot;Unknown or missing protocol&quot;))

        try:
            audit_protocol = socket.getprotobyname(protocol)
        except:
            # Entry for &quot;ipv4&quot; not found in /etc/protocols on (at
            # least) Debian? To ensure audit log compatibility, let&#039;s
            # use the same numeric value as Fedora: 4, which is
            # actually understood by kernel as IP over IP.
            if (protocol == &quot;ipv4&quot;):
                audit_protocol = socket.IPPROTO_IPIP
            else:
                raise ValueError(_(&quot;Unknown or missing protocol&quot;))

        return newaddr, newmask, newprotocol, audit_protocol

    def __add(self, addr, mask, proto, serange, ctype):
        addr, mask, proto, audit_proto = self.validate(addr, mask, proto)

        if is_mls_enabled == 1:
            if serange == &quot;&quot;:
                serange = &quot;s0&quot;
            else:
                serange = untranslate(serange)

        if ctype == &quot;&quot;:
            raise ValueError(_(&quot;SELinux node type is required&quot;))

        ctype = sepolicy.get_real_type_name(ctype)

        if ctype not in self.valid_types:
            raise ValueError(_(&quot;Type %s is invalid, must be a node type&quot;) % ctype)

        (rc, k) = semanage_node_key_create(self.sh, addr, mask, proto)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % addr)

        (rc, node) = semanage_node_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create addr for %s&quot;) % addr)
        semanage_node_set_proto(node, proto)

        rc = semanage_node_set_addr(self.sh, node, proto, addr)
        (rc, con) = semanage_context_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create context for %s&quot;) % addr)

        rc = semanage_node_set_mask(self.sh, node, proto, mask)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set mask for %s&quot;) % addr)

        rc = semanage_context_set_user(self.sh, con, &quot;system_u&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set user in addr context for %s&quot;) % addr)

        rc = semanage_context_set_role(self.sh, con, &quot;object_r&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set role in addr context for %s&quot;) % addr)

        rc = semanage_context_set_type(self.sh, con, ctype)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set type in addr context for %s&quot;) % addr)

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            rc = semanage_context_set_mls(self.sh, con, serange)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set mls fields in addr context for %s&quot;) % addr)

        rc = semanage_node_set_con(self.sh, node, con)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set addr context for %s&quot;) % addr)

        rc = semanage_node_modify_local(self.sh, k, node)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add addr %s&quot;) % addr)

        semanage_context_free(con)
        semanage_node_key_free(k)
        semanage_node_free(node)

        self.mylog.log_change(&quot;resrc=node op=add laddr=%s netmask=%s proto=%s tcontext=%s:%s:%s:%s&quot; % (addr, mask, audit_proto, &quot;system_u&quot;, &quot;object_r&quot;, ctype, serange))

    def add(self, addr, mask, proto, serange, ctype):
        self.begin()
        if self.__exists(addr, mask, proto):
            print(_(&quot;Addr %s already defined, modifying instead&quot;) % addr)
            self.__modify(addr, mask, proto, serange, ctype)
        else:
            self.__add(addr, mask, proto, serange, ctype)
        self.commit()

    def __exists(self, addr, mask, proto):
        addr, mask, proto, audit_proto = self.validate(addr, mask, proto)

        (rc, k) = semanage_node_key_create(self.sh, addr, mask, proto)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % addr)

        (rc, exists) = semanage_node_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if addr %s is defined&quot;) % addr)
        semanage_node_key_free(k)

        return exists

    def __modify(self, addr, mask, proto, serange, setype):
        addr, mask, proto, audit_proto = self.validate(addr, mask, proto)

        if serange == &quot;&quot; and setype == &quot;&quot;:
            raise ValueError(_(&quot;Requires setype or serange&quot;))

        setype = sepolicy.get_real_type_name(setype)

        if setype and setype not in self.valid_types:
            raise ValueError(_(&quot;Type %s is invalid, must be a node type&quot;) % setype)

        (rc, k) = semanage_node_key_create(self.sh, addr, mask, proto)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % addr)

        (rc, exists) = semanage_node_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if addr %s is defined&quot;) % addr)
        if not exists:
            raise ValueError(_(&quot;Addr %s is not defined&quot;) % addr)

        (rc, node) = semanage_node_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query addr %s&quot;) % addr)

        con = semanage_node_get_con(node)
        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            semanage_context_set_mls(self.sh, con, untranslate(serange))
        if setype != &quot;&quot;:
            semanage_context_set_type(self.sh, con, setype)

        rc = semanage_node_modify_local(self.sh, k, node)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify addr %s&quot;) % addr)

        semanage_node_key_free(k)
        semanage_node_free(node)

        self.mylog.log_change(&quot;resrc=node op=modify laddr=%s netmask=%s proto=%s tcontext=%s:%s:%s:%s&quot; % (addr, mask, audit_proto, &quot;system_u&quot;, &quot;object_r&quot;, setype, serange))

    def modify(self, addr, mask, proto, serange, setype):
        self.begin()
        self.__modify(addr, mask, proto, serange, setype)
        self.commit()

    def __delete(self, addr, mask, proto):
        addr, mask, proto, audit_proto = self.validate(addr, mask, proto)

        (rc, k) = semanage_node_key_create(self.sh, addr, mask, proto)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % addr)

        (rc, exists) = semanage_node_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if addr %s is defined&quot;) % addr)
        if not exists:
            raise ValueError(_(&quot;Addr %s is not defined&quot;) % addr)

        (rc, exists) = semanage_node_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if addr %s is defined&quot;) % addr)
        if not exists:
            raise ValueError(_(&quot;Addr %s is defined in policy, cannot be deleted&quot;) % addr)

        rc = semanage_node_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete addr %s&quot;) % addr)

        semanage_node_key_free(k)

        self.mylog.log_change(&quot;resrc=node op=delete laddr=%s netmask=%s proto=%s&quot; % (addr, mask, audit_proto))

    def delete(self, addr, mask, proto):
        self.begin()
        self.__delete(addr, mask, proto)
        self.commit()

    def deleteall(self):
        (rc, nlist) = semanage_node_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not deleteall node mappings&quot;))

        self.begin()
        for node in nlist:
            self.__delete(semanage_node_get_addr(self.sh, node)[1], semanage_node_get_mask(self.sh, node)[1], self.protocol[semanage_node_get_proto(node)])
        self.commit()

    def get_all(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.ilist) = semanage_node_list_local(self.sh)
        else:
            (rc, self.ilist) = semanage_node_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list addrs&quot;))

        for node in self.ilist:
            con = semanage_node_get_con(node)
            addr = semanage_node_get_addr(self.sh, node)
            mask = semanage_node_get_mask(self.sh, node)
            proto = self.protocol[semanage_node_get_proto(node)]
            ddict[(addr[1], mask[1], proto)] = (semanage_context_get_user(con), semanage_context_get_role(con), semanage_context_get_type(con), semanage_context_get_mls(con))

        return ddict

    def customized(self):
        l = []
        ddict = self.get_all(True)
        for k in sorted(ddict.keys()):
            if ddict[k][3]:
                l.append(&quot;-a -M %s -p %s -t %s -r &#039;%s&#039; %s&quot; % (k[1], k[2], ddict[k][2], ddict[k][3], k[0]))
            else:
                l.append(&quot;-a -M %s -p %s -t %s %s&quot; % (k[1], k[2], ddict[k][2], k[0]))
        return l

    def list(self, heading=1, locallist=0):
        ddict = self.get_all(locallist)
        if len(ddict) == 0:
            return
        keys = sorted(ddict.keys())

        if heading:
            print(&quot;%-18s %-18s %-5s %-5s\n&quot; % (&quot;IP Address&quot;, &quot;Netmask&quot;, &quot;Protocol&quot;, &quot;Context&quot;))
        if is_mls_enabled:
            for k in keys:
                val = &#039;&#039;
                for fields in k:
                    val = val + &#039;\t&#039; + str(fields)
                print(&quot;%-18s %-18s %-5s %s:%s:%s:%s &quot; % (k[0], k[1], k[2], ddict[k][0], ddict[k][1], ddict[k][2], translate(ddict[k][3], False)))
        else:
            for k in keys:
                print(&quot;%-18s %-18s %-5s %s:%s:%s &quot; % (k[0], k[1], k[2], ddict[k][0], ddict[k][1], ddict[k][2]))


class interfaceRecords(semanageRecords):

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)

    def __add(self, interface, serange, ctype):
        if is_mls_enabled == 1:
            if serange == &quot;&quot;:
                serange = &quot;s0&quot;
            else:
                serange = untranslate(serange)

        if ctype == &quot;&quot;:
            raise ValueError(_(&quot;SELinux Type is required&quot;))

        (rc, k) = semanage_iface_key_create(self.sh, interface)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % interface)

        (rc, iface) = semanage_iface_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create interface for %s&quot;) % interface)

        rc = semanage_iface_set_name(self.sh, iface, interface)
        (rc, con) = semanage_context_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create context for %s&quot;) % interface)

        rc = semanage_context_set_user(self.sh, con, &quot;system_u&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set user in interface context for %s&quot;) % interface)

        rc = semanage_context_set_role(self.sh, con, &quot;object_r&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set role in interface context for %s&quot;) % interface)

        rc = semanage_context_set_type(self.sh, con, ctype)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set type in interface context for %s&quot;) % interface)

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            rc = semanage_context_set_mls(self.sh, con, serange)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set mls fields in interface context for %s&quot;) % interface)

        rc = semanage_iface_set_ifcon(self.sh, iface, con)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set interface context for %s&quot;) % interface)

        rc = semanage_iface_set_msgcon(self.sh, iface, con)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set message context for %s&quot;) % interface)

        rc = semanage_iface_modify_local(self.sh, k, iface)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add interface %s&quot;) % interface)

        semanage_context_free(con)
        semanage_iface_key_free(k)
        semanage_iface_free(iface)

        self.mylog.log_change(&quot;resrc=interface op=add netif=%s tcontext=%s:%s:%s:%s&quot; % (interface, &quot;system_u&quot;, &quot;object_r&quot;, ctype, serange))

    def add(self, interface, serange, ctype):
        self.begin()
        if self.__exists(interface):
            print(_(&quot;Interface %s already defined, modifying instead&quot;) % interface)
            self.__modify(interface, serange, ctype)
        else:
            self.__add(interface, serange, ctype)
        self.commit()

    def __exists(self, interface):
        (rc, k) = semanage_iface_key_create(self.sh, interface)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % interface)

        (rc, exists) = semanage_iface_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if interface %s is defined&quot;) % interface)
        semanage_iface_key_free(k)

        return exists

    def __modify(self, interface, serange, setype):
        if serange == &quot;&quot; and setype == &quot;&quot;:
            raise ValueError(_(&quot;Requires setype or serange&quot;))

        (rc, k) = semanage_iface_key_create(self.sh, interface)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % interface)

        (rc, exists) = semanage_iface_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if interface %s is defined&quot;) % interface)
        if not exists:
            raise ValueError(_(&quot;Interface %s is not defined&quot;) % interface)

        (rc, iface) = semanage_iface_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query interface %s&quot;) % interface)

        con = semanage_iface_get_ifcon(iface)

        if (is_mls_enabled == 1) and (serange != &quot;&quot;):
            semanage_context_set_mls(self.sh, con, untranslate(serange))
        if setype != &quot;&quot;:
            semanage_context_set_type(self.sh, con, setype)

        rc = semanage_iface_modify_local(self.sh, k, iface)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify interface %s&quot;) % interface)

        semanage_iface_key_free(k)
        semanage_iface_free(iface)

        self.mylog.log_change(&quot;resrc=interface op=modify netif=%s tcontext=%s:%s:%s:%s&quot; % (interface, &quot;system_u&quot;, &quot;object_r&quot;, setype, serange))

    def modify(self, interface, serange, setype):
        self.begin()
        self.__modify(interface, serange, setype)
        self.commit()

    def __delete(self, interface):
        (rc, k) = semanage_iface_key_create(self.sh, interface)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % interface)

        (rc, exists) = semanage_iface_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if interface %s is defined&quot;) % interface)
        if not exists:
            raise ValueError(_(&quot;Interface %s is not defined&quot;) % interface)

        (rc, exists) = semanage_iface_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if interface %s is defined&quot;) % interface)
        if not exists:
            raise ValueError(_(&quot;Interface %s is defined in policy, cannot be deleted&quot;) % interface)

        rc = semanage_iface_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete interface %s&quot;) % interface)

        semanage_iface_key_free(k)

        self.mylog.log_change(&quot;resrc=interface op=delete netif=%s&quot; % interface)

    def delete(self, interface):
        self.begin()
        self.__delete(interface)
        self.commit()

    def deleteall(self):
        (rc, ulist) = semanage_iface_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete all interface  mappings&quot;))

        self.begin()
        for i in ulist:
            self.__delete(semanage_iface_get_name(i))
        self.commit()

    def get_all(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.ilist) = semanage_iface_list_local(self.sh)
        else:
            (rc, self.ilist) = semanage_iface_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list interfaces&quot;))

        for interface in self.ilist:
            con = semanage_iface_get_ifcon(interface)
            ddict[semanage_iface_get_name(interface)] = (semanage_context_get_user(con), semanage_context_get_role(con), semanage_context_get_type(con), semanage_context_get_mls(con))

        return ddict

    def customized(self):
        l = []
        ddict = self.get_all(True)
        for k in sorted(ddict.keys()):
            if ddict[k][3]:
                l.append(&quot;-a -t %s -r &#039;%s&#039; %s&quot; % (ddict[k][2], ddict[k][3], k))
            else:
                l.append(&quot;-a -t %s %s&quot; % (ddict[k][2], k))
        return l

    def list(self, heading=1, locallist=0):
        ddict = self.get_all(locallist)
        if len(ddict) == 0:
            return
        keys = sorted(ddict.keys())

        if heading:
            print(&quot;%-30s %s\n&quot; % (_(&quot;SELinux Interface&quot;), _(&quot;Context&quot;)))
        if is_mls_enabled:
            for k in keys:
                print(&quot;%-30s %s:%s:%s:%s &quot; % (k, ddict[k][0], ddict[k][1], ddict[k][2], translate(ddict[k][3], False)))
        else:
            for k in keys:
                print(&quot;%-30s %s:%s:%s &quot; % (k, ddict[k][0], ddict[k][1], ddict[k][2]))


class fcontextRecords(semanageRecords):

    valid_types = []

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)
        try:
            self.valid_types = list(list(sepolicy.info(sepolicy.ATTRIBUTE, &quot;file_type&quot;))[0][&quot;types&quot;])
            self.valid_types += list(list(sepolicy.info(sepolicy.ATTRIBUTE, &quot;device_node&quot;))[0][&quot;types&quot;])
        except RuntimeError:
            pass

        self.equiv = {}
        self.equiv_dist = {}
        self.equal_ind = False
        try:
            fd = open(selinux.selinux_file_context_subs_path(), &quot;r&quot;)
            for i in fd.readlines():
                i = i.strip()
                if len(i) == 0:
                    continue
                if i.startswith(&quot;#&quot;):
                    continue
                target, substitute = i.split()
                self.equiv[target] = substitute
            fd.close()
        except IOError:
            pass
        try:
            fd = open(selinux.selinux_file_context_subs_dist_path(), &quot;r&quot;)
            for i in fd.readlines():
                i = i.strip()
                if len(i) == 0:
                    continue
                if i.startswith(&quot;#&quot;):
                    continue
                target, substitute = i.split()
                self.equiv_dist[target] = substitute
            fd.close()
        except IOError:
            pass

    def commit(self):
        if self.equal_ind:
            subs_file = selinux.selinux_file_context_subs_path()
            tmpfile = &quot;%s.tmp&quot; % subs_file
            fd = open(tmpfile, &quot;w&quot;)
            for target in self.equiv.keys():
                fd.write(&quot;%s %s\n&quot; % (target, self.equiv[target]))
            fd.close()
            try:
                os.chmod(tmpfile, os.stat(subs_file)[stat.ST_MODE])
            except:
                pass
            os.rename(tmpfile, subs_file)
            self.equal_ind = False
        semanageRecords.commit(self)

    def add_equal(self, target, substitute):
        self.begin()
        if target != &quot;/&quot; and target[-1] == &quot;/&quot;:
            raise ValueError(_(&quot;Target %s is not valid. Target is not allowed to end with &#039;/&#039;&quot;) % target)

        if substitute != &quot;/&quot; and substitute[-1] == &quot;/&quot;:
            raise ValueError(_(&quot;Substitute %s is not valid. Substitute is not allowed to end with &#039;/&#039;&quot;) % substitute)

        if target in self.equiv.keys():
            print(_(&quot;Equivalence class for %s already exists, modifying instead&quot;) % target)
            self.equiv[target] = substitute
            self.equal_ind = True
            self.mylog.log_change(&quot;resrc=fcontext op=modify-equal %s %s&quot; % (audit.audit_encode_nv_string(&quot;sglob&quot;, target, 0), audit.audit_encode_nv_string(&quot;tglob&quot;, substitute, 0)))
            self.commit()
            return

        self.validate(target)

        for fdict in (self.equiv, self.equiv_dist):
            for i in fdict:
                if i.startswith(target + &quot;/&quot;):
                    raise ValueError(_(&quot;File spec %s conflicts with equivalency rule &#039;%s %s&#039;&quot;) % (target, i, fdict[i]))

        self.mylog.log_change(&quot;resrc=fcontext op=add-equal %s %s&quot; % (audit.audit_encode_nv_string(&quot;sglob&quot;, target, 0), audit.audit_encode_nv_string(&quot;tglob&quot;, substitute, 0)))

        self.equiv[target] = substitute
        self.equal_ind = True
        self.commit()

    def modify_equal(self, target, substitute):
        self.begin()
        if target not in self.equiv.keys():
            raise ValueError(_(&quot;Equivalence class for %s does not exist&quot;) % target)
        self.equiv[target] = substitute
        self.equal_ind = True

        self.mylog.log_change(&quot;resrc=fcontext op=modify-equal %s %s&quot; % (audit.audit_encode_nv_string(&quot;sglob&quot;, target, 0), audit.audit_encode_nv_string(&quot;tglob&quot;, substitute, 0)))

        self.commit()

    def createcon(self, target, seuser=&quot;system_u&quot;):
        (rc, con) = semanage_context_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create context for %s&quot;) % target)
        if seuser == &quot;&quot;:
            seuser = &quot;system_u&quot;

        rc = semanage_context_set_user(self.sh, con, seuser)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set user in file context for %s&quot;) % target)

        rc = semanage_context_set_role(self.sh, con, &quot;object_r&quot;)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set role in file context for %s&quot;) % target)

        if is_mls_enabled == 1:
            rc = semanage_context_set_mls(self.sh, con, &quot;s0&quot;)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set mls fields in file context for %s&quot;) % target)

        return con

    def validate(self, target):
        if target == &quot;&quot; or target.find(&quot;\n&quot;) &gt;= 0:
            raise ValueError(_(&quot;Invalid file specification&quot;))
        if target.find(&quot; &quot;) != -1:
            raise ValueError(_(&quot;File specification can not include spaces&quot;))
        for fdict in (self.equiv, self.equiv_dist):
            for i in fdict:
                if target.startswith(i + &quot;/&quot;):
                    t = re.sub(i, fdict[i], target)
                    raise ValueError(_(&quot;File spec %s conflicts with equivalency rule &#039;%s %s&#039;; Try adding &#039;%s&#039; instead&quot;) % (target, i, fdict[i], t))

    def __add(self, target, type, ftype=&quot;&quot;, serange=&quot;&quot;, seuser=&quot;system_u&quot;):
        self.validate(target)

        if is_mls_enabled == 1:
            serange = untranslate(serange)

        if type == &quot;&quot;:
            raise ValueError(_(&quot;SELinux Type is required&quot;))

        if type != &quot;&lt;&lt;none&gt;&gt;&quot;:
            type = sepolicy.get_real_type_name(type)
            if type not in self.valid_types:
                raise ValueError(_(&quot;Type %s is invalid, must be a file or device type&quot;) % type)

        (rc, k) = semanage_fcontext_key_create(self.sh, target, file_types[ftype])
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % target)

        (rc, fcontext) = semanage_fcontext_create(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create file context for %s&quot;) % target)

        rc = semanage_fcontext_set_expr(self.sh, fcontext, target)
        if type != &quot;&lt;&lt;none&gt;&gt;&quot;:
            con = self.createcon(target, seuser)

            rc = semanage_context_set_type(self.sh, con, type)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set type in file context for %s&quot;) % target)

            if (is_mls_enabled == 1) and (serange != &quot;&quot;):
                rc = semanage_context_set_mls(self.sh, con, serange)
                if rc &lt; 0:
                    raise ValueError(_(&quot;Could not set mls fields in file context for %s&quot;) % target)
            rc = semanage_fcontext_set_con(self.sh, fcontext, con)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set file context for %s&quot;) % target)

        semanage_fcontext_set_type(fcontext, file_types[ftype])

        rc = semanage_fcontext_modify_local(self.sh, k, fcontext)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not add file context for %s&quot;) % target)

        if type != &quot;&lt;&lt;none&gt;&gt;&quot;:
            semanage_context_free(con)
        semanage_fcontext_key_free(k)
        semanage_fcontext_free(fcontext)

        if not seuser:
            seuser = &quot;system_u&quot;

        self.mylog.log_change(&quot;resrc=fcontext op=add %s ftype=%s tcontext=%s:%s:%s:%s&quot; % (audit.audit_encode_nv_string(&quot;tglob&quot;, target, 0), ftype_to_audit[ftype], seuser, &quot;object_r&quot;, type, serange))

    def add(self, target, type, ftype=&quot;&quot;, serange=&quot;&quot;, seuser=&quot;system_u&quot;):
        self.begin()
        if self.__exists(target, ftype):
            print(_(&quot;File context for %s already defined, modifying instead&quot;) % target)
            self.__modify(target, type, ftype, serange, seuser)
        else:
            self.__add(target, type, ftype, serange, seuser)
        self.commit()

    def __exists(self, target, ftype):
        (rc, k) = semanage_fcontext_key_create(self.sh, target, file_types[ftype])
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create key for %s&quot;) % target)

        (rc, exists) = semanage_fcontext_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if file context for %s is defined&quot;) % target)

        if not exists:
            (rc, exists) = semanage_fcontext_exists_local(self.sh, k)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not check if file context for %s is defined&quot;) % target)
        semanage_fcontext_key_free(k)

        return exists

    def __modify(self, target, setype, ftype, serange, seuser):
        if serange == &quot;&quot; and setype == &quot;&quot; and seuser == &quot;&quot;:
            raise ValueError(_(&quot;Requires setype, serange or seuser&quot;))
        if setype not in [&quot;&quot;,  &quot;&lt;&lt;none&gt;&gt;&quot;]:
            setype = sepolicy.get_real_type_name(setype)
            if setype not in self.valid_types:
                raise ValueError(_(&quot;Type %s is invalid, must be a file or device type&quot;) % setype)

        self.validate(target)

        (rc, k) = semanage_fcontext_key_create(self.sh, target, file_types[ftype])
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % target)

        (rc, exists) = semanage_fcontext_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if file context for %s is defined&quot;) % target)
        if exists:
            try:
                (rc, fcontext) = semanage_fcontext_query(self.sh, k)
            except OSError:
                raise ValueError(_(&quot;Could not query file context for %s&quot;) % target)
        else:
            (rc, exists) = semanage_fcontext_exists_local(self.sh, k)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not check if file context for %s is defined&quot;) % target)
            if not exists:
                raise ValueError(_(&quot;File context for %s is not defined&quot;) % target)
            try:
                (rc, fcontext) = semanage_fcontext_query_local(self.sh, k)
            except OSError:
                raise ValueError(_(&quot;Could not query file context for %s&quot;) % target)

        if setype != &quot;&lt;&lt;none&gt;&gt;&quot;:
            con = semanage_fcontext_get_con(fcontext)

            if con is None:
                con = self.createcon(target)

            if (is_mls_enabled == 1) and (serange != &quot;&quot;):
                semanage_context_set_mls(self.sh, con, untranslate(serange))
            if seuser != &quot;&quot;:
                semanage_context_set_user(self.sh, con, seuser)

            if setype != &quot;&quot;:
                semanage_context_set_type(self.sh, con, setype)

            rc = semanage_fcontext_set_con(self.sh, fcontext, con)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set file context for %s&quot;) % target)
        else:
            rc = semanage_fcontext_set_con(self.sh, fcontext, None)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set file context for %s&quot;) % target)

        rc = semanage_fcontext_modify_local(self.sh, k, fcontext)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify file context for %s&quot;) % target)

        semanage_fcontext_key_free(k)
        semanage_fcontext_free(fcontext)

        if not seuser:
            seuser = &quot;system_u&quot;

        self.mylog.log_change(&quot;resrc=fcontext op=modify %s ftype=%s tcontext=%s:%s:%s:%s&quot; % (audit.audit_encode_nv_string(&quot;tglob&quot;, target, 0), ftype_to_audit[ftype], seuser, &quot;object_r&quot;, setype, serange))

    def modify(self, target, setype, ftype, serange, seuser):
        self.begin()
        self.__modify(target, setype, ftype, serange, seuser)
        self.commit()

    def deleteall(self):
        (rc, flist) = semanage_fcontext_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list the file contexts&quot;))

        self.begin()

        for fcontext in flist:
            target = semanage_fcontext_get_expr(fcontext)
            ftype = semanage_fcontext_get_type(fcontext)
            ftype_str = semanage_fcontext_get_type_str(ftype)
            (rc, k) = semanage_fcontext_key_create(self.sh, target, file_types[ftype_str])
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not create a key for %s&quot;) % target)

            rc = semanage_fcontext_del_local(self.sh, k)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not delete the file context %s&quot;) % target)
            semanage_fcontext_key_free(k)

            self.mylog.log_change(&quot;resrc=fcontext op=delete %s ftype=%s&quot; % (audit.audit_encode_nv_string(&quot;tglob&quot;, target, 0), ftype_to_audit[file_type_str_to_option[ftype_str]]))

        self.equiv = {}
        self.equal_ind = True
        self.commit()

    def __delete(self, target, ftype):
        if target in self.equiv.keys():
            self.equiv.pop(target)
            self.equal_ind = True

            self.mylog.log_change(&quot;resrc=fcontext op=delete-equal %s&quot; % (audit.audit_encode_nv_string(&quot;tglob&quot;, target, 0)))

            return

        (rc, k) = semanage_fcontext_key_create(self.sh, target, file_types[ftype])
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % target)

        (rc, exists) = semanage_fcontext_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if file context for %s is defined&quot;) % target)
        if not exists:
            (rc, exists) = semanage_fcontext_exists(self.sh, k)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not check if file context for %s is defined&quot;) % target)
            if exists:
                raise ValueError(_(&quot;File context for %s is defined in policy, cannot be deleted&quot;) % target)
            else:
                raise ValueError(_(&quot;File context for %s is not defined&quot;) % target)

        rc = semanage_fcontext_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete file context for %s&quot;) % target)

        semanage_fcontext_key_free(k)

        self.mylog.log_change(&quot;resrc=fcontext op=delete %s ftype=%s&quot; % (audit.audit_encode_nv_string(&quot;tglob&quot;, target, 0), ftype_to_audit[ftype]))

    def delete(self, target, ftype):
        self.begin()
        self.__delete(target, ftype)
        self.commit()

    def get_all(self, locallist=0):
        if locallist:
            (rc, self.flist) = semanage_fcontext_list_local(self.sh)
        else:
            (rc, self.flist) = semanage_fcontext_list(self.sh)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not list file contexts&quot;))

            (rc, fchomedirs) = semanage_fcontext_list_homedirs(self.sh)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not list file contexts for home directories&quot;))

            (rc, fclocal) = semanage_fcontext_list_local(self.sh)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not list local file contexts&quot;))

            self.flist += fchomedirs
            self.flist += fclocal

        ddict = {}
        for fcontext in self.flist:
            expr = semanage_fcontext_get_expr(fcontext)
            ftype = semanage_fcontext_get_type(fcontext)
            ftype_str = semanage_fcontext_get_type_str(ftype)
            con = semanage_fcontext_get_con(fcontext)
            if con:
                ddict[(expr, ftype_str)] = (semanage_context_get_user(con), semanage_context_get_role(con), semanage_context_get_type(con), semanage_context_get_mls(con))
            else:
                ddict[(expr, ftype_str)] = con

        return ddict

    def customized(self):
        l = []
        fcon_dict = self.get_all(True)
        for k in fcon_dict.keys():
            if fcon_dict[k]:
                if fcon_dict[k][3]:
                    l.append(&quot;-a -f %s -t %s -r &#039;%s&#039; &#039;%s&#039;&quot; % (file_type_str_to_option[k[1]], fcon_dict[k][2], fcon_dict[k][3], k[0]))
                else:
                    l.append(&quot;-a -f %s -t %s &#039;%s&#039;&quot; % (file_type_str_to_option[k[1]], fcon_dict[k][2], k[0]))

        if len(self.equiv):
            for target in self.equiv.keys():
                l.append(&quot;-a -e %s %s&quot; % (self.equiv[target], target))
        return l

    def list(self, heading=1, locallist=0):
        fcon_dict = self.get_all(locallist)
        if len(fcon_dict) != 0:
            if heading:
                print(&quot;%-50s %-18s %s\n&quot; % (_(&quot;SELinux fcontext&quot;), _(&quot;type&quot;), _(&quot;Context&quot;)))
            # do not sort local customizations since they are evaluated based on the order they where added in
            if locallist:
                fkeys = fcon_dict.keys()
            else:
                fkeys = sorted(fcon_dict.keys())
            for k in fkeys:
                if fcon_dict[k]:
                    if is_mls_enabled:
                        print(&quot;%-50s %-18s %s:%s:%s:%s &quot; % (k[0], k[1], fcon_dict[k][0], fcon_dict[k][1], fcon_dict[k][2], translate(fcon_dict[k][3], False)))
                    else:
                        print(&quot;%-50s %-18s %s:%s:%s &quot; % (k[0], k[1], fcon_dict[k][0], fcon_dict[k][1], fcon_dict[k][2]))
                else:
                    print(&quot;%-50s %-18s &lt;&lt;None&gt;&gt;&quot; % (k[0], k[1]))

        if len(self.equiv_dist):
            if not locallist:
                if heading:
                    print(_(&quot;\nSELinux Distribution fcontext Equivalence \n&quot;))
                for target in self.equiv_dist.keys():
                    print(&quot;%s = %s&quot; % (target, self.equiv_dist[target]))
        if len(self.equiv):
            if heading:
                print(_(&quot;\nSELinux Local fcontext Equivalence \n&quot;))

            for target in self.equiv.keys():
                print(&quot;%s = %s&quot; % (target, self.equiv[target]))


class booleanRecords(semanageRecords):

    def __init__(self, args = None):
        semanageRecords.__init__(self, args)
        self.dict = {}
        self.dict[&quot;TRUE&quot;] = 1
        self.dict[&quot;FALSE&quot;] = 0
        self.dict[&quot;ON&quot;] = 1
        self.dict[&quot;OFF&quot;] = 0
        self.dict[&quot;1&quot;] = 1
        self.dict[&quot;0&quot;] = 0

        try:
            rc, self.current_booleans = selinux.security_get_boolean_names()
            rc, ptype = selinux.selinux_getpolicytype()
        except:
            self.current_booleans = []
            ptype = None

        if self.store == &quot;&quot; or self.store == ptype:
            self.modify_local = True
        else:
            self.modify_local = False

    def __mod(self, name, value):
        name = selinux.selinux_boolean_sub(name)

        (rc, k) = semanage_bool_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)
        (rc, exists) = semanage_bool_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if boolean %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;Boolean %s is not defined&quot;) % name)

        (rc, b) = semanage_bool_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query file context %s&quot;) % name)

        if value.upper() in self.dict:
            semanage_bool_set_value(b, self.dict[value.upper()])
        else:
            raise ValueError(_(&quot;You must specify one of the following values: %s&quot;) % &quot;, &quot;.join(self.dict.keys()))

        if self.modify_local and name in self.current_booleans:
            rc = semanage_bool_set_active(self.sh, k, b)
            if rc &lt; 0:
                raise ValueError(_(&quot;Could not set active value of boolean %s&quot;) % name)
        rc = semanage_bool_modify_local(self.sh, k, b)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not modify boolean %s&quot;) % name)
        semanage_bool_key_free(k)
        semanage_bool_free(b)

    def modify(self, name, value=None, use_file=False):
        self.begin()
        if use_file:
            fd = open(name)
            for b in fd.read().split(&quot;\n&quot;):
                b = b.strip()
                if len(b) == 0:
                    continue

                try:
                    boolname, val = b.split(&quot;=&quot;)
                except ValueError:
                    raise ValueError(_(&quot;Bad format {filename}: Record {record}&quot;).format(filename=name, record=b))
                self.__mod(boolname.strip(), val.strip())
            fd.close()
        else:
            self.__mod(name, value)

        self.commit()

    def __delete(self, name):
        name = selinux.selinux_boolean_sub(name)

        (rc, k) = semanage_bool_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)
        (rc, exists) = semanage_bool_exists(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if boolean %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;Boolean %s is not defined&quot;) % name)

        (rc, exists) = semanage_bool_exists_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not check if boolean %s is defined&quot;) % name)
        if not exists:
            raise ValueError(_(&quot;Boolean %s is defined in policy, cannot be deleted&quot;) % name)

        rc = semanage_bool_del_local(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not delete boolean %s&quot;) % name)

        semanage_bool_key_free(k)

    def delete(self, name):
        self.begin()
        self.__delete(name)
        self.commit()

        # New transaction to reset the boolean to its default value.
        # Calling __reset_value in the same transaction as the removal of
        # local customizations does nothing
        self.begin()
        self.__reset_value(name)
        self.commit()

    def deleteall(self):
        deleted = []
        (rc, self.blist) = semanage_bool_list_local(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list booleans&quot;))

        self.begin()

        for boolean in self.blist:
            name = semanage_bool_get_name(boolean)
            deleted.append(name)
            self.__delete(name)

        self.commit()

        # New transaction to reset all affected booleans to their default values.
        # Calling __reset_value in the same transaction as the removal of
        # local customizations does nothing
        self.begin()

        for boolean in deleted:
            self.__reset_value(boolean)

        self.commit()

    # Set active value to default
    # Note: this needs to be called in a new transaction after removing local customizations
    # in order for semanage_bool_query to fetch the default value
    # (as opposed to the current one -- set by the local customizations)
    def __reset_value(self, name):
        name = selinux.selinux_boolean_sub(name)

        (rc, k) = semanage_bool_key_create(self.sh, name)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not create a key for %s&quot;) % name)

        (rc, b) = semanage_bool_query(self.sh, k)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not query boolean %s&quot;) % name)

        semanage_bool_set_value(b, semanage_bool_get_value(b))

        rc = semanage_bool_set_active(self.sh, k, b)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not set active value of boolean %s&quot;) % name)

        semanage_bool_key_free(k)
        semanage_bool_free(b)

    def get_all(self, locallist=0):
        ddict = {}
        if locallist:
            (rc, self.blist) = semanage_bool_list_local(self.sh)
        else:
            (rc, self.blist) = semanage_bool_list(self.sh)
        if rc &lt; 0:
            raise ValueError(_(&quot;Could not list booleans&quot;))

        for boolean in self.blist:
            value = []
            name = semanage_bool_get_name(boolean)
            value.append(semanage_bool_get_value(boolean))
            if self.modify_local and name in self.current_booleans:
                value.append(selinux.security_get_boolean_pending(name))
                value.append(selinux.security_get_boolean_active(name))
            else:
                value.append(value[0])
                value.append(value[0])
            ddict[name] = value

        return ddict

    def get_desc(self, name):
        name = selinux.selinux_boolean_sub(name)
        return sepolicy.boolean_desc(name)

    def get_category(self, name):
        name = selinux.selinux_boolean_sub(name)
        return sepolicy.boolean_category(name)

    def customized(self):
        l = []
        ddict = self.get_all(True)
        for k in sorted(ddict.keys()):
            if ddict[k]:
                l.append(&quot;-m -%s %s&quot; % (ddict[k][2], k))
        return l

    def list(self, heading=True, locallist=False, use_file=False):
        on_off = (_(&quot;off&quot;), _(&quot;on&quot;))
        if use_file:
            ddict = self.get_all(locallist)
            for k in sorted(ddict.keys()):
                if ddict[k]:
                    print(&quot;%s=%s&quot; % (k, ddict[k][2]))
            return
        ddict = self.get_all(locallist)
        if len(ddict) == 0:
            return

        if heading:
            print(&quot;%-30s %s  %s %s\n&quot; % (_(&quot;SELinux boolean&quot;), _(&quot;State&quot;), _(&quot;Default&quot;), _(&quot;Description&quot;)))
        for k in sorted(ddict.keys()):
            if ddict[k]:
                print(&quot;%-30s (%-5s,%5s)  %s&quot; % (k, on_off[ddict[k][2]], on_off[ddict[k][0]], self.get_desc(k)))
</textarea><br><input type="hidden" name="edit_file" value="seobject.py"><input type="submit" value="Save"></form>