2

from pvl.verkko.utils import parse_timedelta, IPv4Network

     3

     4

from pvl.web import 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

    24

class Host (object) :

    25

    DATE_FMT = '%Y%m%d'

    26

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

    27

    28

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

    29

    MAC_SEP = r'[-:.]?'

    30

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

    31

    32

    @classmethod

    33

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

    34

        """

    35

            seen        - select hosts seen during given timedelta period

    36

        """

    37

    38

        query = session.query(cls)

    39

    40

        return query

    41

    42

    @classmethod

    43

    def normalize_mac (cls, mac) :

    44

        match = cls.MAC_RE.search(mac)

    45

    46

        if not match :

    47

            raise ValueError(mac)

    48

    49

        else :

    50

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

    51

    52

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

    53

        self.ip = ip

    54

        self.mac = mac

    55

        self.name = name

    56

    57

    def render_mac (self) :

    58

        if not self.mac :

    59

            return None

    60

    61

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

    62

            return u'???'

    63

    64

        else :

    65

            return unicode(self.mac)

    66

    67

    def render_name (self) :

    68

        if self.name :

    69

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

    70

        else :

    71

            return None

    72

    73

    STATES = {

    74

        'DHCPACK':      'ack',

    75

        'DHCPNAK':      'nak',

    76

        'DHCPRELEASE':  'release',

    77

        'DHCPDISCOVER': 'search',

    78

        'DHCPREQUEST':  'search',

    79

        'DHCPOFFER':    'search',

    80

    }

    81

    82

    def state_class (self) :

    83

        if self.error :

    84

            return 'dhcp-error'

    85

    86

        elif self.state in self.STATES :

    87

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

    88

    89

        else :

    90

            return None

    91

    92

    def state_title (self) :

    93

        return self.error # or None

    94

    95

    def render_state (self) :

    96

        if self.error :

    97

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

    98

        else :

    99

            return self.state

   100

   101

    @classmethod

   102

    def format_datetime (cls, dt) :

   103

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

   104

            return dt.strftime(cls.DATE_FMT)

   105

   106

        else :

   107

            return dt.strftime(cls.TIME_FMT)

   108

   109

    def seen (self) :

   110

        return (

   111

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

   112

                '-',

   113

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

   114

        )

   115

   116

    def dns (self) :

   117

        """

   118

            Reverse-DNS lookup.

   119

        """

   120

   121

        if not self.ip :

   122

            return None

   123

   124

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

   125

   126

        for sockaddr in sockaddrs :

   127

            try :

   128

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

   129

            except socket.gaierror :

   130

                continue

   131

   132

            return host

   133

   134

    def __unicode__ (self) :

   135

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

   136

   137

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

   138

    #id      = db.dhcp_hosts.c.rowid,

   139

    #state   = db.dhcp_hosts.c.,

   140

))

   141

   147

   155

    HOST_ATTRS = {

   156

        'id':       Host.id,

   157

        'net':      Host.gw,

   158

        'ip':       Host.ip,

   159

        'mac':      Host.mac,

   160

        'name':     Host.name,

   161

        'seen':     Host.last_seen,

   162

        'state':    Host.state,

   163

        'count':    Host.count,

   164

    }

   165

   166

    HOST_SORT = Host.last_seen.desc()

   167

   168

    def query (self) :

   169

        return self.db.query(Host)

   170

   171

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

   172

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

   173

   174

        if sort :

   175

            name = sort.lstrip('+-')

   176

        else :

   177

            name = None

   178

   179

        if name :

   180

            order_by = self.HOST_ATTRS[name]

   181

        else :

   182

            order_by = default

   183

   184

        # prefix

   185

        if not sort :

   186

            pass

   187

        elif sort.startswith('+') :

   188

            order_by = order_by.asc()

   189

        elif sort.startswith('-') :

   190

            order_by = order_by.desc()

   191

        else :

   192

            pass

   193

   194

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

   195

   196

        hosts = hosts.order_by(order_by)

   197

   198

        # k

   199

        return sort, hosts

   200

   201

    def filter_attr (self, attr, value) :

   202

        """

   203

            Return filter expression for given attr == value

   204

        """

   205

   206

        if attr == 'seen' :

   207

            column = Host.last_seen

   208

   209

            if value.isdigit() :

   210

                # specific date

   211

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

   212

   213

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

   214

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

   215

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

   216

                )

   217

            else :

   218

                # recent

   219

                timedelta = parse_timedelta(value)

   220

   221

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

   222

   223

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

   224

                # to seconds

   225

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

   226

   227

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

   228

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

   229

   230

        elif attr == 'ip' :

   231

            column = Host.ip

   232

   233

            # column is IPv4 string literal format...

   234

            if '/' in value :

   235

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

   236

            else :

   237

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

   238

   239

        else :

   240

            # preprocess

   241

            like = False

   242

   243

            if value.endswith('*') :

   244

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

   245

   246

            elif attr == 'mac' :

   247

                value = Host.normalize_mac(value)

   248

   249

            # filter

   250

            column = self.HOST_ATTRS[attr]

   251

   252

            if like :

   253

                return (column.like(like))

   254

            else :

   255

                return (column == value)

   256

   257

    def filter (self, hosts) :

   258

        """

   259

            Apply filters from request.args against given hosts.

   260

   261

            Returns (filters, hosts).

   262

        """

   263

   264

        # filter?

   265

        filters = {}

   266

   267

        for attr in self.HOST_ATTRS :

   268

            values = [value.strip() for value in self.request.args.getlist(attr) if value.strip()]

   269

   270

            # ignore empty fields

   271

            if not values :

   272

                continue

   273

   274

            # build query expression

   275

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

   276

   277

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

   278

   279

            hosts = hosts.filter(filter)

   280

            filters[attr] = values

   281

   282

        return filters, hosts

   283

   284

    def filters_title (self) :

   285

        """

   286

            Return a string representing the applied filters.

   287

        """

   288

   289

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

   290

   291

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

   292

        COLS = (

   293

            #title          sort        filter      class

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

        )

   301

   302

        def url (**opts) :

   303

            args = dict()

   304

   305

            if filters :

   306

                args.update(filters)

   307

   308

            args.update(opts)

   309

   310

            return self.url(**args)

   311

   312

        def sortlink (attr) :

   313

            if not self.sorts :

   314

                sort = attr

   315

            elif self.sorts.lstrip('+-') != attr :

   316

                sort = attr

   317

            elif self.sorts.startswith('-') :

   318

                sort = "+" + attr

   319

            else :

   320

                sort = "-" + attr

   321

   322

            return html.a(href=url(sort=sort))

   323

   324

        def paginate (page, count=None) :

   325

            """

   326

                Render pagination.

   327

            """

   328

   329

            if count is not None :

   330

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

   331

            else :

   332

                pages = None

   333

   334

            if page > 0 :

   335

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

   336

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

   337

   338

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

   339

   340

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

   341

   342

        def render_filter (filter) :

   343

            value = filters.get(filter)

   344

   345

            if value :

   346

                # XXX: multi-valued filters?

   347

                value = value[0]

   348

            else :

   349

                value = None

   350

   351

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

   352

   353

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

   354

            if htmlvalue :

   355

                cell = htmlvalue

   356

            else :

   357

                cell = value

   358

   359

            if filter :

   360

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

   361

   362

            if cssclass is True :

   363

                cssclass = attr

   364

   365

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

   366

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

   367

   368

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

   369

   370

        table = html.table(

   371

            html.caption(title) if title else None,

   372

            html.thead(

   373

                html.tr(

   374

                    html.th('#'),

   375

                    (

   376

                        html.th(

   377

                            sortlink(sort)(title) if sort else (title)

   378

                        ) for title, sort, filter, class_ in COLS

   379

                    )

   380

                ),

   381

                html.tr(class_='filter')(

   382

                    html.td(

   383

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

   384

                    ),

   385

                    (

   386

                        html.td(class_=class_)(

   387

                            render_filter(filter) if filter else None

   388

                        ) for title, sort, filter, class_ in COLS

   389

                    )

   390

                ) if filters is not False else None

   391

            ),

   392

            html.tbody(

   393

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

   394

                    html.th(

   395

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

   396

                            '#' #host.id

   397

                        )

   398

                    ),

   399

   400

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

   401

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

   402

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

   403

                    render_cell('gw', host.gw),

   404

   405

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

   406

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

   407

                ) for i, host in enumerate(hosts)

   408

            ),

   409

            html.tfoot(

   410

                html.tr(

   411

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

   412

                        paginate(page) if page is not None else (

   413

                            # XXX: does separate SELECT count()

   414

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

   415

                        )

   416

                    )

   417

                )

   418

            )

   419

        )

   420

   421

        if filters is False :

   422

            return table

   423

        else :

   424

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

   425

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

   426

                table,

   427

            )

   428

   429

class ItemHandler (BaseHandler) :

   434

    def process (self, id) :

   435

        self.hosts = self.query()

   436

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

   437

   438

        if not self.host :

   439

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

   440

   441

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

   442

   443

    def title (self) :

   444

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

   445

   446

    def render_host (self, host) :

   447

        """

   448

            Details for specific host.

   449

        """

   450

   451

        attrs = (

   452

                ('Network',     host.gw),

   453

                ('IP',          host.ip),

   454

                ('MAC',         host.mac),

   455

                ('Hostname',    host.name),

   456

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

   457

                ('First seen',  host.first_seen),

   458

                ('Last seen',   host.last_seen),

   459

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

   460

                ('Total messages',      host.count),

   461

        )

   462

   463

        return (

   464

            html.dl(

   465

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

   466

            )

   467

        )

   468

   469

    def render (self) :

   470

        return (

   471

            html.h2('Host'),

   472

            self.render_host(self.host),

   473

   474

            html.h2('Related'),

   475

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

   476

   477

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

   478

        )

   479

   480

   481

class ListHandler (BaseHandler) :

   486

    # pagination

   487

    PAGE = 10

   488

   489

    def process (self) :

   490

        hosts = self.query()

   491

   492

        # filter