2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2015 Teddy Hogeborn
7
# Copyright © 2009-2015 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>.
4
from __future__ import division, absolute_import, with_statement
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
15
41
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
24
locale.setlocale(locale.LC_ALL, u'')
51
if sys.version_info.major == 2:
54
locale.setlocale(locale.LC_ALL, '')
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
26
59
# Some useful constants
27
domain = 'se.bsnet.fukt'
60
domain = 'se.recompile'
28
61
server_interface = domain + '.Mandos'
29
62
client_interface = domain + '.Mandos.Client'
32
# Always run in monochrome mode
33
urwid.curses_display.curses.has_colors = lambda : False
35
# Urwid doesn't support blinking, but we want it. Since we have no
36
# use for underline on its own, we make underline also always blink.
37
urwid.curses_display.curses.A_UNDERLINE |= (
38
urwid.curses_display.curses.A_BLINK)
65
def isoformat_to_datetime(iso):
66
"Parse an ISO 8601 date string to a datetime.datetime()"
69
d, t = iso.split("T", 1)
70
year, month, day = d.split("-", 2)
71
hour, minute, second = t.split(":", 2)
72
second, fraction = divmod(float(second), 1)
73
return datetime.datetime(int(year),
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
40
81
class MandosClientPropertyCache(object):
41
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
42
83
properties and calls a hook function when any of them are
45
def __init__(self, proxy_object=None, *args, **kwargs):
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
46
87
self.proxy = proxy_object # Mandos Client proxy object
48
self.properties = dict()
49
self.proxy.connect_to_signal(u"PropertyChanged",
50
self.property_changed,
54
self.properties.update(
55
self.proxy.GetAll(client_interface,
56
dbus_interface = dbus.PROPERTIES_IFACE))
57
super(MandosClientPropertyCache, self).__init__(
58
proxy_object=proxy_object, *args, **kwargs)
88
self.properties = dict() if properties is None else properties
89
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertiesChanged",
91
self.properties_changed,
92
dbus.PROPERTIES_IFACE,
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
99
= dbus.PROPERTIES_IFACE))
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
60
def property_changed(self, property=None, value=None):
61
"""This is called whenever we get a PropertyChanged signal
62
It updates the changed property in the "properties" dict.
103
def properties_changed(self, interface, properties, invalidated):
104
"""This is called whenever we get a PropertiesChanged signal
105
It updates the changed properties in the "properties" dict.
64
107
# Update properties dict with new value
65
self.properties[property] = value
108
self.properties.update(properties)
111
self.property_changed_match.remove()
68
114
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
81
127
self.logger = logger
129
self._update_timer_callback_tag = None
83
131
# The widget shown normally
84
self._text_widget = urwid.Text(u"")
132
self._text_widget = urwid.Text("")
85
133
# The widget shown when we have focus
86
self._focus_text_widget = urwid.Text(u"")
87
super(MandosClientWidget, self).__init__(
88
update_hook=update_hook, delete_hook=delete_hook,
134
self._focus_text_widget = urwid.Text("")
135
super(MandosClientWidget, self).__init__(**kwargs)
91
137
self.opened = False
92
self.proxy.connect_to_signal(u"CheckerCompleted",
93
self.checker_completed,
96
self.proxy.connect_to_signal(u"CheckerStarted",
100
self.proxy.connect_to_signal(u"GotSecret",
104
self.proxy.connect_to_signal(u"Rejected",
139
self.match_objects = (
140
self.proxy.connect_to_signal("CheckerCompleted",
141
self.checker_completed,
144
self.proxy.connect_to_signal("CheckerStarted",
145
self.checker_started,
148
self.proxy.connect_to_signal("GotSecret",
152
self.proxy.connect_to_signal("NeedApproval",
156
self.proxy.connect_to_signal("Rejected",
160
self.logger('Created client {}'
161
.format(self.properties["Name"]), level=0)
163
def using_timer(self, flag):
164
"""Call this method with True or False when timer should be
165
activated or deactivated.
167
if flag and self._update_timer_callback_tag is None:
168
# Will update the shown timer value every second
169
self._update_timer_callback_tag = (gobject.timeout_add
172
elif not (flag or self._update_timer_callback_tag is None):
173
gobject.source_remove(self._update_timer_callback_tag)
174
self._update_timer_callback_tag = None
109
176
def checker_completed(self, exitstatus, condition, command):
110
177
if exitstatus == 0:
111
self.logger(u'Checker for client %s (command "%s")'
113
% (self.properties[u"name"], command))
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
115
184
if os.WIFEXITED(condition):
116
self.logger(u'Checker for client %s (command "%s")'
117
u' failed with exit code %s'
118
% (self.properties[u"name"], command,
119
os.WEXITSTATUS(condition)))
121
if os.WIFSIGNALED(condition):
122
self.logger(u'Checker for client %s (command "%s")'
123
u' was killed by signal %s'
124
% (self.properties[u"name"], command,
125
os.WTERMSIG(condition)))
127
if os.WCOREDUMP(condition):
128
self.logger(u'Checker for client %s (command "%s")'
130
% (self.properties[u"name"], command))
131
self.logger(u'Checker for client %s completed mysteriously')
185
self.logger('Checker for client {} (command "{}") failed'
187
.format(self.properties["Name"], command,
188
os.WEXITSTATUS(condition)))
189
elif os.WIFSIGNALED(condition):
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
193
os.WTERMSIG(condition)))
133
196
def checker_started(self, command):
134
self.logger(u'Client %s started checker "%s"'
135
% (self.properties[u"name"], unicode(command)))
197
"""Server signals that a checker started."""
198
self.logger('Client {} started checker "{}"'
199
.format(self.properties["Name"],
137
202
def got_secret(self):
138
self.logger(u'Client %s received its secret'
139
% self.properties[u"name"])
142
self.logger(u'Client %s was rejected'
143
% self.properties[u"name"])
203
self.logger('Client {} received its secret'
204
.format(self.properties["Name"]))
206
def need_approval(self, timeout, default):
208
message = 'Client {} needs approval within {} seconds'
210
message = 'Client {} will get its secret in {} seconds'
211
self.logger(message.format(self.properties["Name"],
214
def rejected(self, reason):
215
self.logger('Client {} was rejected; reason: {}'
216
.format(self.properties["Name"], reason))
145
218
def selectable(self):
146
219
"""Make this a "selectable" widget.
147
220
This overrides the method from urwid.FlowWidget."""
150
def rows(self, (maxcol,), focus=False):
223
def rows(self, maxcolrow, focus=False):
151
224
"""How many rows this widget will occupy might depend on
152
225
whether we have focus or not.
153
226
This overrides the method from urwid.FlowWidget"""
154
return self.current_widget(focus).rows((maxcol,), focus=focus)
227
return self.current_widget(focus).rows(maxcolrow, focus=focus)
156
229
def current_widget(self, focus=False):
157
230
if focus or self.opened:
161
234
def update(self):
162
235
"Called when what is visible on the screen should be updated."
163
236
# How to add standout mode to a style
164
with_standout = { u"normal": u"standout",
165
u"bold": u"bold-standout",
167
u"underline-blink-standout",
168
u"bold-underline-blink":
169
u"bold-underline-blink-standout",
237
with_standout = { "normal": "standout",
238
"bold": "bold-standout",
240
"underline-blink-standout",
241
"bold-underline-blink":
242
"bold-underline-blink-standout",
172
245
# Rebuild focus and non-focus widgets using current properties
173
self._text = (u'%(name)s: %(enabled)s'
174
% { u"name": self.properties[u"name"],
177
if self.properties[u"enabled"]
247
# Base part of a client. Name!
248
base = '{name}: '.format(name=self.properties["Name"])
249
if not self.properties["Enabled"]:
251
self.using_timer(False)
252
elif self.properties["ApprovalPending"]:
253
timeout = datetime.timedelta(milliseconds
256
last_approval_request = isoformat_to_datetime(
257
self.properties["LastApprovalRequest"])
258
if last_approval_request is not None:
259
timer = max(timeout - (datetime.datetime.utcnow()
260
- last_approval_request),
261
datetime.timedelta())
263
timer = datetime.timedelta()
264
if self.properties["ApprovedByDefault"]:
265
message = "Approval in {}. (d)eny?"
267
message = "Denial in {}. (a)pprove?"
268
message = message.format(str(timer).rsplit(".", 1)[0])
269
self.using_timer(True)
270
elif self.properties["LastCheckerStatus"] != 0:
271
# When checker has failed, show timer until client expires
272
expires = self.properties["Expires"]
274
timer = datetime.timedelta(0)
276
expires = (datetime.datetime.strptime
277
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
278
timer = max(expires - datetime.datetime.utcnow(),
279
datetime.timedelta())
280
message = ('A checker has failed! Time until client'
282
.format(str(timer).rsplit(".", 1)[0]))
283
self.using_timer(True)
286
self.using_timer(False)
287
self._text = "{}{}".format(base, message)
179
289
if not urwid.supports_unicode():
180
290
self._text = self._text.encode("ascii", "replace")
181
textlist = [(u"normal", self._text)]
291
textlist = [("normal", self._text)]
182
292
self._text_widget.set_text(textlist)
183
293
self._focus_text_widget.set_text([(with_standout[text[0]],
192
302
if self.update_hook is not None:
193
303
self.update_hook()
305
def update_timer(self):
306
"""called by gobject. Will indefinitely loop until
307
gobject.source_remove() on tag is called"""
309
return True # Keep calling this
311
def delete(self, **kwargs):
312
if self._update_timer_callback_tag is not None:
313
gobject.source_remove(self._update_timer_callback_tag)
314
self._update_timer_callback_tag = None
315
for match in self.match_objects:
317
self.match_objects = ()
196
318
if self.delete_hook is not None:
197
319
self.delete_hook(self)
320
return super(MandosClientWidget, self).delete(**kwargs)
199
def render(self, (maxcol,), focus=False):
322
def render(self, maxcolrow, focus=False):
200
323
"""Render differently if we have focus.
201
324
This overrides the method from urwid.FlowWidget"""
202
return self.current_widget(focus).render((maxcol,),
325
return self.current_widget(focus).render(maxcolrow,
205
def keypress(self, (maxcol,), key):
328
def keypress(self, maxcolrow, key):
207
330
This overrides the method from urwid.FlowWidget"""
208
if key == u"e" or key == u"+":
210
elif key == u"d" or key == u"-":
212
elif key == u"r" or key == u"_" or key == u"ctrl k":
332
self.proxy.Set(client_interface, "Enabled",
333
dbus.Boolean(True), ignore_reply = True,
334
dbus_interface = dbus.PROPERTIES_IFACE)
336
self.proxy.Set(client_interface, "Enabled", False,
338
dbus_interface = dbus.PROPERTIES_IFACE)
340
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
341
dbus_interface = client_interface,
344
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
345
dbus_interface = client_interface,
347
elif key == "R" or key == "_" or key == "ctrl k":
213
348
self.server_proxy_object.RemoveClient(self.proxy
216
self.proxy.StartChecker()
218
self.proxy.StopChecker()
220
self.proxy.CheckedOK()
352
self.proxy.Set(client_interface, "CheckerRunning",
353
dbus.Boolean(True), ignore_reply = True,
354
dbus_interface = dbus.PROPERTIES_IFACE)
356
self.proxy.Set(client_interface, "CheckerRunning",
357
dbus.Boolean(False), ignore_reply = True,
358
dbus_interface = dbus.PROPERTIES_IFACE)
360
self.proxy.CheckedOK(dbus_interface = client_interface,
222
# elif key == u"p" or key == "=":
363
# elif key == "p" or key == "=":
223
364
# self.proxy.pause()
224
# elif key == u"u" or key == ":":
365
# elif key == "u" or key == ":":
225
366
# self.proxy.unpause()
226
# elif key == u"RET":
231
def property_changed(self, property=None, value=None,
233
"""Call self.update() if old value is not new value.
372
def properties_changed(self, interface, properties, invalidated):
373
"""Call self.update() if any properties changed.
234
374
This overrides the method from MandosClientPropertyCache"""
235
property_name = unicode(property)
236
old_value = self.properties.get(property_name)
237
super(MandosClientWidget, self).property_changed(
238
property=property, value=value, *args, **kwargs)
239
if self.properties.get(property_name) != old_value:
375
old_values = { key: self.properties.get(key)
376
for key in properties.keys() }
377
super(MandosClientWidget, self).properties_changed(
378
interface, properties, invalidated)
379
if any(old_values[key] != self.properties.get(key)
380
for key in old_values):
256
397
"""This is the entire user interface - the whole screen
257
398
with boxes, lists of client widgets, etc.
259
def __init__(self, max_log_length=1000):
400
def __init__(self, max_log_length=1000, log_level=1):
260
401
DBusGMainLoop(set_as_default=True)
262
403
self.screen = urwid.curses_display.Screen()
264
405
self.screen.register_palette((
266
u"default", u"default", None),
268
u"default", u"default", u"bold"),
270
u"default", u"default", u"underline"),
272
u"default", u"default", u"standout"),
273
(u"bold-underline-blink",
274
u"default", u"default", (u"bold", u"underline")),
276
u"default", u"default", (u"bold", u"standout")),
277
(u"underline-blink-standout",
278
u"default", u"default", (u"underline", u"standout")),
279
(u"bold-underline-blink-standout",
280
u"default", u"default", (u"bold", u"underline",
407
"default", "default", None),
409
"bold", "default", "bold"),
411
"underline,blink", "default", "underline,blink"),
413
"standout", "default", "standout"),
414
("bold-underline-blink",
415
"bold,underline,blink", "default", "bold,underline,blink"),
417
"bold,standout", "default", "bold,standout"),
418
("underline-blink-standout",
419
"underline,blink,standout", "default",
420
"underline,blink,standout"),
421
("bold-underline-blink-standout",
422
"bold,underline,blink,standout", "default",
423
"bold,underline,blink,standout"),
284
426
if urwid.supports_unicode():
285
self.divider = u"─" # \u2500
286
#self.divider = u"━" # \u2501
427
self.divider = "─" # \u2500
428
#self.divider = "━" # \u2501
288
#self.divider = u"-" # \u002d
289
self.divider = u"_" # \u005f
430
#self.divider = "-" # \u002d
431
self.divider = "_" # \u005f
291
433
self.screen.start()
306
450
# This keeps track of whether self.uilist currently has
307
451
# self.logbox in it or not
308
452
self.log_visible = True
309
self.log_wrap = u"any"
453
self.log_wrap = "any"
312
self.log_message_raw((u"bold",
313
u"Mandos Monitor version " + version))
314
self.log_message_raw((u"bold",
456
self.log_message_raw(("bold",
457
"Mandos Monitor version " + version))
458
self.log_message_raw(("bold",
317
461
self.busname = domain + '.Mandos'
318
462
self.main_loop = gobject.MainLoop()
319
self.bus = dbus.SystemBus()
320
mandos_dbus_objc = self.bus.get_object(
321
self.busname, u"/", follow_name_owner_changes=True)
322
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
326
mandos_clients = (self.mandos_serv
327
.GetAllClientsWithProperties())
328
except dbus.exceptions.DBusException:
329
mandos_clients = dbus.Dictionary()
332
.connect_to_signal(u"ClientRemoved",
333
self.find_and_remove_client,
334
dbus_interface=server_interface,
337
.connect_to_signal(u"ClientAdded",
339
dbus_interface=server_interface,
342
.connect_to_signal(u"ClientNotFound",
343
self.client_not_found,
344
dbus_interface=server_interface,
346
for path, client in mandos_clients.iteritems():
347
client_proxy_object = self.bus.get_object(self.busname,
349
self.add_client(MandosClientWidget(server_proxy_object
352
=client_proxy_object,
362
464
def client_not_found(self, fingerprint, address):
363
self.log_message((u"Client with address %s and fingerprint %s"
364
u" could not be found" % (address,
465
self.log_message("Client with address {} and fingerprint {}"
466
" could not be found"
467
.format(address, fingerprint))
367
469
def rebuild(self):
368
470
"""This rebuilds the User Interface.
369
471
Call this when the widget layout needs to change"""
371
473
#self.uilist.append(urwid.ListBox(self.clients))
372
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
474
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
373
476
#header=urwid.Divider(),
375
footer=urwid.Divider(div_char=self.divider)))
479
urwid.Divider(div_char=
376
481
if self.log_visible:
377
482
self.uilist.append(self.logbox)
379
483
self.topwidget = urwid.Pile(self.uilist)
381
def log_message(self, message):
485
def log_message(self, message, level=1):
486
"""Log message formatted with timestamp"""
487
if level < self.log_level:
382
489
timestamp = datetime.datetime.now().isoformat()
383
self.log_message_raw(timestamp + u": " + message)
490
self.log_message_raw("{}: {}".format(timestamp, message),
385
def log_message_raw(self, markup):
493
def log_message_raw(self, markup, level=1):
386
494
"""Add a log message to the log buffer."""
495
if level < self.log_level:
387
497
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
388
498
if (self.max_log_length
389
499
and len(self.log) > self.max_log_length):
390
500
del self.log[0:len(self.log)-self.max_log_length-1]
391
501
self.logbox.set_focus(len(self.logbox.body.contents),
392
coming_from=u"above")
395
505
def toggle_log_display(self):
396
506
"""Toggle visibility of the log buffer."""
397
507
self.log_visible = not self.log_visible
399
self.log_message(u"Log visibility changed to: "
400
+ unicode(self.log_visible))
509
self.log_message("Log visibility changed to: {}"
510
.format(self.log_visible), level=0)
402
512
def change_log_display(self):
403
513
"""Change type of log display.
404
514
Currently, this toggles wrapping of text lines."""
405
if self.log_wrap == u"clip":
406
self.log_wrap = u"any"
515
if self.log_wrap == "clip":
516
self.log_wrap = "any"
408
self.log_wrap = u"clip"
518
self.log_wrap = "clip"
409
519
for textwidget in self.log:
410
520
textwidget.set_wrap_mode(self.log_wrap)
411
self.log_message(u"Wrap mode: " + self.log_wrap)
521
self.log_message("Wrap mode: {}".format(self.log_wrap),
413
524
def find_and_remove_client(self, path, name):
414
"""Find an client from its object path and remove it.
525
"""Find a client by its object path and remove it.
416
527
This is connected to the ClientRemoved signal from the
417
528
Mandos server object."""
465
573
"""Start the main loop and exit when it's done."""
574
self.bus = dbus.SystemBus()
575
mandos_dbus_objc = self.bus.get_object(
576
self.busname, "/", follow_name_owner_changes=True)
577
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
581
mandos_clients = (self.mandos_serv
582
.GetAllClientsWithProperties())
583
if not mandos_clients:
584
self.log_message_raw(("bold", "Note: Server has no clients."))
585
except dbus.exceptions.DBusException:
586
self.log_message_raw(("bold", "Note: No Mandos server running."))
587
mandos_clients = dbus.Dictionary()
590
.connect_to_signal("ClientRemoved",
591
self.find_and_remove_client,
592
dbus_interface=server_interface,
595
.connect_to_signal("ClientAdded",
597
dbus_interface=server_interface,
600
.connect_to_signal("ClientNotFound",
601
self.client_not_found,
602
dbus_interface=server_interface,
604
for path, client in mandos_clients.items():
605
client_proxy_object = self.bus.get_object(self.busname,
607
self.add_client(MandosClientWidget(server_proxy_object
610
=client_proxy_object,
467
621
self._input_callback_tag = (gobject.io_add_watch
468
622
(sys.stdin.fileno(),
494
648
except KeyError: # :-)
497
if key == u"q" or key == u"Q":
651
if key == "q" or key == "Q":
500
elif key == u"window resize":
654
elif key == "window resize":
501
655
self.size = self.screen.get_cols_rows()
503
elif key == u"\f": # Ctrl-L
657
elif key == "ctrl l":
505
elif key == u"l" or key == u"D":
660
elif key == "l" or key == "D":
506
661
self.toggle_log_display()
508
elif key == u"w" or key == u"i":
663
elif key == "w" or key == "i":
509
664
self.change_log_display()
511
elif key == u"?" or key == u"f1" or key == u"esc":
666
elif key == "?" or key == "f1" or key == "esc":
512
667
if not self.log_visible:
513
668
self.log_visible = True
515
self.log_message_raw((u"bold",
519
u"l: Log window toggle",
520
u"TAB: Switch window",
522
self.log_message_raw((u"bold",
528
u"s: Start new checker",
670
self.log_message_raw(("bold",
674
"l: Log window toggle",
675
"TAB: Switch window",
676
"w: Wrap (log lines)",
677
"v: Toggle verbose log",
679
self.log_message_raw(("bold",
685
"s: Start new checker",
533
692
if self.topwidget.get_focus() is self.logbox:
534
693
self.topwidget.set_focus(0)
536
695
self.topwidget.set_focus(self.logbox)
538
#elif (key == u"end" or key == u"meta >" or key == u"G"
698
if self.log_level == 0:
700
self.log_message("Verbose mode: Off")
703
self.log_message("Verbose mode: On")
704
#elif (key == "end" or key == "meta >" or key == "G"
540
706
# pass # xxx end-of-buffer
541
#elif (key == u"home" or key == u"meta <" or key == u"g"
707
#elif (key == "home" or key == "meta <" or key == "g"
543
709
# pass # xxx beginning-of-buffer
544
#elif key == u"ctrl e" or key == u"$":
710
#elif key == "ctrl e" or key == "$":
545
711
# pass # xxx move-end-of-line
546
#elif key == u"ctrl a" or key == u"^":
712
#elif key == "ctrl a" or key == "^":
547
713
# pass # xxx move-beginning-of-line
548
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
714
#elif key == "ctrl b" or key == "meta (" or key == "h":
549
715
# pass # xxx left
550
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
716
#elif key == "ctrl f" or key == "meta )" or key == "l":
551
717
# pass # xxx right
553
719
# pass # scroll up log
555
721
# pass # scroll down log
556
722
elif self.topwidget.selectable():
557
723
self.topwidget.keypress(self.size, key)