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'
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)
65
43
def isoformat_to_datetime(iso):
66
44
"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)
47
d, t = iso.split(u"T", 1)
48
year, month, day = d.split(u"-", 2)
49
hour, minute, second = t.split(u":", 2)
72
50
second, fraction = divmod(float(second), 1)
73
51
return datetime.datetime(int(year),
83
61
properties and calls a hook function when any of them are
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
64
def __init__(self, proxy_object=None, *args, **kwargs):
87
65
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)
67
self.properties = dict()
68
self.proxy.connect_to_signal(u"PropertyChanged",
69
self.property_changed,
73
self.properties.update(
74
self.proxy.GetAll(client_interface,
75
dbus_interface = dbus.PROPERTIES_IFACE))
77
#XXX This break good super behaviour!
78
# super(MandosClientPropertyCache, self).__init__(
107
81
def property_changed(self, property=None, value=None):
108
82
"""This is called whenever we get a PropertyChanged signal
131
102
self.logger = logger
133
104
self._update_timer_callback_tag = None
105
self._update_timer_callback_lock = 0
106
self.last_checker_failed = False
135
108
# The widget shown normally
136
self._text_widget = urwid.Text("")
109
self._text_widget = urwid.Text(u"")
137
110
# The widget shown when we have focus
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
111
self._focus_text_widget = urwid.Text(u"")
112
super(MandosClientWidget, self).__init__(
113
update_hook=update_hook, delete_hook=delete_hook,
141
116
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"]))
118
last_checked_ok = isoformat_to_datetime(self.properties
120
if last_checked_ok is None:
121
self.last_checker_failed = True
123
self.last_checker_failed = ((datetime.datetime.utcnow()
130
if self.last_checker_failed:
131
self.using_timer(True)
133
if self.need_approval:
134
self.using_timer(True)
136
self.proxy.connect_to_signal(u"CheckerCompleted",
137
self.checker_completed,
140
self.proxy.connect_to_signal(u"CheckerStarted",
141
self.checker_started,
144
self.proxy.connect_to_signal(u"GotSecret",
148
self.proxy.connect_to_signal(u"NeedApproval",
152
self.proxy.connect_to_signal(u"Rejected",
157
def property_changed(self, property=None, value=None):
158
super(self, MandosClientWidget).property_changed(property,
160
if property == u"ApprovalPending":
161
using_timer(bool(value))
167
163
def using_timer(self, flag):
168
164
"""Call this method with True or False when timer should be
169
165
activated or deactivated.
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
167
old = self._update_timer_callback_lock
169
self._update_timer_callback_lock += 1
171
self._update_timer_callback_lock -= 1
172
if old == 0 and self._update_timer_callback_lock:
173
173
self._update_timer_callback_tag = (gobject.timeout_add
175
175
self.update_timer))
176
elif not (flag or self._update_timer_callback_tag is None):
176
elif old and self._update_timer_callback_lock == 0:
177
177
gobject.source_remove(self._update_timer_callback_tag)
178
178
self._update_timer_callback_tag = None
180
180
def checker_completed(self, exitstatus, condition, command):
181
181
if exitstatus == 0:
182
if self.last_checker_failed:
183
self.last_checker_failed = False
184
self.using_timer(False)
185
#self.logger(u'Checker for client %s (command "%s")'
187
# % (self.properties[u"Name"], command))
191
if not self.last_checker_failed:
192
self.last_checker_failed = True
193
self.using_timer(True)
185
194
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)))
195
self.logger(u'Checker for client %s (command "%s")'
196
u' failed with exit code %s'
197
% (self.properties[u"Name"], command,
198
os.WEXITSTATUS(condition)))
190
199
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)))
200
self.logger(u'Checker for client %s (command "%s")'
201
u' was killed by signal %s'
202
% (self.properties[u"Name"], command,
203
os.WTERMSIG(condition)))
195
204
elif os.WCOREDUMP(condition):
196
self.logger('Checker for client {0} (command "{1}")'
198
.format(self.properties["Name"], command))
205
self.logger(u'Checker for client %s (command "%s")'
207
% (self.properties[u"Name"], command))
200
self.logger('Checker for client {0} completed'
202
.format(self.properties["Name"]))
209
self.logger(u'Checker for client %s completed'
205
213
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"],
214
#self.logger(u'Client %s started checker "%s"'
215
# % (self.properties[u"Name"], unicode(command)))
213
218
def got_secret(self):
214
self.logger('Client {0} received its secret'
215
.format(self.properties["Name"]))
219
self.last_checker_failed = False
220
self.logger(u'Client %s received its secret'
221
% self.properties[u"Name"])
217
223
def need_approval(self, timeout, default):
219
message = 'Client {0} needs approval within {1} seconds'
225
message = u'Client %s needs approval within %s seconds'
221
message = 'Client {0} will get its secret in {1} seconds'
222
self.logger(message.format(self.properties["Name"],
227
message = u'Client %s will get its secret in %s seconds'
229
% (self.properties[u"Name"], timeout/1000))
230
self.using_timer(True)
225
232
def rejected(self, reason):
226
self.logger('Client {0} was rejected; reason: {1}'
227
.format(self.properties["Name"], reason))
233
self.logger(u'Client %s was rejected; reason: %s'
234
% (self.properties[u"Name"], reason))
229
236
def selectable(self):
230
237
"""Make this a "selectable" widget.
231
238
This overrides the method from urwid.FlowWidget."""
234
def rows(self, maxcolrow, focus=False):
241
def rows(self, (maxcol,), focus=False):
235
242
"""How many rows this widget will occupy might depend on
236
243
whether we have focus or not.
237
244
This overrides the method from urwid.FlowWidget"""
238
return self.current_widget(focus).rows(maxcolrow, focus=focus)
245
return self.current_widget(focus).rows((maxcol,), focus=focus)
240
247
def current_widget(self, focus=False):
241
248
if focus or self.opened:
245
252
def update(self):
246
253
"Called when what is visible on the screen should be updated."
247
254
# 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",
255
with_standout = { u"normal": u"standout",
256
u"bold": u"bold-standout",
258
u"underline-blink-standout",
259
u"bold-underline-blink":
260
u"bold-underline-blink-standout",
256
263
# Rebuild focus and non-focus widgets using current properties
258
265
# 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"]:
266
base = (u'%(name)s: '
267
% {u"name": self.properties[u"Name"]})
268
if not self.properties[u"Enabled"]:
269
message = u"DISABLED"
270
elif self.properties[u"ApprovalPending"]:
264
271
timeout = datetime.timedelta(milliseconds
265
272
= self.properties
267
274
last_approval_request = isoformat_to_datetime(
268
self.properties["LastApprovalRequest"])
275
self.properties[u"LastApprovalRequest"])
269
276
if last_approval_request is not None:
270
timer = max(timeout - (datetime.datetime.utcnow()
271
- last_approval_request),
272
datetime.timedelta())
277
timer = timeout - (datetime.datetime.utcnow()
278
- last_approval_request)
274
280
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)
281
if self.properties[u"ApprovedByDefault"]:
282
message = u"Approval in %s. (d)eny?"
284
message = u"Denial in %s. (a)pprove?"
285
message = message % unicode(timer).rsplit(".", 1)[0]
286
elif self.last_checker_failed:
287
timeout = datetime.timedelta(milliseconds
290
last_ok = isoformat_to_datetime(
291
max((self.properties[u"LastCheckedOK"]
292
or self.properties[u"Created"]),
293
self.properties[u"LastEnabled"]))
294
timer = timeout - (datetime.datetime.utcnow() - last_ok)
295
message = (u'A checker has failed! Time until client'
296
u' gets disabled: %s'
297
% unicode(timer).rsplit(".", 1)[0])
297
self.using_timer(False)
298
self._text = "{0}{1}".format(base, message)
300
self._text = "%s%s" % (base, message)
300
302
if not urwid.supports_unicode():
301
303
self._text = self._text.encode("ascii", "replace")
302
textlist = [("normal", self._text)]
304
textlist = [(u"normal", self._text)]
303
305
self._text_widget.set_text(textlist)
304
306
self._focus_text_widget.set_text([(with_standout[text[0]],
314
316
self.update_hook()
316
318
def update_timer(self):
317
"""called by gobject. Will indefinitely loop until
318
gobject.source_remove() on tag is called"""
320
321
return True # Keep calling this
322
def delete(self, **kwargs):
323
324
if self._update_timer_callback_tag is not None:
324
325
gobject.source_remove(self._update_timer_callback_tag)
325
326
self._update_timer_callback_tag = None
326
for match in self.match_objects:
328
self.match_objects = ()
329
327
if self.delete_hook is not None:
330
328
self.delete_hook(self)
331
return super(MandosClientWidget, self).delete(**kwargs)
333
def render(self, maxcolrow, focus=False):
330
def render(self, (maxcol,), focus=False):
334
331
"""Render differently if we have focus.
335
332
This overrides the method from urwid.FlowWidget"""
336
return self.current_widget(focus).render(maxcolrow,
333
return self.current_widget(focus).render((maxcol,),
339
def keypress(self, maxcolrow, key):
336
def keypress(self, (maxcol,), key):
341
338
This overrides the method from urwid.FlowWidget"""
343
self.proxy.Enable(dbus_interface = client_interface,
346
self.proxy.Disable(dbus_interface = client_interface,
340
self.proxy.Enable(dbus_interface = client_interface)
342
self.proxy.Disable(dbus_interface = client_interface)
349
344
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
350
dbus_interface = client_interface,
345
dbus_interface = client_interface)
353
347
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
354
dbus_interface = client_interface,
356
elif key == "R" or key == "_" or key == "ctrl k":
348
dbus_interface = client_interface)
349
elif key == u"r" or key == u"_" or key == u"ctrl k":
357
350
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,
353
self.proxy.StartChecker(dbus_interface = client_interface)
355
self.proxy.StopChecker(dbus_interface = client_interface)
357
self.proxy.CheckedOK(dbus_interface = client_interface)
370
# elif key == "p" or key == "=":
359
# elif key == u"p" or key == "=":
371
360
# self.proxy.pause()
372
# elif key == "u" or key == ":":
361
# elif key == u"u" or key == ":":
373
362
# self.proxy.unpause()
363
# elif key == u"RET":
379
def property_changed(self, property=None, **kwargs):
368
def property_changed(self, property=None, value=None,
380
370
"""Call self.update() if old value is not new value.
381
371
This overrides the method from MandosClientPropertyCache"""
382
property_name = str(property)
372
property_name = unicode(property)
383
373
old_value = self.properties.get(property_name)
384
374
super(MandosClientWidget, self).property_changed(
385
property=property, **kwargs)
375
property=property, value=value, *args, **kwargs)
386
376
if self.properties.get(property_name) != old_value:
409
400
self.screen = urwid.curses_display.Screen()
411
402
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"),
404
u"default", u"default", None),
406
u"default", u"default", u"bold"),
408
u"default", u"default", u"underline"),
410
u"default", u"default", u"standout"),
411
(u"bold-underline-blink",
412
u"default", u"default", (u"bold", u"underline")),
414
u"default", u"default", (u"bold", u"standout")),
415
(u"underline-blink-standout",
416
u"default", u"default", (u"underline", u"standout")),
417
(u"bold-underline-blink-standout",
418
u"default", u"default", (u"bold", u"underline",
432
422
if urwid.supports_unicode():
433
self.divider = "─" # \u2500
434
#self.divider = "━" # \u2501
423
self.divider = u"─" # \u2500
424
#self.divider = u"━" # \u2501
436
#self.divider = "-" # \u002d
437
self.divider = "_" # \u005f
426
#self.divider = u"-" # \u002d
427
self.divider = u"_" # \u005f
439
429
self.screen.start()
454
444
# This keeps track of whether self.uilist currently has
455
445
# self.logbox in it or not
456
446
self.log_visible = True
457
self.log_wrap = "any"
447
self.log_wrap = u"any"
460
self.log_message_raw(("bold",
461
"Mandos Monitor version " + version))
462
self.log_message_raw(("bold",
450
self.log_message_raw((u"bold",
451
u"Mandos Monitor version " + version))
452
self.log_message_raw((u"bold",
465
455
self.busname = domain + '.Mandos'
466
456
self.main_loop = gobject.MainLoop()
457
self.bus = dbus.SystemBus()
458
mandos_dbus_objc = self.bus.get_object(
459
self.busname, u"/", follow_name_owner_changes=True)
460
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
464
mandos_clients = (self.mandos_serv
465
.GetAllClientsWithProperties())
466
except dbus.exceptions.DBusException:
467
mandos_clients = dbus.Dictionary()
470
.connect_to_signal(u"ClientRemoved",
471
self.find_and_remove_client,
472
dbus_interface=server_interface,
475
.connect_to_signal(u"ClientAdded",
477
dbus_interface=server_interface,
480
.connect_to_signal(u"ClientNotFound",
481
self.client_not_found,
482
dbus_interface=server_interface,
484
for path, client in mandos_clients.iteritems():
485
client_proxy_object = self.bus.get_object(self.busname,
487
self.add_client(MandosClientWidget(server_proxy_object
490
=client_proxy_object,
468
500
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))
501
self.log_message((u"Client with address %s and fingerprint %s"
502
u" could not be found" % (address,
473
505
def rebuild(self):
474
506
"""This rebuilds the User Interface.
498
530
and len(self.log) > self.max_log_length):
499
531
del self.log[0:len(self.log)-self.max_log_length-1]
500
532
self.logbox.set_focus(len(self.logbox.body.contents),
533
coming_from=u"above")
504
536
def toggle_log_display(self):
505
537
"""Toggle visibility of the log buffer."""
506
538
self.log_visible = not self.log_visible
508
#self.log_message("Log visibility changed to: "
509
# + str(self.log_visible))
540
#self.log_message(u"Log visibility changed to: "
541
# + unicode(self.log_visible))
511
543
def change_log_display(self):
512
544
"""Change type of log display.
513
545
Currently, this toggles wrapping of text lines."""
514
if self.log_wrap == "clip":
515
self.log_wrap = "any"
546
if self.log_wrap == u"clip":
547
self.log_wrap = u"any"
517
self.log_wrap = "clip"
549
self.log_wrap = u"clip"
518
550
for textwidget in self.log:
519
551
textwidget.set_wrap_mode(self.log_wrap)
520
#self.log_message("Wrap mode: " + self.log_wrap)
552
#self.log_message(u"Wrap mode: " + self.log_wrap)
522
554
def find_and_remove_client(self, path, name):
523
"""Find a client by its object path and remove it.
555
"""Find an client from its object path and remove it.
525
557
This is connected to the ClientRemoved signal from the
526
558
Mandos server object."""
571
606
"""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
608
self._input_callback_tag = (gobject.io_add_watch
620
609
(sys.stdin.fileno(),
646
635
except KeyError: # :-)
649
if key == "q" or key == "Q":
638
if key == u"q" or key == u"Q":
652
elif key == "window resize":
641
elif key == u"window resize":
653
642
self.size = self.screen.get_cols_rows()
655
elif key == "\f": # Ctrl-L
644
elif key == u"\f": # Ctrl-L
657
elif key == "l" or key == "D":
646
elif key == u"l" or key == u"D":
658
647
self.toggle_log_display()
660
elif key == "w" or key == "i":
649
elif key == u"w" or key == u"i":
661
650
self.change_log_display()
663
elif key == "?" or key == "f1" or key == "esc":
652
elif key == u"?" or key == u"f1" or key == u"esc":
664
653
if not self.log_visible:
665
654
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",
656
self.log_message_raw((u"bold",
660
u"l: Log window toggle",
661
u"TAB: Switch window",
663
self.log_message_raw((u"bold",
669
u"s: Start new checker",
687
676
if self.topwidget.get_focus() is self.logbox:
688
677
self.topwidget.set_focus(0)
690
679
self.topwidget.set_focus(self.logbox)
692
#elif (key == "end" or key == "meta >" or key == "G"
681
#elif (key == u"end" or key == u"meta >" or key == u"G"
694
683
# pass # xxx end-of-buffer
695
#elif (key == "home" or key == "meta <" or key == "g"
684
#elif (key == u"home" or key == u"meta <" or key == u"g"
697
686
# pass # xxx beginning-of-buffer
698
#elif key == "ctrl e" or key == "$":
687
#elif key == u"ctrl e" or key == u"$":
699
688
# pass # xxx move-end-of-line
700
#elif key == "ctrl a" or key == "^":
689
#elif key == u"ctrl a" or key == u"^":
701
690
# pass # xxx move-beginning-of-line
702
#elif key == "ctrl b" or key == "meta (" or key == "h":
691
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
703
692
# pass # xxx left
704
#elif key == "ctrl f" or key == "meta )" or key == "l":
693
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
705
694
# pass # xxx right
707
696
# pass # scroll up log
709
698
# pass # scroll down log
710
699
elif self.topwidget.selectable():
711
700
self.topwidget.keypress(self.size, key)