2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 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 *
4
from __future__ import division, absolute_import, with_statement
41
15
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
51
if sys.version_info[0] == 2:
54
locale.setlocale(locale.LC_ALL, '')
24
locale.setlocale(locale.LC_ALL, u'')
57
27
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
59
29
# Some useful constants
60
domain = 'se.recompile'
30
domain = 'se.bsnet.fukt'
61
31
server_interface = domain + '.Mandos'
62
32
client_interface = domain + '.Mandos.Client'
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
35
# Always run in monochrome mode
36
urwid.curses_display.curses.has_colors = lambda : False
38
# Urwid doesn't support blinking, but we want it. Since we have no
39
# use for underline on its own, we make underline also always blink.
40
urwid.curses_display.curses.A_UNDERLINE |= (
41
urwid.curses_display.curses.A_BLINK)
81
43
class MandosClientPropertyCache(object):
82
44
"""This wraps a Mandos Client D-Bus proxy object, caches the
83
45
properties and calls a hook function when any of them are
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
48
def __init__(self, proxy_object=None, *args, **kwargs):
87
49
self.proxy = proxy_object # Mandos Client proxy object
88
self.properties = dict() if properties is None else properties
89
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertyChanged",
91
self._property_changed,
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)
103
def _property_changed(self, property, value):
104
"""Helper which takes positional arguments"""
105
return self.property_changed(property=property, value=value)
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))
60
super(MandosClientPropertyCache, self).__init__(
61
proxy_object=proxy_object, *args, **kwargs)
107
63
def property_changed(self, property=None, value=None):
108
64
"""This is called whenever we get a PropertyChanged signal
131
84
self.logger = logger
133
self._update_timer_callback_tag = None
135
86
# The widget shown normally
136
self._text_widget = urwid.Text("")
87
self._text_widget = urwid.Text(u"")
137
88
# The widget shown when we have focus
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
89
self._focus_text_widget = urwid.Text(u"")
90
super(MandosClientWidget, self).__init__(
91
update_hook=update_hook, delete_hook=delete_hook,
141
94
self.opened = False
143
self.match_objects = (
144
self.proxy.connect_to_signal("CheckerCompleted",
145
self.checker_completed,
148
self.proxy.connect_to_signal("CheckerStarted",
149
self.checker_started,
152
self.proxy.connect_to_signal("GotSecret",
156
self.proxy.connect_to_signal("NeedApproval",
160
self.proxy.connect_to_signal("Rejected",
164
#self.logger('Created client {0}'
165
# .format(self.properties["Name"]))
167
def using_timer(self, flag):
168
"""Call this method with True or False when timer should be
169
activated or deactivated.
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
173
self._update_timer_callback_tag = (gobject.timeout_add
176
elif not (flag or self._update_timer_callback_tag is None):
177
gobject.source_remove(self._update_timer_callback_tag)
178
self._update_timer_callback_tag = None
95
self.proxy.connect_to_signal(u"CheckerCompleted",
96
self.checker_completed,
99
self.proxy.connect_to_signal(u"CheckerStarted",
100
self.checker_started,
103
self.proxy.connect_to_signal(u"GotSecret",
107
self.proxy.connect_to_signal(u"Rejected",
180
112
def checker_completed(self, exitstatus, condition, command):
181
113
if exitstatus == 0:
114
self.logger(u'Checker for client %s (command "%s")'
116
% (self.properties[u"name"], command))
185
118
if os.WIFEXITED(condition):
186
self.logger('Checker for client {0} (command "{1}")'
187
' failed with exit code {2}'
188
.format(self.properties["Name"], command,
189
os.WEXITSTATUS(condition)))
190
elif os.WIFSIGNALED(condition):
191
self.logger('Checker for client {0} (command "{1}") was'
192
' killed by signal {2}'
193
.format(self.properties["Name"], command,
194
os.WTERMSIG(condition)))
195
elif os.WCOREDUMP(condition):
196
self.logger('Checker for client {0} (command "{1}")'
198
.format(self.properties["Name"], command))
200
self.logger('Checker for client {0} completed'
202
.format(self.properties["Name"]))
119
self.logger(u'Checker for client %s (command "%s")'
120
u' failed with exit code %s'
121
% (self.properties[u"name"], command,
122
os.WEXITSTATUS(condition)))
124
if os.WIFSIGNALED(condition):
125
self.logger(u'Checker for client %s (command "%s")'
126
u' was killed by signal %s'
127
% (self.properties[u"name"], command,
128
os.WTERMSIG(condition)))
130
if os.WCOREDUMP(condition):
131
self.logger(u'Checker for client %s (command "%s")'
133
% (self.properties[u"name"], command))
134
self.logger(u'Checker for client %s completed mysteriously')
205
136
def checker_started(self, command):
206
"""Server signals that a checker started. This could be useful
207
to log in the future. """
208
#self.logger('Client {0} started checker "{1}"'
209
# .format(self.properties["Name"],
137
self.logger(u'Client %s started checker "%s"'
138
% (self.properties[u"name"], unicode(command)))
213
140
def got_secret(self):
214
self.logger('Client {0} received its secret'
215
.format(self.properties["Name"]))
217
def need_approval(self, timeout, default):
219
message = 'Client {0} needs approval within {1} seconds'
221
message = 'Client {0} will get its secret in {1} seconds'
222
self.logger(message.format(self.properties["Name"],
225
def rejected(self, reason):
226
self.logger('Client {0} was rejected; reason: {1}'
227
.format(self.properties["Name"], reason))
141
self.logger(u'Client %s received its secret'
142
% self.properties[u"name"])
145
self.logger(u'Client %s was rejected'
146
% self.properties[u"name"])
229
148
def selectable(self):
230
149
"""Make this a "selectable" widget.
231
150
This overrides the method from urwid.FlowWidget."""
234
def rows(self, maxcolrow, focus=False):
153
def rows(self, (maxcol,), focus=False):
235
154
"""How many rows this widget will occupy might depend on
236
155
whether we have focus or not.
237
156
This overrides the method from urwid.FlowWidget"""
238
return self.current_widget(focus).rows(maxcolrow, focus=focus)
157
return self.current_widget(focus).rows((maxcol,), focus=focus)
240
159
def current_widget(self, focus=False):
241
160
if focus or self.opened:
245
164
def update(self):
246
165
"Called when what is visible on the screen should be updated."
247
166
# How to add standout mode to a style
248
with_standout = { "normal": "standout",
249
"bold": "bold-standout",
251
"underline-blink-standout",
252
"bold-underline-blink":
253
"bold-underline-blink-standout",
167
with_standout = { u"normal": u"standout",
168
u"bold": u"bold-standout",
170
u"underline-blink-standout",
171
u"bold-underline-blink":
172
u"bold-underline-blink-standout",
256
175
# Rebuild focus and non-focus widgets using current properties
258
# Base part of a client. Name!
259
base = '{name}: '.format(name=self.properties["Name"])
260
if not self.properties["Enabled"]:
262
self.using_timer(False)
263
elif self.properties["ApprovalPending"]:
264
timeout = datetime.timedelta(milliseconds
267
last_approval_request = isoformat_to_datetime(
268
self.properties["LastApprovalRequest"])
269
if last_approval_request is not None:
270
timer = max(timeout - (datetime.datetime.utcnow()
271
- last_approval_request),
272
datetime.timedelta())
274
timer = datetime.timedelta()
275
if self.properties["ApprovedByDefault"]:
276
message = "Approval in {0}. (d)eny?"
278
message = "Denial in {0}. (a)pprove?"
279
message = message.format(str(timer).rsplit(".", 1)[0])
280
self.using_timer(True)
281
elif self.properties["LastCheckerStatus"] != 0:
282
# When checker has failed, show timer until client expires
283
expires = self.properties["Expires"]
285
timer = datetime.timedelta(0)
287
expires = (datetime.datetime.strptime
288
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
289
timer = max(expires - datetime.datetime.utcnow(),
290
datetime.timedelta())
291
message = ('A checker has failed! Time until client'
292
' gets disabled: {0}'
293
.format(str(timer).rsplit(".", 1)[0]))
294
self.using_timer(True)
297
self.using_timer(False)
298
self._text = "{0}{1}".format(base, message)
176
self._text = (u'%(name)s: %(enabled)s'
177
% { u"name": self.properties[u"name"],
180
if self.properties[u"enabled"]
300
182
if not urwid.supports_unicode():
301
183
self._text = self._text.encode("ascii", "replace")
302
textlist = [("normal", self._text)]
184
textlist = [(u"normal", self._text)]
303
185
self._text_widget.set_text(textlist)
304
186
self._focus_text_widget.set_text([(with_standout[text[0]],
313
195
if self.update_hook is not None:
314
196
self.update_hook()
316
def update_timer(self):
317
"""called by gobject. Will indefinitely loop until
318
gobject.source_remove() on tag is called"""
320
return True # Keep calling this
322
def delete(self, **kwargs):
323
if self._update_timer_callback_tag is not None:
324
gobject.source_remove(self._update_timer_callback_tag)
325
self._update_timer_callback_tag = None
326
for match in self.match_objects:
328
self.match_objects = ()
329
199
if self.delete_hook is not None:
330
200
self.delete_hook(self)
331
return super(MandosClientWidget, self).delete(**kwargs)
333
def render(self, maxcolrow, focus=False):
202
def render(self, (maxcol,), focus=False):
334
203
"""Render differently if we have focus.
335
204
This overrides the method from urwid.FlowWidget"""
336
return self.current_widget(focus).render(maxcolrow,
205
return self.current_widget(focus).render((maxcol,),
339
def keypress(self, maxcolrow, key):
208
def keypress(self, (maxcol,), key):
341
210
This overrides the method from urwid.FlowWidget"""
343
self.proxy.Enable(dbus_interface = client_interface,
346
self.proxy.Disable(dbus_interface = client_interface,
349
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
350
dbus_interface = client_interface,
353
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
354
dbus_interface = client_interface,
356
elif key == "R" or key == "_" or key == "ctrl k":
211
if key == u"e" or key == u"+":
213
elif key == u"d" or key == u"-":
215
elif key == u"r" or key == u"_" or key == u"ctrl k":
357
216
self.server_proxy_object.RemoveClient(self.proxy
361
self.proxy.StartChecker(dbus_interface = client_interface,
364
self.proxy.StopChecker(dbus_interface = client_interface,
367
self.proxy.CheckedOK(dbus_interface = client_interface,
219
self.proxy.StartChecker()
221
self.proxy.StopChecker()
223
self.proxy.CheckedOK()
370
# elif key == "p" or key == "=":
225
# elif key == u"p" or key == "=":
371
226
# self.proxy.pause()
372
# elif key == "u" or key == ":":
227
# elif key == u"u" or key == ":":
373
228
# self.proxy.unpause()
229
# elif key == u"RET":
379
def property_changed(self, property=None, **kwargs):
234
def property_changed(self, property=None, value=None,
380
236
"""Call self.update() if old value is not new value.
381
237
This overrides the method from MandosClientPropertyCache"""
382
property_name = str(property)
238
property_name = unicode(property)
383
239
old_value = self.properties.get(property_name)
384
240
super(MandosClientWidget, self).property_changed(
385
property=property, **kwargs)
241
property=property, value=value, *args, **kwargs)
386
242
if self.properties.get(property_name) != old_value:
409
265
self.screen = urwid.curses_display.Screen()
411
267
self.screen.register_palette((
413
"default", "default", None),
415
"bold", "default", "bold"),
417
"underline,blink", "default", "underline,blink"),
419
"standout", "default", "standout"),
420
("bold-underline-blink",
421
"bold,underline,blink", "default", "bold,underline,blink"),
423
"bold,standout", "default", "bold,standout"),
424
("underline-blink-standout",
425
"underline,blink,standout", "default",
426
"underline,blink,standout"),
427
("bold-underline-blink-standout",
428
"bold,underline,blink,standout", "default",
429
"bold,underline,blink,standout"),
269
u"default", u"default", None),
271
u"default", u"default", u"bold"),
273
u"default", u"default", u"underline"),
275
u"default", u"default", u"standout"),
276
(u"bold-underline-blink",
277
u"default", u"default", (u"bold", u"underline")),
279
u"default", u"default", (u"bold", u"standout")),
280
(u"underline-blink-standout",
281
u"default", u"default", (u"underline", u"standout")),
282
(u"bold-underline-blink-standout",
283
u"default", u"default", (u"bold", u"underline",
432
287
if urwid.supports_unicode():
433
self.divider = "─" # \u2500
434
#self.divider = "━" # \u2501
288
self.divider = u"─" # \u2500
289
#self.divider = u"━" # \u2501
436
#self.divider = "-" # \u002d
437
self.divider = "_" # \u005f
291
#self.divider = u"-" # \u002d
292
self.divider = u"_" # \u005f
439
294
self.screen.start()
454
309
# This keeps track of whether self.uilist currently has
455
310
# self.logbox in it or not
456
311
self.log_visible = True
457
self.log_wrap = "any"
312
self.log_wrap = u"any"
460
self.log_message_raw(("bold",
461
"Mandos Monitor version " + version))
462
self.log_message_raw(("bold",
315
self.log_message_raw((u"bold",
316
u"Mandos Monitor version " + version))
317
self.log_message_raw((u"bold",
465
320
self.busname = domain + '.Mandos'
466
321
self.main_loop = gobject.MainLoop()
322
self.bus = dbus.SystemBus()
323
mandos_dbus_objc = self.bus.get_object(
324
self.busname, u"/", follow_name_owner_changes=True)
325
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
329
mandos_clients = (self.mandos_serv
330
.GetAllClientsWithProperties())
331
except dbus.exceptions.DBusException:
332
mandos_clients = dbus.Dictionary()
335
.connect_to_signal(u"ClientRemoved",
336
self.find_and_remove_client,
337
dbus_interface=server_interface,
340
.connect_to_signal(u"ClientAdded",
342
dbus_interface=server_interface,
345
.connect_to_signal(u"ClientNotFound",
346
self.client_not_found,
347
dbus_interface=server_interface,
349
for path, client in mandos_clients.iteritems():
350
client_proxy_object = self.bus.get_object(self.busname,
352
self.add_client(MandosClientWidget(server_proxy_object
355
=client_proxy_object,
468
365
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {0} and fingerprint"
470
" {1} could not be found"
471
.format(address, fingerprint))
366
self.log_message((u"Client with address %s and fingerprint %s"
367
u" could not be found" % (address,
473
370
def rebuild(self):
474
371
"""This rebuilds the User Interface.
475
372
Call this when the widget layout needs to change"""
477
374
#self.uilist.append(urwid.ListBox(self.clients))
478
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
375
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
480
376
#header=urwid.Divider(),
483
urwid.Divider(div_char=
378
footer=urwid.Divider(div_char=self.divider)))
485
379
if self.log_visible:
486
380
self.uilist.append(self.logbox)
487
382
self.topwidget = urwid.Pile(self.uilist)
489
384
def log_message(self, message):
490
"""Log message formatted with timestamp"""
491
385
timestamp = datetime.datetime.now().isoformat()
492
self.log_message_raw(timestamp + ": " + message)
386
self.log_message_raw(timestamp + u": " + message)
494
388
def log_message_raw(self, markup):
495
389
"""Add a log message to the log buffer."""
498
392
and len(self.log) > self.max_log_length):
499
393
del self.log[0:len(self.log)-self.max_log_length-1]
500
394
self.logbox.set_focus(len(self.logbox.body.contents),
395
coming_from=u"above")
504
398
def toggle_log_display(self):
505
399
"""Toggle visibility of the log buffer."""
506
400
self.log_visible = not self.log_visible
508
#self.log_message("Log visibility changed to: "
509
# + str(self.log_visible))
402
self.log_message(u"Log visibility changed to: "
403
+ unicode(self.log_visible))
511
405
def change_log_display(self):
512
406
"""Change type of log display.
513
407
Currently, this toggles wrapping of text lines."""
514
if self.log_wrap == "clip":
515
self.log_wrap = "any"
408
if self.log_wrap == u"clip":
409
self.log_wrap = u"any"
517
self.log_wrap = "clip"
411
self.log_wrap = u"clip"
518
412
for textwidget in self.log:
519
413
textwidget.set_wrap_mode(self.log_wrap)
520
#self.log_message("Wrap mode: " + self.log_wrap)
414
self.log_message(u"Wrap mode: " + self.log_wrap)
522
416
def find_and_remove_client(self, path, name):
523
"""Find a client by its object path and remove it.
417
"""Find an client from its object path and remove it.
525
419
This is connected to the ClientRemoved signal from the
526
420
Mandos server object."""
571
468
"""Start the main loop and exit when it's done."""
572
self.bus = dbus.SystemBus()
573
mandos_dbus_objc = self.bus.get_object(
574
self.busname, "/", follow_name_owner_changes=True)
575
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
579
mandos_clients = (self.mandos_serv
580
.GetAllClientsWithProperties())
581
if not mandos_clients:
582
self.log_message_raw(("bold", "Note: Server has no clients."))
583
except dbus.exceptions.DBusException:
584
self.log_message_raw(("bold", "Note: No Mandos server running."))
585
mandos_clients = dbus.Dictionary()
588
.connect_to_signal("ClientRemoved",
589
self.find_and_remove_client,
590
dbus_interface=server_interface,
593
.connect_to_signal("ClientAdded",
595
dbus_interface=server_interface,
598
.connect_to_signal("ClientNotFound",
599
self.client_not_found,
600
dbus_interface=server_interface,
602
for path, client in mandos_clients.items():
603
client_proxy_object = self.bus.get_object(self.busname,
605
self.add_client(MandosClientWidget(server_proxy_object
608
=client_proxy_object,
619
470
self._input_callback_tag = (gobject.io_add_watch
620
471
(sys.stdin.fileno(),
646
497
except KeyError: # :-)
649
if key == "q" or key == "Q":
500
if key == u"q" or key == u"Q":
652
elif key == "window resize":
503
elif key == u"window resize":
653
504
self.size = self.screen.get_cols_rows()
655
elif key == "\f": # Ctrl-L
506
elif key == u"\f": # Ctrl-L
657
elif key == "l" or key == "D":
508
elif key == u"l" or key == u"D":
658
509
self.toggle_log_display()
660
elif key == "w" or key == "i":
511
elif key == u"w" or key == u"i":
661
512
self.change_log_display()
663
elif key == "?" or key == "f1" or key == "esc":
514
elif key == u"?" or key == u"f1" or key == u"esc":
664
515
if not self.log_visible:
665
516
self.log_visible = True
667
self.log_message_raw(("bold",
671
"l: Log window toggle",
672
"TAB: Switch window",
674
self.log_message_raw(("bold",
680
"s: Start new checker",
518
self.log_message_raw((u"bold",
522
u"l: Log window toggle",
523
u"TAB: Switch window",
525
self.log_message_raw((u"bold",
531
u"s: Start new checker",
687
536
if self.topwidget.get_focus() is self.logbox:
688
537
self.topwidget.set_focus(0)
690
539
self.topwidget.set_focus(self.logbox)
692
#elif (key == "end" or key == "meta >" or key == "G"
541
#elif (key == u"end" or key == u"meta >" or key == u"G"
694
543
# pass # xxx end-of-buffer
695
#elif (key == "home" or key == "meta <" or key == "g"
544
#elif (key == u"home" or key == u"meta <" or key == u"g"
697
546
# pass # xxx beginning-of-buffer
698
#elif key == "ctrl e" or key == "$":
547
#elif key == u"ctrl e" or key == u"$":
699
548
# pass # xxx move-end-of-line
700
#elif key == "ctrl a" or key == "^":
549
#elif key == u"ctrl a" or key == u"^":
701
550
# pass # xxx move-beginning-of-line
702
#elif key == "ctrl b" or key == "meta (" or key == "h":
551
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
703
552
# pass # xxx left
704
#elif key == "ctrl f" or key == "meta )" or key == "l":
553
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
705
554
# pass # xxx right
707
556
# pass # scroll up log
709
558
# pass # scroll down log
710
559
elif self.topwidget.selectable():
711
560
self.topwidget.keypress(self.size, key)