/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
  • Author(s): gregor herrmann
  • Date: 2012-02-21 21:20:12 UTC
  • mto: (237.4.29 release)
  • mto: This revision was merged to the branch mainline in revision 560.
  • Revision ID: teddy@recompile.se-20120221212012-vrbd180yikwm0qdv
http://bugs.debian.org/656178
* debian/changelog (1.5.3-1.1): New entry.
* debian/control (Source: mandos/Build-Depends): Added "locales-all".
* debian/rules (build-arch-stamp, build-indep-stamp): Add
                                                      LC_ALL=en_US.utf8
                                                      to
                                                      "dh_auto_build"
                                                      invocation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
3
3
# 
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
# 
6
 
# Copyright © 2009-2011 Teddy Hogeborn
7
 
# Copyright © 2009-2011 Björn Påhlsson
 
6
# Copyright © 2009-2012 Teddy Hogeborn
 
7
# Copyright © 2009-2012 Björn Påhlsson
8
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
19
19
# You should have received a copy of the GNU General Public License
20
20
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
21
21
# 
22
 
# Contact the authors at <mandos@fukt.bsnet.se>.
 
22
# Contact the authors at <mandos@recompile.se>.
23
23
# 
24
24
 
25
 
from __future__ import division, absolute_import, print_function, unicode_literals
 
25
from __future__ import (division, absolute_import, print_function,
 
26
                        unicode_literals)
26
27
 
27
28
import sys
28
29
import os
48
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
49
50
 
50
51
# Some useful constants
51
 
domain = 'se.bsnet.fukt'
 
52
domain = 'se.recompile'
52
53
server_interface = domain + '.Mandos'
53
54
client_interface = domain + '.Mandos.Client'
54
 
version = "1.2.3"
 
55
version = "1.5.3"
55
56
 
56
57
# Always run in monochrome mode
57
58
urwid.curses_display.curses.has_colors = lambda : False
86
87
        self.proxy = proxy_object # Mandos Client proxy object
87
88
        
88
89
        self.properties = dict()
89
 
        self.proxy.connect_to_signal("PropertyChanged",
90
 
                                     self.property_changed,
91
 
                                     client_interface,
92
 
                                     byte_arrays=True)
 
90
        self.property_changed_match = (
 
91
            self.proxy.connect_to_signal("PropertyChanged",
 
92
                                         self.property_changed,
 
93
                                         client_interface,
 
94
                                         byte_arrays=True))
93
95
        
94
96
        self.properties.update(
95
97
            self.proxy.GetAll(client_interface,
96
98
                              dbus_interface = dbus.PROPERTIES_IFACE))
97
99
 
98
 
        #XXX This break good super behaviour!
 
100
        #XXX This breaks good super behaviour
99
101
#        super(MandosClientPropertyCache, self).__init__(
100
102
#            *args, **kwargs)
101
103
    
105
107
        """
106
108
        # Update properties dict with new value
107
109
        self.properties[property] = value
 
110
    
 
111
    def delete(self, *args, **kwargs):
 
112
        self.property_changed_match.remove()
 
113
        super(MandosClientPropertyCache, self).__init__(
 
114
            *args, **kwargs)
108
115
 
109
116
 
110
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
124
131
        
125
132
        self._update_timer_callback_tag = None
126
133
        self._update_timer_callback_lock = 0
127
 
        self.last_checker_failed = False
128
134
        
129
135
        # The widget shown normally
130
136
        self._text_widget = urwid.Text("")
138
144
        
139
145
        last_checked_ok = isoformat_to_datetime(self.properties
140
146
                                                ["LastCheckedOK"])
141
 
        if last_checked_ok is None:
142
 
            self.last_checker_failed = True
143
 
        else:
144
 
            self.last_checker_failed = ((datetime.datetime.utcnow()
145
 
                                         - last_checked_ok)
146
 
                                        > datetime.timedelta
147
 
                                        (milliseconds=
148
 
                                         self.properties
149
 
                                         ["Interval"]))
150
147
        
151
 
        if self.last_checker_failed:
 
148
        if self.properties ["LastCheckerStatus"] != 0:
152
149
            self.using_timer(True)
153
150
        
154
151
        if self.need_approval:
155
152
            self.using_timer(True)
156
153
        
157
 
        self.proxy.connect_to_signal("CheckerCompleted",
158
 
                                     self.checker_completed,
159
 
                                     client_interface,
160
 
                                     byte_arrays=True)
161
 
        self.proxy.connect_to_signal("CheckerStarted",
162
 
                                     self.checker_started,
163
 
                                     client_interface,
164
 
                                     byte_arrays=True)
165
 
        self.proxy.connect_to_signal("GotSecret",
166
 
                                     self.got_secret,
167
 
                                     client_interface,
168
 
                                     byte_arrays=True)
169
 
        self.proxy.connect_to_signal("NeedApproval",
170
 
                                     self.need_approval,
171
 
                                     client_interface,
172
 
                                     byte_arrays=True)
173
 
        self.proxy.connect_to_signal("Rejected",
174
 
                                     self.rejected,
175
 
                                     client_interface,
176
 
                                     byte_arrays=True)
 
154
        self.match_objects = (
 
155
            self.proxy.connect_to_signal("CheckerCompleted",
 
156
                                         self.checker_completed,
 
157
                                         client_interface,
 
158
                                         byte_arrays=True),
 
159
            self.proxy.connect_to_signal("CheckerStarted",
 
160
                                         self.checker_started,
 
161
                                         client_interface,
 
162
                                         byte_arrays=True),
 
163
            self.proxy.connect_to_signal("GotSecret",
 
164
                                         self.got_secret,
 
165
                                         client_interface,
 
166
                                         byte_arrays=True),
 
167
            self.proxy.connect_to_signal("NeedApproval",
 
168
                                         self.need_approval,
 
169
                                         client_interface,
 
170
                                         byte_arrays=True),
 
171
            self.proxy.connect_to_signal("Rejected",
 
172
                                         self.rejected,
 
173
                                         client_interface,
 
174
                                         byte_arrays=True))
 
175
        #self.logger('Created client %s' % (self.properties["Name"]))
177
176
    
178
177
    def property_changed(self, property=None, value=None):
179
178
        super(self, MandosClientWidget).property_changed(property,
180
179
                                                         value)
181
180
        if property == "ApprovalPending":
182
181
            using_timer(bool(value))
183
 
        
 
182
        if property == "LastCheckerStatus":
 
183
            using_timer(value != 0)
 
184
            #self.logger('Checker for client %s (command "%s")'
 
185
            #            ' was successful'
 
186
            #            % (self.properties["Name"], command))
 
187
    
184
188
    def using_timer(self, flag):
185
189
        """Call this method with True or False when timer should be
186
190
        activated or deactivated.
191
195
        else:
192
196
            self._update_timer_callback_lock -= 1
193
197
        if old == 0 and self._update_timer_callback_lock:
 
198
            # Will update the shown timer value every second
194
199
            self._update_timer_callback_tag = (gobject.timeout_add
195
200
                                               (1000,
196
201
                                                self.update_timer))
200
205
    
201
206
    def checker_completed(self, exitstatus, condition, command):
202
207
        if exitstatus == 0:
203
 
            if self.last_checker_failed:
204
 
                self.last_checker_failed = False
205
 
                self.using_timer(False)
206
 
            #self.logger('Checker for client %s (command "%s")'
207
 
            #            ' was successful'
208
 
            #            % (self.properties["Name"], command))
209
208
            self.update()
210
209
            return
211
210
        # Checker failed
212
 
        if not self.last_checker_failed:
213
 
            self.last_checker_failed = True
214
 
            self.using_timer(True)
215
211
        if os.WIFEXITED(condition):
216
212
            self.logger('Checker for client %s (command "%s")'
217
213
                        ' failed with exit code %s'
232
228
        self.update()
233
229
    
234
230
    def checker_started(self, command):
 
231
        """Server signals that a checker started. This could be useful
 
232
           to log in the future. """
235
233
        #self.logger('Client %s started checker "%s"'
236
234
        #            % (self.properties["Name"], unicode(command)))
237
235
        pass
238
236
    
239
237
    def got_secret(self):
240
 
        self.last_checker_failed = False
241
238
        self.logger('Client %s received its secret'
242
239
                    % self.properties["Name"])
243
240
    
304
301
            else:
305
302
                message = "Denial in %s. (a)pprove?"
306
303
            message = message % unicode(timer).rsplit(".", 1)[0]
307
 
        elif self.last_checker_failed:
308
 
            timeout = datetime.timedelta(milliseconds
309
 
                                         = self.properties
310
 
                                         ["Timeout"])
311
 
            last_ok = isoformat_to_datetime(
312
 
                max((self.properties["LastCheckedOK"]
313
 
                     or self.properties["Created"]),
314
 
                    self.properties["LastEnabled"]))
315
 
            timer = timeout - (datetime.datetime.utcnow() - last_ok)
 
304
        elif self.properties["LastCheckerStatus"] != 0:
 
305
            # When checker has failed, print a timer until client expires
 
306
            expires = self.properties["Expires"]
 
307
            if expires == "":
 
308
                timer = datetime.timedelta(0)
 
309
            else:
 
310
                expires = datetime.datetime.strptime(expires,
 
311
                                                     '%Y-%m-%dT%H:%M:%S.%f')
 
312
                timer = expires - datetime.datetime.utcnow()
316
313
            message = ('A checker has failed! Time until client'
317
314
                       ' gets disabled: %s'
318
315
                           % unicode(timer).rsplit(".", 1)[0])
337
334
            self.update_hook()
338
335
    
339
336
    def update_timer(self):
340
 
        "called by gobject"
 
337
        """called by gobject. Will indefinitely loop until
 
338
        gobject.source_remove() on tag is called"""
341
339
        self.update()
342
340
        return True             # Keep calling this
343
341
    
344
 
    def delete(self):
 
342
    def delete(self, *args, **kwargs):
345
343
        if self._update_timer_callback_tag is not None:
346
344
            gobject.source_remove(self._update_timer_callback_tag)
347
345
            self._update_timer_callback_tag = None
 
346
        for match in self.match_objects:
 
347
            match.remove()
 
348
        self.match_objects = ()
348
349
        if self.delete_hook is not None:
349
350
            self.delete_hook(self)
 
351
        return super(MandosClientWidget, self).delete(*args, **kwargs)
350
352
    
351
353
    def render(self, maxcolrow, focus=False):
352
354
        """Render differently if we have focus.
358
360
        """Handle keys.
359
361
        This overrides the method from urwid.FlowWidget"""
360
362
        if key == "+":
361
 
            self.proxy.Enable(dbus_interface = client_interface)
 
363
            self.proxy.Enable(dbus_interface = client_interface,
 
364
                              ignore_reply=True)
362
365
        elif key == "-":
363
 
            self.proxy.Disable(dbus_interface = client_interface)
 
366
            self.proxy.Disable(dbus_interface = client_interface,
 
367
                               ignore_reply=True)
364
368
        elif key == "a":
365
369
            self.proxy.Approve(dbus.Boolean(True, variant_level=1),
366
 
                               dbus_interface = client_interface)
 
370
                               dbus_interface = client_interface,
 
371
                               ignore_reply=True)
367
372
        elif key == "d":
368
373
            self.proxy.Approve(dbus.Boolean(False, variant_level=1),
369
 
                                  dbus_interface = client_interface)
 
374
                                  dbus_interface = client_interface,
 
375
                               ignore_reply=True)
370
376
        elif key == "R" or key == "_" or key == "ctrl k":
371
377
            self.server_proxy_object.RemoveClient(self.proxy
372
 
                                                  .object_path)
 
378
                                                  .object_path,
 
379
                                                  ignore_reply=True)
373
380
        elif key == "s":
374
 
            self.proxy.StartChecker(dbus_interface = client_interface)
 
381
            self.proxy.StartChecker(dbus_interface = client_interface,
 
382
                                    ignore_reply=True)
375
383
        elif key == "S":
376
 
            self.proxy.StopChecker(dbus_interface = client_interface)
 
384
            self.proxy.StopChecker(dbus_interface = client_interface,
 
385
                                   ignore_reply=True)
377
386
        elif key == "C":
378
 
            self.proxy.CheckedOK(dbus_interface = client_interface)
 
387
            self.proxy.CheckedOK(dbus_interface = client_interface,
 
388
                                 ignore_reply=True)
379
389
        # xxx
380
390
#         elif key == "p" or key == "=":
381
391
#             self.proxy.pause()
474
484
        
475
485
        self.busname = domain + '.Mandos'
476
486
        self.main_loop = gobject.MainLoop()
477
 
        self.bus = dbus.SystemBus()
478
 
        mandos_dbus_objc = self.bus.get_object(
479
 
            self.busname, "/", follow_name_owner_changes=True)
480
 
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
481
 
                                          dbus_interface
482
 
                                          = server_interface)
483
 
        try:
484
 
            mandos_clients = (self.mandos_serv
485
 
                              .GetAllClientsWithProperties())
486
 
        except dbus.exceptions.DBusException:
487
 
            mandos_clients = dbus.Dictionary()
488
 
        
489
 
        (self.mandos_serv
490
 
         .connect_to_signal("ClientRemoved",
491
 
                            self.find_and_remove_client,
492
 
                            dbus_interface=server_interface,
493
 
                            byte_arrays=True))
494
 
        (self.mandos_serv
495
 
         .connect_to_signal("ClientAdded",
496
 
                            self.add_new_client,
497
 
                            dbus_interface=server_interface,
498
 
                            byte_arrays=True))
499
 
        (self.mandos_serv
500
 
         .connect_to_signal("ClientNotFound",
501
 
                            self.client_not_found,
502
 
                            dbus_interface=server_interface,
503
 
                            byte_arrays=True))
504
 
        for path, client in mandos_clients.iteritems():
505
 
            client_proxy_object = self.bus.get_object(self.busname,
506
 
                                                      path)
507
 
            self.add_client(MandosClientWidget(server_proxy_object
508
 
                                               =self.mandos_serv,
509
 
                                               proxy_object
510
 
                                               =client_proxy_object,
511
 
                                               properties=client,
512
 
                                               update_hook
513
 
                                               =self.refresh,
514
 
                                               delete_hook
515
 
                                               =self.remove_client,
516
 
                                               logger
517
 
                                               =self.log_message),
518
 
                            path=path)
519
487
    
520
488
    def client_not_found(self, fingerprint, address):
521
489
        self.log_message(("Client with address %s and fingerprint %s"
536
504
                                                     self.divider)))
537
505
        if self.log_visible:
538
506
            self.uilist.append(self.logbox)
539
 
            pass
540
507
        self.topwidget = urwid.Pile(self.uilist)
541
508
    
542
509
    def log_message(self, message):
572
539
        #self.log_message("Wrap mode: " + self.log_wrap)
573
540
    
574
541
    def find_and_remove_client(self, path, name):
575
 
        """Find an client from its object path and remove it.
 
542
        """Find a client by its object path and remove it.
576
543
        
577
544
        This is connected to the ClientRemoved signal from the
578
545
        Mandos server object."""
580
547
            client = self.clients_dict[path]
581
548
        except KeyError:
582
549
            # not found?
 
550
            self.log_message("Unknown client %r (%r) removed", name,
 
551
                             path)
583
552
            return
584
 
        self.remove_client(client, path)
 
553
        client.delete()
585
554
    
586
555
    def add_new_client(self, path):
587
556
        client_proxy_object = self.bus.get_object(self.busname, path)
624
593
    
625
594
    def run(self):
626
595
        """Start the main loop and exit when it's done."""
 
596
        self.bus = dbus.SystemBus()
 
597
        mandos_dbus_objc = self.bus.get_object(
 
598
            self.busname, "/", follow_name_owner_changes=True)
 
599
        self.mandos_serv = dbus.Interface(mandos_dbus_objc,
 
600
                                          dbus_interface
 
601
                                          = server_interface)
 
602
        try:
 
603
            mandos_clients = (self.mandos_serv
 
604
                              .GetAllClientsWithProperties())
 
605
        except dbus.exceptions.DBusException:
 
606
            mandos_clients = dbus.Dictionary()
 
607
        
 
608
        (self.mandos_serv
 
609
         .connect_to_signal("ClientRemoved",
 
610
                            self.find_and_remove_client,
 
611
                            dbus_interface=server_interface,
 
612
                            byte_arrays=True))
 
613
        (self.mandos_serv
 
614
         .connect_to_signal("ClientAdded",
 
615
                            self.add_new_client,
 
616
                            dbus_interface=server_interface,
 
617
                            byte_arrays=True))
 
618
        (self.mandos_serv
 
619
         .connect_to_signal("ClientNotFound",
 
620
                            self.client_not_found,
 
621
                            dbus_interface=server_interface,
 
622
                            byte_arrays=True))
 
623
        for path, client in mandos_clients.iteritems():
 
624
            client_proxy_object = self.bus.get_object(self.busname,
 
625
                                                      path)
 
626
            self.add_client(MandosClientWidget(server_proxy_object
 
627
                                               =self.mandos_serv,
 
628
                                               proxy_object
 
629
                                               =client_proxy_object,
 
630
                                               properties=client,
 
631
                                               update_hook
 
632
                                               =self.refresh,
 
633
                                               delete_hook
 
634
                                               =self.remove_client,
 
635
                                               logger
 
636
                                               =self.log_message),
 
637
                            path=path)
 
638
 
627
639
        self.refresh()
628
640
        self._input_callback_tag = (gobject.io_add_watch
629
641
                                    (sys.stdin.fileno(),