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

     9

import math

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

    72

        if self.error :

    73

            return 'dhcp-error'

    74

    75

        elif self.state in self.STATES :

    76

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

    77

    78

        else :

    79

            return None

    80

    81

    def state_title (self) :

    82

        return self.error # or None

    83

    84

    def render_state (self) :

    85

        if self.error :

    86

            return "{self.state}: {self.error}".format(self=self)

    87

        else :

    88

            return self.state

    89

    90

    def when (self) :

    91

        return (

    92

                html.span(title=self.first_seen)(self.first_seen.strftime(self.DATE_FMT)),

    93

                '-',

    94

                html.span(title=self.last_seen)(self.last_seen.strftime(self.DATE_FMT)),

    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(

   119

    #id      = db.dhcp_hosts.c.rowid,

   120

    #state   = db.dhcp_hosts.c.,

   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,

   133

    }

   134

   135

    HOST_SORT = Host.last_seen.desc()

   136

   137

    def query (self) :

   138

        return self.db.query(Host)

   139

   140

    def sort (self, hosts, default=HOST_SORT) :

   141

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

   142

   143

        if self.sort :

   144

            sort = self.HOST_ATTRS[self.sort]

   145

        else :

   146

            sort = default

   147

   148

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

   149

   150

        hosts = hosts.order_by(sort)

   151

   152

        # k

   153

        return hosts

   154

   155

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

   156

        COLS = (

   157

            #title          sort        filter      class

   158

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

   159

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

   160

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

   161

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

   162

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

   163

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

   164

        )

   165

   166

        def url (**opts) :

   167

            args = dict()

   168

   169

            if filters :

   170

                args.update(filters)

   171

   172

            args.update(opts)

   173

   174

            return self.url(**args)

   175

   176

        def paginate (page, count=None) :

   177

            """

   178

                Render pagination.

   179

            """

   180

   181

            if count is not None :

   182

                pages = int(math.ceil(count / self.PAGE)) # XXX: bad self.PAGE

   183

            else :

   184

                pages = None

   185

   186

            if page > 0 :

   187

                yield html.a(href=url(page=0))(html("«« First"))

   188

                yield html.a(href=url(page=(page - 1)))(html("« Prev"))

   189

   190

            yield html.span("Page {page} of {pages}".format(page=(page + 1), pages=(pages or '???')))

   191

   192

            yield html.a(href=url(page=(page + 1)))(html("» Next"))

   193

   194

   195

        table = html.table(

   196

            html.caption(title) if title else None,

   197

            html.thead(

   198

                html.tr(

   199

                    html.th('#'),

   200

                    (

   201

                        html.th(

   202

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

   203

                        ) for title, sort, filter, class_ in COLS

   204

                    )

   205

                ),

   206

                html.tr(class_='filter')(

   207

                    html.td(

   208

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

   209

                    ),

   210

                    (

   211

                        html.td(class_=class_)(

   212

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

   213

                        ) for title, sort, filter, class_ in COLS

   214

                    )

   215

                ) if filters is not False else None

   216

            ),

   217

            html.tbody(

   218

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

   219

                    html.th(

   220

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

   221

                            '#' #host.id

   222

                        )

   223

                    ),

   224

                    html.td(class_='ip')(

   225

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

   226

                            host.ip

   227

                        )

   228

                    ),

   229

                    html.td(class_='mac')(

   230

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

   231

                            host.render_mac()

   232

                        )

   233

                    ),

   234

                    html.td(host.render_name()),

   235

                    html.td(

   236

                        host.gw

   237

                    ),

   238

                    html.td(host.when()),

   239

                    html.td(class_=host.state_class(), title=host.state_title())(host.state),

   240

                ) for i, host in enumerate(hosts)

   241

            ),

   242

            html.tfoot(

   243

                html.tr(

   244

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

   245

                        paginate(page) if page is not None else (

   246

                            # XXX: does separate SELECT count()

   247

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

   248

                        )

   249

                    )

   250

                )

   251

            )

   252

        )

   253

   254

        if filters is False :

   255

            return table

   256

        else :

   257

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

   258

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

   259

                table,

   260

            )

   261

   262

    def render_host (self, host, hosts) :

   263

        attrs = (

   264

                ('Network',     host.gw),

   265

                ('IP',          host.ip),

   266

                ('MAC',         host.mac),

   267

                ('Hostname',    host.name),

   268

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

   269

                ('First seen',  host.first_seen),

   270

                ('Last seen',   host.last_seen),

   271

                ('Last state',  host.render_state()),

   273

        )

   274

   275

        return (

   276

            html.h2('Host'),

   277

            html.dl(

   278

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

   279

            ),

   280

   281

            html.h2('Related'),

   282

            self.render_hosts(hosts),

   283

   284

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

   285

        )

   286

   287

class ItemHandler (BaseHandler) :

   288

    def process (self, id) :

   289

        self.hosts = self.query()

   290

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

   291

   292

        if not self.host :

   293

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

   294

   295

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

   296

   297

    def title (self) :

   298

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

   299

   300

    def render (self) :

   301

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

   302

   303

class ListHandler (BaseHandler) :

   304

    # pagination

   305

    PAGE = 10

   306

   307

    def process (self) :

   308

        hosts = self.query()

   309

   310

        # filter?

   311

        column = None

   312

        self.filters = {}

   313

   314

        for attr in self.HOST_ATTRS :

   315

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

   316

   317

            if not value :

   318

                continue

   319

   320

            if attr == 'seen' :

   321

                column = Host.last_seen

   322

   323

                if value.isdigit() :

   324

                    # specific date

   325

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

   326

   327

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

   328

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

   329

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

   330

                    )

   331

                else :

   332

                    # recent

   333

                    timedelta = parse_timedelta(value)

   334

   335

                    filter = ((db.func.now() - Host.last_seen) < timedelta)

   336

   337

                    # XXX: for sqlite, pgsql should handle this natively?

   338

                    # to seconds

   339

                    #timeout = timedelta.days * (24 * 60 * 60) + timedelta.seconds

   340

   341

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

   342

                    #filter = (db.func.strftime('%s', 'now') - db.func.strftime('%s', Host.last_seen) < timeout)

   343

   344

            elif attr == 'ip' :

   345

                column = Host.ip

   346

   347

                # column is IPv4 string literal format...

   348

                if '/' in value :

   349

                    filter = (db.func.inet(Host.ip).op('<<')(db.func.cidr(value)))

   350

                else :

   351

                    filter = (db.func.inet(Host.ip) == db.func.inet(value))

   352

   353

            else :

   354

                # preprocess

   355

                like = False

   356

   357

                if value.endswith('*') :

   358

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

   359

   360

                elif attr == 'mac' :

   361

                    value = Host.normalize_mac(value)

   362

   363

                # filter

   364

                column = self.HOST_ATTRS[attr]

   365

   366

                if like :

   367

                    filter = (column.like(like))

   368

                else :

   369

                    filter = (column == value)

   370

   371

            hosts = hosts.filter(filter)

   372

            self.filters[attr] = value

   373

   374

        # sort XXX: default per filter column

   375

        hosts = self.sort(hosts) #, column)

   376

   377

        # page?

   378

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

   379

   380

        if self.page :

   381

            self.page = int(self.page)

   382

   383

            hosts = hosts.offset(self.page * self.PAGE).limit(self.PAGE)

   384

   385

        self.hosts = hosts

   386

   387

    def title (self) :

   388

        if self.filters :

   389

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

   390

        else :

   391

            return "DHCP Hosts"

   392

   393

    def render (self) :

   394

        return (

   395

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

   396

   397

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

   398

        )