2
2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 Björn Påhlsson
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
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, '')
24
locale.setlocale(locale.LC_ALL, u'')
57
27
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
59
29
# Some useful constants
60
domain = 'se.recompile'
30
domain = 'se.bsnet.fukt'
61
31
server_interface = domain + '.Mandos'
62
32
client_interface = domain + '.Mandos.Client'
35
# Always run in monochrome mode
36
urwid.curses_display.curses.has_colors = lambda : False
38
# Urwid doesn't support blinking, but we want it. Since we have no
39
# use for underline on its own, we make underline also always blink.
40
urwid.curses_display.curses.A_UNDERLINE |= (
41
urwid.curses_display.curses.A_BLINK)
65
43
def isoformat_to_datetime(iso):
66
44
"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)
47
d, t = iso.split(u"T", 1)
48
year, month, day = d.split(u"-", 2)
49
hour, minute, second = t.split(u":", 2)
72
50
second, fraction = divmod(float(second), 1)
73
51
return datetime.datetime(int(year),
83
61
properties and calls a hook function when any of them are
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
64
def __init__(self, proxy_object=None, *args, **kwargs):
87
65
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("PropertyChanged",
91
self._property_changed,
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)
103
def _property_changed(self, property, value):
104
"""Helper which takes positional arguments"""
105
return self.property_changed(property=property, value=value)
67
self.properties = dict()
68
self.proxy.connect_to_signal(u"PropertyChanged",
69
self.property_changed,
73
self.properties.update(
74
self.proxy.GetAll(client_interface,
75
dbus_interface = dbus.PROPERTIES_IFACE))
77
#XXX This break good super behaviour!
78
# super(MandosClientPropertyCache, self).__init__(
107
81
def property_changed(self, property=None, value=None):
108
82
"""This is called whenever we get a PropertyChanged signal
131
102
self.logger = logger
133
104
self._update_timer_callback_tag = None
105
self._update_timer_callback_lock = 0
106
self.last_checker_failed = False
135
108
# The widget shown normally
136
self._text_widget = urwid.Text("")
109
self._text_widget = urwid.Text(u"")
137
110
# The widget shown when we have focus
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
111
self._focus_text_widget = urwid.Text(u"")
112
super(MandosClientWidget, self).__init__(
113
update_hook=update_hook, delete_hook=delete_hook,
141
116
self.opened = False
143
self.match_objects = (
144
self.proxy.connect_to_signal("CheckerCompleted",
145
self.checker_completed,
148
self.proxy.connect_to_signal("CheckerStarted",
149
self.checker_started,
152
self.proxy.connect_to_signal("GotSecret",
156
self.proxy.connect_to_signal("NeedApproval",
160
self.proxy.connect_to_signal("Rejected",
164
self.logger('Created client {}'
165
.format(self.properties["Name"]), level=0)
118
last_checked_ok = isoformat_to_datetime(self.properties
120
if last_checked_ok is None:
121
self.last_checker_failed = True
123
self.last_checker_failed = ((datetime.datetime.utcnow()
130
if self.last_checker_failed:
131
self.using_timer(True)
133
if self.need_approval:
134
self.using_timer(True)
136
self.proxy.connect_to_signal(u"CheckerCompleted",
137
self.checker_completed,
140
self.proxy.connect_to_signal(u"CheckerStarted",
141
self.checker_started,
144
self.proxy.connect_to_signal(u"GotSecret",
148
self.proxy.connect_to_signal(u"NeedApproval",
152
self.proxy.connect_to_signal(u"Rejected",
157
def property_changed(self, property=None, value=None):
158
super(self, MandosClientWidget).property_changed(property,
160
if property == u"ApprovalPending":
161
using_timer(bool(value))
167
163
def using_timer(self, flag):
168
164
"""Call this method with True or False when timer should be
169
165
activated or deactivated.
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
167
old = self._update_timer_callback_lock
169
self._update_timer_callback_lock += 1
171
self._update_timer_callback_lock -= 1
172
if old == 0 and self._update_timer_callback_lock:
173
173
self._update_timer_callback_tag = (gobject.timeout_add
175
175
self.update_timer))
176
elif not (flag or self._update_timer_callback_tag is None):
176
elif old and self._update_timer_callback_lock == 0:
177
177
gobject.source_remove(self._update_timer_callback_tag)
178
178
self._update_timer_callback_tag = None
180
180
def checker_completed(self, exitstatus, condition, command):
181
181
if exitstatus == 0:
182
self.logger('Checker for client {} (command "{}")'
183
' succeeded'.format(self.properties["Name"],
182
if self.last_checker_failed:
183
self.last_checker_failed = False
184
self.using_timer(False)
185
#self.logger(u'Checker for client %s (command "%s")'
187
# % (self.properties[u"Name"], command))
191
if not self.last_checker_failed:
192
self.last_checker_failed = True
193
self.using_timer(True)
188
194
if os.WIFEXITED(condition):
189
self.logger('Checker for client {} (command "{}") failed'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
195
self.logger(u'Checker for client %s (command "%s")'
196
u' failed with exit code %s'
197
% (self.properties[u"Name"], command,
198
os.WEXITSTATUS(condition)))
193
199
elif os.WIFSIGNALED(condition):
194
self.logger('Checker for client {} (command "{}") was'
195
' killed by signal {}'
196
.format(self.properties["Name"], command,
197
os.WTERMSIG(condition)))
200
self.logger(u'Checker for client %s (command "%s")'
201
u' was killed by signal %s'
202
% (self.properties[u"Name"], command,
203
os.WTERMSIG(condition)))
198
204
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {} (command "{}") dumped'
200
' core'.format(self.properties["Name"],
205
self.logger(u'Checker for client %s (command "%s")'
207
% (self.properties[u"Name"], command))
203
self.logger('Checker for client {} completed'
205
.format(self.properties["Name"]))
209
self.logger(u'Checker for client %s completed'
208
213
def checker_started(self, command):
209
"""Server signals that a checker started."""
210
self.logger('Client {} started checker "{}"'
211
.format(self.properties["Name"],
214
#self.logger(u'Client %s started checker "%s"'
215
# % (self.properties[u"Name"], unicode(command)))
214
218
def got_secret(self):
215
self.logger('Client {} received its secret'
216
.format(self.properties["Name"]))
219
self.last_checker_failed = False
220
self.logger(u'Client %s received its secret'
221
% self.properties[u"Name"])
218
223
def need_approval(self, timeout, default):
220
message = 'Client {} needs approval within {} seconds'
225
message = u'Client %s needs approval within %s seconds'
222
message = 'Client {} will get its secret in {} seconds'
223
self.logger(message.format(self.properties["Name"],
227
message = u'Client %s will get its secret in %s seconds'
229
% (self.properties[u"Name"], timeout/1000))
230
self.using_timer(True)
226
232
def rejected(self, reason):
227
self.logger('Client {} was rejected; reason: {}'
228
.format(self.properties["Name"], reason))
233
self.logger(u'Client %s was rejected; reason: %s'
234
% (self.properties[u"Name"], reason))
230
236
def selectable(self):
231
237
"""Make this a "selectable" widget.
232
238
This overrides the method from urwid.FlowWidget."""
235
def rows(self, maxcolrow, focus=False):
241
def rows(self, (maxcol,), focus=False):
236
242
"""How many rows this widget will occupy might depend on
237
243
whether we have focus or not.
238
244
This overrides the method from urwid.FlowWidget"""
239
return self.current_widget(focus).rows(maxcolrow, focus=focus)
245
return self.current_widget(focus).rows((maxcol,), focus=focus)
241
247
def current_widget(self, focus=False):
242
248
if focus or self.opened:
246
252
def update(self):
247
253
"Called when what is visible on the screen should be updated."
248
254
# How to add standout mode to a style
249
with_standout = { "normal": "standout",
250
"bold": "bold-standout",
252
"underline-blink-standout",
253
"bold-underline-blink":
254
"bold-underline-blink-standout",
255
with_standout = { u"normal": u"standout",
256
u"bold": u"bold-standout",
258
u"underline-blink-standout",
259
u"bold-underline-blink":
260
u"bold-underline-blink-standout",
257
263
# Rebuild focus and non-focus widgets using current properties
259
265
# Base part of a client. Name!
260
base = '{name}: '.format(name=self.properties["Name"])
261
if not self.properties["Enabled"]:
263
self.using_timer(False)
264
elif self.properties["ApprovalPending"]:
266
base = (u'%(name)s: '
267
% {u"name": self.properties[u"Name"]})
268
if not self.properties[u"Enabled"]:
269
message = u"DISABLED"
270
elif self.properties[u"ApprovalPending"]:
265
271
timeout = datetime.timedelta(milliseconds
266
272
= self.properties
268
274
last_approval_request = isoformat_to_datetime(
269
self.properties["LastApprovalRequest"])
275
self.properties[u"LastApprovalRequest"])
270
276
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
277
timer = timeout - (datetime.datetime.utcnow()
278
- last_approval_request)
275
280
timer = datetime.timedelta()
276
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {}. (d)eny?"
279
message = "Denial in {}. (a)pprove?"
280
message = message.format(str(timer).rsplit(".", 1)[0])
281
self.using_timer(True)
282
elif self.properties["LastCheckerStatus"] != 0:
283
# When checker has failed, show timer until client expires
284
expires = self.properties["Expires"]
286
timer = datetime.timedelta(0)
288
expires = (datetime.datetime.strptime
289
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
290
timer = max(expires - datetime.datetime.utcnow(),
291
datetime.timedelta())
292
message = ('A checker has failed! Time until client'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
281
if self.properties[u"ApprovedByDefault"]:
282
message = u"Approval in %s. (d)eny?"
284
message = u"Denial in %s. (a)pprove?"
285
message = message % unicode(timer).rsplit(".", 1)[0]
286
elif self.last_checker_failed:
287
timeout = datetime.timedelta(milliseconds
290
last_ok = isoformat_to_datetime(
291
max((self.properties[u"LastCheckedOK"]
292
or self.properties[u"Created"]),
293
self.properties[u"LastEnabled"]))
294
timer = timeout - (datetime.datetime.utcnow() - last_ok)
295
message = (u'A checker has failed! Time until client'
296
u' gets disabled: %s'
297
% unicode(timer).rsplit(".", 1)[0])
298
self.using_timer(False)
299
self._text = "{}{}".format(base, message)
300
self._text = "%s%s" % (base, message)
301
302
if not urwid.supports_unicode():
302
303
self._text = self._text.encode("ascii", "replace")
303
textlist = [("normal", self._text)]
304
textlist = [(u"normal", self._text)]
304
305
self._text_widget.set_text(textlist)
305
306
self._focus_text_widget.set_text([(with_standout[text[0]],
315
316
self.update_hook()
317
318
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
321
321
return True # Keep calling this
323
def delete(self, **kwargs):
324
324
if self._update_timer_callback_tag is not None:
325
325
gobject.source_remove(self._update_timer_callback_tag)
326
326
self._update_timer_callback_tag = None
327
for match in self.match_objects:
329
self.match_objects = ()
330
327
if self.delete_hook is not None:
331
328
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
334
def render(self, maxcolrow, focus=False):
330
def render(self, (maxcol,), focus=False):
335
331
"""Render differently if we have focus.
336
332
This overrides the method from urwid.FlowWidget"""
337
return self.current_widget(focus).render(maxcolrow,
333
return self.current_widget(focus).render((maxcol,),
340
def keypress(self, maxcolrow, key):
336
def keypress(self, (maxcol,), key):
342
338
This overrides the method from urwid.FlowWidget"""
344
self.proxy.Enable(dbus_interface = client_interface,
347
self.proxy.Disable(dbus_interface = client_interface,
340
self.proxy.Enable(dbus_interface = client_interface)
342
self.proxy.Disable(dbus_interface = client_interface)
350
344
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
351
dbus_interface = client_interface,
345
dbus_interface = client_interface)
354
347
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
355
dbus_interface = client_interface,
357
elif key == "R" or key == "_" or key == "ctrl k":
348
dbus_interface = client_interface)
349
elif key == u"r" or key == u"_" or key == u"ctrl k":
358
350
self.server_proxy_object.RemoveClient(self.proxy
362
self.proxy.StartChecker(dbus_interface = client_interface,
365
self.proxy.StopChecker(dbus_interface = client_interface,
368
self.proxy.CheckedOK(dbus_interface = client_interface,
353
self.proxy.StartChecker(dbus_interface = client_interface)
355
self.proxy.StopChecker(dbus_interface = client_interface)
357
self.proxy.CheckedOK(dbus_interface = client_interface)
371
# elif key == "p" or key == "=":
359
# elif key == u"p" or key == "=":
372
360
# self.proxy.pause()
373
# elif key == "u" or key == ":":
361
# elif key == u"u" or key == ":":
374
362
# self.proxy.unpause()
363
# elif key == u"RET":
380
def property_changed(self, property=None, **kwargs):
368
def property_changed(self, property=None, value=None,
381
370
"""Call self.update() if old value is not new value.
382
371
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
372
property_name = unicode(property)
384
373
old_value = self.properties.get(property_name)
385
374
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
375
property=property, value=value, *args, **kwargs)
387
376
if self.properties.get(property_name) != old_value:
404
394
"""This is the entire user interface - the whole screen
405
395
with boxes, lists of client widgets, etc.
407
def __init__(self, max_log_length=1000, log_level=1):
397
def __init__(self, max_log_length=1000):
408
398
DBusGMainLoop(set_as_default=True)
410
400
self.screen = urwid.curses_display.Screen()
412
402
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", "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"),
404
u"default", u"default", None),
406
u"default", u"default", u"bold"),
408
u"default", u"default", u"underline"),
410
u"default", u"default", u"standout"),
411
(u"bold-underline-blink",
412
u"default", u"default", (u"bold", u"underline")),
414
u"default", u"default", (u"bold", u"standout")),
415
(u"underline-blink-standout",
416
u"default", u"default", (u"underline", u"standout")),
417
(u"bold-underline-blink-standout",
418
u"default", u"default", (u"bold", u"underline",
433
422
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
423
self.divider = u"─" # \u2500
424
#self.divider = u"━" # \u2501
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
426
#self.divider = u"-" # \u002d
427
self.divider = u"_" # \u005f
440
429
self.screen.start()
457
444
# This keeps track of whether self.uilist currently has
458
445
# self.logbox in it or not
459
446
self.log_visible = True
460
self.log_wrap = "any"
447
self.log_wrap = u"any"
463
self.log_message_raw(("bold",
464
"Mandos Monitor version " + version))
465
self.log_message_raw(("bold",
450
self.log_message_raw((u"bold",
451
u"Mandos Monitor version " + version))
452
self.log_message_raw((u"bold",
468
455
self.busname = domain + '.Mandos'
469
456
self.main_loop = gobject.MainLoop()
457
self.bus = dbus.SystemBus()
458
mandos_dbus_objc = self.bus.get_object(
459
self.busname, u"/", follow_name_owner_changes=True)
460
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
464
mandos_clients = (self.mandos_serv
465
.GetAllClientsWithProperties())
466
except dbus.exceptions.DBusException:
467
mandos_clients = dbus.Dictionary()
470
.connect_to_signal(u"ClientRemoved",
471
self.find_and_remove_client,
472
dbus_interface=server_interface,
475
.connect_to_signal(u"ClientAdded",
477
dbus_interface=server_interface,
480
.connect_to_signal(u"ClientNotFound",
481
self.client_not_found,
482
dbus_interface=server_interface,
484
for path, client in mandos_clients.iteritems():
485
client_proxy_object = self.bus.get_object(self.busname,
487
self.add_client(MandosClientWidget(server_proxy_object
490
=client_proxy_object,
471
500
def client_not_found(self, fingerprint, address):
472
self.log_message("Client with address {} and fingerprint {}"
473
" could not be found"
474
.format(address, fingerprint))
501
self.log_message((u"Client with address %s and fingerprint %s"
502
u" could not be found" % (address,
476
505
def rebuild(self):
477
506
"""This rebuilds the User Interface.
488
517
if self.log_visible:
489
518
self.uilist.append(self.logbox)
490
520
self.topwidget = urwid.Pile(self.uilist)
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
522
def log_message(self, message):
496
523
timestamp = datetime.datetime.now().isoformat()
497
self.log_message_raw("{}: {}".format(timestamp, message),
524
self.log_message_raw(timestamp + u": " + message)
500
def log_message_raw(self, markup, level=1):
526
def log_message_raw(self, markup):
501
527
"""Add a log message to the log buffer."""
502
if level < self.log_level:
504
528
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505
529
if (self.max_log_length
506
530
and len(self.log) > self.max_log_length):
507
531
del self.log[0:len(self.log)-self.max_log_length-1]
508
532
self.logbox.set_focus(len(self.logbox.body.contents),
533
coming_from=u"above")
512
536
def toggle_log_display(self):
513
537
"""Toggle visibility of the log buffer."""
514
538
self.log_visible = not self.log_visible
516
self.log_message("Log visibility changed to: {}"
517
.format(self.log_visible), level=0)
540
#self.log_message(u"Log visibility changed to: "
541
# + unicode(self.log_visible))
519
543
def change_log_display(self):
520
544
"""Change type of log display.
521
545
Currently, this toggles wrapping of text lines."""
522
if self.log_wrap == "clip":
523
self.log_wrap = "any"
546
if self.log_wrap == u"clip":
547
self.log_wrap = u"any"
525
self.log_wrap = "clip"
549
self.log_wrap = u"clip"
526
550
for textwidget in self.log:
527
551
textwidget.set_wrap_mode(self.log_wrap)
528
self.log_message("Wrap mode: {}".format(self.log_wrap),
552
#self.log_message(u"Wrap mode: " + self.log_wrap)
531
554
def find_and_remove_client(self, path, name):
532
"""Find a client by its object path and remove it.
555
"""Find an client from its object path and remove it.
534
557
This is connected to the ClientRemoved signal from the
535
558
Mandos server object."""
580
606
"""Start the main loop and exit when it's done."""
581
self.bus = dbus.SystemBus()
582
mandos_dbus_objc = self.bus.get_object(
583
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
588
mandos_clients = (self.mandos_serv
589
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
mandos_clients = dbus.Dictionary()
597
.connect_to_signal("ClientRemoved",
598
self.find_and_remove_client,
599
dbus_interface=server_interface,
602
.connect_to_signal("ClientAdded",
604
dbus_interface=server_interface,
607
.connect_to_signal("ClientNotFound",
608
self.client_not_found,
609
dbus_interface=server_interface,
611
for path, client in mandos_clients.items():
612
client_proxy_object = self.bus.get_object(self.busname,
614
self.add_client(MandosClientWidget(server_proxy_object
617
=client_proxy_object,
628
608
self._input_callback_tag = (gobject.io_add_watch
629
609
(sys.stdin.fileno(),
655
635
except KeyError: # :-)
658
if key == "q" or key == "Q":
638
if key == u"q" or key == u"Q":
661
elif key == "window resize":
641
elif key == u"window resize":
662
642
self.size = self.screen.get_cols_rows()
664
elif key == "ctrl l":
644
elif key == u"\f": # Ctrl-L
667
elif key == "l" or key == "D":
646
elif key == u"l" or key == u"D":
668
647
self.toggle_log_display()
670
elif key == "w" or key == "i":
649
elif key == u"w" or key == u"i":
671
650
self.change_log_display()
673
elif key == "?" or key == "f1" or key == "esc":
652
elif key == u"?" or key == u"f1" or key == u"esc":
674
653
if not self.log_visible:
675
654
self.log_visible = True
677
self.log_message_raw(("bold",
681
"l: Log window toggle",
682
"TAB: Switch window",
683
"w: Wrap (log lines)",
684
"v: Toggle verbose log",
686
self.log_message_raw(("bold",
692
"s: Start new checker",
656
self.log_message_raw((u"bold",
660
u"l: Log window toggle",
661
u"TAB: Switch window",
663
self.log_message_raw((u"bold",
669
u"s: Start new checker",
699
676
if self.topwidget.get_focus() is self.logbox:
700
677
self.topwidget.set_focus(0)
702
679
self.topwidget.set_focus(self.logbox)
705
if self.log_level == 0:
707
self.log_message("Verbose mode: Off")
710
self.log_message("Verbose mode: On")
711
#elif (key == "end" or key == "meta >" or key == "G"
681
#elif (key == u"end" or key == u"meta >" or key == u"G"
713
683
# pass # xxx end-of-buffer
714
#elif (key == "home" or key == "meta <" or key == "g"
684
#elif (key == u"home" or key == u"meta <" or key == u"g"
716
686
# pass # xxx beginning-of-buffer
717
#elif key == "ctrl e" or key == "$":
687
#elif key == u"ctrl e" or key == u"$":
718
688
# pass # xxx move-end-of-line
719
#elif key == "ctrl a" or key == "^":
689
#elif key == u"ctrl a" or key == u"^":
720
690
# pass # xxx move-beginning-of-line
721
#elif key == "ctrl b" or key == "meta (" or key == "h":
691
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
722
692
# pass # xxx left
723
#elif key == "ctrl f" or key == "meta )" or key == "l":
693
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
724
694
# pass # xxx right
726
696
# pass # scroll up log
728
698
# pass # scroll down log
729
699
elif self.topwidget.selectable():
730
700
self.topwidget.keypress(self.size, key)