chiark - git - mdw - tripe/blob - mon/tripemon.in

   1 #! @PYTHON@
   2 ### -*- mode: python; coding: utf-8 -*-
   3 ###
   4 ### Graphical monitor for tripe server
   5 ###
   6 ### (c) 2007 Straylight/Edgeware
   7 ###
   8
   9 ###----- Licensing notice ---------------------------------------------------
  10 ###
  11 ### This file is part of Trivial IP Encryption (TrIPE).
  12 ###
  13 ### TrIPE is free software: you can redistribute it and/or modify it under
  14 ### the terms of the GNU General Public License as published by the Free
  15 ### Software Foundation; either version 3 of the License, or (at your
  16 ### option) any later version.
  17 ###
  18 ### TrIPE is distributed in the hope that it will be useful, but WITHOUT
  19 ### ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20 ### FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  21 ### for more details.
  22 ###
  23 ### You should have received a copy of the GNU General Public License
  24 ### along with TrIPE.  If not, see <https://www.gnu.org/licenses/>.
  25
  26 ###--------------------------------------------------------------------------
  27 ### Dependencies.
  28
  29 import socket as S
  30 import tripe as T
  31 import mLib as M
  32 from sys import argv, exit, stdin, stdout, stderr, exc_info, excepthook
  33 import os as OS
  34 from os import environ
  35 import math as MATH
  36 import sets as SET
  37 from optparse import OptionParser
  38 import time as TIME
  39 import re as RX
  40 from cStringIO import StringIO
  41
  42 try:
  43   if OS.getenv('TRIPEMON_FORCE_GI'): raise ImportError
  44   import pygtk
  45   pygtk.require('2.0')
  46   import gtk as G
  47   import gobject as GO
  48   import gtk.gdk as GDK
  49   GL = GO
  50   GDK.KEY_Escape = G.keysyms.Escape
  51   def raise_window(w): w.window.raise_()
  52   combo_box_text = G.combo_box_new_text
  53   def set_entry_bg(e, c): e.modify_base(G.STATE_NORMAL, c)
  54 except ImportError:
  55   from gi.repository import GObject as GO, GLib as GL, Gtk as G, Gdk as GDK
  56   G.WINDOW_TOPLEVEL = G.WindowType.TOPLEVEL
  57   G.EXPAND = G.AttachOptions.EXPAND
  58   G.SHRINK = G.AttachOptions.SHRINK
  59   G.FILL = G.AttachOptions.FILL
  60   G.SORT_ASCENDING = G.SortType.ASCENDING
  61   G.POLICY_AUTOMATIC = G.PolicyType.AUTOMATIC
  62   G.SHADOW_IN = G.ShadowType.IN
  63   G.SELECTION_NONE = G.SelectionMode.NONE
  64   G.DIALOG_MODAL = G.DialogFlags.MODAL
  65   G.RESPONSE_CANCEL = G.ResponseType.CANCEL
  66   G.RESPONSE_NONE = G.ResponseType.NONE
  67   def raise_window(w): getattr(w.get_window(), 'raise')()
  68   combo_box_text = G.ComboBoxText
  69   def set_entry_bg(e, c): e.modify_bg(G.StateType.NORMAL, c)
  70
  71 if OS.getenv('TRIPE_DEBUG_MONITOR') is not None:
  72   T._debug = 1
  73
  74 ###--------------------------------------------------------------------------
  75 ### Doing things later.
  76
  77 def uncaught():
  78   """Report an uncaught exception."""
  79   excepthook(*exc_info())
  80
  81 def xwrap(func):
  82   """
  83   Return a function which behaves like FUNC, but reports exceptions via
  84   uncaught.
  85   """
  86   def _(*args, **kw):
  87     try:
  88       return func(*args, **kw)
  89     except SystemExit:
  90       raise
  91     except:
  92       uncaught()
  93       raise
  94   return _
  95
  96 def invoker(func, *args, **kw):
  97   """
  98   Return a function which throws away its arguments and calls
  99   FUNC(*ARGS, **KW).
 100
 101   If for loops worked by binding rather than assignment then we wouldn't need
 102   this kludge.
 103   """
 104   return lambda *hunoz, **hukairz: xwrap(func)(*args, **kw)
 105
 106 def cr(func, *args, **kw):
 107   """Return a function which invokes FUNC(*ARGS, **KW) in a coroutine."""
 108   name = T.funargstr(func, args, kw)
 109   return lambda *hunoz, **hukairz: \
 110          T.Coroutine(xwrap(func), name = name).switch(*args, **kw)
 111
 112 def incr(func):
 113   """Decorator: runs its function in a coroutine of its own."""
 114   return lambda *args, **kw: \
 115          (T.Coroutine(func, name = T.funargstr(func, args, kw))
 116           .switch(*args, **kw))
 117
 118 ###--------------------------------------------------------------------------
 119 ### Random bits of infrastructure.
 120
 121 ## Program name, shorn of extraneous stuff.
 122 M.ego(argv[0])
 123 moan = M.moan
 124 die = M.die
 125
 126 class HookList (object):
 127   """
 128   Notification hook list.
 129
 130   Other objects can add functions onto the hook list.  When the hook list is
 131   run, the functions are called in the order in which they were registered.
 132   """
 133
 134   def __init__(me):
 135     """Basic initialization: create the hook list."""
 136     me.list = []
 137
 138   def add(me, func, obj):
 139     """Add FUNC to the list of hook functions."""
 140     me.list.append((obj, func))
 141
 142   def prune(me, obj):
 143     """Remove hook functions registered with the given OBJ."""
 144     new = []
 145     for o, f in me.list:
 146       if o is not obj:
 147         new.append((o, f))
 148     me.list = new
 149
 150   def run(me, *args, **kw):
 151     """Invoke the hook functions with arguments *ARGS and **KW."""
 152     for o, hook in me.list:
 153       rc = hook(*args, **kw)
 154       if rc is not None: return rc
 155     return None
 156
 157 class HookClient (object):
 158   """
 159   Mixin for classes which are clients of hooks.
 160
 161   It keeps track of the hooks it's a client of, and has the ability to
 162   extricate itself from all of them.  This is useful because weak objects
 163   don't seem to work well.
 164   """
 165   def __init__(me):
 166     """Basic initialization."""
 167     me.hooks = SET.Set()
 168
 169   def hook(me, hk, func):
 170     """Add FUNC to the hook list HK."""
 171     hk.add(func, me)
 172     me.hooks.add(hk)
 173
 174   def unhook(me, hk):
 175     """Remove myself from the hook list HK."""
 176     hk.prune(me)
 177     me.hooks.discard(hk)
 178
 179   def unhookall(me):
 180     """Remove myself from all hook lists."""
 181     for hk in me.hooks:
 182       hk.prune(me)
 183     me.hooks.clear()
 184
 185 class struct (object):
 186   """A very simple dumb data container object."""
 187   def __init__(me, **kw):
 188     me.__dict__.update(kw)
 189
 190 ## Matches ISO date format yyyy-mm-ddThh:mm:ss.
 191 rx_time = RX.compile(r'^(\d+)-(\d+)-(\d+)T(\d+):(\d+):(\d+)$')
 192
 193 ###--------------------------------------------------------------------------
 194 ### Connections.
 195
 196 class GIOWatcher (object):
 197   """
 198   Monitor I/O events using glib.
 199   """
 200   def __init__(me, conn, mc = GL.main_context_default()):
 201     me._conn = conn
 202     me._watch = None
 203     me._mc = mc
 204   def connected(me, sock):
 205     me._watch = GL.io_add_watch(sock, GL.IO_IN,
 206                                 lambda *hunoz: me._conn.receive())
 207   def disconnected(me):
 208     GL.source_remove(me._watch)
 209     me._watch = None
 210   def iterate(me):
 211     me._mc.iteration(True)
 212
 213 class Connection (T.TripeCommandDispatcher):
 214   """
 215   The main connection to the server.
 216
 217   The improvement over the TripeCommandDispatcher is that the Connection
 218   provides hooklists for NOTE, WARN and TRACE messages, and for connect and
 219   disconnect events.
 220
 221   This class knows about the Glib I/O dispatcher system, and plugs into it.
 222
 223   Hooks:
 224
 225     * connecthook(): a connection to the server has been established
 226     * disconnecthook(): the connection has been dropped
 227     * notehook(TOKEN, ...): server issued a notification
 228     * warnhook(TOKEN, ...): server issued a warning
 229     * tracehook(TOKEN, ...): server issued a trace message
 230   """
 231
 232   def __init__(me, socket):
 233     """Create a new Connection."""
 234     T.TripeCommandDispatcher.__init__(me, socket)
 235     me.connecthook = HookList()
 236     me.disconnecthook = HookList()
 237     me.notehook = HookList()
 238     me.warnhook = HookList()
 239     me.tracehook = HookList()
 240     me.handler['NOTE'] = lambda _, *rest: me.notehook.run(*rest)
 241     me.handler['WARN'] = lambda _, *rest: me.warnhook.run(*rest)
 242     me.handler['TRACE'] = lambda _, *rest: me.tracehook.run(*rest)
 243     me.iowatch = GIOWatcher(me)
 244
 245   def connected(me):
 246     """Handles reconnection to the server, and signals the hook."""
 247     T.TripeCommandDispatcher.connected(me)
 248     me.connecthook.run()
 249
 250   def disconnected(me, reason):
 251     """Handles disconnection from the server, and signals the hook."""
 252     me.disconnecthook.run(reason)
 253     T.TripeCommandDispatcher.disconnected(me, reason)
 254
 255 ###--------------------------------------------------------------------------
 256 ### Watching the peers go by.
 257
 258 class MonitorObject (object):
 259   """
 260   An object with hooks it uses to notify others of changes in its state.
 261   These are the objects tracked by the MonitorList class.
 262
 263   The object has a name, an `aliveness' state indicated by the `alivep' flag,
 264   and hooks.
 265
 266   Hooks:
 267
 268     * changehook(): the object has changed its state
 269     * deadhook(): the object has been destroyed
 270
 271   Subclass responsibilities:
 272
 273     * update(INFO): update internal state based on the provided INFO, and run
 274       the changehook.
 275   """
 276
 277   def __init__(me, name):
 278     """Initialize the object with the given NAME."""
 279     me.name = name
 280     me.deadhook = HookList()
 281     me.changehook = HookList()
 282     me.alivep = True
 283
 284   def dead(me):
 285     """Mark the object as dead; invoke the deadhook."""
 286     me.alivep = False
 287     me.deadhook.run()
 288
 289 class Peer (MonitorObject):
 290   """
 291   An object representing a connected peer.
 292
 293   As well as the standard hooks, a peer has a pinghook, which isn't used
 294   directly by this class.
 295
 296   Hooks:
 297
 298     * pinghook(): invoked by the Pinger (q.v.) when ping statistics change
 299
 300   Attributes provided are:
 301
 302     * addr = a vaguely human-readable representation of the peer's address
 303     * ifname = the peer's interface name
 304     * tunnel = the kind of tunnel the peer is using
 305     * keepalive = the peer's keepalive interval in seconds
 306     * ping['EPING'] and ping['PING'] = pingstate statistics (maintained by
 307       the Pinger)
 308   """
 309
 310   def __init__(me, name):
 311     """Initialize the object with the given name."""
 312     MonitorObject.__init__(me, name)
 313     me.pinghook = HookList()
 314     me.__dict__.update(conn.algs(name))
 315     me.update()
 316
 317   def update(me, hunoz = None):
 318     """Update the peer, fetching information about it from the server."""
 319     me._setaddr(conn.addr(me.name))
 320     me.ifname = conn.ifname(me.name)
 321     me.__dict__.update(conn.peerinfo(me.name))
 322     me.changehook.run()
 323
 324   def _setaddr(me, addr):
 325     """Set the peer's address."""
 326     if addr[0] == 'INET':
 327       ipaddr, port = addr[1:]
 328       try:
 329         name = S.gethostbyaddr(ipaddr)[0]
 330         me.addr = 'INET %s:%s [%s]' % (name, port, ipaddr)
 331       except S.herror:
 332         me.addr = 'INET %s:%s' % (ipaddr, port)
 333     else:
 334       me.addr = ' '.join(addr)
 335
 336   def setaddr(me, addr):
 337     """Informs the object of a change to its address to ADDR."""
 338     me._setaddr(addr)
 339     me.changehook.run()
 340
 341   def setifname(me, newname):
 342     """Informs the object of a change to its interface name to NEWNAME."""
 343     me.ifname = newname
 344     me.changehook.run()
 345
 346 class Service (MonitorObject):
 347   """
 348   Represents a service.
 349
 350   Additional attributes are:
 351
 352     * version = the service version
 353   """
 354   def __init__(me, name, version):
 355     MonitorObject.__init__(me, name)
 356     me.version = version
 357
 358   def update(me, version):
 359     """Tell the Service that its version has changed to VERSION."""
 360     me.version = version
 361     me.changehook.run()
 362
 363 class MonitorList (object):
 364   """
 365   Maintains a collection of MonitorObjects.
 366
 367   The MonitorList can be indexed by name to retrieve the individual objects;
 368   iteration generates the individual objects.  More complicated operations
 369   can be done on the `table' dictionary directly.
 370
 371   Hooks addhook(OBJ) and delhook(OBJ) are invoked when objects are added or
 372   deleted.
 373
 374   Subclass responsibilities:
 375
 376     * list(): return a list of (NAME, INFO) pairs.
 377
 378     * make(NAME, INFO): returns a new MonitorObject for the given NAME; INFO
 379       is from the output of list().
 380   """
 381
 382   def __init__(me):
 383     """Initialize a new MonitorList."""
 384     me.table = {}
 385     me.addhook = HookList()
 386     me.delhook = HookList()
 387
 388   def update(me):
 389     """
 390     Refresh the list of objects:
 391
 392     We add new object which have appeared, delete ones which have vanished,
 393     and update any which persist.
 394     """
 395     new = {}
 396     for name, stuff in me.list():
 397       new[name] = True
 398       me.add(name, stuff)
 399     for name in me.table.copy():
 400       if name not in new:
 401         me.remove(name)
 402
 403   def add(me, name, stuff):
 404     """
 405     Add a new object created by make(NAME, STUFF) if it doesn't already
 406     exist.  If it does, update it.
 407     """
 408     if name not in me.table:
 409       obj = me.make(name, stuff)
 410       me.table[name] = obj
 411       me.addhook.run(obj)
 412     else:
 413       me.table[name].update(stuff)
 414
 415   def remove(me, name):
 416     """
 417     Remove the object called NAME from the list.
 418
 419     The object becomes dead.
 420     """
 421     if name in me.table:
 422       obj = me.table[name]
 423       del me.table[name]
 424       me.delhook.run(obj)
 425       obj.dead()
 426
 427   def __getitem__(me, name):
 428     """Retrieve the object called NAME."""
 429     return me.table[name]
 430
 431   def __iter__(me):
 432     """Iterate over the objects."""
 433     return me.table.itervalues()
 434
 435 class PeerList (MonitorList):
 436   """The list of the known peers."""
 437   def list(me):
 438     return [(name, None) for name in conn.list()]
 439   def make(me, name, stuff):
 440     return Peer(name)
 441
 442 class ServiceList (MonitorList):
 443   """The list of the registered services."""
 444   def list(me):
 445     return conn.svclist()
 446   def make(me, name, stuff):
 447     return Service(name, stuff)
 448
 449 class Monitor (HookClient):
 450   """
 451   The main monitor: keeps track of the changes happening to the server.
 452
 453   Exports the peers, services MonitorLists, and a (plain Python) list
 454   autopeers of peers which the connect service knows how to start by name.
 455
 456   Hooks provided:
 457
 458     * autopeershook(): invoked when the auto-peers list changes.
 459   """
 460   def __init__(me):
 461     """Initialize the Monitor."""
 462     HookClient.__init__(me)
 463     me.peers = PeerList()
 464     me.services = ServiceList()
 465     me.hook(conn.connecthook, me._connected)
 466     me.hook(conn.notehook, me._notify)
 467     me.autopeershook = HookList()
 468     me.autopeers = None
 469
 470   def _connected(me):
 471     """Handle a successful connection by starting the setup coroutine."""
 472     me._setup()
 473
 474   @incr
 475   def _setup(me):
 476     """Coroutine function: initialize for a new connection."""
 477     conn.watch('-A+wnt')
 478     me.peers.update()
 479     me.services.update()
 480     me._updateautopeers()
 481
 482   def _updateautopeers(me):
 483     """Update the auto-peers list from the connect service."""
 484     if 'connect' in me.services.table:
 485       me.autopeers = [' '.join(line)
 486                       for line in conn.svcsubmit('connect', 'list-active')]
 487       me.autopeers.sort()
 488     else:
 489       me.autopeers = None
 490     me.autopeershook.run()
 491
 492   def _notify(me, code, *rest):
 493     """
 494     Handle notifications from the server.
 495
 496     ADD, KILL and NEWIFNAME notifications get passed up to the PeerList;
 497     SVCCLAIM and SVCRELEASE get passed up to the ServiceList.  Finally,
 498     peerdb-update notifications from the watch service cause us to refresh
 499     the auto-peers list.
 500     """
 501     if code == 'ADD':
 502       T.aside(me.peers.add, rest[0], None)
 503     elif code == 'KILL':
 504       T.aside(me.peers.remove, rest[0])
 505     elif code == 'NEWIFNAME':
 506       try:
 507         me.peers[rest[0]].setifname(rest[2])
 508       except KeyError:
 509         pass
 510     elif code == 'NEWADDR':
 511       try:
 512         me.peers[rest[0]].setaddr(rest[1:])
 513       except KeyError:
 514         pass
 515     elif code == 'SVCCLAIM':
 516       T.aside(me.services.add, rest[0], rest[1])
 517       if rest[0] == 'connect':
 518         T.aside(me._updateautopeers)
 519     elif code == 'SVCRELEASE':
 520       T.aside(me.services.remove, rest[0])
 521       if rest[0] == 'connect':
 522         T.aside(me._updateautopeers)
 523     elif code == 'USER':
 524       if not rest: return
 525       if rest[0] == 'watch' and \
 526          rest[1] == 'peerdb-update':
 527         T.aside(me._updateautopeers)
 528
 529 ###--------------------------------------------------------------------------
 530 ### Window management cruft.
 531
 532 class MyWindowMixin (G.Window, HookClient):
 533   """
 534   Mixin for windows which call a closehook when they're destroyed.  It's also
 535   a hookclient, and will release its hooks when it's destroyed.
 536
 537   Hooks:
 538
 539     * closehook(): called when the window is closed.
 540   """
 541
 542   def mywininit(me):
 543     """Initialization function.  Note that it's not called __init__!"""
 544     me.closehook = HookList()
 545     HookClient.__init__(me)
 546     me.connect('destroy', invoker(me.close))
 547
 548   def close(me):
 549     """Close the window, invoking the closehook and releasing all hooks."""
 550     me.closehook.run()
 551     me.destroy()
 552     me.unhookall()
 553
 554 class MyWindow (MyWindowMixin):
 555   """A version of MyWindowMixin suitable as a single parent class."""
 556   def __init__(me, kind = G.WINDOW_TOPLEVEL):
 557     G.Window.__init__(me, kind)
 558     me.mywininit()
 559
 560 class TrivialWindowMixin (MyWindowMixin):
 561   """A simple window which you can close with Escape."""
 562   def mywininit(me):
 563     super(TrivialWindowMixin, me).mywininit()
 564     me.connect('key-press-event', me._keypress)
 565   def _keypress(me, _, ev):
 566     if ev.keyval == GDK.KEY_Escape: me.destroy()
 567
 568 class TrivialWindow (MyWindow, TrivialWindowMixin):
 569   pass
 570
 571 class MyDialog (G.Dialog, MyWindowMixin, HookClient):
 572   """A dialogue box with a closehook and sensible button binding."""
 573
 574   def __init__(me, title = None, flags = 0, buttons = []):
 575     """
 576     The BUTTONS are a list of (STOCKID, THUNK) pairs: call the appropriate
 577     THUNK when the button is pressed.  The other arguments are just like
 578     GTK's Dialog class.
 579     """
 580     i = 0
 581     br = []
 582     me.rmap = []
 583     for b, f in buttons:
 584       br.append(b)
 585       br.append(i)
 586       me.rmap.append(f)
 587       i += 1
 588     G.Dialog.__init__(me, title, None, flags, tuple(br))
 589     me.mywininit()
 590     me.set_default_response(i - 1)
 591     me.connect('response', me.respond)
 592
 593   def respond(me, hunoz, rid, *hukairz):
 594     """Dispatch responses to the appropriate thunks."""
 595     if rid >= 0: me.rmap[rid]()
 596
 597 def makeactiongroup(name, acts):
 598   """
 599   Creates an ActionGroup called NAME.
 600
 601   ACTS is a list of tuples containing:
 602
 603     * ACT: an action name
 604     * LABEL: the label string for the action
 605     * ACCEL: accelerator string, or None
 606     * FUNC: thunk to call when the action is invoked
 607   """
 608   actgroup = G.ActionGroup(name)
 609   for act, label, accel, func in acts:
 610     a = G.Action(act, label, None, None)
 611     if func: a.connect('activate', invoker(func))
 612     actgroup.add_action_with_accel(a, accel)
 613   return actgroup
 614
 615 class GridPacker (G.Table):
 616   """
 617   Like a Table, but with more state: makes filling in the widgets easier.
 618   """
 619
 620   def __init__(me):
 621     """Initialize a new GridPacker."""
 622     G.Table.__init__(me)
 623     me.row = 0
 624     me.col = 0
 625     me.rows = 1
 626     me.cols = 1
 627     me.set_border_width(4)
 628     me.set_col_spacings(4)
 629     me.set_row_spacings(4)
 630
 631   def pack(me, w, width = 1, newlinep = False,
 632            xopt = G.EXPAND | G.FILL | G.SHRINK, yopt = 0,
 633            xpad = 0, ypad = 0):
 634     """
 635     Packs a new widget.
 636
 637     W is the widget to add.  XOPY, YOPT, XPAD and YPAD are as for Table.
 638     WIDTH is how many cells to take up horizontally.  NEWLINEP is whether to
 639     start a new line for this widget.  Returns W.
 640     """
 641     if newlinep:
 642       me.row += 1
 643       me.col = 0
 644     bot = me.row + 1
 645     right = me.col + width
 646     if bot > me.rows or right > me.cols:
 647       if bot > me.rows: me.rows = bot
 648       if right > me.cols: me.cols = right
 649       me.resize(me.rows, me.cols)
 650     me.attach(w, me.col, me.col + width, me.row, me.row + 1,
 651               xopt, yopt, xpad, ypad)
 652     me.col += width
 653     return w
 654
 655   def labelled(me, lab, w, newlinep = False, **kw):
 656     """
 657     Packs a labelled widget.
 658
 659     Other arguments are as for pack.  Returns W.
 660     """
 661     label = G.Label(lab + ' ')
 662     label.set_alignment(1.0, 0)
 663     me.pack(label, newlinep = newlinep, xopt = G.FILL)
 664     me.pack(w, **kw)
 665     return w
 666
 667   def info(me, label, text = None, len = 18, **kw):
 668     """
 669     Packs an information widget with a label.
 670
 671     LABEL is the label; TEXT is the initial text; LEN is the estimated length
 672     in characters.  Returns the entry widget.
 673     """
 674     e = G.Label()
 675     if text is not None: e.set_text(text)
 676     e.set_width_chars(len)
 677     e.set_selectable(True)
 678     e.set_alignment(0.0, 0.5)
 679     me.labelled(label, e, **kw)
 680     return e
 681
 682 class WindowSlot (HookClient):
 683   """
 684   A place to store a window -- specificially a MyWindowMixin.
 685
 686   If the window is destroyed, remember this; when we come to open the window,
 687   raise it if it already exists; otherwise make a new one.
 688   """
 689   def __init__(me, createfunc):
 690     """
 691     Constructor: CREATEFUNC must return a new Window which supports the
 692     closehook protocol.
 693     """
 694     HookClient.__init__(me)
 695     me.createfunc = createfunc
 696     me.window = None
 697
 698   def open(me):
 699     """Opens the window, creating it if necessary."""
 700     if me.window:
 701       raise_window(me.window)
 702     else:
 703       me.window = me.createfunc()
 704       me.hook(me.window.closehook, me.closed)
 705
 706   def closed(me):
 707     """Handles the window being closed."""
 708     me.unhook(me.window.closehook)
 709     me.window = None
 710
 711 class MyTreeView (G.TreeView):
 712   def __init__(me, model):
 713     G.TreeView.__init__(me, model)
 714     me.set_rules_hint(True)
 715
 716 class MyScrolledWindow (G.ScrolledWindow):
 717   def __init__(me):
 718     G.ScrolledWindow.__init__(me)
 719     me.set_policy(G.POLICY_AUTOMATIC, G.POLICY_AUTOMATIC)
 720     me.set_shadow_type(G.SHADOW_IN)
 721
 722 ## Matches a signed integer.
 723 rx_num = RX.compile(r'^[-+]?\d+$')
 724
 725 ## The colour red.
 726 c_red = GDK.color_parse('#ff6666')
 727
 728 class ValidationError (Exception):
 729   """Raised by ValidatingEntry.get_text() if the text isn't valid."""
 730   pass
 731
 732 class ValidatingEntry (G.Entry):
 733   """
 734   Like an Entry, but makes the text go red if the contents are invalid.
 735
 736   If get_text is called, and the text is invalid, ValidationError is raised.
 737   The attribute validp reflects whether the contents are currently valid.
 738   """
 739
 740   def __init__(me, valid, text = '', size = -1, *arg, **kw):
 741     """
 742     Make a validating Entry.
 743
 744     VALID is a regular expression or a predicate on strings.  TEXT is the
 745     default text to insert.  SIZE is the size of the box to set, in
 746     characters (ish).  Other arguments are passed to Entry.
 747     """
 748     G.Entry.__init__(me, *arg, **kw)
 749     me.connect("changed", me._check)
 750     me.connect("state-changed", me._check)
 751     if callable(valid):
 752       me.validate = valid
 753     else:
 754       me.validate = RX.compile(valid).match
 755     me.ensure_style()
 756     if size != -1: me.set_width_chars(size)
 757     me.set_activates_default(True)
 758     me.set_text(text)
 759     me._check()
 760
 761   def _check(me, *hunoz):
 762     """Check the current text and update validp and the text colour."""
 763     if me.validate(G.Entry.get_text(me)):
 764       me.validp = True
 765       set_entry_bg(me, None)
 766     else:
 767       me.validp = False
 768       set_entry_bg(me, me.is_sensitive() and c_red or None)
 769
 770   def get_text(me):
 771     """
 772     Return the text in the Entry if it's valid.  If it isn't, raise
 773     ValidationError.
 774     """
 775     if not me.validp:
 776       raise ValidationError
 777     return G.Entry.get_text(me)
 778
 779 def numericvalidate(min = None, max = None):
 780   """
 781   Return a validation function for numbers.
 782
 783   Entry must consist of an optional sign followed by digits, and the
 784   resulting integer must be within the given bounds.
 785   """
 786   return lambda x: (rx_num.match(x) and
 787                     (min is None or long(x) >= min) and
 788                     (max is None or long(x) <= max))
 789
 790 ###--------------------------------------------------------------------------
 791 ### Various minor dialog boxen.
 792
 793 GPL = """\
 794 TrIPE is free software: you can redistribute it and/or modify it under
 795 the terms of the GNU General Public License as published by the Free
 796 Software Foundation; either version 3 of the License, or (at your
 797 option) any later version.
 798
 799 TrIPE is distributed in the hope that it will be useful, but WITHOUT
 800 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 801 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 802 for more details.
 803
 804 You should have received a copy of the GNU General Public License
 805 along with TrIPE.  If not, see <https://www.gnu.org/licenses/>."""
 806
 807 class AboutBox (G.AboutDialog, TrivialWindowMixin):
 808   """The program `About' box."""
 809   def __init__(me):
 810     G.AboutDialog.__init__(me)
 811     me.mywininit()
 812     me.set_name('TrIPEmon')
 813     me.set_version(T.VERSION)
 814     me.set_license(GPL)
 815     me.set_authors(['Mark Wooding <mdw@distorted.org.uk>'])
 816     me.set_comments('A graphical monitor for the TrIPE VPN server')
 817     me.set_copyright('Copyright © 2006-2008 Straylight/Edgeware')
 818     me.connect('response', me.respond)
 819     me.show()
 820   def respond(me, hunoz, rid, *hukairz):
 821     if rid == G.RESPONSE_CANCEL:
 822       me.close()
 823 aboutbox = WindowSlot(AboutBox)
 824
 825 def moanbox(msg):
 826   """Report an error message in a window."""
 827   d = G.Dialog('Error from %s' % M.quis,
 828                flags = G.DIALOG_MODAL,
 829                buttons = ((G.STOCK_OK, G.RESPONSE_NONE)))
 830   label = G.Label(msg)
 831   label.set_padding(20, 20)
 832   d.vbox.pack_start(label, True, True, 0)
 833   label.show()
 834   d.run()
 835   d.destroy()
 836
 837 def unimplemented(*hunoz):
 838   """Indicator of laziness."""
 839   moanbox("I've not written that bit yet.")
 840
 841 ###--------------------------------------------------------------------------
 842 ### Logging windows.
 843
 844 class LogModel (G.ListStore):
 845   """
 846   A simple list of log messages, usable as the model for a TreeView.
 847
 848   The column headings are stored in the `cols' attribute.
 849   """
 850
 851   def __init__(me, columns):
 852     """
 853     COLUMNS must be a list of column name strings.  We add a time column to
 854     the left.
 855     """
 856     me.cols = ('Time',) + columns
 857     G.ListStore.__init__(me, *((GO.TYPE_STRING,) * len(me.cols)))
 858
 859   def add(me, *entries):
 860     """
 861     Adds a new log message, with a timestamp.
 862
 863     The ENTRIES are the contents for the list columns.
 864     """
 865     now = TIME.strftime('%Y-%m-%d %H:%M:%S')
 866     me.append((now, ) + entries)
 867
 868 class TraceLogModel (LogModel):
 869   """Log model for trace messages."""
 870   def __init__(me):
 871     LogModel.__init__(me, ('Message',))
 872   def notify(me, line):
 873     """Call with a new trace message."""
 874     me.add(line)
 875
 876 class WarningLogModel (LogModel):
 877   """
 878   Log model for warnings.
 879
 880   We split the category out into a separate column.
 881   """
 882   def __init__(me):
 883     LogModel.__init__(me, ('Category', 'Message'))
 884   def notify(me, tag, *rest):
 885     """Call with a new warning message."""
 886     me.add(tag, ' '.join([T.quotify(w) for w in rest]))
 887
 888 class LogViewer (TrivialWindow):
 889   """
 890   A log viewer window.
 891
 892   Its contents are a TreeView showing the log.
 893
 894   Attributes:
 895
 896     * model: an appropriate LogModel
 897     * list: a TreeView widget to display the log
 898   """
 899
 900   def __init__(me, model):
 901     """
 902     Create a log viewer showing the LogModel MODEL.
 903     """
 904     TrivialWindow.__init__(me)
 905     me.model = model
 906     scr = MyScrolledWindow()
 907     me.list = MyTreeView(me.model)
 908     i = 0
 909     for c in me.model.cols:
 910       crt = G.CellRendererText()
 911       me.list.append_column(G.TreeViewColumn(c, crt, text = i))
 912       i += 1
 913     crt.set_property('family', 'monospace')
 914     me.set_default_size(440, 256)
 915     scr.add(me.list)
 916     me.add(scr)
 917     me.show_all()
 918
 919 ###--------------------------------------------------------------------------
 920 ### Pinging peers.
 921
 922 class pingstate (struct):
 923   """
 924   Information kept for each peer by the Pinger.
 925
 926   Important attributes:
 927
 928     * peer = the peer name
 929     * command = PING or EPING
 930     * n = how many pings we've sent so far
 931     * ngood = how many returned
 932     * nmiss = how many didn't return
 933     * nmissrun = how many pings since the last good one
 934     * tlast = round-trip time for the last (good) ping
 935     * ttot = total roung trip time
 936   """
 937   pass
 938
 939 class Pinger (T.Coroutine, HookClient):
 940   """
 941   Coroutine which pings known peers and collects statistics.
 942
 943   Interesting attributes:
 944
 945     * _map: dict mapping peer names to Peer objects
 946     * _q: event queue for notifying pinger coroutine
 947     * _timer: gobject timer for waking the coroutine
 948   """
 949
 950   def __init__(me):
 951     """
 952     Initialize the pinger.
 953
 954     We watch the monitor's PeerList to track which peers we should ping.  We
 955     maintain an event queue and put all the events on that.
 956
 957     The statistics for a PEER are held in the Peer object, in PEER.ping[CMD],
 958     where CMD is 'PING' or 'EPING'.
 959     """
 960     T.Coroutine.__init__(me)
 961     HookClient.__init__(me)
 962     me._map = {}
 963     me._q = T.Queue()
 964     me._timer = None
 965     me.hook(conn.connecthook, me._connected)
 966     me.hook(conn.disconnecthook, me._disconnected)
 967     me.hook(monitor.peers.addhook,
 968             lambda p: T.defer(me._q.put, (p, 'ADD', None)))
 969     me.hook(monitor.peers.delhook,
 970             lambda p: T.defer(me._q.put, (p, 'KILL', None)))
 971     if conn.connectedp(): me.connected()
 972
 973   def _connected(me):
 974     """Respond to connection: start pinging thngs."""
 975     me._timer = GL.timeout_add(1000, me._timerfunc)
 976
 977   def _timerfunc(me):
 978     """Timer function: put a timer event on the queue."""
 979     me._q.put((None, 'TIMER', None))
 980     return True
 981
 982   def _disconnected(me, reason):
 983     """Respond to disconnection: stop pinging."""
 984     GL.source_remove(me._timer)
 985
 986   def run(me):
 987     """
 988     Coroutine function: read events from the queue and process them.
 989
 990     Interesting events:
 991
 992       * (PEER, 'KILL', None): remove PEER from the interesting peers list
 993       * (PEER, 'ADD', None): add PEER to the list
 994       * (PEER, 'INFO', TOKENS): result from a PING command
 995       * (None, 'TIMER', None): interval timer went off: send more pings
 996     """
 997     while True:
 998       tag, code, stuff = me._q.get()
 999       if code == 'KILL':
1000         name = tag.name
1001         if name in me._map:
1002           del me._map[name]
1003       elif not conn.connectedp():
1004         pass
1005       elif code == 'ADD':
1006         p = tag
1007         p.ping = {}
1008         for cmd in 'PING', 'EPING':
1009           ps = pingstate(command = cmd, peer = p,
1010                          n = 0, ngood = 0, nmiss = 0, nmissrun = 0,
1011                          tlast = 0, ttot = 0)
1012           p.ping[cmd] = ps
1013         me._map[p.name] = p
1014       elif code == 'INFO':
1015         ps = tag
1016         if stuff[0] == 'ping-ok':
1017           t = float(stuff[1])
1018           ps.ngood += 1
1019           ps.nmissrun = 0
1020           ps.tlast = t
1021           ps.ttot += t
1022         else:
1023           ps.nmiss += 1
1024           ps.nmissrun += 1
1025         ps.n += 1
1026         ps.peer.pinghook.run(ps.peer, ps.command, ps)
1027       elif code == 'TIMER':
1028         for name, p in me._map.iteritems():
1029           for cmd, ps in p.ping.iteritems():
1030             conn.rawcommand(T.TripeAsynchronousCommand(me._q, ps, [
1031               cmd, '-background', conn.bgtag(), '--', name]))
1032
1033 ###--------------------------------------------------------------------------
1034 ### Random dialogue boxes.
1035
1036 class AddPeerDialog (MyDialog):
1037   """
1038   Let the user create a new peer the low-level way.
1039
1040   Interesting attributes:
1041
1042     * e_name, e_addr, e_port, c_keepalive, l_tunnel: widgets in the dialog
1043   """
1044
1045   def __init__(me):
1046     """Initialize the dialogue."""
1047     MyDialog.__init__(me, 'Add peer',
1048                       buttons = [(G.STOCK_CANCEL, me.destroy),
1049                                  (G.STOCK_OK, me.ok)])
1050     me._setup()
1051
1052   @incr
1053   def _setup(me):
1054     """Coroutine function: background setup for AddPeerDialog."""
1055     table = GridPacker()
1056     me.vbox.pack_start(table, True, True, 0)
1057     me.e_name = table.labelled('Name',
1058                                ValidatingEntry(r'^[^\s.:]+$', '', 16),
1059                                width = 3)
1060     me.e_addr = table.labelled('Address',
1061                                ValidatingEntry(r'^[a-zA-Z0-9.-]+$', '', 24),
1062                                newlinep = True)
1063     me.e_port = table.labelled('Port',
1064                                ValidatingEntry(numericvalidate(0, 65535),
1065                                                '4070',
1066                                                5))
1067     me.l_tunnel = table.labelled('Tunnel', combo_box_text(),
1068                                  newlinep = True, width = 3)
1069     me.tuns = ['(Default)'] + conn.tunnels()
1070     for t in me.tuns:
1071       me.l_tunnel.append_text(t)
1072     me.l_tunnel.set_active(0)
1073
1074     def tickybox_sensitivity(tickybox, target):
1075       tickybox.connect('toggled',
1076                        lambda t: target.set_sensitive (t.get_active()))
1077
1078     me.c_keepalive = G.CheckButton('Keepalives')
1079     table.pack(me.c_keepalive, newlinep = True, xopt = G.FILL)
1080     me.e_keepalive = ValidatingEntry(r'^\d+[hms]?$', '', 5)
1081     me.e_keepalive.set_sensitive(False)
1082     tickybox_sensitivity(me.c_keepalive, me.e_keepalive)
1083     table.pack(me.e_keepalive, width = 3)
1084
1085     me.c_cork = G.CheckButton('Cork')
1086     table.pack(me.c_cork, newlinep = True, width = 4, xopt = G.FILL)
1087
1088     me.c_mobile = G.CheckButton('Mobile')
1089     table.pack(me.c_mobile, newlinep = True, width = 4, xopt = G.FILL)
1090
1091     me.c_peerkey = G.CheckButton('Peer key tag')
1092     table.pack(me.c_peerkey, newlinep = True, xopt = G.FILL)
1093     me.e_peerkey = ValidatingEntry(r'^[^.:\s]+$', '', 16)
1094     me.e_peerkey.set_sensitive(False)
1095     tickybox_sensitivity(me.c_peerkey, me.e_peerkey)
1096     table.pack(me.e_peerkey, width = 3)
1097
1098     me.c_privkey = G.CheckButton('Private key tag')
1099     table.pack(me.c_privkey, newlinep = True, xopt = G.FILL)
1100     me.e_privkey = ValidatingEntry(r'^[^.:\s]+$', '', 16)
1101     me.e_privkey.set_sensitive(False)
1102     tickybox_sensitivity(me.c_privkey, me.e_privkey)
1103     table.pack(me.e_privkey, width = 3)
1104
1105     me.show_all()
1106
1107   def ok(me):
1108     """Handle an OK press: create the peer."""
1109     try:
1110       t = me.l_tunnel.get_active()
1111       me._addpeer(me.e_name.get_text(),
1112                   me.e_addr.get_text(),
1113                   me.e_port.get_text(),
1114                   keepalive = (me.c_keepalive.get_active() and
1115                                me.e_keepalive.get_text() or None),
1116                   tunnel = t and me.tuns[t] or None,
1117                   cork = me.c_cork.get_active() or None,
1118                   mobile = me.c_mobile.get_active() or None,
1119                   key = (me.c_peerkey.get_active() and
1120                          me.e_peerkey.get_text() or None),
1121                   priv = (me.c_privkey.get_active() and
1122                           me.e_privkey.get_text() or None))
1123     except ValidationError:
1124       GDK.beep()
1125       return
1126
1127   @incr
1128   def _addpeer(me, *args, **kw):
1129     """Coroutine function: actually do the ADD command."""
1130     try:
1131       conn.add(*args, **kw)
1132       me.destroy()
1133     except T.TripeError, exc:
1134       T.defer(moanbox, ' '.join(exc))
1135
1136 class ServInfo (TrivialWindow):
1137   """
1138   Show information about the server and available services.
1139
1140   Interesting attributes:
1141
1142     * e: maps SERVINFO keys to entry widgets
1143     * svcs: Gtk ListStore describing services (columns are name and version)
1144   """
1145
1146   def __init__(me):
1147     TrivialWindow.__init__(me)
1148     me.set_title('TrIPE server info')
1149     table = GridPacker()
1150     me.add(table)
1151     me.e = {}
1152     def add(label, tag, text = None, **kw):
1153       me.e[tag] = table.info(label, text, **kw)
1154     add('Implementation', 'implementation')
1155     add('Version', 'version', newlinep = True)
1156     me.svcs = G.ListStore(*(GO.TYPE_STRING,) * 2)
1157     me.svcs.set_sort_column_id(0, G.SORT_ASCENDING)
1158     scr = MyScrolledWindow()
1159     lb = MyTreeView(me.svcs)
1160     i = 0
1161     for title in 'Service', 'Version':
1162       lb.append_column(G.TreeViewColumn(
1163         title, G.CellRendererText(), text = i))
1164       i += 1
1165     for svc in monitor.services:
1166       me.svcs.append([svc.name, svc.version])
1167     scr.add(lb)
1168     table.pack(scr, width = 2, newlinep = True,
1169                yopt = G.EXPAND | G.FILL | G.SHRINK)
1170     me.update()
1171     me.hook(conn.connecthook, me.update)
1172     me.hook(monitor.services.addhook, me.addsvc)
1173     me.hook(monitor.services.delhook, me.delsvc)
1174     me.show_all()
1175
1176   def addsvc(me, svc):
1177     me.svcs.append([svc.name, svc.version])
1178
1179   def delsvc(me, svc):
1180     for i in xrange(len(me.svcs)):
1181       if me.svcs[i][0] == svc.name:
1182         me.svcs.remove(me.svcs.get_iter(i))
1183         break
1184   @incr
1185   def update(me):
1186     info = conn.servinfo()
1187     for i in me.e:
1188       me.e[i].set_text(info[i])
1189
1190 class TraceOptions (MyDialog):
1191   """Tracing options window."""
1192   def __init__(me):
1193     MyDialog.__init__(me, title = 'Tracing options',
1194                       buttons = [(G.STOCK_CLOSE, me.destroy),
1195                                  (G.STOCK_OK, cr(me.ok))])
1196     me._setup()
1197
1198   @incr
1199   def _setup(me):
1200     me.opts = []
1201     for ch, st, desc in conn.trace():
1202       if ch.isupper(): continue
1203       text = desc[0].upper() + desc[1:]
1204       ticky = G.CheckButton(text)
1205       ticky.set_active(st == '+')
1206       me.vbox.pack_start(ticky, True, True, 0)
1207       me.opts.append((ch, ticky))
1208     me.show_all()
1209   def ok(me):
1210     on = []
1211     off = []
1212     for ch, ticky in me.opts:
1213       if ticky.get_active():
1214         on.append(ch)
1215       else:
1216         off.append(ch)
1217     setting = ''.join(on) + '-' + ''.join(off)
1218     conn.trace(setting)
1219     me.destroy()
1220
1221 ###--------------------------------------------------------------------------
1222 ### Peer window.
1223
1224 def xlate_time(t):
1225   """Translate a TrIPE-format time to something human-readable."""
1226   if t == 'NEVER': return '(never)'
1227   YY, MM, DD, hh, mm, ss = map(int, rx_time.match(t).group(1, 2, 3, 4, 5, 6))
1228   ago = TIME.time() - TIME.mktime((YY, MM, DD, hh, mm, ss, 0, 0, -1))
1229   ago = MATH.floor(ago); unit = 's'
1230   for n, u in [(60, 'min'), (60, 'hrs'), (24, 'days')]:
1231     if ago < 2*n: break
1232     ago /= n
1233     unit = u
1234   return '%04d:%02d:%02d %02d:%02d:%02d (%.1f %s ago)' % \
1235          (YY, MM, DD, hh, mm, ss, ago, unit)
1236 def xlate_bytes(b):
1237   """Translate a raw byte count into something a human might want to read."""
1238   suff = 'B'
1239   b = int(b)
1240   for s in 'KMG':
1241     if b < 4096: break
1242     b /= 1024
1243     suff = s
1244   return '%d %s' % (b, suff)
1245
1246 ## How to translate peer stats.  Maps the stat name to a translation
1247 ## function.
1248 statsxlate = \
1249   [('start-time', xlate_time),
1250    ('last-packet-time', xlate_time),
1251    ('last-keyexch-time', xlate_time),
1252    ('bytes-in', xlate_bytes),
1253    ('bytes-out', xlate_bytes),
1254    ('keyexch-bytes-in', xlate_bytes),
1255    ('keyexch-bytes-out', xlate_bytes),
1256    ('ip-bytes-in', xlate_bytes),
1257    ('ip-bytes-out', xlate_bytes)]
1258
1259 def format_stat(format, dict):
1260   if callable(format): return format(dict)
1261   else: return format % dict
1262
1263 ## How to lay out the stats dialog.  Format is (LABEL, FORMAT): LABEL is
1264 ## the label to give the entry box; FORMAT is the format string to write into
1265 ## the entry.
1266 cryptolayout = \
1267   [('Diffie-Hellman group',
1268     '%(kx-group)s '
1269     '(%(kx-group-order-bits)s-bit order, '
1270     '%(kx-group-elt-bits)s-bit elements)'),
1271    ('Bulk crypto transform',
1272     '%(bulk-transform)s (%(bulk-overhead)s byte overhead)'),
1273    ('Data encryption', lambda d: '%s (%s; %s)' % (
1274      d['cipher'],
1275      '%d-bit key' % (8*int(d['cipher-keysz'])),
1276      d.get('cipher-blksz', '0') == '0'
1277        and 'stream cipher'
1278        or '%d-bit block' % (8*int(d['cipher-blksz'])))),
1279    ('Message authentication', lambda d: '%s (%s; %s)' % (
1280      d['mac'],
1281      d.get('mac-keysz') is None
1282        and 'one-time MAC'
1283        or '%d-bit key' % (8*int(d['mac-keysz'])),
1284      '%d-bit tag' % (8*int(d['mac-tagsz'])))),
1285    ('Hash', lambda d: '%s (%d-bit output)' %
1286     (d['hash'], 8*int(d['hash-sz'])))]
1287
1288 statslayout = \
1289   [('Start time', '%(start-time)s'),
1290    ('Private key', '%(current-key)s')] + \
1291   cryptolayout + \
1292   [('Last key-exchange', '%(last-keyexch-time)s'),
1293    ('Last packet', '%(last-packet-time)s'),
1294    ('Packets in/out',
1295     '%(packets-in)s (%(bytes-in)s) / %(packets-out)s (%(bytes-out)s)'),
1296    ('Key-exchange in/out',
1297     '%(keyexch-packets-in)s (%(keyexch-bytes-in)s) / %(keyexch-packets-out)s (%(keyexch-bytes-out)s)'),
1298    ('IP in/out',
1299     '%(ip-packets-in)s (%(ip-bytes-in)s) / %(ip-packets-out)s (%(ip-bytes-out)s)'),
1300    ('Rejected packets', '%(rejected-packets)s')]
1301
1302 class PeerWindow (TrivialWindow):
1303   """
1304   Show information about a peer.
1305
1306   This gives a graphical view of the server's peer statistics.
1307
1308   Interesting attributes:
1309
1310     * e: dict mapping keys (mostly matching label widget texts, though pings
1311       use command names) to entry widgets so that we can update them easily
1312     * peer: the peer this window shows information about
1313     * cr: the info-fetching coroutine, or None if crrrently disconnected
1314     * doupate: whether the info-fetching corouting should continue running
1315   """
1316
1317   def __init__(me, peer):
1318     """Construct a PeerWindow, showing information about PEER."""
1319
1320     TrivialWindow.__init__(me)
1321     me.set_title('TrIPE statistics: %s' % peer.name)
1322     me.peer = peer
1323
1324     table = GridPacker()
1325     me.add(table)
1326
1327     ## Utility for adding fields.
1328     me.e = {}
1329     def add(label, text = None, key = None):
1330       if key is None: key = label
1331       me.e[key] = table.info(label, text, len = 42, newlinep = True)
1332
1333     ## Build the dialogue box.
1334     add('Peer name', peer.name)
1335     add('Tunnel', peer.tunnel)
1336     add('Interface', peer.ifname)
1337     add('Keepalives',
1338         (peer.keepalive == '0' and 'never') or '%s s' % peer.keepalive)
1339     add('Address', peer.addr)
1340     add('Transport pings', key = 'PING')
1341     add('Encrypted pings', key = 'EPING')
1342
1343     for label, format in statslayout:
1344       add(label)
1345
1346     ## Hook onto various interesting events.
1347     me.hook(conn.connecthook, me.tryupdate)
1348     me.hook(conn.disconnecthook, me.stopupdate)
1349     me.hook(me.closehook, me.stopupdate)
1350     me.hook(me.peer.deadhook, me.dead)
1351     me.hook(me.peer.changehook, me.change)
1352     me.hook(me.peer.pinghook, me.ping)
1353     me.cr = None
1354     me.doupdate = True
1355     me.tryupdate()
1356
1357     ## Format the ping statistics.
1358     for cmd, ps in me.peer.ping.iteritems():
1359       me.ping(me.peer, cmd, ps)
1360
1361     ## And show the window.
1362     me.show_all()
1363
1364   def change(me):
1365     """Update the display in response to a notification."""
1366     me.e['Interface'].set_text(me.peer.ifname)
1367
1368   def _update(me):
1369     """
1370     Main display-updating coroutine.
1371
1372     This does an update, sleeps for a while, and starts again.  If the
1373     me.doupdate flag goes low, we stop the loop.
1374     """
1375     while me.peer.alivep and conn.connectedp() and me.doupdate:
1376       stat = conn.stats(me.peer.name)
1377       for s, trans in statsxlate:
1378         stat[s] = trans(stat[s])
1379       stat.update(me.peer.__dict__)
1380       for label, format in statslayout:
1381         me.e[label].set_text(format_stat(format, stat))
1382       GL.timeout_add(1000, lambda: me.cr.switch() and False)
1383       me.cr.parent.switch()
1384     me.cr = None
1385
1386   def tryupdate(me):
1387     """Start the updater coroutine, if it's not going already."""
1388     if me.cr is None:
1389       me.cr = T.Coroutine(me._update,
1390                           name = 'update-peer-window %s' % me.peer.name)
1391       me.cr.switch()
1392
1393   def stopupdate(me, *hunoz, **hukairz):
1394     """Stop the update coroutine, by setting me.doupdate."""
1395     me.doupdate = False
1396
1397   def dead(me):
1398     """Called when the peer is killed."""
1399     me.set_title('TrIPE statistics: %s [defunct]' % me.peer.name)
1400     me.e['Peer name'].set_text('%s [defunct]' % me.peer.name)
1401     me.stopupdate()
1402
1403   def ping(me, peer, cmd, ps):
1404     """Called when a ping result for the peer is reported."""
1405     s = '%d/%d' % (ps.ngood, ps.n)
1406     if ps.n:
1407       s += ' (%.1f%%)' % (ps.ngood * 100.0/ps.n)
1408     if ps.ngood:
1409       s += '; %.2f ms (last %.1f ms)' % (ps.ttot/ps.ngood, ps.tlast);
1410     me.e[ps.command].set_text(s)
1411
1412 ###--------------------------------------------------------------------------
1413 ### Cryptographic status.
1414
1415 class CryptoInfo (TrivialWindow):
1416   """Simple display of cryptographic algorithms in use."""
1417   def __init__(me):
1418     TrivialWindow.__init__(me)
1419     me.set_title('Cryptographic algorithms')
1420     T.aside(me.populate)
1421   def populate(me):
1422     table = GridPacker()
1423     me.add(table)
1424
1425     crypto = conn.algs()
1426     table.info('Diffie-Hellman group',
1427                '%s (%d-bit order, %d-bit elements)' %
1428                (crypto['kx-group'],
1429                 int(crypto['kx-group-order-bits']),
1430                 int(crypto['kx-group-elt-bits'])),
1431                len = 32)
1432     table.info('Data encryption',
1433                '%s (%d-bit key; %s)' %
1434                (crypto['cipher'],
1435                 int(crypto['cipher-keysz']) * 8,
1436                 crypto['cipher-blksz'] == '0'
1437                   and 'stream cipher'
1438                   or '%d-bit block' % (int(crypto['cipher-blksz']) * 8)),
1439                newlinep = True)
1440     table.info('Message authentication',
1441                '%s (%d-bit key; %d-bit tag)' %
1442                (crypto['mac'],
1443                 int(crypto['mac-keysz']) * 8,
1444                 int(crypto['mac-tagsz']) * 8),
1445                newlinep = True)
1446     table.info('Hash function',
1447                '%s (%d-bit output)' %
1448                (crypto['hash'],
1449                 int(crypto['hash-sz']) * 8),
1450                newlinep = True)
1451
1452     me.show_all()
1453
1454 ###--------------------------------------------------------------------------
1455 ### Main monitor window.
1456
1457 class MonitorWindow (MyWindow):
1458
1459   """
1460   The main monitor window.
1461
1462   This class creates, populates and maintains the main monitor window.
1463
1464   Lots of attributes:
1465
1466     * warnings, trace: log models for server output
1467     * warnview, traceview, traceopts, addpeerwin, cryptoinfo, servinfo:
1468       WindowSlot objects for ancillary windows
1469     * ui: Gtk UIManager object for the menu system
1470     * apmenu: pair of identical autoconnecting peer menus
1471     * listmodel: Gtk ListStore for connected peers; contains peer name,
1472       address, and ping times (transport and encrypted, value and colour)
1473     * status: Gtk Statusbar at the bottom of the window
1474     * _kidding: an unpleasant backchannel between the apchange method (which
1475       builds the apmenus) and the menu handler, forced on us by a Gtk
1476       misfeature
1477
1478   Also installs attributes on Peer objects:
1479
1480     * i: index of peer's entry in listmodel
1481     * win: WindowSlot object for the peer's PeerWindow
1482   """
1483
1484   def __init__(me):
1485     """Construct the window."""
1486
1487     ## Basic stuff.
1488     MyWindow.__init__(me)
1489     me.set_title('TrIPE monitor')
1490
1491     ## Hook onto diagnostic outputs.
1492     me.warnings = WarningLogModel()
1493     me.hook(conn.warnhook, me.warnings.notify)
1494     me.trace = TraceLogModel()
1495     me.hook(conn.tracehook, me.trace.notify)
1496
1497     ## Make slots to store the various ancillary singleton windows.
1498     me.warnview = WindowSlot(lambda: LogViewer(me.warnings))
1499     me.traceview = WindowSlot(lambda: LogViewer(me.trace))
1500     me.traceopts = WindowSlot(lambda: TraceOptions())
1501     me.addpeerwin = WindowSlot(lambda: AddPeerDialog())
1502     me.cryptoinfo = WindowSlot(lambda: CryptoInfo())
1503     me.servinfo = WindowSlot(lambda: ServInfo())
1504
1505     ## Main window structure.
1506     vbox = G.VBox()
1507     me.add(vbox)
1508
1509     ## UI manager  makes our menus.  (We're too cheap to have a toolbar.)
1510     me.ui = G.UIManager()
1511     actgroup = makeactiongroup('monitor',
1512       [('file-menu', '_File', None, None),
1513        ('connect', '_Connect', '<Control>C', conn.connect),
1514        ('disconnect', '_Disconnect', '<Control>D',
1515         lambda: conn.disconnect(None)),
1516        ('quit', '_Quit', '<Control>Q', me.close),
1517        ('server-menu', '_Server', None, None),
1518        ('daemon', 'Run in _background', None, cr(conn.daemon)),
1519        ('server-version', 'Server version', '<Control>V', me.servinfo.open),
1520        ('crypto-algs', 'Cryptographic algorithms',
1521         '<Control>Y', me.cryptoinfo.open),
1522        ('reload-keys', 'Reload keys', '<Control>R', cr(conn.reload)),
1523        ('server-quit', 'Terminate server', None, cr(conn.quit)),
1524        ('conn-peer', 'Connect peer', None, None),
1525        ('logs-menu', '_Logs', None, None),
1526        ('show-warnings', 'Show _warnings', '<Control>W', me.warnview.open),
1527        ('show-trace', 'Show _trace', '<Control>T', me.traceview.open),
1528        ('trace-options', 'Trace _options...', None, me.traceopts.open),
1529        ('help-menu', '_Help', None, None),
1530        ('about', '_About tripemon...', None, aboutbox.open),
1531        ('add-peer', '_Add peer...', '<Control>A', me.addpeerwin.open),
1532        ('kill-peer', '_Kill peer', None, me.killpeer),
1533        ('force-kx', 'Force key e_xchange', None, me.forcekx)])
1534
1535     ## Menu structures.
1536     uidef = '''
1537       <ui>
1538         <menubar>
1539           <menu action="file-menu">
1540             <menuitem action="quit"/>
1541           </menu>
1542           <menu action="server-menu">
1543             <menuitem action="connect"/>
1544             <menuitem action="disconnect"/>
1545             <separator/>
1546             <menuitem action="server-version"/>
1547             <menuitem action="crypto-algs"/>
1548             <menuitem action="add-peer"/>
1549             <menuitem action="conn-peer"/>
1550             <menuitem action="daemon"/>
1551             <menuitem action="reload-keys"/>
1552             <separator/>
1553             <menuitem action="server-quit"/>
1554           </menu>
1555           <menu action="logs-menu">
1556             <menuitem action="show-warnings"/>
1557             <menuitem action="show-trace"/>
1558             <menuitem action="trace-options"/>
1559           </menu>
1560           <menu action="help-menu">
1561             <menuitem action="about"/>
1562           </menu>
1563         </menubar>
1564         <popup name="peer-popup">
1565           <menuitem action="add-peer"/>
1566           <menuitem action="conn-peer"/>
1567           <menuitem action="kill-peer"/>
1568           <menuitem action="force-kx"/>
1569         </popup>
1570       </ui>
1571       '''
1572
1573     ## Populate the UI manager.
1574     me.ui.insert_action_group(actgroup, 0)
1575     me.ui.add_ui_from_string(uidef)
1576
1577     ## Construct the menu bar.
1578     vbox.pack_start(me.ui.get_widget('/menubar'), False, True, 0)
1579     me.add_accel_group(me.ui.get_accel_group())
1580
1581     ## Construct and attach the auto-peers menu.  (This is a horrible bodge
1582     ## because we can't attach the same submenu in two different places.)
1583     me.apmenu = G.Menu(), G.Menu()
1584     me.ui.get_widget('/menubar/server-menu/conn-peer') \
1585       .set_submenu(me.apmenu[0])
1586     me.ui.get_widget('/peer-popup/conn-peer').set_submenu(me.apmenu[1])
1587
1588     ## Construct the main list model, and listen on hooks which report
1589     ## changes to the available peers.
1590     me.listmodel = G.ListStore(*(GO.TYPE_STRING,) * 6)
1591     me.listmodel.set_sort_column_id(0, G.SORT_ASCENDING)
1592     me.hook(monitor.peers.addhook, me.addpeer)
1593     me.hook(monitor.peers.delhook, me.delpeer)
1594     me.hook(monitor.autopeershook, me.apchange)
1595
1596     ## Construct the list viewer and put it in a scrolling window.
1597     scr = MyScrolledWindow()
1598     me.list = MyTreeView(me.listmodel)
1599     me.list.append_column(G.TreeViewColumn('Peer name',
1600                                            G.CellRendererText(),
1601                                            text = 0))
1602     me.list.append_column(G.TreeViewColumn('Address',
1603                                            G.CellRendererText(),
1604                                            text = 1))
1605     me.list.append_column(G.TreeViewColumn('T-ping',
1606                                            G.CellRendererText(),
1607                                            text = 2,
1608                                            foreground = 3))
1609     me.list.append_column(G.TreeViewColumn('E-ping',
1610                                            G.CellRendererText(),
1611                                            text = 4,
1612                                            foreground = 5))
1613     me.list.get_column(1).set_expand(True)
1614     me.list.connect('row-activated', me.activate)
1615     me.list.connect('button-press-event', me.buttonpress)
1616     me.list.set_reorderable(True)
1617     me.list.get_selection().set_mode(G.SELECTION_NONE)
1618     scr.add(me.list)
1619     vbox.pack_start(scr, True, True, 0)
1620
1621     ## Construct the status bar, and listen on hooks which report changes to
1622     ## connection status.
1623     me.status = G.Statusbar()
1624     vbox.pack_start(me.status, False, True, 0)
1625     me.hook(conn.connecthook, cr(me.connected))
1626     me.hook(conn.disconnecthook, me.disconnected)
1627     me.hook(conn.notehook, me.notify)
1628
1629     ## Set a plausible default window size.
1630     me.set_default_size(512, 180)
1631
1632   def addpeer(me, peer):
1633     """Hook: announces that PEER has been added."""
1634     peer.i = me.listmodel.append([peer.name, peer.addr,
1635                                   '???', 'green', '???', 'green'])
1636     peer.win = WindowSlot(lambda: PeerWindow(peer))
1637     me.hook(peer.pinghook, me._ping)
1638     me.apchange()
1639
1640   def delpeer(me, peer):
1641     """Hook: announces that PEER has been removed."""
1642     me.listmodel.remove(peer.i)
1643     me.unhook(peer.pinghook)
1644     me.apchange()
1645
1646   def path_peer(me, path):
1647     """Return the peer corresponding to a given list-model PATH."""
1648     return monitor.peers[me.listmodel[path][0]]
1649
1650   def apchange(me):
1651     """
1652     Hook: announces that a change has been made to the peers available for
1653     automated connection.
1654
1655     This populates both auto-peer menus and keeps them in sync.  (As
1656     mentioned above, we can't attach the same submenu to two separate parent
1657     menu items.  So we end up with two identical menus instead.  Yes, this
1658     does suck.)
1659     """
1660
1661     ## The set_active method of a CheckMenuItem works by maybe activating the
1662     ## menu item.  This signals our handler.  But we don't actually want to
1663     ## signal the handler unless the user actually frobbed the item.  So the
1664     ## _kidding flag is used as an underhanded way of telling the handler
1665     ## that we don't actually want it to do anything.  Of course, this sucks
1666     ## mightily.
1667     me._kidding = True
1668
1669     ## Iterate over the two menus.
1670     for m in 0, 1:
1671       menu = me.apmenu[m]
1672       existing = menu.get_children()
1673       if monitor.autopeers is None:
1674
1675         ## No peers, so empty out the menu.
1676         for item in existing:
1677           menu.remove(item)
1678
1679       else:
1680
1681         ## Insert the new items into the menu.  (XXX this seems buggy XXX)
1682         ## Tick the peers which are actually connected.
1683         i = j = 0
1684         for peer in monitor.autopeers:
1685           if j < len(existing) and \
1686              existing[j].get_child().get_text() == peer:
1687             item = existing[j]
1688             j += 1
1689           else:
1690             item = G.CheckMenuItem(peer, use_underline = False)
1691             item.connect('activate', invoker(me._addautopeer, peer))
1692             menu.insert(item, i)
1693           item.set_active(peer in monitor.peers.table)
1694           i += 1
1695
1696       ## Make all the menu items visible.
1697       menu.show_all()
1698
1699     ## Set the parent menu items sensitive if and only if there are any peers
1700     ## to connect.
1701     for name in ['/menubar/server-menu/conn-peer', '/peer-popup/conn-peer']:
1702       me.ui.get_widget(name).set_sensitive(bool(monitor.autopeers))
1703
1704     ## And now allow the handler to do its business normally.
1705     me._kidding = False
1706
1707   def _addautopeer(me, peer):
1708     """
1709     Automatically connect an auto-peer.
1710
1711     This method is invoked from the main coroutine.  Since the actual
1712     connection needs to issue administration commands, we must spawn a new
1713     child coroutine for it.
1714     """
1715     if me._kidding:
1716       return
1717     T.Coroutine(me._addautopeer_hack,
1718                 name = '_addautopeerhack %s' % peer).switch(peer)
1719
1720   def _addautopeer_hack(me, peer):
1721     """Make an automated connection to PEER in response to a user click."""
1722     if me._kidding:
1723       return
1724     try:
1725       T._simple(conn.svcsubmit('connect', 'active', peer))
1726     except T.TripeError, exc:
1727       T.defer(moanbox, ' '.join(exc.args))
1728     me.apchange()
1729
1730   def activate(me, l, path, col):
1731     """
1732     Handle a double-click on a peer in the main list: open a PeerInfo window.
1733     """
1734     peer = me.path_peer(path)
1735     peer.win.open()
1736
1737   def buttonpress(me, l, ev):
1738     """
1739     Handle a mouse click on the main list.
1740
1741     Currently we're only interested in button-3, which pops up the peer menu.
1742     For future reference, we stash the peer that was clicked in me.menupeer.
1743     """
1744     if ev.button == 3:
1745       x, y = int(ev.x), int(ev.y)
1746       r = me.list.get_path_at_pos(x, y)
1747       for i in '/peer-popup/kill-peer', '/peer-popup/force-kx':
1748         me.ui.get_widget(i).set_sensitive(conn.connectedp() and
1749                                           r is not None)
1750       me.ui.get_widget('/peer-popup/conn-peer'). \
1751         set_sensitive(bool(monitor.autopeers))
1752       if r:
1753         me.menupeer = me.path_peer(r[0])
1754       else:
1755         me.menupeer = None
1756       me.ui.get_widget('/peer-popup').popup(
1757         None, None, None, ev.button, ev.time)
1758
1759   def killpeer(me):
1760     """Kill a peer from the popup menu."""
1761     cr(conn.kill, me.menupeer.name)()
1762
1763   def forcekx(me):
1764     """Kickstart a key-exchange from the popup menu."""
1765     cr(conn.forcekx, me.menupeer.name)()
1766
1767   _columnmap = {'PING': (2, 3), 'EPING': (4, 5)}
1768   def _ping(me, p, cmd, ps):
1769     """Hook: responds to ping reports."""
1770     textcol, colourcol = me._columnmap[cmd]
1771     if ps.nmissrun:
1772       me.listmodel[p.i][textcol] = '(miss %d)' % ps.nmissrun
1773       me.listmodel[p.i][colourcol] = 'red'
1774     else:
1775       me.listmodel[p.i][textcol] = '%.1f ms' % ps.tlast
1776       me.listmodel[p.i][colourcol] = 'black'
1777
1778   def setstatus(me, status):
1779     """Update the message in the status bar."""
1780     me.status.pop(0)
1781     me.status.push(0, status)
1782
1783   def notify(me, note, *rest):
1784     """Hook: invoked when interesting notifications occur."""
1785     if note == 'DAEMON':
1786       me.ui.get_widget('/menubar/server-menu/daemon').set_sensitive(False)
1787
1788   def connected(me):
1789     """
1790     Hook: invoked when a connection is made to the server.
1791
1792     Make options which require a server connection sensitive.
1793     """
1794     me.setstatus('Connected (port %s)' % conn.port())
1795     me.ui.get_widget('/menubar/server-menu/connect').set_sensitive(False)
1796     for i in ('/menubar/server-menu/disconnect',
1797               '/menubar/server-menu/server-version',
1798               '/menubar/server-menu/add-peer',
1799               '/menubar/server-menu/server-quit',
1800               '/menubar/logs-menu/trace-options'):
1801       me.ui.get_widget(i).set_sensitive(True)
1802     me.ui.get_widget('/menubar/server-menu/conn-peer'). \
1803       set_sensitive(bool(monitor.autopeers))
1804     me.ui.get_widget('/menubar/server-menu/daemon'). \
1805       set_sensitive(conn.servinfo()['daemon'] == 'nil')
1806
1807   def disconnected(me, reason):
1808     """
1809     Hook: invoked when the connection to the server is lost.
1810
1811     Make most options insensitive.
1812     """
1813     me.setstatus('Disconnected')
1814     me.ui.get_widget('/menubar/server-menu/connect').set_sensitive(True)
1815     for i in ('/menubar/server-menu/disconnect',
1816               '/menubar/server-menu/server-version',
1817               '/menubar/server-menu/add-peer',
1818               '/menubar/server-menu/conn-peer',
1819               '/menubar/server-menu/daemon',
1820               '/menubar/server-menu/server-quit',
1821               '/menubar/logs-menu/trace-options'):
1822       me.ui.get_widget(i).set_sensitive(False)
1823     if reason: moanbox(reason)
1824
1825 ###--------------------------------------------------------------------------
1826 ### Main program.
1827
1828 def parse_options():
1829   """
1830   Parse command-line options.
1831
1832   Process the boring ones.  Return all of them, for later.
1833   """
1834   op = OptionParser(usage = '%prog [-a FILE] [-d DIR]',
1835                     version = '%prog (tripe version 1.0.0)')
1836   op.add_option('-a', '--admin-socket',
1837                 metavar = 'FILE', dest = 'tripesock', default = T.tripesock,
1838                 help = 'Select socket to connect to [default %default]')
1839   op.add_option('-d', '--directory',
1840                 metavar = 'DIR', dest = 'dir', default = T.configdir,
1841                 help = 'Select current diretory [default %default]')
1842   opts, args = op.parse_args()
1843   if args: op.error('no arguments permitted')
1844   OS.chdir(opts.dir)
1845   return opts
1846
1847 def init(opts):
1848   """Initialization."""
1849
1850   global conn, monitor, pinger
1851
1852   ## Try to establish a connection.
1853   conn = Connection(opts.tripesock)
1854
1855   ## Make the main interesting coroutines and objects.
1856   monitor = Monitor()
1857   pinger = Pinger()
1858   pinger.switch()
1859
1860 def main():
1861
1862   ## Main window.
1863   root = MonitorWindow()
1864   conn.connect()
1865   root.show_all()
1866
1867   ## Main loop.
1868   HookClient().hook(root.closehook, exit)
1869   conn.mainloop()
1870
1871 if __name__ == '__main__':
1872   opts = parse_options()
1873   init(opts)
1874   main()
1875
1876 ###----- That's all, folks --------------------------------------------------