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

   155

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

   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

   205

        table = html.table(

   206

            html.caption(title) if title else None,

   207

            html.thead(

   208

                html.tr(

   209

                    html.th('#'),

   210

                    (

   211

                        html.th(

   212

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

   213

                        ) for title, sort, filter, class_ in COLS

   214

                    )

   215

                ),

   216

                html.tr(class_='filter')(

   217

                    html.td(

   218

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

   219

                    ),

   220

                    (

   221

                        html.td(class_=class_)(

   222

                            render_filter(filter) if filter else None

   223

                        ) for title, sort, filter, class_ in COLS

   224

                    )

   225

                ) if filters is not False else None

   226

            ),

   227

            html.tbody(

   228

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

   229

                    html.th(

   230

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

   231

                            '#' #host.id

   232

                        )

   233

                    ),

   234

                    html.td(class_='ip')(

   236

                            host.ip

   237

                        )

   238

                    ),

   239

                    html.td(class_='mac')(

   241

                            host.render_mac()

   242

                        )

   243

                    ),

   244

                    html.td(host.render_name()),

   245

                    html.td(

   246

                        host.gw

   247

                    ),

   248

                    html.td(host.when()),

   249

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

   250

                ) for i, host in enumerate(hosts)

   251

            ),

   252

            html.tfoot(

   253

                html.tr(

   254

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

   255

                        paginate(page) if page is not None else (

   256

                            # XXX: does separate SELECT count()

   257

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

   258

                        )

   259

                    )

   260

                )

   261

            )

   262

        )

   263

   264

        if filters is False :

   265

            return table

   266

        else :

   267

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

   268

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

   269

                table,

   270

            )

   271

   272

class ItemHandler (BaseHandler) :

   273

    def process (self, id) :

   274

        self.hosts = self.query()

   275

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

   276

   277

        if not self.host :

   278

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

   279

   280

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

   281

   282

    def title (self) :

   283

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

   284

   308

    def render (self) :

   319

   320

class ListHandler (BaseHandler) :

   321

    # pagination

   322

    PAGE = 10

   323

   324

    # views

   325

    VIEWS = (

   326

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

   327

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

   328

        ("All",         dict()),

   329

    ) + tuple(

   330

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

   331

            '194.197.235.0/24',

   332

            '10.1.0.0/16',

   333

            '10.4.0.0/16',

   334

            '10.5.0.0/16',

   335

            '10.6.0.0/16',

   336

            '10.10.0.0/16',

   337

        )

   338

    ) + (

   339

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

   340

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

   341

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

   342

    )

   343

   344

    def filter (self, attr, value) :

   345

        """

   346

            Return filter expression for given attr == value

   347

        """

   348

   349

        if attr == 'seen' :

   350

            column = Host.last_seen

   351

   352

            if value.isdigit() :

   353

                # specific date

   354

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

   355

   356

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

   357

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

   358

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

   359

                )

   360

            else :

   361

                # recent

   362

                timedelta = parse_timedelta(value)

   363

   364

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

   365

   366

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

   367

                # to seconds

   368

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

   369

   370

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

   371

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

   372

   373

        elif attr == 'ip' :

   374

            column = Host.ip

   375

   376

            # column is IPv4 string literal format...

   377

            if '/' in value :

   378

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

   379

            else :

   380

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

   381

   382

        else :

   383

            # preprocess

   384

            like = False

   385

   386

            if value.endswith('*') :

   387

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

   388

   389

            elif attr == 'mac' :

   390

                value = Host.normalize_mac(value)

   391

   392

            # filter

   393

            column = self.HOST_ATTRS[attr]

   394

   395

            if like :

   396

                return (column.like(like))

   397

            else :

   398

                return (column == value)

   399

   400

    def process (self) :

   401

        hosts = self.query()

   402

   403

        # filter?

   404

        self.filters = {}

   405

   406

        for attr in self.HOST_ATTRS :

   407

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

   408

   409

            if not values :

   410

                continue

   411

   412

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

   413

   414

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

   415

   416

            hosts = hosts.filter(filter)

   417

            self.filters[attr] = values

   418

   419

        # sort XXX: default per filter column?

   420

        hosts = self.sort(hosts)

   421

   422

        # page?

   423

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

   424

   425

        if self.page :

   426

            self.page = int(self.page)

   427

   428

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

   429

   430

        self.hosts = hosts

   431

   432

    def title (self) :

   433

        if self.filters :

   434

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

   435

        else :

   436

            return "DHCP Hosts"

   437

   438

    def render (self) :

   439

        return (

   440

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

   441

   442

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

   443

        )