2
2
# -*- mode: python; coding: utf-8 -*-
4
from __future__ import division, absolute_import, with_statement
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2012 Teddy Hogeborn
7
# Copyright © 2009-2012 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
21
# <http://www.gnu.org/licenses/>.
23
# Contact the authors at <mandos@recompile.se>.
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
40
65
urwid.curses_display.curses.A_UNDERLINE |= (
41
66
urwid.curses_display.curses.A_BLINK)
68
def isoformat_to_datetime(iso):
69
"Parse an ISO 8601 date string to a datetime.datetime()"
72
d, t = iso.split("T", 1)
73
year, month, day = d.split("-", 2)
74
hour, minute, second = t.split(":", 2)
75
second, fraction = divmod(float(second), 1)
76
return datetime.datetime(int(year),
81
int(second), # Whole seconds
82
int(fraction*1000000)) # Microseconds
43
84
class MandosClientPropertyCache(object):
44
85
"""This wraps a Mandos Client D-Bus proxy object, caches the
45
86
properties and calls a hook function when any of them are
48
def __init__(self, proxy_object=None, *args, **kwargs):
89
def __init__(self, proxy_object=None, properties=None, **kwargs):
49
90
self.proxy = proxy_object # Mandos Client proxy object
51
self.properties = dict()
52
self.proxy.connect_to_signal(u"PropertyChanged",
53
self.property_changed,
57
self.properties.update(
58
self.proxy.GetAll(client_interface,
59
dbus_interface = dbus.PROPERTIES_IFACE))
61
#XXX This break good super behaviour!
62
# super(MandosClientPropertyCache, self).__init__(
91
self.properties = dict() if properties is None else properties
92
self.property_changed_match = (
93
self.proxy.connect_to_signal("PropertyChanged",
94
self._property_changed,
98
if properties is None:
99
self.properties.update(
100
self.proxy.GetAll(client_interface,
102
= dbus.PROPERTIES_IFACE))
104
super(MandosClientPropertyCache, self).__init__(**kwargs)
106
def _property_changed(self, property, value):
107
"""Helper which takes positional arguments"""
108
return self.property_changed(property=property, value=value)
65
110
def property_changed(self, property=None, value=None):
66
111
"""This is called whenever we get a PropertyChanged signal
86
134
self.logger = logger
136
self._update_timer_callback_tag = None
88
138
# The widget shown normally
89
self._text_widget = urwid.Text(u"")
139
self._text_widget = urwid.Text("")
90
140
# The widget shown when we have focus
91
self._focus_text_widget = urwid.Text(u"")
92
super(MandosClientWidget, self).__init__(
93
update_hook=update_hook, delete_hook=delete_hook,
141
self._focus_text_widget = urwid.Text("")
142
super(MandosClientWidget, self).__init__(**kwargs)
96
144
self.opened = False
97
self.proxy.connect_to_signal(u"CheckerCompleted",
98
self.checker_completed,
101
self.proxy.connect_to_signal(u"CheckerStarted",
102
self.checker_started,
105
self.proxy.connect_to_signal(u"GotSecret",
109
self.proxy.connect_to_signal(u"NeedApproval",
113
self.proxy.connect_to_signal(u"Rejected",
146
self.match_objects = (
147
self.proxy.connect_to_signal("CheckerCompleted",
148
self.checker_completed,
151
self.proxy.connect_to_signal("CheckerStarted",
152
self.checker_started,
155
self.proxy.connect_to_signal("GotSecret",
159
self.proxy.connect_to_signal("NeedApproval",
163
self.proxy.connect_to_signal("Rejected",
167
#self.logger('Created client {0}'
168
# .format(self.properties["Name"]))
170
def using_timer(self, flag):
171
"""Call this method with True or False when timer should be
172
activated or deactivated.
174
if flag and self._update_timer_callback_tag is None:
175
# Will update the shown timer value every second
176
self._update_timer_callback_tag = (gobject.timeout_add
179
elif not (flag or self._update_timer_callback_tag is None):
180
gobject.source_remove(self._update_timer_callback_tag)
181
self._update_timer_callback_tag = None
118
183
def checker_completed(self, exitstatus, condition, command):
119
184
if exitstatus == 0:
120
#self.logger(u'Checker for client %s (command "%s")'
122
# % (self.properties[u"name"], command))
124
188
if os.WIFEXITED(condition):
125
self.logger(u'Checker for client %s (command "%s")'
126
u' failed with exit code %s'
127
% (self.properties[u"name"], command,
128
os.WEXITSTATUS(condition)))
130
if os.WIFSIGNALED(condition):
131
self.logger(u'Checker for client %s (command "%s")'
132
u' was killed by signal %s'
133
% (self.properties[u"name"], command,
134
os.WTERMSIG(condition)))
136
if os.WCOREDUMP(condition):
137
self.logger(u'Checker for client %s (command "%s")'
139
% (self.properties[u"name"], command))
140
self.logger(u'Checker for client %s completed mysteriously')
189
self.logger('Checker for client {0} (command "{1}")'
190
' failed with exit code {2}'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
193
elif os.WIFSIGNALED(condition):
194
self.logger('Checker for client {0} (command "{1}") was'
195
' killed by signal {2}'
196
.format(self.properties["Name"], command,
197
os.WTERMSIG(condition)))
198
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {0} (command "{1}")'
201
.format(self.properties["Name"], command))
203
self.logger('Checker for client {0} completed'
205
.format(self.properties["Name"]))
142
208
def checker_started(self, command):
143
#self.logger(u'Client %s started checker "%s"'
144
# % (self.properties[u"name"], unicode(command)))
209
"""Server signals that a checker started. This could be useful
210
to log in the future. """
211
#self.logger('Client {0} started checker "{1}"'
212
# .format(self.properties["Name"],
147
216
def got_secret(self):
148
self.logger(u'Client %s received its secret'
149
% self.properties[u"name"])
217
self.logger('Client {0} received its secret'
218
.format(self.properties["Name"]))
151
220
def need_approval(self, timeout, default):
153
message = u'Client %s needs approval within %s seconds'
222
message = 'Client {0} needs approval within {1} seconds'
155
message = u'Client %s will get its secret in %s seconds'
157
% (self.properties[u"name"], timeout/1000))
224
message = 'Client {0} will get its secret in {1} seconds'
225
self.logger(message.format(self.properties["Name"],
159
228
def rejected(self, reason):
160
self.logger(u'Client %s was rejected; reason: %s'
161
% (self.properties[u"name"], reason))
229
self.logger('Client {0} was rejected; reason: {1}'
230
.format(self.properties["Name"], reason))
163
232
def selectable(self):
164
233
"""Make this a "selectable" widget.
165
234
This overrides the method from urwid.FlowWidget."""
168
def rows(self, (maxcol,), focus=False):
237
def rows(self, maxcolrow, focus=False):
169
238
"""How many rows this widget will occupy might depend on
170
239
whether we have focus or not.
171
240
This overrides the method from urwid.FlowWidget"""
172
return self.current_widget(focus).rows((maxcol,), focus=focus)
241
return self.current_widget(focus).rows(maxcolrow, focus=focus)
174
243
def current_widget(self, focus=False):
175
244
if focus or self.opened:
179
248
def update(self):
180
249
"Called when what is visible on the screen should be updated."
181
250
# How to add standout mode to a style
182
with_standout = { u"normal": u"standout",
183
u"bold": u"bold-standout",
185
u"underline-blink-standout",
186
u"bold-underline-blink":
187
u"bold-underline-blink-standout",
251
with_standout = { "normal": "standout",
252
"bold": "bold-standout",
254
"underline-blink-standout",
255
"bold-underline-blink":
256
"bold-underline-blink-standout",
190
259
# Rebuild focus and non-focus widgets using current properties
192
261
# Base part of a client. Name!
193
self._text = (u'%(name)s: '
194
% {u"name": self.properties[u"name"]})
196
if self.properties[u"approved_pending"]:
197
if self.properties[u"approved_by_default"]:
198
self._text += u"Connection established to client. (d)eny?"
200
self._text += u"Seeks approval to send secret. (a)pprove?"
262
base = '{name}: '.format(name=self.properties["Name"])
263
if not self.properties["Enabled"]:
265
self.using_timer(False)
266
elif self.properties["ApprovalPending"]:
267
timeout = datetime.timedelta(milliseconds
270
last_approval_request = isoformat_to_datetime(
271
self.properties["LastApprovalRequest"])
272
if last_approval_request is not None:
273
timer = max(timeout - (datetime.datetime.utcnow()
274
- last_approval_request),
275
datetime.timedelta())
277
timer = datetime.timedelta()
278
if self.properties["ApprovedByDefault"]:
279
message = "Approval in {0}. (d)eny?"
281
message = "Denial in {0}. (a)pprove?"
282
message = message.format(unicode(timer).rsplit(".", 1)[0])
283
self.using_timer(True)
284
elif self.properties["LastCheckerStatus"] != 0:
285
# When checker has failed, show timer until client expires
286
expires = self.properties["Expires"]
288
timer = datetime.timedelta(0)
290
expires = (datetime.datetime.strptime
291
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
292
timer = max(expires - datetime.datetime.utcnow(),
293
datetime.timedelta())
294
message = ('A checker has failed! Time until client'
295
' gets disabled: {0}'
296
.format(unicode(timer).rsplit(".", 1)[0]))
297
self.using_timer(True)
202
self._text += (u'%(enabled)s'
205
if self.properties[u"enabled"]
300
self.using_timer(False)
301
self._text = "{0}{1}".format(base, message)
207
303
if not urwid.supports_unicode():
208
304
self._text = self._text.encode("ascii", "replace")
209
textlist = [(u"normal", self._text)]
305
textlist = [("normal", self._text)]
210
306
self._text_widget.set_text(textlist)
211
307
self._focus_text_widget.set_text([(with_standout[text[0]],
220
316
if self.update_hook is not None:
221
317
self.update_hook()
319
def update_timer(self):
320
"""called by gobject. Will indefinitely loop until
321
gobject.source_remove() on tag is called"""
323
return True # Keep calling this
325
def delete(self, **kwargs):
326
if self._update_timer_callback_tag is not None:
327
gobject.source_remove(self._update_timer_callback_tag)
328
self._update_timer_callback_tag = None
329
for match in self.match_objects:
331
self.match_objects = ()
224
332
if self.delete_hook is not None:
225
333
self.delete_hook(self)
334
return super(MandosClientWidget, self).delete(**kwargs)
227
def render(self, (maxcol,), focus=False):
336
def render(self, maxcolrow, focus=False):
228
337
"""Render differently if we have focus.
229
338
This overrides the method from urwid.FlowWidget"""
230
return self.current_widget(focus).render((maxcol,),
339
return self.current_widget(focus).render(maxcolrow,
233
def keypress(self, (maxcol,), key):
342
def keypress(self, maxcolrow, key):
235
344
This overrides the method from urwid.FlowWidget"""
237
self.proxy.Enable(dbus_interface = client_interface)
239
self.proxy.Disable(dbus_interface = client_interface)
346
self.proxy.Enable(dbus_interface = client_interface,
349
self.proxy.Disable(dbus_interface = client_interface,
241
352
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
242
dbus_interface = client_interface)
353
dbus_interface = client_interface,
244
356
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
245
dbus_interface = client_interface)
246
elif key == u"r" or key == u"_" or key == u"ctrl k":
357
dbus_interface = client_interface,
359
elif key == "R" or key == "_" or key == "ctrl k":
247
360
self.server_proxy_object.RemoveClient(self.proxy
250
self.proxy.StartChecker(dbus_interface = client_interface)
252
self.proxy.StopChecker(dbus_interface = client_interface)
254
self.proxy.CheckedOK(dbus_interface = client_interface)
364
self.proxy.StartChecker(dbus_interface = client_interface,
367
self.proxy.StopChecker(dbus_interface = client_interface,
370
self.proxy.CheckedOK(dbus_interface = client_interface,
256
# elif key == u"p" or key == "=":
373
# elif key == "p" or key == "=":
257
374
# self.proxy.pause()
258
# elif key == u"u" or key == ":":
375
# elif key == "u" or key == ":":
259
376
# self.proxy.unpause()
260
# elif key == u"RET":
263
# self.proxy.Approve(True)
265
# self.proxy.Approve(False)
269
def property_changed(self, property=None, value=None,
382
def property_changed(self, property=None, **kwargs):
271
383
"""Call self.update() if old value is not new value.
272
384
This overrides the method from MandosClientPropertyCache"""
273
385
property_name = unicode(property)
274
386
old_value = self.properties.get(property_name)
275
387
super(MandosClientWidget, self).property_changed(
276
property=property, value=value, *args, **kwargs)
388
property=property, **kwargs)
277
389
if self.properties.get(property_name) != old_value:
300
412
self.screen = urwid.curses_display.Screen()
302
414
self.screen.register_palette((
304
u"default", u"default", None),
306
u"default", u"default", u"bold"),
308
u"default", u"default", u"underline"),
310
u"default", u"default", u"standout"),
311
(u"bold-underline-blink",
312
u"default", u"default", (u"bold", u"underline")),
314
u"default", u"default", (u"bold", u"standout")),
315
(u"underline-blink-standout",
316
u"default", u"default", (u"underline", u"standout")),
317
(u"bold-underline-blink-standout",
318
u"default", u"default", (u"bold", u"underline",
416
"default", "default", None),
418
"default", "default", "bold"),
420
"default", "default", "underline"),
422
"default", "default", "standout"),
423
("bold-underline-blink",
424
"default", "default", ("bold", "underline")),
426
"default", "default", ("bold", "standout")),
427
("underline-blink-standout",
428
"default", "default", ("underline", "standout")),
429
("bold-underline-blink-standout",
430
"default", "default", ("bold", "underline",
322
434
if urwid.supports_unicode():
323
self.divider = u"─" # \u2500
324
#self.divider = u"━" # \u2501
435
self.divider = "─" # \u2500
436
#self.divider = "━" # \u2501
326
#self.divider = u"-" # \u002d
327
self.divider = u"_" # \u005f
438
#self.divider = "-" # \u002d
439
self.divider = "_" # \u005f
329
441
self.screen.start()
344
456
# This keeps track of whether self.uilist currently has
345
457
# self.logbox in it or not
346
458
self.log_visible = True
347
self.log_wrap = u"any"
459
self.log_wrap = "any"
350
self.log_message_raw((u"bold",
351
u"Mandos Monitor version " + version))
352
self.log_message_raw((u"bold",
462
self.log_message_raw(("bold",
463
"Mandos Monitor version " + version))
464
self.log_message_raw(("bold",
355
467
self.busname = domain + '.Mandos'
356
468
self.main_loop = gobject.MainLoop()
357
self.bus = dbus.SystemBus()
358
mandos_dbus_objc = self.bus.get_object(
359
self.busname, u"/", follow_name_owner_changes=True)
360
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
364
mandos_clients = (self.mandos_serv
365
.GetAllClientsWithProperties())
366
except dbus.exceptions.DBusException:
367
mandos_clients = dbus.Dictionary()
370
.connect_to_signal(u"ClientRemoved",
371
self.find_and_remove_client,
372
dbus_interface=server_interface,
375
.connect_to_signal(u"ClientAdded",
377
dbus_interface=server_interface,
380
.connect_to_signal(u"ClientNotFound",
381
self.client_not_found,
382
dbus_interface=server_interface,
384
for path, client in mandos_clients.iteritems():
385
client_proxy_object = self.bus.get_object(self.busname,
387
self.add_client(MandosClientWidget(server_proxy_object
390
=client_proxy_object,
400
470
def client_not_found(self, fingerprint, address):
401
self.log_message((u"Client with address %s and fingerprint %s"
402
u" could not be found" % (address,
471
self.log_message("Client with address {0} and fingerprint"
472
" {1} could not be found"
473
.format(address, fingerprint))
405
475
def rebuild(self):
406
476
"""This rebuilds the User Interface.
407
477
Call this when the widget layout needs to change"""
409
479
#self.uilist.append(urwid.ListBox(self.clients))
410
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
411
482
#header=urwid.Divider(),
413
footer=urwid.Divider(div_char=self.divider)))
485
urwid.Divider(div_char=
414
487
if self.log_visible:
415
488
self.uilist.append(self.logbox)
417
489
self.topwidget = urwid.Pile(self.uilist)
419
491
def log_message(self, message):
492
"""Log message formatted with timestamp"""
420
493
timestamp = datetime.datetime.now().isoformat()
421
self.log_message_raw(timestamp + u": " + message)
494
self.log_message_raw(timestamp + ": " + message)
423
496
def log_message_raw(self, markup):
424
497
"""Add a log message to the log buffer."""
427
500
and len(self.log) > self.max_log_length):
428
501
del self.log[0:len(self.log)-self.max_log_length-1]
429
502
self.logbox.set_focus(len(self.logbox.body.contents),
430
coming_from=u"above")
433
506
def toggle_log_display(self):
434
507
"""Toggle visibility of the log buffer."""
435
508
self.log_visible = not self.log_visible
437
self.log_message(u"Log visibility changed to: "
438
+ unicode(self.log_visible))
510
#self.log_message("Log visibility changed to: "
511
# + unicode(self.log_visible))
440
513
def change_log_display(self):
441
514
"""Change type of log display.
442
515
Currently, this toggles wrapping of text lines."""
443
if self.log_wrap == u"clip":
444
self.log_wrap = u"any"
516
if self.log_wrap == "clip":
517
self.log_wrap = "any"
446
self.log_wrap = u"clip"
519
self.log_wrap = "clip"
447
520
for textwidget in self.log:
448
521
textwidget.set_wrap_mode(self.log_wrap)
449
self.log_message(u"Wrap mode: " + self.log_wrap)
522
#self.log_message("Wrap mode: " + self.log_wrap)
451
524
def find_and_remove_client(self, path, name):
452
"""Find an client from its object path and remove it.
525
"""Find a client by its object path and remove it.
454
527
This is connected to the ClientRemoved signal from the
455
528
Mandos server object."""
503
578
"""Start the main loop and exit when it's done."""
579
self.bus = dbus.SystemBus()
580
mandos_dbus_objc = self.bus.get_object(
581
self.busname, "/", follow_name_owner_changes=True)
582
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
586
mandos_clients = (self.mandos_serv
587
.GetAllClientsWithProperties())
588
if not mandos_clients:
589
self.log_message_raw(("bold", "Note: Server has no clients."))
590
except dbus.exceptions.DBusException:
591
self.log_message_raw(("bold", "Note: No Mandos server running."))
592
mandos_clients = dbus.Dictionary()
595
.connect_to_signal("ClientRemoved",
596
self.find_and_remove_client,
597
dbus_interface=server_interface,
600
.connect_to_signal("ClientAdded",
602
dbus_interface=server_interface,
605
.connect_to_signal("ClientNotFound",
606
self.client_not_found,
607
dbus_interface=server_interface,
609
for path, client in mandos_clients.iteritems():
610
client_proxy_object = self.bus.get_object(self.busname,
612
self.add_client(MandosClientWidget(server_proxy_object
615
=client_proxy_object,
505
626
self._input_callback_tag = (gobject.io_add_watch
506
627
(sys.stdin.fileno(),
532
653
except KeyError: # :-)
535
if key == u"q" or key == u"Q":
656
if key == "q" or key == "Q":
538
elif key == u"window resize":
659
elif key == "window resize":
539
660
self.size = self.screen.get_cols_rows()
541
elif key == u"\f": # Ctrl-L
662
elif key == "\f": # Ctrl-L
543
elif key == u"l" or key == u"D":
664
elif key == "l" or key == "D":
544
665
self.toggle_log_display()
546
elif key == u"w" or key == u"i":
667
elif key == "w" or key == "i":
547
668
self.change_log_display()
549
elif key == u"?" or key == u"f1" or key == u"esc":
670
elif key == "?" or key == "f1" or key == "esc":
550
671
if not self.log_visible:
551
672
self.log_visible = True
553
self.log_message_raw((u"bold",
557
u"l: Log window toggle",
558
u"TAB: Switch window",
560
self.log_message_raw((u"bold",
566
u"s: Start new checker",
674
self.log_message_raw(("bold",
678
"l: Log window toggle",
679
"TAB: Switch window",
681
self.log_message_raw(("bold",
687
"s: Start new checker",
573
694
if self.topwidget.get_focus() is self.logbox:
574
695
self.topwidget.set_focus(0)
576
697
self.topwidget.set_focus(self.logbox)
578
#elif (key == u"end" or key == u"meta >" or key == u"G"
699
#elif (key == "end" or key == "meta >" or key == "G"
580
701
# pass # xxx end-of-buffer
581
#elif (key == u"home" or key == u"meta <" or key == u"g"
702
#elif (key == "home" or key == "meta <" or key == "g"
583
704
# pass # xxx beginning-of-buffer
584
#elif key == u"ctrl e" or key == u"$":
705
#elif key == "ctrl e" or key == "$":
585
706
# pass # xxx move-end-of-line
586
#elif key == u"ctrl a" or key == u"^":
707
#elif key == "ctrl a" or key == "^":
587
708
# pass # xxx move-beginning-of-line
588
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
709
#elif key == "ctrl b" or key == "meta (" or key == "h":
589
710
# pass # xxx left
590
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
711
#elif key == "ctrl f" or key == "meta )" or key == "l":
591
712
# pass # xxx right
593
714
# pass # scroll up log
595
716
# pass # scroll down log
596
717
elif self.topwidget.selectable():
597
718
self.topwidget.keypress(self.size, key)