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
41
15
from dbus.mainloop.glib import DBusGMainLoop
43
from gi.repository import GObject
45
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'
66
dbus.OBJECT_MANAGER_IFACE
67
except AttributeError:
68
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
70
def isoformat_to_datetime(iso):
71
"Parse an ISO 8601 date string to a datetime.datetime()"
74
d, t = iso.split("T", 1)
75
year, month, day = d.split("-", 2)
76
hour, minute, second = t.split(":", 2)
77
second, fraction = divmod(float(second), 1)
78
return datetime.datetime(int(year),
83
int(second), # Whole seconds
84
int(fraction*1000000)) # Microseconds
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)
86
43
class MandosClientPropertyCache(object):
87
44
"""This wraps a Mandos Client D-Bus proxy object, caches the
88
45
properties and calls a hook function when any of them are
91
def __init__(self, proxy_object=None, properties=None, **kwargs):
48
def __init__(self, proxy_object=None, *args, **kwargs):
92
49
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(
102
self.proxy.GetAll(client_interface,
104
= dbus.PROPERTIES_IFACE))
106
super(MandosClientPropertyCache, self).__init__(**kwargs)
51
self.properties = dict()
52
self.proxy.connect_to_signal(u"PropertyChanged",
53
self.property_changed,
57
self.properties.update(
58
self.proxy.GetAll(client_interface,
59
dbus_interface = dbus.PROPERTIES_IFACE))
60
super(MandosClientPropertyCache, self).__init__(
61
proxy_object=proxy_object, *args, **kwargs)
108
def properties_changed(self, interface, properties, invalidated):
109
"""This is called whenever we get a PropertiesChanged signal
110
It updates the changed properties in the "properties" dict.
63
def property_changed(self, property=None, value=None):
64
"""This is called whenever we get a PropertyChanged signal
65
It updates the changed property in the "properties" dict.
112
67
# Update properties dict with new value
113
if interface == client_interface:
114
self.properties.update(properties)
117
self.property_changed_match.remove()
68
self.properties[property] = value
120
71
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
133
84
self.logger = logger
135
self._update_timer_callback_tag = None
137
86
# The widget shown normally
138
self._text_widget = urwid.Text("")
87
self._text_widget = urwid.Text(u"")
139
88
# The widget shown when we have focus
140
self._focus_text_widget = urwid.Text("")
141
super(MandosClientWidget, self).__init__(**kwargs)
89
self._focus_text_widget = urwid.Text(u"")
90
super(MandosClientWidget, self).__init__(
91
update_hook=update_hook, delete_hook=delete_hook,
143
94
self.opened = False
145
self.match_objects = (
146
self.proxy.connect_to_signal("CheckerCompleted",
147
self.checker_completed,
150
self.proxy.connect_to_signal("CheckerStarted",
151
self.checker_started,
154
self.proxy.connect_to_signal("GotSecret",
158
self.proxy.connect_to_signal("NeedApproval",
162
self.proxy.connect_to_signal("Rejected",
166
self.logger('Created client {}'
167
.format(self.properties["Name"]), level=0)
169
def using_timer(self, flag):
170
"""Call this method with True or False when timer should be
171
activated or deactivated.
173
if flag and self._update_timer_callback_tag is None:
174
# Will update the shown timer value every second
175
self._update_timer_callback_tag = (GObject.timeout_add
178
elif not (flag or self._update_timer_callback_tag is None):
179
GObject.source_remove(self._update_timer_callback_tag)
180
self._update_timer_callback_tag = None
95
self.proxy.connect_to_signal(u"CheckerCompleted",
96
self.checker_completed,
99
self.proxy.connect_to_signal(u"CheckerStarted",
100
self.checker_started,
103
self.proxy.connect_to_signal(u"GotSecret",
107
self.proxy.connect_to_signal(u"Rejected",
182
112
def checker_completed(self, exitstatus, condition, command):
183
113
if exitstatus == 0:
184
self.logger('Checker for client {} (command "{}")'
185
' succeeded'.format(self.properties["Name"],
114
self.logger(u'Checker for client %s (command "%s")'
116
% (self.properties[u"name"], command))
190
118
if os.WIFEXITED(condition):
191
self.logger('Checker for client {} (command "{}") failed'
193
.format(self.properties["Name"], command,
194
os.WEXITSTATUS(condition)))
195
elif os.WIFSIGNALED(condition):
196
self.logger('Checker for client {} (command "{}") was'
197
' killed by signal {}'
198
.format(self.properties["Name"], command,
199
os.WTERMSIG(condition)))
119
self.logger(u'Checker for client %s (command "%s")'
120
u' failed with exit code %s'
121
% (self.properties[u"name"], command,
122
os.WEXITSTATUS(condition)))
124
if os.WIFSIGNALED(condition):
125
self.logger(u'Checker for client %s (command "%s")'
126
u' was killed by signal %s'
127
% (self.properties[u"name"], command,
128
os.WTERMSIG(condition)))
130
if os.WCOREDUMP(condition):
131
self.logger(u'Checker for client %s (command "%s")'
133
% (self.properties[u"name"], command))
134
self.logger(u'Checker for client %s completed mysteriously')
202
136
def checker_started(self, command):
203
"""Server signals that a checker started."""
204
self.logger('Client {} started checker "{}"'
205
.format(self.properties["Name"],
137
self.logger(u'Client %s started checker "%s"'
138
% (self.properties[u"name"], unicode(command)))
208
140
def got_secret(self):
209
self.logger('Client {} received its secret'
210
.format(self.properties["Name"]))
212
def need_approval(self, timeout, default):
214
message = 'Client {} needs approval within {} seconds'
216
message = 'Client {} will get its secret in {} seconds'
217
self.logger(message.format(self.properties["Name"],
220
def rejected(self, reason):
221
self.logger('Client {} was rejected; reason: {}'
222
.format(self.properties["Name"], reason))
141
self.logger(u'Client %s received its secret'
142
% self.properties[u"name"])
145
self.logger(u'Client %s was rejected'
146
% self.properties[u"name"])
224
148
def selectable(self):
225
149
"""Make this a "selectable" widget.
226
150
This overrides the method from urwid.FlowWidget."""
229
def rows(self, maxcolrow, focus=False):
153
def rows(self, (maxcol,), focus=False):
230
154
"""How many rows this widget will occupy might depend on
231
155
whether we have focus or not.
232
156
This overrides the method from urwid.FlowWidget"""
233
return self.current_widget(focus).rows(maxcolrow, focus=focus)
157
return self.current_widget(focus).rows((maxcol,), focus=focus)
235
159
def current_widget(self, focus=False):
236
160
if focus or self.opened:
240
164
def update(self):
241
165
"Called when what is visible on the screen should be updated."
242
166
# How to add standout mode to a style
243
with_standout = { "normal": "standout",
244
"bold": "bold-standout",
246
"underline-blink-standout",
247
"bold-underline-blink":
248
"bold-underline-blink-standout",
167
with_standout = { u"normal": u"standout",
168
u"bold": u"bold-standout",
170
u"underline-blink-standout",
171
u"bold-underline-blink":
172
u"bold-underline-blink-standout",
251
175
# Rebuild focus and non-focus widgets using current properties
253
# Base part of a client. Name!
254
base = '{name}: '.format(name=self.properties["Name"])
255
if not self.properties["Enabled"]:
257
self.using_timer(False)
258
elif self.properties["ApprovalPending"]:
259
timeout = datetime.timedelta(milliseconds
262
last_approval_request = isoformat_to_datetime(
263
self.properties["LastApprovalRequest"])
264
if last_approval_request is not None:
265
timer = max(timeout - (datetime.datetime.utcnow()
266
- last_approval_request),
267
datetime.timedelta())
269
timer = datetime.timedelta()
270
if self.properties["ApprovedByDefault"]:
271
message = "Approval in {}. (d)eny?"
273
message = "Denial in {}. (a)pprove?"
274
message = message.format(str(timer).rsplit(".", 1)[0])
275
self.using_timer(True)
276
elif self.properties["LastCheckerStatus"] != 0:
277
# When checker has failed, show timer until client expires
278
expires = self.properties["Expires"]
280
timer = datetime.timedelta(0)
282
expires = (datetime.datetime.strptime
283
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
284
timer = max(expires - datetime.datetime.utcnow(),
285
datetime.timedelta())
286
message = ('A checker has failed! Time until client'
288
.format(str(timer).rsplit(".", 1)[0]))
289
self.using_timer(True)
292
self.using_timer(False)
293
self._text = "{}{}".format(base, message)
176
self._text = (u'%(name)s: %(enabled)s'
177
% { u"name": self.properties[u"name"],
180
if self.properties[u"enabled"]
295
182
if not urwid.supports_unicode():
296
183
self._text = self._text.encode("ascii", "replace")
297
textlist = [("normal", self._text)]
184
textlist = [(u"normal", self._text)]
298
185
self._text_widget.set_text(textlist)
299
186
self._focus_text_widget.set_text([(with_standout[text[0]],
308
195
if self.update_hook is not None:
309
196
self.update_hook()
311
def update_timer(self):
312
"""called by GObject. Will indefinitely loop until
313
GObject.source_remove() on tag is called"""
315
return True # Keep calling this
317
def delete(self, **kwargs):
318
if self._update_timer_callback_tag is not None:
319
GObject.source_remove(self._update_timer_callback_tag)
320
self._update_timer_callback_tag = None
321
for match in self.match_objects:
323
self.match_objects = ()
324
199
if self.delete_hook is not None:
325
200
self.delete_hook(self)
326
return super(MandosClientWidget, self).delete(**kwargs)
328
def render(self, maxcolrow, focus=False):
202
def render(self, (maxcol,), focus=False):
329
203
"""Render differently if we have focus.
330
204
This overrides the method from urwid.FlowWidget"""
331
return self.current_widget(focus).render(maxcolrow,
205
return self.current_widget(focus).render((maxcol,),
334
def keypress(self, maxcolrow, key):
208
def keypress(self, (maxcol,), key):
336
210
This overrides the method from urwid.FlowWidget"""
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply = True,
340
dbus_interface = dbus.PROPERTIES_IFACE)
342
self.proxy.Set(client_interface, "Enabled", False,
344
dbus_interface = dbus.PROPERTIES_IFACE)
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
347
dbus_interface = client_interface,
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
351
dbus_interface = client_interface,
353
elif key == "R" or key == "_" or key == "ctrl k":
211
if key == u"e" or key == u"+":
213
elif key == u"d" or key == u"-":
215
elif key == u"r" or key == u"_" or key == u"ctrl k":
354
216
self.server_proxy_object.RemoveClient(self.proxy
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply = True,
360
dbus_interface = dbus.PROPERTIES_IFACE)
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply = True,
364
dbus_interface = dbus.PROPERTIES_IFACE)
366
self.proxy.CheckedOK(dbus_interface = client_interface,
219
self.proxy.StartChecker()
221
self.proxy.StopChecker()
223
self.proxy.CheckedOK()
369
# elif key == "p" or key == "=":
225
# elif key == u"p" or key == "=":
370
226
# self.proxy.pause()
371
# elif key == "u" or key == ":":
227
# elif key == u"u" or key == ":":
372
228
# self.proxy.unpause()
229
# elif key == u"RET":
378
def properties_changed(self, interface, properties, invalidated):
379
"""Call self.update() if any properties changed.
234
def property_changed(self, property=None, value=None,
236
"""Call self.update() if old value is not new value.
380
237
This overrides the method from MandosClientPropertyCache"""
381
old_values = { key: self.properties.get(key)
382
for key in properties.keys() }
383
super(MandosClientWidget, self).properties_changed(
384
interface, properties, invalidated)
385
if any(old_values[key] != self.properties.get(key)
386
for key in old_values):
238
property_name = unicode(property)
239
old_value = self.properties.get(property_name)
240
super(MandosClientWidget, self).property_changed(
241
property=property, value=value, *args, **kwargs)
242
if self.properties.get(property_name) != old_value:
403
259
"""This is the entire user interface - the whole screen
404
260
with boxes, lists of client widgets, etc.
406
def __init__(self, max_log_length=1000, log_level=1):
262
def __init__(self, max_log_length=1000):
407
263
DBusGMainLoop(set_as_default=True)
409
265
self.screen = urwid.curses_display.Screen()
411
267
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", "bold,underline,blink"),
423
"bold,standout", "default", "bold,standout"),
424
("underline-blink-standout",
425
"underline,blink,standout", "default",
426
"underline,blink,standout"),
427
("bold-underline-blink-standout",
428
"bold,underline,blink,standout", "default",
429
"bold,underline,blink,standout"),
269
u"default", u"default", None),
271
u"default", u"default", u"bold"),
273
u"default", u"default", u"underline"),
275
u"default", u"default", u"standout"),
276
(u"bold-underline-blink",
277
u"default", u"default", (u"bold", u"underline")),
279
u"default", u"default", (u"bold", u"standout")),
280
(u"underline-blink-standout",
281
u"default", u"default", (u"underline", u"standout")),
282
(u"bold-underline-blink-standout",
283
u"default", u"default", (u"bold", u"underline",
432
287
if urwid.supports_unicode():
433
self.divider = "─" # \u2500
434
#self.divider = "━" # \u2501
288
self.divider = u"─" # \u2500
289
#self.divider = u"━" # \u2501
436
#self.divider = "-" # \u002d
437
self.divider = "_" # \u005f
291
#self.divider = u"-" # \u002d
292
self.divider = u"_" # \u005f
439
294
self.screen.start()
456
309
# This keeps track of whether self.uilist currently has
457
310
# self.logbox in it or not
458
311
self.log_visible = True
459
self.log_wrap = "any"
312
self.log_wrap = u"any"
462
self.log_message_raw(("bold",
463
"Mandos Monitor version " + version))
464
self.log_message_raw(("bold",
315
self.log_message_raw((u"bold",
316
u"Mandos Monitor version " + version))
317
self.log_message_raw((u"bold",
467
320
self.busname = domain + '.Mandos'
468
self.main_loop = GObject.MainLoop()
321
self.main_loop = gobject.MainLoop()
322
self.bus = dbus.SystemBus()
323
mandos_dbus_objc = self.bus.get_object(
324
self.busname, u"/", follow_name_owner_changes=True)
325
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
329
mandos_clients = (self.mandos_serv
330
.GetAllClientsWithProperties())
331
except dbus.exceptions.DBusException:
332
mandos_clients = dbus.Dictionary()
335
.connect_to_signal(u"ClientRemoved",
336
self.find_and_remove_client,
337
dbus_interface=server_interface,
340
.connect_to_signal(u"ClientAdded",
342
dbus_interface=server_interface,
345
.connect_to_signal(u"ClientNotFound",
346
self.client_not_found,
347
dbus_interface=server_interface,
349
for path, client in mandos_clients.iteritems():
350
client_proxy_object = self.bus.get_object(self.busname,
352
self.add_client(MandosClientWidget(server_proxy_object
355
=client_proxy_object,
470
365
def client_not_found(self, fingerprint, address):
471
self.log_message("Client with address {} and fingerprint {}"
472
" could not be found"
473
.format(address, fingerprint))
366
self.log_message((u"Client with address %s and fingerprint %s"
367
u" could not be found" % (address,
475
370
def rebuild(self):
476
371
"""This rebuilds the User Interface.
477
372
Call this when the widget layout needs to change"""
479
374
#self.uilist.append(urwid.ListBox(self.clients))
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
375
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
482
376
#header=urwid.Divider(),
485
urwid.Divider(div_char=
378
footer=urwid.Divider(div_char=self.divider)))
487
379
if self.log_visible:
488
380
self.uilist.append(self.logbox)
489
382
self.topwidget = urwid.Pile(self.uilist)
491
def log_message(self, message, level=1):
492
"""Log message formatted with timestamp"""
493
if level < self.log_level:
384
def log_message(self, message):
495
385
timestamp = datetime.datetime.now().isoformat()
496
self.log_message_raw("{}: {}".format(timestamp, message),
386
self.log_message_raw(timestamp + u": " + message)
499
def log_message_raw(self, markup, level=1):
388
def log_message_raw(self, markup):
500
389
"""Add a log message to the log buffer."""
501
if level < self.log_level:
503
390
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
504
391
if (self.max_log_length
505
392
and len(self.log) > self.max_log_length):
506
393
del self.log[0:len(self.log)-self.max_log_length-1]
507
394
self.logbox.set_focus(len(self.logbox.body.contents),
395
coming_from=u"above")
511
398
def toggle_log_display(self):
512
399
"""Toggle visibility of the log buffer."""
513
400
self.log_visible = not self.log_visible
515
self.log_message("Log visibility changed to: {}"
516
.format(self.log_visible), level=0)
402
self.log_message(u"Log visibility changed to: "
403
+ unicode(self.log_visible))
518
405
def change_log_display(self):
519
406
"""Change type of log display.
520
407
Currently, this toggles wrapping of text lines."""
521
if self.log_wrap == "clip":
522
self.log_wrap = "any"
408
if self.log_wrap == u"clip":
409
self.log_wrap = u"any"
524
self.log_wrap = "clip"
411
self.log_wrap = u"clip"
525
412
for textwidget in self.log:
526
413
textwidget.set_wrap_mode(self.log_wrap)
527
self.log_message("Wrap mode: {}".format(self.log_wrap),
414
self.log_message(u"Wrap mode: " + self.log_wrap)
530
def find_and_remove_client(self, path, interfaces):
531
"""Find a client by its object path and remove it.
416
def find_and_remove_client(self, path, name):
417
"""Find an client from its object path and remove it.
533
This is connected to the InterfacesRemoved signal from the
419
This is connected to the ClientRemoved signal from the
534
420
Mandos server object."""
535
if client_interface not in interfaces:
536
# Not a Mandos client object; ignore
539
422
client = self.clients_dict[path]
542
self.log_message("Unknown client {!r} removed"
426
self.remove_client(client, path)
547
def add_new_client(self, path, ifs_and_props):
548
"""Find a client by its object path and remove it.
550
This is connected to the InterfacesAdded signal from the
551
Mandos server object.
553
if client_interface not in ifs_and_props:
554
# Not a Mandos client object; ignore
428
def add_new_client(self, path):
556
429
client_proxy_object = self.bus.get_object(self.busname, path)
557
430
self.add_client(MandosClientWidget(server_proxy_object
558
431
=self.mandos_serv,
593
468
"""Start the main loop and exit when it's done."""
594
self.bus = dbus.SystemBus()
595
mandos_dbus_objc = self.bus.get_object(
596
self.busname, "/", follow_name_owner_changes=True)
597
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
601
mandos_clients = (self.mandos_serv
602
.GetAllClientsWithProperties())
603
if not mandos_clients:
604
self.log_message_raw(("bold", "Note: Server has no clients."))
605
except dbus.exceptions.DBusException:
606
self.log_message_raw(("bold", "Note: No Mandos server running."))
607
mandos_clients = dbus.Dictionary()
610
.connect_to_signal("InterfacesRemoved",
611
self.find_and_remove_client,
613
= dbus.OBJECT_MANAGER_IFACE,
616
.connect_to_signal("InterfacesAdded",
619
= dbus.OBJECT_MANAGER_IFACE,
622
.connect_to_signal("ClientNotFound",
623
self.client_not_found,
624
dbus_interface=server_interface,
626
for path, client in mandos_clients.items():
627
client_proxy_object = self.bus.get_object(self.busname,
629
self.add_client(MandosClientWidget(server_proxy_object
632
=client_proxy_object,
643
self._input_callback_tag = (GObject.io_add_watch
470
self._input_callback_tag = (gobject.io_add_watch
644
471
(sys.stdin.fileno(),
646
473
self.process_input))
647
474
self.main_loop.run()
648
475
# Main loop has finished, we should close everything now
649
GObject.source_remove(self._input_callback_tag)
476
gobject.source_remove(self._input_callback_tag)
650
477
self.screen.stop()
670
497
except KeyError: # :-)
673
if key == "q" or key == "Q":
500
if key == u"q" or key == u"Q":
676
elif key == "window resize":
503
elif key == u"window resize":
677
504
self.size = self.screen.get_cols_rows()
679
elif key == "ctrl l":
506
elif key == u"\f": # Ctrl-L
682
elif key == "l" or key == "D":
508
elif key == u"l" or key == u"D":
683
509
self.toggle_log_display()
685
elif key == "w" or key == "i":
511
elif key == u"w" or key == u"i":
686
512
self.change_log_display()
688
elif key == "?" or key == "f1" or key == "esc":
514
elif key == u"?" or key == u"f1" or key == u"esc":
689
515
if not self.log_visible:
690
516
self.log_visible = True
692
self.log_message_raw(("bold",
696
"l: Log window toggle",
697
"TAB: Switch window",
698
"w: Wrap (log lines)",
699
"v: Toggle verbose log",
701
self.log_message_raw(("bold",
707
"s: Start new checker",
518
self.log_message_raw((u"bold",
522
u"l: Log window toggle",
523
u"TAB: Switch window",
525
self.log_message_raw((u"bold",
531
u"s: Start new checker",
714
536
if self.topwidget.get_focus() is self.logbox:
715
537
self.topwidget.set_focus(0)
717
539
self.topwidget.set_focus(self.logbox)
720
if self.log_level == 0:
722
self.log_message("Verbose mode: Off")
725
self.log_message("Verbose mode: On")
726
#elif (key == "end" or key == "meta >" or key == "G"
541
#elif (key == u"end" or key == u"meta >" or key == u"G"
728
543
# pass # xxx end-of-buffer
729
#elif (key == "home" or key == "meta <" or key == "g"
544
#elif (key == u"home" or key == u"meta <" or key == u"g"
731
546
# pass # xxx beginning-of-buffer
732
#elif key == "ctrl e" or key == "$":
547
#elif key == u"ctrl e" or key == u"$":
733
548
# pass # xxx move-end-of-line
734
#elif key == "ctrl a" or key == "^":
549
#elif key == u"ctrl a" or key == u"^":
735
550
# pass # xxx move-beginning-of-line
736
#elif key == "ctrl b" or key == "meta (" or key == "h":
551
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
737
552
# pass # xxx left
738
#elif key == "ctrl f" or key == "meta )" or key == "l":
553
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
739
554
# pass # xxx right
741
556
# pass # scroll up log
743
558
# pass # scroll down log
744
559
elif self.topwidget.selectable():
745
560
self.topwidget.keypress(self.size, key)