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

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

   154

   155

        if self.sort :

   156

            sort = self.HOST_ATTRS[self.sort]

   157

        else :

   158

            sort = default

   159

   160

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

   161

   162

        hosts = hosts.order_by(sort)

   163

   164

        # k

   165

        return hosts

   166

   167

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

   168

        COLS = (

   169

            #title          sort        filter      class

   170

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

   171

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

   172

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

   173

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

   174

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

   175

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

   176

        )

   177

   178

        def url (**opts) :

   179

            args = dict()

   180

   181

            if filters :

   182

                args.update(filters)

   183

   184

            args.update(opts)

   185

   186

            return self.url(**args)

   187

   188

        def paginate (page, count=None) :

   189

            """

   190

                Render pagination.

   191

            """

   192

   193

            if count is not None :

   194

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

   195

            else :

   196

                pages = None

   197

   198

            if page > 0 :

   199

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

   200

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

   201

   202

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

   203

   204

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

   205

   206

        def render_filter (filter) :

   207

            value = filters.get(filter)

   208

   209

            if value :

   210

                # XXX: multi-valued filters?

   211

                value = value[0]

   212

            else :

   213

                value = None

   214

   215

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

   216

   217

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

   218

            if htmlvalue :

   219

                cell = htmlvalue

   220

            else :

   221

                cell = value

   222

   223

            if filter :

   224

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

   225

   226

            if cssclass is True :

   227

                cssclass = attr

   228

   229

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

   230

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

   231

   232

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

   233

   234

        table = html.table(

   235

            html.caption(title) if title else None,

   236

            html.thead(

   237

                html.tr(

   238

                    html.th('#'),

   239

                    (

   240

                        html.th(

   241

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

   242

                        ) for title, sort, filter, class_ in COLS

   243

                    )

   244

                ),

   245

                html.tr(class_='filter')(

   246

                    html.td(

   247

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

   248

                    ),

   249

                    (

   250

                        html.td(class_=class_)(

   251

                            render_filter(filter) if filter else None

   252

                        ) for title, sort, filter, class_ in COLS

   253

                    )

   254

                ) if filters is not False else None

   255

            ),

   256

            html.tbody(

   257

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

   258

                    html.th(

   259

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

   260

                            '#' #host.id

   261

                        )

   262

                    ),

   263

   264

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

   265

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

   266

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

   267

                    render_cell('gw', host.gw),

   268

   269

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

   270

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

   271

                ) for i, host in enumerate(hosts)

   272

            ),

   273

            html.tfoot(

   274

                html.tr(

   275

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

   276

                        paginate(page) if page is not None else (

   277

                            # XXX: does separate SELECT count()

   278

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

   279

                        )

   280

                    )

   281

                )

   282

            )

   283

        )

   284

   285

        if filters is False :

   286

            return table

   287

        else :

   288

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

   289

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

   290

                table,

   291

            )

   292

   293

class ItemHandler (BaseHandler) :

   294

    def process (self, id) :

   295

        self.hosts = self.query()

   296

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

   297

   298

        if not self.host :

   299

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

   300

   301

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

   302

   303

    def title (self) :

   304

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

   305

   306

    def render_host (self, host) :

   307

        """

   308

            Details for specific host.

   309

        """

   310

   311

        attrs = (

   312

                ('Network',     host.gw),

   313

                ('IP',          host.ip),

   314

                ('MAC',         host.mac),

   315

                ('Hostname',    host.name),

   316

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

   317

                ('First seen',  host.first_seen),

   318

                ('Last seen',   host.last_seen),

   319

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

   320

                ('Total messages',      host.count),

   321

        )

   322

   323

        return (

   324

            html.dl(

   325

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

   326

            )

   327

        )

   328

   329

    def render (self) :

   330

        return (

   331

            html.h2('Host'),

   332

            self.render_host(self.host),

   333

   334

            html.h2('Related'),

   335

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

   336

   337

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

   338

        )

   339

   340

   341

class ListHandler (BaseHandler) :

   342

    # pagination

   343

    PAGE = 10

   344

   345

    # views

   346

    VIEWS = (

   347

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

   348

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

   349

        ("All",         dict()),

   350

    ) + tuple(

   351

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

   352

            '194.197.235.0/24',

   353

            '10.1.0.0/16',

   354

            '10.4.0.0/16',

   355

            '10.5.0.0/16',

   356

            '10.6.0.0/16',

   357

            '10.10.0.0/16',

   358

        )

   359

    ) + (

   360

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

   361

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

   362

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

   363

    )

   364

   365

    def filter (self, attr, value) :

   366

        """

   367

            Return filter expression for given attr == value

   368

        """

   369

   370

        if attr == 'seen' :

   371

            column = Host.last_seen

   372

   373

            if value.isdigit() :

   374

                # specific date

   375

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

   376

   377

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

   378

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

   379

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

   380

                )

   381

            else :

   382

                # recent

   383

                timedelta = parse_timedelta(value)

   384

   385

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

   386

   387

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

   388

                # to seconds

   389

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

   390

   391

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

   392

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

   393

   394

        elif attr == 'ip' :

   395

            column = Host.ip

   396

   397

            # column is IPv4 string literal format...

   398

            if '/' in value :

   399

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

   400

            else :

   401

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

   402

   403

        else :

   404

            # preprocess

   405

            like = False

   406

   407

            if value.endswith('*') :

   408

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

   409

   410

            elif attr == 'mac' :

   411

                value = Host.normalize_mac(value)

   412

   413

            # filter

   414

            column = self.HOST_ATTRS[attr]

   415

   416

            if like :

   417

                return (column.like(like))

   418

            else :

   419

                return (column == value)

   420

   421

    def process (self) :

   422

        hosts = self.query()

   423

   424

        # filter?

   425

        self.filters = {}

   426

   427

        for attr in self.HOST_ATTRS :

   428

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

   429

   430

            if not values :

   431

                continue

   432

   433

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

   434

   435

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

   436

   437

            hosts = hosts.filter(filter)

   438

            self.filters[attr] = values

   439

   440

        # sort XXX: default per filter column?

   441

        hosts = self.sort(hosts)

   442

   443

        # page?

   444

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

   445

   446

        if self.page :

   447

            self.page = int(self.page)

   448

   449

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

   450

   451

        self.hosts = hosts

   452

   453

    def title (self) :

   454

        if self.filters :

   455

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

   456

        else :

   457

            return "DHCP Hosts"

   458

   459

    def render (self) :

   460

        return (

   461

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

   462

   463

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

   464

        )

   465

   466

import json

   467

import time

   468

   469

def dt2ts (dt) :

   470

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

   471

   472

def ts2dt (ts) :

   473

    return datetime.datetime.fromtimestamp(ts)

   474

   475

class RealtimeHandler (web.Handler) :

   476

    TITLE = "Pseudo-Realtime hosts.."

   480

    JS = (

   481

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

   482

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

   484

        '/static/js/spin.js',

   485

        '/static/hosts.js',

   486

    )

   487

   488

    def process (self) :

   489

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

   490

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

   491

   492

        if t :