/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos-monitor

  • Committer: Teddy Hogeborn
  • Date: 2008-08-03 01:09:36 UTC
  • mfrom: (24.1.9 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20080803010936-ujme8tgxceszfbi1
* plugbasedclient.c (main): New "--userid" and "--groupid" options.
                            Take an additional non-option argument and
                            parse it as a plus-separated and -prefixed
                            list of additional options.

* plugins.d/mandosclient.c (DH_BITS): Replaced with
                                      "mandos_context.dh_bits".  All
                                      users changed.
  (certdir): Renamed to "keydir".  All users changed.
  (certfile): Renamed to "pubkeyfile".  All users changed.
  (certkey): Renamed to "seckeyfile".  All users changed.
  (encrypted_session): Replaced with "mandos_context".  All users
                       changed.
  (initgnutls): Take additional "session" and "dh_params" arguments.
                All callers changed.
  (start_mandos_communication): Take additional "mc" argument.  All
                                callers changed.  Print target IPv6
                                address if different than supplied
                                string.
  (simple_poll) Replaced with "mandos_context.simple_poll".  All users
                changed.
  (server): Replaced with "mandos_context.server".  All users changed.
  (main): Default interface to "eth0".  Rename "--certdir" to
          "--keydir", "--certkey" to "--seckey", and "--certfile" to
          "--pubkey".  New options "--dh-bits" and "--priority".  If
          the interface is not up, bring it up.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
1
 
#!/usr/bin/python
2
 
# -*- mode: python; coding: utf-8 -*-
3
 
 
4
 
from __future__ import division, absolute_import, with_statement
5
 
 
6
 
import sys
7
 
import signal
8
 
 
9
 
import urwid.curses_display
10
 
import urwid
11
 
 
12
 
from dbus.mainloop.glib import DBusGMainLoop
13
 
import gobject
14
 
 
15
 
import dbus
16
 
 
17
 
import UserList
18
 
 
19
 
# Some useful constants
20
 
domain = 'se.bsnet.fukt'
21
 
server_interface = domain + '.Mandos'
22
 
client_interface = domain + '.Mandos.Client'
23
 
version = "1.0.14"
24
 
 
25
 
# Always run in monochrome mode
26
 
urwid.curses_display.curses.has_colors = lambda : False
27
 
 
28
 
# Urwid doesn't support blinking, but we want it.  Since we have no
29
 
# use for underline on its own, we make underline also always blink.
30
 
urwid.curses_display.curses.A_UNDERLINE |= (
31
 
    urwid.curses_display.curses.A_BLINK)
32
 
 
33
 
class MandosClientPropertyCache(object):
34
 
    """This wraps a Mandos Client D-Bus proxy object, caches the
35
 
    properties and calls a hook function when any of them are
36
 
    changed.
37
 
    """
38
 
    def __init__(self, proxy_object=None, properties=None, *args,
39
 
                 **kwargs):
40
 
        self.proxy = proxy_object # Mandos Client proxy object
41
 
        
42
 
        if properties is None:
43
 
            self.properties = dict()
44
 
        else:
45
 
            self.properties = properties
46
 
        self.proxy.connect_to_signal("PropertyChanged",
47
 
                                     self.property_changed,
48
 
                                     client_interface,
49
 
                                     byte_arrays=True)
50
 
        
51
 
        if properties is None:
52
 
            self.properties.update(self.proxy.GetAll(client_interface,
53
 
                                                     dbus_interface =
54
 
                                                     dbus.PROPERTIES_IFACE))
55
 
        super(MandosClientPropertyCache, self).__init__(
56
 
            proxy_object=proxy_object,
57
 
            properties=properties, *args, **kwargs)
58
 
    
59
 
    def property_changed(self, property=None, value=None):
60
 
        """This is called whenever we get a PropertyChanged signal
61
 
        It updates the changed property in the "properties" dict.
62
 
        """
63
 
        # Update properties dict with new value
64
 
        self.properties[property] = value
65
 
 
66
 
 
67
 
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
68
 
    """A Mandos Client which is visible on the screen.
69
 
    """
70
 
    
71
 
    def __init__(self, server_proxy_object=None, update_hook=None,
72
 
                 delete_hook=None, *args, **kwargs):
73
 
        # Called on update
74
 
        self.update_hook = update_hook
75
 
        # Called on delete
76
 
        self.delete_hook = delete_hook
77
 
        # Mandos Server proxy object
78
 
        self.server_proxy_object = server_proxy_object
79
 
        
80
 
        # The widget shown normally
81
 
        self._text_widget = urwid.Text("")
82
 
        # The widget shown when we have focus
83
 
        self._focus_text_widget = urwid.Text("")
84
 
        super(MandosClientWidget, self).__init__(
85
 
            update_hook=update_hook, delete_hook=delete_hook,
86
 
            *args, **kwargs)
87
 
        self.update()
88
 
        self.opened = False
89
 
    
90
 
    def selectable(self):
91
 
        """Make this a "selectable" widget.
92
 
        This overrides the method from urwid.FlowWidget."""
93
 
        return True
94
 
    
95
 
    def rows(self, (maxcol,), focus=False):
96
 
        """How many rows this widget will occupy might depend on
97
 
        whether we have focus or not.
98
 
        This overrides the method from urwid.FlowWidget"""
99
 
        return self.current_widget(focus).rows((maxcol,), focus=focus)
100
 
    
101
 
    def current_widget(self, focus=False):
102
 
        if focus or self.opened:
103
 
            return self._focus_widget
104
 
        return self._widget
105
 
    
106
 
    def update(self):
107
 
        "Called when what is visible on the screen should be updated."
108
 
        # How to add standout mode to a style
109
 
        with_standout = { u"normal": u"standout",
110
 
                          u"bold": u"bold-standout",
111
 
                          u"underline-blink":
112
 
                              u"underline-blink-standout",
113
 
                          u"bold-underline-blink":
114
 
                              u"bold-underline-blink-standout",
115
 
                          }
116
 
        
117
 
        # Rebuild focus and non-focus widgets using current properties
118
 
        self._text = (u'name="%(name)s", enabled=%(enabled)s'
119
 
                      % self.properties)
120
 
        if not urwid.supports_unicode():
121
 
            self._text = self._text.encode("ascii", "replace")
122
 
        textlist = [(u"normal", u"BLARGH: "), (u"bold", self._text)]
123
 
        self._text_widget.set_text(textlist)
124
 
        self._focus_text_widget.set_text([(with_standout[text[0]],
125
 
                                           text[1])
126
 
                                          if isinstance(text, tuple)
127
 
                                          else text
128
 
                                          for text in textlist])
129
 
        self._widget = self._text_widget
130
 
        self._focus_widget = urwid.AttrWrap(self._focus_text_widget,
131
 
                                            "standout")
132
 
        # Run update hook, if any
133
 
        if self.update_hook is not None:
134
 
            self.update_hook()
135
 
    
136
 
    def delete(self):
137
 
        if self.delete_hook is not None:
138
 
            self.delete_hook(self)
139
 
    
140
 
    def render(self, (maxcol,), focus=False):
141
 
        """Render differently if we have focus.
142
 
        This overrides the method from urwid.FlowWidget"""
143
 
        return self.current_widget(focus).render((maxcol,),
144
 
                                                 focus=focus)
145
 
    
146
 
    def keypress(self, (maxcol,), key):
147
 
        """Handle keys.
148
 
        This overrides the method from urwid.FlowWidget"""
149
 
        if key == u"e" or key == u"+":
150
 
            self.proxy.Enable()
151
 
        elif key == u"d" or key == u"-":
152
 
            self.proxy.Disable()
153
 
        elif key == u"r" or key == u"_" or key == u"ctrl k":
154
 
            self.server_proxy_object.RemoveClient(self.proxy
155
 
                                                  .object_path)
156
 
        elif key == u"s":
157
 
            self.proxy.StartChecker()
158
 
        elif key == u"S":
159
 
            self.proxy.StopChecker()
160
 
        elif key == u"C":
161
 
            self.proxy.CheckedOK()
162
 
        # xxx
163
 
#         elif key == u"p" or key == "=":
164
 
#             self.proxy.pause()
165
 
#         elif key == u"u" or key == ":":
166
 
#             self.proxy.unpause()
167
 
#         elif key == u"RET":
168
 
#             self.open()
169
 
        else:
170
 
            return key
171
 
    
172
 
    def property_changed(self, property=None, value=None,
173
 
                         *args, **kwargs):
174
 
        """Call self.update() if old value is not new value.
175
 
        This overrides the method from MandosClientPropertyCache"""
176
 
        property_name = unicode(property)
177
 
        old_value = self.properties.get(property_name)
178
 
        super(MandosClientWidget, self).property_changed(
179
 
            property=property, value=value, *args, **kwargs)
180
 
        if self.properties.get(property_name) != old_value:
181
 
            self.update()
182
 
 
183
 
 
184
 
class ConstrainedListBox(urwid.ListBox):
185
 
    """Like a normal urwid.ListBox, but will consume all "up" or
186
 
    "down" key presses, thus not allowing any containing widgets to
187
 
    use them as an excuse to shift focus away from this widget.
188
 
    """
189
 
    def keypress(self, (maxcol, maxrow), key):
190
 
        ret = super(ConstrainedListBox, self).keypress((maxcol, maxrow), key)
191
 
        if ret in (u"up", u"down"):
192
 
            return
193
 
        return ret
194
 
 
195
 
 
196
 
class UserInterface(object):
197
 
    """This is the entire user interface - the whole screen
198
 
    with boxes, lists of client widgets, etc.
199
 
    """
200
 
    def __init__(self, max_log_length=1000):
201
 
        DBusGMainLoop(set_as_default=True)
202
 
        
203
 
        self.screen = urwid.curses_display.Screen()
204
 
        
205
 
        self.screen.register_palette((
206
 
                (u"normal",
207
 
                 u"default", u"default", None),
208
 
                (u"bold",
209
 
                 u"default", u"default", u"bold"),
210
 
                (u"underline-blink",
211
 
                 u"default", u"default", u"underline"),
212
 
                (u"standout",
213
 
                 u"default", u"default", u"standout"),
214
 
                (u"bold-underline-blink",
215
 
                 u"default", u"default", (u"bold", u"underline")),
216
 
                (u"bold-standout",
217
 
                 u"default", u"default", (u"bold", u"standout")),
218
 
                (u"underline-blink-standout",
219
 
                 u"default", u"default", (u"underline", u"standout")),
220
 
                (u"bold-underline-blink-standout",
221
 
                 u"default", u"default", (u"bold", u"underline",
222
 
                                          u"standout")),
223
 
                ))
224
 
        
225
 
        if urwid.supports_unicode():
226
 
            self.divider = u"─" # \u2500
227
 
            #self.divider = u"━" # \u2501
228
 
        else:
229
 
            #self.divider = u"-" # \u002d
230
 
            self.divider = u"_" # \u005f
231
 
        
232
 
        self.screen.start()
233
 
        
234
 
        self.size = self.screen.get_cols_rows()
235
 
        
236
 
        self.clients = urwid.SimpleListWalker([])
237
 
        self.clients_dict = {}
238
 
        
239
 
        # We will add Text widgets to this list
240
 
        self.log = []
241
 
        self.max_log_length = max_log_length
242
 
        
243
 
        # We keep a reference to the log widget so we can remove it
244
 
        # from the ListWalker without it getting destroyed
245
 
        self.logbox = ConstrainedListBox(self.log)
246
 
        
247
 
        # This keeps track of whether self.uilist currently has
248
 
        # self.logbox in it or not
249
 
        self.log_visible = True
250
 
        self.log_wrap = u"any"
251
 
        
252
 
        self.rebuild()
253
 
        self.log_message((u"bold",
254
 
                          u"Mandos Monitor version " + version))
255
 
        self.log_message((u"bold",
256
 
                          u"q: Quit  ?: Help"))
257
 
        
258
 
        self.busname = domain + '.Mandos'
259
 
        self.main_loop = gobject.MainLoop()
260
 
        self.bus = dbus.SystemBus()
261
 
        mandos_dbus_objc = self.bus.get_object(
262
 
            self.busname, u"/", follow_name_owner_changes=True)
263
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
264
 
                                          dbus_interface
265
 
                                          = server_interface)
266
 
        try:
267
 
            mandos_clients = (self.mandos_serv
268
 
                              .GetAllClientsWithProperties())
269
 
        except dbus.exceptions.DBusException:
270
 
            mandos_clients = dbus.Dictionary()
271
 
        
272
 
        (self.mandos_serv
273
 
         .connect_to_signal("ClientRemoved",
274
 
                            self.find_and_remove_client,
275
 
                            dbus_interface=server_interface,
276
 
                            byte_arrays=True))
277
 
        (self.mandos_serv
278
 
         .connect_to_signal("ClientAdded",
279
 
                            self.add_new_client,
280
 
                            dbus_interface=server_interface,
281
 
                            byte_arrays=True))
282
 
        for path, client in mandos_clients.iteritems():
283
 
            client_proxy_object = self.bus.get_object(self.busname,
284
 
                                                      path)
285
 
            self.add_client(MandosClientWidget(server_proxy_object
286
 
                                               =self.mandos_serv,
287
 
                                               proxy_object
288
 
                                               =client_proxy_object,
289
 
                                               properties=client,
290
 
                                               update_hook
291
 
                                               =self.refresh,
292
 
                                               delete_hook
293
 
                                               =self.remove_client),
294
 
                            path=path)
295
 
    
296
 
    def rebuild(self):
297
 
        """This rebuilds the User Interface.
298
 
        Call this when the widget layout needs to change"""
299
 
        self.uilist = []
300
 
        #self.uilist.append(urwid.ListBox(self.clients))
301
 
        self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
302
 
                                       #header=urwid.Divider(),
303
 
                                       header=None,
304
 
                                       footer=urwid.Divider(div_char=self.divider)))
305
 
        if self.log_visible:
306
 
            self.uilist.append(self.logbox)
307
 
            pass
308
 
        self.topwidget = urwid.Pile(self.uilist)
309
 
    
310
 
    def log_message(self, markup):
311
 
        """Add a log message to the log buffer."""
312
 
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
313
 
        if (self.max_log_length
314
 
            and len(self.log) > self.max_log_length):
315
 
            del self.log[0:len(self.log)-self.max_log_length-1]
316
 
        self.logbox.set_focus(len(self.logbox.body.contents),
317
 
                              coming_from=u"above")
318
 
    
319
 
    def toggle_log_display(self):
320
 
        """Toggle visibility of the log buffer."""
321
 
        self.log_visible = not self.log_visible
322
 
        self.rebuild()
323
 
        self.log_message(u"Log visibility changed to: "
324
 
                         + unicode(self.log_visible))
325
 
    
326
 
    def change_log_display(self):
327
 
        """Change type of log display.
328
 
        Currently, this toggles wrapping of text lines."""
329
 
        if self.log_wrap == u"clip":
330
 
            self.log_wrap = u"any"
331
 
        else:
332
 
            self.log_wrap = u"clip"
333
 
        for textwidget in self.log:
334
 
            textwidget.set_wrap_mode(self.log_wrap)
335
 
        self.log_message(u"Wrap mode: " + self.log_wrap)
336
 
    
337
 
    def find_and_remove_client(self, path, name):
338
 
        """Find an client from its object path and remove it.
339
 
        
340
 
        This is connected to the ClientRemoved signal from the
341
 
        Mandos server object."""
342
 
        try:
343
 
            client = self.clients_dict[path]
344
 
        except KeyError:
345
 
            # not found?
346
 
            return
347
 
        self.remove_client(client, path)
348
 
    
349
 
    def add_new_client(self, path, properties):
350
 
        client_proxy_object = self.bus.get_object(self.busname, path)
351
 
        self.add_client(MandosClientWidget(server_proxy_object
352
 
                                           =self.mandos_serv,
353
 
                                           proxy_object
354
 
                                           =client_proxy_object,
355
 
                                           properties=properties,
356
 
                                           update_hook
357
 
                                           =self.refresh,
358
 
                                           delete_hook
359
 
                                           =self.remove_client),
360
 
                        path=path)
361
 
    
362
 
    def add_client(self, client, path=None):
363
 
        self.clients.append(client)
364
 
        if path is None:
365
 
            path = client.proxy.object_path
366
 
        self.clients_dict[path] = client
367
 
        self.clients.sort(None, lambda c: c.properties[u"name"])
368
 
        self.refresh()
369
 
    
370
 
    def remove_client(self, client, path=None):
371
 
        self.clients.remove(client)
372
 
        if path is None:
373
 
            path = client.proxy.object_path
374
 
        del self.clients_dict[path]
375
 
        if not self.clients_dict:
376
 
            # Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
377
 
            # is completely emptied, we need to recreate it.
378
 
            self.clients = urwid.SimpleListWalker([])
379
 
            self.rebuild()
380
 
        self.refresh()
381
 
    
382
 
    def refresh(self):
383
 
        """Redraw the screen"""
384
 
        canvas = self.topwidget.render(self.size, focus=True)
385
 
        self.screen.draw_screen(self.size, canvas)
386
 
    
387
 
    def run(self):
388
 
        """Start the main loop and exit when it's done."""
389
 
        self.refresh()
390
 
        self._input_callback_tag = (gobject.io_add_watch
391
 
                                    (sys.stdin.fileno(),
392
 
                                     gobject.IO_IN,
393
 
                                     self.process_input))
394
 
        self.main_loop.run()
395
 
        # Main loop has finished, we should close everything now
396
 
        gobject.source_remove(self._input_callback_tag)
397
 
        self.screen.stop()
398
 
    
399
 
    def stop(self):
400
 
        self.main_loop.quit()
401
 
    
402
 
    def process_input(self, source, condition):
403
 
        keys = self.screen.get_input()
404
 
        translations = { u"ctrl n": u"down",      # Emacs
405
 
                         u"ctrl p": u"up",        # Emacs
406
 
                         u"ctrl v": u"page down", # Emacs
407
 
                         u"meta v": u"page up",   # Emacs
408
 
                         u" ": u"page down",      # less
409
 
                         u"f": u"page down",      # less
410
 
                         u"b": u"page up",        # less
411
 
                         u"j": u"down",           # vi
412
 
                         u"k": u"up",             # vi
413
 
                         }
414
 
        for key in keys:
415
 
            try:
416
 
                key = translations[key]
417
 
            except KeyError:    # :-)
418
 
                pass
419
 
            
420
 
            if key == u"q" or key == u"Q":
421
 
                self.stop()
422
 
                break
423
 
            elif key == u"window resize":
424
 
                self.size = self.screen.get_cols_rows()
425
 
                self.refresh()
426
 
            elif key == u"\f":  # Ctrl-L
427
 
                self.refresh()
428
 
            elif key == u"l" or key == u"D":
429
 
                self.toggle_log_display()
430
 
                self.refresh()
431
 
            elif key == u"w" or key == u"i":
432
 
                self.change_log_display()
433
 
                self.refresh()
434
 
            elif key == u"?" or key == u"f1" or key == u"esc":
435
 
                if not self.log_visible:
436
 
                    self.log_visible = True
437
 
                    self.rebuild()
438
 
                self.log_message((u"bold",
439
 
                                  u"  ".join((u"q: Quit",
440
 
                                              u"?: Help",
441
 
                                              u"l: Log window toggle",
442
 
                                              u"TAB: Switch window",
443
 
                                              u"w: Wrap (log)"))))
444
 
                self.log_message((u"bold",
445
 
                                  u"  ".join((u"Clients:",
446
 
                                              u"e: Enable",
447
 
                                              u"d: Disable",
448
 
                                              u"r: Remove",
449
 
                                              u"s: Start new checker",
450
 
                                              u"S: Stop checker",
451
 
                                              u"C: Checker OK"))))
452
 
                self.refresh()
453
 
            elif key == u"tab":
454
 
                if self.topwidget.get_focus() is self.logbox:
455
 
                    self.topwidget.set_focus(0)
456
 
                else:
457
 
                    self.topwidget.set_focus(self.logbox)
458
 
                self.refresh()
459
 
            #elif (key == u"end" or key == u"meta >" or key == u"G"
460
 
            #      or key == u">"):
461
 
            #    pass            # xxx end-of-buffer
462
 
            #elif (key == u"home" or key == u"meta <" or key == u"g"
463
 
            #      or key == u"<"):
464
 
            #    pass            # xxx beginning-of-buffer
465
 
            #elif key == u"ctrl e" or key == u"$":
466
 
            #    pass            # xxx move-end-of-line
467
 
            #elif key == u"ctrl a" or key == u"^":
468
 
            #    pass            # xxx move-beginning-of-line
469
 
            #elif key == u"ctrl b" or key == u"meta (" or key == u"h":
470
 
            #    pass            # xxx left
471
 
            #elif key == u"ctrl f" or key == u"meta )" or key == u"l":
472
 
            #    pass            # xxx right
473
 
            #elif key == u"a":
474
 
            #    pass            # scroll up log
475
 
            #elif key == u"z":
476
 
            #    pass            # scroll down log
477
 
            elif self.topwidget.selectable():
478
 
                self.topwidget.keypress(self.size, key)
479
 
                self.refresh()
480
 
        return True
481
 
 
482
 
ui = UserInterface()
483
 
try:
484
 
    ui.run()
485
 
except:
486
 
    ui.screen.stop()
487
 
    raise