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

    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

   126

class BaseHandler (web.Handler) :

   127

    HOST_ATTRS = {

   128

        'id':       Host.id,

   129

        'net':      Host.gw,

   130

        'ip':       Host.ip,

   131

        'mac':      Host.mac,

   132

        'name':     Host.name,

   133

        'seen':     Host.last_seen,

   134

        'state':    Host.state,

   135

        'count':    Host.count,

   136

    }

   137

   138

    HOST_SORT = Host.last_seen.desc()

   139

   140

    def query (self) :

   141

        return self.db.query(Host)

   142

   143

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

   144

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

   145

   146

        if self.sort :

   147

            sort = self.HOST_ATTRS[self.sort]

   148

        else :

   149

            sort = default

   150

   151

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

   152

   153

        hosts = hosts.order_by(sort)

   154

   155

        # k

   156

        return hosts

   157

   158

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

   159

        COLS = (

   160

            #title          sort        filter      class

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

        )

   168

   169

        def url (**opts) :

   170

            args = dict()

   171

   172

            if filters :

   173

                args.update(filters)

   174

   175

            args.update(opts)

   176

   177

            return self.url(**args)

   178

   179

        def paginate (page, count=None) :

   180

            """

   181

                Render pagination.

   182

            """

   183

   184

            if count is not None :

   185

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

   186

            else :

   187

                pages = None

   188

   189

            if page > 0 :

   190

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

   191

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

   192

   193

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

   194

   195

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

   196

   197

        def render_filter (filter) :

   198

            value = filters.get(filter)

   199

   200

            if value :

   201

                # XXX: multi-valued filters?

   202

                value = value[0]

   203

            else :

   204

                value = None

   205

   206

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

   207

   208

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

   209

            if htmlvalue :

   210

                cell = htmlvalue

   211

            else :

   212

                cell = value

   213

   214

            if filter :

   215

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

   216

   217

            if cssclass is True :

   218

                cssclass = attr

   219

   220

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

   221

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

   222

   223

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

   224

   225

        table = html.table(

   226

            html.caption(title) if title else None,

   227

            html.thead(

   228

                html.tr(

   229

                    html.th('#'),

   230

                    (

   231

                        html.th(

   232

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

   233

                        ) for title, sort, filter, class_ in COLS

   234

                    )

   235

                ),

   236

                html.tr(class_='filter')(

   237

                    html.td(

   238

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

   239

                    ),

   240

                    (

   241

                        html.td(class_=class_)(

   242

                            render_filter(filter) if filter else None

   243

                        ) for title, sort, filter, class_ in COLS

   244

                    )

   245

                ) if filters is not False else None

   246

            ),

   247

            html.tbody(

   248

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

   249

                    html.th(

   250

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

   251

                            '#' #host.id

   252

                        )

   253

                    ),

   254

   255

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

   256

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

   257

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

   258

                    render_cell('gw', host.gw),

   259

   261

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

   262

                ) for i, host in enumerate(hosts)

   263

            ),

   264

            html.tfoot(

   265

                html.tr(

   266

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

   267

                        paginate(page) if page is not None else (

   268

                            # XXX: does separate SELECT count()

   269

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

   270

                        )

   271

                    )

   272

                )

   273

            )

   274

        )

   275

   276

        if filters is False :

   277

            return table

   278

        else :

   279

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

   280

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

   281

                table,

   282

            )

   283

   284

class ItemHandler (BaseHandler) :

   285

    def process (self, id) :

   286

        self.hosts = self.query()

   287

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

   288

   289

        if not self.host :

   290

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

   291

   292

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

   293

   294

    def title (self) :

   295

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

   296

   297

    def render_host (self, host) :

   298

        """

   299

            Details for specific host.

   300

        """

   301

   302

        attrs = (

   303

                ('Network',     host.gw),

   304

                ('IP',          host.ip),

   305

                ('MAC',         host.mac),

   306

                ('Hostname',    host.name),

   307

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

   308

                ('First seen',  host.first_seen),

   309

                ('Last seen',   host.last_seen),

   310

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

   311

                ('Total messages',      host.count),

   312

        )

   313

   314

        return (

   315

            html.dl(

   316

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

   317

            )

   318

        )

   319

   320

    def render (self) :

   321

        return (

   322

            html.h2('Host'),

   323

            self.render_host(self.host),

   324

   325

            html.h2('Related'),

   326

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

   327

   328

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

   329

        )

   330

   331

   332

class ListHandler (BaseHandler) :

   333

    # pagination

   334

    PAGE = 10

   335

   336

    # views

   337

    VIEWS = (

   338

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

   339

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

   340

        ("All",         dict()),

   341

    ) + tuple(

   342

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

   343

            '194.197.235.0/24',

   344

            '10.1.0.0/16',

   345

            '10.4.0.0/16',

   346

            '10.5.0.0/16',

   347

            '10.6.0.0/16',

   348

            '10.10.0.0/16',

   349

        )

   350

    ) + (

   351

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

   352

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

   353

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

   354

    )

   355

   356

    def filter (self, attr, value) :

   357

        """

   358

            Return filter expression for given attr == value

   359

        """

   360

   361

        if attr == 'seen' :

   362

            column = Host.last_seen

   363

   364

            if value.isdigit() :

   365

                # specific date

   366

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

   367

   368

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

   369

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

   370

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

   371

                )

   372

            else :

   373

                # recent

   374

                timedelta = parse_timedelta(value)

   375

   376

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

   377

   378

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

   379

                # to seconds

   380

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

   381

   382

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

   383

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

   384

   385

        elif attr == 'ip' :

   386

            column = Host.ip

   387

   388

            # column is IPv4 string literal format...

   389

            if '/' in value :

   390

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

   391

            else :

   392

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

   393

   394

        else :

   395

            # preprocess

   396

            like = False

   397

   398

            if value.endswith('*') :

   399

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

   400

   401

            elif attr == 'mac' :

   402

                value = Host.normalize_mac(value)

   403

   404

            # filter

   405

            column = self.HOST_ATTRS[attr]

   406

   407

            if like :

   408

                return (column.like(like))

   409

            else :

   410

                return (column == value)

   411

   412

    def process (self) :

   413

        hosts = self.query()

   414

   415

        # filter?

   416

        self.filters = {}

   417

   418

        for attr in self.HOST_ATTRS :

   419

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

   420

   421

            if not values :

   422

                continue

   423

   424

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

   425

   426

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

   427

   428

            hosts = hosts.filter(filter)

   429

            self.filters[attr] = values

   430

   431

        # sort XXX: default per filter column?

   432

        hosts = self.sort(hosts)

   433

   434

        # page?

   435

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

   436

   437

        if self.page :

   438

            self.page = int(self.page)

   439

   440

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

   441

   442

        self.hosts = hosts

   443

   444

    def title (self) :

   445

        if self.filters :

   446

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

   447

        else :

   448

            return "DHCP Hosts"

   449

   450

    def render (self) :

   451

        return (

   452

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

   453

   454

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

   455

        )

   456

   457

import json

   458

import time

   459

   460

def dt2ts (dt) :

   461

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

   462

   463

def ts2dt (ts) :

   464

    return datetime.datetime.fromtimestamp(ts)

   465

   466

class RealtimeHandler (web.Handler) :

   467

    TITLE = "Pseudo-Realtime hosts.."

   468

    JS = (

   469

        #"/static/jquery/jquery.js",

   470

        'http://code.jquery.com/jquery-1.8.2.js',

   472

        '/static/hosts.js',

   473

    )

   474

   475

    def process (self) :

   476

        hosts = self.db.query(Host).order_by(Host.last_seen.desc())

   477

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

   478

   479

        if t :

   480

            t = ts2dt(int(t))

   481

   482

            # update

   483

            hosts = hosts.filter(Host.last_seen > t)

   484

            hosts = list(hosts)

   485

            hosts.reverse()

   486

   487

            if hosts :

   488

                t = hosts[-1].last_seen