2
2
# -*- mode: python; coding: utf-8 -*-
4
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
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,
38
39
import urwid.curses_display
41
42
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
43
from gi.repository import GLib
51
if sys.version_info[0] == 2:
51
if sys.version_info.major == 2:
54
log = logging.getLogger(os.path.basename(sys.argv[0]))
55
logging.basicConfig(level="NOTSET", # Show all messages
56
format="%(message)s") # Show basic log messages
58
logging.captureWarnings(True) # Show warnings via the logging system
54
60
locale.setlocale(locale.LC_ALL, '')
57
62
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
59
64
# Some useful constants
60
65
domain = 'se.recompile'
61
66
server_interface = domain + '.Mandos'
62
67
client_interface = domain + '.Mandos.Client'
71
dbus.OBJECT_MANAGER_IFACE
72
except AttributeError:
73
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
65
76
def isoformat_to_datetime(iso):
66
77
"Parse an ISO 8601 date string to a datetime.datetime()"
86
98
def __init__(self, proxy_object=None, properties=None, **kwargs):
87
self.proxy = proxy_object # Mandos Client proxy object
99
self.proxy = proxy_object # Mandos Client proxy object
88
100
self.properties = dict() if properties is None else properties
89
101
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertyChanged",
91
self._property_changed,
102
self.proxy.connect_to_signal("PropertiesChanged",
103
self.properties_changed,
104
dbus.PROPERTIES_IFACE,
93
105
byte_arrays=True))
95
107
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
99
= dbus.PROPERTIES_IFACE))
108
self.properties.update(self.proxy.GetAll(
110
dbus_interface=dbus.PROPERTIES_IFACE))
101
112
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)
107
def property_changed(self, property=None, value=None):
108
"""This is called whenever we get a PropertyChanged signal
109
It updates the changed property in the "properties" dict.
114
def properties_changed(self, interface, properties, invalidated):
115
"""This is called whenever we get a PropertiesChanged signal
116
It updates the changed properties in the "properties" dict.
111
118
# Update properties dict with new value
112
self.properties[property] = value
119
if interface == client_interface:
120
self.properties.update(properties)
114
122
def delete(self):
115
123
self.property_changed_match.remove()
162
168
client_interface,
163
169
byte_arrays=True))
164
self.logger('Created client {}'
165
.format(self.properties["Name"]), level=0)
170
log.debug('Created client %s', self.properties["Name"])
167
172
def using_timer(self, flag):
168
173
"""Call this method with True or False when timer should be
169
174
activated or deactivated.
171
176
if flag and self._update_timer_callback_tag is None:
172
177
# Will update the shown timer value every second
173
self._update_timer_callback_tag = (gobject.timeout_add
178
self._update_timer_callback_tag = (
179
GLib.timeout_add(1000,
180
glib_safely(self.update_timer)))
176
181
elif not (flag or self._update_timer_callback_tag is None):
177
gobject.source_remove(self._update_timer_callback_tag)
182
GLib.source_remove(self._update_timer_callback_tag)
178
183
self._update_timer_callback_tag = None
180
185
def checker_completed(self, exitstatus, condition, command):
181
186
if exitstatus == 0:
182
self.logger('Checker for client {} (command "{}")'
183
' succeeded'.format(self.properties["Name"],
187
log.debug('Checker for client %s (command "%s")'
188
' succeeded', self.properties["Name"], command)
188
192
if os.WIFEXITED(condition):
189
self.logger('Checker for client {} (command "{}") failed'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
193
log.info('Checker for client %s (command "%s") failed'
194
' with exit code %d', self.properties["Name"],
195
command, os.WEXITSTATUS(condition))
193
196
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"]))
197
log.info('Checker for client %s (command "%s") was'
198
' killed by signal %d', self.properties["Name"],
199
command, os.WTERMSIG(condition))
208
202
def checker_started(self, command):
209
203
"""Server signals that a checker started."""
210
self.logger('Client {} started checker "{}"'
211
.format(self.properties["Name"],
204
log.debug('Client %s started checker "%s"',
205
self.properties["Name"], command)
214
207
def got_secret(self):
215
self.logger('Client {} received its secret'
216
.format(self.properties["Name"]))
208
log.info("Client %s received its secret",
209
self.properties["Name"])
218
211
def need_approval(self, timeout, default):
220
message = 'Client {} needs approval within {} seconds'
213
message = "Client %s needs approval within %f seconds"
222
message = 'Client {} will get its secret in {} seconds'
223
self.logger(message.format(self.properties["Name"],
215
message = "Client %s will get its secret in %f seconds"
216
log.info(message, self.properties["Name"], timeout/1000)
226
218
def rejected(self, reason):
227
self.logger('Client {} was rejected; reason: {}'
228
.format(self.properties["Name"], reason))
219
log.info("Client %s was rejected; reason: %s",
220
self.properties["Name"], reason)
230
222
def selectable(self):
231
223
"""Make this a "selectable" widget.
232
224
This overrides the method from urwid.FlowWidget."""
235
227
def rows(self, maxcolrow, focus=False):
236
228
"""How many rows this widget will occupy might depend on
237
229
whether we have focus or not.
238
230
This overrides the method from urwid.FlowWidget"""
239
231
return self.current_widget(focus).rows(maxcolrow, focus=focus)
241
233
def current_widget(self, focus=False):
242
234
if focus or self.opened:
243
235
return self._focus_widget
244
236
return self._widget
246
238
def update(self):
247
239
"Called when what is visible on the screen should be updated."
248
240
# 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",
241
with_standout = {"normal": "standout",
242
"bold": "bold-standout",
244
"underline-blink-standout",
245
"bold-underline-blink":
246
"bold-underline-blink-standout",
257
249
# Rebuild focus and non-focus widgets using current properties
259
251
# Base part of a client. Name!
260
252
base = '{name}: '.format(name=self.properties["Name"])
261
253
if not self.properties["Enabled"]:
262
254
message = "DISABLED"
263
255
self.using_timer(False)
264
256
elif self.properties["ApprovalPending"]:
265
timeout = datetime.timedelta(milliseconds
257
timeout = datetime.timedelta(
258
milliseconds=self.properties["ApprovalDelay"])
268
259
last_approval_request = isoformat_to_datetime(
269
260
self.properties["LastApprovalRequest"])
270
261
if last_approval_request is not None:
330
322
if self.delete_hook is not None:
331
323
self.delete_hook(self)
332
324
return super(MandosClientWidget, self).delete(**kwargs)
334
326
def render(self, maxcolrow, focus=False):
335
327
"""Render differently if we have focus.
336
328
This overrides the method from urwid.FlowWidget"""
337
329
return self.current_widget(focus).render(maxcolrow,
340
332
def keypress(self, maxcolrow, key):
342
334
This overrides the method from urwid.FlowWidget"""
344
self.proxy.Enable(dbus_interface = client_interface,
336
self.proxy.Set(client_interface, "Enabled",
337
dbus.Boolean(True), ignore_reply=True,
338
dbus_interface=dbus.PROPERTIES_IFACE)
347
self.proxy.Disable(dbus_interface = client_interface,
340
self.proxy.Set(client_interface, "Enabled", False,
342
dbus_interface=dbus.PROPERTIES_IFACE)
350
344
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
351
dbus_interface = client_interface,
345
dbus_interface=client_interface,
352
346
ignore_reply=True)
354
348
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
355
dbus_interface = client_interface,
349
dbus_interface=client_interface,
356
350
ignore_reply=True)
357
351
elif key == "R" or key == "_" or key == "ctrl k":
358
352
self.server_proxy_object.RemoveClient(self.proxy
360
354
ignore_reply=True)
362
self.proxy.StartChecker(dbus_interface = client_interface,
356
self.proxy.Set(client_interface, "CheckerRunning",
357
dbus.Boolean(True), ignore_reply=True,
358
dbus_interface=dbus.PROPERTIES_IFACE)
365
self.proxy.StopChecker(dbus_interface = client_interface,
360
self.proxy.Set(client_interface, "CheckerRunning",
361
dbus.Boolean(False), ignore_reply=True,
362
dbus_interface=dbus.PROPERTIES_IFACE)
368
self.proxy.CheckedOK(dbus_interface = client_interface,
364
self.proxy.CheckedOK(dbus_interface=client_interface,
369
365
ignore_reply=True)
371
367
# elif key == "p" or key == "=":
380
def property_changed(self, property=None, **kwargs):
381
"""Call self.update() if old value is not new value.
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
382
378
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
384
old_value = self.properties.get(property_name)
385
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
387
if self.properties.get(property_name) != old_value:
379
old_values = {key: self.properties.get(key)
380
for key in properties.keys()}
381
super(MandosClientWidget, self).properties_changed(
382
interface, properties, invalidated)
383
if any(old_values[key] != self.properties.get(key)
384
for key in old_values):
388
def glib_safely(func, retval=True):
389
def safe_func(*args, **kwargs):
391
return func(*args, **kwargs)
391
398
class ConstrainedListBox(urwid.ListBox):
392
399
"""Like a normal urwid.ListBox, but will consume all "up" or
393
400
"down" key presses, thus not allowing any containing widgets to
394
401
use them as an excuse to shift focus away from this widget.
396
403
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
404
ret = (super(ConstrainedListBox, self)
405
.keypress(*args, **kwargs))
398
406
if ret in ("up", "down"):
429
438
"bold,underline,blink,standout", "default",
430
439
"bold,underline,blink,standout"),
433
442
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
443
self.divider = "─" # \u2500
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
445
self.divider = "_" # \u005f
440
447
self.screen.start()
442
449
self.size = self.screen.get_cols_rows()
444
451
self.clients = urwid.SimpleListWalker([])
445
452
self.clients_dict = {}
447
454
# We will add Text widgets to this list
455
self.log = urwid.SimpleListWalker([])
449
456
self.max_log_length = max_log_length
451
self.log_level = log_level
453
458
# We keep a reference to the log widget so we can remove it
454
459
# from the ListWalker without it getting destroyed
455
460
self.logbox = ConstrainedListBox(self.log)
457
462
# This keeps track of whether self.uilist currently has
458
463
# self.logbox in it or not
459
464
self.log_visible = True
460
465
self.log_wrap = "any"
467
self.loghandler = UILogHandler(self)
463
self.log_message_raw(("bold",
464
"Mandos Monitor version " + version))
465
self.log_message_raw(("bold",
470
self.add_log_line(("bold",
471
"Mandos Monitor version " + version))
472
self.add_log_line(("bold", "q: Quit ?: Help"))
468
474
self.busname = domain + '.Mandos'
469
self.main_loop = gobject.MainLoop()
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))
475
self.main_loop = GLib.MainLoop()
477
def client_not_found(self, key_id, address):
478
log.info("Client with address %s and key ID %s could"
479
" not be found", address, key_id)
476
481
def rebuild(self):
477
482
"""This rebuilds the User Interface.
478
483
Call this when the widget layout needs to change"""
480
#self.uilist.append(urwid.ListBox(self.clients))
485
# self.uilist.append(urwid.ListBox(self.clients))
481
486
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
483
#header=urwid.Divider(),
488
# header=urwid.Divider(),
486
urwid.Divider(div_char=
490
footer=urwid.Divider(
491
div_char=self.divider)))
488
492
if self.log_visible:
489
493
self.uilist.append(self.logbox)
490
494
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:
496
def add_log_line(self, markup):
504
497
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),
498
if self.max_log_length:
499
if len(self.log) > self.max_log_length:
500
del self.log[0:(len(self.log) - self.max_log_length)]
501
self.logbox.set_focus(len(self.logbox.body.contents)-1,
509
502
coming_from="above")
512
505
def toggle_log_display(self):
513
506
"""Toggle visibility of the log buffer."""
514
507
self.log_visible = not self.log_visible
516
self.log_message("Log visibility changed to: {}"
517
.format(self.log_visible), level=0)
509
log.debug("Log visibility changed to: %s", self.log_visible)
519
511
def change_log_display(self):
520
512
"""Change type of log display.
521
513
Currently, this toggles wrapping of text lines."""
525
517
self.log_wrap = "clip"
526
518
for textwidget in self.log:
527
519
textwidget.set_wrap_mode(self.log_wrap)
528
self.log_message("Wrap mode: {}".format(self.log_wrap),
531
def find_and_remove_client(self, path, name):
520
log.debug("Wrap mode: %s", self.log_wrap)
522
def find_and_remove_client(self, path, interfaces):
532
523
"""Find a client by its object path and remove it.
534
This is connected to the ClientRemoved signal from the
525
This is connected to the InterfacesRemoved signal from the
535
526
Mandos server object."""
527
if client_interface not in interfaces:
528
# Not a Mandos client object; ignore
537
531
client = self.clients_dict[path]
540
self.log_message("Unknown client {!r} ({!r}) removed"
534
log.warning("Unknown client %s removed", path)
545
def add_new_client(self, path):
538
def add_new_client(self, path, ifs_and_props):
539
"""Find a client by its object path and remove it.
541
This is connected to the InterfacesAdded signal from the
542
Mandos server object.
544
if client_interface not in ifs_and_props:
545
# Not a Mandos client object; ignore
546
547
client_proxy_object = self.bus.get_object(self.busname, path)
547
self.add_client(MandosClientWidget(server_proxy_object
550
=client_proxy_object,
548
self.add_client(MandosClientWidget(
549
server_proxy_object=self.mandos_serv,
550
proxy_object=client_proxy_object,
551
update_hook=self.refresh,
552
delete_hook=self.remove_client,
553
properties=dict(ifs_and_props[client_interface])),
559
556
def add_client(self, client, path=None):
560
557
self.clients.append(client)
563
560
self.clients_dict[path] = client
564
561
self.clients.sort(key=lambda c: c.properties["Name"])
567
564
def remove_client(self, client, path=None):
568
565
self.clients.remove(client)
570
567
path = client.proxy.object_path
571
568
del self.clients_dict[path]
574
571
def refresh(self):
575
572
"""Redraw the screen"""
576
573
canvas = self.topwidget.render(self.size, focus=True)
577
574
self.screen.draw_screen(self.size, canvas)
580
577
"""Start the main loop and exit when it's done."""
578
log.addHandler(self.loghandler)
579
self.orig_log_propagate = log.propagate
580
log.propagate = False
581
self.orig_log_level = log.level
581
583
self.bus = dbus.SystemBus()
582
584
mandos_dbus_objc = self.bus.get_object(
583
585
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
586
self.mandos_serv = dbus.Interface(
587
mandos_dbus_objc, dbus_interface=server_interface)
588
589
mandos_clients = (self.mandos_serv
589
590
.GetAllClientsWithProperties())
590
591
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
log.warning("Note: Server has no clients.")
592
593
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
log.warning("Note: No Mandos server running.")
594
595
mandos_clients = dbus.Dictionary()
596
597
(self.mandos_serv
597
.connect_to_signal("ClientRemoved",
598
.connect_to_signal("InterfacesRemoved",
598
599
self.find_and_remove_client,
599
dbus_interface=server_interface,
600
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
600
601
byte_arrays=True))
601
602
(self.mandos_serv
602
.connect_to_signal("ClientAdded",
603
.connect_to_signal("InterfacesAdded",
603
604
self.add_new_client,
604
dbus_interface=server_interface,
605
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
605
606
byte_arrays=True))
606
607
(self.mandos_serv
607
608
.connect_to_signal("ClientNotFound",
611
612
for path, client in mandos_clients.items():
612
613
client_proxy_object = self.bus.get_object(self.busname,
614
self.add_client(MandosClientWidget(server_proxy_object
617
=client_proxy_object,
615
self.add_client(MandosClientWidget(
616
server_proxy_object=self.mandos_serv,
617
proxy_object=client_proxy_object,
619
update_hook=self.refresh,
620
delete_hook=self.remove_client),
628
self._input_callback_tag = (gobject.io_add_watch
624
self._input_callback_tag = (
626
GLib.IOChannel.unix_new(sys.stdin.fileno()),
627
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
628
glib_safely(self.process_input)))
632
629
self.main_loop.run()
633
630
# Main loop has finished, we should close everything now
634
gobject.source_remove(self._input_callback_tag)
631
GLib.source_remove(self._input_callback_tag)
632
with warnings.catch_warnings():
633
warnings.simplefilter("ignore", BytesWarning)
638
637
self.main_loop.quit()
638
log.removeHandler(self.loghandler)
639
log.propagate = self.orig_log_propagate
640
641
def process_input(self, source, condition):
641
642
keys = self.screen.get_input()
642
translations = { "ctrl n": "down", # Emacs
643
"ctrl p": "up", # Emacs
644
"ctrl v": "page down", # Emacs
645
"meta v": "page up", # Emacs
646
" ": "page down", # less
647
"f": "page down", # less
648
"b": "page up", # less
643
translations = {"ctrl n": "down", # Emacs
644
"ctrl p": "up", # Emacs
645
"ctrl v": "page down", # Emacs
646
"meta v": "page up", # Emacs
647
" ": "page down", # less
648
"f": "page down", # less
649
"b": "page up", # less
654
655
key = translations[key]
655
656
except KeyError: # :-)
658
659
if key == "q" or key == "Q":
702
702
self.topwidget.set_focus(self.logbox)
705
if self.log_level == 0:
707
self.log_message("Verbose mode: Off")
705
if log.level < logging.INFO:
706
log.setLevel(logging.INFO)
707
log.info("Verbose mode: Off")
710
self.log_message("Verbose mode: On")
711
#elif (key == "end" or key == "meta >" or key == "G"
713
# pass # xxx end-of-buffer
714
#elif (key == "home" or key == "meta <" or key == "g"
716
# pass # xxx beginning-of-buffer
717
#elif key == "ctrl e" or key == "$":
718
# pass # xxx move-end-of-line
719
#elif key == "ctrl a" or key == "^":
720
# pass # xxx move-beginning-of-line
721
#elif key == "ctrl b" or key == "meta (" or key == "h":
723
#elif key == "ctrl f" or key == "meta )" or key == "l":
726
# pass # scroll up log
728
# pass # scroll down log
709
log.setLevel(logging.NOTSET)
710
log.info("Verbose mode: On")
711
# elif (key == "end" or key == "meta >" or key == "G"
713
# pass # xxx end-of-buffer
714
# elif (key == "home" or key == "meta <" or key == "g"
716
# pass # xxx beginning-of-buffer
717
# elif key == "ctrl e" or key == "$":
718
# pass # xxx move-end-of-line
719
# elif key == "ctrl a" or key == "^":
720
# pass # xxx move-beginning-of-line
721
# elif key == "ctrl b" or key == "meta (" or key == "h":
723
# elif key == "ctrl f" or key == "meta )" or key == "l":
726
# pass # scroll up log
728
# pass # scroll down log
729
729
elif self.topwidget.selectable():
730
730
self.topwidget.keypress(self.size, key)
735
class UILogHandler(logging.Handler):
736
def __init__(self, ui, *args, **kwargs):
738
super(UILogHandler, self).__init__(*args, **kwargs)
740
logging.Formatter("%(asctime)s: %(message)s"))
741
def emit(self, record):
742
msg = self.format(record)
743
if record.levelno > logging.INFO:
745
self.ui.add_log_line(msg)
734
748
ui = UserInterface()
737
751
except KeyboardInterrupt:
739
except Exception as e:
740
ui.log_message(str(e))
752
with warnings.catch_warnings():
753
warnings.filterwarnings("ignore", "", BytesWarning)
756
with warnings.catch_warnings():
757
warnings.filterwarnings("ignore", "", BytesWarning)