1

"""

     2

    CLI argument handling; common stuff: logging

     3

"""

     4

     5

import optparse

     6

import logging

     7

     8

import pwd, grp, os, sys

     9

    10

import logging; log = logging.getLogger('pvl.args')

    11

    12

def parser (parser, setuid=None) :

    13

    """

    14

        Return an optparse.OptionGroup.

    15

    """

    16

    17

    if setuid is None :

    18

        # autodetect: only if we will be capable of

    19

        # XXX: use linux capabilities?

    20

        setuid = (os.geteuid() == 0)

    21

    22

    general = optparse.OptionGroup(parser, "General options")

    23

    24

    general.add_option('-q', '--quiet',     dest='loglevel', action='store_const', const=logging.ERROR, help="Less output")

    25

    general.add_option('-v', '--verbose',   dest='loglevel', action='store_const', const=logging.INFO,  help="More output")

    26

    general.add_option('-D', '--debug',     dest='loglevel', action='store_const', const=logging.DEBUG, help="Even more output")

    27

    general.add_option('--log-file',                                                                    help="Log to file")

    28

    general.add_option('--debug-module',    action='append', metavar='MODULE', 

    29

            help="Enable logging for the given logger/module name")

    30

    31

    if setuid :

    32

        general.add_option('--uid',             help="Change uid")

    33

        general.add_option('--gid',             help="Change gid")

    34

    35

    # defaults

    36

    parser.set_defaults(

    37

        _setuid             = setuid,

    38

        logname             = parser.prog,

    39

        loglevel            = logging.WARN,

    40

        debug_module        = [],

    41

    )

    42

    43

    return general

    44

    45

def options (**options) :

    46

    """

    47

        Synthensise options.

    48

    """

    49

    50

    return optparse.Values(options)

    51

    52

def apply_setid (options, rootok=None) :

    53

    """

    54

        Drop privileges if running as root.

    55

    56

        XXX: this feature isn't very useful (import-time issues etc), but in certain cases (syslog-ng -> python),

    57

        it's difficult to avoid this without some extra wrapper tool..?

    58

    """

    59

    60

    # --uid -> pw

    61

    if not options.uid :

    62

        pw = None

    63

    elif options.uid.isdigit() :

    64

        pw = pwd.getpwuid(int(options.uid))

    65

    else :

    66

        pw = pwd.getpwnam(options.uid)

    67

    68

    # --gid -> gr

    69

    if not options.gid and not pw :

    70

        gr = None

    71

    elif not options.gid :

    72

        gr = grp.getgrgid(pw.pw_gid)

    73

    elif options.gid.isdigit() :

    74

        gr = grp.getgrgid(str(options.gid))

    75

    else :

    76

        gr = grp.getgrnam(options.gid)

    77

    78

    if gr :

    79

        # XXX: secondary groups? seem to get cleared

    80

        log.info("setgid: %s: %s", gr.gr_name, gr.gr_gid)

    81

        os.setgid(gr.gr_gid)

    82

    83

    if pw :

    84

        log.info("setuid: %s: %s", pw.pw_name, pw.pw_uid)

    85

        os.setuid(pw.pw_uid)

    86

    87

    elif os.getuid() == 0 :

    88

        if rootok :

    89

            log.info("running as root")

    90

        else :

    91

            log.error("refusing to run as root, use --uid 0 to override")

    92

            sys.exit(2)

    93

    94

def apply (options, logname=None, rootok=True) :

    95

    """

    96

        Apply the optparse options.

    97

    """

    98

    99

    if logname :

   100

        prefix = options.logname + ': '

   101

    else :

   102

        prefix = ''

   103

   104

    # configure

   105

    logging.basicConfig(

   106

        # XXX: log Class.__init__ as Class, not __init__?

   107

        format      = prefix + '%(name)-20s: %(levelname)5s %(funcName)s: %(message)s',

   108

        level       = options.loglevel,

   109

        filename    = options.log_file,

   110

    )

   111

   112

    # TODO: use --quiet for stdout output?

   113

    options.quiet = options.loglevel > logging.WARN

   114

   115

    if options._setuid :

   116

        if options.uid or options.gid or not rootok :

   117

            # set uid/gid

   118

            apply_setid(options, rootok=rootok)

   119

   120

    # enable debugging for specific targets

   121

    for logger in options.debug_module :

   122

        logging.getLogger(logger).setLevel(logging.DEBUG)

   123