2
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2012 Teddy Hogeborn
7
# Copyright © 2009-2012 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,
29
from future_builtins import *
30
from future_builtins import *
89
92
def __init__(self, proxy_object=None, properties=None, **kwargs):
90
self.proxy = proxy_object # Mandos Client proxy object
93
self.proxy = proxy_object # Mandos Client proxy object
91
94
self.properties = dict() if properties is None else properties
92
95
self.property_changed_match = (
93
self.proxy.connect_to_signal("PropertyChanged",
94
self._property_changed,
96
self.proxy.connect_to_signal("PropertiesChanged",
97
self.properties_changed,
98
dbus.PROPERTIES_IFACE,
98
101
if properties is None:
99
self.properties.update(
100
self.proxy.GetAll(client_interface,
102
= dbus.PROPERTIES_IFACE))
102
self.properties.update(self.proxy.GetAll(
104
dbus_interface=dbus.PROPERTIES_IFACE))
104
106
super(MandosClientPropertyCache, self).__init__(**kwargs)
106
def _property_changed(self, property, value):
107
"""Helper which takes positional arguments"""
108
return self.property_changed(property=property, value=value)
110
def property_changed(self, property=None, value=None):
111
"""This is called whenever we get a PropertyChanged signal
112
It updates the changed property in the "properties" dict.
108
def properties_changed(self, interface, properties, invalidated):
109
"""This is called whenever we get a PropertiesChanged signal
110
It updates the changed properties in the "properties" dict.
114
112
# Update properties dict with new value
115
self.properties[property] = value
113
if interface == client_interface:
114
self.properties.update(properties)
117
116
def delete(self):
118
117
self.property_changed_match.remove()
175
164
client_interface,
176
165
byte_arrays=True))
177
#self.logger('Created client {0}'
178
# .format(self.properties["Name"]))
180
def property_changed(self, property=None, value=None):
181
super(self, MandosClientWidget).property_changed(property,
183
if property == "ApprovalPending":
184
using_timer(bool(value))
185
if property == "LastCheckerStatus":
186
using_timer(value != 0)
187
#self.logger('Checker for client {0} (command "{1}") was '
188
# ' successful'.format(self.properties["Name"],
166
self.logger('Created client {}'
167
.format(self.properties["Name"]), level=0)
191
169
def using_timer(self, flag):
192
170
"""Call this method with True or False when timer should be
193
171
activated or deactivated.
195
old = self._update_timer_callback_lock
197
self._update_timer_callback_lock += 1
199
self._update_timer_callback_lock -= 1
200
if old == 0 and self._update_timer_callback_lock:
173
if flag and self._update_timer_callback_tag is None:
201
174
# Will update the shown timer value every second
202
self._update_timer_callback_tag = (gobject.timeout_add
175
self._update_timer_callback_tag = (GLib.timeout_add
204
177
self.update_timer))
205
elif old and self._update_timer_callback_lock == 0:
206
gobject.source_remove(self._update_timer_callback_tag)
178
elif not (flag or self._update_timer_callback_tag is None):
179
GLib.source_remove(self._update_timer_callback_tag)
207
180
self._update_timer_callback_tag = None
209
182
def checker_completed(self, exitstatus, condition, command):
210
183
if exitstatus == 0:
184
self.logger('Checker for client {} (command "{}")'
185
' succeeded'.format(self.properties["Name"],
214
190
if os.WIFEXITED(condition):
215
self.logger('Checker for client {0} (command "{1}")'
216
' failed with exit code {2}'
191
self.logger('Checker for client {} (command "{}") failed'
217
193
.format(self.properties["Name"], command,
218
194
os.WEXITSTATUS(condition)))
219
195
elif os.WIFSIGNALED(condition):
220
self.logger('Checker for client {0} (command "{1}") was'
221
' killed by signal {2}'
196
self.logger('Checker for client {} (command "{}") was'
197
' killed by signal {}'
222
198
.format(self.properties["Name"], command,
223
199
os.WTERMSIG(condition)))
224
elif os.WCOREDUMP(condition):
225
self.logger('Checker for client {0} (command "{1}")'
227
.format(self.properties["Name"], command))
229
self.logger('Checker for client {0} completed'
231
.format(self.properties["Name"]))
234
202
def checker_started(self, command):
235
"""Server signals that a checker started. This could be useful
236
to log in the future. """
237
#self.logger('Client {0} started checker "{1}"'
238
# .format(self.properties["Name"],
203
"""Server signals that a checker started."""
204
self.logger('Client {} started checker "{}"'
205
.format(self.properties["Name"],
242
208
def got_secret(self):
243
self.logger('Client {0} received its secret'
209
self.logger('Client {} received its secret'
244
210
.format(self.properties["Name"]))
246
212
def need_approval(self, timeout, default):
248
message = 'Client {0} needs approval within {1} seconds'
214
message = 'Client {} needs approval within {} seconds'
250
message = 'Client {0} will get its secret in {1} seconds'
216
message = 'Client {} will get its secret in {} seconds'
251
217
self.logger(message.format(self.properties["Name"],
253
self.using_timer(True)
255
220
def rejected(self, reason):
256
self.logger('Client {0} was rejected; reason: {1}'
221
self.logger('Client {} was rejected; reason: {}'
257
222
.format(self.properties["Name"], reason))
259
224
def selectable(self):
260
225
"""Make this a "selectable" widget.
261
226
This overrides the method from urwid.FlowWidget."""
264
229
def rows(self, maxcolrow, focus=False):
265
230
"""How many rows this widget will occupy might depend on
266
231
whether we have focus or not.
267
232
This overrides the method from urwid.FlowWidget"""
268
233
return self.current_widget(focus).rows(maxcolrow, focus=focus)
270
235
def current_widget(self, focus=False):
271
236
if focus or self.opened:
272
237
return self._focus_widget
273
238
return self._widget
275
240
def update(self):
276
241
"Called when what is visible on the screen should be updated."
277
242
# How to add standout mode to a style
278
with_standout = { "normal": "standout",
279
"bold": "bold-standout",
281
"underline-blink-standout",
282
"bold-underline-blink":
283
"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",
286
251
# Rebuild focus and non-focus widgets using current properties
289
254
base = '{name}: '.format(name=self.properties["Name"])
290
255
if not self.properties["Enabled"]:
291
256
message = "DISABLED"
257
self.using_timer(False)
292
258
elif self.properties["ApprovalPending"]:
293
timeout = datetime.timedelta(milliseconds
259
timeout = datetime.timedelta(
260
milliseconds=self.properties["ApprovalDelay"])
296
261
last_approval_request = isoformat_to_datetime(
297
262
self.properties["LastApprovalRequest"])
298
263
if last_approval_request is not None:
299
timer = timeout - (datetime.datetime.utcnow()
300
- last_approval_request)
264
timer = max(timeout - (datetime.datetime.utcnow()
265
- last_approval_request),
266
datetime.timedelta())
302
268
timer = datetime.timedelta()
303
269
if self.properties["ApprovedByDefault"]:
304
message = "Approval in {0}. (d)eny?"
270
message = "Approval in {}. (d)eny?"
306
message = "Denial in {0}. (a)pprove?"
307
message = message.format(unicode(timer).rsplit(".", 1)[0])
272
message = "Denial in {}. (a)pprove?"
273
message = message.format(str(timer).rsplit(".", 1)[0])
274
self.using_timer(True)
308
275
elif self.properties["LastCheckerStatus"] != 0:
309
276
# When checker has failed, show timer until client expires
310
277
expires = self.properties["Expires"]
353
324
if self.delete_hook is not None:
354
325
self.delete_hook(self)
355
326
return super(MandosClientWidget, self).delete(**kwargs)
357
328
def render(self, maxcolrow, focus=False):
358
329
"""Render differently if we have focus.
359
330
This overrides the method from urwid.FlowWidget"""
360
331
return self.current_widget(focus).render(maxcolrow,
363
334
def keypress(self, maxcolrow, key):
365
336
This overrides the method from urwid.FlowWidget"""
367
self.proxy.Enable(dbus_interface = client_interface,
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply=True,
340
dbus_interface=dbus.PROPERTIES_IFACE)
370
self.proxy.Disable(dbus_interface = client_interface,
342
self.proxy.Set(client_interface, "Enabled", False,
344
dbus_interface=dbus.PROPERTIES_IFACE)
373
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
374
dbus_interface = client_interface,
347
dbus_interface=client_interface,
375
348
ignore_reply=True)
377
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
378
dbus_interface = client_interface,
351
dbus_interface=client_interface,
379
352
ignore_reply=True)
380
353
elif key == "R" or key == "_" or key == "ctrl k":
381
354
self.server_proxy_object.RemoveClient(self.proxy
383
356
ignore_reply=True)
385
self.proxy.StartChecker(dbus_interface = client_interface,
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply=True,
360
dbus_interface=dbus.PROPERTIES_IFACE)
388
self.proxy.StopChecker(dbus_interface = client_interface,
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply=True,
364
dbus_interface=dbus.PROPERTIES_IFACE)
391
self.proxy.CheckedOK(dbus_interface = client_interface,
366
self.proxy.CheckedOK(dbus_interface=client_interface,
392
367
ignore_reply=True)
394
369
# elif key == "p" or key == "=":
427
404
"""This is the entire user interface - the whole screen
428
405
with boxes, lists of client widgets, etc.
430
def __init__(self, max_log_length=1000):
407
def __init__(self, max_log_length=1000, log_level=1):
431
408
DBusGMainLoop(set_as_default=True)
433
410
self.screen = urwid.curses_display.Screen()
435
412
self.screen.register_palette((
437
414
"default", "default", None),
439
"default", "default", "bold"),
416
"bold", "default", "bold"),
440
417
("underline-blink",
441
"default", "default", "underline"),
418
"underline,blink", "default", "underline,blink"),
443
"default", "default", "standout"),
420
"standout", "default", "standout"),
444
421
("bold-underline-blink",
445
"default", "default", ("bold", "underline")),
422
"bold,underline,blink", "default",
423
"bold,underline,blink"),
446
424
("bold-standout",
447
"default", "default", ("bold", "standout")),
425
"bold,standout", "default", "bold,standout"),
448
426
("underline-blink-standout",
449
"default", "default", ("underline", "standout")),
427
"underline,blink,standout", "default",
428
"underline,blink,standout"),
450
429
("bold-underline-blink-standout",
451
"default", "default", ("bold", "underline",
430
"bold,underline,blink,standout", "default",
431
"bold,underline,blink,standout"),
455
434
if urwid.supports_unicode():
456
self.divider = "─" # \u2500
457
#self.divider = "━" # \u2501
435
self.divider = "─" # \u2500
459
#self.divider = "-" # \u002d
460
self.divider = "_" # \u005f
437
self.divider = "_" # \u005f
462
439
self.screen.start()
464
441
self.size = self.screen.get_cols_rows()
466
443
self.clients = urwid.SimpleListWalker([])
467
444
self.clients_dict = {}
469
446
# We will add Text widgets to this list
447
self.log = urwid.SimpleListWalker([])
471
448
self.max_log_length = max_log_length
450
self.log_level = log_level
473
452
# We keep a reference to the log widget so we can remove it
474
453
# from the ListWalker without it getting destroyed
475
454
self.logbox = ConstrainedListBox(self.log)
477
456
# This keeps track of whether self.uilist currently has
478
457
# self.logbox in it or not
479
458
self.log_visible = True
480
459
self.log_wrap = "any"
483
462
self.log_message_raw(("bold",
484
463
"Mandos Monitor version " + version))
485
464
self.log_message_raw(("bold",
486
465
"q: Quit ?: Help"))
488
467
self.busname = domain + '.Mandos'
489
self.main_loop = gobject.MainLoop()
468
self.main_loop = GLib.MainLoop()
491
470
def client_not_found(self, fingerprint, address):
492
self.log_message("Client with address {0} and fingerprint"
493
" {1} could not be found"
471
self.log_message("Client with address {} and fingerprint {}"
472
" could not be found"
494
473
.format(address, fingerprint))
496
475
def rebuild(self):
497
476
"""This rebuilds the User Interface.
498
477
Call this when the widget layout needs to change"""
500
#self.uilist.append(urwid.ListBox(self.clients))
479
# self.uilist.append(urwid.ListBox(self.clients))
501
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
503
#header=urwid.Divider(),
482
# header=urwid.Divider(),
506
urwid.Divider(div_char=
484
footer=urwid.Divider(
485
div_char=self.divider)))
508
486
if self.log_visible:
509
487
self.uilist.append(self.logbox)
510
488
self.topwidget = urwid.Pile(self.uilist)
512
def log_message(self, message):
490
def log_message(self, message, level=1):
491
"""Log message formatted with timestamp"""
492
if level < self.log_level:
513
494
timestamp = datetime.datetime.now().isoformat()
514
self.log_message_raw(timestamp + ": " + message)
516
def log_message_raw(self, markup):
495
self.log_message_raw("{}: {}".format(timestamp, message),
498
def log_message_raw(self, markup, level=1):
517
499
"""Add a log message to the log buffer."""
500
if level < self.log_level:
518
502
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
519
if (self.max_log_length
520
and len(self.log) > self.max_log_length):
521
del self.log[0:len(self.log)-self.max_log_length-1]
522
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,
523
507
coming_from="above")
526
510
def toggle_log_display(self):
527
511
"""Toggle visibility of the log buffer."""
528
512
self.log_visible = not self.log_visible
530
#self.log_message("Log visibility changed to: "
531
# + unicode(self.log_visible))
514
self.log_message("Log visibility changed to: {}"
515
.format(self.log_visible), level=0)
533
517
def change_log_display(self):
534
518
"""Change type of log display.
535
519
Currently, this toggles wrapping of text lines."""
539
523
self.log_wrap = "clip"
540
524
for textwidget in self.log:
541
525
textwidget.set_wrap_mode(self.log_wrap)
542
#self.log_message("Wrap mode: " + self.log_wrap)
544
def find_and_remove_client(self, path, name):
526
self.log_message("Wrap mode: {}".format(self.log_wrap),
529
def find_and_remove_client(self, path, interfaces):
545
530
"""Find a client by its object path and remove it.
547
This is connected to the ClientRemoved signal from the
532
This is connected to the InterfacesRemoved signal from the
548
533
Mandos server object."""
534
if client_interface not in interfaces:
535
# Not a Mandos client object; ignore
550
538
client = self.clients_dict[path]
553
self.log_message("Unknown client {0!r} ({1!r}) removed"
541
self.log_message("Unknown client {!r} removed"
558
def add_new_client(self, path):
546
def add_new_client(self, path, ifs_and_props):
547
"""Find a client by its object path and remove it.
549
This is connected to the InterfacesAdded signal from the
550
Mandos server object.
552
if client_interface not in ifs_and_props:
553
# Not a Mandos client object; ignore
559
555
client_proxy_object = self.bus.get_object(self.busname, path)
560
self.add_client(MandosClientWidget(server_proxy_object
563
=client_proxy_object,
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)
575
568
path = client.proxy.object_path
576
569
self.clients_dict[path] = client
577
self.clients.sort(None, lambda c: c.properties["Name"])
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]
585
if not self.clients_dict:
586
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
587
# is completely emptied, we need to recreate it.
588
self.clients = urwid.SimpleListWalker([])
592
580
def refresh(self):
593
581
"""Redraw the screen"""
594
582
canvas = self.topwidget.render(self.size, focus=True)
595
583
self.screen.draw_screen(self.size, canvas)
598
586
"""Start the main loop and exit when it's done."""
599
587
self.bus = dbus.SystemBus()
600
588
mandos_dbus_objc = self.bus.get_object(
601
589
self.busname, "/", follow_name_owner_changes=True)
602
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
606
593
mandos_clients = (self.mandos_serv
607
594
.GetAllClientsWithProperties())
595
if not mandos_clients:
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
608
598
except dbus.exceptions.DBusException:
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
609
601
mandos_clients = dbus.Dictionary()
611
603
(self.mandos_serv
612
.connect_to_signal("ClientRemoved",
604
.connect_to_signal("InterfacesRemoved",
613
605
self.find_and_remove_client,
614
dbus_interface=server_interface,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
615
607
byte_arrays=True))
616
608
(self.mandos_serv
617
.connect_to_signal("ClientAdded",
609
.connect_to_signal("InterfacesAdded",
618
610
self.add_new_client,
619
dbus_interface=server_interface,
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
620
612
byte_arrays=True))
621
613
(self.mandos_serv
622
614
.connect_to_signal("ClientNotFound",
623
615
self.client_not_found,
624
616
dbus_interface=server_interface,
625
617
byte_arrays=True))
626
for path, client in mandos_clients.iteritems():
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 = (GLib.io_add_watch
644
632
(sys.stdin.fileno(),
646
634
self.process_input))
647
635
self.main_loop.run()
648
636
# Main loop has finished, we should close everything now
649
gobject.source_remove(self._input_callback_tag)
637
GLib.source_remove(self._input_callback_tag)
650
638
self.screen.stop()
653
641
self.main_loop.quit()
655
643
def process_input(self, source, condition):
656
644
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
645
translations = {"ctrl n": "down", # Emacs
646
"ctrl p": "up", # Emacs
647
"ctrl v": "page down", # Emacs
648
"meta v": "page up", # Emacs
649
" ": "page down", # less
650
"f": "page down", # less
651
"b": "page up", # less
669
657
key = translations[key]
670
658
except KeyError: # :-)
673
661
if key == "q" or key == "Q":
676
664
elif key == "window resize":
677
665
self.size = self.screen.get_cols_rows()
679
elif key == "\f": # Ctrl-L
667
elif key == "ctrl l":
681
670
elif key == "l" or key == "D":
682
671
self.toggle_log_display()
714
705
self.topwidget.set_focus(self.logbox)
716
#elif (key == "end" or key == "meta >" or key == "G"
718
# pass # xxx end-of-buffer
719
#elif (key == "home" or key == "meta <" or key == "g"
721
# pass # xxx beginning-of-buffer
722
#elif key == "ctrl e" or key == "$":
723
# pass # xxx move-end-of-line
724
#elif key == "ctrl a" or key == "^":
725
# pass # xxx move-beginning-of-line
726
#elif key == "ctrl b" or key == "meta (" or key == "h":
728
#elif key == "ctrl f" or key == "meta )" or key == "l":
731
# pass # scroll up log
733
# pass # scroll down log
708
if self.log_level == 0:
710
self.log_message("Verbose mode: Off")
713
self.log_message("Verbose mode: On")
714
# elif (key == "end" or key == "meta >" or key == "G"
716
# pass # xxx end-of-buffer
717
# elif (key == "home" or key == "meta <" or key == "g"
719
# pass # xxx beginning-of-buffer
720
# elif key == "ctrl e" or key == "$":
721
# pass # xxx move-end-of-line
722
# elif key == "ctrl a" or key == "^":
723
# pass # xxx move-beginning-of-line
724
# elif key == "ctrl b" or key == "meta (" or key == "h":
726
# elif key == "ctrl f" or key == "meta )" or key == "l":
729
# pass # scroll up log
731
# pass # scroll down log
734
732
elif self.topwidget.selectable():
735
733
self.topwidget.keypress(self.size, key)
739
738
ui = UserInterface()
742
741
except KeyboardInterrupt:
745
ui.log_message(unicode(e))
743
except Exception as e:
744
ui.log_message(str(e))