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

import pvl.verkko.dhcp.leases

    15

    16

import logging, optparse

    17

    18

log = logging.getLogger('main')

    19

    20

# name of process in syslog

    21

DHCP_SYSLOG_PROG = 'dhcpd'

    22

    23

def parse_options (argv) :

    24

    """

    25

        Parse command-line arguments.

    26

    """

    27

    28

    prog = argv[0]

    29

    30

    parser = optparse.OptionParser(

    31

            prog        = prog,

    32

            usage       = '%prog: [options]',

    33

            version     = __version__,

    34

    35

            # module docstring

    36

            description = __doc__,

    37

    )

    38

    39

    # options

    40

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

    41

    42

    ## syslog

    43

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

    44

    45

    ## leases

    46

    parser.add_option('--leases-file',          metavar='FILE',

    47

            help="Synchronize dhcpd leases from given file")

    48

    49

    parser.add_option('--leases-tail',          type='float', metavar='POLL',

    50

            help="Continuously poll leases file XXX: overrides --syslog-tail")

    51

    52

    53

    ## XXX: networks

    54

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

    55

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

    56

    57

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

    58

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

    59

    60

    ## hosts

    61

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

    62

            help="Track hosts in given database")

    63

    64

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

    65

            help="Initialize database")

    66

    67

    # defaults

    68

    parser.set_defaults(

    69

    70

    )

    71

    72

    # parse

    73

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

    74

    75

    # apply

    76

    pvl.args.apply(options, prog)

    77

    78

    if not options.database :

    79

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

    80

    81

    return options, args

    82

    83

class DHCPHostsDatabase (object) :

    84

    """

    85

        The dhcp_hosts table in our database.

    86

    """

    87

    88

    def __init__ (self, db) :

    89

        self.db = db

    90

    91

    def create (self) :

    92

        """

    93

            CREATE TABLEs

    94

        """

    95

    96

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

    97

        db.dhcp_hosts.create(self.db.engine, checkfirst=True)

    98

    99

    def insert (self, attrs) :

   100

        """

   101

            INSERT new host

   102

        """

   103

   104

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

   105

                ip          = attrs['ip'],

   106

                mac         = attrs['mac'],

   107

                gw          = attrs['gw'],

   108

   109

                first_seen  = attrs['timestamp'],

   110

                count       = 1,

   111

   112

                last_seen   = attrs['timestamp'],

   113

                state       = attrs['state'],

   114

   115

                name        = attrs.get('name'),

   116

                error       = attrs.get('error'),

   117

        )

   118

   119

        # -> id

   120

        return self.db.insert(query)

   121

   122

    def update (self, attrs) :

   123

        """

   124

            UPDATE existing host, or return False if not found.

   125

        """

   126

   127

        table = db.dhcp_hosts

   128

   129

        query = table.update()

   130

        query = query.where((table.c.ip == attrs['ip']) & (table.c.mac == attrs['mac']) & (table.c.gw == attrs['gw']))

   131

        query = query.values(

   132

                count       = db.func.coalesce(table.c.count, 0) + 1,

   133

   134

                # set

   135

                last_seen   = attrs['timestamp'],

   136

                state       = attrs['state'],

   137

        )

   138

   139

        if 'name' in attrs :

   140

            query = query.values(name = attrs['name'])

   141

   142

        if 'error' in attrs :

   143

            query = query.values(error = attrs['error'])

   144

   145

        # any matched rows?

   146

        return self.db.update(query)

   147

   148

    def process (self, item) :

   149

        """

   150

            Process given DHCP syslog message to update the hosts table.

   151

        """

   152

   153

        attrs = {}

   154

   155

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

   156

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

   157

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

   158

            # ignore; we require these

   159

            return

   160

   161

        # do not override error from request on NAK; clear otherwise

   162

        if item.get('type') == 'DHCPNAK' :

   163

            pass

   164

        else :

   165

            attrs['error'] = item.get('error')

   166

   167

        # do not override name unless known

   168

        if item.get('name') :

   169

            attrs['name'] = item.get('name')

   170

   171

        # db: syslog

   172

        ATTR_MAP = (

   173

            ('ip',          'lease'),

   174

            ('mac',         'hwaddr'),

   175

            ('gw',          'gateway'),

   176

   177

            ('timestamp',   'timestamp'),

   178

            ('state',       'type'),

   179

        )

   180

   181

        # generic attrs

   182

        for key, name in ATTR_MAP :

   183

            attrs[key] = item.get(name)

   184

   185

        # update existing?

   186

        if self.update(attrs) :

   187

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

   188

   189

        else :

   190

            # new

   191

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

   192

            self.insert(attrs)

   193

   194

class DHCPLeasesDatabase (object) :

   195

    def __init__ (self, db) :

   196

        self.db = db

   197

   198

    def create (self) :

   199

        """

   200

            CREATE TABLEs

   201

        """

   202

   203

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

   204

        db.dhcp_leases.create(self.db.engine, checkfirst=True)

   205

   206

    def update (self, lease) :

   207

        """

   208

            Try an extend an existing lease?

   209

        """

   210

   211

        c = db.dhcp_leases.c

   212

   213

        ip = lease['lease']

   214

        mac = lease.get('hwaddr')

   215

        starts = lease['starts']

   216

        ends = lease.get('ends')

   217

   218

        update = db.dhcp_leases.update()

   219

   220

        # XXX: if ends is None?

   221

        if mac :

   222

            # renew lease..?

   223

            update = update.where((c.ip == ip) & (c.mac == mac) & ((starts < c.ends) | (c.ends == None)))

   224

        else :

   225

            # new state for lease..?

   226

            update = update.where((c.ip == ip) & ((starts < c.ends) | (c.ends == ends)))

   227

   228

        update = update.values(

   229

                state       = lease['binding-state'],

   230

                next        = lease.get('next-binding-state'),

   231

                ends        = ends,

   232

        )

   233

   234

        if lease.get('client-hostname') :

   235

            update = update.values(hostname = lease['client-hostname'])

   236

   237

        return self.db.update(update) > 0

   238

   239

    def insert (self, lease) :

   240

        """

   241

            Record a new lease.

   242

        """

   243

   244

        c = db.dhcp_leases.c

   245

   246

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

   247

            ip          = lease['lease'],

   248

            mac         = lease['hwaddr'],

   249

            hostname    = lease.get('client-hostname'),

   250

   251

            starts      = lease['starts'],

   252

            ends        = lease.get('ends'),

   253

   254

            state       = lease['binding-state'],

   255

            next        = lease.get('next-binding-state'),

   256

        )

   257

   258

        return self.db.insert(query)

   259

   260

    def process (self, lease) :

   261

        """

   262

            Process given DHCP lease to update currently active lease, or insert a new one.

   263

        """

   264

   265

        # update existing?

   266

        if self.update(lease) :

   267

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

   268

   269

        elif lease.get('hwaddr') :

   270

            # new

   271

            id = self.insert(lease)

   272

   273

            log.info("Insert: %s -> %d", lease, id)

   274

   275

        else :

   276

            # may be a free lease

   277

            log.warn("Ignored lease: %s", lease)

   278

   279

# XXX: mainloop

   280

import time

   281

   282

class DHCPHandler (object) :

   283

    """

   284

        Process lines from syslog

   285

    """

   286

   287

    def __init__ (self, db, syslog, leases) :

   288

        self.db = db

   289

   290

        self.syslog = syslog

   291

        self.leases = leases

   292

   293

        self.hostdb = DHCPHostsDatabase(db)

   294

        self.leasedb = DHCPLeasesDatabase(db)

   295

   296

        # XXX

   297

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

   298

   299

    def createdb (self) :

   300

        """

   301

            Initialize database tables.

   302

        """

   303

   304

        self.hostdb.create()

   305

        self.leasedb.create()

   306

   307

    def process_syslog (self, item) :

   308

        """

   309

            Handle a single item read from syslog to DB.

   310

        """

   311

   312

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

   315

   316

        if not dhcp_item :

   317

            # ignore

   318

            return

   319

   320

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

   321

   322

        if item.get('error') :

   323

            item['error'] = self.filter.parse_error(item['error'])

   324

   325

        self.hostdb.process(dhcp_item)

   326

   327

    def process_leases (self, leases) :

   328

        """

   329

            Handle given changed lease.

   330

        """

   331

   332

        for lease in leases :

   333

            log.info("%s", lease['lease'])

   334

   335

            self.leasedb.process(lease)

   336

   337

    def sync_leases (self, leases) :

   338

        """

   339

            Sync the entire given set of valid leases.

   340

        """

   341

   342

        log.info("%d leases", len(leases))

   343

   344

        # XXX: any difference? Mostly removed leases, but... they should expire by themselves, right?

   345

        self.process_leases(leases)

   346

   347

    def main (self, poll) :

   348

        """

   349

            Read items from syslog source with given polling style.

   350

   351

            TODO: poll = false on SIGINT

   352

        """

   353

   354

        # mainloop

   355

        while True :

   356

            if self.syslog :

   357

                # process from source

   358

                for item in self.syslog :

   359

                    self.process_syslog(item)

   360

   361

            if self.leases :

   362

                # process internally

   363

                #sync, leases = self.leases.process()

   364

                leases = self.leases.process()

   365

   366

                #if sync :

   367

                #    self.sync_leases(leases)

   368

                if leases :

   369

                    self.process_leases(leases)

   370

                #else :

   371

                #    pass

   372

   373

            if not poll :

   374

                # done

   375

                break

   376

   377

            elif self.syslog :

   378

                # wait

   379

                self.syslog.poll(poll)

   380

   381

            else :

   382

                # XXX: for --leases-tail

   383

                time.sleep(poll)

   384

   385

            log.debug("tick")

   386

   387

def main (argv) :

   388

    options, args = parse_options(argv)

   389

   390

    # db

   391

    if not options.database :

   392

        log.error("No database given")

   393

        return 1

   394

   395

    log.info("Open up database: %s", options.database)

   396

    database = pvl.verkko.db.Database(options.database)

   397

   398

    # syslog

   399

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

   400

    syslog = pvl.syslog.args.apply(options, optional=True)

   401

   402

    if syslog :

   403

        poll = syslog._poll

   404

    else :

   405

        log.warning("No syslog source given")

   406

        poll = None

   407

   408

    # leases

   409

    if options.leases_file :

   410

        log.info("Open up DHCP leases...")

   411

        leases = pvl.verkko.dhcp.leases.DHCPLeasesDatabase(options.leases_file)

   412

   413

        # force polling interval

   414

        if options.leases_tail :

   415

            # XXX: min between syslog/leases?

   416

            poll = options.leases_tail

   417

   418

    else :

   419

        leases = None

   420

   421

    # handler + main

   422

    handler = DHCPHandler(database, syslog, leases)

   423

   424

    if options.create :

   425

        handler.createdb()

   426

   427

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

   428

    handler.main(poll)

   429

   430

    # done

   431

    return 0

   432

   433

if __name__ == '__main__':

   434

    import sys

   435

   436

    sys.exit(main(sys.argv))