1

from pvl.verkko import db, web

     2

     3

from pvl.html import tags as html

     4

     5

import socket # dns

     6

     7

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

     8

     9

# XXX: this should actually be DHCPHost

    10

class Host (object) :

    11

    DATE_FMT = '%Y%m%d'

    12

    13

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

    14

        self.ip = ip

    15

        self.mac = mac

    16

        self.name = name

    17

    18

    def render_mac (self) :

    19

        if not self.mac :

    20

            return None

    21

    22

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

    23

            return u'???'

    24

    25

        else :

    26

            return unicode(self.mac)

    27

    28

    def render_name (self) :

    29

        if self.name :

    30

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

    31

        else :

    32

            return None

    33

    34

    def when (self) :

    35

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

    36

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

    37

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

    38

        )

    39

    40

    def dns (self) :

    41

        """

    42

            Reverse-DNS lookup.

    43

        """

    44

    45

        if not self.ip :

    46

            return None

    47

    48

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

    49

    50

        for sockaddr in sockaddrs :

    51

            try :

    52

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

    53

            except socket.gaierror :

    54

                continue

    55

    56

            return host

    57

    58

    def __unicode__ (self) :

    59

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

    60

    61

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

    62

    id      = db.dhcp_hosts.c.rowid,

    63

    #_mac    = db.dhcp_hosts.c.mac,

    64

    #_name   = db.dhcp_hosts.c.name,

    65

))

    66

    67

class BaseHandler (web.Handler) :

    68

    HOST_ATTRS = {

    69

        'id':   Host.id,

    70

        'ip':   Host.ip,

    71

        'mac':  Host.mac,

    72

        'name': Host.name,

    73

        'seen': Host.last_seen,

    74

    }

    75

    76

    HOST_SORT = Host.last_seen.desc()

    77

    78

    def query (self) :

    79

        hosts = self.db.query(Host)

    80

    81

        # sort ?

    82

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

    83

    84

        if sort :

    85

            sort = self.HOST_ATTRS[sort]

    86

        else :

    87

            sort = self.HOST_SORT

    88

    89

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

    90

    91

        hosts = hosts.order_by(sort)

    92

    93

        # k

    94

        return hosts

    95

    96

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

    97

        COLS = (

    98

            #title          sort

    99

            ('#',           None),

   100

            ('IP',          'ip'),

   101

            ('MAC',         'mac'),

   102

            ('Hostname',    'name'),

   103

            ('Seen',        'seen'),

   104

        )

   105

   106

        return html.table(

   107

            html.caption(title) if title else None,

   108

            html.thead(

   109

                html.tr(

   110

                    html.th(

   112

                    ) for title, sort in COLS

   113

                )

   114

            ),

   115

            html.tbody(

   116

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

   117

                    html.td(class_='id')(

   119

                            '#' #host['rowid'])

   120

                        )

   121

                    ),

   122

                    html.td(class_='ip')(

   126

                    ),

   127

                    html.td(class_='mac')(

   129

                            host.render_mac()

   130

                        )

   131

                    ),

   132

                    html.td(host.render_name()),

   133

                    html.td(host.when()),

   134

                ) for i, host in enumerate(hosts)

   135

            )

   136

        )

   137

   138

    def render_host (self, host, hosts) :

   139

        attrs = (

   140

                ('IP',          host.ip),

   141

                ('MAC',         host.mac),

   142

                ('Hostname',    host.name),

   143

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

   144

        )

   145

   146

        return (

   147

            html.h2('Host'),

   148

            html.dl(

   149

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

   150

            ),

   151

   152

            html.h2('Related'),

   153

            self.render_hosts(hosts),

   154

   156

        )

   157

   158

class IndexHandler (BaseHandler) :

   159

    def process (self) :

   160

        self.hosts = self.query()

   161

   162

    def title (self) :

   163

        return "DHCP Hosts"

   164

   165

    def render (self) :

   166

        return self.render_hosts(self.hosts)

   167

   168

class ItemHandler (BaseHandler) :

   169

    def process (self, id) :

   170

        self.hosts = self.query()

   171

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

   172

   173

        if not self.host :

   174

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

   175

   176

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

   177

   178

    def title (self) :

   179

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

   180

   181

    def render (self) :

   182

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

   183

   184

class ListHandler (BaseHandler) :

   185

    def process (self, attr, value) :

   186

        # fake host

   187

        _host = { 'ip': None, 'mac': None, 'name': None }

   188

   189

        if attr not in self.HOST_ATTRS :

   190

            raise web.BadRequest("Invalid attribute: {attr}".format(attr=attr))

   191

   192

        _host[attr] = value

   193

   194

        self.host = Host(**_host)

   195

        self.expression = "{attr}: {value}".format(attr=attr, value=value)

   196

   197

        # query

   198

        attr = self.HOST_ATTRS[attr]

   199

        log.debug("%s == %s", attr, value)

   200

   201

        self.hosts = self.query().filter(attr == value)

   202

   203

    def title (self) :

   204

        return "DHCP Hosts: {self.expression}".format(self=self)

   205

   206

    def render (self) :

   207

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

   208