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>.
4
from __future__ import division, absolute_import, with_statement
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
15
41
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
24
locale.setlocale(locale.LC_ALL, u'')
51
if sys.version_info.major == 2:
54
locale.setlocale(locale.LC_ALL, '')
27
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
29
59
# Some useful constants
30
domain = 'se.bsnet.fukt'
60
domain = 'se.recompile'
31
61
server_interface = domain + '.Mandos'
32
62
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)
43
65
def isoformat_to_datetime(iso):
44
66
"Parse an ISO 8601 date string to a datetime.datetime()"
47
d, t = iso.split(u"T", 1)
48
year, month, day = d.split(u"-", 2)
49
hour, minute, second = t.split(u":", 2)
69
d, t = iso.split("T", 1)
70
year, month, day = d.split("-", 2)
71
hour, minute, second = t.split(":", 2)
50
72
second, fraction = divmod(float(second), 1)
51
73
return datetime.datetime(int(year),
61
83
properties and calls a hook function when any of them are
64
def __init__(self, proxy_object=None, *args, **kwargs):
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
65
87
self.proxy = proxy_object # Mandos Client proxy object
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__(
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)
81
107
def property_changed(self, property=None, value=None):
82
108
"""This is called whenever we get a PropertyChanged signal
102
131
self.logger = logger
104
133
self._update_timer_callback_tag = None
105
self.last_checker_failed = False
107
135
# The widget shown normally
108
self._text_widget = urwid.Text(u"")
136
self._text_widget = urwid.Text("")
109
137
# The widget shown when we have focus
110
self._focus_text_widget = urwid.Text(u"")
111
super(MandosClientWidget, self).__init__(
112
update_hook=update_hook, delete_hook=delete_hook,
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
115
141
self.opened = False
116
self.proxy.connect_to_signal(u"CheckerCompleted",
117
self.checker_completed,
120
self.proxy.connect_to_signal(u"CheckerStarted",
121
self.checker_started,
124
self.proxy.connect_to_signal(u"GotSecret",
128
self.proxy.connect_to_signal(u"NeedApproval",
132
self.proxy.connect_to_signal(u"Rejected",
136
last_checked_ok = isoformat_to_datetime(self.properties
138
if last_checked_ok is None:
139
self.last_checker_failed = True
141
self.last_checker_failed = ((datetime.datetime.utcnow()
145
self.properties["interval"]))
146
if self.last_checker_failed:
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)
167
def using_timer(self, flag):
168
"""Call this method with True or False when timer should be
169
activated or deactivated.
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
147
173
self._update_timer_callback_tag = (gobject.timeout_add
149
175
self.update_timer))
176
elif not (flag or self._update_timer_callback_tag is None):
177
gobject.source_remove(self._update_timer_callback_tag)
178
self._update_timer_callback_tag = None
151
180
def checker_completed(self, exitstatus, condition, command):
152
181
if exitstatus == 0:
153
if self.last_checker_failed:
154
self.last_checker_failed = False
155
gobject.source_remove(self._update_timer_callback_tag)
156
self._update_timer_callback_tag = None
157
self.logger(u'Checker for client %s (command "%s")'
159
% (self.properties[u"name"], command))
182
self.logger('Checker for client {} (command "{}")'
183
' succeeded'.format(self.properties["Name"],
163
if not self.last_checker_failed:
164
self.last_checker_failed = True
165
self._update_timer_callback_tag = (gobject.timeout_add
168
188
if os.WIFEXITED(condition):
169
self.logger(u'Checker for client %s (command "%s")'
170
u' failed with exit code %s'
171
% (self.properties[u"name"], command,
172
os.WEXITSTATUS(condition)))
189
self.logger('Checker for client {} (command "{}") failed'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
173
193
elif os.WIFSIGNALED(condition):
174
self.logger(u'Checker for client %s (command "%s")'
175
u' was killed by signal %s'
176
% (self.properties[u"name"], command,
177
os.WTERMSIG(condition)))
194
self.logger('Checker for client {} (command "{}") was'
195
' killed by signal {}'
196
.format(self.properties["Name"], command,
197
os.WTERMSIG(condition)))
178
198
elif os.WCOREDUMP(condition):
179
self.logger(u'Checker for client %s (command "%s")'
181
% (self.properties[u"name"], command))
199
self.logger('Checker for client {} (command "{}") dumped'
200
' core'.format(self.properties["Name"],
183
self.logger(u'Checker for client %s completed mysteriously')
203
self.logger('Checker for client {} completed'
205
.format(self.properties["Name"]))
186
208
def checker_started(self, command):
187
#self.logger(u'Client %s started checker "%s"'
188
# % (self.properties[u"name"], unicode(command)))
209
"""Server signals that a checker started."""
210
self.logger('Client {} started checker "{}"'
211
.format(self.properties["Name"],
191
214
def got_secret(self):
192
self.last_checker_failed = False
193
self.logger(u'Client %s received its secret'
194
% self.properties[u"name"])
215
self.logger('Client {} received its secret'
216
.format(self.properties["Name"]))
196
218
def need_approval(self, timeout, default):
198
message = u'Client %s needs approval within %s seconds'
220
message = 'Client {} needs approval within {} seconds'
200
message = u'Client %s will get its secret in %s seconds'
202
% (self.properties[u"name"], timeout/1000))
222
message = 'Client {} will get its secret in {} seconds'
223
self.logger(message.format(self.properties["Name"],
204
226
def rejected(self, reason):
205
self.logger(u'Client %s was rejected; reason: %s'
206
% (self.properties[u"name"], reason))
227
self.logger('Client {} was rejected; reason: {}'
228
.format(self.properties["Name"], reason))
208
230
def selectable(self):
209
231
"""Make this a "selectable" widget.
210
232
This overrides the method from urwid.FlowWidget."""
213
def rows(self, (maxcol,), focus=False):
235
def rows(self, maxcolrow, focus=False):
214
236
"""How many rows this widget will occupy might depend on
215
237
whether we have focus or not.
216
238
This overrides the method from urwid.FlowWidget"""
217
return self.current_widget(focus).rows((maxcol,), focus=focus)
239
return self.current_widget(focus).rows(maxcolrow, focus=focus)
219
241
def current_widget(self, focus=False):
220
242
if focus or self.opened:
224
246
def update(self):
225
247
"Called when what is visible on the screen should be updated."
226
248
# How to add standout mode to a style
227
with_standout = { u"normal": u"standout",
228
u"bold": u"bold-standout",
230
u"underline-blink-standout",
231
u"bold-underline-blink":
232
u"bold-underline-blink-standout",
249
with_standout = { "normal": "standout",
250
"bold": "bold-standout",
252
"underline-blink-standout",
253
"bold-underline-blink":
254
"bold-underline-blink-standout",
235
257
# Rebuild focus and non-focus widgets using current properties
237
259
# Base part of a client. Name!
238
base = (u'%(name)s: '
239
% {u"name": self.properties[u"name"]})
240
if not self.properties[u"enabled"]:
241
message = u"DISABLED"
242
elif self.properties[u"approved_pending"]:
243
if self.properties[u"approved_by_default"]:
244
message = u"Connection established to client. (d)eny?"
246
message = u"Seeks approval to send secret. (a)pprove?"
247
elif self.last_checker_failed:
260
base = '{name}: '.format(name=self.properties["Name"])
261
if not self.properties["Enabled"]:
263
self.using_timer(False)
264
elif self.properties["ApprovalPending"]:
248
265
timeout = datetime.timedelta(milliseconds
249
= self.properties[u"timeout"])
250
last_ok = isoformat_to_datetime(
251
max((self.properties["last_checked_ok"]
252
or self.properties["created"]),
253
self.properties[u"last_enabled"]))
254
timer = timeout - (datetime.datetime.utcnow() - last_ok)
255
message = (u'A checker has failed! Time until client gets diabled: %s'
256
% unicode(timer).rsplit(".", 1)[0])
268
last_approval_request = isoformat_to_datetime(
269
self.properties["LastApprovalRequest"])
270
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
275
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)
259
self._text = "%s%s" % (base, message)
298
self.using_timer(False)
299
self._text = "{}{}".format(base, message)
261
301
if not urwid.supports_unicode():
262
302
self._text = self._text.encode("ascii", "replace")
263
textlist = [(u"normal", self._text)]
303
textlist = [("normal", self._text)]
264
304
self._text_widget.set_text(textlist)
265
305
self._focus_text_widget.set_text([(with_standout[text[0]],
275
315
self.update_hook()
277
317
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
280
321
return True # Keep calling this
323
def delete(self, **kwargs):
283
324
if self._update_timer_callback_tag is not None:
284
325
gobject.source_remove(self._update_timer_callback_tag)
285
326
self._update_timer_callback_tag = None
327
for match in self.match_objects:
329
self.match_objects = ()
286
330
if self.delete_hook is not None:
287
331
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
289
def render(self, (maxcol,), focus=False):
334
def render(self, maxcolrow, focus=False):
290
335
"""Render differently if we have focus.
291
336
This overrides the method from urwid.FlowWidget"""
292
return self.current_widget(focus).render((maxcol,),
337
return self.current_widget(focus).render(maxcolrow,
295
def keypress(self, (maxcol,), key):
340
def keypress(self, maxcolrow, key):
297
342
This overrides the method from urwid.FlowWidget"""
299
self.proxy.Enable(dbus_interface = client_interface)
301
self.proxy.Disable(dbus_interface = client_interface)
344
self.proxy.Enable(dbus_interface = client_interface,
347
self.proxy.Disable(dbus_interface = client_interface,
303
350
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
304
dbus_interface = client_interface)
351
dbus_interface = client_interface,
306
354
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
307
dbus_interface = client_interface)
308
elif key == u"r" or key == u"_" or key == u"ctrl k":
355
dbus_interface = client_interface,
357
elif key == "R" or key == "_" or key == "ctrl k":
309
358
self.server_proxy_object.RemoveClient(self.proxy
312
self.proxy.StartChecker(dbus_interface = client_interface)
314
self.proxy.StopChecker(dbus_interface = client_interface)
316
self.proxy.CheckedOK(dbus_interface = client_interface)
362
self.proxy.StartChecker(dbus_interface = client_interface,
365
self.proxy.StopChecker(dbus_interface = client_interface,
368
self.proxy.CheckedOK(dbus_interface = client_interface,
318
# elif key == u"p" or key == "=":
371
# elif key == "p" or key == "=":
319
372
# self.proxy.pause()
320
# elif key == u"u" or key == ":":
373
# elif key == "u" or key == ":":
321
374
# self.proxy.unpause()
322
# elif key == u"RET":
325
# self.proxy.Approve(True)
327
# self.proxy.Approve(False)
331
def property_changed(self, property=None, value=None,
380
def property_changed(self, property=None, **kwargs):
333
381
"""Call self.update() if old value is not new value.
334
382
This overrides the method from MandosClientPropertyCache"""
335
property_name = unicode(property)
383
property_name = str(property)
336
384
old_value = self.properties.get(property_name)
337
385
super(MandosClientWidget, self).property_changed(
338
property=property, value=value, *args, **kwargs)
386
property=property, **kwargs)
339
387
if self.properties.get(property_name) != old_value:
356
404
"""This is the entire user interface - the whole screen
357
405
with boxes, lists of client widgets, etc.
359
def __init__(self, max_log_length=1000):
407
def __init__(self, max_log_length=1000, log_level=1):
360
408
DBusGMainLoop(set_as_default=True)
362
410
self.screen = urwid.curses_display.Screen()
364
412
self.screen.register_palette((
366
u"default", u"default", None),
368
u"default", u"default", u"bold"),
370
u"default", u"default", u"underline"),
372
u"default", u"default", u"standout"),
373
(u"bold-underline-blink",
374
u"default", u"default", (u"bold", u"underline")),
376
u"default", u"default", (u"bold", u"standout")),
377
(u"underline-blink-standout",
378
u"default", u"default", (u"underline", u"standout")),
379
(u"bold-underline-blink-standout",
380
u"default", u"default", (u"bold", u"underline",
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"),
384
433
if urwid.supports_unicode():
385
self.divider = u"─" # \u2500
386
#self.divider = u"━" # \u2501
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
388
#self.divider = u"-" # \u002d
389
self.divider = u"_" # \u005f
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
391
440
self.screen.start()
406
457
# This keeps track of whether self.uilist currently has
407
458
# self.logbox in it or not
408
459
self.log_visible = True
409
self.log_wrap = u"any"
460
self.log_wrap = "any"
412
self.log_message_raw((u"bold",
413
u"Mandos Monitor version " + version))
414
self.log_message_raw((u"bold",
463
self.log_message_raw(("bold",
464
"Mandos Monitor version " + version))
465
self.log_message_raw(("bold",
417
468
self.busname = domain + '.Mandos'
418
469
self.main_loop = gobject.MainLoop()
419
self.bus = dbus.SystemBus()
420
mandos_dbus_objc = self.bus.get_object(
421
self.busname, u"/", follow_name_owner_changes=True)
422
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
426
mandos_clients = (self.mandos_serv
427
.GetAllClientsWithProperties())
428
except dbus.exceptions.DBusException:
429
mandos_clients = dbus.Dictionary()
432
.connect_to_signal(u"ClientRemoved",
433
self.find_and_remove_client,
434
dbus_interface=server_interface,
437
.connect_to_signal(u"ClientAdded",
439
dbus_interface=server_interface,
442
.connect_to_signal(u"ClientNotFound",
443
self.client_not_found,
444
dbus_interface=server_interface,
446
for path, client in mandos_clients.iteritems():
447
client_proxy_object = self.bus.get_object(self.busname,
449
self.add_client(MandosClientWidget(server_proxy_object
452
=client_proxy_object,
462
471
def client_not_found(self, fingerprint, address):
463
self.log_message((u"Client with address %s and fingerprint %s"
464
u" could not be found" % (address,
472
self.log_message("Client with address {} and fingerprint {}"
473
" could not be found"
474
.format(address, fingerprint))
467
476
def rebuild(self):
468
477
"""This rebuilds the User Interface.
469
478
Call this when the widget layout needs to change"""
471
480
#self.uilist.append(urwid.ListBox(self.clients))
472
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
481
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
473
483
#header=urwid.Divider(),
475
footer=urwid.Divider(div_char=self.divider)))
486
urwid.Divider(div_char=
476
488
if self.log_visible:
477
489
self.uilist.append(self.logbox)
479
490
self.topwidget = urwid.Pile(self.uilist)
481
def log_message(self, message):
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
482
496
timestamp = datetime.datetime.now().isoformat()
483
self.log_message_raw(timestamp + u": " + message)
497
self.log_message_raw("{}: {}".format(timestamp, message),
485
def log_message_raw(self, markup):
500
def log_message_raw(self, markup, level=1):
486
501
"""Add a log message to the log buffer."""
502
if level < self.log_level:
487
504
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
488
505
if (self.max_log_length
489
506
and len(self.log) > self.max_log_length):
490
507
del self.log[0:len(self.log)-self.max_log_length-1]
491
508
self.logbox.set_focus(len(self.logbox.body.contents),
492
coming_from=u"above")
495
512
def toggle_log_display(self):
496
513
"""Toggle visibility of the log buffer."""
497
514
self.log_visible = not self.log_visible
499
self.log_message(u"Log visibility changed to: "
500
+ unicode(self.log_visible))
516
self.log_message("Log visibility changed to: {}"
517
.format(self.log_visible), level=0)
502
519
def change_log_display(self):
503
520
"""Change type of log display.
504
521
Currently, this toggles wrapping of text lines."""
505
if self.log_wrap == u"clip":
506
self.log_wrap = u"any"
522
if self.log_wrap == "clip":
523
self.log_wrap = "any"
508
self.log_wrap = u"clip"
525
self.log_wrap = "clip"
509
526
for textwidget in self.log:
510
527
textwidget.set_wrap_mode(self.log_wrap)
511
self.log_message(u"Wrap mode: " + self.log_wrap)
528
self.log_message("Wrap mode: {}".format(self.log_wrap),
513
531
def find_and_remove_client(self, path, name):
514
"""Find an client from its object path and remove it.
532
"""Find a client by its object path and remove it.
516
534
This is connected to the ClientRemoved signal from the
517
535
Mandos server object."""
565
580
"""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,
567
628
self._input_callback_tag = (gobject.io_add_watch
568
629
(sys.stdin.fileno(),
594
655
except KeyError: # :-)
597
if key == u"q" or key == u"Q":
658
if key == "q" or key == "Q":
600
elif key == u"window resize":
661
elif key == "window resize":
601
662
self.size = self.screen.get_cols_rows()
603
elif key == u"\f": # Ctrl-L
664
elif key == "ctrl l":
605
elif key == u"l" or key == u"D":
667
elif key == "l" or key == "D":
606
668
self.toggle_log_display()
608
elif key == u"w" or key == u"i":
670
elif key == "w" or key == "i":
609
671
self.change_log_display()
611
elif key == u"?" or key == u"f1" or key == u"esc":
673
elif key == "?" or key == "f1" or key == "esc":
612
674
if not self.log_visible:
613
675
self.log_visible = True
615
self.log_message_raw((u"bold",
619
u"l: Log window toggle",
620
u"TAB: Switch window",
622
self.log_message_raw((u"bold",
628
u"s: Start new checker",
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",
635
699
if self.topwidget.get_focus() is self.logbox:
636
700
self.topwidget.set_focus(0)
638
702
self.topwidget.set_focus(self.logbox)
640
#elif (key == u"end" or key == u"meta >" or key == u"G"
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"
642
713
# pass # xxx end-of-buffer
643
#elif (key == u"home" or key == u"meta <" or key == u"g"
714
#elif (key == "home" or key == "meta <" or key == "g"
645
716
# pass # xxx beginning-of-buffer
646
#elif key == u"ctrl e" or key == u"$":
717
#elif key == "ctrl e" or key == "$":
647
718
# pass # xxx move-end-of-line
648
#elif key == u"ctrl a" or key == u"^":
719
#elif key == "ctrl a" or key == "^":
649
720
# pass # xxx move-beginning-of-line
650
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
721
#elif key == "ctrl b" or key == "meta (" or key == "h":
651
722
# pass # xxx left
652
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
723
#elif key == "ctrl f" or key == "meta )" or key == "l":
653
724
# pass # xxx right
655
726
# pass # scroll up log
657
728
# pass # scroll down log
658
729
elif self.topwidget.selectable():
659
730
self.topwidget.keypress(self.size, key)