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

    TIME_FMT = '%H:%M:%S'

    17

    18

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

    19

    MAC_SEP = r'[-:.]?'

    20

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

    21

    22

    @classmethod

    23

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

    24

        """

    25

            seen        - select hosts seen during given timedelta period

    26

        """

    27

    28

        query = session.query(cls)

    29

    30

        return query

    31

    32

    @classmethod

    33

    def normalize_mac (cls, mac) :

    34

        match = cls.MAC_RE.search(mac)

    35

    36

        if not match :

    37

            raise ValueError(mac)

    38

    39

        else :

    40

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

    41

    42

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

    43

        self.ip = ip

    44

        self.mac = mac

    45

        self.name = name

    46

    47

    def render_mac (self) :

    48

        if not self.mac :

    49

            return None

    50

    51

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

    52

            return u'???'

    53

    54

        else :

    55

            return unicode(self.mac)

    56

    57

    def render_name (self) :

    58

        if self.name :

    59

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

    60

        else :

    61

            return None

    62

    63

    STATES = {

    64

        'DHCPACK':      'ack',

    65

        'DHCPNAK':      'nak',

    66

        'DHCPRELEASE':  'release',

    67

        'DHCPDISCOVER': 'search',

    68

        'DHCPREQUEST':  'search',

    69

        'DHCPOFFER':    'search',

    70

    }

    71

    72

    def state_class (self) :

    73

        if self.error :

    74

            return 'dhcp-error'

    75

    76

        elif self.state in self.STATES :

    77

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

    78

    79

        else :

    80

            return None

    81

    82

    def state_title (self) :

    83

        return self.error # or None

    84

    85

    def render_state (self) :

    86

        if self.error :

    87

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

    88

        else :

    89

            return self.state

    90

    91

    @classmethod

    92

    def format_datetime (cls, dt) :

    93

        if (datetime.datetime.now() - dt).days :

    94

            return dt.strftime(cls.DATE_FMT)

    95

    96

        else :

    97

            return dt.strftime(cls.TIME_FMT)

    98

    99

    def seen (self) :

   100

        return (

   101

                html.span(title=self.first_seen)(self.format_datetime(self.first_seen)),

   102

                '-',

   103

                html.span(title=self.last_seen)(self.format_datetime(self.last_seen))

   104

        )

   105

   106

    def dns (self) :

   107

        """

   108

            Reverse-DNS lookup.

   109

        """

   110

   111

        if not self.ip :

   112

            return None

   113

   114

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

   115

   116

        for sockaddr in sockaddrs :

   117

            try :

   118

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

   119

            except socket.gaierror :

   120

                continue

   121

   122

            return host

   123

   124

    def __unicode__ (self) :

   125

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

   126

   127

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

   128

    #id      = db.dhcp_hosts.c.rowid,

   129

    #state   = db.dhcp_hosts.c.,

   130

))

   131

   132

   133

   134

   135

class BaseHandler (web.Handler) :

   136

    HOST_ATTRS = {

   137

        'id':       Host.id,

   138

        'net':      Host.gw,

   139

        'ip':       Host.ip,

   140

        'mac':      Host.mac,

   141

        'name':     Host.name,

   142

        'seen':     Host.last_seen,

   143

        'state':    Host.state,

   144

        'count':    Host.count,

   145

    }

   146

   147

    HOST_SORT = Host.last_seen.desc()

   148

   149

    def query (self) :

   150

        return self.db.query(Host)

   151

   152

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

   153

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

   154

   155

        if sort :

   156

            order_by = self.HOST_ATTRS[sort]

   157

        else :

   158

            order_by = default

   159

   160

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

   161

   162

        hosts = hosts.order_by(order_by)

   163

   164

        # k

   165

        return sort, hosts

   166

   167

    def filter_attr (self, attr, value) :

   168

        """

   169

            Return filter expression for given attr == value

   170

        """

   171

   172

        if attr == 'seen' :

   173

            column = Host.last_seen

   174

   175

            if value.isdigit() :

   176

                # specific date

   177

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

   178

   179

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

   180

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

   181

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

   182

                )

   183

            else :

   184

                # recent

   185

                timedelta = parse_timedelta(value)

   186

   187

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

   188

   189

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

   190

                # to seconds

   191

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

   192

   193

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

   194

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

   195

   196

        elif attr == 'ip' :

   197

            column = Host.ip

   198

   199

            # column is IPv4 string literal format...

   200

            if '/' in value :

   201

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

   202

            else :

   203

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

   204

   205

        else :

   206

            # preprocess

   207

            like = False

   208

   209

            if value.endswith('*') :

   210

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

   211

   212

            elif attr == 'mac' :

   213

                value = Host.normalize_mac(value)

   214

   215

            # filter

   216

            column = self.HOST_ATTRS[attr]

   217

   218

            if like :

   219

                return (column.like(like))

   220

            else :

   221

                return (column == value)

   222

   223

    def filter (self, hosts) :

   224

        """

   225

            Apply filters from request.args against given hosts.

   226

   227

            Returns (filters, hosts).

   228

        """

   229

   230

        # filter?

   231

        filters = {}

   232

   233

        for attr in self.HOST_ATTRS :

   234

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

   235

   236

            if not values :

   237

                continue

   238

   239

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

   240

   241

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

   242

   243

            hosts = hosts.filter(filter)

   244

            filters[attr] = values

   245

   246

        return filters, hosts

   247

   248

    def filters_title (self) :

   249

        """

   250

            Return a string representing the applied filters.

   251

        """

   252

   253

        return ', '.join(value for values in self.filters.itervalues() for value in values)

   254

   255

    def render_hosts (self, hosts, title=None, filters=False, page=None, hilight=None) :

   256

        COLS = (

   257

            #title          sort        filter      class

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

        )

   265

   266

        def url (**opts) :

   267

            args = dict()

   268

   269

            if filters :

   270

                args.update(filters)

   271

   272

            args.update(opts)

   273

   274

            return self.url(**args)

   275

   276

        def paginate (page, count=None) :

   277

            """

   278

                Render pagination.

   279

            """

   280

   281

            if count is not None :

   282

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

   283

            else :

   284

                pages = None

   285

   286

            if page > 0 :

   287

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

   288

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

   289

   290

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

   291

   292

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

   293

   294

        def render_filter (filter) :

   295

            value = filters.get(filter)

   296

   297

            if value :

   298

                # XXX: multi-valued filters?

   299

                value = value[0]

   300

            else :

   301

                value = None

   302

   303

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

   304

   305

        def render_cell (attr, value, cssclass=True, filter=None, htmlvalue=None) :

   306

            if htmlvalue :

   307

                cell = htmlvalue

   308

            else :

   309

                cell = value

   310

   311

            if filter :

   312

                cell = html.a(href=self.url(ListHandler, **{attr: value}))(cell)

   313

   314

            if cssclass is True :

   315

                cssclass = attr

   316

   317

            css = (cssclass, 'hilight' if (hilight and attr in hilight and value in hilight[attr]) else None)

   318

            css = ' '.join(cls for cls in css if cls)

   319

   320

            return html.td(class_=css)(cell)

   321

   322

        table = html.table(

   323

            html.caption(title) if title else None,

   324

            html.thead(

   325

                html.tr(

   326

                    html.th('#'),

   327

                    (

   328

                        html.th(

   329

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

   330

                        ) for title, sort, filter, class_ in COLS

   331

                    )

   332

                ),

   333

                html.tr(class_='filter')(

   334

                    html.td(

   335

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

   336

                    ),

   337

                    (

   338

                        html.td(class_=class_)(

   339

                            render_filter(filter) if filter else None

   340

                        ) for title, sort, filter, class_ in COLS

   341

                    )

   342

                ) if filters is not False else None

   343

            ),

   344

            html.tbody(

   345

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

   346

                    html.th(

   347

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

   348

                            '#' #host.id

   349

                        )

   350

                    ),

   351

   352

                    render_cell('ip', host.ip, filter=True),

   353

                    render_cell('mac', host.mac, filter=True, htmlvalue=host.render_mac()),

   354

                    render_cell('name', host.name, htmlvalue=host.render_name()),

   355

                    render_cell('gw', host.gw),

   356

   357

                    render_cell('seen', host.seen()),

   358

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

   359

                ) for i, host in enumerate(hosts)

   360

            ),

   361

            html.tfoot(

   362

                html.tr(

   363

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

   364

                        paginate(page) if page is not None else (

   365

                            # XXX: does separate SELECT count()

   366

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

   367

                        )

   368

                    )

   369

                )

   370

            )

   371

        )

   372

   373

        if filters is False :

   374

            return table

   375

        else :

   376

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

   377

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

   378

                table,

   379

            )

   380

   381

class ItemHandler (BaseHandler) :

   382

    def process (self, id) :

   383

        self.hosts = self.query()

   384

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

   385

   386

        if not self.host :

   387

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

   388

   389

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

   390

   391

    def title (self) :

   392

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

   393

   394

    def render_host (self, host) :

   395

        """

   396

            Details for specific host.

   397

        """

   398

   399

        attrs = (

   400

                ('Network',     host.gw),

   401

                ('IP',          host.ip),

   402

                ('MAC',         host.mac),

   403

                ('Hostname',    host.name),

   404

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

   405

                ('First seen',  host.first_seen),

   406

                ('Last seen',   host.last_seen),

   407

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

   408

                ('Total messages',      host.count),

   409

        )

   410

   411

        return (

   412

            html.dl(

   413

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

   414

            )

   415

        )

   416

   417

    def render (self) :

   418

        return (

   419

            html.h2('Host'),

   420

            self.render_host(self.host),

   421

   422

            html.h2('Related'),

   423

            self.render_hosts(self.hosts, hilight=dict(ip=self.host.ip, mac=self.host.mac)),

   424

   425

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

   426

        )

   427

   428

   429

class ListHandler (BaseHandler) :

   430

    # pagination

   431

    PAGE = 10

   432

   433

    # views

   434

    VIEWS = (

   435

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

   436

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

   437

        ("All",         dict()),

   438

    ) + tuple(

   439

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

   440

            '194.197.235.0/24',

   441

            '10.1.0.0/16',

   442

            '10.4.0.0/16',

   443

            '10.5.0.0/16',

   444

            '10.6.0.0/16',

   445

            '10.10.0.0/16',

   446

        )

   447

    ) + (

   448

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

   449

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

   450

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

   451

    )

   452

   453

    def process (self) :

   454

        hosts = self.query()

   455

   456

        # filter

   457

        self.filters, hosts = self.filter(hosts)

   458

   459

        # sort XXX: default per filter column?

   460

        self.sorts, hosts = self.sort(hosts)

   461

   462

        # page?

   463

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

   464

   465

        if self.page :

   466

            self.page = int(self.page)

   467

   468

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

   469

   470

        self.hosts = hosts

   471

   472

    def title (self) :

   473

        if self.filters :

   474

            return "DHCP Hosts: {filters}".format(filters=self.filters_title())

   475

        else :

   476

            return "DHCP Hosts"

   477

   478

    def render (self) :

   479

        return (

   480

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

   481

   482

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

   483

        )

   484

   485

import json

   486

import time

   487

   488

def dt2ts (dt) :

   489

    return int(time.mktime(dt.timetuple()))

   490

   491

def ts2dt (ts) :

   492

    return datetime.datetime.fromtimestamp(ts)