1

#!/usr/bin/python

     2

     3

"""

     4

    Analyze WLAN STA logs.

     5

     6

        Jul  3 23:05:04 buffalo-g300n-647682 daemon.info hostapd: wlan0-1: STA aa:bb:cc:dd:ee:ff WPA: group key handshake completed (RSN)

     7

     8

"""

     9

    10

__version__ = '0.1'

    11

    12

import pvl.args

    13

import pvl.syslog.args

    14

import pvl.rrd.hosts

    15

    16

import optparse

    17

import logging; log = logging.getLogger('main')

    18

    19

WLAN_STA_PROG = 'hostapd'

    20

    21

def parse_argv (argv, doc = __doc__) :

    22

    """

    23

        Parse command-line argv, returning (options, args).

    24

    """

    25

    26

    prog = argv.pop(0)

    27

    args = argv

    28

    29

    # optparse

    30

    parser = optparse.OptionParser(

    31

        prog        = prog,

    32

        usage       = '%prog: [options] [<input.txt> [...]]',

    33

        version     = __version__,

    34

        description = doc,

    35

    )

    36

    37

    # common

    38

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

    39

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

    40

    parser.add_option_group(pvl.verkko.db.parser(parser, table=db.wlan_sta))

    41

    42

    parser.add_option('--interfaces', metavar='PATH',

    43

            help="Load interface/node names from mapping file")

    44

    45

    # parse

    46

    options, args = parser.parse_args(args)

    47

    48

    # apply

    49

    pvl.args.apply(options)

    50

    51

    return options, args

    52

    53

import re

    54

from pvl.verkko import db

    55

    60

    67

        """

    71

        self.db = db

    72

    74

        """

    75

            SELECT unique gw/ip hosts, for given interval.

    76

        """

    77

    79

    80

        if interval :

    81

            # timedelta

    82

            query = query.where(db.func.now() - self.DB_LAST_SEEN < interval)

    83

    84

        return self.db.select(query)

    85

    87

        """

    89

        """

    90

    91

        query = self.DB_TABLE.insert().values(**key).values(**update).values(

    92

                first_seen  = timestamp,

    93

                last_seen   = timestamp,

    94

        )

    95

    97

            query = query.values(count=1)

    98

    99

        # -> id

   100

        return self.db.insert(query)

   101

   103

        """

   105

        """

   106

   107

        table = self.DB_TABLE

   108

        query = table.update()

   109

   110

        for col, value in key.iteritems() :

   111

            query = query.where(table.c[col] == value)

   112

   113

        query = query.values(last_seen=timestamp)

   114

   117

   118

        query = query.values(**update)

   119

   120

        # -> any matched rows?

   121

        return self.db.update(query)

   122

   124

        # update existing?

   127

        else :

   147

   148

    def parse (self, item) :

   149

        """

   150

            Parse fields from a hostapd syslog message.

   151

        """

   152

   153

        match = self.HOSTAPD_STA_RE.match(item['msg'])

   154

   155

        if not match :

   156

            return None

   157

   158

        return match.groupdict()

   159

   175

    def __call__ (self, item) :

   176

        match = self.parse(item)

   177

   178

        if not match :

   179

            return

   180

   181

        # lookup?

   183

   184

        # update/insert

   185

        self.touch(

   189

        )

   190

   191

def main (argv) :

   192

    options, args = parse_argv(argv)

   193

   194

    # database

   195

    db = pvl.verkko.db.apply(options)

   196

   197

    if options.interfaces :

   198

        interfaces = dict(pvl.rrd.hosts.map_interfaces(options, open(options.interfaces)))

   199

    else :

   200

        interfaces = None

   201

   202

    # syslog

   203

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

   204

    syslog = pvl.syslog.args.apply(options)

   205

   206

    # handler

   207

    handler = WlanStaDatabase(db, interface_map=interfaces)

   208

   209

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

   210

    for source in syslog.main() :

   211

        for item in source:

   212

            handler(item)

   213

   214

    return 0

   215

   216

if __name__ == '__main__':

   217

    import sys

   218

   219

    sys.exit(main(sys.argv))