/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos-monitor

  • Committer: Teddy Hogeborn
  • Date: 2016-03-19 12:10:15 UTC
  • Revision ID: teddy@recompile.se-20160319121015-ywrw6qx3srtj2dix
Server: Debian package bug fix: Include /usr/lib/tmpfiles.d dir

The Debian package for the server needs the /usr/lib/tmpfiles.d
directory in its .dirs file in order for the directory to exist when
the Makefile "install-server" rule is run, otherwise the
tmpfiles.d-mandos.conf file will not be installed.

* debian/mandos.dirs (usr/lib/tmpfiles.d): Added.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
 
#
 
3
# 
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
 
#
6
 
# Copyright © 2009-2017 Teddy Hogeborn
7
 
# Copyright © 2009-2017 Björn Påhlsson
8
 
#
 
5
# 
 
6
# Copyright © 2009-2016 Teddy Hogeborn
 
7
# Copyright © 2009-2016 Björn Påhlsson
 
8
# 
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
11
11
# the Free Software Foundation, either version 3 of the License, or
15
15
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
16
16
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
17
#     GNU General Public License for more details.
18
 
#
 
18
# 
19
19
# You should have received a copy of the GNU General Public License
20
20
# along with this program.  If not, see
21
21
# <http://www.gnu.org/licenses/>.
22
 
#
 
22
# 
23
23
# Contact the authors at <mandos@recompile.se>.
24
 
#
 
24
# 
25
25
 
26
26
from __future__ import (division, absolute_import, print_function,
27
27
                        unicode_literals)
45
45
 
46
46
import locale
47
47
 
48
 
import logging
49
 
 
50
48
if sys.version_info.major == 2:
51
49
    str = unicode
52
50
 
53
51
locale.setlocale(locale.LC_ALL, '')
54
52
 
 
53
import logging
55
54
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
56
55
 
57
56
# Some useful constants
58
57
domain = 'se.recompile'
59
58
server_interface = domain + '.Mandos'
60
59
client_interface = domain + '.Mandos.Client'
61
 
version = "1.7.15"
 
60
version = "1.7.6"
62
61
 
63
62
try:
64
63
    dbus.OBJECT_MANAGER_IFACE
65
64
except AttributeError:
66
65
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
67
66
 
68
 
 
69
67
def isoformat_to_datetime(iso):
70
68
    "Parse an ISO 8601 date string to a datetime.datetime()"
71
69
    if not iso:
79
77
                             int(day),
80
78
                             int(hour),
81
79
                             int(minute),
82
 
                             int(second),            # Whole seconds
83
 
                             int(fraction*1000000))  # Microseconds
84
 
 
 
80
                             int(second),           # Whole seconds
 
81
                             int(fraction*1000000)) # Microseconds
85
82
 
86
83
class MandosClientPropertyCache(object):
87
84
    """This wraps a Mandos Client D-Bus proxy object, caches the
89
86
    changed.
90
87
    """
91
88
    def __init__(self, proxy_object=None, properties=None, **kwargs):
92
 
        self.proxy = proxy_object  # Mandos Client proxy object
 
89
        self.proxy = proxy_object # Mandos Client proxy object
93
90
        self.properties = dict() if properties is None else properties
94
91
        self.property_changed_match = (
95
92
            self.proxy.connect_to_signal("PropertiesChanged",
96
93
                                         self.properties_changed,
97
94
                                         dbus.PROPERTIES_IFACE,
98
95
                                         byte_arrays=True))
99
 
 
 
96
        
100
97
        if properties is None:
101
 
            self.properties.update(self.proxy.GetAll(
102
 
                client_interface,
103
 
                dbus_interface=dbus.PROPERTIES_IFACE))
104
 
 
 
98
            self.properties.update(
 
99
                self.proxy.GetAll(client_interface,
 
100
                                  dbus_interface
 
101
                                  = dbus.PROPERTIES_IFACE))
 
102
        
105
103
        super(MandosClientPropertyCache, self).__init__(**kwargs)
106
 
 
 
104
    
107
105
    def properties_changed(self, interface, properties, invalidated):
108
106
        """This is called whenever we get a PropertiesChanged signal
109
107
        It updates the changed properties in the "properties" dict.
111
109
        # Update properties dict with new value
112
110
        if interface == client_interface:
113
111
            self.properties.update(properties)
114
 
 
 
112
    
115
113
    def delete(self):
116
114
        self.property_changed_match.remove()
117
115
 
119
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
120
118
    """A Mandos Client which is visible on the screen.
121
119
    """
122
 
 
 
120
    
123
121
    def __init__(self, server_proxy_object=None, update_hook=None,
124
122
                 delete_hook=None, logger=None, **kwargs):
125
123
        # Called on update
130
128
        self.server_proxy_object = server_proxy_object
131
129
        # Logger
132
130
        self.logger = logger
133
 
 
 
131
        
134
132
        self._update_timer_callback_tag = None
135
 
 
 
133
        
136
134
        # The widget shown normally
137
135
        self._text_widget = urwid.Text("")
138
136
        # The widget shown when we have focus
140
138
        super(MandosClientWidget, self).__init__(**kwargs)
141
139
        self.update()
142
140
        self.opened = False
143
 
 
 
141
        
144
142
        self.match_objects = (
145
143
            self.proxy.connect_to_signal("CheckerCompleted",
146
144
                                         self.checker_completed,
164
162
                                         byte_arrays=True))
165
163
        self.logger('Created client {}'
166
164
                    .format(self.properties["Name"]), level=0)
167
 
 
 
165
    
168
166
    def using_timer(self, flag):
169
167
        """Call this method with True or False when timer should be
170
168
        activated or deactivated.
177
175
        elif not (flag or self._update_timer_callback_tag is None):
178
176
            GLib.source_remove(self._update_timer_callback_tag)
179
177
            self._update_timer_callback_tag = None
180
 
 
 
178
    
181
179
    def checker_completed(self, exitstatus, condition, command):
182
180
        if exitstatus == 0:
183
181
            self.logger('Checker for client {} (command "{}")'
197
195
                        .format(self.properties["Name"], command,
198
196
                                os.WTERMSIG(condition)))
199
197
        self.update()
200
 
 
 
198
    
201
199
    def checker_started(self, command):
202
200
        """Server signals that a checker started."""
203
201
        self.logger('Client {} started checker "{}"'
204
202
                    .format(self.properties["Name"],
205
203
                            command), level=0)
206
 
 
 
204
    
207
205
    def got_secret(self):
208
206
        self.logger('Client {} received its secret'
209
207
                    .format(self.properties["Name"]))
210
 
 
 
208
    
211
209
    def need_approval(self, timeout, default):
212
210
        if not default:
213
211
            message = 'Client {} needs approval within {} seconds'
215
213
            message = 'Client {} will get its secret in {} seconds'
216
214
        self.logger(message.format(self.properties["Name"],
217
215
                                   timeout/1000))
218
 
 
 
216
    
219
217
    def rejected(self, reason):
220
218
        self.logger('Client {} was rejected; reason: {}'
221
219
                    .format(self.properties["Name"], reason))
222
 
 
 
220
    
223
221
    def selectable(self):
224
222
        """Make this a "selectable" widget.
225
223
        This overrides the method from urwid.FlowWidget."""
226
224
        return True
227
 
 
 
225
    
228
226
    def rows(self, maxcolrow, focus=False):
229
227
        """How many rows this widget will occupy might depend on
230
228
        whether we have focus or not.
231
229
        This overrides the method from urwid.FlowWidget"""
232
230
        return self.current_widget(focus).rows(maxcolrow, focus=focus)
233
 
 
 
231
    
234
232
    def current_widget(self, focus=False):
235
233
        if focus or self.opened:
236
234
            return self._focus_widget
237
235
        return self._widget
238
 
 
 
236
    
239
237
    def update(self):
240
238
        "Called when what is visible on the screen should be updated."
241
239
        # How to add standout mode to a style
242
 
        with_standout = {"normal": "standout",
243
 
                         "bold": "bold-standout",
244
 
                         "underline-blink":
245
 
                         "underline-blink-standout",
246
 
                         "bold-underline-blink":
247
 
                         "bold-underline-blink-standout",
248
 
                         }
249
 
 
 
240
        with_standout = { "normal": "standout",
 
241
                          "bold": "bold-standout",
 
242
                          "underline-blink":
 
243
                              "underline-blink-standout",
 
244
                          "bold-underline-blink":
 
245
                              "bold-underline-blink-standout",
 
246
                          }
 
247
        
250
248
        # Rebuild focus and non-focus widgets using current properties
251
 
 
 
249
        
252
250
        # Base part of a client. Name!
253
251
        base = '{name}: '.format(name=self.properties["Name"])
254
252
        if not self.properties["Enabled"]:
255
253
            message = "DISABLED"
256
254
            self.using_timer(False)
257
255
        elif self.properties["ApprovalPending"]:
258
 
            timeout = datetime.timedelta(
259
 
                milliseconds=self.properties["ApprovalDelay"])
 
256
            timeout = datetime.timedelta(milliseconds
 
257
                                         = self.properties
 
258
                                         ["ApprovalDelay"])
260
259
            last_approval_request = isoformat_to_datetime(
261
260
                self.properties["LastApprovalRequest"])
262
261
            if last_approval_request is not None:
289
288
            message = "enabled"
290
289
            self.using_timer(False)
291
290
        self._text = "{}{}".format(base, message)
292
 
 
 
291
        
293
292
        if not urwid.supports_unicode():
294
293
            self._text = self._text.encode("ascii", "replace")
295
294
        textlist = [("normal", self._text)]
305
304
        # Run update hook, if any
306
305
        if self.update_hook is not None:
307
306
            self.update_hook()
308
 
 
 
307
    
309
308
    def update_timer(self):
310
309
        """called by GLib. Will indefinitely loop until
311
310
        GLib.source_remove() on tag is called
312
311
        """
313
312
        self.update()
314
313
        return True             # Keep calling this
315
 
 
 
314
    
316
315
    def delete(self, **kwargs):
317
316
        if self._update_timer_callback_tag is not None:
318
317
            GLib.source_remove(self._update_timer_callback_tag)
323
322
        if self.delete_hook is not None:
324
323
            self.delete_hook(self)
325
324
        return super(MandosClientWidget, self).delete(**kwargs)
326
 
 
 
325
    
327
326
    def render(self, maxcolrow, focus=False):
328
327
        """Render differently if we have focus.
329
328
        This overrides the method from urwid.FlowWidget"""
330
329
        return self.current_widget(focus).render(maxcolrow,
331
330
                                                 focus=focus)
332
 
 
 
331
    
333
332
    def keypress(self, maxcolrow, key):
334
333
        """Handle keys.
335
334
        This overrides the method from urwid.FlowWidget"""
336
335
        if key == "+":
337
336
            self.proxy.Set(client_interface, "Enabled",
338
 
                           dbus.Boolean(True), ignore_reply=True,
339
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
337
                           dbus.Boolean(True), ignore_reply = True,
 
338
                           dbus_interface = dbus.PROPERTIES_IFACE)
340
339
        elif key == "-":
341
340
            self.proxy.Set(client_interface, "Enabled", False,
342
 
                           ignore_reply=True,
343
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
341
                           ignore_reply = True,
 
342
                           dbus_interface = dbus.PROPERTIES_IFACE)
344
343
        elif key == "a":
345
344
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
346
 
                               dbus_interface=client_interface,
 
345
                               dbus_interface = client_interface,
347
346
                               ignore_reply=True)
348
347
        elif key == "d":
349
348
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
350
 
                               dbus_interface=client_interface,
 
349
                                  dbus_interface = client_interface,
351
350
                               ignore_reply=True)
352
351
        elif key == "R" or key == "_" or key == "ctrl k":
353
352
            self.server_proxy_object.RemoveClient(self.proxy
355
354
                                                  ignore_reply=True)
356
355
        elif key == "s":
357
356
            self.proxy.Set(client_interface, "CheckerRunning",
358
 
                           dbus.Boolean(True), ignore_reply=True,
359
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
357
                           dbus.Boolean(True), ignore_reply = True,
 
358
                           dbus_interface = dbus.PROPERTIES_IFACE)
360
359
        elif key == "S":
361
360
            self.proxy.Set(client_interface, "CheckerRunning",
362
 
                           dbus.Boolean(False), ignore_reply=True,
363
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
361
                           dbus.Boolean(False), ignore_reply = True,
 
362
                           dbus_interface = dbus.PROPERTIES_IFACE)
364
363
        elif key == "C":
365
 
            self.proxy.CheckedOK(dbus_interface=client_interface,
 
364
            self.proxy.CheckedOK(dbus_interface = client_interface,
366
365
                                 ignore_reply=True)
367
366
        # xxx
368
367
#         elif key == "p" or key == "=":
373
372
#             self.open()
374
373
        else:
375
374
            return key
376
 
 
 
375
    
377
376
    def properties_changed(self, interface, properties, invalidated):
378
377
        """Call self.update() if any properties changed.
379
378
        This overrides the method from MandosClientPropertyCache"""
380
 
        old_values = {key: self.properties.get(key)
381
 
                      for key in properties.keys()}
 
379
        old_values = { key: self.properties.get(key)
 
380
                       for key in properties.keys() }
382
381
        super(MandosClientWidget, self).properties_changed(
383
382
            interface, properties, invalidated)
384
383
        if any(old_values[key] != self.properties.get(key)
392
391
    use them as an excuse to shift focus away from this widget.
393
392
    """
394
393
    def keypress(self, *args, **kwargs):
395
 
        ret = (super(ConstrainedListBox, self)
396
 
               .keypress(*args, **kwargs))
 
394
        ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
397
395
        if ret in ("up", "down"):
398
396
            return
399
397
        return ret
405
403
    """
406
404
    def __init__(self, max_log_length=1000, log_level=1):
407
405
        DBusGMainLoop(set_as_default=True)
408
 
 
 
406
        
409
407
        self.screen = urwid.curses_display.Screen()
410
 
 
 
408
        
411
409
        self.screen.register_palette((
412
410
                ("normal",
413
411
                 "default", "default", None),
418
416
                ("standout",
419
417
                 "standout", "default", "standout"),
420
418
                ("bold-underline-blink",
421
 
                 "bold,underline,blink", "default",
422
 
                 "bold,underline,blink"),
 
419
                 "bold,underline,blink", "default", "bold,underline,blink"),
423
420
                ("bold-standout",
424
421
                 "bold,standout", "default", "bold,standout"),
425
422
                ("underline-blink-standout",
429
426
                 "bold,underline,blink,standout", "default",
430
427
                 "bold,underline,blink,standout"),
431
428
                ))
432
 
 
 
429
        
433
430
        if urwid.supports_unicode():
434
 
            self.divider = "─"  # \u2500
 
431
            self.divider = "─" # \u2500
 
432
            #self.divider = "━" # \u2501
435
433
        else:
436
 
            self.divider = "_"  # \u005f
437
 
 
 
434
            #self.divider = "-" # \u002d
 
435
            self.divider = "_" # \u005f
 
436
        
438
437
        self.screen.start()
439
 
 
 
438
        
440
439
        self.size = self.screen.get_cols_rows()
441
 
 
 
440
        
442
441
        self.clients = urwid.SimpleListWalker([])
443
442
        self.clients_dict = {}
444
 
 
 
443
        
445
444
        # We will add Text widgets to this list
446
445
        self.log = []
447
446
        self.max_log_length = max_log_length
448
 
 
 
447
        
449
448
        self.log_level = log_level
450
 
 
 
449
        
451
450
        # We keep a reference to the log widget so we can remove it
452
451
        # from the ListWalker without it getting destroyed
453
452
        self.logbox = ConstrainedListBox(self.log)
454
 
 
 
453
        
455
454
        # This keeps track of whether self.uilist currently has
456
455
        # self.logbox in it or not
457
456
        self.log_visible = True
458
457
        self.log_wrap = "any"
459
 
 
 
458
        
460
459
        self.rebuild()
461
460
        self.log_message_raw(("bold",
462
461
                              "Mandos Monitor version " + version))
463
462
        self.log_message_raw(("bold",
464
463
                              "q: Quit  ?: Help"))
465
 
 
 
464
        
466
465
        self.busname = domain + '.Mandos'
467
466
        self.main_loop = GLib.MainLoop()
468
 
 
 
467
    
469
468
    def client_not_found(self, fingerprint, address):
470
469
        self.log_message("Client with address {} and fingerprint {}"
471
470
                         " could not be found"
472
471
                         .format(address, fingerprint))
473
 
 
 
472
    
474
473
    def rebuild(self):
475
474
        """This rebuilds the User Interface.
476
475
        Call this when the widget layout needs to change"""
477
476
        self.uilist = []
478
 
        # self.uilist.append(urwid.ListBox(self.clients))
 
477
        #self.uilist.append(urwid.ListBox(self.clients))
479
478
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.
480
479
                                                          clients),
481
 
                                       # header=urwid.Divider(),
 
480
                                       #header=urwid.Divider(),
482
481
                                       header=None,
483
 
                                       footer=urwid.Divider(
484
 
                                           div_char=self.divider)))
 
482
                                       footer=
 
483
                                       urwid.Divider(div_char=
 
484
                                                     self.divider)))
485
485
        if self.log_visible:
486
486
            self.uilist.append(self.logbox)
487
487
        self.topwidget = urwid.Pile(self.uilist)
488
 
 
 
488
    
489
489
    def log_message(self, message, level=1):
490
490
        """Log message formatted with timestamp"""
491
491
        if level < self.log_level:
493
493
        timestamp = datetime.datetime.now().isoformat()
494
494
        self.log_message_raw("{}: {}".format(timestamp, message),
495
495
                             level=level)
496
 
 
 
496
    
497
497
    def log_message_raw(self, markup, level=1):
498
498
        """Add a log message to the log buffer."""
499
499
        if level < self.log_level:
500
500
            return
501
501
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
502
 
        if self.max_log_length:
503
 
            if len(self.log) > self.max_log_length:
504
 
                del self.log[0:len(self.log)-self.max_log_length-1]
 
502
        if (self.max_log_length
 
503
            and len(self.log) > self.max_log_length):
 
504
            del self.log[0:len(self.log)-self.max_log_length-1]
505
505
        self.logbox.set_focus(len(self.logbox.body.contents),
506
506
                              coming_from="above")
507
507
        self.refresh()
508
 
 
 
508
    
509
509
    def toggle_log_display(self):
510
510
        """Toggle visibility of the log buffer."""
511
511
        self.log_visible = not self.log_visible
512
512
        self.rebuild()
513
513
        self.log_message("Log visibility changed to: {}"
514
514
                         .format(self.log_visible), level=0)
515
 
 
 
515
    
516
516
    def change_log_display(self):
517
517
        """Change type of log display.
518
518
        Currently, this toggles wrapping of text lines."""
524
524
            textwidget.set_wrap_mode(self.log_wrap)
525
525
        self.log_message("Wrap mode: {}".format(self.log_wrap),
526
526
                         level=0)
527
 
 
 
527
    
528
528
    def find_and_remove_client(self, path, interfaces):
529
529
        """Find a client by its object path and remove it.
530
 
 
 
530
        
531
531
        This is connected to the InterfacesRemoved signal from the
532
532
        Mandos server object."""
533
533
        if client_interface not in interfaces:
541
541
                             .format(path))
542
542
            return
543
543
        client.delete()
544
 
 
 
544
    
545
545
    def add_new_client(self, path, ifs_and_props):
546
546
        """Find a client by its object path and remove it.
547
 
 
 
547
        
548
548
        This is connected to the InterfacesAdded signal from the
549
549
        Mandos server object.
550
550
        """
552
552
            # Not a Mandos client object; ignore
553
553
            return
554
554
        client_proxy_object = self.bus.get_object(self.busname, path)
555
 
        self.add_client(MandosClientWidget(
556
 
            server_proxy_object=self.mandos_serv,
557
 
            proxy_object=client_proxy_object,
558
 
            update_hook=self.refresh,
559
 
            delete_hook=self.remove_client,
560
 
            logger=self.log_message,
561
 
            properties=dict(ifs_and_props[client_interface])),
 
555
        self.add_client(MandosClientWidget(server_proxy_object
 
556
                                           =self.mandos_serv,
 
557
                                           proxy_object
 
558
                                           =client_proxy_object,
 
559
                                           update_hook
 
560
                                           =self.refresh,
 
561
                                           delete_hook
 
562
                                           =self.remove_client,
 
563
                                           logger
 
564
                                           =self.log_message,
 
565
                                           properties
 
566
                                           = dict(ifs_and_props[
 
567
                                               client_interface])),
562
568
                        path=path)
563
 
 
 
569
    
564
570
    def add_client(self, client, path=None):
565
571
        self.clients.append(client)
566
572
        if path is None:
568
574
        self.clients_dict[path] = client
569
575
        self.clients.sort(key=lambda c: c.properties["Name"])
570
576
        self.refresh()
571
 
 
 
577
    
572
578
    def remove_client(self, client, path=None):
573
579
        self.clients.remove(client)
574
580
        if path is None:
575
581
            path = client.proxy.object_path
576
582
        del self.clients_dict[path]
577
583
        self.refresh()
578
 
 
 
584
    
579
585
    def refresh(self):
580
586
        """Redraw the screen"""
581
587
        canvas = self.topwidget.render(self.size, focus=True)
582
588
        self.screen.draw_screen(self.size, canvas)
583
 
 
 
589
    
584
590
    def run(self):
585
591
        """Start the main loop and exit when it's done."""
586
592
        self.bus = dbus.SystemBus()
587
593
        mandos_dbus_objc = self.bus.get_object(
588
594
            self.busname, "/", follow_name_owner_changes=True)
589
 
        self.mandos_serv = dbus.Interface(
590
 
            mandos_dbus_objc, dbus_interface=server_interface)
 
595
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
596
                                          dbus_interface
 
597
                                          = server_interface)
591
598
        try:
592
599
            mandos_clients = (self.mandos_serv
593
600
                              .GetAllClientsWithProperties())
594
601
            if not mandos_clients:
595
 
                self.log_message_raw(("bold",
596
 
                                      "Note: Server has no clients."))
 
602
                self.log_message_raw(("bold", "Note: Server has no clients."))
597
603
        except dbus.exceptions.DBusException:
598
 
            self.log_message_raw(("bold",
599
 
                                  "Note: No Mandos server running."))
 
604
            self.log_message_raw(("bold", "Note: No Mandos server running."))
600
605
            mandos_clients = dbus.Dictionary()
601
 
 
 
606
        
602
607
        (self.mandos_serv
603
608
         .connect_to_signal("InterfacesRemoved",
604
609
                            self.find_and_remove_client,
605
 
                            dbus_interface=dbus.OBJECT_MANAGER_IFACE,
 
610
                            dbus_interface
 
611
                            = dbus.OBJECT_MANAGER_IFACE,
606
612
                            byte_arrays=True))
607
613
        (self.mandos_serv
608
614
         .connect_to_signal("InterfacesAdded",
609
615
                            self.add_new_client,
610
 
                            dbus_interface=dbus.OBJECT_MANAGER_IFACE,
 
616
                            dbus_interface
 
617
                            = dbus.OBJECT_MANAGER_IFACE,
611
618
                            byte_arrays=True))
612
619
        (self.mandos_serv
613
620
         .connect_to_signal("ClientNotFound",
617
624
        for path, client in mandos_clients.items():
618
625
            client_proxy_object = self.bus.get_object(self.busname,
619
626
                                                      path)
620
 
            self.add_client(MandosClientWidget(
621
 
                server_proxy_object=self.mandos_serv,
622
 
                proxy_object=client_proxy_object,
623
 
                properties=client,
624
 
                update_hook=self.refresh,
625
 
                delete_hook=self.remove_client,
626
 
                logger=self.log_message),
 
627
            self.add_client(MandosClientWidget(server_proxy_object
 
628
                                               =self.mandos_serv,
 
629
                                               proxy_object
 
630
                                               =client_proxy_object,
 
631
                                               properties=client,
 
632
                                               update_hook
 
633
                                               =self.refresh,
 
634
                                               delete_hook
 
635
                                               =self.remove_client,
 
636
                                               logger
 
637
                                               =self.log_message),
627
638
                            path=path)
628
 
 
 
639
        
629
640
        self.refresh()
630
641
        self._input_callback_tag = (GLib.io_add_watch
631
642
                                    (sys.stdin.fileno(),
635
646
        # Main loop has finished, we should close everything now
636
647
        GLib.source_remove(self._input_callback_tag)
637
648
        self.screen.stop()
638
 
 
 
649
    
639
650
    def stop(self):
640
651
        self.main_loop.quit()
641
 
 
 
652
    
642
653
    def process_input(self, source, condition):
643
654
        keys = self.screen.get_input()
644
 
        translations = {"ctrl n": "down",       # Emacs
645
 
                        "ctrl p": "up",         # Emacs
646
 
                        "ctrl v": "page down",  # Emacs
647
 
                        "meta v": "page up",    # Emacs
648
 
                        " ": "page down",       # less
649
 
                        "f": "page down",       # less
650
 
                        "b": "page up",         # less
651
 
                        "j": "down",            # vi
652
 
                        "k": "up",              # vi
653
 
                        }
 
655
        translations = { "ctrl n": "down",      # Emacs
 
656
                         "ctrl p": "up",        # Emacs
 
657
                         "ctrl v": "page down", # Emacs
 
658
                         "meta v": "page up",   # Emacs
 
659
                         " ": "page down",      # less
 
660
                         "f": "page down",      # less
 
661
                         "b": "page up",        # less
 
662
                         "j": "down",           # vi
 
663
                         "k": "up",             # vi
 
664
                         }
654
665
        for key in keys:
655
666
            try:
656
667
                key = translations[key]
657
668
            except KeyError:    # :-)
658
669
                pass
659
 
 
 
670
            
660
671
            if key == "q" or key == "Q":
661
672
                self.stop()
662
673
                break
710
721
                else:
711
722
                    self.log_level = 0
712
723
                    self.log_message("Verbose mode: On")
713
 
            # elif (key == "end" or key == "meta >" or key == "G"
714
 
            #       or key == ">"):
715
 
            #     pass            # xxx end-of-buffer
716
 
            # elif (key == "home" or key == "meta <" or key == "g"
717
 
            #       or key == "<"):
718
 
            #     pass            # xxx beginning-of-buffer
719
 
            # elif key == "ctrl e" or key == "$":
720
 
            #     pass            # xxx move-end-of-line
721
 
            # elif key == "ctrl a" or key == "^":
722
 
            #     pass            # xxx move-beginning-of-line
723
 
            # elif key == "ctrl b" or key == "meta (" or key == "h":
724
 
            #     pass            # xxx left
725
 
            # elif key == "ctrl f" or key == "meta )" or key == "l":
726
 
            #     pass            # xxx right
727
 
            # elif key == "a":
728
 
            #     pass            # scroll up log
729
 
            # elif key == "z":
730
 
            #     pass            # scroll down log
 
724
            #elif (key == "end" or key == "meta >" or key == "G"
 
725
            #      or key == ">"):
 
726
            #    pass            # xxx end-of-buffer
 
727
            #elif (key == "home" or key == "meta <" or key == "g"
 
728
            #      or key == "<"):
 
729
            #    pass            # xxx beginning-of-buffer
 
730
            #elif key == "ctrl e" or key == "$":
 
731
            #    pass            # xxx move-end-of-line
 
732
            #elif key == "ctrl a" or key == "^":
 
733
            #    pass            # xxx move-beginning-of-line
 
734
            #elif key == "ctrl b" or key == "meta (" or key == "h":
 
735
            #    pass            # xxx left
 
736
            #elif key == "ctrl f" or key == "meta )" or key == "l":
 
737
            #    pass            # xxx right
 
738
            #elif key == "a":
 
739
            #    pass            # scroll up log
 
740
            #elif key == "z":
 
741
            #    pass            # scroll down log
731
742
            elif self.topwidget.selectable():
732
743
                self.topwidget.keypress(self.size, key)
733
744
                self.refresh()
734
745
        return True
735
746
 
736
 
 
737
747
ui = UserInterface()
738
748
try:
739
749
    ui.run()