/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos-monitor

  • Committer: Teddy Hogeborn
  • Date: 2009-04-17 08:26:17 UTC
  • Revision ID: teddy@fukt.bsnet.se-20090417082617-eltetak5lzjyz55o
* initramfs-tools-hook: Bug fix: Add "--userid" and "--groupid" to
                        start of "plugin-runner.conf" file instead of
                        appending, to allow any preexisting options to
                        override.
* plugin-runner.conf: Improved wording.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/python
2
 
# -*- mode: python; coding: utf-8 -*-
3
 
 
4
 
from __future__ import division, absolute_import, with_statement
5
 
 
6
 
import sys
7
 
import os
8
 
import signal
9
 
 
10
 
import datetime
11
 
 
12
 
import urwid.curses_display
13
 
import urwid
14
 
 
15
 
from dbus.mainloop.glib import DBusGMainLoop
16
 
import gobject
17
 
 
18
 
import dbus
19
 
 
20
 
import UserList
21
 
 
22
 
import locale
23
 
 
24
 
locale.setlocale(locale.LC_ALL, u'')
25
 
 
26
 
import logging
27
 
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
28
 
 
29
 
# Some useful constants
30
 
domain = 'se.bsnet.fukt'
31
 
server_interface = domain + '.Mandos'
32
 
client_interface = domain + '.Mandos.Client'
33
 
version = "1.0.15"
34
 
 
35
 
# Always run in monochrome mode
36
 
urwid.curses_display.curses.has_colors = lambda : False
37
 
 
38
 
# Urwid doesn't support blinking, but we want it.  Since we have no
39
 
# use for underline on its own, we make underline also always blink.
40
 
urwid.curses_display.curses.A_UNDERLINE |= (
41
 
    urwid.curses_display.curses.A_BLINK)
42
 
 
43
 
class MandosClientPropertyCache(object):
44
 
    """This wraps a Mandos Client D-Bus proxy object, caches the
45
 
    properties and calls a hook function when any of them are
46
 
    changed.
47
 
    """
48
 
    def __init__(self, proxy_object=None, *args, **kwargs):
49
 
        self.proxy = proxy_object # Mandos Client proxy object
50
 
        
51
 
        self.properties = dict()
52
 
        self.proxy.connect_to_signal(u"PropertyChanged",
53
 
                                     self.property_changed,
54
 
                                     client_interface,
55
 
                                     byte_arrays=True)
56
 
        
57
 
        self.properties.update(
58
 
            self.proxy.GetAll(client_interface,
59
 
                              dbus_interface = dbus.PROPERTIES_IFACE))
60
 
 
61
 
        #XXX This break good super behaviour!
62
 
#        super(MandosClientPropertyCache, self).__init__(
63
 
#            *args, **kwargs)
64
 
    
65
 
    def property_changed(self, property=None, value=None):
66
 
        """This is called whenever we get a PropertyChanged signal
67
 
        It updates the changed property in the "properties" dict.
68
 
        """
69
 
        # Update properties dict with new value
70
 
        self.properties[property] = value
71
 
 
72
 
 
73
 
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
74
 
    """A Mandos Client which is visible on the screen.
75
 
    """
76
 
    
77
 
    def __init__(self, server_proxy_object=None, update_hook=None,
78
 
                 delete_hook=None, logger=None, *args, **kwargs):
79
 
        # Called on update
80
 
        self.update_hook = update_hook
81
 
        # Called on delete
82
 
        self.delete_hook = delete_hook
83
 
        # Mandos Server proxy object
84
 
        self.server_proxy_object = server_proxy_object
85
 
        # Logger
86
 
        self.logger = logger
87
 
        
88
 
        # The widget shown normally
89
 
        self._text_widget = urwid.Text(u"")
90
 
        # The widget shown when we have focus
91
 
        self._focus_text_widget = urwid.Text(u"")
92
 
        super(MandosClientWidget, self).__init__(
93
 
            update_hook=update_hook, delete_hook=delete_hook,
94
 
            *args, **kwargs)
95
 
        self.update()
96
 
        self.opened = False
97
 
        self.proxy.connect_to_signal(u"CheckerCompleted",
98
 
                                     self.checker_completed,
99
 
                                     client_interface,
100
 
                                     byte_arrays=True)
101
 
        self.proxy.connect_to_signal(u"CheckerStarted",
102
 
                                     self.checker_started,
103
 
                                     client_interface,
104
 
                                     byte_arrays=True)
105
 
        self.proxy.connect_to_signal(u"GotSecret",
106
 
                                     self.got_secret,
107
 
                                     client_interface,
108
 
                                     byte_arrays=True)
109
 
        self.proxy.connect_to_signal(u"NeedApproval",
110
 
                                     self.need_approval,
111
 
                                     client_interface,
112
 
                                     byte_arrays=True)
113
 
        self.proxy.connect_to_signal(u"Rejected",
114
 
                                     self.rejected,
115
 
                                     client_interface,
116
 
                                     byte_arrays=True)
117
 
    
118
 
    def checker_completed(self, exitstatus, condition, command):
119
 
        if exitstatus == 0:
120
 
            #self.logger(u'Checker for client %s (command "%s")'
121
 
            #            u' was successful'
122
 
            #            % (self.properties[u"name"], command))
123
 
            return
124
 
        if os.WIFEXITED(condition):
125
 
            self.logger(u'Checker for client %s (command "%s")'
126
 
                        u' failed with exit code %s'
127
 
                        % (self.properties[u"name"], command,
128
 
                           os.WEXITSTATUS(condition)))
129
 
            return
130
 
        if os.WIFSIGNALED(condition):
131
 
            self.logger(u'Checker for client %s (command "%s")'
132
 
                        u' was killed by signal %s'
133
 
                        % (self.properties[u"name"], command,
134
 
                           os.WTERMSIG(condition)))
135
 
            return
136
 
        if os.WCOREDUMP(condition):
137
 
            self.logger(u'Checker for client %s (command "%s")'
138
 
                        u' dumped core'
139
 
                        % (self.properties[u"name"], command))
140
 
        self.logger(u'Checker for client %s completed mysteriously')
141
 
    
142
 
    def checker_started(self, command):
143
 
        #self.logger(u'Client %s started checker "%s"'
144
 
        #            % (self.properties[u"name"], unicode(command)))
145
 
        pass
146
 
    
147
 
    def got_secret(self):
148
 
        self.logger(u'Client %s received its secret'
149
 
                    % self.properties[u"name"])
150
 
    
151
 
    def need_approval(self, timeout, default):
152
 
        if not default:
153
 
            message = u'Client %s needs approval within %s seconds'
154
 
        else:
155
 
            message = u'Client %s will get its secret in %s seconds'
156
 
        self.logger(message
157
 
                    % (self.properties[u"name"], timeout/1000))
158
 
    
159
 
    def rejected(self, reason):
160
 
        self.logger(u'Client %s was rejected; reason: %s'
161
 
                    % (self.properties[u"name"], reason))
162
 
    
163
 
    def selectable(self):
164
 
        """Make this a "selectable" widget.
165
 
        This overrides the method from urwid.FlowWidget."""
166
 
        return True
167
 
    
168
 
    def rows(self, (maxcol,), focus=False):
169
 
        """How many rows this widget will occupy might depend on
170
 
        whether we have focus or not.
171
 
        This overrides the method from urwid.FlowWidget"""
172
 
        return self.current_widget(focus).rows((maxcol,), focus=focus)
173
 
    
174
 
    def current_widget(self, focus=False):
175
 
        if focus or self.opened:
176
 
            return self._focus_widget
177
 
        return self._widget
178
 
    
179
 
    def update(self):
180
 
        "Called when what is visible on the screen should be updated."
181
 
        # How to add standout mode to a style
182
 
        with_standout = { u"normal": u"standout",
183
 
                          u"bold": u"bold-standout",
184
 
                          u"underline-blink":
185
 
                              u"underline-blink-standout",
186
 
                          u"bold-underline-blink":
187
 
                              u"bold-underline-blink-standout",
188
 
                          }
189
 
 
190
 
        # Rebuild focus and non-focus widgets using current properties
191
 
 
192
 
        # Base part of a client. Name!
193
 
        self._text = (u'%(name)s: '
194
 
                      % {u"name": self.properties[u"name"]})
195
 
 
196
 
        if self.properties[u"approved_pending"]:
197
 
            if self.properties[u"approved_by_default"]:
198
 
                self._text += u"Connection established to client. (d)eny?"
199
 
            else:
200
 
                self._text += u"Seeks approval to send secret. (a)pprove?"
201
 
        else:
202
 
            self._text += (u'%(enabled)s'
203
 
                           % {u"enabled":
204
 
                               (u"enabled"
205
 
                                if self.properties[u"enabled"]
206
 
                                else u"DISABLED")})
207
 
        if not urwid.supports_unicode():
208
 
            self._text = self._text.encode("ascii", "replace")
209
 
        textlist = [(u"normal", self._text)]
210
 
        self._text_widget.set_text(textlist)
211
 
        self._focus_text_widget.set_text([(with_standout[text[0]],
212
 
                                           text[1])
213
 
                                          if isinstance(text, tuple)
214
 
                                          else text
215
 
                                          for text in textlist])
216
 
        self._widget = self._text_widget
217
 
        self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
218
 
                                            "standout")
219
 
        # Run update hook, if any
220
 
        if self.update_hook is not None:
221
 
            self.update_hook()
222
 
    
223
 
    def delete(self):
224
 
        if self.delete_hook is not None:
225
 
            self.delete_hook(self)
226
 
    
227
 
    def render(self, (maxcol,), focus=False):
228
 
        """Render differently if we have focus.
229
 
        This overrides the method from urwid.FlowWidget"""
230
 
        return self.current_widget(focus).render((maxcol,),
231
 
                                                 focus=focus)
232
 
    
233
 
    def keypress(self, (maxcol,), key):
234
 
        """Handle keys.
235
 
        This overrides the method from urwid.FlowWidget"""
236
 
        if key == u"+":
237
 
            self.proxy.Enable(dbus_interface = client_interface)
238
 
        elif key == u"-":
239
 
            self.proxy.Disable(dbus_interface = client_interface)
240
 
        elif key == u"a":
241
 
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
242
 
                               dbus_interface = client_interface)
243
 
        elif key == u"d":
244
 
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
245
 
                                  dbus_interface = client_interface)
246
 
        elif key == u"r" or key == u"_" or key == u"ctrl k":
247
 
            self.server_proxy_object.RemoveClient(self.proxy
248
 
                                                  .object_path)
249
 
        elif key == u"s":
250
 
            self.proxy.StartChecker(dbus_interface = client_interface)
251
 
        elif key == u"S":
252
 
            self.proxy.StopChecker(dbus_interface = client_interface)
253
 
        elif key == u"C":
254
 
            self.proxy.CheckedOK(dbus_interface = client_interface)
255
 
        # xxx
256
 
#         elif key == u"p" or key == "=":
257
 
#             self.proxy.pause()
258
 
#         elif key == u"u" or key == ":":
259
 
#             self.proxy.unpause()
260
 
#         elif key == u"RET":
261
 
#             self.open()
262
 
#        elif key == u"+":
263
 
#            self.proxy.Approve(True)
264
 
#        elif key == u"-":
265
 
#            self.proxy.Approve(False)
266
 
        else:
267
 
            return key
268
 
    
269
 
    def property_changed(self, property=None, value=None,
270
 
                         *args, **kwargs):
271
 
        """Call self.update() if old value is not new value.
272
 
        This overrides the method from MandosClientPropertyCache"""
273
 
        property_name = unicode(property)
274
 
        old_value = self.properties.get(property_name)
275
 
        super(MandosClientWidget, self).property_changed(
276
 
            property=property, value=value, *args, **kwargs)
277
 
        if self.properties.get(property_name) != old_value:
278
 
            self.update()
279
 
 
280
 
 
281
 
class ConstrainedListBox(urwid.ListBox):
282
 
    """Like a normal urwid.ListBox, but will consume all "up" or
283
 
    "down" key presses, thus not allowing any containing widgets to
284
 
    use them as an excuse to shift focus away from this widget.
285
 
    """
286
 
    def keypress(self, (maxcol, maxrow), key):
287
 
        ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
288
 
        if ret in (u"up", u"down"):
289
 
            return
290
 
        return ret
291
 
 
292
 
 
293
 
class UserInterface(object):
294
 
    """This is the entire user interface - the whole screen
295
 
    with boxes, lists of client widgets, etc.
296
 
    """
297
 
    def __init__(self, max_log_length=1000):
298
 
        DBusGMainLoop(set_as_default=True)
299
 
        
300
 
        self.screen = urwid.curses_display.Screen()
301
 
        
302
 
        self.screen.register_palette((
303
 
                (u"normal",
304
 
                 u"default", u"default", None),
305
 
                (u"bold",
306
 
                 u"default", u"default", u"bold"),
307
 
                (u"underline-blink",
308
 
                 u"default", u"default", u"underline"),
309
 
                (u"standout",
310
 
                 u"default", u"default", u"standout"),
311
 
                (u"bold-underline-blink",
312
 
                 u"default", u"default", (u"bold", u"underline")),
313
 
                (u"bold-standout",
314
 
                 u"default", u"default", (u"bold", u"standout")),
315
 
                (u"underline-blink-standout",
316
 
                 u"default", u"default", (u"underline", u"standout")),
317
 
                (u"bold-underline-blink-standout",
318
 
                 u"default", u"default", (u"bold", u"underline",
319
 
                                          u"standout")),
320
 
                ))
321
 
        
322
 
        if urwid.supports_unicode():
323
 
            self.divider = u"─" # \u2500
324
 
            #self.divider = u"━" # \u2501
325
 
        else:
326
 
            #self.divider = u"-" # \u002d
327
 
            self.divider = u"_" # \u005f
328
 
        
329
 
        self.screen.start()
330
 
        
331
 
        self.size = self.screen.get_cols_rows()
332
 
        
333
 
        self.clients = urwid.SimpleListWalker([])
334
 
        self.clients_dict = {}
335
 
        
336
 
        # We will add Text widgets to this list
337
 
        self.log = []
338
 
        self.max_log_length = max_log_length
339
 
        
340
 
        # We keep a reference to the log widget so we can remove it
341
 
        # from the ListWalker without it getting destroyed
342
 
        self.logbox = ConstrainedListBox(self.log)
343
 
        
344
 
        # This keeps track of whether self.uilist currently has
345
 
        # self.logbox in it or not
346
 
        self.log_visible = True
347
 
        self.log_wrap = u"any"
348
 
        
349
 
        self.rebuild()
350
 
        self.log_message_raw((u"bold",
351
 
                              u"Mandos Monitor version " + version))
352
 
        self.log_message_raw((u"bold",
353
 
                              u"q: Quit  ?: Help"))
354
 
        
355
 
        self.busname = domain + '.Mandos'
356
 
        self.main_loop = gobject.MainLoop()
357
 
        self.bus = dbus.SystemBus()
358
 
        mandos_dbus_objc = self.bus.get_object(
359
 
            self.busname, u"/", follow_name_owner_changes=True)
360
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
361
 
                                          dbus_interface
362
 
                                          = server_interface)
363
 
        try:
364
 
            mandos_clients = (self.mandos_serv
365
 
                              .GetAllClientsWithProperties())
366
 
        except dbus.exceptions.DBusException:
367
 
            mandos_clients = dbus.Dictionary()
368
 
        
369
 
        (self.mandos_serv
370
 
         .connect_to_signal(u"ClientRemoved",
371
 
                            self.find_and_remove_client,
372
 
                            dbus_interface=server_interface,
373
 
                            byte_arrays=True))
374
 
        (self.mandos_serv
375
 
         .connect_to_signal(u"ClientAdded",
376
 
                            self.add_new_client,
377
 
                            dbus_interface=server_interface,
378
 
                            byte_arrays=True))
379
 
        (self.mandos_serv
380
 
         .connect_to_signal(u"ClientNotFound",
381
 
                            self.client_not_found,
382
 
                            dbus_interface=server_interface,
383
 
                            byte_arrays=True))
384
 
        for path, client in mandos_clients.iteritems():
385
 
            client_proxy_object = self.bus.get_object(self.busname,
386
 
                                                      path)
387
 
            self.add_client(MandosClientWidget(server_proxy_object
388
 
                                               =self.mandos_serv,
389
 
                                               proxy_object
390
 
                                               =client_proxy_object,
391
 
                                               properties=client,
392
 
                                               update_hook
393
 
                                               =self.refresh,
394
 
                                               delete_hook
395
 
                                               =self.remove_client,
396
 
                                               logger
397
 
                                               =self.log_message),
398
 
                            path=path)
399
 
    
400
 
    def client_not_found(self, fingerprint, address):
401
 
        self.log_message((u"Client with address %s and fingerprint %s"
402
 
                          u" could not be found" % (address,
403
 
                                                    fingerprint)))
404
 
    
405
 
    def rebuild(self):
406
 
        """This rebuilds the User Interface.
407
 
        Call this when the widget layout needs to change"""
408
 
        self.uilist = []
409
 
        #self.uilist.append(urwid.ListBox(self.clients))
410
 
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
411
 
                                       #header=urwid.Divider(),
412
 
                                       header=None,
413
 
                                       footer=urwid.Divider(div_char=self.divider)))
414
 
        if self.log_visible:
415
 
            self.uilist.append(self.logbox)
416
 
            pass
417
 
        self.topwidget = urwid.Pile(self.uilist)
418
 
    
419
 
    def log_message(self, message):
420
 
        timestamp = datetime.datetime.now().isoformat()
421
 
        self.log_message_raw(timestamp + u": " + message)
422
 
    
423
 
    def log_message_raw(self, markup):
424
 
        """Add a log message to the log buffer."""
425
 
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
426
 
        if (self.max_log_length
427
 
            and len(self.log) > self.max_log_length):
428
 
            del self.log[0:len(self.log)-self.max_log_length-1]
429
 
        self.logbox.set_focus(len(self.logbox.body.contents),
430
 
                              coming_from=u"above")
431
 
        self.refresh()
432
 
    
433
 
    def toggle_log_display(self):
434
 
        """Toggle visibility of the log buffer."""
435
 
        self.log_visible = not self.log_visible
436
 
        self.rebuild()
437
 
        self.log_message(u"Log visibility changed to: "
438
 
                         + unicode(self.log_visible))
439
 
    
440
 
    def change_log_display(self):
441
 
        """Change type of log display.
442
 
        Currently, this toggles wrapping of text lines."""
443
 
        if self.log_wrap == u"clip":
444
 
            self.log_wrap = u"any"
445
 
        else:
446
 
            self.log_wrap = u"clip"
447
 
        for textwidget in self.log:
448
 
            textwidget.set_wrap_mode(self.log_wrap)
449
 
        self.log_message(u"Wrap mode: " + self.log_wrap)
450
 
    
451
 
    def find_and_remove_client(self, path, name):
452
 
        """Find an client from its object path and remove it.
453
 
        
454
 
        This is connected to the ClientRemoved signal from the
455
 
        Mandos server object."""
456
 
        try:
457
 
            client = self.clients_dict[path]
458
 
        except KeyError:
459
 
            # not found?
460
 
            return
461
 
        self.remove_client(client, path)
462
 
    
463
 
    def add_new_client(self, path):
464
 
        client_proxy_object = self.bus.get_object(self.busname, path)
465
 
        self.add_client(MandosClientWidget(server_proxy_object
466
 
                                           =self.mandos_serv,
467
 
                                           proxy_object
468
 
                                           =client_proxy_object,
469
 
                                           update_hook
470
 
                                           =self.refresh,
471
 
                                           delete_hook
472
 
                                           =self.remove_client,
473
 
                                           logger
474
 
                                           =self.log_message),
475
 
                        path=path)
476
 
    
477
 
    def add_client(self, client, path=None):
478
 
        self.clients.append(client)
479
 
        if path is None:
480
 
            path = client.proxy.object_path
481
 
        self.clients_dict[path] = client
482
 
        self.clients.sort(None, lambda c: c.properties[u"name"])
483
 
        self.refresh()
484
 
    
485
 
    def remove_client(self, client, path=None):
486
 
        self.clients.remove(client)
487
 
        if path is None:
488
 
            path = client.proxy.object_path
489
 
        del self.clients_dict[path]
490
 
        if not self.clients_dict:
491
 
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
492
 
            # is completely emptied, we need to recreate it.
493
 
            self.clients = urwid.SimpleListWalker([])
494
 
            self.rebuild()
495
 
        self.refresh()
496
 
    
497
 
    def refresh(self):
498
 
        """Redraw the screen"""
499
 
        canvas = self.topwidget.render(self.size, focus=True)
500
 
        self.screen.draw_screen(self.size, canvas)
501
 
    
502
 
    def run(self):
503
 
        """Start the main loop and exit when it's done."""
504
 
        self.refresh()
505
 
        self._input_callback_tag = (gobject.io_add_watch
506
 
                                    (sys.stdin.fileno(),
507
 
                                     gobject.IO_IN,
508
 
                                     self.process_input))
509
 
        self.main_loop.run()
510
 
        # Main loop has finished, we should close everything now
511
 
        gobject.source_remove(self._input_callback_tag)
512
 
        self.screen.stop()
513
 
    
514
 
    def stop(self):
515
 
        self.main_loop.quit()
516
 
    
517
 
    def process_input(self, source, condition):
518
 
        keys = self.screen.get_input()
519
 
        translations = { u"ctrl n": u"down",      # Emacs
520
 
                         u"ctrl p": u"up",        # Emacs
521
 
                         u"ctrl v": u"page down", # Emacs
522
 
                         u"meta v": u"page up",   # Emacs
523
 
                         u" ": u"page down",      # less
524
 
                         u"f": u"page down",      # less
525
 
                         u"b": u"page up",        # less
526
 
                         u"j": u"down",           # vi
527
 
                         u"k": u"up",             # vi
528
 
                         }
529
 
        for key in keys:
530
 
            try:
531
 
                key = translations[key]
532
 
            except KeyError:    # :-)
533
 
                pass
534
 
            
535
 
            if key == u"q" or key == u"Q":
536
 
                self.stop()
537
 
                break
538
 
            elif key == u"window resize":
539
 
                self.size = self.screen.get_cols_rows()
540
 
                self.refresh()
541
 
            elif key == u"\f":  # Ctrl-L
542
 
                self.refresh()
543
 
            elif key == u"l" or key == u"D":
544
 
                self.toggle_log_display()
545
 
                self.refresh()
546
 
            elif key == u"w" or key == u"i":
547
 
                self.change_log_display()
548
 
                self.refresh()
549
 
            elif key == u"?" or key == u"f1" or key == u"esc":
550
 
                if not self.log_visible:
551
 
                    self.log_visible = True
552
 
                    self.rebuild()
553
 
                self.log_message_raw((u"bold",
554
 
                                      u"  ".
555
 
                                      join((u"q: Quit",
556
 
                                            u"?: Help",
557
 
                                            u"l: Log window toggle",
558
 
                                            u"TAB: Switch window",
559
 
                                            u"w: Wrap (log)"))))
560
 
                self.log_message_raw((u"bold",
561
 
                                      u"  "
562
 
                                      .join((u"Clients:",
563
 
                                             u"e: Enable",
564
 
                                             u"d: Disable",
565
 
                                             u"r: Remove",
566
 
                                             u"s: Start new checker",
567
 
                                             u"S: Stop checker",
568
 
                                             u"C: Checker OK",
569
 
                                             u"A: Approve",
570
 
                                             u"D: Deny"))))
571
 
                self.refresh()
572
 
            elif key == u"tab":
573
 
                if self.topwidget.get_focus() is self.logbox:
574
 
                    self.topwidget.set_focus(0)
575
 
                else:
576
 
                    self.topwidget.set_focus(self.logbox)
577
 
                self.refresh()
578
 
            #elif (key == u"end" or key == u"meta >" or key == u"G"
579
 
            #      or key == u">"):
580
 
            #    pass            # xxx end-of-buffer
581
 
            #elif (key == u"home" or key == u"meta <" or key == u"g"
582
 
            #      or key == u"<"):
583
 
            #    pass            # xxx beginning-of-buffer
584
 
            #elif key == u"ctrl e" or key == u"$":
585
 
            #    pass            # xxx move-end-of-line
586
 
            #elif key == u"ctrl a" or key == u"^":
587
 
            #    pass            # xxx move-beginning-of-line
588
 
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
589
 
            #    pass            # xxx left
590
 
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
591
 
            #    pass            # xxx right
592
 
            #elif key == u"a":
593
 
            #    pass            # scroll up log
594
 
            #elif key == u"z":
595
 
            #    pass            # scroll down log
596
 
            elif self.topwidget.selectable():
597
 
                self.topwidget.keypress(self.size, key)
598
 
                self.refresh()
599
 
        return True
600
 
 
601
 
ui = UserInterface()
602
 
try:
603
 
    ui.run()
604
 
except Exception, e:
605
 
    ui.log_message(unicode(e))
606
 
    ui.screen.stop()
607
 
    raise