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 = (

   113

            #title          sort        filter      class

   114

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

   115

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

   116

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

   117

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

   118

        )

   119

   120

        def url (**opts) :

   121

            args = dict()

   122

   123

            if filters :

   124

                args.update(filters)

   125

   126

            args.update(opts)

   127

   128

            return self.url(**args)

   129

   130

        table = html.table(

   131

            html.caption(title) if title else None,

   132

            html.thead(

   133

                html.tr(

   134

                    html.th('#'),

   135

                    (

   136

                        html.th(

   137

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

   138

                        ) for title, sort, filter, class_ in COLS

   139

                    )

   140

                ),

   141

                html.tr(class_='filter')(

   142

                    html.td(

   143

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

   144

                    ),

   145

                    (

   146

                        html.td(class_=class_)(

   147

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

   148

                        ) for title, sort, filter, class_ in COLS

   149

                    )

   150

                ) if filters is not False else None

   151

            ),

   152

            html.tbody(

   153

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

   154

                    html.th(

   155

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

   156

                            '#' #host['rowid'])

   157

                        )

   158

                    ),

   159

                    html.td(class_='ip')(

   160

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

   161

                            host.ip

   162

                        )

   163

                    ),

   164

                    html.td(class_='mac')(

   165

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

   166

                            host.render_mac()

   167

                        )

   168

                    ),

   169

                    html.td(host.render_name()),

   170

                    html.td(host.when()),

   171

                ) for i, host in enumerate(hosts)

   180

            )

   181

        )

   182

   183

        if filters is False :

   184

            return table

   185

        else :

   186

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

   187

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

   188

                table,

   189

            )

   190

   191

    def render_host (self, host, hosts) :

   192

        attrs = (

   193

                ('IP',          host.ip),

   194

                ('MAC',         host.mac),

   195

                ('Hostname',    host.name),

   196

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

   197

                ('First seen',  host.first_seen),

   198

                ('Last seen',   host.last_seen),

   199

        )

   200

   201

        return (

   202

            html.h2('Host'),

   203

            html.dl(

   204

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

   205

            ),

   206

   207

            html.h2('Related'),

   208

            self.render_hosts(hosts),

   209

   210

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

   211

        )

   212

   213

class ItemHandler (BaseHandler) :

   214

    def process (self, id) :

   215

        self.hosts = self.query()

   216

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

   217

   218

        if not self.host :

   219

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

   220

   221

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

   222

   223

    def title (self) :

   224

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

   225

   226

    def render (self) :

   227

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

   228

   229

class ListHandler (BaseHandler) :

   230

    def process (self) :

   231

        self.hosts = self.query()

   232

   233

        # filter?

   234

        self.filters = {}

   235

   236

        for attr in self.HOST_ATTRS :

   237

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

   238

   239

            if not value :

   240

                continue

   241

   242

            # preprocess

   243

            like = False

   244

   245

            if value.endswith('*') :

   246

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

   247

   248

            elif attr == 'mac' :

   249

                value = Host.normalize_mac(value)

   250

   251

            # filter

   252

            col = self.HOST_ATTRS[attr]

   253

   254

            if like :

   255

                filter = (col.like(like))

   256

            else :

   257

                filter = (col == value)

   258

   259

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

   260

            self.filters[attr] = value

   261

   262

    def title (self) :

   263

        if self.filters :

   264

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

   265

        else :

   266

            return "DHCP Hosts"

   267

   268

    def render (self) :

   269

        return (

   270

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

   271

   272

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

   273

        )