2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
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
13
# the Free Software Foundation, either version 3 of the License, or
14
# (at your option) any later version.
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
# GNU General Public License for more details.
21
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
24
# Contact the authors at <mandos@recompile.se>.
27
from __future__ import (division, absolute_import, print_function,
30
from future_builtins import *
4
from __future__ import division, absolute_import, with_statement
39
12
import urwid.curses_display
42
15
from dbus.mainloop.glib import DBusGMainLoop
43
from gi.repository import GLib
51
if sys.version_info.major == 2:
54
locale.setlocale(locale.LC_ALL, '')
56
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
58
22
# Some useful constants
59
domain = 'se.recompile'
23
domain = 'se.bsnet.fukt'
60
24
server_interface = domain + '.Mandos'
61
25
client_interface = domain + '.Mandos.Client'
65
dbus.OBJECT_MANAGER_IFACE
66
except AttributeError:
67
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
70
def isoformat_to_datetime(iso):
71
"Parse an ISO 8601 date string to a datetime.datetime()"
74
d, t = iso.split("T", 1)
75
year, month, day = d.split("-", 2)
76
hour, minute, second = t.split(":", 2)
77
second, fraction = divmod(float(second), 1)
78
return datetime.datetime(int(year),
83
int(second), # Whole seconds
84
int(fraction*1000000)) # Microseconds
28
# Always run in monochrome mode
29
urwid.curses_display.curses.has_colors = lambda : False
31
# Urwid doesn't support blinking, but we want it. Since we have no
32
# use for underline on its own, we make underline also always blink.
33
urwid.curses_display.curses.A_UNDERLINE |= (
34
urwid.curses_display.curses.A_BLINK)
87
36
class MandosClientPropertyCache(object):
88
37
"""This wraps a Mandos Client D-Bus proxy object, caches the
89
38
properties and calls a hook function when any of them are
92
def __init__(self, proxy_object=None, properties=None, **kwargs):
93
self.proxy = proxy_object # Mandos Client proxy object
94
self.properties = dict() if properties is None else properties
95
self.property_changed_match = (
96
self.proxy.connect_to_signal("PropertiesChanged",
97
self.properties_changed,
98
dbus.PROPERTIES_IFACE,
101
if properties is None:
102
self.properties.update(self.proxy.GetAll(
104
dbus_interface=dbus.PROPERTIES_IFACE))
106
super(MandosClientPropertyCache, self).__init__(**kwargs)
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.
41
def __init__(self, proxy_object=None, properties=None, *args,
43
self.proxy = proxy_object # Mandos Client proxy object
45
if properties is None:
46
self.properties = dict()
48
self.properties = properties
49
self.proxy.connect_to_signal(u"PropertyChanged",
50
self.property_changed,
54
if properties is None:
55
self.properties.update(self.proxy.GetAll(client_interface,
57
dbus.PROPERTIES_IFACE))
58
super(MandosClientPropertyCache, self).__init__(
59
proxy_object=proxy_object,
60
properties=properties, *args, **kwargs)
62
def property_changed(self, property=None, value=None):
63
"""This is called whenever we get a PropertyChanged signal
64
It updates the changed property in the "properties" dict.
112
66
# Update properties dict with new value
113
if interface == client_interface:
114
self.properties.update(properties)
117
self.property_changed_match.remove()
67
self.properties[property] = value
120
70
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
121
71
"""A Mandos Client which is visible on the screen.
124
74
def __init__(self, server_proxy_object=None, update_hook=None,
125
delete_hook=None, logger=None, **kwargs):
75
delete_hook=None, logger=None, *args, **kwargs):
126
76
# Called on update
127
77
self.update_hook = update_hook
128
78
# Called on delete
131
81
self.server_proxy_object = server_proxy_object
133
83
self.logger = logger
135
self._update_timer_callback_tag = None
137
85
# The widget shown normally
138
self._text_widget = urwid.Text("")
86
self._text_widget = urwid.Text(u"")
139
87
# The widget shown when we have focus
140
self._focus_text_widget = urwid.Text("")
141
super(MandosClientWidget, self).__init__(**kwargs)
88
self._focus_text_widget = urwid.Text(u"")
89
super(MandosClientWidget, self).__init__(
90
update_hook=update_hook, delete_hook=delete_hook,
143
93
self.opened = False
145
self.match_objects = (
146
self.proxy.connect_to_signal("CheckerCompleted",
147
self.checker_completed,
150
self.proxy.connect_to_signal("CheckerStarted",
151
self.checker_started,
154
self.proxy.connect_to_signal("GotSecret",
158
self.proxy.connect_to_signal("NeedApproval",
162
self.proxy.connect_to_signal("Rejected",
166
self.logger('Created client {}'
167
.format(self.properties["Name"]), level=0)
169
def using_timer(self, flag):
170
"""Call this method with True or False when timer should be
171
activated or deactivated.
173
if flag and self._update_timer_callback_tag is None:
174
# Will update the shown timer value every second
175
self._update_timer_callback_tag = (GLib.timeout_add
178
elif not (flag or self._update_timer_callback_tag is None):
179
GLib.source_remove(self._update_timer_callback_tag)
180
self._update_timer_callback_tag = None
94
self.proxy.connect_to_signal(u"CheckerCompleted",
95
self.checker_completed,
98
self.proxy.connect_to_signal(u"CheckerStarted",
102
self.proxy.connect_to_signal(u"GotSecret",
106
self.proxy.connect_to_signal(u"Rejected",
182
111
def checker_completed(self, exitstatus, condition, command):
183
112
if exitstatus == 0:
184
self.logger('Checker for client {} (command "{}")'
185
' succeeded'.format(self.properties["Name"],
113
self.logger(u'Checker for client %s (command "%s")'
115
% (self.properties[u"name"], command))
190
117
if os.WIFEXITED(condition):
191
self.logger('Checker for client {} (command "{}") failed'
193
.format(self.properties["Name"], command,
194
os.WEXITSTATUS(condition)))
195
elif os.WIFSIGNALED(condition):
196
self.logger('Checker for client {} (command "{}") was'
197
' killed by signal {}'
198
.format(self.properties["Name"], command,
199
os.WTERMSIG(condition)))
118
self.logger(u'Checker for client %s (command "%s")'
119
u' failed with exit code %s'
120
% (self.properties[u"name"], command,
121
os.WEXITSTATUS(condition)))
123
if os.WIFSIGNALED(condition):
124
self.logger(u'Checker for client %s (command "%s")'
125
u' was killed by signal %s'
126
% (self.properties[u"name"], command,
127
os.WTERMSIG(condition)))
129
if os.WCOREDUMP(condition):
130
self.logger(u'Checker for client %s (command "%s")'
132
% (self.properties[u"name"], command))
133
self.logger(u'Checker for client %s completed mysteriously')
202
135
def checker_started(self, command):
203
"""Server signals that a checker started."""
204
self.logger('Client {} started checker "{}"'
205
.format(self.properties["Name"],
136
self.logger(u'Client %s started checker "%s"'
137
% (self.properties[u"name"], unicode(command)))
208
139
def got_secret(self):
209
self.logger('Client {} received its secret'
210
.format(self.properties["Name"]))
212
def need_approval(self, timeout, default):
214
message = 'Client {} needs approval within {} seconds'
216
message = 'Client {} will get its secret in {} seconds'
217
self.logger(message.format(self.properties["Name"],
220
def rejected(self, reason):
221
self.logger('Client {} was rejected; reason: {}'
222
.format(self.properties["Name"], reason))
140
self.logger(u'Client %s received its secret'
141
% self.properties[u"name"])
144
self.logger(u'Client %s was rejected'
145
% self.properties[u"name"])
224
147
def selectable(self):
225
148
"""Make this a "selectable" widget.
226
149
This overrides the method from urwid.FlowWidget."""
229
def rows(self, maxcolrow, focus=False):
152
def rows(self, (maxcol,), focus=False):
230
153
"""How many rows this widget will occupy might depend on
231
154
whether we have focus or not.
232
155
This overrides the method from urwid.FlowWidget"""
233
return self.current_widget(focus).rows(maxcolrow, focus=focus)
156
return self.current_widget(focus).rows((maxcol,), focus=focus)
235
158
def current_widget(self, focus=False):
236
159
if focus or self.opened:
237
160
return self._focus_widget
238
161
return self._widget
240
163
def update(self):
241
164
"Called when what is visible on the screen should be updated."
242
165
# 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",
166
with_standout = { u"normal": u"standout",
167
u"bold": u"bold-standout",
169
u"underline-blink-standout",
170
u"bold-underline-blink":
171
u"bold-underline-blink-standout",
251
174
# Rebuild focus and non-focus widgets using current properties
253
# Base part of a client. Name!
254
base = '{name}: '.format(name=self.properties["Name"])
255
if not self.properties["Enabled"]:
257
self.using_timer(False)
258
elif self.properties["ApprovalPending"]:
259
timeout = datetime.timedelta(
260
milliseconds=self.properties["ApprovalDelay"])
261
last_approval_request = isoformat_to_datetime(
262
self.properties["LastApprovalRequest"])
263
if last_approval_request is not None:
264
timer = max(timeout - (datetime.datetime.utcnow()
265
- last_approval_request),
266
datetime.timedelta())
268
timer = datetime.timedelta()
269
if self.properties["ApprovedByDefault"]:
270
message = "Approval in {}. (d)eny?"
272
message = "Denial in {}. (a)pprove?"
273
message = message.format(str(timer).rsplit(".", 1)[0])
274
self.using_timer(True)
275
elif self.properties["LastCheckerStatus"] != 0:
276
# When checker has failed, show timer until client expires
277
expires = self.properties["Expires"]
279
timer = datetime.timedelta(0)
281
expires = (datetime.datetime.strptime
282
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
283
timer = max(expires - datetime.datetime.utcnow(),
284
datetime.timedelta())
285
message = ('A checker has failed! Time until client'
287
.format(str(timer).rsplit(".", 1)[0]))
288
self.using_timer(True)
291
self.using_timer(False)
292
self._text = "{}{}".format(base, message)
175
self._text = (u'%(name)s: %(enabled)s'
176
% { u"name": self.properties[u"name"],
179
if self.properties[u"enabled"]
294
181
if not urwid.supports_unicode():
295
182
self._text = self._text.encode("ascii", "replace")
296
textlist = [("normal", self._text)]
183
textlist = [(u"normal", self._text)]
297
184
self._text_widget.set_text(textlist)
298
185
self._focus_text_widget.set_text([(with_standout[text[0]],
306
193
# Run update hook, if any
307
194
if self.update_hook is not None:
308
195
self.update_hook()
310
def update_timer(self):
311
"""called by GLib. Will indefinitely loop until
312
GLib.source_remove() on tag is called
315
return True # Keep calling this
317
def delete(self, **kwargs):
318
if self._update_timer_callback_tag is not None:
319
GLib.source_remove(self._update_timer_callback_tag)
320
self._update_timer_callback_tag = None
321
for match in self.match_objects:
323
self.match_objects = ()
324
198
if self.delete_hook is not None:
325
199
self.delete_hook(self)
326
return super(MandosClientWidget, self).delete(**kwargs)
328
def render(self, maxcolrow, focus=False):
201
def render(self, (maxcol,), focus=False):
329
202
"""Render differently if we have focus.
330
203
This overrides the method from urwid.FlowWidget"""
331
return self.current_widget(focus).render(maxcolrow,
204
return self.current_widget(focus).render((maxcol,),
334
def keypress(self, maxcolrow, key):
207
def keypress(self, (maxcol,), key):
336
209
This overrides the method from urwid.FlowWidget"""
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply=True,
340
dbus_interface=dbus.PROPERTIES_IFACE)
342
self.proxy.Set(client_interface, "Enabled", False,
344
dbus_interface=dbus.PROPERTIES_IFACE)
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
347
dbus_interface=client_interface,
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
351
dbus_interface=client_interface,
353
elif key == "R" or key == "_" or key == "ctrl k":
210
if key == u"e" or key == u"+":
212
elif key == u"d" or key == u"-":
214
elif key == u"r" or key == u"_" or key == u"ctrl k":
354
215
self.server_proxy_object.RemoveClient(self.proxy
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply=True,
360
dbus_interface=dbus.PROPERTIES_IFACE)
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply=True,
364
dbus_interface=dbus.PROPERTIES_IFACE)
366
self.proxy.CheckedOK(dbus_interface=client_interface,
218
self.proxy.StartChecker()
220
self.proxy.StopChecker()
222
self.proxy.CheckedOK()
369
# elif key == "p" or key == "=":
224
# elif key == u"p" or key == "=":
370
225
# self.proxy.pause()
371
# elif key == "u" or key == ":":
226
# elif key == u"u" or key == ":":
372
227
# self.proxy.unpause()
228
# elif key == u"RET":
378
def properties_changed(self, interface, properties, invalidated):
379
"""Call self.update() if any properties changed.
233
def property_changed(self, property=None, value=None,
235
"""Call self.update() if old value is not new value.
380
236
This overrides the method from MandosClientPropertyCache"""
381
old_values = {key: self.properties.get(key)
382
for key in properties.keys()}
383
super(MandosClientWidget, self).properties_changed(
384
interface, properties, invalidated)
385
if any(old_values[key] != self.properties.get(key)
386
for key in old_values):
237
property_name = unicode(property)
238
old_value = self.properties.get(property_name)
239
super(MandosClientWidget, self).property_changed(
240
property=property, value=value, *args, **kwargs)
241
if self.properties.get(property_name) != old_value:
404
258
"""This is the entire user interface - the whole screen
405
259
with boxes, lists of client widgets, etc.
407
def __init__(self, max_log_length=1000, log_level=1):
261
def __init__(self, max_log_length=1000):
408
262
DBusGMainLoop(set_as_default=True)
410
264
self.screen = urwid.curses_display.Screen()
412
266
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",
423
"bold,underline,blink"),
425
"bold,standout", "default", "bold,standout"),
426
("underline-blink-standout",
427
"underline,blink,standout", "default",
428
"underline,blink,standout"),
429
("bold-underline-blink-standout",
430
"bold,underline,blink,standout", "default",
431
"bold,underline,blink,standout"),
268
u"default", u"default", None),
270
u"default", u"default", u"bold"),
272
u"default", u"default", u"underline"),
274
u"default", u"default", u"standout"),
275
(u"bold-underline-blink",
276
u"default", u"default", (u"bold", u"underline")),
278
u"default", u"default", (u"bold", u"standout")),
279
(u"underline-blink-standout",
280
u"default", u"default", (u"underline", u"standout")),
281
(u"bold-underline-blink-standout",
282
u"default", u"default", (u"bold", u"underline",
434
286
if urwid.supports_unicode():
435
self.divider = "─" # \u2500
287
self.divider = u"─" # \u2500
288
#self.divider = u"━" # \u2501
437
self.divider = "_" # \u005f
290
#self.divider = u"-" # \u002d
291
self.divider = u"_" # \u005f
439
293
self.screen.start()
441
295
self.size = self.screen.get_cols_rows()
443
297
self.clients = urwid.SimpleListWalker([])
444
298
self.clients_dict = {}
446
300
# We will add Text widgets to this list
447
self.log = urwid.SimpleListWalker([])
448
302
self.max_log_length = max_log_length
450
self.log_level = log_level
452
304
# We keep a reference to the log widget so we can remove it
453
305
# from the ListWalker without it getting destroyed
454
306
self.logbox = ConstrainedListBox(self.log)
456
308
# This keeps track of whether self.uilist currently has
457
309
# self.logbox in it or not
458
310
self.log_visible = True
459
self.log_wrap = "any"
311
self.log_wrap = u"any"
462
self.log_message_raw(("bold",
463
"Mandos Monitor version " + version))
464
self.log_message_raw(("bold",
314
self.log_message_raw((u"bold",
315
u"Mandos Monitor version " + version))
316
self.log_message_raw((u"bold",
467
319
self.busname = domain + '.Mandos'
468
self.main_loop = GLib.MainLoop()
320
self.main_loop = gobject.MainLoop()
321
self.bus = dbus.SystemBus()
322
mandos_dbus_objc = self.bus.get_object(
323
self.busname, u"/", follow_name_owner_changes=True)
324
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
328
mandos_clients = (self.mandos_serv
329
.GetAllClientsWithProperties())
330
except dbus.exceptions.DBusException:
331
mandos_clients = dbus.Dictionary()
334
.connect_to_signal(u"ClientRemoved",
335
self.find_and_remove_client,
336
dbus_interface=server_interface,
339
.connect_to_signal(u"ClientAdded",
341
dbus_interface=server_interface,
344
.connect_to_signal(u"ClientNotFound",
345
self.client_not_found,
346
dbus_interface=server_interface,
348
for path, client in mandos_clients.iteritems():
349
client_proxy_object = self.bus.get_object(self.busname,
351
self.add_client(MandosClientWidget(server_proxy_object
354
=client_proxy_object,
470
364
def client_not_found(self, fingerprint, address):
471
self.log_message("Client with address {} and fingerprint {}"
472
" could not be found"
473
.format(address, fingerprint))
365
self.log_message((u"Client with address %s and fingerprint %s"
366
u" could not be found" % (address,
475
369
def rebuild(self):
476
370
"""This rebuilds the User Interface.
477
371
Call this when the widget layout needs to change"""
479
# self.uilist.append(urwid.ListBox(self.clients))
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
482
# header=urwid.Divider(),
373
#self.uilist.append(urwid.ListBox(self.clients))
374
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
375
#header=urwid.Divider(),
484
footer=urwid.Divider(
485
div_char=self.divider)))
377
footer=urwid.Divider(div_char=self.divider)))
486
378
if self.log_visible:
487
379
self.uilist.append(self.logbox)
488
381
self.topwidget = urwid.Pile(self.uilist)
490
def log_message(self, message, level=1):
491
"""Log message formatted with timestamp"""
492
if level < self.log_level:
383
def log_message(self, message):
494
384
timestamp = datetime.datetime.now().isoformat()
495
self.log_message_raw("{}: {}".format(timestamp, message),
498
def log_message_raw(self, markup, level=1):
385
self.log_message_raw(timestamp + u": " + message)
387
def log_message_raw(self, markup):
499
388
"""Add a log message to the log buffer."""
500
if level < self.log_level:
502
389
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
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,
390
if (self.max_log_length
391
and len(self.log) > self.max_log_length):
392
del self.log[0:len(self.log)-self.max_log_length-1]
393
self.logbox.set_focus(len(self.logbox.body.contents),
394
coming_from=u"above")
510
397
def toggle_log_display(self):
511
398
"""Toggle visibility of the log buffer."""
512
399
self.log_visible = not self.log_visible
514
self.log_message("Log visibility changed to: {}"
515
.format(self.log_visible), level=0)
401
self.log_message(u"Log visibility changed to: "
402
+ unicode(self.log_visible))
517
404
def change_log_display(self):
518
405
"""Change type of log display.
519
406
Currently, this toggles wrapping of text lines."""
520
if self.log_wrap == "clip":
521
self.log_wrap = "any"
407
if self.log_wrap == u"clip":
408
self.log_wrap = u"any"
523
self.log_wrap = "clip"
410
self.log_wrap = u"clip"
524
411
for textwidget in self.log:
525
412
textwidget.set_wrap_mode(self.log_wrap)
526
self.log_message("Wrap mode: {}".format(self.log_wrap),
529
def find_and_remove_client(self, path, interfaces):
530
"""Find a client by its object path and remove it.
532
This is connected to the InterfacesRemoved signal from the
413
self.log_message(u"Wrap mode: " + self.log_wrap)
415
def find_and_remove_client(self, path, name):
416
"""Find an client from its object path and remove it.
418
This is connected to the ClientRemoved signal from the
533
419
Mandos server object."""
534
if client_interface not in interfaces:
535
# Not a Mandos client object; ignore
538
421
client = self.clients_dict[path]
541
self.log_message("Unknown client {!r} removed"
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
425
self.remove_client(client, path)
427
def add_new_client(self, path, properties):
555
428
client_proxy_object = self.bus.get_object(self.busname, path)
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])),
429
self.add_client(MandosClientWidget(server_proxy_object
432
=client_proxy_object,
433
properties=properties,
437
=self.remove_client),
565
440
def add_client(self, client, path=None):
566
441
self.clients.append(client)
568
443
path = client.proxy.object_path
569
444
self.clients_dict[path] = client
570
self.clients.sort(key=lambda c: c.properties["Name"])
445
self.clients.sort(None, lambda c: c.properties[u"name"])
573
448
def remove_client(self, client, path=None):
574
449
self.clients.remove(client)
576
451
path = client.proxy.object_path
577
452
del self.clients_dict[path]
453
if not self.clients_dict:
454
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
455
# is completely emptied, we need to recreate it.
456
self.clients = urwid.SimpleListWalker([])
580
460
def refresh(self):
581
461
"""Redraw the screen"""
582
462
canvas = self.topwidget.render(self.size, focus=True)
583
463
self.screen.draw_screen(self.size, canvas)
586
466
"""Start the main loop and exit when it's done."""
587
self.bus = dbus.SystemBus()
588
mandos_dbus_objc = self.bus.get_object(
589
self.busname, "/", follow_name_owner_changes=True)
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
593
mandos_clients = (self.mandos_serv
594
.GetAllClientsWithProperties())
595
if not mandos_clients:
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
598
except dbus.exceptions.DBusException:
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
601
mandos_clients = dbus.Dictionary()
604
.connect_to_signal("InterfacesRemoved",
605
self.find_and_remove_client,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
609
.connect_to_signal("InterfacesAdded",
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
614
.connect_to_signal("ClientNotFound",
615
self.client_not_found,
616
dbus_interface=server_interface,
618
for path, client in mandos_clients.items():
619
client_proxy_object = self.bus.get_object(self.busname,
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),
631
self._input_callback_tag = (
633
GLib.IOChannel.unix_new(sys.stdin.fileno()),
634
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
468
self._input_callback_tag = (gobject.io_add_watch
636
472
self.main_loop.run()
637
473
# Main loop has finished, we should close everything now
638
GLib.source_remove(self._input_callback_tag)
639
with warnings.catch_warnings():
640
warnings.simplefilter("ignore", BytesWarning)
474
gobject.source_remove(self._input_callback_tag)
644
478
self.main_loop.quit()
646
480
def process_input(self, source, condition):
647
481
keys = self.screen.get_input()
648
translations = {"ctrl n": "down", # Emacs
649
"ctrl p": "up", # Emacs
650
"ctrl v": "page down", # Emacs
651
"meta v": "page up", # Emacs
652
" ": "page down", # less
653
"f": "page down", # less
654
"b": "page up", # less
482
translations = { u"ctrl n": u"down", # Emacs
483
u"ctrl p": u"up", # Emacs
484
u"ctrl v": u"page down", # Emacs
485
u"meta v": u"page up", # Emacs
486
u" ": u"page down", # less
487
u"f": u"page down", # less
488
u"b": u"page up", # less
660
494
key = translations[key]
661
495
except KeyError: # :-)
664
if key == "q" or key == "Q":
498
if key == u"q" or key == u"Q":
667
elif key == "window resize":
501
elif key == u"window resize":
668
502
self.size = self.screen.get_cols_rows()
670
elif key == "ctrl l":
504
elif key == u"\f": # Ctrl-L
673
elif key == "l" or key == "D":
506
elif key == u"l" or key == u"D":
674
507
self.toggle_log_display()
676
elif key == "w" or key == "i":
509
elif key == u"w" or key == u"i":
677
510
self.change_log_display()
679
elif key == "?" or key == "f1" or key == "esc":
512
elif key == u"?" or key == u"f1" or key == u"esc":
680
513
if not self.log_visible:
681
514
self.log_visible = True
683
self.log_message_raw(("bold",
687
"l: Log window toggle",
688
"TAB: Switch window",
689
"w: Wrap (log lines)",
690
"v: Toggle verbose log",
692
self.log_message_raw(("bold",
698
"s: Start new checker",
516
self.log_message_raw((u"bold",
520
u"l: Log window toggle",
521
u"TAB: Switch window",
523
self.log_message_raw((u"bold",
529
u"s: Start new checker",
705
534
if self.topwidget.get_focus() is self.logbox:
706
535
self.topwidget.set_focus(0)
708
537
self.topwidget.set_focus(self.logbox)
711
if self.log_level == 0:
713
self.log_message("Verbose mode: Off")
716
self.log_message("Verbose mode: On")
717
# elif (key == "end" or key == "meta >" or key == "G"
719
# pass # xxx end-of-buffer
720
# elif (key == "home" or key == "meta <" or key == "g"
722
# pass # xxx beginning-of-buffer
723
# elif key == "ctrl e" or key == "$":
724
# pass # xxx move-end-of-line
725
# elif key == "ctrl a" or key == "^":
726
# pass # xxx move-beginning-of-line
727
# elif key == "ctrl b" or key == "meta (" or key == "h":
729
# elif key == "ctrl f" or key == "meta )" or key == "l":
732
# pass # scroll up log
734
# pass # scroll down log
539
#elif (key == u"end" or key == u"meta >" or key == u"G"
541
# pass # xxx end-of-buffer
542
#elif (key == u"home" or key == u"meta <" or key == u"g"
544
# pass # xxx beginning-of-buffer
545
#elif key == u"ctrl e" or key == u"$":
546
# pass # xxx move-end-of-line
547
#elif key == u"ctrl a" or key == u"^":
548
# pass # xxx move-beginning-of-line
549
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
551
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
554
# pass # scroll up log
556
# pass # scroll down log
735
557
elif self.topwidget.selectable():
736
558
self.topwidget.keypress(self.size, key)
741
562
ui = UserInterface()
744
except KeyboardInterrupt:
746
except Exception as e:
747
ui.log_message(str(e))