/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: 2013-10-13 15:43:42 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 303.
  • Revision ID: teddy@recompile.se-20131013154342-2ztabynqog6xuk0t
* initramfs-unpack: Bug fix: Made executable.

Show diffs side-by-side

added added

removed removed

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