2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009,2010 Teddy Hogeborn
7
# Copyright © 2009,2010 Björn Påhlsson
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
11
# the Free Software Foundation, either version 3 of the License, or
12
# (at your option) any later version.
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
# GNU General Public License for more details.
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/>.
22
# Contact the authors at <mandos@fukt.bsnet.se>.
25
4
from __future__ import division, absolute_import, with_statement
33
9
import urwid.curses_display
61
30
urwid.curses_display.curses.A_UNDERLINE |= (
62
31
urwid.curses_display.curses.A_BLINK)
64
def isoformat_to_datetime(iso):
65
"Parse an ISO 8601 date string to a datetime.datetime()"
68
d, t = iso.split(u"T", 1)
69
year, month, day = d.split(u"-", 2)
70
hour, minute, second = t.split(u":", 2)
71
second, fraction = divmod(float(second), 1)
72
return datetime.datetime(int(year),
77
int(second), # Whole seconds
78
int(fraction*1000000)) # Microseconds
80
33
class MandosClientPropertyCache(object):
81
34
"""This wraps a Mandos Client D-Bus proxy object, caches the
82
35
properties and calls a hook function when any of them are
85
def __init__(self, proxy_object=None, *args, **kwargs):
38
def __init__(self, proxy_object=None, properties=None, *args,
40
# Type conversion mapping
42
dbus.ObjectPath: unicode,
44
dbus.Signature: unicode,
52
dbus.Dictionary: dict,
86
59
self.proxy = proxy_object # Mandos Client proxy object
88
self.properties = dict()
89
self.proxy.connect_to_signal(u"PropertyChanged",
61
if properties is None:
62
self.properties = dict()
64
self.properties = dict(self.convert_property(prop, val)
66
properties.iteritems())
67
self.proxy.connect_to_signal("PropertyChanged",
90
68
self.property_changed,
94
self.properties.update(
95
self.proxy.GetAll(client_interface,
96
dbus_interface = dbus.PROPERTIES_IFACE))
98
#XXX This break good super behaviour!
99
# super(MandosClientPropertyCache, self).__init__(
72
if properties is None:
73
self.properties.update(
74
self.convert_property(prop, val)
76
self.proxy.GetAll(client_interface,
78
dbus.PROPERTIES_IFACE).iteritems())
79
super(MandosClientPropertyCache, self).__init__(
80
proxy_object=proxy_object,
81
properties=properties, *args, **kwargs)
83
def convert_property(self, property, value):
84
"""This converts the arguments from a D-Bus signal, which are
85
D-Bus types, into normal Python types, using a conversion
86
function from "self.type_map".
88
property_name = unicode(property) # Always a dbus.String
89
if isinstance(value, dbus.UTF8String):
90
# Should not happen, but prepare for it anyway
91
value = dbus.String(str(value).decode("utf-8"))
93
convfunc = self.type_map[type(value)]
95
# Unknown type, return unmodified
96
return property_name, value
97
return property_name, convfunc(value)
102
98
def property_changed(self, property=None, value=None):
103
99
"""This is called whenever we get a PropertyChanged signal
104
100
It updates the changed property in the "properties" dict.
102
# Convert name and value
103
property_name, cvalue = self.convert_property(property, value)
106
104
# Update properties dict with new value
107
self.properties[property] = value
105
self.properties[property_name] = cvalue
110
108
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
114
112
def __init__(self, server_proxy_object=None, update_hook=None,
115
delete_hook=None, logger=None, *args, **kwargs):
113
delete_hook=None, *args, **kwargs):
116
114
# Called on update
117
115
self.update_hook = update_hook
118
116
# Called on delete
119
117
self.delete_hook = delete_hook
120
118
# Mandos Server proxy object
121
119
self.server_proxy_object = server_proxy_object
125
self._update_timer_callback_tag = None
126
self._update_timer_callback_lock = 0
127
self.last_checker_failed = False
129
121
# The widget shown normally
130
self._text_widget = urwid.Text(u"")
122
self._text_widget = urwid.Text("")
131
123
# The widget shown when we have focus
132
self._focus_text_widget = urwid.Text(u"")
124
self._focus_text_widget = urwid.Text("")
133
125
super(MandosClientWidget, self).__init__(
134
126
update_hook=update_hook, delete_hook=delete_hook,
137
129
self.opened = False
139
last_checked_ok = isoformat_to_datetime(self.properties
141
if last_checked_ok is None:
142
self.last_checker_failed = True
144
self.last_checker_failed = ((datetime.datetime.utcnow()
151
if self.last_checker_failed:
152
self.using_timer(True)
154
if self.need_approval:
155
self.using_timer(True)
157
self.proxy.connect_to_signal(u"CheckerCompleted",
158
self.checker_completed,
161
self.proxy.connect_to_signal(u"CheckerStarted",
162
self.checker_started,
165
self.proxy.connect_to_signal(u"GotSecret",
169
self.proxy.connect_to_signal(u"NeedApproval",
173
self.proxy.connect_to_signal(u"Rejected",
178
def property_changed(self, property=None, value=None):
179
super(self, MandosClientWidget).property_changed(property,
181
if property == u"ApprovalPending":
182
using_timer(bool(value))
184
def using_timer(self, flag):
185
"""Call this method with True or False when timer should be
186
activated or deactivated.
188
old = self._update_timer_callback_lock
190
self._update_timer_callback_lock += 1
192
self._update_timer_callback_lock -= 1
193
if old == 0 and self._update_timer_callback_lock:
194
self._update_timer_callback_tag = (gobject.timeout_add
197
elif old and self._update_timer_callback_lock == 0:
198
gobject.source_remove(self._update_timer_callback_tag)
199
self._update_timer_callback_tag = None
201
def checker_completed(self, exitstatus, condition, command):
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")'
208
# % (self.properties[u"Name"], command))
212
if not self.last_checker_failed:
213
self.last_checker_failed = True
214
self.using_timer(True)
215
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)))
220
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)))
225
elif os.WCOREDUMP(condition):
226
self.logger(u'Checker for client %s (command "%s")'
228
% (self.properties[u"Name"], command))
230
self.logger(u'Checker for client %s completed'
234
def checker_started(self, command):
235
#self.logger(u'Client %s started checker "%s"'
236
# % (self.properties[u"Name"], unicode(command)))
239
def got_secret(self):
240
self.last_checker_failed = False
241
self.logger(u'Client %s received its secret'
242
% self.properties[u"Name"])
244
def need_approval(self, timeout, default):
246
message = u'Client %s needs approval within %s seconds'
248
message = u'Client %s will get its secret in %s seconds'
250
% (self.properties[u"Name"], timeout/1000))
251
self.using_timer(True)
253
def rejected(self, reason):
254
self.logger(u'Client %s was rejected; reason: %s'
255
% (self.properties[u"Name"], reason))
257
131
def selectable(self):
258
132
"""Make this a "selectable" widget.
280
154
u"bold-underline-blink":
281
155
u"bold-underline-blink-standout",
284
158
# Rebuild focus and non-focus widgets using current properties
286
# 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"]:
292
timeout = datetime.timedelta(milliseconds
295
last_approval_request = isoformat_to_datetime(
296
self.properties[u"LastApprovalRequest"])
297
if last_approval_request is not None:
298
timer = timeout - (datetime.datetime.utcnow()
299
- last_approval_request)
301
timer = datetime.timedelta()
302
if self.properties[u"ApprovedByDefault"]:
303
message = u"Approval in %s. (d)eny?"
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
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])
321
self._text = "%s%s" % (base, message)
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
323
161
if not urwid.supports_unicode():
324
162
self._text = self._text.encode("ascii", "replace")
325
textlist = [(u"normal", self._text)]
163
textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]
326
164
self._text_widget.set_text(textlist)
327
165
self._focus_text_widget.set_text([(with_standout[text[0]],
357
187
def keypress(self, (maxcol,), key):
359
189
This overrides the method from urwid.FlowWidget"""
361
self.proxy.Enable(dbus_interface = client_interface)
363
self.proxy.Disable(dbus_interface = client_interface)
365
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
dbus_interface = client_interface)
368
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":
190
if key == u"e" or key == u"+":
192
elif key == u"d" or key == u"-":
194
elif key == u"r" or key == u"_":
371
195
self.server_proxy_object.RemoveClient(self.proxy
373
197
elif key == u"s":
374
self.proxy.StartChecker(dbus_interface = client_interface)
198
self.proxy.StartChecker()
200
self.proxy.StopChecker()
375
201
elif key == u"S":
376
self.proxy.StopChecker(dbus_interface = client_interface)
378
self.proxy.CheckedOK(dbus_interface = client_interface)
202
self.proxy.CheckedOK()
380
204
# elif key == u"p" or key == "=":
381
205
# self.proxy.pause()
401
class ConstrainedListBox(urwid.ListBox):
402
"""Like a normal urwid.ListBox, but will consume all "up" or
403
"down" key presses, thus not allowing any containing widgets to
404
use them as an excuse to shift focus away from this widget.
406
def keypress(self, (maxcol, maxrow), key):
407
ret = super(ConstrainedListBox, self).keypress((maxcol,
409
if ret in (u"up", u"down"):
414
225
class UserInterface(object):
415
226
"""This is the entire user interface - the whole screen
416
227
with boxes, lists of client widgets, etc.
418
def __init__(self, max_log_length=1000):
419
DBusGMainLoop(set_as_default=True)
230
DBusGMainLoop(set_as_default=True )
421
232
self.screen = urwid.curses_display.Screen()
443
if urwid.supports_unicode():
444
self.divider = u"─" # \u2500
445
#self.divider = u"━" # \u2501
447
#self.divider = u"-" # \u002d
448
self.divider = u"_" # \u005f
450
254
self.screen.start()
452
256
self.size = self.screen.get_cols_rows()
454
258
self.clients = urwid.SimpleListWalker([])
455
259
self.clients_dict = {}
457
# We will add Text widgets to this list
459
self.max_log_length = max_log_length
461
# We keep a reference to the log widget so we can remove it
462
# from the ListWalker without it getting destroyed
463
self.logbox = ConstrainedListBox(self.log)
465
# This keeps track of whether self.uilist currently has
466
# self.logbox in it or not
467
self.log_visible = True
468
self.log_wrap = u"any"
471
self.log_message_raw((u"bold",
472
u"Mandos Monitor version " + version))
473
self.log_message_raw((u"bold",
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
476
263
self.busname = domain + '.Mandos'
477
264
self.main_loop = gobject.MainLoop()
488
275
mandos_clients = dbus.Dictionary()
490
277
(self.mandos_serv
491
.connect_to_signal(u"ClientRemoved",
278
.connect_to_signal("ClientRemoved",
492
279
self.find_and_remove_client,
493
280
dbus_interface=server_interface,
494
281
byte_arrays=True))
495
282
(self.mandos_serv
496
.connect_to_signal(u"ClientAdded",
283
.connect_to_signal("ClientAdded",
497
284
self.add_new_client,
498
285
dbus_interface=server_interface,
499
286
byte_arrays=True))
501
.connect_to_signal(u"ClientNotFound",
502
self.client_not_found,
503
dbus_interface=server_interface,
505
for path, client in mandos_clients.iteritems():
287
for path, client in (mandos_clients.iteritems()):
506
288
client_proxy_object = self.bus.get_object(self.busname,
508
290
self.add_client(MandosClientWidget(server_proxy_object
298
=self.remove_client),
521
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,
527
"""This rebuilds the User Interface.
528
Call this when the widget layout needs to change"""
530
#self.uilist.append(urwid.ListBox(self.clients))
531
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
533
#header=urwid.Divider(),
536
urwid.Divider(div_char=
539
self.uilist.append(self.logbox)
541
self.topwidget = urwid.Pile(self.uilist)
543
def log_message(self, message):
544
timestamp = datetime.datetime.now().isoformat()
545
self.log_message_raw(timestamp + u": " + message)
547
def log_message_raw(self, markup):
548
"""Add a log message to the log buffer."""
549
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
550
if (self.max_log_length
551
and len(self.log) > self.max_log_length):
552
del self.log[0:len(self.log)-self.max_log_length-1]
553
self.logbox.set_focus(len(self.logbox.body.contents),
554
coming_from=u"above")
557
def toggle_log_display(self):
558
"""Toggle visibility of the log buffer."""
559
self.log_visible = not self.log_visible
561
#self.log_message(u"Log visibility changed to: "
562
# + unicode(self.log_visible))
564
def change_log_display(self):
565
"""Change type of log display.
566
Currently, this toggles wrapping of text lines."""
567
if self.log_wrap == u"clip":
568
self.log_wrap = u"any"
570
self.log_wrap = u"clip"
571
for textwidget in self.log:
572
textwidget.set_wrap_mode(self.log_wrap)
573
#self.log_message(u"Wrap mode: " + self.log_wrap)
575
301
def find_and_remove_client(self, path, name):
576
302
"""Find an client from its object path and remove it.
662
375
elif key == u"window resize":
663
376
self.size = self.screen.get_cols_rows()
665
elif key == u"\f": # Ctrl-L
667
elif key == u"l" or key == u"D":
668
self.toggle_log_display()
670
elif key == u"w" or key == u"i":
671
self.change_log_display()
673
elif key == u"?" or key == u"f1" or key == u"esc":
674
if not self.log_visible:
675
self.log_visible = True
677
self.log_message_raw((u"bold",
681
u"l: Log window toggle",
682
u"TAB: Switch window",
684
self.log_message_raw((u"bold",
690
u"s: Start new checker",
697
if self.topwidget.get_focus() is self.logbox:
698
self.topwidget.set_focus(0)
700
self.topwidget.set_focus(self.logbox)
702
#elif (key == u"end" or key == u"meta >" or key == u"G"
704
# pass # xxx end-of-buffer
705
#elif (key == u"home" or key == u"meta <" or key == u"g"
707
# pass # xxx beginning-of-buffer
708
#elif key == u"ctrl e" or key == u"$":
709
# pass # xxx move-end-of-line
710
#elif key == u"ctrl a" or key == u"^":
711
# pass # xxx move-beginning-of-line
712
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
714
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
717
# pass # scroll up log
719
# pass # scroll down log
720
380
elif self.topwidget.selectable():
721
381
self.topwidget.keypress(self.size, key)