/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: Teddy Hogeborn
  • Date: 2014-03-29 02:38:15 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 311.
  • Revision ID: teddy@recompile.se-20140329023815-bpgxi9v4ikrlcpst
Update copyright year.

* mandos-keygen: Update copyright year.
* plugin-runner.c: - '' -
* plugins.d/askpass-fifo.c: - '' -
* plugins.d/mandos-client.c: - '' -
* plugins.d/password-prompt.c: - '' -
* plugins.d/plymouth.c: - '' -
* plugins.d/splashy.c: - '' -
* plugins.d/usplash.c: - '' -

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-2011 Teddy Hogeborn
7
 
# Copyright © 2009-2011 Björn Påhlsson
 
6
# Copyright © 2009-2014 Teddy Hogeborn
 
7
# Copyright © 2009-2014 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
17
17
#     GNU General Public License for more details.
18
18
# 
19
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/>.
 
20
# along with this program.  If not, see
 
21
# <http://www.gnu.org/licenses/>.
21
22
# 
22
 
# Contact the authors at <mandos@fukt.bsnet.se>.
 
23
# Contact the authors at <mandos@recompile.se>.
23
24
# 
24
25
 
25
 
from __future__ import division, absolute_import, print_function, unicode_literals
 
26
from __future__ import (division, absolute_import, print_function,
 
27
                        unicode_literals)
 
28
try:
 
29
    from future_builtins import *
 
30
except ImportError:
 
31
    pass
26
32
 
27
33
import sys
28
34
import os
29
 
import signal
30
35
 
31
36
import datetime
32
37
 
34
39
import urwid
35
40
 
36
41
from dbus.mainloop.glib import DBusGMainLoop
37
 
import gobject
 
42
try:
 
43
    import gobject
 
44
except ImportError:
 
45
    from gi.repository import GObject as gobject
38
46
 
39
47
import dbus
40
48
 
41
 
import UserList
42
 
 
43
49
import locale
44
50
 
 
51
if sys.version_info[0] == 2:
 
52
    str = unicode
 
53
 
45
54
locale.setlocale(locale.LC_ALL, '')
46
55
 
47
56
import logging
48
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
58
 
50
59
# Some useful constants
51
 
domain = 'se.bsnet.fukt'
 
60
domain = 'se.recompile'
52
61
server_interface = domain + '.Mandos'
53
62
client_interface = domain + '.Mandos.Client'
54
 
version = "1.2.3"
55
 
 
56
 
# Always run in monochrome mode
57
 
urwid.curses_display.curses.has_colors = lambda : False
58
 
 
59
 
# Urwid doesn't support blinking, but we want it.  Since we have no
60
 
# use for underline on its own, we make underline also always blink.
61
 
urwid.curses_display.curses.A_UNDERLINE |= (
62
 
    urwid.curses_display.curses.A_BLINK)
 
63
version = "1.6.4"
63
64
 
64
65
def isoformat_to_datetime(iso):
65
66
    "Parse an ISO 8601 date string to a datetime.datetime()"
82
83
    properties and calls a hook function when any of them are
83
84
    changed.
84
85
    """
85
 
    def __init__(self, proxy_object=None, *args, **kwargs):
 
86
    def __init__(self, proxy_object=None, properties=None, **kwargs):
86
87
        self.proxy = proxy_object # Mandos Client proxy object
87
 
        
88
 
        self.properties = dict()
89
 
        self.proxy.connect_to_signal("PropertyChanged",
90
 
                                     self.property_changed,
91
 
                                     client_interface,
92
 
                                     byte_arrays=True)
93
 
        
94
 
        self.properties.update(
95
 
            self.proxy.GetAll(client_interface,
96
 
                              dbus_interface = dbus.PROPERTIES_IFACE))
97
 
 
98
 
        #XXX This break good super behaviour!
99
 
#        super(MandosClientPropertyCache, self).__init__(
100
 
#            *args, **kwargs)
 
88
        self.properties = dict() if properties is None else properties
 
89
        self.property_changed_match = (
 
90
            self.proxy.connect_to_signal("PropertyChanged",
 
91
                                         self._property_changed,
 
92
                                         client_interface,
 
93
                                         byte_arrays=True))
 
94
        
 
95
        if properties is None:
 
96
            self.properties.update(
 
97
                self.proxy.GetAll(client_interface,
 
98
                                  dbus_interface
 
99
                                  = dbus.PROPERTIES_IFACE))
 
100
        
 
101
        super(MandosClientPropertyCache, self).__init__(**kwargs)
 
102
    
 
103
    def _property_changed(self, property, value):
 
104
        """Helper which takes positional arguments"""
 
105
        return self.property_changed(property=property, value=value)
101
106
    
102
107
    def property_changed(self, property=None, value=None):
103
108
        """This is called whenever we get a PropertyChanged signal
105
110
        """
106
111
        # Update properties dict with new value
107
112
        self.properties[property] = value
 
113
    
 
114
    def delete(self):
 
115
        self.property_changed_match.remove()
108
116
 
109
117
 
110
118
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
112
120
    """
113
121
    
114
122
    def __init__(self, server_proxy_object=None, update_hook=None,
115
 
                 delete_hook=None, logger=None, *args, **kwargs):
 
123
                 delete_hook=None, logger=None, **kwargs):
116
124
        # Called on update
117
125
        self.update_hook = update_hook
118
126
        # Called on delete
123
131
        self.logger = logger
124
132
        
125
133
        self._update_timer_callback_tag = None
126
 
        self._update_timer_callback_lock = 0
127
 
        self.last_checker_failed = False
128
134
        
129
135
        # The widget shown normally
130
136
        self._text_widget = urwid.Text("")
131
137
        # The widget shown when we have focus
132
138
        self._focus_text_widget = urwid.Text("")
133
 
        super(MandosClientWidget, self).__init__(
134
 
            update_hook=update_hook, delete_hook=delete_hook,
135
 
            *args, **kwargs)
 
139
        super(MandosClientWidget, self).__init__(**kwargs)
136
140
        self.update()
137
141
        self.opened = False
138
142
        
139
 
        last_checked_ok = isoformat_to_datetime(self.properties
140
 
                                                ["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
 
                                         ["Interval"]))
150
 
        
151
 
        if self.last_checker_failed:
152
 
            self.using_timer(True)
153
 
        
154
 
        if self.need_approval:
155
 
            self.using_timer(True)
156
 
        
157
 
        self.proxy.connect_to_signal("CheckerCompleted",
158
 
                                     self.checker_completed,
159
 
                                     client_interface,
160
 
                                     byte_arrays=True)
161
 
        self.proxy.connect_to_signal("CheckerStarted",
162
 
                                     self.checker_started,
163
 
                                     client_interface,
164
 
                                     byte_arrays=True)
165
 
        self.proxy.connect_to_signal("GotSecret",
166
 
                                     self.got_secret,
167
 
                                     client_interface,
168
 
                                     byte_arrays=True)
169
 
        self.proxy.connect_to_signal("NeedApproval",
170
 
                                     self.need_approval,
171
 
                                     client_interface,
172
 
                                     byte_arrays=True)
173
 
        self.proxy.connect_to_signal("Rejected",
174
 
                                     self.rejected,
175
 
                                     client_interface,
176
 
                                     byte_arrays=True)
 
143
        self.match_objects = (
 
144
            self.proxy.connect_to_signal("CheckerCompleted",
 
145
                                         self.checker_completed,
 
146
                                         client_interface,
 
147
                                         byte_arrays=True),
 
148
            self.proxy.connect_to_signal("CheckerStarted",
 
149
                                         self.checker_started,
 
150
                                         client_interface,
 
151
                                         byte_arrays=True),
 
152
            self.proxy.connect_to_signal("GotSecret",
 
153
                                         self.got_secret,
 
154
                                         client_interface,
 
155
                                         byte_arrays=True),
 
156
            self.proxy.connect_to_signal("NeedApproval",
 
157
                                         self.need_approval,
 
158
                                         client_interface,
 
159
                                         byte_arrays=True),
 
160
            self.proxy.connect_to_signal("Rejected",
 
161
                                         self.rejected,
 
162
                                         client_interface,
 
163
                                         byte_arrays=True))
 
164
        #self.logger('Created client {0}'
 
165
        #            .format(self.properties["Name"]))
177
166
    
178
 
    def property_changed(self, property=None, value=None):
179
 
        super(self, MandosClientWidget).property_changed(property,
180
 
                                                         value)
181
 
        if property == "ApprovalPending":
182
 
            using_timer(bool(value))
183
 
        
184
167
    def using_timer(self, flag):
185
168
        """Call this method with True or False when timer should be
186
169
        activated or deactivated.
187
170
        """
188
 
        old = self._update_timer_callback_lock
189
 
        if flag:
190
 
            self._update_timer_callback_lock += 1
191
 
        else:
192
 
            self._update_timer_callback_lock -= 1
193
 
        if old == 0 and self._update_timer_callback_lock:
 
171
        if flag and self._update_timer_callback_tag is None:
 
172
            # Will update the shown timer value every second
194
173
            self._update_timer_callback_tag = (gobject.timeout_add
195
174
                                               (1000,
196
175
                                                self.update_timer))
197
 
        elif old and self._update_timer_callback_lock == 0:
 
176
        elif not (flag or self._update_timer_callback_tag is None):
198
177
            gobject.source_remove(self._update_timer_callback_tag)
199
178
            self._update_timer_callback_tag = None
200
179
    
201
180
    def checker_completed(self, exitstatus, condition, command):
202
181
        if exitstatus == 0:
203
 
            if self.last_checker_failed:
204
 
                self.last_checker_failed = False
205
 
                self.using_timer(False)
206
 
            #self.logger('Checker for client %s (command "%s")'
207
 
            #            ' was successful'
208
 
            #            % (self.properties["Name"], command))
209
182
            self.update()
210
183
            return
211
184
        # Checker failed
212
 
        if not self.last_checker_failed:
213
 
            self.last_checker_failed = True
214
 
            self.using_timer(True)
215
185
        if os.WIFEXITED(condition):
216
 
            self.logger('Checker for client %s (command "%s")'
217
 
                        ' failed with exit code %s'
218
 
                        % (self.properties["Name"], command,
219
 
                           os.WEXITSTATUS(condition)))
 
186
            self.logger('Checker for client {0} (command "{1}")'
 
187
                        ' failed with exit code {2}'
 
188
                        .format(self.properties["Name"], command,
 
189
                                os.WEXITSTATUS(condition)))
220
190
        elif os.WIFSIGNALED(condition):
221
 
            self.logger('Checker for client %s (command "%s")'
222
 
                        ' was killed by signal %s'
223
 
                        % (self.properties["Name"], command,
224
 
                           os.WTERMSIG(condition)))
 
191
            self.logger('Checker for client {0} (command "{1}") was'
 
192
                        ' killed by signal {2}'
 
193
                        .format(self.properties["Name"], command,
 
194
                                os.WTERMSIG(condition)))
225
195
        elif os.WCOREDUMP(condition):
226
 
            self.logger('Checker for client %s (command "%s")'
 
196
            self.logger('Checker for client {0} (command "{1}")'
227
197
                        ' dumped core'
228
 
                        % (self.properties["Name"], command))
 
198
                        .format(self.properties["Name"], command))
229
199
        else:
230
 
            self.logger('Checker for client %s completed'
231
 
                        ' mysteriously')
 
200
            self.logger('Checker for client {0} completed'
 
201
                        ' mysteriously'
 
202
                        .format(self.properties["Name"]))
232
203
        self.update()
233
204
    
234
205
    def checker_started(self, command):
235
 
        #self.logger('Client %s started checker "%s"'
236
 
        #            % (self.properties["Name"], unicode(command)))
 
206
        """Server signals that a checker started. This could be useful
 
207
           to log in the future. """
 
208
        #self.logger('Client {0} started checker "{1}"'
 
209
        #            .format(self.properties["Name"],
 
210
        #                    str(command)))
237
211
        pass
238
212
    
239
213
    def got_secret(self):
240
 
        self.last_checker_failed = False
241
 
        self.logger('Client %s received its secret'
242
 
                    % self.properties["Name"])
 
214
        self.logger('Client {0} received its secret'
 
215
                    .format(self.properties["Name"]))
243
216
    
244
217
    def need_approval(self, timeout, default):
245
218
        if not default:
246
 
            message = 'Client %s needs approval within %s seconds'
 
219
            message = 'Client {0} needs approval within {1} seconds'
247
220
        else:
248
 
            message = 'Client %s will get its secret in %s seconds'
249
 
        self.logger(message
250
 
                    % (self.properties["Name"], timeout/1000))
251
 
        self.using_timer(True)
 
221
            message = 'Client {0} will get its secret in {1} seconds'
 
222
        self.logger(message.format(self.properties["Name"],
 
223
                                   timeout/1000))
252
224
    
253
225
    def rejected(self, reason):
254
 
        self.logger('Client %s was rejected; reason: %s'
255
 
                    % (self.properties["Name"], reason))
 
226
        self.logger('Client {0} was rejected; reason: {1}'
 
227
                    .format(self.properties["Name"], reason))
256
228
    
257
229
    def selectable(self):
258
230
        """Make this a "selectable" widget.
280
252
                          "bold-underline-blink":
281
253
                              "bold-underline-blink-standout",
282
254
                          }
283
 
 
 
255
        
284
256
        # Rebuild focus and non-focus widgets using current properties
285
 
 
 
257
        
286
258
        # Base part of a client. Name!
287
 
        base = ('%(name)s: '
288
 
                      % {"name": self.properties["Name"]})
 
259
        base = '{name}: '.format(name=self.properties["Name"])
289
260
        if not self.properties["Enabled"]:
290
261
            message = "DISABLED"
 
262
            self.using_timer(False)
291
263
        elif self.properties["ApprovalPending"]:
292
264
            timeout = datetime.timedelta(milliseconds
293
265
                                         = self.properties
295
267
            last_approval_request = isoformat_to_datetime(
296
268
                self.properties["LastApprovalRequest"])
297
269
            if last_approval_request is not None:
298
 
                timer = timeout - (datetime.datetime.utcnow()
299
 
                                   - last_approval_request)
 
270
                timer = max(timeout - (datetime.datetime.utcnow()
 
271
                                       - last_approval_request),
 
272
                            datetime.timedelta())
300
273
            else:
301
274
                timer = datetime.timedelta()
302
275
            if self.properties["ApprovedByDefault"]:
303
 
                message = "Approval in %s. (d)eny?"
304
 
            else:
305
 
                message = "Denial in %s. (a)pprove?"
306
 
            message = message % unicode(timer).rsplit(".", 1)[0]
307
 
        elif self.last_checker_failed:
308
 
            timeout = datetime.timedelta(milliseconds
309
 
                                         = self.properties
310
 
                                         ["Timeout"])
311
 
            last_ok = isoformat_to_datetime(
312
 
                max((self.properties["LastCheckedOK"]
313
 
                     or self.properties["Created"]),
314
 
                    self.properties["LastEnabled"]))
315
 
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
 
276
                message = "Approval in {0}. (d)eny?"
 
277
            else:
 
278
                message = "Denial in {0}. (a)pprove?"
 
279
            message = message.format(str(timer).rsplit(".", 1)[0])
 
280
            self.using_timer(True)
 
281
        elif self.properties["LastCheckerStatus"] != 0:
 
282
            # When checker has failed, show timer until client expires
 
283
            expires = self.properties["Expires"]
 
284
            if expires == "":
 
285
                timer = datetime.timedelta(0)
 
286
            else:
 
287
                expires = (datetime.datetime.strptime
 
288
                           (expires, '%Y-%m-%dT%H:%M:%S.%f'))
 
289
                timer = max(expires - datetime.datetime.utcnow(),
 
290
                            datetime.timedelta())
316
291
            message = ('A checker has failed! Time until client'
317
 
                       ' gets disabled: %s'
318
 
                           % unicode(timer).rsplit(".", 1)[0])
 
292
                       ' gets disabled: {0}'
 
293
                       .format(str(timer).rsplit(".", 1)[0]))
 
294
            self.using_timer(True)
319
295
        else:
320
296
            message = "enabled"
321
 
        self._text = "%s%s" % (base, message)
322
 
            
 
297
            self.using_timer(False)
 
298
        self._text = "{0}{1}".format(base, message)
 
299
        
323
300
        if not urwid.supports_unicode():
324
301
            self._text = self._text.encode("ascii", "replace")
325
302
        textlist = [("normal", self._text)]
337
314
            self.update_hook()
338
315
    
339
316
    def update_timer(self):
340
 
        "called by gobject"
 
317
        """called by gobject. Will indefinitely loop until
 
318
        gobject.source_remove() on tag is called"""
341
319
        self.update()
342
320
        return True             # Keep calling this
343
321
    
344
 
    def delete(self):
 
322
    def delete(self, **kwargs):
345
323
        if self._update_timer_callback_tag is not None:
346
324
            gobject.source_remove(self._update_timer_callback_tag)
347
325
            self._update_timer_callback_tag = None
 
326
        for match in self.match_objects:
 
327
            match.remove()
 
328
        self.match_objects = ()
348
329
        if self.delete_hook is not None:
349
330
            self.delete_hook(self)
 
331
        return super(MandosClientWidget, self).delete(**kwargs)
350
332
    
351
333
    def render(self, maxcolrow, focus=False):
352
334
        """Render differently if we have focus.
358
340
        """Handle keys.
359
341
        This overrides the method from urwid.FlowWidget"""
360
342
        if key == "+":
361
 
            self.proxy.Enable(dbus_interface = client_interface)
 
343
            self.proxy.Enable(dbus_interface = client_interface,
 
344
                              ignore_reply=True)
362
345
        elif key == "-":
363
 
            self.proxy.Disable(dbus_interface = client_interface)
 
346
            self.proxy.Disable(dbus_interface = client_interface,
 
347
                               ignore_reply=True)
364
348
        elif key == "a":
365
349
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
 
                               dbus_interface = client_interface)
 
350
                               dbus_interface = client_interface,
 
351
                               ignore_reply=True)
367
352
        elif key == "d":
368
353
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
 
                                  dbus_interface = client_interface)
 
354
                                  dbus_interface = client_interface,
 
355
                               ignore_reply=True)
370
356
        elif key == "R" or key == "_" or key == "ctrl k":
371
357
            self.server_proxy_object.RemoveClient(self.proxy
372
 
                                                  .object_path)
 
358
                                                  .object_path,
 
359
                                                  ignore_reply=True)
373
360
        elif key == "s":
374
 
            self.proxy.StartChecker(dbus_interface = client_interface)
 
361
            self.proxy.StartChecker(dbus_interface = client_interface,
 
362
                                    ignore_reply=True)
375
363
        elif key == "S":
376
 
            self.proxy.StopChecker(dbus_interface = client_interface)
 
364
            self.proxy.StopChecker(dbus_interface = client_interface,
 
365
                                   ignore_reply=True)
377
366
        elif key == "C":
378
 
            self.proxy.CheckedOK(dbus_interface = client_interface)
 
367
            self.proxy.CheckedOK(dbus_interface = client_interface,
 
368
                                 ignore_reply=True)
379
369
        # xxx
380
370
#         elif key == "p" or key == "=":
381
371
#             self.proxy.pause()
386
376
        else:
387
377
            return key
388
378
    
389
 
    def property_changed(self, property=None, value=None,
390
 
                         *args, **kwargs):
 
379
    def property_changed(self, property=None, **kwargs):
391
380
        """Call self.update() if old value is not new value.
392
381
        This overrides the method from MandosClientPropertyCache"""
393
 
        property_name = unicode(property)
 
382
        property_name = str(property)
394
383
        old_value = self.properties.get(property_name)
395
384
        super(MandosClientWidget, self).property_changed(
396
 
            property=property, value=value, *args, **kwargs)
 
385
            property=property, **kwargs)
397
386
        if self.properties.get(property_name) != old_value:
398
387
            self.update()
399
388
 
403
392
    "down" key presses, thus not allowing any containing widgets to
404
393
    use them as an excuse to shift focus away from this widget.
405
394
    """
406
 
    def keypress(self, maxcolrow, key):
407
 
        ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
 
395
    def keypress(self, *args, **kwargs):
 
396
        ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
408
397
        if ret in ("up", "down"):
409
398
            return
410
399
        return ret
423
412
                ("normal",
424
413
                 "default", "default", None),
425
414
                ("bold",
426
 
                 "default", "default", "bold"),
 
415
                 "bold", "default", "bold"),
427
416
                ("underline-blink",
428
 
                 "default", "default", "underline"),
 
417
                 "underline,blink", "default", "underline,blink"),
429
418
                ("standout",
430
 
                 "default", "default", "standout"),
 
419
                 "standout", "default", "standout"),
431
420
                ("bold-underline-blink",
432
 
                 "default", "default", ("bold", "underline")),
 
421
                 "bold,underline,blink", "default", "bold,underline,blink"),
433
422
                ("bold-standout",
434
 
                 "default", "default", ("bold", "standout")),
 
423
                 "bold,standout", "default", "bold,standout"),
435
424
                ("underline-blink-standout",
436
 
                 "default", "default", ("underline", "standout")),
 
425
                 "underline,blink,standout", "default",
 
426
                 "underline,blink,standout"),
437
427
                ("bold-underline-blink-standout",
438
 
                 "default", "default", ("bold", "underline",
439
 
                                          "standout")),
 
428
                 "bold,underline,blink,standout", "default",
 
429
                 "bold,underline,blink,standout"),
440
430
                ))
441
431
        
442
432
        if urwid.supports_unicode():
474
464
        
475
465
        self.busname = domain + '.Mandos'
476
466
        self.main_loop = gobject.MainLoop()
477
 
        self.bus = dbus.SystemBus()
478
 
        mandos_dbus_objc = self.bus.get_object(
479
 
            self.busname, "/", follow_name_owner_changes=True)
480
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
 
                                          dbus_interface
482
 
                                          = server_interface)
483
 
        try:
484
 
            mandos_clients = (self.mandos_serv
485
 
                              .GetAllClientsWithProperties())
486
 
        except dbus.exceptions.DBusException:
487
 
            mandos_clients = dbus.Dictionary()
488
 
        
489
 
        (self.mandos_serv
490
 
         .connect_to_signal("ClientRemoved",
491
 
                            self.find_and_remove_client,
492
 
                            dbus_interface=server_interface,
493
 
                            byte_arrays=True))
494
 
        (self.mandos_serv
495
 
         .connect_to_signal("ClientAdded",
496
 
                            self.add_new_client,
497
 
                            dbus_interface=server_interface,
498
 
                            byte_arrays=True))
499
 
        (self.mandos_serv
500
 
         .connect_to_signal("ClientNotFound",
501
 
                            self.client_not_found,
502
 
                            dbus_interface=server_interface,
503
 
                            byte_arrays=True))
504
 
        for path, client in mandos_clients.iteritems():
505
 
            client_proxy_object = self.bus.get_object(self.busname,
506
 
                                                      path)
507
 
            self.add_client(MandosClientWidget(server_proxy_object
508
 
                                               =self.mandos_serv,
509
 
                                               proxy_object
510
 
                                               =client_proxy_object,
511
 
                                               properties=client,
512
 
                                               update_hook
513
 
                                               =self.refresh,
514
 
                                               delete_hook
515
 
                                               =self.remove_client,
516
 
                                               logger
517
 
                                               =self.log_message),
518
 
                            path=path)
519
467
    
520
468
    def client_not_found(self, fingerprint, address):
521
 
        self.log_message(("Client with address %s and fingerprint %s"
522
 
                          " could not be found" % (address,
523
 
                                                    fingerprint)))
 
469
        self.log_message("Client with address {0} and fingerprint"
 
470
                         " {1} could not be found"
 
471
                         .format(address, fingerprint))
524
472
    
525
473
    def rebuild(self):
526
474
        """This rebuilds the User Interface.
536
484
                                                     self.divider)))
537
485
        if self.log_visible:
538
486
            self.uilist.append(self.logbox)
539
 
            pass
540
487
        self.topwidget = urwid.Pile(self.uilist)
541
488
    
542
489
    def log_message(self, message):
 
490
        """Log message formatted with timestamp"""
543
491
        timestamp = datetime.datetime.now().isoformat()
544
492
        self.log_message_raw(timestamp + ": " + message)
545
493
    
558
506
        self.log_visible = not self.log_visible
559
507
        self.rebuild()
560
508
        #self.log_message("Log visibility changed to: "
561
 
        #                 + unicode(self.log_visible))
 
509
        #                 + str(self.log_visible))
562
510
    
563
511
    def change_log_display(self):
564
512
        """Change type of log display.
572
520
        #self.log_message("Wrap mode: " + self.log_wrap)
573
521
    
574
522
    def find_and_remove_client(self, path, name):
575
 
        """Find an client from its object path and remove it.
 
523
        """Find a client by its object path and remove it.
576
524
        
577
525
        This is connected to the ClientRemoved signal from the
578
526
        Mandos server object."""
580
528
            client = self.clients_dict[path]
581
529
        except KeyError:
582
530
            # not found?
 
531
            self.log_message("Unknown client {0!r} ({1!r}) removed"
 
532
                             .format(name, path))
583
533
            return
584
 
        self.remove_client(client, path)
 
534
        client.delete()
585
535
    
586
536
    def add_new_client(self, path):
587
537
        client_proxy_object = self.bus.get_object(self.busname, path)
602
552
        if path is None:
603
553
            path = client.proxy.object_path
604
554
        self.clients_dict[path] = client
605
 
        self.clients.sort(None, lambda c: c.properties["Name"])
 
555
        self.clients.sort(key=lambda c: c.properties["Name"])
606
556
        self.refresh()
607
557
    
608
558
    def remove_client(self, client, path=None):
610
560
        if path is None:
611
561
            path = client.proxy.object_path
612
562
        del self.clients_dict[path]
613
 
        if not self.clients_dict:
614
 
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
615
 
            # is completely emptied, we need to recreate it.
616
 
            self.clients = urwid.SimpleListWalker([])
617
 
            self.rebuild()
618
563
        self.refresh()
619
564
    
620
565
    def refresh(self):
624
569
    
625
570
    def run(self):
626
571
        """Start the main loop and exit when it's done."""
 
572
        self.bus = dbus.SystemBus()
 
573
        mandos_dbus_objc = self.bus.get_object(
 
574
            self.busname, "/", follow_name_owner_changes=True)
 
575
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
576
                                          dbus_interface
 
577
                                          = server_interface)
 
578
        try:
 
579
            mandos_clients = (self.mandos_serv
 
580
                              .GetAllClientsWithProperties())
 
581
            if not mandos_clients:
 
582
                self.log_message_raw(("bold", "Note: Server has no clients."))
 
583
        except dbus.exceptions.DBusException:
 
584
            self.log_message_raw(("bold", "Note: No Mandos server running."))
 
585
            mandos_clients = dbus.Dictionary()
 
586
        
 
587
        (self.mandos_serv
 
588
         .connect_to_signal("ClientRemoved",
 
589
                            self.find_and_remove_client,
 
590
                            dbus_interface=server_interface,
 
591
                            byte_arrays=True))
 
592
        (self.mandos_serv
 
593
         .connect_to_signal("ClientAdded",
 
594
                            self.add_new_client,
 
595
                            dbus_interface=server_interface,
 
596
                            byte_arrays=True))
 
597
        (self.mandos_serv
 
598
         .connect_to_signal("ClientNotFound",
 
599
                            self.client_not_found,
 
600
                            dbus_interface=server_interface,
 
601
                            byte_arrays=True))
 
602
        for path, client in mandos_clients.items():
 
603
            client_proxy_object = self.bus.get_object(self.busname,
 
604
                                                      path)
 
605
            self.add_client(MandosClientWidget(server_proxy_object
 
606
                                               =self.mandos_serv,
 
607
                                               proxy_object
 
608
                                               =client_proxy_object,
 
609
                                               properties=client,
 
610
                                               update_hook
 
611
                                               =self.refresh,
 
612
                                               delete_hook
 
613
                                               =self.remove_client,
 
614
                                               logger
 
615
                                               =self.log_message),
 
616
                            path=path)
 
617
        
627
618
        self.refresh()
628
619
        self._input_callback_tag = (gobject.io_add_watch
629
620
                                    (sys.stdin.fileno(),
726
717
    ui.run()
727
718
except KeyboardInterrupt:
728
719
    ui.screen.stop()
729
 
except Exception, e:
730
 
    ui.log_message(unicode(e))
 
720
except Exception as e:
 
721
    ui.log_message(str(e))
731
722
    ui.screen.stop()
732
723
    raise