/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: 2011-09-26 19:34:23 UTC
  • Revision ID: teddy@fukt.bsnet.se-20110926193423-5yc1fcv4joiwc1gq
* mandos-clients.conf.xml (OPTIONS/timeout): No longer used when
                                             secret key is given;
                                             refer to
                                             "extended_timeout".

Show diffs side-by-side

added added

removed removed

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