/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos-monitor

  • Committer: Björn Påhlsson
  • Date: 2010-09-07 16:48:58 UTC
  • mto: (237.7.1 mandos)
  • mto: This revision was merged to the branch mainline in revision 270.
  • Revision ID: belorn@fukt.bsnet.se-20100907164858-tcg8hkxdj41zizac
mandos server: Added debuglevel that adjust at what level information
               should be reported.
plugin-runner, askpass-fifo, password-prompt, splasy, usplash:
               Using error instead of perror

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
 
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"+: Enable",
 
564
                                             u"-: 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