Gecko [ oric.aiou.edu.pk ]

Name	Size	Permission
__pycache__	[ DIR ]	drwxr-xr-x
test	[ DIR ]	drwxr-xr-x
__init__.py	442 B	-rw-r--r--
inetd.py	1.92 KB	-rw-r--r--
inetdconf.py	4.8 KB	-rw-r--r--
inetdtap.py	3.47 KB	-rw-r--r--
procmon.py	12.38 KB	-rw-r--r--
procmontap.py	2.24 KB	-rw-r--r--

Code Editor : inetdconf.py

# -*- test-case-name: twisted.runner.test.test_inetdconf -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Parser for inetd.conf files
"""

# Various exceptions
class InvalidConfError(Exception):
    """
    Invalid configuration file
    """

class InvalidInetdConfError(InvalidConfError):
    """
    Invalid inetd.conf file
    """

class InvalidServicesConfError(InvalidConfError):
    """
    Invalid services file
    """

class UnknownService(Exception):
    """
    Unknown service name
    """

class SimpleConfFile:
    """
    Simple configuration file parser superclass.

Filters out comments and empty lines (which includes lines that only
    contain comments).

To use this class, override parseLine or parseFields.
    """

commentChar = '#'
    defaultFilename = None

def parseFile(self, file=None):
        """
        Parse a configuration file

If file is None and self.defaultFilename is set, it will open
        defaultFilename and use it.
        """
        close = False
        if file is None and self.defaultFilename:
            file = open(self.defaultFilename,'r')
            close = True

try:
            for line in file.readlines():
                # Strip out comments
                comment = line.find(self.commentChar)
                if comment != -1:
                    line = line[:comment]

# Strip whitespace
                line = line.strip()

# Skip empty lines (and lines which only contain comments)
                if not line:
                    continue

self.parseLine(line)
        finally:
            if close:
                file.close()

def parseLine(self, line):
        """
        Override this.

By default, this will split the line on whitespace and call
        self.parseFields (catching any errors).
        """
        try:
            self.parseFields(*line.split())
        except ValueError:
            raise InvalidInetdConfError('Invalid line: ' + repr(line))

def parseFields(self, *fields):
        """
        Override this.
        """

class InetdService:
    """
    A simple description of an inetd service.
    """
    name = None
    port = None
    socketType = None
    protocol = None
    wait = None
    user = None
    group = None
    program = None
    programArgs = None

def __init__(self, name, port, socketType, protocol, wait, user, group,
                 program, programArgs):
        self.name = name
        self.port = port
        self.socketType = socketType
        self.protocol = protocol
        self.wait = wait
        self.user = user
        self.group = group
        self.program = program
        self.programArgs = programArgs

class InetdConf(SimpleConfFile):
    """
    Configuration parser for a traditional UNIX inetd(8)
    """

defaultFilename = '/etc/inetd.conf'

def __init__(self, knownServices=None):
        self.services = []

if knownServices is None:
            knownServices = ServicesConf()
            knownServices.parseFile()
        self.knownServices = knownServices

def parseFields(self, serviceName, socketType, protocol, wait, user,
                    program, *programArgs):
        """
        Parse an inetd.conf file.

Implemented from the description in the Debian inetd.conf man page.
        """
        # Extract user (and optional group)
        user, group = (user.split('.') + [None])[:2]

# Find the port for a service
        port = self.knownServices.services.get((serviceName, protocol), None)
        if not port and not protocol.startswith('rpc/'):
            # FIXME: Should this be discarded/ignored, rather than throwing
            #        an exception?
            try:
                port = int(serviceName)
                serviceName = 'unknown'
            except:
                raise UnknownService("Unknown service: %s (%s)" % (
                    serviceName, protocol))

self.services.append(InetdService(serviceName, port, socketType,
                                          protocol, wait, user, group, program,
                                          programArgs))

class ServicesConf(SimpleConfFile):
    """
    /etc/services parser

@ivar services: dict mapping service names to (port, protocol) tuples.
    """

defaultFilename = '/etc/services'

def __init__(self):
        self.services = {}

def parseFields(self, name, portAndProtocol, *aliases):
        try:
            port, protocol = portAndProtocol.split('/')
            port = int(port)
        except:
            raise InvalidServicesConfError(
                'Invalid port/protocol: %s' % (repr(portAndProtocol),))

self.services[(name, protocol)] = port
        for alias in aliases:
            self.services[(alias, protocol)] = port

${this.title}

Code Editor : inetdconf.py