/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

* mandos (Client.stop_checker): Use new Popen.terminate() method.

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
# Mandos Monitor - Control and monitor the Mandos server
 
5
# 
 
6
# Copyright © 2009-2012 Teddy Hogeborn
 
7
# Copyright © 2009-2012 Björn Påhlsson
 
8
# 
 
9
# This program is free software: you can redistribute it and/or modify
 
10
# it under the terms of the GNU General Public License as published by
 
11
# the Free Software Foundation, either version 3 of the License, or
 
12
# (at your option) any later version.
 
13
#
 
14
#     This program is distributed in the hope that it will be useful,
 
15
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
#     GNU General Public License for more details.
 
18
# 
 
19
# You should have received a copy of the GNU General Public License
 
20
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
21
# 
 
22
# Contact the authors at <mandos@recompile.se>.
 
23
# 
 
24
 
 
25
from __future__ import (division, absolute_import, print_function,
 
26
                        unicode_literals)
 
27
 
 
28
import sys
 
29
import os
 
30
import signal
 
31
 
 
32
import datetime
 
33
 
 
34
import urwid.curses_display
 
35
import urwid
 
36
 
 
37
from dbus.mainloop.glib import DBusGMainLoop
 
38
import gobject
 
39
 
 
40
import dbus
 
41
 
 
42
import UserList
 
43
 
 
44
import locale
 
45
 
 
46
locale.setlocale(locale.LC_ALL, '')
 
47
 
 
48
import logging
 
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
 
50
 
 
51
# Some useful constants
 
52
domain = 'se.recompile'
 
53
server_interface = domain + '.Mandos'
 
54
client_interface = domain + '.Mandos.Client'
 
55
version = "1.5.3"
 
56
 
 
57
# Always run in monochrome mode
 
58
urwid.curses_display.curses.has_colors = lambda : False
 
59
 
 
60
# Urwid doesn't support blinking, but we want it.  Since we have no
 
61
# use for underline on its own, we make underline also always blink.
 
62
urwid.curses_display.curses.A_UNDERLINE |= (
 
63
    urwid.curses_display.curses.A_BLINK)
 
64
 
 
65
def isoformat_to_datetime(iso):
 
66
    "Parse an ISO 8601 date string to a datetime.datetime()"
 
67
    if not iso:
 
68
        return None
 
69
    d, t = iso.split("T", 1)
 
70
    year, month, day = d.split("-", 2)
 
71
    hour, minute, second = t.split(":", 2)
 
72
    second, fraction = divmod(float(second), 1)
 
73
    return datetime.datetime(int(year),
 
74
                             int(month),
 
75
                             int(day),
 
76
                             int(hour),
 
77
                             int(minute),
 
78
                             int(second),           # Whole seconds
 
79
                             int(fraction*1000000)) # Microseconds
 
80
 
 
81
class MandosClientPropertyCache(object):
 
82
    """This wraps a Mandos Client D-Bus proxy object, caches the
 
83
    properties and calls a hook function when any of them are
 
84
    changed.
 
85
    """
 
86
    def __init__(self, proxy_object=None, *args, **kwargs):
 
87
        self.proxy = proxy_object # Mandos Client proxy object
 
88
        
 
89
        self.properties = dict()
 
90
        self.property_changed_match = (
 
91
            self.proxy.connect_to_signal("PropertyChanged",
 
92
                                         self.property_changed,
 
93
                                         client_interface,
 
94
                                         byte_arrays=True))
 
95
        
 
96
        self.properties.update(
 
97
            self.proxy.GetAll(client_interface,
 
98
                              dbus_interface = dbus.PROPERTIES_IFACE))
 
99
 
 
100
        #XXX This breaks good super behaviour
 
101
#        super(MandosClientPropertyCache, self).__init__(
 
102
#            *args, **kwargs)
 
103
    
 
104
    def property_changed(self, property=None, value=None):
 
105
        """This is called whenever we get a PropertyChanged signal
 
106
        It updates the changed property in the "properties" dict.
 
107
        """
 
108
        # Update properties dict with new value
 
109
        self.properties[property] = value
 
110
    
 
111
    def delete(self, *args, **kwargs):
 
112
        self.property_changed_match.remove()
 
113
        super(MandosClientPropertyCache, self).__init__(
 
114
            *args, **kwargs)
 
115
 
 
116
 
 
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
 
118
    """A Mandos Client which is visible on the screen.
 
119
    """
 
120
    
 
121
    def __init__(self, server_proxy_object=None, update_hook=None,
 
122
                 delete_hook=None, logger=None, *args, **kwargs):
 
123
        # Called on update
 
124
        self.update_hook = update_hook
 
125
        # Called on delete
 
126
        self.delete_hook = delete_hook
 
127
        # Mandos Server proxy object
 
128
        self.server_proxy_object = server_proxy_object
 
129
        # Logger
 
130
        self.logger = logger
 
131
        
 
132
        self._update_timer_callback_tag = None
 
133
        self._update_timer_callback_lock = 0
 
134
        
 
135
        # The widget shown normally
 
136
        self._text_widget = urwid.Text("")
 
137
        # The widget shown when we have focus
 
138
        self._focus_text_widget = urwid.Text("")
 
139
        super(MandosClientWidget, self).__init__(
 
140
            update_hook=update_hook, delete_hook=delete_hook,
 
141
            *args, **kwargs)
 
142
        self.update()
 
143
        self.opened = False
 
144
        
 
145
        last_checked_ok = isoformat_to_datetime(self.properties
 
146
                                                ["LastCheckedOK"])
 
147
        
 
148
        if self.properties ["LastCheckerStatus"] != 0:
 
149
            self.using_timer(True)
 
150
        
 
151
        if self.need_approval:
 
152
            self.using_timer(True)
 
153
        
 
154
        self.match_objects = (
 
155
            self.proxy.connect_to_signal("CheckerCompleted",
 
156
                                         self.checker_completed,
 
157
                                         client_interface,
 
158
                                         byte_arrays=True),
 
159
            self.proxy.connect_to_signal("CheckerStarted",
 
160
                                         self.checker_started,
 
161
                                         client_interface,
 
162
                                         byte_arrays=True),
 
163
            self.proxy.connect_to_signal("GotSecret",
 
164
                                         self.got_secret,
 
165
                                         client_interface,
 
166
                                         byte_arrays=True),
 
167
            self.proxy.connect_to_signal("NeedApproval",
 
168
                                         self.need_approval,
 
169
                                         client_interface,
 
170
                                         byte_arrays=True),
 
171
            self.proxy.connect_to_signal("Rejected",
 
172
                                         self.rejected,
 
173
                                         client_interface,
 
174
                                         byte_arrays=True))
 
175
        #self.logger('Created client %s' % (self.properties["Name"]))
 
176
    
 
177
    def property_changed(self, property=None, value=None):
 
178
        super(self, MandosClientWidget).property_changed(property,
 
179
                                                         value)
 
180
        if property == "ApprovalPending":
 
181
            using_timer(bool(value))
 
182
        if property == "LastCheckerStatus":
 
183
            using_timer(value != 0)
 
184
            #self.logger('Checker for client %s (command "%s")'
 
185
            #            ' was successful'
 
186
            #            % (self.properties["Name"], command))
 
187
    
 
188
    def using_timer(self, flag):
 
189
        """Call this method with True or False when timer should be
 
190
        activated or deactivated.
 
191
        """
 
192
        old = self._update_timer_callback_lock
 
193
        if flag:
 
194
            self._update_timer_callback_lock += 1
 
195
        else:
 
196
            self._update_timer_callback_lock -= 1
 
197
        if old == 0 and self._update_timer_callback_lock:
 
198
            # Will update the shown timer value every second
 
199
            self._update_timer_callback_tag = (gobject.timeout_add
 
200
                                               (1000,
 
201
                                                self.update_timer))
 
202
        elif old and self._update_timer_callback_lock == 0:
 
203
            gobject.source_remove(self._update_timer_callback_tag)
 
204
            self._update_timer_callback_tag = None
 
205
    
 
206
    def checker_completed(self, exitstatus, condition, command):
 
207
        if exitstatus == 0:
 
208
            self.update()
 
209
            return
 
210
        # Checker failed
 
211
        if os.WIFEXITED(condition):
 
212
            self.logger('Checker for client %s (command "%s")'
 
213
                        ' failed with exit code %s'
 
214
                        % (self.properties["Name"], command,
 
215
                           os.WEXITSTATUS(condition)))
 
216
        elif os.WIFSIGNALED(condition):
 
217
            self.logger('Checker for client %s (command "%s")'
 
218
                        ' was killed by signal %s'
 
219
                        % (self.properties["Name"], command,
 
220
                           os.WTERMSIG(condition)))
 
221
        elif os.WCOREDUMP(condition):
 
222
            self.logger('Checker for client %s (command "%s")'
 
223
                        ' dumped core'
 
224
                        % (self.properties["Name"], command))
 
225
        else:
 
226
            self.logger('Checker for client %s completed'
 
227
                        ' mysteriously')
 
228
        self.update()
 
229
    
 
230
    def checker_started(self, command):
 
231
        """Server signals that a checker started. This could be useful
 
232
           to log in the future. """
 
233
        #self.logger('Client %s started checker "%s"'
 
234
        #            % (self.properties["Name"], unicode(command)))
 
235
        pass
 
236
    
 
237
    def got_secret(self):
 
238
        self.logger('Client %s received its secret'
 
239
                    % self.properties["Name"])
 
240
    
 
241
    def need_approval(self, timeout, default):
 
242
        if not default:
 
243
            message = 'Client %s needs approval within %s seconds'
 
244
        else:
 
245
            message = 'Client %s will get its secret in %s seconds'
 
246
        self.logger(message
 
247
                    % (self.properties["Name"], timeout/1000))
 
248
        self.using_timer(True)
 
249
    
 
250
    def rejected(self, reason):
 
251
        self.logger('Client %s was rejected; reason: %s'
 
252
                    % (self.properties["Name"], reason))
 
253
    
 
254
    def selectable(self):
 
255
        """Make this a "selectable" widget.
 
256
        This overrides the method from urwid.FlowWidget."""
 
257
        return True
 
258
    
 
259
    def rows(self, maxcolrow, focus=False):
 
260
        """How many rows this widget will occupy might depend on
 
261
        whether we have focus or not.
 
262
        This overrides the method from urwid.FlowWidget"""
 
263
        return self.current_widget(focus).rows(maxcolrow, focus=focus)
 
264
    
 
265
    def current_widget(self, focus=False):
 
266
        if focus or self.opened:
 
267
            return self._focus_widget
 
268
        return self._widget
 
269
    
 
270
    def update(self):
 
271
        "Called when what is visible on the screen should be updated."
 
272
        # How to add standout mode to a style
 
273
        with_standout = { "normal": "standout",
 
274
                          "bold": "bold-standout",
 
275
                          "underline-blink":
 
276
                              "underline-blink-standout",
 
277
                          "bold-underline-blink":
 
278
                              "bold-underline-blink-standout",
 
279
                          }
 
280
 
 
281
        # Rebuild focus and non-focus widgets using current properties
 
282
 
 
283
        # Base part of a client. Name!
 
284
        base = ('%(name)s: '
 
285
                      % {"name": self.properties["Name"]})
 
286
        if not self.properties["Enabled"]:
 
287
            message = "DISABLED"
 
288
        elif self.properties["ApprovalPending"]:
 
289
            timeout = datetime.timedelta(milliseconds
 
290
                                         = self.properties
 
291
                                         ["ApprovalDelay"])
 
292
            last_approval_request = isoformat_to_datetime(
 
293
                self.properties["LastApprovalRequest"])
 
294
            if last_approval_request is not None:
 
295
                timer = timeout - (datetime.datetime.utcnow()
 
296
                                   - last_approval_request)
 
297
            else:
 
298
                timer = datetime.timedelta()
 
299
            if self.properties["ApprovedByDefault"]:
 
300
                message = "Approval in %s. (d)eny?"
 
301
            else:
 
302
                message = "Denial in %s. (a)pprove?"
 
303
            message = message % unicode(timer).rsplit(".", 1)[0]
 
304
        elif self.properties["LastCheckerStatus"] != 0:
 
305
            # When checker has failed, print a timer until client expires
 
306
            expires = self.properties["Expires"]
 
307
            if expires == "":
 
308
                timer = datetime.timedelta(0)
 
309
            else:
 
310
                expires = datetime.datetime.strptime(expires,
 
311
                                                     '%Y-%m-%dT%H:%M:%S.%f')
 
312
                timer = expires - datetime.datetime.utcnow()
 
313
            message = ('A checker has failed! Time until client'
 
314
                       ' gets disabled: %s'
 
315
                           % unicode(timer).rsplit(".", 1)[0])
 
316
        else:
 
317
            message = "enabled"
 
318
        self._text = "%s%s" % (base, message)
 
319
            
 
320
        if not urwid.supports_unicode():
 
321
            self._text = self._text.encode("ascii", "replace")
 
322
        textlist = [("normal", self._text)]
 
323
        self._text_widget.set_text(textlist)
 
324
        self._focus_text_widget.set_text([(with_standout[text[0]],
 
325
                                           text[1])
 
326
                                          if isinstance(text, tuple)
 
327
                                          else text
 
328
                                          for text in textlist])
 
329
        self._widget = self._text_widget
 
330
        self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
 
331
                                            "standout")
 
332
        # Run update hook, if any
 
333
        if self.update_hook is not None:
 
334
            self.update_hook()
 
335
    
 
336
    def update_timer(self):
 
337
        """called by gobject. Will indefinitely loop until
 
338
        gobject.source_remove() on tag is called"""
 
339
        self.update()
 
340
        return True             # Keep calling this
 
341
    
 
342
    def delete(self, *args, **kwargs):
 
343
        if self._update_timer_callback_tag is not None:
 
344
            gobject.source_remove(self._update_timer_callback_tag)
 
345
            self._update_timer_callback_tag = None
 
346
        for match in self.match_objects:
 
347
            match.remove()
 
348
        self.match_objects = ()
 
349
        if self.delete_hook is not None:
 
350
            self.delete_hook(self)
 
351
        return super(MandosClientWidget, self).delete(*args, **kwargs)
 
352
    
 
353
    def render(self, maxcolrow, focus=False):
 
354
        """Render differently if we have focus.
 
355
        This overrides the method from urwid.FlowWidget"""
 
356
        return self.current_widget(focus).render(maxcolrow,
 
357
                                                 focus=focus)
 
358
    
 
359
    def keypress(self, maxcolrow, key):
 
360
        """Handle keys.
 
361
        This overrides the method from urwid.FlowWidget"""
 
362
        if key == "+":
 
363
            self.proxy.Enable(dbus_interface = client_interface,
 
364
                              ignore_reply=True)
 
365
        elif key == "-":
 
366
            self.proxy.Disable(dbus_interface = client_interface,
 
367
                               ignore_reply=True)
 
368
        elif key == "a":
 
369
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
 
370
                               dbus_interface = client_interface,
 
371
                               ignore_reply=True)
 
372
        elif key == "d":
 
373
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
 
374
                                  dbus_interface = client_interface,
 
375
                               ignore_reply=True)
 
376
        elif key == "R" or key == "_" or key == "ctrl k":
 
377
            self.server_proxy_object.RemoveClient(self.proxy
 
378
                                                  .object_path,
 
379
                                                  ignore_reply=True)
 
380
        elif key == "s":
 
381
            self.proxy.StartChecker(dbus_interface = client_interface,
 
382
                                    ignore_reply=True)
 
383
        elif key == "S":
 
384
            self.proxy.StopChecker(dbus_interface = client_interface,
 
385
                                   ignore_reply=True)
 
386
        elif key == "C":
 
387
            self.proxy.CheckedOK(dbus_interface = client_interface,
 
388
                                 ignore_reply=True)
 
389
        # xxx
 
390
#         elif key == "p" or key == "=":
 
391
#             self.proxy.pause()
 
392
#         elif key == "u" or key == ":":
 
393
#             self.proxy.unpause()
 
394
#         elif key == "RET":
 
395
#             self.open()
 
396
        else:
 
397
            return key
 
398
    
 
399
    def property_changed(self, property=None, value=None,
 
400
                         *args, **kwargs):
 
401
        """Call self.update() if old value is not new value.
 
402
        This overrides the method from MandosClientPropertyCache"""
 
403
        property_name = unicode(property)
 
404
        old_value = self.properties.get(property_name)
 
405
        super(MandosClientWidget, self).property_changed(
 
406
            property=property, value=value, *args, **kwargs)
 
407
        if self.properties.get(property_name) != old_value:
 
408
            self.update()
 
409
 
 
410
 
 
411
class ConstrainedListBox(urwid.ListBox):
 
412
    """Like a normal urwid.ListBox, but will consume all "up" or
 
413
    "down" key presses, thus not allowing any containing widgets to
 
414
    use them as an excuse to shift focus away from this widget.
 
415
    """
 
416
    def keypress(self, maxcolrow, key):
 
417
        ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
 
418
        if ret in ("up", "down"):
 
419
            return
 
420
        return ret
 
421
 
 
422
 
 
423
class UserInterface(object):
 
424
    """This is the entire user interface - the whole screen
 
425
    with boxes, lists of client widgets, etc.
 
426
    """
 
427
    def __init__(self, max_log_length=1000):
 
428
        DBusGMainLoop(set_as_default=True)
 
429
        
 
430
        self.screen = urwid.curses_display.Screen()
 
431
        
 
432
        self.screen.register_palette((
 
433
                ("normal",
 
434
                 "default", "default", None),
 
435
                ("bold",
 
436
                 "default", "default", "bold"),
 
437
                ("underline-blink",
 
438
                 "default", "default", "underline"),
 
439
                ("standout",
 
440
                 "default", "default", "standout"),
 
441
                ("bold-underline-blink",
 
442
                 "default", "default", ("bold", "underline")),
 
443
                ("bold-standout",
 
444
                 "default", "default", ("bold", "standout")),
 
445
                ("underline-blink-standout",
 
446
                 "default", "default", ("underline", "standout")),
 
447
                ("bold-underline-blink-standout",
 
448
                 "default", "default", ("bold", "underline",
 
449
                                          "standout")),
 
450
                ))
 
451
        
 
452
        if urwid.supports_unicode():
 
453
            self.divider = "─" # \u2500
 
454
            #self.divider = "━" # \u2501
 
455
        else:
 
456
            #self.divider = "-" # \u002d
 
457
            self.divider = "_" # \u005f
 
458
        
 
459
        self.screen.start()
 
460
        
 
461
        self.size = self.screen.get_cols_rows()
 
462
        
 
463
        self.clients = urwid.SimpleListWalker([])
 
464
        self.clients_dict = {}
 
465
        
 
466
        # We will add Text widgets to this list
 
467
        self.log = []
 
468
        self.max_log_length = max_log_length
 
469
        
 
470
        # We keep a reference to the log widget so we can remove it
 
471
        # from the ListWalker without it getting destroyed
 
472
        self.logbox = ConstrainedListBox(self.log)
 
473
        
 
474
        # This keeps track of whether self.uilist currently has
 
475
        # self.logbox in it or not
 
476
        self.log_visible = True
 
477
        self.log_wrap = "any"
 
478
        
 
479
        self.rebuild()
 
480
        self.log_message_raw(("bold",
 
481
                              "Mandos Monitor version " + version))
 
482
        self.log_message_raw(("bold",
 
483
                              "q: Quit  ?: Help"))
 
484
        
 
485
        self.busname = domain + '.Mandos'
 
486
        self.main_loop = gobject.MainLoop()
 
487
    
 
488
    def client_not_found(self, fingerprint, address):
 
489
        self.log_message(("Client with address %s and fingerprint %s"
 
490
                          " could not be found" % (address,
 
491
                                                    fingerprint)))
 
492
    
 
493
    def rebuild(self):
 
494
        """This rebuilds the User Interface.
 
495
        Call this when the widget layout needs to change"""
 
496
        self.uilist = []
 
497
        #self.uilist.append(urwid.ListBox(self.clients))
 
498
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.
 
499
                                                          clients),
 
500
                                       #header=urwid.Divider(),
 
501
                                       header=None,
 
502
                                       footer=
 
503
                                       urwid.Divider(div_char=
 
504
                                                     self.divider)))
 
505
        if self.log_visible:
 
506
            self.uilist.append(self.logbox)
 
507
        self.topwidget = urwid.Pile(self.uilist)
 
508
    
 
509
    def log_message(self, message):
 
510
        timestamp = datetime.datetime.now().isoformat()
 
511
        self.log_message_raw(timestamp + ": " + message)
 
512
    
 
513
    def log_message_raw(self, markup):
 
514
        """Add a log message to the log buffer."""
 
515
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
 
516
        if (self.max_log_length
 
517
            and len(self.log) > self.max_log_length):
 
518
            del self.log[0:len(self.log)-self.max_log_length-1]
 
519
        self.logbox.set_focus(len(self.logbox.body.contents),
 
520
                              coming_from="above")
 
521
        self.refresh()
 
522
    
 
523
    def toggle_log_display(self):
 
524
        """Toggle visibility of the log buffer."""
 
525
        self.log_visible = not self.log_visible
 
526
        self.rebuild()
 
527
        #self.log_message("Log visibility changed to: "
 
528
        #                 + unicode(self.log_visible))
 
529
    
 
530
    def change_log_display(self):
 
531
        """Change type of log display.
 
532
        Currently, this toggles wrapping of text lines."""
 
533
        if self.log_wrap == "clip":
 
534
            self.log_wrap = "any"
 
535
        else:
 
536
            self.log_wrap = "clip"
 
537
        for textwidget in self.log:
 
538
            textwidget.set_wrap_mode(self.log_wrap)
 
539
        #self.log_message("Wrap mode: " + self.log_wrap)
 
540
    
 
541
    def find_and_remove_client(self, path, name):
 
542
        """Find a client by its object path and remove it.
 
543
        
 
544
        This is connected to the ClientRemoved signal from the
 
545
        Mandos server object."""
 
546
        try:
 
547
            client = self.clients_dict[path]
 
548
        except KeyError:
 
549
            # not found?
 
550
            self.log_message("Unknown client %r (%r) removed", name,
 
551
                             path)
 
552
            return
 
553
        client.delete()
 
554
    
 
555
    def add_new_client(self, path):
 
556
        client_proxy_object = self.bus.get_object(self.busname, path)
 
557
        self.add_client(MandosClientWidget(server_proxy_object
 
558
                                           =self.mandos_serv,
 
559
                                           proxy_object
 
560
                                           =client_proxy_object,
 
561
                                           update_hook
 
562
                                           =self.refresh,
 
563
                                           delete_hook
 
564
                                           =self.remove_client,
 
565
                                           logger
 
566
                                           =self.log_message),
 
567
                        path=path)
 
568
    
 
569
    def add_client(self, client, path=None):
 
570
        self.clients.append(client)
 
571
        if path is None:
 
572
            path = client.proxy.object_path
 
573
        self.clients_dict[path] = client
 
574
        self.clients.sort(None, lambda c: c.properties["Name"])
 
575
        self.refresh()
 
576
    
 
577
    def remove_client(self, client, path=None):
 
578
        self.clients.remove(client)
 
579
        if path is None:
 
580
            path = client.proxy.object_path
 
581
        del self.clients_dict[path]
 
582
        if not self.clients_dict:
 
583
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
 
584
            # is completely emptied, we need to recreate it.
 
585
            self.clients = urwid.SimpleListWalker([])
 
586
            self.rebuild()
 
587
        self.refresh()
 
588
    
 
589
    def refresh(self):
 
590
        """Redraw the screen"""
 
591
        canvas = self.topwidget.render(self.size, focus=True)
 
592
        self.screen.draw_screen(self.size, canvas)
 
593
    
 
594
    def run(self):
 
595
        """Start the main loop and exit when it's done."""
 
596
        self.bus = dbus.SystemBus()
 
597
        mandos_dbus_objc = self.bus.get_object(
 
598
            self.busname, "/", follow_name_owner_changes=True)
 
599
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
600
                                          dbus_interface
 
601
                                          = server_interface)
 
602
        try:
 
603
            mandos_clients = (self.mandos_serv
 
604
                              .GetAllClientsWithProperties())
 
605
        except dbus.exceptions.DBusException:
 
606
            mandos_clients = dbus.Dictionary()
 
607
        
 
608
        (self.mandos_serv
 
609
         .connect_to_signal("ClientRemoved",
 
610
                            self.find_and_remove_client,
 
611
                            dbus_interface=server_interface,
 
612
                            byte_arrays=True))
 
613
        (self.mandos_serv
 
614
         .connect_to_signal("ClientAdded",
 
615
                            self.add_new_client,
 
616
                            dbus_interface=server_interface,
 
617
                            byte_arrays=True))
 
618
        (self.mandos_serv
 
619
         .connect_to_signal("ClientNotFound",
 
620
                            self.client_not_found,
 
621
                            dbus_interface=server_interface,
 
622
                            byte_arrays=True))
 
623
        for path, client in mandos_clients.iteritems():
 
624
            client_proxy_object = self.bus.get_object(self.busname,
 
625
                                                      path)
 
626
            self.add_client(MandosClientWidget(server_proxy_object
 
627
                                               =self.mandos_serv,
 
628
                                               proxy_object
 
629
                                               =client_proxy_object,
 
630
                                               properties=client,
 
631
                                               update_hook
 
632
                                               =self.refresh,
 
633
                                               delete_hook
 
634
                                               =self.remove_client,
 
635
                                               logger
 
636
                                               =self.log_message),
 
637
                            path=path)
 
638
 
 
639
        self.refresh()
 
640
        self._input_callback_tag = (gobject.io_add_watch
 
641
                                    (sys.stdin.fileno(),
 
642
                                     gobject.IO_IN,
 
643
                                     self.process_input))
 
644
        self.main_loop.run()
 
645
        # Main loop has finished, we should close everything now
 
646
        gobject.source_remove(self._input_callback_tag)
 
647
        self.screen.stop()
 
648
    
 
649
    def stop(self):
 
650
        self.main_loop.quit()
 
651
    
 
652
    def process_input(self, source, condition):
 
653
        keys = self.screen.get_input()
 
654
        translations = { "ctrl n": "down",      # Emacs
 
655
                         "ctrl p": "up",        # Emacs
 
656
                         "ctrl v": "page down", # Emacs
 
657
                         "meta v": "page up",   # Emacs
 
658
                         " ": "page down",      # less
 
659
                         "f": "page down",      # less
 
660
                         "b": "page up",        # less
 
661
                         "j": "down",           # vi
 
662
                         "k": "up",             # vi
 
663
                         }
 
664
        for key in keys:
 
665
            try:
 
666
                key = translations[key]
 
667
            except KeyError:    # :-)
 
668
                pass
 
669
            
 
670
            if key == "q" or key == "Q":
 
671
                self.stop()
 
672
                break
 
673
            elif key == "window resize":
 
674
                self.size = self.screen.get_cols_rows()
 
675
                self.refresh()
 
676
            elif key == "\f":  # Ctrl-L
 
677
                self.refresh()
 
678
            elif key == "l" or key == "D":
 
679
                self.toggle_log_display()
 
680
                self.refresh()
 
681
            elif key == "w" or key == "i":
 
682
                self.change_log_display()
 
683
                self.refresh()
 
684
            elif key == "?" or key == "f1" or key == "esc":
 
685
                if not self.log_visible:
 
686
                    self.log_visible = True
 
687
                    self.rebuild()
 
688
                self.log_message_raw(("bold",
 
689
                                      "  ".
 
690
                                      join(("q: Quit",
 
691
                                            "?: Help",
 
692
                                            "l: Log window toggle",
 
693
                                            "TAB: Switch window",
 
694
                                            "w: Wrap (log)"))))
 
695
                self.log_message_raw(("bold",
 
696
                                      "  "
 
697
                                      .join(("Clients:",
 
698
                                             "+: Enable",
 
699
                                             "-: Disable",
 
700
                                             "R: Remove",
 
701
                                             "s: Start new checker",
 
702
                                             "S: Stop checker",
 
703
                                             "C: Checker OK",
 
704
                                             "a: Approve",
 
705
                                             "d: Deny"))))
 
706
                self.refresh()
 
707
            elif key == "tab":
 
708
                if self.topwidget.get_focus() is self.logbox:
 
709
                    self.topwidget.set_focus(0)
 
710
                else:
 
711
                    self.topwidget.set_focus(self.logbox)
 
712
                self.refresh()
 
713
            #elif (key == "end" or key == "meta >" or key == "G"
 
714
            #      or key == ">"):
 
715
            #    pass            # xxx end-of-buffer
 
716
            #elif (key == "home" or key == "meta <" or key == "g"
 
717
            #      or key == "<"):
 
718
            #    pass            # xxx beginning-of-buffer
 
719
            #elif key == "ctrl e" or key == "$":
 
720
            #    pass            # xxx move-end-of-line
 
721
            #elif key == "ctrl a" or key == "^":
 
722
            #    pass            # xxx move-beginning-of-line
 
723
            #elif key == "ctrl b" or key == "meta (" or key == "h":
 
724
            #    pass            # xxx left
 
725
            #elif key == "ctrl f" or key == "meta )" or key == "l":
 
726
            #    pass            # xxx right
 
727
            #elif key == "a":
 
728
            #    pass            # scroll up log
 
729
            #elif key == "z":
 
730
            #    pass            # scroll down log
 
731
            elif self.topwidget.selectable():
 
732
                self.topwidget.keypress(self.size, key)
 
733
                self.refresh()
 
734
        return True
 
735
 
 
736
ui = UserInterface()
 
737
try:
 
738
    ui.run()
 
739
except KeyboardInterrupt:
 
740
    ui.screen.stop()
 
741
except Exception, e:
 
742
    ui.log_message(unicode(e))
 
743
    ui.screen.stop()
 
744
    raise