<h2>Editing File: /lib/python3.6/site-packages/sepolgen/module.py</h2><form method='post'><textarea name='content' class='file-edit'># Authors: Karl MacMillan &lt;kmacmillan@mentalrootkit.com&gt;
#
# Copyright (C) 2006 Red Hat 
# see file 'COPYING' for use and warranty information
#
# 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; version 2 only
#
# 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
#

&quot;&quot;&quot;
Utilities for dealing with the compilation of modules and creation
of module tress.
&quot;&quot;&quot;

import re
import tempfile
try:
    from subprocess import getstatusoutput
except ImportError:
    from commands import getstatusoutput
import os
import os.path
import shutil

import selinux

from . import defaults


def is_valid_name(modname):
    &quot;&quot;&quot;Check that a module name is valid.
    &quot;&quot;&quot;
    m = re.findall(r&quot;[^a-zA-Z0-9_\-\.]&quot;, modname)
    if len(m) == 0 and modname[0].isalpha():
        return True
    else:
        return False

class ModuleTree:
    def __init__(self, modname):
        self.modname = modname
        self.dirname = None

    def dir_name(self):
        return self.dirname

    def te_name(self):
        return self.dirname + &quot;/&quot; + self.modname + &quot;.te&quot;

    def fc_name(self):
        return self.dirname + &quot;/&quot; + self.modname + &quot;.fc&quot;

    def if_name(self):
        return self.dirname + &quot;/&quot; + self.modname + &quot;.if&quot;

    def package_name(self):
        return self.dirname + &quot;/&quot; + self.modname + &quot;.pp&quot;

    def makefile_name(self):
        return self.dirname + &quot;/Makefile&quot;

    def create(self, parent_dirname, makefile_include=None):
        self.dirname = parent_dirname + &quot;/&quot; + self.modname
        os.mkdir(self.dirname)
        fd = open(self.makefile_name(), &quot;w&quot;)
        if makefile_include:
            fd.write(&quot;include &quot; + makefile_include)
        else:
            fd.write(&quot;include &quot; + defaults.refpolicy_makefile())
        fd.close()

        # Create empty files for the standard refpolicy
        # module files
        open(self.te_name(), &quot;w&quot;).close()
        open(self.fc_name(), &quot;w&quot;).close()
        open(self.if_name(), &quot;w&quot;).close()

def modname_from_sourcename(sourcename):
    return os.path.splitext(os.path.split(sourcename)[1])[0]

class ModuleCompiler:
    &quot;&quot;&quot;ModuleCompiler eases running of the module compiler.

    The ModuleCompiler class encapsulates running the commandline
    module compiler (checkmodule) and module packager (semodule_package).
    You are likely interested in the create_module_package method.
    
    Several options are controlled via paramaters (only effects the 
    non-refpol builds):
    
     .mls          [boolean] Generate an MLS module (by passed -M to
                   checkmodule). True to generate an MLS module, false
                   otherwise.
                   
     .module       [boolean] Generate a module instead of a base module.
                   True to generate a module, false to generate a base.
                   
     .checkmodule  [string] Fully qualified path to the module compiler.
                   Default is /usr/bin/checkmodule.
                   
     .semodule_package [string] Fully qualified path to the module
                   packager. Defaults to /usr/bin/semodule_package.
     .output       [file object] File object used to write verbose
                   output of the compililation and packaging process.
    &quot;&quot;&quot;
    def __init__(self, output=None):
        &quot;&quot;&quot;Create a ModuleCompiler instance, optionally with an
        output file object for verbose output of the compilation process.
        &quot;&quot;&quot;
        self.mls = selinux.is_selinux_mls_enabled()
        self.module = True
        self.checkmodule = &quot;/usr/bin/checkmodule&quot;
        self.semodule_package = &quot;/usr/bin/semodule_package&quot;
        self.output = output
        self.last_output = &quot;&quot;
        self.refpol_makefile = defaults.refpolicy_makefile()
        self.make = &quot;/usr/bin/make&quot;

    def o(self, str):
        if self.output:
            self.output.write(str + &quot;\n&quot;)
        self.last_output = str

    def run(self, command):
        self.o(command)
        rc, output = getstatusoutput(command)
        self.o(output)
        
        return rc
    
    def gen_filenames(self, sourcename):
        &quot;&quot;&quot;Generate the module and policy package filenames from
        a source file name. The source file must be in the form
        of &quot;foo.te&quot;. This will generate &quot;foo.mod&quot; and &quot;foo.pp&quot;.
        
        Returns a tuple with (modname, policypackage).
        &quot;&quot;&quot;
        splitname = sourcename.split(&quot;.&quot;)
        if len(splitname) &lt; 2:
            raise RuntimeError(&quot;invalid sourcefile name %s (must end in .te)&quot;, sourcename)
        # Handle other periods in the filename correctly
        basename = &quot;.&quot;.join(splitname[0:-1])
        modname = basename + &quot;.mod&quot;
        packagename = basename + &quot;.pp&quot;
        
        return (modname, packagename)

    def create_module_package(self, sourcename, refpolicy=True):
        &quot;&quot;&quot;Create a module package saved in a packagename from a
        sourcename.

        The create_module_package creates a module package saved in a
        file named sourcename (.pp is the standard extension) from a
        source file (.te is the standard extension). The source file
        should contain SELinux policy statements appropriate for a
        base or non-base module (depending on the setting of .module).

        Only file names are accepted, not open file objects or
        descriptors because the command line SELinux tools are used.

        On error a RuntimeError will be raised with a descriptive
        error message.
        &quot;&quot;&quot;
        if refpolicy:
            self.refpol_build(sourcename)
        else:
            modname, packagename = self.gen_filenames(sourcename)
            self.compile(sourcename, modname)
            self.package(modname, packagename)
            os.unlink(modname)
            
    def refpol_build(self, sourcename):
        # Compile
        command = self.make + &quot; -f &quot; + self.refpol_makefile
        rc = self.run(command)

        # Raise an error if the process failed
        if rc != 0:
            raise RuntimeError(&quot;compilation failed:\n%s&quot; % self.last_output)
        
    def compile(self, sourcename, modname):
        s = [self.checkmodule]
        if self.mls:
            s.append(&quot;-M&quot;)
        if self.module:
            s.append(&quot;-m&quot;)
        s.append(&quot;-o&quot;)
        s.append(modname)
        s.append(sourcename)

        rc = self.run(&quot; &quot;.join(s))
        if rc != 0:
            raise RuntimeError(&quot;compilation failed:\n%s&quot; % self.last_output)

    def package(self, modname, packagename):
        s = [self.semodule_package]
        s.append(&quot;-o&quot;)
        s.append(packagename)
        s.append(&quot;-m&quot;)
        s.append(modname)
        
        rc = self.run(&quot; &quot;.join(s))
        if rc != 0:
            raise RuntimeError(&quot;packaging failed [%s]&quot; % self.last_output)
        
    
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib%2Fpython3.6%2Fsite-packages%2Fsepolgen'>Back to Directory</a>