2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 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>.
4
from __future__ import division, absolute_import, with_statement
25
from __future__ import division, absolute_import, print_function, unicode_literals
9
33
import urwid.curses_display
30
61
urwid.curses_display.curses.A_UNDERLINE |= (
31
62
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("T", 1)
69
year, month, day = d.split("-", 2)
70
hour, minute, second = t.split(":", 2)
71
second, fraction = divmod(float(second), 1)
72
return datetime.datetime(int(year),
77
int(second), # Whole seconds
78
int(fraction*1000000)) # Microseconds
33
80
class MandosClientPropertyCache(object):
34
81
"""This wraps a Mandos Client D-Bus proxy object, caches the
35
82
properties and calls a hook function when any of them are
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,
85
def __init__(self, proxy_object=None, *args, **kwargs):
59
86
self.proxy = proxy_object # Mandos Client proxy object
61
if properties is None:
62
self.properties = dict()
64
self.properties = dict(self.convert_property(prop, val)
66
properties.iteritems())
88
self.properties = dict()
67
89
self.proxy.connect_to_signal("PropertyChanged",
68
90
self.property_changed,
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)
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__(
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)
98
102
def property_changed(self, property=None, value=None):
99
103
"""This is called whenever we get a PropertyChanged signal
100
104
It updates the changed property in the "properties" dict.
102
# Convert name and value
103
property_name, cvalue = self.convert_property(property, value)
104
106
# Update properties dict with new value
105
self.properties[property_name] = cvalue
107
self.properties[property] = value
108
110
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
129
137
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("CheckerCompleted",
158
self.checker_completed,
161
self.proxy.connect_to_signal("CheckerStarted",
162
self.checker_started,
165
self.proxy.connect_to_signal("GotSecret",
169
self.proxy.connect_to_signal("NeedApproval",
173
self.proxy.connect_to_signal("Rejected",
178
def property_changed(self, property=None, value=None):
179
super(self, MandosClientWidget).property_changed(property,
181
if property == "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('Checker for client %s (command "%s")'
208
# % (self.properties["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('Checker for client %s (command "%s")'
217
' failed with exit code %s'
218
% (self.properties["Name"], command,
219
os.WEXITSTATUS(condition)))
220
elif os.WIFSIGNALED(condition):
221
self.logger('Checker for client %s (command "%s")'
222
' was killed by signal %s'
223
% (self.properties["Name"], command,
224
os.WTERMSIG(condition)))
225
elif os.WCOREDUMP(condition):
226
self.logger('Checker for client %s (command "%s")'
228
% (self.properties["Name"], command))
230
self.logger('Checker for client %s completed'
234
def checker_started(self, command):
235
#self.logger('Client %s started checker "%s"'
236
# % (self.properties["Name"], unicode(command)))
239
def got_secret(self):
240
self.last_checker_failed = False
241
self.logger('Client %s received its secret'
242
% self.properties["Name"])
244
def need_approval(self, timeout, default):
246
message = 'Client %s needs approval within %s seconds'
248
message = 'Client %s will get its secret in %s seconds'
250
% (self.properties["Name"], timeout/1000))
251
self.using_timer(True)
253
def rejected(self, reason):
254
self.logger('Client %s was rejected; reason: %s'
255
% (self.properties["Name"], reason))
131
257
def selectable(self):
132
258
"""Make this a "selectable" widget.
133
259
This overrides the method from urwid.FlowWidget."""
136
def rows(self, (maxcol,), focus=False):
262
def rows(self, maxcolrow, focus=False):
137
263
"""How many rows this widget will occupy might depend on
138
264
whether we have focus or not.
139
265
This overrides the method from urwid.FlowWidget"""
140
return self.current_widget(focus).rows((maxcol,), focus=focus)
266
return self.current_widget(focus).rows(maxcolrow, focus=focus)
142
268
def current_widget(self, focus=False):
143
269
if focus or self.opened:
147
273
def update(self):
148
274
"Called when what is visible on the screen should be updated."
149
275
# How to add standout mode to a style
150
with_standout = { u"normal": u"standout",
151
u"bold": u"bold-standout",
153
u"underline-blink-standout",
154
u"bold-underline-blink":
155
u"bold-underline-blink-standout",
276
with_standout = { "normal": "standout",
277
"bold": "bold-standout",
279
"underline-blink-standout",
280
"bold-underline-blink":
281
"bold-underline-blink-standout",
158
284
# Rebuild focus and non-focus widgets using current properties
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
286
# Base part of a client. Name!
288
% {"name": self.properties["Name"]})
289
if not self.properties["Enabled"]:
291
elif self.properties["ApprovalPending"]:
292
timeout = datetime.timedelta(milliseconds
295
last_approval_request = isoformat_to_datetime(
296
self.properties["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["ApprovedByDefault"]:
303
message = "Approval in %s. (d)eny?"
305
message = "Denial in %s. (a)pprove?"
306
message = message % unicode(timer).rsplit(".", 1)[0]
307
elif self.last_checker_failed:
308
timeout = datetime.timedelta(milliseconds
311
last_ok = isoformat_to_datetime(
312
max((self.properties["LastCheckedOK"]
313
or self.properties["Created"]),
314
self.properties["LastEnabled"]))
315
timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
message = ('A checker has failed! Time until client'
318
% unicode(timer).rsplit(".", 1)[0])
321
self._text = "%s%s" % (base, message)
161
323
if not urwid.supports_unicode():
162
324
self._text = self._text.encode("ascii", "replace")
163
textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]
325
textlist = [("normal", self._text)]
164
326
self._text_widget.set_text(textlist)
165
327
self._focus_text_widget.set_text([(with_standout[text[0]],
174
336
if self.update_hook is not None:
175
337
self.update_hook()
339
def update_timer(self):
342
return True # Keep calling this
177
344
def delete(self):
345
if self._update_timer_callback_tag is not None:
346
gobject.source_remove(self._update_timer_callback_tag)
347
self._update_timer_callback_tag = None
178
348
if self.delete_hook is not None:
179
349
self.delete_hook(self)
181
def render(self, (maxcol,), focus=False):
351
def render(self, maxcolrow, focus=False):
182
352
"""Render differently if we have focus.
183
353
This overrides the method from urwid.FlowWidget"""
184
return self.current_widget(focus).render((maxcol,),
354
return self.current_widget(focus).render(maxcolrow,
187
def keypress(self, (maxcol,), key):
357
def keypress(self, maxcolrow, key):
189
359
This overrides the method from urwid.FlowWidget"""
190
if key == u"e" or key == u"+":
192
elif key == u"d" or key == u"-":
194
elif key == u"r" or key == u"_":
361
self.proxy.Enable(dbus_interface = client_interface,
364
self.proxy.Disable(dbus_interface = client_interface,
367
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
368
dbus_interface = client_interface,
371
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
372
dbus_interface = client_interface,
374
elif key == "R" or key == "_" or key == "ctrl k":
195
375
self.server_proxy_object.RemoveClient(self.proxy
198
self.proxy.StartChecker()
200
self.proxy.StopChecker()
202
self.proxy.CheckedOK()
379
self.proxy.StartChecker(dbus_interface = client_interface,
382
self.proxy.StopChecker(dbus_interface = client_interface,
385
self.proxy.CheckedOK(dbus_interface = client_interface,
204
# elif key == u"p" or key == "=":
388
# elif key == "p" or key == "=":
205
389
# self.proxy.pause()
206
# elif key == u"u" or key == ":":
390
# elif key == "u" or key == ":":
207
391
# self.proxy.unpause()
208
# elif key == u"RET":
409
class ConstrainedListBox(urwid.ListBox):
410
"""Like a normal urwid.ListBox, but will consume all "up" or
411
"down" key presses, thus not allowing any containing widgets to
412
use them as an excuse to shift focus away from this widget.
414
def keypress(self, maxcolrow, key):
415
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
416
if ret in ("up", "down"):
225
421
class UserInterface(object):
226
422
"""This is the entire user interface - the whole screen
227
423
with boxes, lists of client widgets, etc.
230
DBusGMainLoop(set_as_default=True )
425
def __init__(self, max_log_length=1000):
426
DBusGMainLoop(set_as_default=True)
232
428
self.screen = urwid.curses_display.Screen()
234
430
self.screen.register_palette((
236
u"default", u"default", None),
238
u"default", u"default", u"bold"),
240
u"default", u"default", u"underline"),
242
u"default", u"default", u"standout"),
243
(u"bold-underline-blink",
244
u"default", u"default", (u"bold", u"underline")),
246
u"default", u"default", (u"bold", u"standout")),
247
(u"underline-blink-standout",
248
u"default", u"default", (u"underline", u"standout")),
249
(u"bold-underline-blink-standout",
250
u"default", u"default", (u"bold", u"underline",
432
"default", "default", None),
434
"default", "default", "bold"),
436
"default", "default", "underline"),
438
"default", "default", "standout"),
439
("bold-underline-blink",
440
"default", "default", ("bold", "underline")),
442
"default", "default", ("bold", "standout")),
443
("underline-blink-standout",
444
"default", "default", ("underline", "standout")),
445
("bold-underline-blink-standout",
446
"default", "default", ("bold", "underline",
450
if urwid.supports_unicode():
451
self.divider = "─" # \u2500
452
#self.divider = "━" # \u2501
454
#self.divider = "-" # \u002d
455
self.divider = "_" # \u005f
254
457
self.screen.start()
256
459
self.size = self.screen.get_cols_rows()
258
461
self.clients = urwid.SimpleListWalker([])
259
462
self.clients_dict = {}
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
464
# We will add Text widgets to this list
466
self.max_log_length = max_log_length
468
# We keep a reference to the log widget so we can remove it
469
# from the ListWalker without it getting destroyed
470
self.logbox = ConstrainedListBox(self.log)
472
# This keeps track of whether self.uilist currently has
473
# self.logbox in it or not
474
self.log_visible = True
475
self.log_wrap = "any"
478
self.log_message_raw(("bold",
479
"Mandos Monitor version " + version))
480
self.log_message_raw(("bold",
263
483
self.busname = domain + '.Mandos'
264
484
self.main_loop = gobject.MainLoop()
265
485
self.bus = dbus.SystemBus()
266
486
mandos_dbus_objc = self.bus.get_object(
267
self.busname, u"/", follow_name_owner_changes=True)
487
self.busname, "/", follow_name_owner_changes=True)
268
488
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
270
490
= server_interface)
298
=self.remove_client),
528
def client_not_found(self, fingerprint, address):
529
self.log_message(("Client with address %s and fingerprint %s"
530
" could not be found" % (address,
534
"""This rebuilds the User Interface.
535
Call this when the widget layout needs to change"""
537
#self.uilist.append(urwid.ListBox(self.clients))
538
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
540
#header=urwid.Divider(),
543
urwid.Divider(div_char=
546
self.uilist.append(self.logbox)
548
self.topwidget = urwid.Pile(self.uilist)
550
def log_message(self, message):
551
timestamp = datetime.datetime.now().isoformat()
552
self.log_message_raw(timestamp + ": " + message)
554
def log_message_raw(self, markup):
555
"""Add a log message to the log buffer."""
556
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
557
if (self.max_log_length
558
and len(self.log) > self.max_log_length):
559
del self.log[0:len(self.log)-self.max_log_length-1]
560
self.logbox.set_focus(len(self.logbox.body.contents),
564
def toggle_log_display(self):
565
"""Toggle visibility of the log buffer."""
566
self.log_visible = not self.log_visible
568
#self.log_message("Log visibility changed to: "
569
# + unicode(self.log_visible))
571
def change_log_display(self):
572
"""Change type of log display.
573
Currently, this toggles wrapping of text lines."""
574
if self.log_wrap == "clip":
575
self.log_wrap = "any"
577
self.log_wrap = "clip"
578
for textwidget in self.log:
579
textwidget.set_wrap_mode(self.log_wrap)
580
#self.log_message("Wrap mode: " + self.log_wrap)
301
582
def find_and_remove_client(self, path, name):
302
583
"""Find an client from its object path and remove it.
369
663
except KeyError: # :-)
372
if key == u"q" or key == u"Q":
666
if key == "q" or key == "Q":
375
elif key == u"window resize":
669
elif key == "window resize":
376
670
self.size = self.screen.get_cols_rows()
672
elif key == "\f": # Ctrl-L
674
elif key == "l" or key == "D":
675
self.toggle_log_display()
677
elif key == "w" or key == "i":
678
self.change_log_display()
680
elif key == "?" or key == "f1" or key == "esc":
681
if not self.log_visible:
682
self.log_visible = True
684
self.log_message_raw(("bold",
688
"l: Log window toggle",
689
"TAB: Switch window",
691
self.log_message_raw(("bold",
697
"s: Start new checker",
704
if self.topwidget.get_focus() is self.logbox:
705
self.topwidget.set_focus(0)
707
self.topwidget.set_focus(self.logbox)
709
#elif (key == "end" or key == "meta >" or key == "G"
711
# pass # xxx end-of-buffer
712
#elif (key == "home" or key == "meta <" or key == "g"
714
# pass # xxx beginning-of-buffer
715
#elif key == "ctrl e" or key == "$":
716
# pass # xxx move-end-of-line
717
#elif key == "ctrl a" or key == "^":
718
# pass # xxx move-beginning-of-line
719
#elif key == "ctrl b" or key == "meta (" or key == "h":
721
#elif key == "ctrl f" or key == "meta )" or key == "l":
724
# pass # scroll up log
726
# pass # scroll down log
380
727
elif self.topwidget.selectable():
381
728
self.topwidget.keypress(self.size, key)