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

    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) :

    76

            return 'dhcp-' + self.STATES[self.state]

    77

    78

        else :

    79

            return None

    80

    90

    def when (self) :

    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(

   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

    }

   133

   134

    HOST_SORT = Host.last_seen.desc()

   135

   136

    def query (self) :

   140

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

   141

   142

        if self.sort :

   143

            sort = self.HOST_ATTRS[self.sort]

   144

        else :

   146

   147

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

   149

        hosts = hosts.order_by(sort)

   150

   151

        # k

   152

        return hosts

   153

   155

        COLS = (

   156

            #title          sort        filter      class

   157

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

   158

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

   159

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

   160

            ('Network',     'net',      'net',      False   ),

   161

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

   162

            ('State',       'state',    'state',    False   ), 

   163

        )

   164

   165

        def url (**opts) :

   166

            args = dict()

   167

   168

            if filters :

   169

                args.update(filters)

   170

   171

            args.update(opts)

   172

   173

            return self.url(**args)

   174

   194

        table = html.table(

   195

            html.caption(title) if title else None,

   196

            html.thead(

   197

                html.tr(

   198

                    html.th('#'),

   199

                    (

   200

                        html.th(

   201

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

   202

                        ) for title, sort, filter, class_ in COLS

   203

                    )

   204

                ),

   205

                html.tr(class_='filter')(

   206

                    html.td(

   207

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

   208

                    ),

   209

                    (

   210

                        html.td(class_=class_)(

   211

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

   212

                        ) for title, sort, filter, class_ in COLS

   213

                    )

   214

                ) if filters is not False else None

   215

            ),

   216

            html.tbody(

   217

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

   218

                    html.th(

   219

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

   221

                        )

   222

                    ),

   223

                    html.td(class_='ip')(

   224

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

   225

                            host.ip

   226

                        )

   227

                    ),

   228

                    html.td(class_='mac')(

   229

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

   230

                            host.render_mac()

   231

                        )

   232

                    ),

   233

                    html.td(host.render_name()),

   234

                    html.td(

   235

                        host.gw

   236

                    ),

   237

                    html.td(host.when()),

   239

                ) for i, host in enumerate(hosts)

   240

            ),

   241

            html.tfoot(

   242

                html.tr(

   243

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

   248

                    )

   249

                )

   250

            )

   251

        )

   252

   253

        if filters is False :

   254

            return table

   255

        else :

   256

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

   257

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

   258

                table,

   259

            )

   260

   261

    def render_host (self, host, hosts) :

   262

        attrs = (

   263

                ('Network',     host.gw),

   264

                ('IP',          host.ip),

   265

                ('MAC',         host.mac),

   266

                ('Hostname',    host.name),

   267

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

   268

                ('First seen',  host.first_seen),

   269

                ('Last seen',   host.last_seen),

   271

        )

   272

   273

        return (

   274

            html.h2('Host'),

   275

            html.dl(

   276

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

   277

            ),

   278

   279

            html.h2('Related'),

   280

            self.render_hosts(hosts),

   281

   282

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

   283

        )

   284

   285

class ItemHandler (BaseHandler) :

   286

    def process (self, id) :

   287

        self.hosts = self.query()

   288

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

   289

   290

        if not self.host :

   291

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

   292

   294

   295

    def title (self) :

   296

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

   297

   298

    def render (self) :

   299

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

   300

   301

class ListHandler (BaseHandler) :

   305

    def process (self) :

   306

        hosts = self.query()

   307

   308

        # filter?

   310

        self.filters = {}

   311

   312

        for attr in self.HOST_ATTRS :

   313

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

   314

   315

            if not value :

   316

                continue

   317

   318

            if attr == 'seen' :

   321

                if value.isdigit() :

   322

                    # specific date

   323

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

   324

   325

                    filter = db.between(date.strftime(Host.DATE_FMT), 

   326

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

   327

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

   328

                    )

   329

                else :

   330

                    # recent

   331

                    timedelta = parse_timedelta(value)

   334

   336

                    # to seconds

   338

   339

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

   341

   342

            elif attr == 'ip' :

   344

   348

                else :

   350

   351

            else :

   352

                # preprocess

   353

                like = False

   354

   355

                if value.endswith('*') :

   356

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

   357

   358

                elif attr == 'mac' :

   359

                    value = Host.normalize_mac(value)

   360

   361

                # filter

   363

   364

                if like :

   366

                else :

   368

   369

            hosts = hosts.filter(filter)

   370

            self.filters[attr] = value

   383

        self.hosts = hosts

   384

   385

    def title (self) :

   386

        if self.filters :

   387

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

   388

        else :

   389

            return "DHCP Hosts"

   390

   391

    def render (self) :

   392

        return (

   394

   395

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

   396

        )