1#@!#!123s

: / lib / python3 / dist-packages / twisted / runner /
Filename : inetdconf.py
back
# -*- test-case-name: twisted.runner.test.test_inetdconf -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

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

from typing import Optional


# 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: Optional[str] = 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)
            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 BaseException:
                raise UnknownService(f"Unknown service: {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 BaseException:
            raise InvalidServicesConfError(
                f"Invalid port/protocol: {repr(portAndProtocol)}"
            )

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