2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2016 Teddy Hogeborn
7
# Copyright © 2009-2016 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
11
# the Free Software Foundation, either version 3 of the License, or
12
# (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
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
# GNU General Public License for more details.
19
# 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/>.
23
# Contact the authors at <mandos@recompile.se>.
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
4
from __future__ import division, absolute_import, with_statement
38
9
import urwid.curses_display
41
12
from dbus.mainloop.glib import DBusGMainLoop
42
from gi.repository import GLib
50
if sys.version_info.major == 2:
53
locale.setlocale(locale.LC_ALL, '')
55
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
57
19
# Some useful constants
58
domain = 'se.recompile'
20
domain = 'se.bsnet.fukt'
59
21
server_interface = domain + '.Mandos'
60
22
client_interface = domain + '.Mandos.Client'
64
dbus.OBJECT_MANAGER_IFACE
65
except AttributeError:
66
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
69
def isoformat_to_datetime(iso):
70
"Parse an ISO 8601 date string to a datetime.datetime()"
73
d, t = iso.split("T", 1)
74
year, month, day = d.split("-", 2)
75
hour, minute, second = t.split(":", 2)
76
second, fraction = divmod(float(second), 1)
77
return datetime.datetime(int(year),
82
int(second), # Whole seconds
83
int(fraction*1000000)) # Microseconds
25
# Always run in monochrome mode
26
urwid.curses_display.curses.has_colors = lambda : False
28
# Urwid doesn't support blinking, but we want it. Since we have no
29
# use for underline on its own, we make underline also always blink.
30
urwid.curses_display.curses.A_UNDERLINE |= (
31
urwid.curses_display.curses.A_BLINK)
86
33
class MandosClientPropertyCache(object):
87
34
"""This wraps a Mandos Client D-Bus proxy object, caches the
88
35
properties and calls a hook function when any of them are
91
def __init__(self, proxy_object=None, properties=None, **kwargs):
92
self.proxy = proxy_object # Mandos Client proxy object
93
self.properties = dict() if properties is None else properties
94
self.property_changed_match = (
95
self.proxy.connect_to_signal("PropertiesChanged",
96
self.properties_changed,
97
dbus.PROPERTIES_IFACE,
100
if properties is None:
101
self.properties.update(self.proxy.GetAll(
103
dbus_interface=dbus.PROPERTIES_IFACE))
105
super(MandosClientPropertyCache, self).__init__(**kwargs)
107
def properties_changed(self, interface, properties, invalidated):
108
"""This is called whenever we get a PropertiesChanged signal
109
It updates the changed properties in the "properties" dict.
38
def __init__(self, proxy_object=None, properties=None, *args,
40
# Type conversion mapping
42
dbus.ObjectPath: unicode,
44
dbus.Signature: unicode,
52
dbus.Dictionary: dict,
59
self.proxy = proxy_object # Mandos Client proxy object
61
if properties is None:
62
self.properties = dict()
64
self.properties = dict(self.convert_property(prop, val)
66
properties.iteritems())
67
self.proxy.connect_to_signal("PropertyChanged",
68
self.property_changed,
72
if properties is None:
73
self.properties.update(
74
self.convert_property(prop, val)
76
self.proxy.GetAll(client_interface,
78
dbus.PROPERTIES_IFACE).iteritems())
79
super(MandosClientPropertyCache, self).__init__(
80
proxy_object=proxy_object,
81
properties=properties, *args, **kwargs)
83
def convert_property(self, property, value):
84
"""This converts the arguments from a D-Bus signal, which are
85
D-Bus types, into normal Python types, using a conversion
86
function from "self.type_map".
88
property_name = unicode(property) # Always a dbus.String
89
if isinstance(value, dbus.UTF8String):
90
# Should not happen, but prepare for it anyway
91
value = dbus.String(str(value).decode("utf-8"))
93
convfunc = self.type_map[type(value)]
95
# Unknown type, return unmodified
96
return property_name, value
97
return property_name, convfunc(value)
98
def property_changed(self, property=None, value=None):
99
"""This is called whenever we get a PropertyChanged signal
100
It updates the changed property in the "properties" dict.
102
# Convert name and value
103
property_name, cvalue = self.convert_property(property, value)
111
104
# Update properties dict with new value
112
if interface == client_interface:
113
self.properties.update(properties)
116
self.property_changed_match.remove()
105
self.properties[property_name] = cvalue
119
108
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
120
109
"""A Mandos Client which is visible on the screen.
123
112
def __init__(self, server_proxy_object=None, update_hook=None,
124
delete_hook=None, logger=None, **kwargs):
113
delete_hook=None, *args, **kwargs):
125
114
# Called on update
126
115
self.update_hook = update_hook
127
116
# Called on delete
128
117
self.delete_hook = delete_hook
129
118
# Mandos Server proxy object
130
119
self.server_proxy_object = server_proxy_object
134
self._update_timer_callback_tag = None
136
121
# The widget shown normally
137
122
self._text_widget = urwid.Text("")
138
123
# The widget shown when we have focus
139
124
self._focus_text_widget = urwid.Text("")
140
super(MandosClientWidget, self).__init__(**kwargs)
125
super(MandosClientWidget, self).__init__(
126
update_hook=update_hook, delete_hook=delete_hook,
142
129
self.opened = False
144
self.match_objects = (
145
self.proxy.connect_to_signal("CheckerCompleted",
146
self.checker_completed,
149
self.proxy.connect_to_signal("CheckerStarted",
150
self.checker_started,
153
self.proxy.connect_to_signal("GotSecret",
157
self.proxy.connect_to_signal("NeedApproval",
161
self.proxy.connect_to_signal("Rejected",
165
self.logger('Created client {}'
166
.format(self.properties["Name"]), level=0)
168
def using_timer(self, flag):
169
"""Call this method with True or False when timer should be
170
activated or deactivated.
172
if flag and self._update_timer_callback_tag is None:
173
# Will update the shown timer value every second
174
self._update_timer_callback_tag = (GLib.timeout_add
177
elif not (flag or self._update_timer_callback_tag is None):
178
GLib.source_remove(self._update_timer_callback_tag)
179
self._update_timer_callback_tag = None
181
def checker_completed(self, exitstatus, condition, command):
183
self.logger('Checker for client {} (command "{}")'
184
' succeeded'.format(self.properties["Name"],
189
if os.WIFEXITED(condition):
190
self.logger('Checker for client {} (command "{}") failed'
192
.format(self.properties["Name"], command,
193
os.WEXITSTATUS(condition)))
194
elif os.WIFSIGNALED(condition):
195
self.logger('Checker for client {} (command "{}") was'
196
' killed by signal {}'
197
.format(self.properties["Name"], command,
198
os.WTERMSIG(condition)))
201
def checker_started(self, command):
202
"""Server signals that a checker started."""
203
self.logger('Client {} started checker "{}"'
204
.format(self.properties["Name"],
207
def got_secret(self):
208
self.logger('Client {} received its secret'
209
.format(self.properties["Name"]))
211
def need_approval(self, timeout, default):
213
message = 'Client {} needs approval within {} seconds'
215
message = 'Client {} will get its secret in {} seconds'
216
self.logger(message.format(self.properties["Name"],
219
def rejected(self, reason):
220
self.logger('Client {} was rejected; reason: {}'
221
.format(self.properties["Name"], reason))
223
131
def selectable(self):
224
132
"""Make this a "selectable" widget.
225
133
This overrides the method from urwid.FlowWidget."""
228
def rows(self, maxcolrow, focus=False):
136
def rows(self, (maxcol,), focus=False):
229
137
"""How many rows this widget will occupy might depend on
230
138
whether we have focus or not.
231
139
This overrides the method from urwid.FlowWidget"""
232
return self.current_widget(focus).rows(maxcolrow, focus=focus)
140
return self.current_widget(focus).rows((maxcol,), focus=focus)
234
142
def current_widget(self, focus=False):
235
143
if focus or self.opened:
236
144
return self._focus_widget
237
145
return self._widget
239
147
def update(self):
240
148
"Called when what is visible on the screen should be updated."
241
149
# How to add standout mode to a style
242
with_standout = {"normal": "standout",
243
"bold": "bold-standout",
245
"underline-blink-standout",
246
"bold-underline-blink":
247
"bold-underline-blink-standout",
150
with_standout = { u"normal": u"standout",
151
u"bold": u"bold-standout",
153
u"underline-blink-standout",
154
u"bold-underline-blink":
155
u"bold-underline-blink-standout",
250
158
# Rebuild focus and non-focus widgets using current properties
252
# Base part of a client. Name!
253
base = '{name}: '.format(name=self.properties["Name"])
254
if not self.properties["Enabled"]:
256
self.using_timer(False)
257
elif self.properties["ApprovalPending"]:
258
timeout = datetime.timedelta(
259
milliseconds=self.properties["ApprovalDelay"])
260
last_approval_request = isoformat_to_datetime(
261
self.properties["LastApprovalRequest"])
262
if last_approval_request is not None:
263
timer = max(timeout - (datetime.datetime.utcnow()
264
- last_approval_request),
265
datetime.timedelta())
267
timer = datetime.timedelta()
268
if self.properties["ApprovedByDefault"]:
269
message = "Approval in {}. (d)eny?"
271
message = "Denial in {}. (a)pprove?"
272
message = message.format(str(timer).rsplit(".", 1)[0])
273
self.using_timer(True)
274
elif self.properties["LastCheckerStatus"] != 0:
275
# When checker has failed, show timer until client expires
276
expires = self.properties["Expires"]
278
timer = datetime.timedelta(0)
280
expires = (datetime.datetime.strptime
281
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
282
timer = max(expires - datetime.datetime.utcnow(),
283
datetime.timedelta())
284
message = ('A checker has failed! Time until client'
286
.format(str(timer).rsplit(".", 1)[0]))
287
self.using_timer(True)
290
self.using_timer(False)
291
self._text = "{}{}".format(base, message)
159
self._text = (u'name="%(name)s", enabled=%(enabled)s'
293
161
if not urwid.supports_unicode():
294
162
self._text = self._text.encode("ascii", "replace")
295
textlist = [("normal", self._text)]
163
textlist = [(u"normal", u"BLÄRGH: "), (u"bold", self._text)]
296
164
self._text_widget.set_text(textlist)
297
165
self._focus_text_widget.set_text([(with_standout[text[0]],
305
173
# Run update hook, if any
306
174
if self.update_hook is not None:
307
175
self.update_hook()
309
def update_timer(self):
310
"""called by GLib. Will indefinitely loop until
311
GLib.source_remove() on tag is called
314
return True # Keep calling this
316
def delete(self, **kwargs):
317
if self._update_timer_callback_tag is not None:
318
GLib.source_remove(self._update_timer_callback_tag)
319
self._update_timer_callback_tag = None
320
for match in self.match_objects:
322
self.match_objects = ()
323
178
if self.delete_hook is not None:
324
179
self.delete_hook(self)
325
return super(MandosClientWidget, self).delete(**kwargs)
327
def render(self, maxcolrow, focus=False):
181
def render(self, (maxcol,), focus=False):
328
182
"""Render differently if we have focus.
329
183
This overrides the method from urwid.FlowWidget"""
330
return self.current_widget(focus).render(maxcolrow,
184
return self.current_widget(focus).render((maxcol,),
333
def keypress(self, maxcolrow, key):
187
def keypress(self, (maxcol,), key):
335
189
This overrides the method from urwid.FlowWidget"""
337
self.proxy.Set(client_interface, "Enabled",
338
dbus.Boolean(True), ignore_reply=True,
339
dbus_interface=dbus.PROPERTIES_IFACE)
341
self.proxy.Set(client_interface, "Enabled", False,
343
dbus_interface=dbus.PROPERTIES_IFACE)
345
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
346
dbus_interface=client_interface,
349
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
350
dbus_interface=client_interface,
352
elif key == "R" or key == "_" or key == "ctrl k":
190
if key == u"e" or key == u"+":
192
elif key == u"d" or key == u"-":
194
elif key == u"r" or key == u"_":
353
195
self.server_proxy_object.RemoveClient(self.proxy
357
self.proxy.Set(client_interface, "CheckerRunning",
358
dbus.Boolean(True), ignore_reply=True,
359
dbus_interface=dbus.PROPERTIES_IFACE)
361
self.proxy.Set(client_interface, "CheckerRunning",
362
dbus.Boolean(False), ignore_reply=True,
363
dbus_interface=dbus.PROPERTIES_IFACE)
365
self.proxy.CheckedOK(dbus_interface=client_interface,
198
self.proxy.StartChecker()
200
self.proxy.StopChecker()
202
self.proxy.CheckedOK()
368
# elif key == "p" or key == "=":
204
# elif key == u"p" or key == "=":
369
205
# self.proxy.pause()
370
# elif key == "u" or key == ":":
206
# elif key == u"u" or key == ":":
371
207
# self.proxy.unpause()
208
# elif key == u"RET":
377
def properties_changed(self, interface, properties, invalidated):
378
"""Call self.update() if any properties changed.
213
def property_changed(self, property=None, value=None,
215
"""Call self.update() if old value is not new value.
379
216
This overrides the method from MandosClientPropertyCache"""
380
old_values = {key: self.properties.get(key)
381
for key in properties.keys()}
382
super(MandosClientWidget, self).properties_changed(
383
interface, properties, invalidated)
384
if any(old_values[key] != self.properties.get(key)
385
for key in old_values):
217
property_name = unicode(property)
218
old_value = self.properties.get(property_name)
219
super(MandosClientWidget, self).property_changed(
220
property=property, value=value, *args, **kwargs)
221
if self.properties.get(property_name) != old_value:
389
class ConstrainedListBox(urwid.ListBox):
390
"""Like a normal urwid.ListBox, but will consume all "up" or
391
"down" key presses, thus not allowing any containing widgets to
392
use them as an excuse to shift focus away from this widget.
394
def keypress(self, *args, **kwargs):
395
ret = (super(ConstrainedListBox, self)
396
.keypress(*args, **kwargs))
397
if ret in ("up", "down"):
402
225
class UserInterface(object):
403
226
"""This is the entire user interface - the whole screen
404
227
with boxes, lists of client widgets, etc.
406
def __init__(self, max_log_length=1000, log_level=1):
407
DBusGMainLoop(set_as_default=True)
230
DBusGMainLoop(set_as_default=True )
409
232
self.screen = urwid.curses_display.Screen()
411
234
self.screen.register_palette((
413
"default", "default", None),
415
"bold", "default", "bold"),
417
"underline,blink", "default", "underline,blink"),
419
"standout", "default", "standout"),
420
("bold-underline-blink",
421
"bold,underline,blink", "default",
422
"bold,underline,blink"),
424
"bold,standout", "default", "bold,standout"),
425
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
428
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
236
u"default", u"default", None),
238
u"default", u"default", u"bold"),
240
u"default", u"default", u"underline"),
242
u"default", u"default", u"standout"),
243
(u"bold-underline-blink",
244
u"default", u"default", (u"bold", u"underline")),
246
u"default", u"default", (u"bold", u"standout")),
247
(u"underline-blink-standout",
248
u"default", u"default", (u"underline", u"standout")),
249
(u"bold-underline-blink-standout",
250
u"default", u"default", (u"bold", u"underline",
433
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
436
self.divider = "_" # \u005f
438
254
self.screen.start()
440
256
self.size = self.screen.get_cols_rows()
442
258
self.clients = urwid.SimpleListWalker([])
443
259
self.clients_dict = {}
445
# We will add Text widgets to this list
447
self.max_log_length = max_log_length
449
self.log_level = log_level
451
# We keep a reference to the log widget so we can remove it
452
# from the ListWalker without it getting destroyed
453
self.logbox = ConstrainedListBox(self.log)
455
# This keeps track of whether self.uilist currently has
456
# self.logbox in it or not
457
self.log_visible = True
458
self.log_wrap = "any"
461
self.log_message_raw(("bold",
462
"Mandos Monitor version " + version))
463
self.log_message_raw(("bold",
260
self.topwidget = urwid.LineBox(urwid.ListBox(self.clients))
261
#self.topwidget = urwid.ListBox(clients)
466
263
self.busname = domain + '.Mandos'
467
self.main_loop = GLib.MainLoop()
469
def client_not_found(self, fingerprint, address):
470
self.log_message("Client with address {} and fingerprint {}"
471
" could not be found"
472
.format(address, fingerprint))
475
"""This rebuilds the User Interface.
476
Call this when the widget layout needs to change"""
478
# self.uilist.append(urwid.ListBox(self.clients))
479
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
481
# header=urwid.Divider(),
483
footer=urwid.Divider(
484
div_char=self.divider)))
486
self.uilist.append(self.logbox)
487
self.topwidget = urwid.Pile(self.uilist)
489
def log_message(self, message, level=1):
490
"""Log message formatted with timestamp"""
491
if level < self.log_level:
493
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
497
def log_message_raw(self, markup, level=1):
498
"""Add a log message to the log buffer."""
499
if level < self.log_level:
501
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
if self.max_log_length:
503
if len(self.log) > self.max_log_length:
504
del self.log[0:len(self.log)-self.max_log_length-1]
505
self.logbox.set_focus(len(self.logbox.body.contents),
509
def toggle_log_display(self):
510
"""Toggle visibility of the log buffer."""
511
self.log_visible = not self.log_visible
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
516
def change_log_display(self):
517
"""Change type of log display.
518
Currently, this toggles wrapping of text lines."""
519
if self.log_wrap == "clip":
520
self.log_wrap = "any"
522
self.log_wrap = "clip"
523
for textwidget in self.log:
524
textwidget.set_wrap_mode(self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
528
def find_and_remove_client(self, path, interfaces):
529
"""Find a client by its object path and remove it.
531
This is connected to the InterfacesRemoved signal from the
264
self.main_loop = gobject.MainLoop()
265
self.bus = dbus.SystemBus()
266
mandos_dbus_objc = self.bus.get_object(
267
self.busname, u"/", follow_name_owner_changes=True)
268
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
272
mandos_clients = (self.mandos_serv
273
.GetAllClientsWithProperties())
274
except dbus.exceptions.DBusException:
275
mandos_clients = dbus.Dictionary()
278
.connect_to_signal("ClientRemoved",
279
self.find_and_remove_client,
280
dbus_interface=server_interface,
283
.connect_to_signal("ClientAdded",
285
dbus_interface=server_interface,
287
for path, client in (mandos_clients.iteritems()):
288
client_proxy_object = self.bus.get_object(self.busname,
290
self.add_client(MandosClientWidget(server_proxy_object
293
=client_proxy_object,
298
=self.remove_client),
301
def find_and_remove_client(self, path, name):
302
"""Find an client from its object path and remove it.
304
This is connected to the ClientRemoved signal from the
532
305
Mandos server object."""
533
if client_interface not in interfaces:
534
# Not a Mandos client object; ignore
537
307
client = self.clients_dict[path]
540
self.log_message("Unknown client {!r} removed"
545
def add_new_client(self, path, ifs_and_props):
546
"""Find a client by its object path and remove it.
548
This is connected to the InterfacesAdded signal from the
549
Mandos server object.
551
if client_interface not in ifs_and_props:
552
# Not a Mandos client object; ignore
311
self.remove_client(client, path)
313
def add_new_client(self, path, properties):
554
314
client_proxy_object = self.bus.get_object(self.busname, path)
555
self.add_client(MandosClientWidget(
556
server_proxy_object=self.mandos_serv,
557
proxy_object=client_proxy_object,
558
update_hook=self.refresh,
559
delete_hook=self.remove_client,
560
logger=self.log_message,
561
properties=dict(ifs_and_props[client_interface])),
315
self.add_client(MandosClientWidget(server_proxy_object
318
=client_proxy_object,
319
properties=properties,
323
=self.remove_client),
564
326
def add_client(self, client, path=None):
565
327
self.clients.append(client)
567
329
path = client.proxy.object_path
568
330
self.clients_dict[path] = client
569
self.clients.sort(key=lambda c: c.properties["Name"])
331
self.clients.sort(None, lambda c: c.properties[u"name"])
572
334
def remove_client(self, client, path=None):
573
335
self.clients.remove(client)
575
337
path = client.proxy.object_path
576
338
del self.clients_dict[path]
579
341
def refresh(self):
580
342
"""Redraw the screen"""
581
343
canvas = self.topwidget.render(self.size, focus=True)
582
344
self.screen.draw_screen(self.size, canvas)
585
347
"""Start the main loop and exit when it's done."""
586
self.bus = dbus.SystemBus()
587
mandos_dbus_objc = self.bus.get_object(
588
self.busname, "/", follow_name_owner_changes=True)
589
self.mandos_serv = dbus.Interface(
590
mandos_dbus_objc, dbus_interface=server_interface)
592
mandos_clients = (self.mandos_serv
593
.GetAllClientsWithProperties())
594
if not mandos_clients:
595
self.log_message_raw(("bold",
596
"Note: Server has no clients."))
597
except dbus.exceptions.DBusException:
598
self.log_message_raw(("bold",
599
"Note: No Mandos server running."))
600
mandos_clients = dbus.Dictionary()
603
.connect_to_signal("InterfacesRemoved",
604
self.find_and_remove_client,
605
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
608
.connect_to_signal("InterfacesAdded",
610
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
613
.connect_to_signal("ClientNotFound",
614
self.client_not_found,
615
dbus_interface=server_interface,
617
for path, client in mandos_clients.items():
618
client_proxy_object = self.bus.get_object(self.busname,
620
self.add_client(MandosClientWidget(
621
server_proxy_object=self.mandos_serv,
622
proxy_object=client_proxy_object,
624
update_hook=self.refresh,
625
delete_hook=self.remove_client,
626
logger=self.log_message),
630
self._input_callback_tag = (GLib.io_add_watch
349
self._input_callback_tag = (gobject.io_add_watch
631
350
(sys.stdin.fileno(),
633
352
self.process_input))
634
353
self.main_loop.run()
635
354
# Main loop has finished, we should close everything now
636
GLib.source_remove(self._input_callback_tag)
355
gobject.source_remove(self._input_callback_tag)
637
356
self.screen.stop()
640
359
self.main_loop.quit()
642
361
def process_input(self, source, condition):
643
362
keys = self.screen.get_input()
644
translations = {"ctrl n": "down", # Emacs
645
"ctrl p": "up", # Emacs
646
"ctrl v": "page down", # Emacs
647
"meta v": "page up", # Emacs
648
" ": "page down", # less
649
"f": "page down", # less
650
"b": "page up", # less
363
translations = { u"j": u"down",
656
368
key = translations[key]
657
369
except KeyError: # :-)
660
if key == "q" or key == "Q":
372
if key == u"q" or key == u"Q":
663
elif key == "window resize":
375
elif key == u"window resize":
664
376
self.size = self.screen.get_cols_rows()
666
elif key == "ctrl l":
669
elif key == "l" or key == "D":
670
self.toggle_log_display()
672
elif key == "w" or key == "i":
673
self.change_log_display()
675
elif key == "?" or key == "f1" or key == "esc":
676
if not self.log_visible:
677
self.log_visible = True
679
self.log_message_raw(("bold",
683
"l: Log window toggle",
684
"TAB: Switch window",
685
"w: Wrap (log lines)",
686
"v: Toggle verbose log",
688
self.log_message_raw(("bold",
694
"s: Start new checker",
701
if self.topwidget.get_focus() is self.logbox:
702
self.topwidget.set_focus(0)
704
self.topwidget.set_focus(self.logbox)
707
if self.log_level == 0:
709
self.log_message("Verbose mode: Off")
712
self.log_message("Verbose mode: On")
713
# elif (key == "end" or key == "meta >" or key == "G"
715
# pass # xxx end-of-buffer
716
# elif (key == "home" or key == "meta <" or key == "g"
718
# pass # xxx beginning-of-buffer
719
# elif key == "ctrl e" or key == "$":
720
# pass # xxx move-end-of-line
721
# elif key == "ctrl a" or key == "^":
722
# pass # xxx move-beginning-of-line
723
# elif key == "ctrl b" or key == "meta (" or key == "h":
725
# elif key == "ctrl f" or key == "meta )" or key == "l":
728
# pass # scroll up log
730
# pass # scroll down log
731
380
elif self.topwidget.selectable():
732
381
self.topwidget.keypress(self.size, key)