41
36
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, '')
45
locale.setlocale(locale.LC_ALL, u'')
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
48
logging.getLogger(u'dbus.proxies').setLevel(logging.CRITICAL)
59
50
# Some useful constants
60
domain = 'se.recompile'
61
server_interface = domain + '.Mandos'
62
client_interface = domain + '.Mandos.Client'
51
domain = u'se.bsnet.fukt'
52
server_interface = domain + u'.Mandos'
53
client_interface = domain + u'.Mandos.Client'
56
# Always run in monochrome mode
57
urwid.curses_display.curses.has_colors = lambda : False
59
# Urwid doesn't support blinking, but we want it. Since we have no
60
# use for underline on its own, we make underline also always blink.
61
urwid.curses_display.curses.A_UNDERLINE |= (
62
urwid.curses_display.curses.A_BLINK)
65
64
def isoformat_to_datetime(iso):
66
65
"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)
68
d, t = iso.split(u"T", 1)
69
year, month, day = d.split(u"-", 2)
70
hour, minute, second = t.split(u":", 2)
72
71
second, fraction = divmod(float(second), 1)
73
72
return datetime.datetime(int(year),
83
82
properties and calls a hook function when any of them are
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
85
def __init__(self, proxy_object=None, *args, **kwargs):
87
86
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)
88
self.properties = dict()
89
self.proxy.connect_to_signal(u"PropertyChanged",
90
self.property_changed,
94
self.properties.update(
95
self.proxy.GetAll(client_interface,
96
dbus_interface = dbus.PROPERTIES_IFACE))
98
#XXX This break good super behaviour!
99
# super(MandosClientPropertyCache, self).__init__(
107
102
def property_changed(self, property=None, value=None):
108
103
"""This is called whenever we get a PropertyChanged signal
131
123
self.logger = logger
133
125
self._update_timer_callback_tag = None
126
self._update_timer_callback_lock = 0
127
self.last_checker_failed = False
135
129
# The widget shown normally
136
self._text_widget = urwid.Text("")
130
self._text_widget = urwid.Text(u"")
137
131
# The widget shown when we have focus
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
132
self._focus_text_widget = urwid.Text(u"")
133
super(MandosClientWidget, self).__init__(
134
update_hook=update_hook, delete_hook=delete_hook,
141
137
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)
139
last_checked_ok = isoformat_to_datetime(self.properties
141
if last_checked_ok is None:
142
self.last_checker_failed = True
144
self.last_checker_failed = ((datetime.datetime.utcnow()
151
if self.last_checker_failed:
152
self.using_timer(True)
154
if self.need_approval:
155
self.using_timer(True)
157
self.proxy.connect_to_signal(u"CheckerCompleted",
158
self.checker_completed,
161
self.proxy.connect_to_signal(u"CheckerStarted",
162
self.checker_started,
165
self.proxy.connect_to_signal(u"GotSecret",
169
self.proxy.connect_to_signal(u"NeedApproval",
173
self.proxy.connect_to_signal(u"Rejected",
178
def property_changed(self, property=None, value=None):
179
super(self, MandosClientWidget).property_changed(property,
181
if property == u"ApprovalPending":
182
using_timer(bool(value))
167
184
def using_timer(self, flag):
168
185
"""Call this method with True or False when timer should be
169
186
activated or deactivated.
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
188
old = self._update_timer_callback_lock
190
self._update_timer_callback_lock += 1
192
self._update_timer_callback_lock -= 1
193
if old == 0 and self._update_timer_callback_lock:
173
194
self._update_timer_callback_tag = (gobject.timeout_add
175
196
self.update_timer))
176
elif not (flag or self._update_timer_callback_tag is None):
197
elif old and self._update_timer_callback_lock == 0:
177
198
gobject.source_remove(self._update_timer_callback_tag)
178
199
self._update_timer_callback_tag = None
180
201
def checker_completed(self, exitstatus, condition, command):
181
202
if exitstatus == 0:
182
self.logger('Checker for client {} (command "{}")'
183
' succeeded'.format(self.properties["Name"],
203
if self.last_checker_failed:
204
self.last_checker_failed = False
205
self.using_timer(False)
206
#self.logger(u'Checker for client %s (command "%s")'
208
# % (self.properties[u"Name"], command))
212
if not self.last_checker_failed:
213
self.last_checker_failed = True
214
self.using_timer(True)
188
215
if os.WIFEXITED(condition):
189
self.logger('Checker for client {} (command "{}") failed'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
216
self.logger(u'Checker for client %s (command "%s")'
217
u' failed with exit code %s'
218
% (self.properties[u"Name"], command,
219
os.WEXITSTATUS(condition)))
193
220
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)))
221
self.logger(u'Checker for client %s (command "%s")'
222
u' was killed by signal %s'
223
% (self.properties[u"Name"], command,
224
os.WTERMSIG(condition)))
198
225
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {} (command "{}") dumped'
200
' core'.format(self.properties["Name"],
226
self.logger(u'Checker for client %s (command "%s")'
228
% (self.properties[u"Name"], command))
203
self.logger('Checker for client {} completed'
205
.format(self.properties["Name"]))
230
self.logger(u'Checker for client %s completed'
208
234
def checker_started(self, command):
209
"""Server signals that a checker started."""
210
self.logger('Client {} started checker "{}"'
211
.format(self.properties["Name"],
235
#self.logger(u'Client %s started checker "%s"'
236
# % (self.properties[u"Name"], unicode(command)))
214
239
def got_secret(self):
215
self.logger('Client {} received its secret'
216
.format(self.properties["Name"]))
240
self.last_checker_failed = False
241
self.logger(u'Client %s received its secret'
242
% self.properties[u"Name"])
218
244
def need_approval(self, timeout, default):
220
message = 'Client {} needs approval within {} seconds'
246
message = u'Client %s needs approval within %s seconds'
222
message = 'Client {} will get its secret in {} seconds'
223
self.logger(message.format(self.properties["Name"],
248
message = u'Client %s will get its secret in %s seconds'
250
% (self.properties[u"Name"], timeout/1000))
251
self.using_timer(True)
226
253
def rejected(self, reason):
227
self.logger('Client {} was rejected; reason: {}'
228
.format(self.properties["Name"], reason))
254
self.logger(u'Client %s was rejected; reason: %s'
255
% (self.properties[u"Name"], reason))
230
257
def selectable(self):
231
258
"""Make this a "selectable" widget.
246
273
def update(self):
247
274
"Called when what is visible on the screen should be updated."
248
275
# How to add standout mode to a style
249
with_standout = { "normal": "standout",
250
"bold": "bold-standout",
252
"underline-blink-standout",
253
"bold-underline-blink":
254
"bold-underline-blink-standout",
276
with_standout = { u"normal": u"standout",
277
u"bold": u"bold-standout",
279
u"underline-blink-standout",
280
u"bold-underline-blink":
281
u"bold-underline-blink-standout",
257
284
# Rebuild focus and non-focus widgets using current properties
259
286
# 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"]:
287
base = (u'%(name)s: '
288
% {u"name": self.properties[u"Name"]})
289
if not self.properties[u"Enabled"]:
290
message = u"DISABLED"
291
elif self.properties[u"ApprovalPending"]:
265
292
timeout = datetime.timedelta(milliseconds
266
293
= self.properties
268
295
last_approval_request = isoformat_to_datetime(
269
self.properties["LastApprovalRequest"])
296
self.properties[u"LastApprovalRequest"])
270
297
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
298
timer = timeout - (datetime.datetime.utcnow()
299
- last_approval_request)
275
301
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)
302
if self.properties[u"ApprovedByDefault"]:
303
message = u"Approval in %s. (d)eny?"
305
message = u"Denial in %s. (a)pprove?"
306
message = message % unicode(timer).rsplit(".", 1)[0]
307
elif self.last_checker_failed:
308
timeout = datetime.timedelta(milliseconds
311
last_ok = isoformat_to_datetime(
312
max((self.properties[u"LastCheckedOK"]
313
or self.properties[u"Created"]),
314
self.properties[u"LastEnabled"]))
315
timer = timeout - (datetime.datetime.utcnow() - last_ok)
316
message = (u'A checker has failed! Time until client'
317
u' gets disabled: %s'
318
% unicode(timer).rsplit(".", 1)[0])
298
self.using_timer(False)
299
self._text = "{}{}".format(base, message)
321
self._text = u"%s%s" % (base, message)
301
323
if not urwid.supports_unicode():
302
self._text = self._text.encode("ascii", "replace")
303
textlist = [("normal", self._text)]
324
self._text = self._text.encode(u"ascii", u"replace")
325
textlist = [(u"normal", self._text)]
304
326
self._text_widget.set_text(textlist)
305
327
self._focus_text_widget.set_text([(with_standout[text[0]],
340
357
def keypress(self, maxcolrow, key):
342
359
This overrides the method from urwid.FlowWidget"""
344
self.proxy.Enable(dbus_interface = client_interface,
347
self.proxy.Disable(dbus_interface = client_interface,
361
self.proxy.Enable(dbus_interface = client_interface)
363
self.proxy.Disable(dbus_interface = client_interface)
350
365
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
351
dbus_interface = client_interface,
366
dbus_interface = client_interface)
354
368
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
355
dbus_interface = client_interface,
357
elif key == "R" or key == "_" or key == "ctrl k":
369
dbus_interface = client_interface)
370
elif key == u"R" or key == u"_" or key == u"ctrl k":
358
371
self.server_proxy_object.RemoveClient(self.proxy
362
self.proxy.StartChecker(dbus_interface = client_interface,
365
self.proxy.StopChecker(dbus_interface = client_interface,
368
self.proxy.CheckedOK(dbus_interface = client_interface,
374
self.proxy.StartChecker(dbus_interface = client_interface)
376
self.proxy.StopChecker(dbus_interface = client_interface)
378
self.proxy.CheckedOK(dbus_interface = client_interface)
371
# elif key == "p" or key == "=":
380
# elif key == u"p" or key == "=":
372
381
# self.proxy.pause()
373
# elif key == "u" or key == ":":
382
# elif key == u"u" or key == ":":
374
383
# self.proxy.unpause()
384
# elif key == u"RET":
380
def property_changed(self, property=None, **kwargs):
389
def property_changed(self, property=None, value=None,
381
391
"""Call self.update() if old value is not new value.
382
392
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
393
property_name = unicode(property)
384
394
old_value = self.properties.get(property_name)
385
395
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
396
property=property, value=value, *args, **kwargs)
387
397
if self.properties.get(property_name) != old_value:
404
414
"""This is the entire user interface - the whole screen
405
415
with boxes, lists of client widgets, etc.
407
def __init__(self, max_log_length=1000, log_level=1):
417
def __init__(self, max_log_length=1000):
408
418
DBusGMainLoop(set_as_default=True)
410
420
self.screen = urwid.curses_display.Screen()
412
422
self.screen.register_palette((
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"),
424
u"default", u"default", None),
426
u"default", u"default", u"bold"),
428
u"default", u"default", u"underline"),
430
u"default", u"default", u"standout"),
431
(u"bold-underline-blink",
432
u"default", u"default", (u"bold", u"underline")),
434
u"default", u"default", (u"bold", u"standout")),
435
(u"underline-blink-standout",
436
u"default", u"default", (u"underline", u"standout")),
437
(u"bold-underline-blink-standout",
438
u"default", u"default", (u"bold", u"underline",
433
442
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
443
self.divider = u"─" # \u2500
444
#self.divider = u"━" # \u2501
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
446
#self.divider = u"-" # \u002d
447
self.divider = u"_" # \u005f
440
449
self.screen.start()
457
464
# This keeps track of whether self.uilist currently has
458
465
# self.logbox in it or not
459
466
self.log_visible = True
460
self.log_wrap = "any"
467
self.log_wrap = u"any"
463
self.log_message_raw(("bold",
464
"Mandos Monitor version " + version))
465
self.log_message_raw(("bold",
470
self.log_message_raw((u"bold",
471
u"Mandos Monitor version " + version))
472
self.log_message_raw((u"bold",
468
475
self.busname = domain + '.Mandos'
469
476
self.main_loop = gobject.MainLoop()
477
self.bus = dbus.SystemBus()
478
mandos_dbus_objc = self.bus.get_object(
479
self.busname, u"/", follow_name_owner_changes=True)
480
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
484
mandos_clients = (self.mandos_serv
485
.GetAllClientsWithProperties())
486
except dbus.exceptions.DBusException:
487
mandos_clients = dbus.Dictionary()
490
.connect_to_signal(u"ClientRemoved",
491
self.find_and_remove_client,
492
dbus_interface=server_interface,
495
.connect_to_signal(u"ClientAdded",
497
dbus_interface=server_interface,
500
.connect_to_signal(u"ClientNotFound",
501
self.client_not_found,
502
dbus_interface=server_interface,
504
for path, client in mandos_clients.iteritems():
505
client_proxy_object = self.bus.get_object(self.busname,
507
self.add_client(MandosClientWidget(server_proxy_object
510
=client_proxy_object,
471
520
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))
521
self.log_message((u"Client with address %s and fingerprint %s"
522
u" could not be found" % (address,
476
525
def rebuild(self):
477
526
"""This rebuilds the User Interface.
488
537
if self.log_visible:
489
538
self.uilist.append(self.logbox)
490
540
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:
542
def log_message(self, message):
496
543
timestamp = datetime.datetime.now().isoformat()
497
self.log_message_raw("{}: {}".format(timestamp, message),
544
self.log_message_raw(timestamp + u": " + message)
500
def log_message_raw(self, markup, level=1):
546
def log_message_raw(self, markup):
501
547
"""Add a log message to the log buffer."""
502
if level < self.log_level:
504
548
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505
549
if (self.max_log_length
506
550
and len(self.log) > self.max_log_length):
507
551
del self.log[0:len(self.log)-self.max_log_length-1]
508
552
self.logbox.set_focus(len(self.logbox.body.contents),
553
coming_from=u"above")
512
556
def toggle_log_display(self):
513
557
"""Toggle visibility of the log buffer."""
514
558
self.log_visible = not self.log_visible
516
self.log_message("Log visibility changed to: {}"
517
.format(self.log_visible), level=0)
560
#self.log_message(u"Log visibility changed to: "
561
# + unicode(self.log_visible))
519
563
def change_log_display(self):
520
564
"""Change type of log display.
521
565
Currently, this toggles wrapping of text lines."""
522
if self.log_wrap == "clip":
523
self.log_wrap = "any"
566
if self.log_wrap == u"clip":
567
self.log_wrap = u"any"
525
self.log_wrap = "clip"
569
self.log_wrap = u"clip"
526
570
for textwidget in self.log:
527
571
textwidget.set_wrap_mode(self.log_wrap)
528
self.log_message("Wrap mode: {}".format(self.log_wrap),
572
#self.log_message(u"Wrap mode: " + self.log_wrap)
531
574
def find_and_remove_client(self, path, name):
532
"""Find a client by its object path and remove it.
575
"""Find an client from its object path and remove it.
534
577
This is connected to the ClientRemoved signal from the
535
578
Mandos server object."""
580
626
"""Start the main loop and exit when it's done."""
581
self.bus = dbus.SystemBus()
582
mandos_dbus_objc = self.bus.get_object(
583
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
588
mandos_clients = (self.mandos_serv
589
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
mandos_clients = dbus.Dictionary()
597
.connect_to_signal("ClientRemoved",
598
self.find_and_remove_client,
599
dbus_interface=server_interface,
602
.connect_to_signal("ClientAdded",
604
dbus_interface=server_interface,
607
.connect_to_signal("ClientNotFound",
608
self.client_not_found,
609
dbus_interface=server_interface,
611
for path, client in mandos_clients.items():
612
client_proxy_object = self.bus.get_object(self.busname,
614
self.add_client(MandosClientWidget(server_proxy_object
617
=client_proxy_object,
628
628
self._input_callback_tag = (gobject.io_add_watch
629
629
(sys.stdin.fileno(),
655
655
except KeyError: # :-)
658
if key == "q" or key == "Q":
658
if key == u"q" or key == u"Q":
661
elif key == "window resize":
661
elif key == u"window resize":
662
662
self.size = self.screen.get_cols_rows()
664
elif key == "ctrl l":
664
elif key == u"\f": # Ctrl-L
667
elif key == "l" or key == "D":
666
elif key == u"l" or key == u"D":
668
667
self.toggle_log_display()
670
elif key == "w" or key == "i":
669
elif key == u"w" or key == u"i":
671
670
self.change_log_display()
673
elif key == "?" or key == "f1" or key == "esc":
672
elif key == u"?" or key == u"f1" or key == u"esc":
674
673
if not self.log_visible:
675
674
self.log_visible = True
677
self.log_message_raw(("bold",
681
"l: Log window toggle",
682
"TAB: Switch window",
683
"w: Wrap (log lines)",
684
"v: Toggle verbose log",
686
self.log_message_raw(("bold",
692
"s: Start new checker",
676
self.log_message_raw((u"bold",
680
u"l: Log window toggle",
681
u"TAB: Switch window",
683
self.log_message_raw((u"bold",
689
u"s: Start new checker",
699
696
if self.topwidget.get_focus() is self.logbox:
700
697
self.topwidget.set_focus(0)
702
699
self.topwidget.set_focus(self.logbox)
705
if self.log_level == 0:
707
self.log_message("Verbose mode: Off")
710
self.log_message("Verbose mode: On")
711
#elif (key == "end" or key == "meta >" or key == "G"
701
#elif (key == u"end" or key == u"meta >" or key == u"G"
713
703
# pass # xxx end-of-buffer
714
#elif (key == "home" or key == "meta <" or key == "g"
704
#elif (key == u"home" or key == u"meta <" or key == u"g"
716
706
# pass # xxx beginning-of-buffer
717
#elif key == "ctrl e" or key == "$":
707
#elif key == u"ctrl e" or key == u"$":
718
708
# pass # xxx move-end-of-line
719
#elif key == "ctrl a" or key == "^":
709
#elif key == u"ctrl a" or key == u"^":
720
710
# pass # xxx move-beginning-of-line
721
#elif key == "ctrl b" or key == "meta (" or key == "h":
711
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
722
712
# pass # xxx left
723
#elif key == "ctrl f" or key == "meta )" or key == "l":
713
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
724
714
# pass # xxx right
726
716
# pass # scroll up log
728
718
# pass # scroll down log
729
719
elif self.topwidget.selectable():
730
720
self.topwidget.keypress(self.size, key)