1

from pvl.verkko import db, web

     2

from pvl.verkko.utils import parse_timedelta, IPv4Network

     3

     4

from pvl.html import tags as html

     5

     6

import re

     7

import datetime

     8

import socket # dns

     9

import math

    10

    11

import logging; log = logging.getLogger('pvl.verkko.hosts')

    12

    13

# XXX: this should actually be DHCPHost

    14

class Host (object) :

    15

    DATE_FMT = '%Y%m%d'

    16

    17

    MAC_HEX = r'([A-Za-z0-9]{2})'

    18

    MAC_SEP = r'[-:.]?'

    19

    MAC_RE = re.compile(MAC_SEP.join([MAC_HEX] * 6))

    20

    21

    @classmethod

    22

    def query (cls, session, seen=None) :

    23

        """

    24

            seen        - select hosts seen during given timedelta period

    25

        """

    26

    27

        query = session.query(cls)

    28

    29

        return query

    30

    31

    @classmethod

    32

    def normalize_mac (cls, mac) :

    33

        match = cls.MAC_RE.search(mac)

    34

    35

        if not match :

    36

            raise ValueError(mac)

    37

    38

        else :

    39

            return ':'.join(hh.lower() for hh in match.groups())

    40

    41

    def __init__ (self, ip, mac, name=None) :

    42

        self.ip = ip

    43

        self.mac = mac

    44

        self.name = name

    45

    46

    def render_mac (self) :

    47

        if not self.mac :

    48

            return None

    49

    50

        elif len(self.mac) > (6 * 2 + 5) :

    51

            return u'???'

    52

    53

        else :

    54

            return unicode(self.mac)

    55

    56

    def render_name (self) :

    57

        if self.name :

    58

            return self.name.decode('ascii', 'replace')

    59

        else :

    60

            return None

    61

    62

    STATES = {

    63

        'DHCPACK':      'ack',

    64

        'DHCPNAK':      'nak',

    65

        'DHCPRELEASE':  'release',

    66

        'DHCPDISCOVER': 'search',

    67

        'DHCPREQUEST':  'search',

    68

        'DHCPOFFER':    'search',

    69

    }

    70

    71

    def state_class (self) :

    72

        if self.error :

    73

            return 'dhcp-error'

    74

    75

        elif self.state in self.STATES :

    76

            return 'dhcp-' + self.STATES[self.state]

    77

    78

        else :

    79

            return None

    80

    81

    def state_title (self) :

    82

        return self.error # or None

    83

    84

    def render_state (self) :

    85

        if self.error :

    86

            return "{self.state}: {self.error}".format(self=self)

    87

        else :

    88

            return self.state

    89

    90

    def when (self) :

    91

        return (

    92

                html.span(title=self.first_seen)(self.first_seen.strftime(self.DATE_FMT)),

    93

                '-',

    94

                html.span(title=self.last_seen)(self.last_seen.strftime(self.DATE_FMT)),

    95

        )

    96

    97

    def dns (self) :

    98

        """

    99

            Reverse-DNS lookup.

   100

        """

   101

   102

        if not self.ip :

   103

            return None

   104

   105

        sockaddrs = set(sockaddr for family, socktype, proto, canonname, sockaddr in socket.getaddrinfo(self.ip, 0, 0, 0, 0, socket.AI_NUMERICHOST))

   106

   107

        for sockaddr in sockaddrs :

   108

            try :

   109

                host, port = socket.getnameinfo(sockaddr, socket.NI_NAMEREQD)

   110

            except socket.gaierror :

   111

                continue

   112

   113

            return host

   114

   115

    def __unicode__ (self) :

   116

        return u"{host.ip} ({host.mac})".format(host=self)

   117

   118

db.mapper(Host, db.dhcp_hosts, properties=dict(

   119

    #id      = db.dhcp_hosts.c.rowid,

   120

    #state   = db.dhcp_hosts.c.,

   121

))

   122

   123

class BaseHandler (web.Handler) :

   124

    HOST_ATTRS = {

   125

        'id':       Host.id,

   126

        'net':      Host.gw,

   127

        'ip':       Host.ip,

   128

        'mac':      Host.mac,

   129

        'name':     Host.name,

   130

        'seen':     Host.last_seen,

   131

        'state':    Host.state,

   132

        'count':    Host.count,

   133

    }

   134

   135

    HOST_SORT = Host.last_seen.desc()

   136

   137

    def query (self) :

   138

        return self.db.query(Host)

   139

   140

    def sort (self, hosts, default=HOST_SORT) :

   141

        self.sort = self.request.args.get('sort')

   142

   143

        if self.sort :

   144

            sort = self.HOST_ATTRS[self.sort]

   145

        else :

   146

            sort = default

   147

   148

        log.debug("sort: %s", sort)

   149

   150

        hosts = hosts.order_by(sort)

   151

   152

        # k

   153

        return hosts

   154

   156

        COLS = (

   157

            #title          sort        filter      class

   158

            ('IP',          'ip',       'ip',       'ip'    ),

   159

            ('MAC',         'mac',      'mac',      'mac'   ),

   160

            ('Hostname',    'name',     False,      False   ),

   161

            ('Network',     'net',      'net',      False   ),

   162

            ('Seen',        'seen',     'seen',     False   ),

   163

            ('State',       'state',    'state',    False   ), 

   164

        )

   165

   166

        def url (**opts) :

   167

            args = dict()

   168

   169

            if filters :

   170

                args.update(filters)

   171

   172

            args.update(opts)

   173

   174

            return self.url(**args)

   175

   176

        def paginate (page, count=None) :

   177

            """

   178

                Render pagination.

   179

            """

   180

   181

            if count is not None :

   182

                pages = int(math.ceil(count / self.PAGE)) # XXX: bad self.PAGE

   183

            else :

   184

                pages = None

   185

   186

            if page > 0 :

   187

                yield html.a(href=url(page=0))(html("«« First"))

   188

                yield html.a(href=url(page=(page - 1)))(html("« Prev"))

   189

   190

            yield html.span("Page {page} of {pages}".format(page=(page + 1), pages=(pages or '???')))

   191

   192

            yield html.a(href=url(page=(page + 1)))(html("» Next"))

   193

   194

        def render_filter (filter) :

   195

            value = filters.get(filter)

   196

   197

            if value :

   198

                # XXX: multi-valued filters?

   199

                value = value[0]

   200

            else :

   201

                value = None

   202

   203

            return html.input(type='text', name=filter, value=value)

   204

   223

        table = html.table(

   224

            html.caption(title) if title else None,

   225

            html.thead(

   226

                html.tr(

   227

                    html.th('#'),

   228

                    (

   229

                        html.th(

   230

                            html.a(href=url(sort=sort))(title) if sort else (title)

   231

                        ) for title, sort, filter, class_ in COLS

   232

                    )

   233

                ),

   234

                html.tr(class_='filter')(

   235

                    html.td(

   236

                        html.input(type='submit', value=u'\u00BF'),

   237

                    ),

   238

                    (

   239

                        html.td(class_=class_)(

   240

                            render_filter(filter) if filter else None

   241

                        ) for title, sort, filter, class_ in COLS

   242

                    )

   243

                ) if filters is not False else None

   244

            ),

   245

            html.tbody(

   246

                html.tr(class_=('alternate' if i % 2 else None), id=host.id)(

   247

                    html.th(

   248

                        html.a(href=self.url(ItemHandler, id=host.id))(

   249

                            '#' #host.id

   250

                        )

   251

                    ),

   258

                    html.td(host.when()),

   259

                    html.td(class_=host.state_class(), title=host.state_title())(host.state),

   260

                ) for i, host in enumerate(hosts)

   261

            ),

   262

            html.tfoot(

   263

                html.tr(

   264

                    html.td(colspan=(1 + len(COLS)))(

   265

                        paginate(page) if page is not None else (

   266

                            # XXX: does separate SELECT count()

   267

                            "{count} hosts".format(count=hosts.count())

   268

                        )

   269

                    )

   270

                )

   271

            )

   272

        )

   273

   274

        if filters is False :

   275

            return table

   276

        else :

   277

            return html.form(method='get', action=self.url())(

   278

                html.input(type='hidden', name='sort', value=self.sort),

   279

                table,

   280

            )

   281

   282

class ItemHandler (BaseHandler) :

   283

    def process (self, id) :

   284

        self.hosts = self.query()

   285

        self.host = self.hosts.get(id)

   286

   287

        if not self.host :

   288

            raise web.NotFound("No such host: {id}".format(id=id))

   289

   290

        self.hosts = self.sort(self.hosts.filter((Host.ip == self.host.ip) | (Host.mac == self.host.mac)))

   291

   292

    def title (self) :

   293

        return u"DHCP Host: {self.host}".format(self=self)

   294

   295

    def render_host (self, host) :

   296

        """

   297

            Details for specific host.

   298

        """

   299

   300

        attrs = (

   301

                ('Network',     host.gw),

   302

                ('IP',          host.ip),

   303

                ('MAC',         host.mac),

   304

                ('Hostname',    host.name),

   305

                ('DNS',         host.dns()),

   306

                ('First seen',  host.first_seen),

   307

                ('Last seen',   host.last_seen),

   308

                ('Last state',  host.render_state()),

   309

                ('Total messages',      host.count),

   310

        )

   311

   312

        return (

   313

            html.dl(

   314

                (html.dt(title), html.dd(value)) for title, value in attrs

   315

            )

   316

        )

   317

   318

    def render (self) :

   319

        return (

   320

            html.h2('Host'),

   321

            self.render_host(self.host),

   322

   323

            html.h2('Related'),

   325

   326

            html.a(href=self.url(ListHandler))(html('«'), 'Back'),

   327

        )

   328

   329

   330

class ListHandler (BaseHandler) :

   331

    # pagination

   332

    PAGE = 10

   333

   334

    # views

   335

    VIEWS = (

   336

        ("Last hour",   dict(seen='1h')),

   337

        ("Last day",    dict(seen='24h')),

   338

        ("All",         dict()),

   339

    ) + tuple(

   340

        ("Network " + network,          dict(ip=network)) for network in (

   341

            '194.197.235.0/24',

   342

            '10.1.0.0/16',

   343

            '10.4.0.0/16',

   344

            '10.5.0.0/16',

   345

            '10.6.0.0/16',

   346

            '10.10.0.0/16',

   347

        )

   348

    ) + (

   349

        ("Valid",       dict(state=('DHCPACK', 'DHCPRELEASE'))),

   350

        ("Incomplete",  dict(state=('DHCPDISCOVER', 'DHCPOFFER', 'DHCPREQUEST'))),

   351

        ("Invalid",     dict(state=('DHCPNAK', ))),

   352

    )

   353

   354

    def filter (self, attr, value) :

   355

        """

   356

            Return filter expression for given attr == value

   357

        """

   358

   359

        if attr == 'seen' :

   360

            column = Host.last_seen

   361

   362

            if value.isdigit() :

   363

                # specific date

   364

                date = datetime.datetime.strptime(value, Host.DATE_FMT).date()

   365

   366

                return db.between(date.strftime(Host.DATE_FMT), 

   367

                        db.func.strftime(Host.DATE_FMT, Host.first_seen),

   368

                        db.func.strftime(Host.DATE_FMT, Host.last_seen)

   369

                )

   370

            else :

   371

                # recent

   372

                timedelta = parse_timedelta(value)

   373

   374

                return ((db.func.now() - Host.last_seen) < timedelta)

   375

   376

                # XXX: for sqlite, pgsql should handle this natively?

   377

                # to seconds

   378

                #timeout = timedelta.days * (24 * 60 * 60) + timedelta.seconds

   379

   380

                # WHERE strftime('%s', 'now') - strftime('%s', last_seen) < :timeout

   381

                #filter = (db.func.strftime('%s', 'now') - db.func.strftime('%s', Host.last_seen) < timeout)

   382

   383

        elif attr == 'ip' :

   384

            column = Host.ip

   385

   386

            # column is IPv4 string literal format...

   387

            if '/' in value :

   388

                return (db.func.inet(Host.ip).op('<<')(db.func.cidr(value)))

   389

            else :

   390

                return (db.func.inet(Host.ip) == db.func.inet(value))

   391

   392

        else :

   393

            # preprocess

   394

            like = False

   395

   396

            if value.endswith('*') :

   397

                like = value.replace('*', '%')

   398

   399

            elif attr == 'mac' :

   400

                value = Host.normalize_mac(value)

   401

   402

            # filter

   403

            column = self.HOST_ATTRS[attr]

   404

   405

            if like :

   406

                return (column.like(like))

   407

            else :

   408

                return (column == value)

   409

   410

    def process (self) :

   411

        hosts = self.query()

   412

   413

        # filter?

   414

        self.filters = {}

   415

   416

        for attr in self.HOST_ATTRS :

   417

            values = self.request.args.getlist(attr)

   418

   419

            if not values :

   420

                continue

   421

   422

            filter = db.or_(*[self.filter(attr, value) for value in values])

   423

   424

            log.debug("filter %s: %s", attr, filter)

   425

   426

            hosts = hosts.filter(filter)

   427

            self.filters[attr] = values

   428

   429

        # sort XXX: default per filter column?

   430

        hosts = self.sort(hosts)

   431

   432

        # page?

   433

        self.page = self.request.args.get('page')

   434

   435

        if self.page :

   436

            self.page = int(self.page)

   437

   438

            hosts = hosts.offset(self.page * self.PAGE).limit(self.PAGE)

   439

   440

        self.hosts = hosts

   441

   442

    def title (self) :

   443

        if self.filters :

   444

            return "DHCP Hosts: {filters}".format(filters=', '.join(value for values in self.filters.itervalues() for value in values))

   445

        else :

   446

            return "DHCP Hosts"

   447

   448

    def render (self) :

   449

        return (

   450

            self.render_hosts(self.hosts, filters=self.filters, page=self.page),

   451

   452

            html.a(href=self.url())(html('«'), 'Back') if self.filters else None,

   453

        )