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>.
4
from __future__ import division, absolute_import, with_statement
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
9
38
import urwid.curses_display
12
41
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
51
if sys.version_info.major == 2:
54
locale.setlocale(locale.LC_ALL, '')
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
19
59
# Some useful constants
20
domain = 'se.bsnet.fukt'
60
domain = 'se.recompile'
21
61
server_interface = domain + '.Mandos'
22
62
client_interface = domain + '.Mandos.Client'
25
# Always run in monochrome mode
26
urwid.curses_display.curses.has_colors = lambda : False
28
# Urwid doesn't support blinking, but we want it. Since we have no
29
# use for underline on its own, we make underline also always blink.
30
urwid.curses_display.curses.A_UNDERLINE |= (
31
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
33
81
class MandosClientPropertyCache(object):
34
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
35
83
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,
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
59
87
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())
67
self.proxy.connect_to_signal("PropertyChanged",
68
self.property_changed,
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,
72
95
if properties is None:
73
96
self.properties.update(
74
self.convert_property(prop, val)
76
97
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)
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)
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)
98
107
def property_changed(self, property=None, value=None):
99
108
"""This is called whenever we get a PropertyChanged signal
100
109
It updates the changed property in the "properties" dict.
102
# Convert name and value
103
property_name, cvalue = self.convert_property(property, value)
104
111
# Update properties dict with new value
105
self.properties[property_name] = cvalue
112
self.properties[property] = value
115
self.property_changed_match.remove()
108
118
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
112
122
def __init__(self, server_proxy_object=None, update_hook=None,
113
delete_hook=None, *args, **kwargs):
123
delete_hook=None, logger=None, **kwargs):
114
124
# Called on update
115
125
self.update_hook = update_hook
116
126
# Called on delete
117
127
self.delete_hook = delete_hook
118
128
# Mandos Server proxy object
119
129
self.server_proxy_object = server_proxy_object
133
self._update_timer_callback_tag = None
121
135
# The widget shown normally
122
136
self._text_widget = urwid.Text("")
123
137
# The widget shown when we have focus
124
138
self._focus_text_widget = urwid.Text("")
125
super(MandosClientWidget, self).__init__(
126
update_hook=update_hook, delete_hook=delete_hook,
139
super(MandosClientWidget, self).__init__(**kwargs)
129
141
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 {}'
165
.format(self.properties["Name"]), level=0)
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
180
def checker_completed(self, exitstatus, condition, command):
182
self.logger('Checker for client {} (command "{}")'
183
' succeeded'.format(self.properties["Name"],
188
if os.WIFEXITED(condition):
189
self.logger('Checker for client {} (command "{}") failed'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
193
elif os.WIFSIGNALED(condition):
194
self.logger('Checker for client {} (command "{}") was'
195
' killed by signal {}'
196
.format(self.properties["Name"], command,
197
os.WTERMSIG(condition)))
198
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {} (command "{}") dumped'
200
' core'.format(self.properties["Name"],
203
self.logger('Checker for client {} completed'
205
.format(self.properties["Name"]))
208
def checker_started(self, command):
209
"""Server signals that a checker started."""
210
self.logger('Client {} started checker "{}"'
211
.format(self.properties["Name"],
214
def got_secret(self):
215
self.logger('Client {} received its secret'
216
.format(self.properties["Name"]))
218
def need_approval(self, timeout, default):
220
message = 'Client {} needs approval within {} seconds'
222
message = 'Client {} will get its secret in {} seconds'
223
self.logger(message.format(self.properties["Name"],
226
def rejected(self, reason):
227
self.logger('Client {} was rejected; reason: {}'
228
.format(self.properties["Name"], reason))
131
230
def selectable(self):
132
231
"""Make this a "selectable" widget.
133
232
This overrides the method from urwid.FlowWidget."""
136
def rows(self, (maxcol,), focus=False):
235
def rows(self, maxcolrow, focus=False):
137
236
"""How many rows this widget will occupy might depend on
138
237
whether we have focus or not.
139
238
This overrides the method from urwid.FlowWidget"""
140
return self.current_widget(focus).rows((maxcol,), focus=focus)
239
return self.current_widget(focus).rows(maxcolrow, focus=focus)
142
241
def current_widget(self, focus=False):
143
242
if focus or self.opened:
147
246
def update(self):
148
247
"Called when what is visible on the screen should be updated."
149
248
# 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",
249
with_standout = { "normal": "standout",
250
"bold": "bold-standout",
252
"underline-blink-standout",
253
"bold-underline-blink":
254
"bold-underline-blink-standout",
158
257
# Rebuild focus and non-focus widgets using current properties
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
259
# Base part of a client. Name!
260
base = '{name}: '.format(name=self.properties["Name"])
261
if not self.properties["Enabled"]:
263
self.using_timer(False)
264
elif self.properties["ApprovalPending"]:
265
timeout = datetime.timedelta(milliseconds
268
last_approval_request = isoformat_to_datetime(
269
self.properties["LastApprovalRequest"])
270
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
275
timer = datetime.timedelta()
276
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {}. (d)eny?"
279
message = "Denial in {}. (a)pprove?"
280
message = message.format(str(timer).rsplit(".", 1)[0])
281
self.using_timer(True)
282
elif self.properties["LastCheckerStatus"] != 0:
283
# When checker has failed, show timer until client expires
284
expires = self.properties["Expires"]
286
timer = datetime.timedelta(0)
288
expires = (datetime.datetime.strptime
289
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
290
timer = max(expires - datetime.datetime.utcnow(),
291
datetime.timedelta())
292
message = ('A checker has failed! Time until client'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
298
self.using_timer(False)
299
self._text = "{}{}".format(base, message)
161
301
if not urwid.supports_unicode():
162
302
self._text = self._text.encode("ascii", "replace")
163
textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]
303
textlist = [("normal", self._text)]
164
304
self._text_widget.set_text(textlist)
165
305
self._focus_text_widget.set_text([(with_standout[text[0]],
174
314
if self.update_hook is not None:
175
315
self.update_hook()
317
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
321
return True # Keep calling this
323
def delete(self, **kwargs):
324
if self._update_timer_callback_tag is not None:
325
gobject.source_remove(self._update_timer_callback_tag)
326
self._update_timer_callback_tag = None
327
for match in self.match_objects:
329
self.match_objects = ()
178
330
if self.delete_hook is not None:
179
331
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
181
def render(self, (maxcol,), focus=False):
334
def render(self, maxcolrow, focus=False):
182
335
"""Render differently if we have focus.
183
336
This overrides the method from urwid.FlowWidget"""
184
return self.current_widget(focus).render((maxcol,),
337
return self.current_widget(focus).render(maxcolrow,
187
def keypress(self, (maxcol,), key):
340
def keypress(self, maxcolrow, key):
189
342
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"_":
344
self.proxy.Enable(dbus_interface = client_interface,
347
self.proxy.Disable(dbus_interface = client_interface,
350
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
351
dbus_interface = client_interface,
354
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
355
dbus_interface = client_interface,
357
elif key == "R" or key == "_" or key == "ctrl k":
195
358
self.server_proxy_object.RemoveClient(self.proxy
198
self.proxy.StartChecker()
200
self.proxy.StopChecker()
202
self.proxy.CheckedOK()
362
self.proxy.StartChecker(dbus_interface = client_interface,
365
self.proxy.StopChecker(dbus_interface = client_interface,
368
self.proxy.CheckedOK(dbus_interface = client_interface,
204
# elif key == u"p" or key == "=":
371
# elif key == "p" or key == "=":
205
372
# self.proxy.pause()
206
# elif key == u"u" or key == ":":
373
# elif key == "u" or key == ":":
207
374
# self.proxy.unpause()
208
# elif key == u"RET":
213
def property_changed(self, property=None, value=None,
380
def property_changed(self, property=None, **kwargs):
215
381
"""Call self.update() if old value is not new value.
216
382
This overrides the method from MandosClientPropertyCache"""
217
property_name = unicode(property)
383
property_name = str(property)
218
384
old_value = self.properties.get(property_name)
219
385
super(MandosClientWidget, self).property_changed(
220
property=property, value=value, *args, **kwargs)
386
property=property, **kwargs)
221
387
if self.properties.get(property_name) != old_value:
391
class ConstrainedListBox(urwid.ListBox):
392
"""Like a normal urwid.ListBox, but will consume all "up" or
393
"down" key presses, thus not allowing any containing widgets to
394
use them as an excuse to shift focus away from this widget.
396
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
398
if ret in ("up", "down"):
225
403
class UserInterface(object):
226
404
"""This is the entire user interface - the whole screen
227
405
with boxes, lists of client widgets, etc.
230
DBusGMainLoop(set_as_default=True )
407
def __init__(self, max_log_length=1000, log_level=1):
408
DBusGMainLoop(set_as_default=True)
232
410
self.screen = urwid.curses_display.Screen()
234
412
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",
414
"default", "default", None),
416
"bold", "default", "bold"),
418
"underline,blink", "default", "underline,blink"),
420
"standout", "default", "standout"),
421
("bold-underline-blink",
422
"bold,underline,blink", "default", "bold,underline,blink"),
424
"bold,standout", "default", "bold,standout"),
425
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
428
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
433
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
254
440
self.screen.start()
256
442
self.size = self.screen.get_cols_rows()
258
444
self.clients = urwid.SimpleListWalker([])
259
445
self.clients_dict = {}
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
447
# We will add Text widgets to this list
449
self.max_log_length = max_log_length
451
self.log_level = log_level
453
# We keep a reference to the log widget so we can remove it
454
# from the ListWalker without it getting destroyed
455
self.logbox = ConstrainedListBox(self.log)
457
# This keeps track of whether self.uilist currently has
458
# self.logbox in it or not
459
self.log_visible = True
460
self.log_wrap = "any"
463
self.log_message_raw(("bold",
464
"Mandos Monitor version " + version))
465
self.log_message_raw(("bold",
263
468
self.busname = domain + '.Mandos'
264
469
self.main_loop = gobject.MainLoop()
265
self.bus = dbus.SystemBus()
266
mandos_dbus_objc = self.bus.get_object(
267
self.busname, u"/", follow_name_owner_changes=True)
268
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
272
mandos_clients = (self.mandos_serv
273
.GetAllClientsWithProperties())
274
except dbus.exceptions.DBusException:
275
mandos_clients = dbus.Dictionary()
278
.connect_to_signal("ClientRemoved",
279
self.find_and_remove_client,
280
dbus_interface=server_interface,
283
.connect_to_signal("ClientAdded",
285
dbus_interface=server_interface,
287
for path, client in (mandos_clients.iteritems()):
288
client_proxy_object = self.bus.get_object(self.busname,
290
self.add_client(MandosClientWidget(server_proxy_object
293
=client_proxy_object,
298
=self.remove_client),
471
def client_not_found(self, fingerprint, address):
472
self.log_message("Client with address {} and fingerprint {}"
473
" could not be found"
474
.format(address, fingerprint))
477
"""This rebuilds the User Interface.
478
Call this when the widget layout needs to change"""
480
#self.uilist.append(urwid.ListBox(self.clients))
481
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
483
#header=urwid.Divider(),
486
urwid.Divider(div_char=
489
self.uilist.append(self.logbox)
490
self.topwidget = urwid.Pile(self.uilist)
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
496
timestamp = datetime.datetime.now().isoformat()
497
self.log_message_raw("{}: {}".format(timestamp, message),
500
def log_message_raw(self, markup, level=1):
501
"""Add a log message to the log buffer."""
502
if level < self.log_level:
504
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505
if (self.max_log_length
506
and len(self.log) > self.max_log_length):
507
del self.log[0:len(self.log)-self.max_log_length-1]
508
self.logbox.set_focus(len(self.logbox.body.contents),
512
def toggle_log_display(self):
513
"""Toggle visibility of the log buffer."""
514
self.log_visible = not self.log_visible
516
self.log_message("Log visibility changed to: {}"
517
.format(self.log_visible), level=0)
519
def change_log_display(self):
520
"""Change type of log display.
521
Currently, this toggles wrapping of text lines."""
522
if self.log_wrap == "clip":
523
self.log_wrap = "any"
525
self.log_wrap = "clip"
526
for textwidget in self.log:
527
textwidget.set_wrap_mode(self.log_wrap)
528
self.log_message("Wrap mode: {}".format(self.log_wrap),
301
531
def find_and_remove_client(self, path, name):
302
"""Find an client from its object path and remove it.
532
"""Find a client by its object path and remove it.
304
534
This is connected to the ClientRemoved signal from the
305
535
Mandos server object."""