1

#!/usr/bin/env python

     2

     3

"""

     4

    Monitor DHCP use.

     5

"""

     6

     7

__version__ = '0.0'

     8

     9

import pvl.args

    10

import pvl.syslog.args

    11

    12

import pvl.verkko.db as db

    13

import pvl.syslog.dhcp

    14

    15

import logging, optparse

    16

    17

log = logging.getLogger('main')

    18

    19

# name of process in syslog

    20

DHCP_SYSLOG_PROG = 'dhcpd'

    21

    22

def parse_options (argv) :

    23

    """

    24

        Parse command-line arguments.

    25

    """

    26

    27

    prog = argv[0]

    28

    29

    parser = optparse.OptionParser(

    30

            prog        = prog,

    31

            usage       = '%prog: [options]',

    32

            version     = __version__,

    33

    34

            # module docstring

    35

            description = __doc__,

    36

    )

    37

    38

    # options

    39

    parser.add_option_group(pvl.args.parser(parser))

    40

    41

    ## syslog

    42

    parser.add_option_group(pvl.syslog.args.parser(parser, prog=DHCP_SYSLOG_PROG))

    43

    44

    ## XXX: networks

    45

    parser.add_option('--network',              metavar='NET', action='append',

    46

            help="Filter leases by network prefix as plugin instance")

    47

    48

    parser.add_option('--gateway',              metavar='GW/IFACE', action='append',

    49

            help="Filter messages by gateway/interface as plugin instance")

    50

    51

    ## hosts

    52

    parser.add_option('--database',             metavar='URI',

    53

            help="Track hosts in given database")

    54

    55

    parser.add_option('--create',               action='store_true',

    56

            help="Initialize database")

    57

    58

    # defaults

    59

    parser.set_defaults(

    60

    61

    )

    62

    63

    # parse

    64

    options, args = parser.parse_args(argv[1:])

    65

    66

    # apply

    67

    pvl.args.apply(options, prog)

    68

    69

    if not options.database :

    70

        parser.error("Missing required option: --database")

    71

    72

    return options, args

    73

    74

class DHCPHostsDatabase (db.Database) :

    75

    76

    def create (self) :

    77

        """

    78

            CREATE TABLEs

    79

        """

    80

    81

        log.info("Creating database tables: dhcp_hosts")

    82

        db.dhcp_hosts.create(self.engine)

    83

    84

    def insert (self, attrs) :

    85

        """

    86

            INSERT new host

    87

        """

    88

    89

        query = db.dhcp_hosts.insert().values(

    90

                ip          = attrs['ip'],

    91

                mac         = attrs['mac'],

    92

                gw          = attrs['gw'],

    93

    94

                first_seen  = attrs['timestamp'],

    96

    97

                last_seen   = attrs['timestamp'],

   102

        )

   104

        id, = result.inserted_primary_key

   105

   106

        return id

   107

   108

    def update (self, attrs) :

   109

        """

   110

            UPDATE existing host, or return False if not found.

   111

        """

   112

   113

        table = db.dhcp_hosts

   114

   119

   120

                # set

   121

                last_seen   = attrs['timestamp'],

   123

        )

   132

   133

        # any matched rows?

   134

        return result.rowcount > 0

   135

   136

    def process (self, item) :

   137

        """

   138

            Process given DHCP syslog message to update the hosts table.

   139

        """

   142

   143

        # ignore unless we have enough info to fully identify the client

   144

        # this means that we omit DHCPDISCOVER messages, but we get the OFFER/REQUEST/ACK

   145

        if any(name not in item for name in ('lease', 'hwaddr', 'gateway')) :

   146

            # ignore; we require these

   147

            return

   148

   159

        # db: syslog

   160

        ATTR_MAP = (

   161

            ('ip',          'lease'),

   162

            ('mac',         'hwaddr'),

   163

            ('gw',          'gateway'),

   164

   165

            ('timestamp',   'timestamp'),

   166

            ('state',       'type'),

   167

        )

   168

   172

   173

        # update existing?

   174

        if self.update(attrs) :

   175

            log.info("Update: %s", attrs)

   176

   177

        else :

   178

            # new

   179

            log.info("Insert: %s", attrs)

   180

            self.insert(attrs)

   181

   182

class DHCPSyslogHandler (object) :

   183

    """

   184

        Process lines from syslog

   185

    """

   186

   187

    def __init__ (self, db) :

   188

        self.db = db

   189

   190

        # XXX

   191

        self.filter = pvl.syslog.dhcp.DHCPSyslogFilter()

   192

   193

    def process (self, item) :

   194

        """

   195

            Handle a single item read from syslog to DB.

   196

        filter = pvl.syslog.dhcp.DHCPSyslogFilter()

   197

        """

   198

   199

        dhcp_item = self.filter.parse(item['msg'])

   200

   201

        if not dhcp_item :

   202

            # ignore

   203

            return

   204

   205

        dhcp_item['timestamp'] = item['timestamp'] # XXX: fixup DHCPSyslogParser?

   206

   210

        self.db.process(dhcp_item)

   211

   212

    def main (self, source, poll) :

   213

        """

   214

            Read items from syslog source with given polling style.

   215

   216

            TODO: poll = false on SIGINT

   217

        """

   218

   219

        parser = pvl.syslog.parser.SyslogParser()

   220

   221

        # mainloop

   222

        while True :

   223

            # process from source

   224

            for item in parser.process(source) :

   225

                self.process(item)

   226

   227

            if poll is False :

   228

                # done

   229

                break

   230

            else :

   231

                # wait

   232

                source.poll(poll)

   233

   234

            log.debug("tick")

   235

   236

def main (argv) :

   237

    options, args = parse_options(argv)

   238

   250

    # syslog

   251

    log.info("Open up syslog...")

   252

    syslog_parser = pvl.syslog.parser.SyslogParser(prog=DHCP_SYSLOG_PROG) # filter by prog

   253

   254

    if options.syslog_fifo :

   255

        source = pvl.syslog.fifo.Fifo(options.syslog_fifo)

   256

        poll = None # no timeout

   257

   258

    elif options.syslog_tail :

   259

        # continuous file tail

   260

        source = pvl.syslog.tail.TailFile(options.syslog_file)

   261

        poll = options.syslog_tail # polling interval

   262

   263

    elif options.syslog_file :

   264

        # one-shot file read

   265

        source = pvl.syslog.tail.TailFile(options.syslog_file)

   266

        poll = False # do not poll-loop

   267

   268

    else :

   271

   272

    # handler + main

   273

    handler = DHCPSyslogHandler(database)

   274

   275

    log.info("Enter mainloop...")

   276

    handler.main(source, poll)

   277

   278

    # done

   279

    return 0

   280

   281

if __name__ == '__main__':

   282

    import sys

   283

   284

    sys.exit(main(sys.argv))