2
2
# -*- mode: python; coding: utf-8 -*-
4
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
6
# Copyright © 2009-2019 Teddy Hogeborn
7
# Copyright © 2009-2019 Björn Påhlsson
9
# This file is part of Mandos.
11
# Mandos is free software: you can redistribute it and/or modify it
12
# under the terms of the GNU General Public License as published by
11
13
# the Free Software Foundation, either version 3 of the License, or
12
14
# (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
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
16
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
19
# GNU General Public License for more details.
19
21
# 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/>.
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23
24
# Contact the authors at <mandos@recompile.se>.
26
27
from __future__ import (division, absolute_import, print_function,
41
42
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
43
from gi.repository import GLib
51
51
if sys.version_info.major == 2:
54
54
locale.setlocale(locale.LC_ALL, '')
57
56
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
59
58
# Some useful constants
60
59
domain = 'se.recompile'
61
60
server_interface = domain + '.Mandos'
62
61
client_interface = domain + '.Mandos.Client'
66
65
dbus.OBJECT_MANAGER_IFACE
67
66
except AttributeError:
68
67
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
70
70
def isoformat_to_datetime(iso):
71
71
"Parse an ISO 8601 date string to a datetime.datetime()"
83
int(second), # Whole seconds
84
int(fraction*1000000)) # Microseconds
83
int(second), # Whole seconds
84
int(fraction*1000000)) # Microseconds
86
87
class MandosClientPropertyCache(object):
87
88
"""This wraps a Mandos Client D-Bus proxy object, caches the
91
92
def __init__(self, proxy_object=None, properties=None, **kwargs):
92
self.proxy = proxy_object # Mandos Client proxy object
93
self.proxy = proxy_object # Mandos Client proxy object
93
94
self.properties = dict() if properties is None else properties
94
95
self.property_changed_match = (
95
96
self.proxy.connect_to_signal("PropertiesChanged",
96
97
self.properties_changed,
97
98
dbus.PROPERTIES_IFACE,
100
101
if properties is None:
101
self.properties.update(
102
self.proxy.GetAll(client_interface,
104
= dbus.PROPERTIES_IFACE))
102
self.properties.update(self.proxy.GetAll(
104
dbus_interface=dbus.PROPERTIES_IFACE))
106
106
super(MandosClientPropertyCache, self).__init__(**kwargs)
108
108
def properties_changed(self, interface, properties, invalidated):
109
109
"""This is called whenever we get a PropertiesChanged signal
110
110
It updates the changed properties in the "properties" dict.
120
120
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
121
121
"""A Mandos Client which is visible on the screen.
124
124
def __init__(self, server_proxy_object=None, update_hook=None,
125
125
delete_hook=None, logger=None, **kwargs):
126
126
# Called on update
165
165
byte_arrays=True))
166
166
self.logger('Created client {}'
167
167
.format(self.properties["Name"]), level=0)
169
169
def using_timer(self, flag):
170
170
"""Call this method with True or False when timer should be
171
171
activated or deactivated.
173
173
if flag and self._update_timer_callback_tag is None:
174
174
# Will update the shown timer value every second
175
self._update_timer_callback_tag = (gobject.timeout_add
175
self._update_timer_callback_tag = (GLib.timeout_add
177
177
self.update_timer))
178
178
elif not (flag or self._update_timer_callback_tag is None):
179
gobject.source_remove(self._update_timer_callback_tag)
179
GLib.source_remove(self._update_timer_callback_tag)
180
180
self._update_timer_callback_tag = None
182
182
def checker_completed(self, exitstatus, condition, command):
183
183
if exitstatus == 0:
184
184
self.logger('Checker for client {} (command "{}")'
198
198
.format(self.properties["Name"], command,
199
199
os.WTERMSIG(condition)))
202
202
def checker_started(self, command):
203
203
"""Server signals that a checker started."""
204
204
self.logger('Client {} started checker "{}"'
205
205
.format(self.properties["Name"],
206
206
command), level=0)
208
208
def got_secret(self):
209
209
self.logger('Client {} received its secret'
210
210
.format(self.properties["Name"]))
212
212
def need_approval(self, timeout, default):
214
214
message = 'Client {} needs approval within {} seconds'
216
216
message = 'Client {} will get its secret in {} seconds'
217
217
self.logger(message.format(self.properties["Name"],
220
220
def rejected(self, reason):
221
221
self.logger('Client {} was rejected; reason: {}'
222
222
.format(self.properties["Name"], reason))
224
224
def selectable(self):
225
225
"""Make this a "selectable" widget.
226
226
This overrides the method from urwid.FlowWidget."""
229
229
def rows(self, maxcolrow, focus=False):
230
230
"""How many rows this widget will occupy might depend on
231
231
whether we have focus or not.
232
232
This overrides the method from urwid.FlowWidget"""
233
233
return self.current_widget(focus).rows(maxcolrow, focus=focus)
235
235
def current_widget(self, focus=False):
236
236
if focus or self.opened:
237
237
return self._focus_widget
238
238
return self._widget
240
240
def update(self):
241
241
"Called when what is visible on the screen should be updated."
242
242
# How to add standout mode to a style
243
with_standout = { "normal": "standout",
244
"bold": "bold-standout",
246
"underline-blink-standout",
247
"bold-underline-blink":
248
"bold-underline-blink-standout",
243
with_standout = {"normal": "standout",
244
"bold": "bold-standout",
246
"underline-blink-standout",
247
"bold-underline-blink":
248
"bold-underline-blink-standout",
251
251
# Rebuild focus and non-focus widgets using current properties
253
253
# Base part of a client. Name!
254
254
base = '{name}: '.format(name=self.properties["Name"])
255
255
if not self.properties["Enabled"]:
256
256
message = "DISABLED"
257
257
self.using_timer(False)
258
258
elif self.properties["ApprovalPending"]:
259
timeout = datetime.timedelta(milliseconds
259
timeout = datetime.timedelta(
260
milliseconds=self.properties["ApprovalDelay"])
262
261
last_approval_request = isoformat_to_datetime(
263
262
self.properties["LastApprovalRequest"])
264
263
if last_approval_request is not None:
307
306
# Run update hook, if any
308
307
if self.update_hook is not None:
309
308
self.update_hook()
311
310
def update_timer(self):
312
"""called by gobject. Will indefinitely loop until
313
gobject.source_remove() on tag is called"""
311
"""called by GLib. Will indefinitely loop until
312
GLib.source_remove() on tag is called
315
315
return True # Keep calling this
317
317
def delete(self, **kwargs):
318
318
if self._update_timer_callback_tag is not None:
319
gobject.source_remove(self._update_timer_callback_tag)
319
GLib.source_remove(self._update_timer_callback_tag)
320
320
self._update_timer_callback_tag = None
321
321
for match in self.match_objects:
324
324
if self.delete_hook is not None:
325
325
self.delete_hook(self)
326
326
return super(MandosClientWidget, self).delete(**kwargs)
328
328
def render(self, maxcolrow, focus=False):
329
329
"""Render differently if we have focus.
330
330
This overrides the method from urwid.FlowWidget"""
331
331
return self.current_widget(focus).render(maxcolrow,
334
334
def keypress(self, maxcolrow, key):
336
336
This overrides the method from urwid.FlowWidget"""
338
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply = True,
340
dbus_interface = dbus.PROPERTIES_IFACE)
339
dbus.Boolean(True), ignore_reply=True,
340
dbus_interface=dbus.PROPERTIES_IFACE)
342
342
self.proxy.Set(client_interface, "Enabled", False,
344
dbus_interface = dbus.PROPERTIES_IFACE)
344
dbus_interface=dbus.PROPERTIES_IFACE)
346
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
347
dbus_interface = client_interface,
347
dbus_interface=client_interface,
348
348
ignore_reply=True)
350
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
351
dbus_interface = client_interface,
351
dbus_interface=client_interface,
352
352
ignore_reply=True)
353
353
elif key == "R" or key == "_" or key == "ctrl k":
354
354
self.server_proxy_object.RemoveClient(self.proxy
356
356
ignore_reply=True)
358
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply = True,
360
dbus_interface = dbus.PROPERTIES_IFACE)
359
dbus.Boolean(True), ignore_reply=True,
360
dbus_interface=dbus.PROPERTIES_IFACE)
362
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply = True,
364
dbus_interface = dbus.PROPERTIES_IFACE)
363
dbus.Boolean(False), ignore_reply=True,
364
dbus_interface=dbus.PROPERTIES_IFACE)
366
self.proxy.CheckedOK(dbus_interface = client_interface,
366
self.proxy.CheckedOK(dbus_interface=client_interface,
367
367
ignore_reply=True)
369
369
# elif key == "p" or key == "=":
378
378
def properties_changed(self, interface, properties, invalidated):
379
379
"""Call self.update() if any properties changed.
380
380
This overrides the method from MandosClientPropertyCache"""
381
old_values = { key: self.properties.get(key)
382
for key in properties.keys() }
381
old_values = {key: self.properties.get(key)
382
for key in properties.keys()}
383
383
super(MandosClientWidget, self).properties_changed(
384
384
interface, properties, invalidated)
385
385
if any(old_values[key] != self.properties.get(key)
393
393
use them as an excuse to shift focus away from this widget.
395
395
def keypress(self, *args, **kwargs):
396
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
396
ret = (super(ConstrainedListBox, self)
397
.keypress(*args, **kwargs))
397
398
if ret in ("up", "down"):
406
407
def __init__(self, max_log_length=1000, log_level=1):
407
408
DBusGMainLoop(set_as_default=True)
409
410
self.screen = urwid.curses_display.Screen()
411
412
self.screen.register_palette((
413
414
"default", "default", None),
419
420
"standout", "default", "standout"),
420
421
("bold-underline-blink",
421
"bold,underline,blink", "default", "bold,underline,blink"),
422
"bold,underline,blink", "default",
423
"bold,underline,blink"),
422
424
("bold-standout",
423
425
"bold,standout", "default", "bold,standout"),
424
426
("underline-blink-standout",
428
430
"bold,underline,blink,standout", "default",
429
431
"bold,underline,blink,standout"),
432
434
if urwid.supports_unicode():
433
self.divider = "─" # \u2500
434
#self.divider = "━" # \u2501
435
self.divider = "─" # \u2500
436
#self.divider = "-" # \u002d
437
self.divider = "_" # \u005f
437
self.divider = "_" # \u005f
439
439
self.screen.start()
441
441
self.size = self.screen.get_cols_rows()
443
443
self.clients = urwid.SimpleListWalker([])
444
444
self.clients_dict = {}
446
446
# We will add Text widgets to this list
447
self.log = urwid.SimpleListWalker([])
448
448
self.max_log_length = max_log_length
450
450
self.log_level = log_level
452
452
# We keep a reference to the log widget so we can remove it
453
453
# from the ListWalker without it getting destroyed
454
454
self.logbox = ConstrainedListBox(self.log)
456
456
# This keeps track of whether self.uilist currently has
457
457
# self.logbox in it or not
458
458
self.log_visible = True
459
459
self.log_wrap = "any"
462
462
self.log_message_raw(("bold",
463
463
"Mandos Monitor version " + version))
464
464
self.log_message_raw(("bold",
465
465
"q: Quit ?: Help"))
467
467
self.busname = domain + '.Mandos'
468
self.main_loop = gobject.MainLoop()
468
self.main_loop = GLib.MainLoop()
470
470
def client_not_found(self, fingerprint, address):
471
471
self.log_message("Client with address {} and fingerprint {}"
472
472
" could not be found"
473
473
.format(address, fingerprint))
475
475
def rebuild(self):
476
476
"""This rebuilds the User Interface.
477
477
Call this when the widget layout needs to change"""
479
#self.uilist.append(urwid.ListBox(self.clients))
479
# self.uilist.append(urwid.ListBox(self.clients))
480
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
482
#header=urwid.Divider(),
482
# header=urwid.Divider(),
485
urwid.Divider(div_char=
484
footer=urwid.Divider(
485
div_char=self.divider)))
487
486
if self.log_visible:
488
487
self.uilist.append(self.logbox)
489
488
self.topwidget = urwid.Pile(self.uilist)
491
490
def log_message(self, message, level=1):
492
491
"""Log message formatted with timestamp"""
493
492
if level < self.log_level:
495
494
timestamp = datetime.datetime.now().isoformat()
496
495
self.log_message_raw("{}: {}".format(timestamp, message),
499
498
def log_message_raw(self, markup, level=1):
500
499
"""Add a log message to the log buffer."""
501
500
if level < self.log_level:
503
502
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
504
if (self.max_log_length
505
and len(self.log) > self.max_log_length):
506
del self.log[0:len(self.log)-self.max_log_length-1]
507
self.logbox.set_focus(len(self.logbox.body.contents),
503
if self.max_log_length:
504
if len(self.log) > self.max_log_length:
505
del self.log[0:len(self.log)-self.max_log_length-1]
506
self.logbox.set_focus(len(self.logbox.body.contents)-1,
508
507
coming_from="above")
511
510
def toggle_log_display(self):
512
511
"""Toggle visibility of the log buffer."""
513
512
self.log_visible = not self.log_visible
515
514
self.log_message("Log visibility changed to: {}"
516
515
.format(self.log_visible), level=0)
518
517
def change_log_display(self):
519
518
"""Change type of log display.
520
519
Currently, this toggles wrapping of text lines."""
526
525
textwidget.set_wrap_mode(self.log_wrap)
527
526
self.log_message("Wrap mode: {}".format(self.log_wrap),
530
529
def find_and_remove_client(self, path, interfaces):
531
530
"""Find a client by its object path and remove it.
533
532
This is connected to the InterfacesRemoved signal from the
534
533
Mandos server object."""
535
534
if client_interface not in interfaces:
554
553
# Not a Mandos client object; ignore
556
555
client_proxy_object = self.bus.get_object(self.busname, path)
557
self.add_client(MandosClientWidget(server_proxy_object
560
=client_proxy_object,
568
= dict(ifs_and_props[
556
self.add_client(MandosClientWidget(
557
server_proxy_object=self.mandos_serv,
558
proxy_object=client_proxy_object,
559
update_hook=self.refresh,
560
delete_hook=self.remove_client,
561
logger=self.log_message,
562
properties=dict(ifs_and_props[client_interface])),
572
565
def add_client(self, client, path=None):
573
566
self.clients.append(client)
576
569
self.clients_dict[path] = client
577
570
self.clients.sort(key=lambda c: c.properties["Name"])
580
573
def remove_client(self, client, path=None):
581
574
self.clients.remove(client)
583
576
path = client.proxy.object_path
584
577
del self.clients_dict[path]
587
580
def refresh(self):
588
581
"""Redraw the screen"""
589
582
canvas = self.topwidget.render(self.size, focus=True)
590
583
self.screen.draw_screen(self.size, canvas)
593
586
"""Start the main loop and exit when it's done."""
594
587
self.bus = dbus.SystemBus()
595
588
mandos_dbus_objc = self.bus.get_object(
596
589
self.busname, "/", follow_name_owner_changes=True)
597
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
601
593
mandos_clients = (self.mandos_serv
602
594
.GetAllClientsWithProperties())
603
595
if not mandos_clients:
604
self.log_message_raw(("bold", "Note: Server has no clients."))
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
605
598
except dbus.exceptions.DBusException:
606
self.log_message_raw(("bold", "Note: No Mandos server running."))
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
607
601
mandos_clients = dbus.Dictionary()
609
603
(self.mandos_serv
610
604
.connect_to_signal("InterfacesRemoved",
611
605
self.find_and_remove_client,
613
= dbus.OBJECT_MANAGER_IFACE,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
614
607
byte_arrays=True))
615
608
(self.mandos_serv
616
609
.connect_to_signal("InterfacesAdded",
617
610
self.add_new_client,
619
= dbus.OBJECT_MANAGER_IFACE,
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
620
612
byte_arrays=True))
621
613
(self.mandos_serv
622
614
.connect_to_signal("ClientNotFound",
626
618
for path, client in mandos_clients.items():
627
619
client_proxy_object = self.bus.get_object(self.busname,
629
self.add_client(MandosClientWidget(server_proxy_object
632
=client_proxy_object,
621
self.add_client(MandosClientWidget(
622
server_proxy_object=self.mandos_serv,
623
proxy_object=client_proxy_object,
625
update_hook=self.refresh,
626
delete_hook=self.remove_client,
627
logger=self.log_message),
643
self._input_callback_tag = (gobject.io_add_watch
631
self._input_callback_tag = (
633
GLib.IOChannel.unix_new(sys.stdin.fileno()),
634
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
647
636
self.main_loop.run()
648
637
# Main loop has finished, we should close everything now
649
gobject.source_remove(self._input_callback_tag)
638
GLib.source_remove(self._input_callback_tag)
650
639
self.screen.stop()
653
642
self.main_loop.quit()
655
644
def process_input(self, source, condition):
656
645
keys = self.screen.get_input()
657
translations = { "ctrl n": "down", # Emacs
658
"ctrl p": "up", # Emacs
659
"ctrl v": "page down", # Emacs
660
"meta v": "page up", # Emacs
661
" ": "page down", # less
662
"f": "page down", # less
663
"b": "page up", # less
646
translations = {"ctrl n": "down", # Emacs
647
"ctrl p": "up", # Emacs
648
"ctrl v": "page down", # Emacs
649
"meta v": "page up", # Emacs
650
" ": "page down", # less
651
"f": "page down", # less
652
"b": "page up", # less
669
658
key = translations[key]
670
659
except KeyError: # :-)
673
662
if key == "q" or key == "Q":
724
713
self.log_level = 0
725
714
self.log_message("Verbose mode: On")
726
#elif (key == "end" or key == "meta >" or key == "G"
728
# pass # xxx end-of-buffer
729
#elif (key == "home" or key == "meta <" or key == "g"
731
# pass # xxx beginning-of-buffer
732
#elif key == "ctrl e" or key == "$":
733
# pass # xxx move-end-of-line
734
#elif key == "ctrl a" or key == "^":
735
# pass # xxx move-beginning-of-line
736
#elif key == "ctrl b" or key == "meta (" or key == "h":
738
#elif key == "ctrl f" or key == "meta )" or key == "l":
741
# pass # scroll up log
743
# pass # scroll down log
715
# elif (key == "end" or key == "meta >" or key == "G"
717
# pass # xxx end-of-buffer
718
# elif (key == "home" or key == "meta <" or key == "g"
720
# pass # xxx beginning-of-buffer
721
# elif key == "ctrl e" or key == "$":
722
# pass # xxx move-end-of-line
723
# elif key == "ctrl a" or key == "^":
724
# pass # xxx move-beginning-of-line
725
# elif key == "ctrl b" or key == "meta (" or key == "h":
727
# elif key == "ctrl f" or key == "meta )" or key == "l":
730
# pass # scroll up log
732
# pass # scroll down log
744
733
elif self.topwidget.selectable():
745
734
self.topwidget.keypress(self.size, key)
749
739
ui = UserInterface()