1

from pvl.verkko import db, web

     3

     4

from pvl.html import tags as html

     5

     6

import re

     8

import socket # dns

     9

    10

import logging; log = logging.getLogger('pvl.verkko.hosts')

    11

    12

# XXX: this should actually be DHCPHost

    13

class Host (object) :

    14

    DATE_FMT = '%Y%m%d'

    15

    16

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

    17

    MAC_SEP = r'[-:.]?'

    18

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

    19

    20

    @classmethod

    31

    def normalize_mac (cls, mac) :

    32

        match = cls.MAC_RE.search(mac)

    33

    34

        if not match :

    35

            raise ValueError(mac)

    36

    37

        else :

    38

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

    39

    40

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

    41

        self.ip = ip

    42

        self.mac = mac

    43

        self.name = name

    44

    45

    def render_mac (self) :

    46

        if not self.mac :

    47

            return None

    48

    49

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

    50

            return u'???'

    51

    52

        else :

    53

            return unicode(self.mac)

    54

    55

    def render_name (self) :

    56

        if self.name :

    57

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

    58

        else :

    59

            return None

    76

    77

    def when (self) :

    78

        return '{frm} - {to}'.format(

    79

                frm = self.first_seen.strftime(self.DATE_FMT),

    80

                to  = self.last_seen.strftime(self.DATE_FMT),

    81

        )

    82

    83

    def dns (self) :

    84

        """

    85

            Reverse-DNS lookup.

    86

        """

    87

    88

        if not self.ip :

    89

            return None

    90

    91

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

    92

    93

        for sockaddr in sockaddrs :

    94

            try :

    95

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

    96

            except socket.gaierror :

    97

                continue

    98

    99

            return host

   100

   101

    def __unicode__ (self) :

   102

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

   103

   104

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

   105

    id      = db.dhcp_hosts.c.rowid,

   107

))

   108

   109

class BaseHandler (web.Handler) :

   110

    HOST_ATTRS = {

   118

    }

   119

   120

    HOST_SORT = Host.last_seen.desc()

   121

   122

    def query (self) :

   123

        hosts = self.db.query(Host)

   124

   125

        # sort ?

   126

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

   127

   128

        if self.sort :

   129

            sort = self.HOST_ATTRS[self.sort]

   130

        else :

   131

            sort = self.HOST_SORT

   132

   133

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

   134

   135

        hosts = hosts.order_by(sort)

   136

   137

        # k

   138

        return hosts

   139

   140

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

   141

        COLS = (

   142

            #title          sort        filter      class

   143

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

   144

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

   145

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

   149

        )

   150

   151

        def url (**opts) :

   152

            args = dict()

   153

   154

            if filters :

   155

                args.update(filters)

   156

   157

            args.update(opts)

   158

   159

            return self.url(**args)

   160

   161

        table = html.table(

   162

            html.caption(title) if title else None,

   163

            html.thead(

   164

                html.tr(

   165

                    html.th('#'),

   166

                    (

   167

                        html.th(

   168

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

   169

                        ) for title, sort, filter, class_ in COLS

   170

                    )

   171

                ),

   172

                html.tr(class_='filter')(

   173

                    html.td(

   174

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

   175

                    ),

   176

                    (

   177

                        html.td(class_=class_)(

   178

                            html.input(type='text', name=filter, value=filters.get(filter)) if filter else None

   179

                        ) for title, sort, filter, class_ in COLS

   180

                    )

   181

                ) if filters is not False else None

   182

            ),

   183

            html.tbody(

   184

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

   185

                    html.th(

   186

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

   187

                            '#' #host['rowid'])

   188

                        )

   189

                    ),

   190

                    html.td(class_='ip')(

   191

                        html.a(href=self.url(ListHandler, ip=host.ip))(

   192

                            host.ip

   193

                        )

   194

                    ),

   195

                    html.td(class_='mac')(

   196

                        html.a(href=self.url(ListHandler, mac=host.mac))(

   197

                            host.render_mac()

   198

                        )

   199

                    ),

   200

                    html.td(host.render_name()),

   204

                    html.td(host.when()),

   206

                ) for i, host in enumerate(hosts)

   207

            ),

   208

            html.tfoot(

   209

                html.tr(

   210

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

   211

                        # XXX: does separate SELECT count()

   212

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

   213

                    )

   214

                )

   215

            )

   216

        )

   217

   218

        if filters is False :

   219

            return table

   220

        else :

   221

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

   222

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

   223

                table,

   224

            )

   225

   226

    def render_host (self, host, hosts) :

   227

        attrs = (

   229

                ('IP',          host.ip),

   230

                ('MAC',         host.mac),

   231

                ('Hostname',    host.name),

   232

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

   233

                ('First seen',  host.first_seen),

   234

                ('Last seen',   host.last_seen),

   236

        )

   237

   238

        return (

   239

            html.h2('Host'),

   240

            html.dl(

   241

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

   242

            ),

   243

   244

            html.h2('Related'),

   245

            self.render_hosts(hosts),

   246

   247

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

   248

        )

   249

   250

class ItemHandler (BaseHandler) :

   251

    def process (self, id) :

   252

        self.hosts = self.query()

   253

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

   254

   255

        if not self.host :

   256

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

   257

   258

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

   259

   260

    def title (self) :

   261

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

   262

   263

    def render (self) :

   264

        return self.render_host(self.host, self.hosts)

   265

   266

class ListHandler (BaseHandler) :

   267

    def process (self) :

   269

   270

        # filter?

   271

        self.filters = {}

   272

   273

        for attr in self.HOST_ATTRS :

   274

            value = self.request.args.get(attr)

   275

   276

            if not value :

   277

                continue

   278

   283

   291

   309

            else :

   326

   328

            self.filters[attr] = value

   331

   332

    def title (self) :

   333

        if self.filters :

   334

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

   335

        else :

   336

            return "DHCP Hosts"

   337

   338

    def render (self) :

   339

        return (

   340

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

   341

   342

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

   343

        )