1

from pvl.verkko import db, web

     2

     3

from pvl.html import tags as html

     4

     5

import re

     6

import socket # dns

     7

     8

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

     9

    10

# XXX: this should actually be DHCPHost

    11

class Host (object) :

    12

    DATE_FMT = '%Y%m%d'

    13

    14

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

    15

    MAC_SEP = r'[-:.]?'

    16

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

    17

    18

    @classmethod

    19

    def normalize_mac (cls, mac) :

    20

        match = cls.MAC_RE.search(mac)

    21

    22

        if not match :

    23

            raise ValueError(mac)

    24

    25

        else :

    26

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

    27

    28

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

    29

        self.ip = ip

    30

        self.mac = mac

    31

        self.name = name

    32

    33

    def render_mac (self) :

    34

        if not self.mac :

    35

            return None

    36

    37

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

    38

            return u'???'

    39

    40

        else :

    41

            return unicode(self.mac)

    42

    43

    def render_name (self) :

    44

        if self.name :

    45

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

    46

        else :

    47

            return None

    48

    49

    def when (self) :

    50

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

    51

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

    52

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

    53

        )

    54

    55

    def dns (self) :

    56

        """

    57

            Reverse-DNS lookup.

    58

        """

    59

    60

        if not self.ip :

    61

            return None

    62

    63

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

    64

    65

        for sockaddr in sockaddrs :

    66

            try :

    67

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

    68

            except socket.gaierror :

    69

                continue

    70

    71

            return host

    72

    73

    def __unicode__ (self) :

    74

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

    75

    76

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

    77

    id      = db.dhcp_hosts.c.rowid,

    78

    #_mac    = db.dhcp_hosts.c.mac,

    79

    #_name   = db.dhcp_hosts.c.name,

    80

))

    81

    82

class BaseHandler (web.Handler) :

    83

    HOST_ATTRS = {

    84

        'id':   Host.id,

    85

        'ip':   Host.ip,

    86

        'mac':  Host.mac,

    87

        'name': Host.name,

    88

        'seen': Host.last_seen,

    89

    }

    90

    91

    HOST_SORT = Host.last_seen.desc()

    92

    93

    def query (self) :

    94

        hosts = self.db.query(Host)

    95

    96

        # sort ?

    97

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

    98

    99

        if self.sort :

   100

            sort = self.HOST_ATTRS[self.sort]

   101

        else :

   102

            sort = self.HOST_SORT

   103

   104

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

   105

   106

        hosts = hosts.order_by(sort)

   107

   108

        # k

   109

        return hosts

   110

   111

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

   112

        COLS = (

   118

        )

   119

   120

        def url (**opts) :

   121

            args = dict(filters)

   122

            args.update(opts)

   123

   124

            return self.url(**args)

   125

   126

        table = html.table(

   127

            html.caption(title) if title else None,

   128

            html.thead(

   129

                html.tr(

   130

                    html.th('#'),

   131

                    (

   132

                        html.th(

   133

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

   135

                    )

   136

                ),

   137

                html.tr(class_='filter')(

   138

                    html.td(

   139

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

   140

                    ),

   141

                    (

   143

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

   145

                    )

   146

                ) if filters is not False else None

   147

            ),

   148

            html.tbody(

   149

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

   150

                    html.td(class_='id')(

   151

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

   152

                            '#' #host['rowid'])

   153

                        )

   154

                    ),

   155

                    html.td(class_='ip')(

   156

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

   157

                            host.ip

   158

                        )

   159

                    ),

   160

                    html.td(class_='mac')(

   161

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

   162

                            host.render_mac()

   163

                        )

   164

                    ),

   165

                    html.td(host.render_name()),

   166

                    html.td(host.when()),

   167

                ) for i, host in enumerate(hosts)

   168

            )

   169

        )

   170

   171

        if filters is False :

   172

            return table

   173

        else :

   174

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

   175

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

   176

                table,

   177

            )

   178

   179

    def render_host (self, host, hosts) :

   180

        attrs = (

   181

                ('IP',          host.ip),

   182

                ('MAC',         host.mac),

   183

                ('Hostname',    host.name),

   184

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

   185

                ('First seen',  host.first_seen),

   186

                ('Last seen',   host.last_seen),

   187

        )

   188

   189

        return (

   190

            html.h2('Host'),

   191

            html.dl(

   192

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

   193

            ),

   194

   195

            html.h2('Related'),

   196

            self.render_hosts(hosts),

   197

   198

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

   199

        )

   200

   201

class ItemHandler (BaseHandler) :

   202

    def process (self, id) :

   203

        self.hosts = self.query()

   204

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

   205

   206

        if not self.host :

   207

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

   208

   209

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

   210

   211

    def title (self) :

   212

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

   213

   214

    def render (self) :

   215

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

   216

   217

class ListHandler (BaseHandler) :

   218

    def process (self) :

   219

        self.hosts = self.query()

   220

   221

        # filter?

   222

        self.filters = {}

   223

   224

        for attr in self.HOST_ATTRS :

   225

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

   226

   227

            if not value :

   228

                continue

   229

   230

            # preprocess

   231

            like = False

   232

   233

            if value.endswith('*') :

   234

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

   235

   236

            elif attr == 'mac' :

   237

                value = Host.normalize_mac(value)

   238

   239

            # filter

   240

            col = self.HOST_ATTRS[attr]

   241

   242

            if like :

   243

                filter = (col.like(like))

   244

            else :

   245

                filter = (col == value)

   246

   247

            self.hosts = self.hosts.filter(filter)

   248

            self.filters[attr] = value

   249

   250

    def title (self) :

   251

        if self.filters :

   252

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

   253

        else :

   254

            return "DHCP Hosts"

   255

   256

    def render (self) :

   257

        return (

   258

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

   259

   260

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

   261

        )