2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2015 Teddy Hogeborn
7
# Copyright © 2009-2015 Björn Påhlsson
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
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
41
15
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
51
if sys.version_info.major == 2:
54
locale.setlocale(locale.LC_ALL, '')
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
24
locale.setlocale(locale.LC_ALL, u'')
59
26
# Some useful constants
60
domain = 'se.recompile'
27
domain = 'se.bsnet.fukt'
61
28
server_interface = domain + '.Mandos'
62
29
client_interface = domain + '.Mandos.Client'
32
# Always run in monochrome mode
33
urwid.curses_display.curses.has_colors = lambda : False
35
# Urwid doesn't support blinking, but we want it. Since we have no
36
# use for underline on its own, we make underline also always blink.
37
urwid.curses_display.curses.A_UNDERLINE |= (
38
urwid.curses_display.curses.A_BLINK)
65
40
def isoformat_to_datetime(iso):
66
41
"Parse an ISO 8601 date string to a datetime.datetime()"
69
d, t = iso.split("T", 1)
70
year, month, day = d.split("-", 2)
71
hour, minute, second = t.split(":", 2)
44
d, t = iso.split(u"T", 1)
45
year, month, day = d.split(u"-", 2)
46
hour, minute, second = t.split(u":", 2)
72
47
second, fraction = divmod(float(second), 1)
73
48
return datetime.datetime(int(year),
83
58
properties and calls a hook function when any of them are
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
61
def __init__(self, proxy_object=None, *args, **kwargs):
87
62
self.proxy = proxy_object # Mandos Client proxy object
88
self.properties = dict() if properties is None else properties
89
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertiesChanged",
91
self.properties_changed,
92
dbus.PROPERTIES_IFACE,
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
99
= dbus.PROPERTIES_IFACE))
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
64
self.properties = dict()
65
self.proxy.connect_to_signal(u"PropertyChanged",
66
self.property_changed,
70
self.properties.update(
71
self.proxy.GetAll(client_interface,
72
dbus_interface = dbus.PROPERTIES_IFACE))
73
super(MandosClientPropertyCache, self).__init__(
74
proxy_object=proxy_object, *args, **kwargs)
103
def properties_changed(self, interface, properties, invalidated):
104
"""This is called whenever we get a PropertiesChanged signal
105
It updates the changed properties in the "properties" dict.
76
def property_changed(self, property=None, value=None):
77
"""This is called whenever we get a PropertyChanged signal
78
It updates the changed property in the "properties" dict.
107
80
# Update properties dict with new value
108
self.properties.update(properties)
111
self.property_changed_match.remove()
81
self.properties[property] = value
114
84
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
127
97
self.logger = logger
129
99
self._update_timer_callback_tag = None
100
self.last_checker_failed = False
131
102
# The widget shown normally
132
self._text_widget = urwid.Text("")
103
self._text_widget = urwid.Text(u"")
133
104
# The widget shown when we have focus
134
self._focus_text_widget = urwid.Text("")
135
super(MandosClientWidget, self).__init__(**kwargs)
105
self._focus_text_widget = urwid.Text(u"")
106
super(MandosClientWidget, self).__init__(
107
update_hook=update_hook, delete_hook=delete_hook,
137
110
self.opened = False
139
self.match_objects = (
140
self.proxy.connect_to_signal("CheckerCompleted",
141
self.checker_completed,
144
self.proxy.connect_to_signal("CheckerStarted",
145
self.checker_started,
148
self.proxy.connect_to_signal("GotSecret",
152
self.proxy.connect_to_signal("NeedApproval",
156
self.proxy.connect_to_signal("Rejected",
160
self.logger('Created client {}'
161
.format(self.properties["Name"]), level=0)
163
def using_timer(self, flag):
164
"""Call this method with True or False when timer should be
165
activated or deactivated.
167
if flag and self._update_timer_callback_tag is None:
168
# Will update the shown timer value every second
111
self.proxy.connect_to_signal(u"CheckerCompleted",
112
self.checker_completed,
115
self.proxy.connect_to_signal(u"CheckerStarted",
116
self.checker_started,
119
self.proxy.connect_to_signal(u"GotSecret",
123
self.proxy.connect_to_signal(u"Rejected",
127
last_checked_ok = isoformat_to_datetime(self.properties
129
if last_checked_ok is None:
130
self.last_checker_failed = True
132
self.last_checker_failed = ((datetime.datetime.utcnow()
136
self.properties["interval"]))
137
if self.last_checker_failed:
169
138
self._update_timer_callback_tag = (gobject.timeout_add
171
140
self.update_timer))
172
elif not (flag or self._update_timer_callback_tag is None):
173
gobject.source_remove(self._update_timer_callback_tag)
174
self._update_timer_callback_tag = None
176
def checker_completed(self, exitstatus, signal, command):
142
def checker_completed(self, exitstatus, condition, command):
177
143
if exitstatus == 0:
178
self.logger('Checker for client {} (command "{}")'
179
' succeeded'.format(self.properties["Name"],
144
if self.last_checker_failed:
145
self.last_checker_failed = False
146
gobject.source_remove(self._update_timer_callback_tag)
147
self._update_timer_callback_tag = None
148
self.logger(u'Checker for client %s (command "%s")'
150
% (self.properties[u"name"], command))
185
self.logger('Checker for client {} (command "{}") failed'
187
.format(self.properties["Name"], command,
190
self.logger('Checker for client {} (command "{}") was'
191
' killed by signal {}'
192
.format(self.properties["Name"], command,
154
if not self.last_checker_failed:
155
self.last_checker_failed = True
156
self._update_timer_callback_tag = (gobject.timeout_add
159
if os.WIFEXITED(condition):
160
self.logger(u'Checker for client %s (command "%s")'
161
u' failed with exit code %s'
162
% (self.properties[u"name"], command,
163
os.WEXITSTATUS(condition)))
164
elif os.WIFSIGNALED(condition):
165
self.logger(u'Checker for client %s (command "%s")'
166
u' was killed by signal %s'
167
% (self.properties[u"name"], command,
168
os.WTERMSIG(condition)))
169
elif os.WCOREDUMP(condition):
170
self.logger(u'Checker for client %s (command "%s")'
172
% (self.properties[u"name"], command))
195
self.logger('Checker for client {} completed'
197
.format(self.properties["Name"]))
174
self.logger(u'Checker for client %s completed mysteriously')
200
177
def checker_started(self, command):
201
"""Server signals that a checker started."""
202
self.logger('Client {} started checker "{}"'
203
.format(self.properties["Name"],
178
self.logger(u'Client %s started checker "%s"'
179
% (self.properties[u"name"], unicode(command)))
206
181
def got_secret(self):
207
self.logger('Client {} received its secret'
208
.format(self.properties["Name"]))
210
def need_approval(self, timeout, default):
212
message = 'Client {} needs approval within {} seconds'
214
message = 'Client {} will get its secret in {} seconds'
215
self.logger(message.format(self.properties["Name"],
218
def rejected(self, reason):
219
self.logger('Client {} was rejected; reason: {}'
220
.format(self.properties["Name"], reason))
182
self.logger(u'Client %s received its secret'
183
% self.properties[u"name"])
186
self.logger(u'Client %s was rejected'
187
% self.properties[u"name"])
222
189
def selectable(self):
223
190
"""Make this a "selectable" widget.
224
191
This overrides the method from urwid.FlowWidget."""
227
def rows(self, maxcolrow, focus=False):
194
def rows(self, (maxcol,), focus=False):
228
195
"""How many rows this widget will occupy might depend on
229
196
whether we have focus or not.
230
197
This overrides the method from urwid.FlowWidget"""
231
return self.current_widget(focus).rows(maxcolrow, focus=focus)
198
return self.current_widget(focus).rows((maxcol,), focus=focus)
233
200
def current_widget(self, focus=False):
234
201
if focus or self.opened:
238
205
def update(self):
239
206
"Called when what is visible on the screen should be updated."
240
207
# How to add standout mode to a style
241
with_standout = { "normal": "standout",
242
"bold": "bold-standout",
244
"underline-blink-standout",
245
"bold-underline-blink":
246
"bold-underline-blink-standout",
208
with_standout = { u"normal": u"standout",
209
u"bold": u"bold-standout",
211
u"underline-blink-standout",
212
u"bold-underline-blink":
213
u"bold-underline-blink-standout",
249
216
# Rebuild focus and non-focus widgets using current properties
251
# Base part of a client. Name!
252
base = '{name}: '.format(name=self.properties["Name"])
253
if not self.properties["Enabled"]:
255
self.using_timer(False)
256
elif self.properties["ApprovalPending"]:
257
timeout = datetime.timedelta(milliseconds
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)
217
self._text = (u'%(name)s: %(enabled)s%(timer)s'
218
% { u"name": self.properties[u"name"],
221
if self.properties[u"enabled"]
223
u"timer": (unicode(datetime.timedelta
229
- isoformat_to_datetime
230
(max((self.properties
235
self.properties[u"last_enabled"]))))
236
if (self.last_checker_failed
293
240
if not urwid.supports_unicode():
294
241
self._text = self._text.encode("ascii", "replace")
295
textlist = [("normal", self._text)]
242
textlist = [(u"normal", self._text)]
296
243
self._text_widget.set_text(textlist)
297
244
self._focus_text_widget.set_text([(with_standout[text[0]],
307
254
self.update_hook()
309
256
def update_timer(self):
310
"""called by gobject. Will indefinitely loop until
311
gobject.source_remove() on tag is called"""
313
259
return True # Keep calling this
315
def delete(self, **kwargs):
316
262
if self._update_timer_callback_tag is not None:
317
263
gobject.source_remove(self._update_timer_callback_tag)
318
264
self._update_timer_callback_tag = None
319
for match in self.match_objects:
321
self.match_objects = ()
322
265
if self.delete_hook is not None:
323
266
self.delete_hook(self)
324
return super(MandosClientWidget, self).delete(**kwargs)
326
def render(self, maxcolrow, focus=False):
268
def render(self, (maxcol,), focus=False):
327
269
"""Render differently if we have focus.
328
270
This overrides the method from urwid.FlowWidget"""
329
return self.current_widget(focus).render(maxcolrow,
271
return self.current_widget(focus).render((maxcol,),
332
def keypress(self, maxcolrow, key):
274
def keypress(self, (maxcol,), key):
334
276
This overrides the method from urwid.FlowWidget"""
336
self.proxy.Set(client_interface, "Enabled",
337
dbus.Boolean(True), ignore_reply = True,
338
dbus_interface = dbus.PROPERTIES_IFACE)
340
self.proxy.Set(client_interface, "Enabled", False,
342
dbus_interface = dbus.PROPERTIES_IFACE)
344
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
345
dbus_interface = client_interface,
348
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
349
dbus_interface = client_interface,
351
elif key == "R" or key == "_" or key == "ctrl k":
277
if key == u"e" or key == u"+":
279
elif key == u"d" or key == u"-":
281
elif key == u"r" or key == u"_" or key == u"ctrl k":
352
282
self.server_proxy_object.RemoveClient(self.proxy
356
self.proxy.Set(client_interface, "CheckerRunning",
357
dbus.Boolean(True), ignore_reply = True,
358
dbus_interface = dbus.PROPERTIES_IFACE)
360
self.proxy.Set(client_interface, "CheckerRunning",
361
dbus.Boolean(False), ignore_reply = True,
362
dbus_interface = dbus.PROPERTIES_IFACE)
364
self.proxy.CheckedOK(dbus_interface = client_interface,
285
self.proxy.StartChecker()
287
self.proxy.StopChecker()
289
self.proxy.CheckedOK()
367
# elif key == "p" or key == "=":
291
# elif key == u"p" or key == "=":
368
292
# self.proxy.pause()
369
# elif key == "u" or key == ":":
293
# elif key == u"u" or key == ":":
370
294
# self.proxy.unpause()
295
# elif key == u"RET":
376
def properties_changed(self, interface, properties, invalidated):
377
"""Call self.update() if any properties changed.
300
def property_changed(self, property=None, value=None,
302
"""Call self.update() if old value is not new value.
378
303
This overrides the method from MandosClientPropertyCache"""
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):
304
property_name = unicode(property)
305
old_value = self.properties.get(property_name)
306
super(MandosClientWidget, self).property_changed(
307
property=property, value=value, *args, **kwargs)
308
if self.properties.get(property_name) != old_value:
401
325
"""This is the entire user interface - the whole screen
402
326
with boxes, lists of client widgets, etc.
404
def __init__(self, max_log_length=1000, log_level=1):
328
def __init__(self, max_log_length=1000):
405
329
DBusGMainLoop(set_as_default=True)
407
331
self.screen = urwid.curses_display.Screen()
409
333
self.screen.register_palette((
411
"default", "default", None),
413
"bold", "default", "bold"),
415
"underline,blink", "default", "underline,blink"),
417
"standout", "default", "standout"),
418
("bold-underline-blink",
419
"bold,underline,blink", "default", "bold,underline,blink"),
421
"bold,standout", "default", "bold,standout"),
422
("underline-blink-standout",
423
"underline,blink,standout", "default",
424
"underline,blink,standout"),
425
("bold-underline-blink-standout",
426
"bold,underline,blink,standout", "default",
427
"bold,underline,blink,standout"),
335
u"default", u"default", None),
337
u"default", u"default", u"bold"),
339
u"default", u"default", u"underline"),
341
u"default", u"default", u"standout"),
342
(u"bold-underline-blink",
343
u"default", u"default", (u"bold", u"underline")),
345
u"default", u"default", (u"bold", u"standout")),
346
(u"underline-blink-standout",
347
u"default", u"default", (u"underline", u"standout")),
348
(u"bold-underline-blink-standout",
349
u"default", u"default", (u"bold", u"underline",
430
353
if urwid.supports_unicode():
431
self.divider = "─" # \u2500
432
#self.divider = "━" # \u2501
354
self.divider = u"─" # \u2500
355
#self.divider = u"━" # \u2501
434
#self.divider = "-" # \u002d
435
self.divider = "_" # \u005f
357
#self.divider = u"-" # \u002d
358
self.divider = u"_" # \u005f
437
360
self.screen.start()
454
375
# This keeps track of whether self.uilist currently has
455
376
# self.logbox in it or not
456
377
self.log_visible = True
457
self.log_wrap = "any"
378
self.log_wrap = u"any"
460
self.log_message_raw(("bold",
461
"Mandos Monitor version " + version))
462
self.log_message_raw(("bold",
381
self.log_message_raw((u"bold",
382
u"Mandos Monitor version " + version))
383
self.log_message_raw((u"bold",
465
386
self.busname = domain + '.Mandos'
466
387
self.main_loop = gobject.MainLoop()
388
self.bus = dbus.SystemBus()
389
mandos_dbus_objc = self.bus.get_object(
390
self.busname, u"/", follow_name_owner_changes=True)
391
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
395
mandos_clients = (self.mandos_serv
396
.GetAllClientsWithProperties())
397
except dbus.exceptions.DBusException:
398
mandos_clients = dbus.Dictionary()
401
.connect_to_signal(u"ClientRemoved",
402
self.find_and_remove_client,
403
dbus_interface=server_interface,
406
.connect_to_signal(u"ClientAdded",
408
dbus_interface=server_interface,
411
.connect_to_signal(u"ClientNotFound",
412
self.client_not_found,
413
dbus_interface=server_interface,
415
for path, client in mandos_clients.iteritems():
416
client_proxy_object = self.bus.get_object(self.busname,
418
self.add_client(MandosClientWidget(server_proxy_object
421
=client_proxy_object,
468
431
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {} and fingerprint {}"
470
" could not be found"
471
.format(address, fingerprint))
432
self.log_message((u"Client with address %s and fingerprint %s"
433
u" could not be found" % (address,
473
436
def rebuild(self):
474
437
"""This rebuilds the User Interface.
475
438
Call this when the widget layout needs to change"""
477
440
#self.uilist.append(urwid.ListBox(self.clients))
478
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
441
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
480
442
#header=urwid.Divider(),
483
urwid.Divider(div_char=
444
footer=urwid.Divider(div_char=self.divider)))
485
445
if self.log_visible:
486
446
self.uilist.append(self.logbox)
487
448
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:
450
def log_message(self, message):
493
451
timestamp = datetime.datetime.now().isoformat()
494
self.log_message_raw("{}: {}".format(timestamp, message),
452
self.log_message_raw(timestamp + u": " + message)
497
def log_message_raw(self, markup, level=1):
454
def log_message_raw(self, markup):
498
455
"""Add a log message to the log buffer."""
499
if level < self.log_level:
501
456
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
457
if (self.max_log_length
503
458
and len(self.log) > self.max_log_length):
504
459
del self.log[0:len(self.log)-self.max_log_length-1]
505
460
self.logbox.set_focus(len(self.logbox.body.contents),
461
coming_from=u"above")
509
464
def toggle_log_display(self):
510
465
"""Toggle visibility of the log buffer."""
511
466
self.log_visible = not self.log_visible
513
self.log_message("Log visibility changed to: {}"
514
.format(self.log_visible), level=0)
468
self.log_message(u"Log visibility changed to: "
469
+ unicode(self.log_visible))
516
471
def change_log_display(self):
517
472
"""Change type of log display.
518
473
Currently, this toggles wrapping of text lines."""
519
if self.log_wrap == "clip":
520
self.log_wrap = "any"
474
if self.log_wrap == u"clip":
475
self.log_wrap = u"any"
522
self.log_wrap = "clip"
477
self.log_wrap = u"clip"
523
478
for textwidget in self.log:
524
479
textwidget.set_wrap_mode(self.log_wrap)
525
self.log_message("Wrap mode: {}".format(self.log_wrap),
480
self.log_message(u"Wrap mode: " + self.log_wrap)
528
482
def find_and_remove_client(self, path, name):
529
"""Find a client by its object path and remove it.
483
"""Find an client from its object path and remove it.
531
485
This is connected to the ClientRemoved signal from the
532
486
Mandos server object."""
577
534
"""Start the main loop and exit when it's done."""
578
self.bus = dbus.SystemBus()
579
mandos_dbus_objc = self.bus.get_object(
580
self.busname, "/", follow_name_owner_changes=True)
581
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
585
mandos_clients = (self.mandos_serv
586
.GetAllClientsWithProperties())
587
if not mandos_clients:
588
self.log_message_raw(("bold", "Note: Server has no clients."))
589
except dbus.exceptions.DBusException:
590
self.log_message_raw(("bold", "Note: No Mandos server running."))
591
mandos_clients = dbus.Dictionary()
594
.connect_to_signal("ClientRemoved",
595
self.find_and_remove_client,
596
dbus_interface=server_interface,
599
.connect_to_signal("ClientAdded",
601
dbus_interface=server_interface,
604
.connect_to_signal("ClientNotFound",
605
self.client_not_found,
606
dbus_interface=server_interface,
608
for path, client in mandos_clients.items():
609
client_proxy_object = self.bus.get_object(self.busname,
611
self.add_client(MandosClientWidget(server_proxy_object
614
=client_proxy_object,
625
536
self._input_callback_tag = (gobject.io_add_watch
626
537
(sys.stdin.fileno(),
652
563
except KeyError: # :-)
655
if key == "q" or key == "Q":
566
if key == u"q" or key == u"Q":
658
elif key == "window resize":
569
elif key == u"window resize":
659
570
self.size = self.screen.get_cols_rows()
661
elif key == "ctrl l":
572
elif key == u"\f": # Ctrl-L
664
elif key == "l" or key == "D":
574
elif key == u"l" or key == u"D":
665
575
self.toggle_log_display()
667
elif key == "w" or key == "i":
577
elif key == u"w" or key == u"i":
668
578
self.change_log_display()
670
elif key == "?" or key == "f1" or key == "esc":
580
elif key == u"?" or key == u"f1" or key == u"esc":
671
581
if not self.log_visible:
672
582
self.log_visible = True
674
self.log_message_raw(("bold",
678
"l: Log window toggle",
679
"TAB: Switch window",
680
"w: Wrap (log lines)",
681
"v: Toggle verbose log",
683
self.log_message_raw(("bold",
689
"s: Start new checker",
584
self.log_message_raw((u"bold",
588
u"l: Log window toggle",
589
u"TAB: Switch window",
591
self.log_message_raw((u"bold",
597
u"s: Start new checker",
696
602
if self.topwidget.get_focus() is self.logbox:
697
603
self.topwidget.set_focus(0)
699
605
self.topwidget.set_focus(self.logbox)
702
if self.log_level == 0:
704
self.log_message("Verbose mode: Off")
707
self.log_message("Verbose mode: On")
708
#elif (key == "end" or key == "meta >" or key == "G"
607
#elif (key == u"end" or key == u"meta >" or key == u"G"
710
609
# pass # xxx end-of-buffer
711
#elif (key == "home" or key == "meta <" or key == "g"
610
#elif (key == u"home" or key == u"meta <" or key == u"g"
713
612
# pass # xxx beginning-of-buffer
714
#elif key == "ctrl e" or key == "$":
613
#elif key == u"ctrl e" or key == u"$":
715
614
# pass # xxx move-end-of-line
716
#elif key == "ctrl a" or key == "^":
615
#elif key == u"ctrl a" or key == u"^":
717
616
# pass # xxx move-beginning-of-line
718
#elif key == "ctrl b" or key == "meta (" or key == "h":
617
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
719
618
# pass # xxx left
720
#elif key == "ctrl f" or key == "meta )" or key == "l":
619
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
721
620
# pass # xxx right
723
622
# pass # scroll up log
725
624
# pass # scroll down log
726
625
elif self.topwidget.selectable():
727
626
self.topwidget.keypress(self.size, key)