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.web.args

    15

import pvl.rrd.hosts

    16

import pvl.verkko.wlan

    17

    18

import optparse

    19

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

    20

    21

WLAN_STA_PROG = 'hostapd'

    22

    23

def parse_argv (argv, doc = __doc__) :

    24

    """

    25

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

    26

    """

    27

    28

    prog = argv.pop(0)

    29

    args = argv

    30

    31

    # optparse

    32

    parser = optparse.OptionParser(

    33

        prog        = prog,

    34

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

    35

        version     = __version__,

    36

        description = doc,

    37

    )

    38

    39

    # common

    40

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

    41

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

    42

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

    43

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

    44

    45

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

    46

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

    47

    48

    # parse

    49

    options, args = parser.parse_args(args)

    50

    51

    # apply

    52

    pvl.args.apply(options)

    53

    54

    return options, args

    55

    56

import re

    57

from pvl.verkko import db

    58

    59

class KeyTimestampDatabase (object) :

    60

    """

    61

        A pvl.verkko.db table that tracks events by key/timestamp.

    62

    """

    63

    64

    DB_TABLE = None

    65

    DB_LAST_SEEN = None

    66

    DB_COUNT = None

    67

    DB_DISTINCT = None

    68

    69

    def __init__ (self, db) :

    70

        """

    71

            db      - pvl.verkko.db.Database

    72

        """

    73

    74

        self.db = db

    75

    76

    def select (self, interval=None) :

    77

        """

    78

            SELECT unique gw/ip hosts, for given interval.

    79

        """

    80

    81

        query = db.select(self.DB_DISTINCT, distinct=True)

    82

    83

        if interval :

    84

            # timedelta

    85

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

    86

    87

        return self.db.select(query)

    88

    89

    def insert (self, key, timestamp, update) :

    90

        """

    91

            INSERT new row.

    92

        """

    93

    94

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

    95

                first_seen  = timestamp,

    96

                last_seen   = timestamp,

    97

        )

    98

    99

        if self.DB_COUNT is not None :

   100

            query = query.values(count=1)

   101

   102

        # -> id

   103

        return self.db.insert(query)

   104

   105

    def update (self, key, timestamp, update) :

   106

        """

   107

            UPDATE existing row, or return False if not found.

   108

        """

   109

   110

        table = self.DB_TABLE

   111

        query = table.update()

   112

   113

        for col, value in key.iteritems() :

   114

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

   115

   116

        query = query.values(last_seen=timestamp)

   117

   118

        if self.DB_COUNT is not None :

   119

            query = query.values(count=db.func.coalesce(self.DB_COUNT, 0) + 1)

   120

   121

        query = query.values(**update)

   122

   123

        # -> any matched rows?

   124

        return self.db.update(query)

   125

   126

    def touch (self, key, timestamp, update, **opts) :

   127

        # update existing?

   128

        if self.update(key, timestamp, update, **opts) :

   129

            log.info("Update: %s: %s: %s", key, timestamp, update)

   130

        else :

   131

            log.info("Insert: %s: %s: %s", key, timestamp, update)

   132

            self.insert(key, timestamp, update, **opts)

   133

   134

   135

class WlanStaDatabase (KeyTimestampDatabase) :

   136

    HOSTAPD_STA_RE = re.compile(r'(?P<wlan>.+?): STA (?P<sta>.+?) (?P<msg>.+)')

   137

   138

    DB_TABLE = db.wlan_sta

   139

    DB_LAST_SEEN = db.wlan_sta.c.last_seen

   140

    DB_COUNT = db.wlan_sta.c.count

   141

   142

    DB_DISTINCT = (db.wlan_sta.c.sta, )

   143

   144

    def __init__ (self, db, interface_map=None) :

   145

        """

   146

            interface_map       - {(hostname, interface): (nodename, wlan)}

   147

        """

   148

        KeyTimestampDatabase.__init__(self, db)

   149

        self.interface_map = interface_map

   150

   151

    def parse (self, item) :

   152

        """

   153

            Parse fields from a hostapd syslog message.

   154

        """

   155

   156

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

   157

   158

        if not match :

   159

            return None

   160

   161

        return match.groupdict()

   162

   163

    def lookup_wlan (self, host, iface) :

   164

        """

   165

            Lookup ap/ssid by host/iface.

   166

        """

   167

        mapping = None

   168

        if self.interface_map :

   169

            mapping = self.interface_map.get((host, iface))

   170

   171

        if mapping :

   172

            return mapping

   173

        else :

   174

            # as-is

   175

            log.warning("Unknown host/iface: %s/%s", host, iface)

   176

            return host, iface

   177

   178

    def __call__ (self, item) :

   179

        match = self.parse(item)

   180

   181

        if not match :

   182

            return

   183

   184

        # lookup?

   185

        ap, ssid = self.lookup_wlan(item['host'], match['wlan'])

   186

   187

        # update/insert

   188

        self.touch(

   189

            dict(ap=ap, wlan=ssid, sta=match['sta']),

   190

            item['timestamp'],

   191

            dict(msg=match['msg']),

   192

        )

   193

   194

def main (argv) :

   195

    options, args = parse_argv(argv)

   196

   197

    # database

   198

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

   199

   200

    if options.interfaces :

   201

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

   202

    else :

   203

        interfaces = None

   204

   205

    # syslog

   206

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

   207

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

   208

   209

    if syslog :

   210

        # handler

   211

        handler = WlanStaDatabase(db, interface_map=interfaces)

   212

   213

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

   214

        for source in syslog.main() :

   215

            for item in source:

   216

                handler(item)

   217

    else :

   218

        # run web

   219

        application = pvl.web.args.apply(options, pvl.verkko.wlan.Application, db)

   220

        return pvl.web.args.main(options, application)

   221

   222

    return 0

   223

   224

if __name__ == '__main__':

   225

    import sys

   226

   227

    sys.exit(main(sys.argv))