/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: 2012-04-24 06:55:34 UTC
  • Revision ID: teddy@recompile.se-20120424065534-n1jqfth9odw3l1jr
* network-hooks.d/bridge: Move "start" and "stop" commands to separate
                          functions.
* network-hooks.d/openvpn: - '' -
* network-hooks.d/wireless: - '' -

Show diffs side-by-side

added added

removed removed

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