/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

  • Committer: Teddy Hogeborn
  • Date: 2008-11-09 06:40:29 UTC
  • mto: (24.1.113 mandos) (237.2.1 mandos)
  • mto: This revision was merged to the branch mainline in revision 238.
  • Revision ID: teddy@fukt.bsnet.se-20081109064029-df71jpoce308cq3v
First steps of a D-Bus interface to the server.

* mandos: Also import "dbus.service".
  (Client): Inherit from "dbus.service.Object", which is a new-style
            class, so inheriting from "object" is no longer necessary.
  (Client.interface): New temporary variable which only exists during
                     class definition.

  (Client.getName, Client.getFingerprint): New D-Bus getter methods.
  (Client.setSecret): New D-Bus setter method.
  (Client._set_timeout): Emit D-Bus signal "TimeoutChanged".
  (Client.getTimeout): New D-Bus getter method.
  (Client.TimeoutChanged): New D-Bus signal.
  (Client._set_interval): Emit D-Bus signal "IntervalChanged".
  (Client.getInterval): New D-Bus getter method.
  (Client.intervalChanged): New D-Bus signal.
  (Client.__init__): Also call "dbus.service.Object.__init__".
  (Client.started): New boolean attribute.
  (Client.start, Client.stop): Update "self.started", and emit D-Bus
                               signal "StateChanged".
  (Client.StateChanged): New D-Bus signal.
  (Client.stop): Use "self.started" instead of misusing "self.secret".
                 Also simplify code by using "getattr" instead of
                 "hasattr".
  (Client.checker_callback): Emit D-Bus signal "CheckerCompleted".
  (Client.CheckerCompleted): New D-Bus signal.
  (Client.bumpTimeout): D-Bus method name for "bump_timeout".
  (Client.start_checker): Emit D-Bus signal "CheckerStarted".
  (Client.CheckerStarted): New D-Bus signal.
  (Client.checkerIsRunning): New D-Bus method.
  (Client.StopChecker): D-Bus method name for "stop_checker".
  (Client.still_valid): First check "self.started".
  (Client.stillValid): D-Bus method name for "still_valid".

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
11
11
# and some lines in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008,2009 Teddy Hogeborn
15
 
# Copyright © 2008,2009 Björn Påhlsson
 
14
# Copyright © 2008 Teddy Hogeborn & Björn Påhlsson
16
15
# 
17
16
# This program is free software: you can redistribute it and/or modify
18
17
# it under the terms of the GNU General Public License as published by
35
34
 
36
35
import SocketServer
37
36
import socket
38
 
import optparse
 
37
from optparse import OptionParser
39
38
import datetime
40
39
import errno
41
40
import gnutls.crypto
66
65
import ctypes
67
66
import ctypes.util
68
67
 
69
 
version = "1.0.5"
 
68
version = "1.0.2"
70
69
 
71
70
logger = logging.Logger('mandos')
72
 
syslogger = (logging.handlers.SysLogHandler
73
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
74
 
              address = "/dev/log"))
75
 
syslogger.setFormatter(logging.Formatter
76
 
                       ('Mandos [%(process)d]: %(levelname)s:'
77
 
                        ' %(message)s'))
 
71
syslogger = logging.handlers.SysLogHandler\
 
72
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
73
             address = "/dev/log")
 
74
syslogger.setFormatter(logging.Formatter\
 
75
                        ('Mandos: %(levelname)s: %(message)s'))
78
76
logger.addHandler(syslogger)
79
77
 
80
78
console = logging.StreamHandler()
81
 
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
82
 
                                       ' %(levelname)s: %(message)s'))
 
79
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
 
80
                                       ' %(message)s'))
83
81
logger.addHandler(console)
84
82
 
85
83
class AvahiError(Exception):
86
 
    def __init__(self, value, *args, **kwargs):
 
84
    def __init__(self, value):
87
85
        self.value = value
88
 
        super(AvahiError, self).__init__(value, *args, **kwargs)
89
 
    def __unicode__(self):
90
 
        return unicode(repr(self.value))
 
86
        super(AvahiError, self).__init__()
 
87
    def __str__(self):
 
88
        return repr(self.value)
91
89
 
92
90
class AvahiServiceError(AvahiError):
93
91
    pass
113
111
                  a sensible number of times
114
112
    """
115
113
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
116
 
                 servicetype = None, port = None, TXT = None,
117
 
                 domain = "", host = "", max_renames = 32768):
 
114
                 servicetype = None, port = None, TXT = None, domain = "",
 
115
                 host = "", max_renames = 32768):
118
116
        self.interface = interface
119
117
        self.name = name
120
118
        self.type = servicetype
121
119
        self.port = port
122
 
        self.TXT = TXT if TXT is not None else []
 
120
        if TXT is None:
 
121
            self.TXT = []
 
122
        else:
 
123
            self.TXT = TXT
123
124
        self.domain = domain
124
125
        self.host = host
125
126
        self.rename_count = 0
130
131
            logger.critical(u"No suitable Zeroconf service name found"
131
132
                            u" after %i retries, exiting.",
132
133
                            self.rename_count)
133
 
            raise AvahiServiceError(u"Too many renames")
 
134
            raise AvahiServiceError("Too many renames")
134
135
        self.name = server.GetAlternativeServiceName(self.name)
135
136
        logger.info(u"Changing Zeroconf service name to %r ...",
136
137
                    str(self.name))
137
 
        syslogger.setFormatter(logging.Formatter
 
138
        syslogger.setFormatter(logging.Formatter\
138
139
                               ('Mandos (%s): %%(levelname)s:'
139
 
                                ' %%(message)s' % self.name))
 
140
                               ' %%(message)s' % self.name))
140
141
        self.remove()
141
142
        self.add()
142
143
        self.rename_count += 1
148
149
        """Derived from the Avahi example code"""
149
150
        global group
150
151
        if group is None:
151
 
            group = dbus.Interface(bus.get_object
152
 
                                   (avahi.DBUS_NAME,
 
152
            group = dbus.Interface\
 
153
                    (bus.get_object(avahi.DBUS_NAME,
153
154
                                    server.EntryGroupNew()),
154
 
                                   avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
155
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
155
156
            group.connect_to_signal('StateChanged',
156
157
                                    entry_group_state_changed)
157
158
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
171
172
# End of Avahi example code
172
173
 
173
174
 
174
 
def _datetime_to_dbus(dt, variant_level=0):
175
 
    """Convert a UTC datetime.datetime() to a D-Bus type."""
176
 
    return dbus.String(dt.isoformat(), variant_level=variant_level)
177
 
 
178
 
 
179
175
class Client(dbus.service.Object):
180
176
    """A representation of a client host served by this server.
181
177
    Attributes:
182
 
    name:       string; from the config file, used in log messages and
183
 
                        D-Bus identifiers
 
178
    name:      string; from the config file, used in log messages
184
179
    fingerprint: string (40 or 32 hexadecimal digits); used to
185
180
                 uniquely identify the client
186
 
    secret:     bytestring; sent verbatim (over TLS) to client
187
 
    host:       string; available for use by the checker command
188
 
    created:    datetime.datetime(); (UTC) object creation
189
 
    last_enabled: datetime.datetime(); (UTC)
190
 
    enabled:    bool()
191
 
    last_checked_ok: datetime.datetime(); (UTC) or None
192
 
    timeout:    datetime.timedelta(); How long from last_checked_ok
193
 
                                      until this client is invalid
194
 
    interval:   datetime.timedelta(); How often to start a new checker
195
 
    disable_hook:  If set, called by disable() as disable_hook(self)
196
 
    checker:    subprocess.Popen(); a running checker process used
197
 
                                    to see if the client lives.
198
 
                                    'None' if no process is running.
 
181
    secret:    bytestring; sent verbatim (over TLS) to client
 
182
    host:      string; available for use by the checker command
 
183
    created:   datetime.datetime(); object creation, not client host
 
184
    started:   bool()
 
185
    last_checked_ok: datetime.datetime() or None if not yet checked OK
 
186
    timeout:   datetime.timedelta(); How long from last_checked_ok
 
187
                                     until this client is invalid
 
188
    interval:  datetime.timedelta(); How often to start a new checker
 
189
    stop_hook: If set, called by stop() as stop_hook(self)
 
190
    checker:   subprocess.Popen(); a running checker process used
 
191
                                   to see if the client lives.
 
192
                                   'None' if no process is running.
199
193
    checker_initiator_tag: a gobject event source tag, or None
200
 
    disable_initiator_tag:    - '' -
 
194
    stop_initiator_tag:    - '' -
201
195
    checker_callback_tag:  - '' -
202
196
    checker_command: string; External command which is run to check if
203
197
                     client lives.  %() expansions are done at
204
198
                     runtime with vars(self) as dict, so that for
205
199
                     instance %(name)s can be used in the command.
206
 
    use_dbus: bool(); Whether to provide D-Bus interface and signals
207
 
    dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
 
200
    Private attibutes:
 
201
    _timeout: Real variable for 'timeout'
 
202
    _interval: Real variable for 'interval'
 
203
    _timeout_milliseconds: Used when calling gobject.timeout_add()
 
204
    _interval_milliseconds: - '' -
208
205
    """
209
 
    def timeout_milliseconds(self):
210
 
        "Return the 'timeout' attribute in milliseconds"
211
 
        return ((self.timeout.days * 24 * 60 * 60 * 1000)
212
 
                + (self.timeout.seconds * 1000)
213
 
                + (self.timeout.microseconds // 1000))
214
 
    
215
 
    def interval_milliseconds(self):
216
 
        "Return the 'interval' attribute in milliseconds"
217
 
        return ((self.interval.days * 24 * 60 * 60 * 1000)
218
 
                + (self.interval.seconds * 1000)
219
 
                + (self.interval.microseconds // 1000))
220
 
    
221
 
    def __init__(self, name = None, disable_hook=None, config=None,
222
 
                 use_dbus=True):
 
206
    interface = u"org.mandos_system.Mandos.Clients"
 
207
    
 
208
    @dbus.service.method(interface, out_signature="s")
 
209
    def getName(self):
 
210
        "D-Bus getter method"
 
211
        return self.name
 
212
    
 
213
    @dbus.service.method(interface, out_signature="s")
 
214
    def getFingerprint(self):
 
215
        "D-Bus getter method"
 
216
        return self.fingerprint
 
217
    
 
218
    @dbus.service.method(interface, in_signature="ay",
 
219
                         byte_arrays=True)
 
220
    def setSecret(self, secret):
 
221
        "D-Bus setter method"
 
222
        self.secret = secret
 
223
    
 
224
    def _set_timeout(self, timeout):
 
225
        "Setter function for the 'timeout' attribute"
 
226
        self._timeout = timeout
 
227
        self._timeout_milliseconds = ((self.timeout.days
 
228
                                       * 24 * 60 * 60 * 1000)
 
229
                                      + (self.timeout.seconds * 1000)
 
230
                                      + (self.timeout.microseconds
 
231
                                         // 1000))
 
232
        # Emit D-Bus signal
 
233
        self.TimeoutChanged(self._timeout_milliseconds)
 
234
    timeout = property(lambda self: self._timeout, _set_timeout)
 
235
    del _set_timeout
 
236
    
 
237
    @dbus.service.method(interface, out_signature="t")
 
238
    def getTimeout(self):
 
239
        "D-Bus getter method"
 
240
        return self._timeout_milliseconds
 
241
    
 
242
    @dbus.service.signal(interface, signature="t")
 
243
    def TimeoutChanged(self, t):
 
244
        "D-Bus signal"
 
245
        pass
 
246
    
 
247
    def _set_interval(self, interval):
 
248
        "Setter function for the 'interval' attribute"
 
249
        self._interval = interval
 
250
        self._interval_milliseconds = ((self.interval.days
 
251
                                        * 24 * 60 * 60 * 1000)
 
252
                                       + (self.interval.seconds
 
253
                                          * 1000)
 
254
                                       + (self.interval.microseconds
 
255
                                          // 1000))
 
256
        # Emit D-Bus signal
 
257
        self.IntervalChanged(self._interval_milliseconds)
 
258
    interval = property(lambda self: self._interval, _set_interval)
 
259
    del _set_interval
 
260
    
 
261
    @dbus.service.method(interface, out_signature="t")
 
262
    def getInterval(self):
 
263
        "D-Bus getter method"
 
264
        return self._interval_milliseconds
 
265
    
 
266
    @dbus.service.signal(interface, signature="t")
 
267
    def IntervalChanged(self, t):
 
268
        "D-Bus signal"
 
269
        pass
 
270
    
 
271
    def __init__(self, name = None, stop_hook=None, config=None):
223
272
        """Note: the 'checker' key in 'config' sets the
224
273
        'checker_command' attribute and *not* the 'checker'
225
274
        attribute."""
226
 
        self.name = name
 
275
        dbus.service.Object.__init__(self, bus,
 
276
                                     "/Mandos/Clients/%s"
 
277
                                     % name.replace(".", "_"))
227
278
        if config is None:
228
279
            config = {}
 
280
        self.name = name
229
281
        logger.debug(u"Creating client %r", self.name)
230
 
        self.use_dbus = False   # During __init__
231
282
        # Uppercase and remove spaces from fingerprint for later
232
283
        # comparison purposes with return value from the fingerprint()
233
284
        # function
234
 
        self.fingerprint = (config["fingerprint"].upper()
235
 
                            .replace(u" ", u""))
 
285
        self.fingerprint = config["fingerprint"].upper()\
 
286
                           .replace(u" ", u"")
236
287
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
237
288
        if "secret" in config:
238
289
            self.secret = config["secret"].decode(u"base64")
239
290
        elif "secfile" in config:
240
291
            with closing(open(os.path.expanduser
241
292
                              (os.path.expandvars
242
 
                               (config["secfile"])))) as secfile:
 
293
                               (config["secfile"])))) \
 
294
                               as secfile:
243
295
                self.secret = secfile.read()
244
296
        else:
245
297
            raise TypeError(u"No secret or secfile for client %s"
246
298
                            % self.name)
247
299
        self.host = config.get("host", "")
248
 
        self.created = datetime.datetime.utcnow()
249
 
        self.enabled = False
250
 
        self.last_enabled = None
 
300
        self.created = datetime.datetime.now()
 
301
        self.started = False
251
302
        self.last_checked_ok = None
252
303
        self.timeout = string_to_delta(config["timeout"])
253
304
        self.interval = string_to_delta(config["interval"])
254
 
        self.disable_hook = disable_hook
 
305
        self.stop_hook = stop_hook
255
306
        self.checker = None
256
307
        self.checker_initiator_tag = None
257
 
        self.disable_initiator_tag = None
 
308
        self.stop_initiator_tag = None
258
309
        self.checker_callback_tag = None
259
 
        self.checker_command = config["checker"]
260
 
        self.last_connect = None
261
 
        # Only now, when this client is initialized, can it show up on
262
 
        # the D-Bus
263
 
        self.use_dbus = use_dbus
264
 
        if self.use_dbus:
265
 
            self.dbus_object_path = (dbus.ObjectPath
266
 
                                     ("/clients/"
267
 
                                      + self.name.replace(".", "_")))
268
 
            dbus.service.Object.__init__(self, bus,
269
 
                                         self.dbus_object_path)
 
310
        self.check_command = config["checker"]
270
311
    
271
 
    def enable(self):
 
312
    def start(self):
272
313
        """Start this client's checker and timeout hooks"""
273
 
        self.last_enabled = datetime.datetime.utcnow()
 
314
        self.started = True
274
315
        # Schedule a new checker to be started an 'interval' from now,
275
316
        # and every interval from then on.
276
 
        self.checker_initiator_tag = (gobject.timeout_add
277
 
                                      (self.interval_milliseconds(),
278
 
                                       self.start_checker))
 
317
        self.checker_initiator_tag = gobject.timeout_add\
 
318
                                     (self._interval_milliseconds,
 
319
                                      self.start_checker)
279
320
        # Also start a new checker *right now*.
280
321
        self.start_checker()
281
 
        # Schedule a disable() when 'timeout' has passed
282
 
        self.disable_initiator_tag = (gobject.timeout_add
283
 
                                   (self.timeout_milliseconds(),
284
 
                                    self.disable))
285
 
        self.enabled = True
286
 
        if self.use_dbus:
287
 
            # Emit D-Bus signals
288
 
            self.PropertyChanged(dbus.String(u"enabled"),
289
 
                                 dbus.Boolean(True, variant_level=1))
290
 
            self.PropertyChanged(dbus.String(u"last_enabled"),
291
 
                                 (_datetime_to_dbus(self.last_enabled,
292
 
                                                    variant_level=1)))
293
 
    
294
 
    def disable(self):
295
 
        """Disable this client."""
296
 
        if not getattr(self, "enabled", False):
 
322
        # Schedule a stop() when 'timeout' has passed
 
323
        self.stop_initiator_tag = gobject.timeout_add\
 
324
                                  (self._timeout_milliseconds,
 
325
                                   self.stop)
 
326
        # Emit D-Bus signal
 
327
        self.StateChanged(True)
 
328
    
 
329
    @dbus.service.signal(interface, signature="b")
 
330
    def StateChanged(self, started):
 
331
        "D-Bus signal"
 
332
        pass
 
333
    
 
334
    def stop(self):
 
335
        """Stop this client."""
 
336
        if getattr(self, "started", False):
 
337
            logger.info(u"Stopping client %s", self.name)
 
338
        else:
297
339
            return False
298
 
        logger.info(u"Disabling client %s", self.name)
299
 
        if getattr(self, "disable_initiator_tag", False):
300
 
            gobject.source_remove(self.disable_initiator_tag)
301
 
            self.disable_initiator_tag = None
 
340
        if getattr(self, "stop_initiator_tag", False):
 
341
            gobject.source_remove(self.stop_initiator_tag)
 
342
            self.stop_initiator_tag = None
302
343
        if getattr(self, "checker_initiator_tag", False):
303
344
            gobject.source_remove(self.checker_initiator_tag)
304
345
            self.checker_initiator_tag = None
305
346
        self.stop_checker()
306
 
        if self.disable_hook:
307
 
            self.disable_hook(self)
308
 
        self.enabled = False
309
 
        if self.use_dbus:
310
 
            # Emit D-Bus signal
311
 
            self.PropertyChanged(dbus.String(u"enabled"),
312
 
                                 dbus.Boolean(False, variant_level=1))
 
347
        if self.stop_hook:
 
348
            self.stop_hook(self)
 
349
        # Emit D-Bus signal
 
350
        self.StateChanged(False)
313
351
        # Do not run this again if called by a gobject.timeout_add
314
352
        return False
 
353
    # D-Bus variant
 
354
    Stop = dbus.service.method(interface)(stop)
315
355
    
316
356
    def __del__(self):
317
 
        self.disable_hook = None
318
 
        self.disable()
 
357
        self.stop_hook = None
 
358
        self.stop()
319
359
    
320
 
    def checker_callback(self, pid, condition, command):
 
360
    def checker_callback(self, pid, condition):
321
361
        """The checker has completed, so take appropriate actions."""
322
362
        self.checker_callback_tag = None
323
363
        self.checker = None
324
 
        if self.use_dbus:
 
364
        if os.WIFEXITED(condition) \
 
365
               and (os.WEXITSTATUS(condition) == 0):
 
366
            logger.info(u"Checker for %(name)s succeeded",
 
367
                        vars(self))
325
368
            # Emit D-Bus signal
326
 
            self.PropertyChanged(dbus.String(u"checker_running"),
327
 
                                 dbus.Boolean(False, variant_level=1))
328
 
        if os.WIFEXITED(condition):
329
 
            exitstatus = os.WEXITSTATUS(condition)
330
 
            if exitstatus == 0:
331
 
                logger.info(u"Checker for %(name)s succeeded",
332
 
                            vars(self))
333
 
                self.checked_ok()
334
 
            else:
335
 
                logger.info(u"Checker for %(name)s failed",
336
 
                            vars(self))
337
 
            if self.use_dbus:
338
 
                # Emit D-Bus signal
339
 
                self.CheckerCompleted(dbus.Int16(exitstatus),
340
 
                                      dbus.Int64(condition),
341
 
                                      dbus.String(command))
342
 
        else:
 
369
            self.CheckerCompleted(True)
 
370
            self.bump_timeout()
 
371
        elif not os.WIFEXITED(condition):
343
372
            logger.warning(u"Checker for %(name)s crashed?",
344
373
                           vars(self))
345
 
            if self.use_dbus:
346
 
                # Emit D-Bus signal
347
 
                self.CheckerCompleted(dbus.Int16(-1),
348
 
                                      dbus.Int64(condition),
349
 
                                      dbus.String(command))
350
 
    
351
 
    def checked_ok(self):
 
374
            # Emit D-Bus signal
 
375
            self.CheckerCompleted(False)
 
376
        else:
 
377
            logger.info(u"Checker for %(name)s failed",
 
378
                        vars(self))
 
379
            # Emit D-Bus signal
 
380
            self.CheckerCompleted(False)
 
381
    
 
382
    @dbus.service.signal(interface, signature="b")
 
383
    def CheckerCompleted(self, success):
 
384
        "D-Bus signal"
 
385
        pass
 
386
    
 
387
    def bump_timeout(self):
352
388
        """Bump up the timeout for this client.
353
389
        This should only be called when the client has been seen,
354
390
        alive and well.
355
391
        """
356
 
        self.last_checked_ok = datetime.datetime.utcnow()
357
 
        gobject.source_remove(self.disable_initiator_tag)
358
 
        self.disable_initiator_tag = (gobject.timeout_add
359
 
                                      (self.timeout_milliseconds(),
360
 
                                       self.disable))
361
 
        if self.use_dbus:
362
 
            # Emit D-Bus signal
363
 
            self.PropertyChanged(
364
 
                dbus.String(u"last_checked_ok"),
365
 
                (_datetime_to_dbus(self.last_checked_ok,
366
 
                                   variant_level=1)))
 
392
        self.last_checked_ok = datetime.datetime.now()
 
393
        gobject.source_remove(self.stop_initiator_tag)
 
394
        self.stop_initiator_tag = gobject.timeout_add\
 
395
            (self._timeout_milliseconds, self.stop)
 
396
    # D-Bus variant
 
397
    bumpTimeout = dbus.service.method(interface)(bump_timeout)
367
398
    
368
399
    def start_checker(self):
369
400
        """Start a new checker subprocess if one is not running.
379
410
        # is as it should be.
380
411
        if self.checker is None:
381
412
            try:
382
 
                # In case checker_command has exactly one % operator
383
 
                command = self.checker_command % self.host
 
413
                # In case check_command has exactly one % operator
 
414
                command = self.check_command % self.host
384
415
            except TypeError:
385
416
                # Escape attributes for the shell
386
417
                escaped_attrs = dict((key, re.escape(str(val)))
387
418
                                     for key, val in
388
419
                                     vars(self).iteritems())
389
420
                try:
390
 
                    command = self.checker_command % escaped_attrs
 
421
                    command = self.check_command % escaped_attrs
391
422
                except TypeError, error:
392
423
                    logger.error(u'Could not format string "%s":'
393
 
                                 u' %s', self.checker_command, error)
 
424
                                 u' %s', self.check_command, error)
394
425
                    return True # Try again later
395
426
            try:
396
427
                logger.info(u"Starting checker %r for %s",
402
433
                self.checker = subprocess.Popen(command,
403
434
                                                close_fds=True,
404
435
                                                shell=True, cwd="/")
405
 
                if self.use_dbus:
406
 
                    # Emit D-Bus signal
407
 
                    self.CheckerStarted(command)
408
 
                    self.PropertyChanged(
409
 
                        dbus.String("checker_running"),
410
 
                        dbus.Boolean(True, variant_level=1))
411
 
                self.checker_callback_tag = (gobject.child_watch_add
412
 
                                             (self.checker.pid,
413
 
                                              self.checker_callback,
414
 
                                              data=command))
 
436
                self.checker_callback_tag = gobject.child_watch_add\
 
437
                                            (self.checker.pid,
 
438
                                             self.checker_callback)
 
439
                # Emit D-Bus signal
 
440
                self.CheckerStarted(command)
415
441
            except OSError, error:
416
442
                logger.error(u"Failed to start subprocess: %s",
417
443
                             error)
418
444
        # Re-run this periodically if run by gobject.timeout_add
419
445
        return True
420
446
    
 
447
    @dbus.service.signal(interface, signature="s")
 
448
    def CheckerStarted(self, command):
 
449
        pass
 
450
    
 
451
    @dbus.service.method(interface, out_signature="b")
 
452
    def checkerIsRunning(self):
 
453
        "D-Bus getter method"
 
454
        return self.checker is not None
 
455
    
421
456
    def stop_checker(self):
422
457
        """Force the checker process, if any, to stop."""
423
458
        if self.checker_callback_tag:
435
470
            if error.errno != errno.ESRCH: # No such process
436
471
                raise
437
472
        self.checker = None
438
 
        if self.use_dbus:
439
 
            self.PropertyChanged(dbus.String(u"checker_running"),
440
 
                                 dbus.Boolean(False, variant_level=1))
 
473
    # D-Bus variant
 
474
    StopChecker = dbus.service.method(interface)(stop_checker)
441
475
    
442
476
    def still_valid(self):
443
477
        """Has the timeout not yet passed for this client?"""
444
 
        if not getattr(self, "enabled", False):
 
478
        if not self.started:
445
479
            return False
446
 
        now = datetime.datetime.utcnow()
 
480
        now = datetime.datetime.now()
447
481
        if self.last_checked_ok is None:
448
482
            return now < (self.created + self.timeout)
449
483
        else:
450
484
            return now < (self.last_checked_ok + self.timeout)
451
 
    
452
 
    ## D-Bus methods & signals
453
 
    _interface = u"se.bsnet.fukt.Mandos.Client"
454
 
    
455
 
    # CheckedOK - method
456
 
    CheckedOK = dbus.service.method(_interface)(checked_ok)
457
 
    CheckedOK.__name__ = "CheckedOK"
458
 
    
459
 
    # CheckerCompleted - signal
460
 
    @dbus.service.signal(_interface, signature="nxs")
461
 
    def CheckerCompleted(self, exitcode, waitstatus, command):
462
 
        "D-Bus signal"
463
 
        pass
464
 
    
465
 
    # CheckerStarted - signal
466
 
    @dbus.service.signal(_interface, signature="s")
467
 
    def CheckerStarted(self, command):
468
 
        "D-Bus signal"
469
 
        pass
470
 
    
471
 
    # GetAllProperties - method
472
 
    @dbus.service.method(_interface, out_signature="a{sv}")
473
 
    def GetAllProperties(self):
474
 
        "D-Bus method"
475
 
        return dbus.Dictionary({
476
 
                dbus.String("name"):
477
 
                    dbus.String(self.name, variant_level=1),
478
 
                dbus.String("fingerprint"):
479
 
                    dbus.String(self.fingerprint, variant_level=1),
480
 
                dbus.String("host"):
481
 
                    dbus.String(self.host, variant_level=1),
482
 
                dbus.String("created"):
483
 
                    _datetime_to_dbus(self.created, variant_level=1),
484
 
                dbus.String("last_enabled"):
485
 
                    (_datetime_to_dbus(self.last_enabled,
486
 
                                       variant_level=1)
487
 
                     if self.last_enabled is not None
488
 
                     else dbus.Boolean(False, variant_level=1)),
489
 
                dbus.String("enabled"):
490
 
                    dbus.Boolean(self.enabled, variant_level=1),
491
 
                dbus.String("last_checked_ok"):
492
 
                    (_datetime_to_dbus(self.last_checked_ok,
493
 
                                       variant_level=1)
494
 
                     if self.last_checked_ok is not None
495
 
                     else dbus.Boolean (False, variant_level=1)),
496
 
                dbus.String("timeout"):
497
 
                    dbus.UInt64(self.timeout_milliseconds(),
498
 
                                variant_level=1),
499
 
                dbus.String("interval"):
500
 
                    dbus.UInt64(self.interval_milliseconds(),
501
 
                                variant_level=1),
502
 
                dbus.String("checker"):
503
 
                    dbus.String(self.checker_command,
504
 
                                variant_level=1),
505
 
                dbus.String("checker_running"):
506
 
                    dbus.Boolean(self.checker is not None,
507
 
                                 variant_level=1),
508
 
                dbus.String("object_path"):
509
 
                    dbus.ObjectPath(self.dbus_object_path,
510
 
                                    variant_level=1)
511
 
                }, signature="sv")
512
 
    
513
 
    # IsStillValid - method
514
 
    IsStillValid = (dbus.service.method(_interface, out_signature="b")
515
 
                    (still_valid))
516
 
    IsStillValid.__name__ = "IsStillValid"
517
 
    
518
 
    # PropertyChanged - signal
519
 
    @dbus.service.signal(_interface, signature="sv")
520
 
    def PropertyChanged(self, property, value):
521
 
        "D-Bus signal"
522
 
        pass
523
 
    
524
 
    # SetChecker - method
525
 
    @dbus.service.method(_interface, in_signature="s")
526
 
    def SetChecker(self, checker):
527
 
        "D-Bus setter method"
528
 
        self.checker_command = checker
529
 
        # Emit D-Bus signal
530
 
        self.PropertyChanged(dbus.String(u"checker"),
531
 
                             dbus.String(self.checker_command,
532
 
                                         variant_level=1))
533
 
    
534
 
    # SetHost - method
535
 
    @dbus.service.method(_interface, in_signature="s")
536
 
    def SetHost(self, host):
537
 
        "D-Bus setter method"
538
 
        self.host = host
539
 
        # Emit D-Bus signal
540
 
        self.PropertyChanged(dbus.String(u"host"),
541
 
                             dbus.String(self.host, variant_level=1))
542
 
    
543
 
    # SetInterval - method
544
 
    @dbus.service.method(_interface, in_signature="t")
545
 
    def SetInterval(self, milliseconds):
546
 
        self.interval = datetime.timedelta(0, 0, 0, milliseconds)
547
 
        # Emit D-Bus signal
548
 
        self.PropertyChanged(dbus.String(u"interval"),
549
 
                             (dbus.UInt64(self.interval_milliseconds(),
550
 
                                          variant_level=1)))
551
 
    
552
 
    # SetSecret - method
553
 
    @dbus.service.method(_interface, in_signature="ay",
554
 
                         byte_arrays=True)
555
 
    def SetSecret(self, secret):
556
 
        "D-Bus setter method"
557
 
        self.secret = str(secret)
558
 
    
559
 
    # SetTimeout - method
560
 
    @dbus.service.method(_interface, in_signature="t")
561
 
    def SetTimeout(self, milliseconds):
562
 
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
563
 
        # Emit D-Bus signal
564
 
        self.PropertyChanged(dbus.String(u"timeout"),
565
 
                             (dbus.UInt64(self.timeout_milliseconds(),
566
 
                                          variant_level=1)))
567
 
    
568
 
    # Enable - method
569
 
    Enable = dbus.service.method(_interface)(enable)
570
 
    Enable.__name__ = "Enable"
571
 
    
572
 
    # StartChecker - method
573
 
    @dbus.service.method(_interface)
574
 
    def StartChecker(self):
575
 
        "D-Bus method"
576
 
        self.start_checker()
577
 
    
578
 
    # Disable - method
579
 
    @dbus.service.method(_interface)
580
 
    def Disable(self):
581
 
        "D-Bus method"
582
 
        self.disable()
583
 
    
584
 
    # StopChecker - method
585
 
    StopChecker = dbus.service.method(_interface)(stop_checker)
586
 
    StopChecker.__name__ = "StopChecker"
587
 
    
588
 
    del _interface
 
485
    # D-Bus variant
 
486
    stillValid = dbus.service.method(interface, out_signature="b")\
 
487
        (still_valid)
 
488
    
 
489
    del interface
589
490
 
590
491
 
591
492
def peer_certificate(session):
592
493
    "Return the peer's OpenPGP certificate as a bytestring"
593
494
    # If not an OpenPGP certificate...
594
 
    if (gnutls.library.functions
595
 
        .gnutls_certificate_type_get(session._c_object)
596
 
        != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
 
495
    if gnutls.library.functions.gnutls_certificate_type_get\
 
496
            (session._c_object) \
 
497
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
597
498
        # ...do the normal thing
598
499
        return session.peer_certificate
599
 
    list_size = ctypes.c_uint(1)
600
 
    cert_list = (gnutls.library.functions
601
 
                 .gnutls_certificate_get_peers
602
 
                 (session._c_object, ctypes.byref(list_size)))
603
 
    if not bool(cert_list) and list_size.value != 0:
604
 
        raise gnutls.errors.GNUTLSError("error getting peer"
605
 
                                        " certificate")
 
500
    list_size = ctypes.c_uint()
 
501
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
 
502
        (session._c_object, ctypes.byref(list_size))
606
503
    if list_size.value == 0:
607
504
        return None
608
505
    cert = cert_list[0]
612
509
def fingerprint(openpgp):
613
510
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
614
511
    # New GnuTLS "datum" with the OpenPGP public key
615
 
    datum = (gnutls.library.types
616
 
             .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
617
 
                                         ctypes.POINTER
618
 
                                         (ctypes.c_ubyte)),
619
 
                             ctypes.c_uint(len(openpgp))))
 
512
    datum = gnutls.library.types.gnutls_datum_t\
 
513
        (ctypes.cast(ctypes.c_char_p(openpgp),
 
514
                     ctypes.POINTER(ctypes.c_ubyte)),
 
515
         ctypes.c_uint(len(openpgp)))
620
516
    # New empty GnuTLS certificate
621
517
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
622
 
    (gnutls.library.functions
623
 
     .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
518
    gnutls.library.functions.gnutls_openpgp_crt_init\
 
519
        (ctypes.byref(crt))
624
520
    # Import the OpenPGP public key into the certificate
625
 
    (gnutls.library.functions
626
 
     .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
627
 
                                gnutls.library.constants
628
 
                                .GNUTLS_OPENPGP_FMT_RAW))
 
521
    gnutls.library.functions.gnutls_openpgp_crt_import\
 
522
                    (crt, ctypes.byref(datum),
 
523
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
629
524
    # Verify the self signature in the key
630
525
    crtverify = ctypes.c_uint()
631
 
    (gnutls.library.functions
632
 
     .gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
 
526
    gnutls.library.functions.gnutls_openpgp_crt_verify_self\
 
527
        (crt, 0, ctypes.byref(crtverify))
633
528
    if crtverify.value != 0:
634
529
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
635
530
        raise gnutls.errors.CertificateSecurityError("Verify failed")
637
532
    buf = ctypes.create_string_buffer(20)
638
533
    buf_len = ctypes.c_size_t()
639
534
    # Get the fingerprint from the certificate into the buffer
640
 
    (gnutls.library.functions
641
 
     .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
642
 
                                         ctypes.byref(buf_len)))
 
535
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
 
536
        (crt, ctypes.byref(buf), ctypes.byref(buf_len))
643
537
    # Deinit the certificate
644
538
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
645
539
    # Convert the buffer to a Python bytestring
657
551
    def handle(self):
658
552
        logger.info(u"TCP connection from: %s",
659
553
                    unicode(self.client_address))
660
 
        session = (gnutls.connection
661
 
                   .ClientSession(self.request,
662
 
                                  gnutls.connection
663
 
                                  .X509Credentials()))
 
554
        session = gnutls.connection.ClientSession\
 
555
                  (self.request, gnutls.connection.X509Credentials())
664
556
        
665
557
        line = self.request.makefile().readline()
666
558
        logger.debug(u"Protocol version: %r", line)
677
569
        # using OpenPGP certificates.
678
570
        
679
571
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
680
 
        #                     "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
681
 
        #                     "+DHE-DSS"))
 
572
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
 
573
        #                "+DHE-DSS"))
682
574
        # Use a fallback default, since this MUST be set.
683
575
        priority = self.server.settings.get("priority", "NORMAL")
684
 
        (gnutls.library.functions
685
 
         .gnutls_priority_set_direct(session._c_object,
686
 
                                     priority, None))
 
576
        gnutls.library.functions.gnutls_priority_set_direct\
 
577
            (session._c_object, priority, None)
687
578
        
688
579
        try:
689
580
            session.handshake()
692
583
            # Do not run session.bye() here: the session is not
693
584
            # established.  Just abandon the request.
694
585
            return
695
 
        logger.debug(u"Handshake succeeded")
696
586
        try:
697
587
            fpr = fingerprint(peer_certificate(session))
698
588
        except (TypeError, gnutls.errors.GNUTLSError), error:
700
590
            session.bye()
701
591
            return
702
592
        logger.debug(u"Fingerprint: %s", fpr)
703
 
        
 
593
        client = None
704
594
        for c in self.server.clients:
705
595
            if c.fingerprint == fpr:
706
596
                client = c
707
597
                break
708
 
        else:
 
598
        if not client:
709
599
            logger.warning(u"Client not found for fingerprint: %s",
710
600
                           fpr)
711
601
            session.bye()
719
609
            session.bye()
720
610
            return
721
611
        ## This won't work here, since we're in a fork.
722
 
        # client.checked_ok()
 
612
        # client.bump_timeout()
723
613
        sent_size = 0
724
614
        while sent_size < len(client.secret):
725
615
            sent = session.send(client.secret[sent_size:])
765
655
                                 u" bind to interface %s",
766
656
                                 self.settings["interface"])
767
657
                else:
768
 
                    raise
 
658
                    raise error
769
659
        # Only bind(2) the socket if we really need to.
770
660
        if self.server_address[0] or self.server_address[1]:
771
661
            if not self.server_address[0]:
792
682
 
793
683
def string_to_delta(interval):
794
684
    """Parse a string and return a datetime.timedelta
795
 
    
 
685
 
796
686
    >>> string_to_delta('7d')
797
687
    datetime.timedelta(7)
798
688
    >>> string_to_delta('60s')
850
740
    elif state == avahi.ENTRY_GROUP_FAILURE:
851
741
        logger.critical(u"Avahi: Error in group state changed %s",
852
742
                        unicode(error))
853
 
        raise AvahiGroupError(u"State changed: %s" % unicode(error))
 
743
        raise AvahiGroupError("State changed: %s", str(error))
854
744
 
855
745
def if_nametoindex(interface):
856
746
    """Call the C function if_nametoindex(), or equivalent"""
857
747
    global if_nametoindex
858
748
    try:
859
 
        if_nametoindex = (ctypes.cdll.LoadLibrary
860
 
                          (ctypes.util.find_library("c"))
861
 
                          .if_nametoindex)
 
749
        if_nametoindex = ctypes.cdll.LoadLibrary\
 
750
            (ctypes.util.find_library("c")).if_nametoindex
862
751
    except (OSError, AttributeError):
863
752
        if "struct" not in sys.modules:
864
753
            import struct
899
788
 
900
789
 
901
790
def main():
902
 
    parser = optparse.OptionParser(version = "%%prog %s" % version)
 
791
    parser = OptionParser(version = "%%prog %s" % version)
903
792
    parser.add_option("-i", "--interface", type="string",
904
793
                      metavar="IF", help="Bind to interface IF")
905
794
    parser.add_option("-a", "--address", type="string",
906
795
                      help="Address to listen for requests on")
907
796
    parser.add_option("-p", "--port", type="int",
908
797
                      help="Port number to receive requests on")
909
 
    parser.add_option("--check", action="store_true",
 
798
    parser.add_option("--check", action="store_true", default=False,
910
799
                      help="Run self-test")
911
800
    parser.add_option("--debug", action="store_true",
912
801
                      help="Debug mode; run in foreground and log to"
919
808
                      default="/etc/mandos", metavar="DIR",
920
809
                      help="Directory to search for configuration"
921
810
                      " files")
922
 
    parser.add_option("--no-dbus", action="store_false",
923
 
                      dest="use_dbus",
924
 
                      help="Do not provide D-Bus system bus"
925
 
                      " interface")
926
811
    options = parser.parse_args()[0]
927
812
    
928
813
    if options.check:
938
823
                        "priority":
939
824
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
940
825
                        "servicename": "Mandos",
941
 
                        "use_dbus": "True",
942
826
                        }
943
827
    
944
828
    # Parse config file for server-global settings
947
831
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
948
832
    # Convert the SafeConfigParser object to a dict
949
833
    server_settings = server_config.defaults()
950
 
    # Use the appropriate methods on the non-string config options
951
 
    server_settings["debug"] = server_config.getboolean("DEFAULT",
952
 
                                                        "debug")
953
 
    server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
954
 
                                                           "use_dbus")
955
 
    if server_settings["port"]:
956
 
        server_settings["port"] = server_config.getint("DEFAULT",
957
 
                                                       "port")
 
834
    # Use getboolean on the boolean config option
 
835
    server_settings["debug"] = server_config.getboolean\
 
836
                               ("DEFAULT", "debug")
958
837
    del server_config
959
838
    
960
839
    # Override the settings from the config file with command line
961
840
    # options, if set.
962
841
    for option in ("interface", "address", "port", "debug",
963
 
                   "priority", "servicename", "configdir",
964
 
                   "use_dbus"):
 
842
                   "priority", "servicename", "configdir"):
965
843
        value = getattr(options, option)
966
844
        if value is not None:
967
845
            server_settings[option] = value
968
846
    del options
969
847
    # Now we have our good server settings in "server_settings"
970
848
    
971
 
    # For convenience
972
849
    debug = server_settings["debug"]
973
 
    use_dbus = server_settings["use_dbus"]
974
850
    
975
851
    if not debug:
976
852
        syslogger.setLevel(logging.WARNING)
977
853
        console.setLevel(logging.WARNING)
978
854
    
979
855
    if server_settings["servicename"] != "Mandos":
980
 
        syslogger.setFormatter(logging.Formatter
 
856
        syslogger.setFormatter(logging.Formatter\
981
857
                               ('Mandos (%s): %%(levelname)s:'
982
858
                                ' %%(message)s'
983
859
                                % server_settings["servicename"]))
985
861
    # Parse config file with clients
986
862
    client_defaults = { "timeout": "1h",
987
863
                        "interval": "5m",
988
 
                        "checker": "fping -q -- %%(host)s",
 
864
                        "checker": "fping -q -- %(host)s",
989
865
                        "host": "",
990
866
                        }
991
867
    client_config = ConfigParser.SafeConfigParser(client_defaults)
1001
877
    pidfilename = "/var/run/mandos.pid"
1002
878
    try:
1003
879
        pidfile = open(pidfilename, "w")
1004
 
    except IOError:
 
880
    except IOError, error:
1005
881
        logger.error("Could not open file %r", pidfilename)
1006
882
    
1007
 
    try:
1008
 
        uid = pwd.getpwnam("_mandos").pw_uid
1009
 
        gid = pwd.getpwnam("_mandos").pw_gid
1010
 
    except KeyError:
1011
 
        try:
1012
 
            uid = pwd.getpwnam("mandos").pw_uid
1013
 
            gid = pwd.getpwnam("mandos").pw_gid
1014
 
        except KeyError:
1015
 
            try:
1016
 
                uid = pwd.getpwnam("nobody").pw_uid
1017
 
                gid = pwd.getpwnam("nogroup").pw_gid
1018
 
            except KeyError:
1019
 
                uid = 65534
1020
 
                gid = 65534
1021
 
    try:
 
883
    uid = 65534
 
884
    gid = 65534
 
885
    try:
 
886
        uid = pwd.getpwnam("mandos").pw_uid
 
887
    except KeyError:
 
888
        try:
 
889
            uid = pwd.getpwnam("nobody").pw_uid
 
890
        except KeyError:
 
891
            pass
 
892
    try:
 
893
        gid = pwd.getpwnam("mandos").pw_gid
 
894
    except KeyError:
 
895
        try:
 
896
            gid = pwd.getpwnam("nogroup").pw_gid
 
897
        except KeyError:
 
898
            pass
 
899
    try:
 
900
        os.setuid(uid)
1022
901
        os.setgid(gid)
1023
 
        os.setuid(uid)
1024
902
    except OSError, error:
1025
903
        if error[0] != errno.EPERM:
1026
904
            raise error
1027
905
    
1028
 
    # Enable all possible GnuTLS debugging
1029
 
    if debug:
1030
 
        # "Use a log level over 10 to enable all debugging options."
1031
 
        # - GnuTLS manual
1032
 
        gnutls.library.functions.gnutls_global_set_log_level(11)
1033
 
        
1034
 
        @gnutls.library.types.gnutls_log_func
1035
 
        def debug_gnutls(level, string):
1036
 
            logger.debug("GnuTLS: %s", string[:-1])
1037
 
        
1038
 
        (gnutls.library.functions
1039
 
         .gnutls_global_set_log_function(debug_gnutls))
1040
 
    
1041
906
    global service
1042
907
    service = AvahiService(name = server_settings["servicename"],
1043
908
                           servicetype = "_mandos._tcp", )
1044
909
    if server_settings["interface"]:
1045
 
        service.interface = (if_nametoindex
1046
 
                             (server_settings["interface"]))
 
910
        service.interface = if_nametoindex\
 
911
                            (server_settings["interface"])
1047
912
    
1048
913
    global main_loop
1049
914
    global bus
1056
921
                                           avahi.DBUS_PATH_SERVER),
1057
922
                            avahi.DBUS_INTERFACE_SERVER)
1058
923
    # End of Avahi example code
1059
 
    if use_dbus:
1060
 
        bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
 
924
    
 
925
    def remove_from_clients(client):
 
926
        clients.remove(client)
 
927
        if not clients:
 
928
            logger.critical(u"No clients left, exiting")
 
929
            sys.exit()
1061
930
    
1062
931
    clients.update(Set(Client(name = section,
 
932
                              stop_hook = remove_from_clients,
1063
933
                              config
1064
 
                              = dict(client_config.items(section)),
1065
 
                              use_dbus = use_dbus)
 
934
                              = dict(client_config.items(section)))
1066
935
                       for section in client_config.sections()))
1067
936
    if not clients:
1068
 
        logger.warning(u"No clients defined")
 
937
        logger.critical(u"No clients defined")
 
938
        sys.exit(1)
1069
939
    
1070
940
    if debug:
1071
941
        # Redirect stdin so all checkers get /dev/null
1103
973
        
1104
974
        while clients:
1105
975
            client = clients.pop()
1106
 
            client.disable_hook = None
1107
 
            client.disable()
 
976
            client.stop_hook = None
 
977
            client.stop()
1108
978
    
1109
979
    atexit.register(cleanup)
1110
980
    
1113
983
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1114
984
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1115
985
    
1116
 
    if use_dbus:
1117
 
        class MandosServer(dbus.service.Object):
1118
 
            """A D-Bus proxy object"""
1119
 
            def __init__(self):
1120
 
                dbus.service.Object.__init__(self, bus, "/")
1121
 
            _interface = u"se.bsnet.fukt.Mandos"
1122
 
            
1123
 
            @dbus.service.signal(_interface, signature="oa{sv}")
1124
 
            def ClientAdded(self, objpath, properties):
1125
 
                "D-Bus signal"
1126
 
                pass
1127
 
            
1128
 
            @dbus.service.signal(_interface, signature="os")
1129
 
            def ClientRemoved(self, objpath, name):
1130
 
                "D-Bus signal"
1131
 
                pass
1132
 
            
1133
 
            @dbus.service.method(_interface, out_signature="ao")
1134
 
            def GetAllClients(self):
1135
 
                "D-Bus method"
1136
 
                return dbus.Array(c.dbus_object_path for c in clients)
1137
 
            
1138
 
            @dbus.service.method(_interface, out_signature="a{oa{sv}}")
1139
 
            def GetAllClientsWithProperties(self):
1140
 
                "D-Bus method"
1141
 
                return dbus.Dictionary(
1142
 
                    ((c.dbus_object_path, c.GetAllProperties())
1143
 
                     for c in clients),
1144
 
                    signature="oa{sv}")
1145
 
            
1146
 
            @dbus.service.method(_interface, in_signature="o")
1147
 
            def RemoveClient(self, object_path):
1148
 
                "D-Bus method"
1149
 
                for c in clients:
1150
 
                    if c.dbus_object_path == object_path:
1151
 
                        clients.remove(c)
1152
 
                        # Don't signal anything except ClientRemoved
1153
 
                        c.use_dbus = False
1154
 
                        c.disable()
1155
 
                        # Emit D-Bus signal
1156
 
                        self.ClientRemoved(object_path, c.name)
1157
 
                        return
1158
 
                raise KeyError
1159
 
            
1160
 
            del _interface
1161
 
        
1162
 
        mandos_server = MandosServer()
1163
 
    
1164
986
    for client in clients:
1165
 
        if use_dbus:
1166
 
            # Emit D-Bus signal
1167
 
            mandos_server.ClientAdded(client.dbus_object_path,
1168
 
                                      client.GetAllProperties())
1169
 
        client.enable()
 
987
        client.start()
1170
988
    
1171
989
    tcp_server.enable()
1172
990
    tcp_server.server_activate()
1190
1008
        
1191
1009
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1192
1010
                             lambda *args, **kwargs:
1193
 
                             (tcp_server.handle_request
1194
 
                              (*args[2:], **kwargs) or True))
 
1011
                             tcp_server.handle_request\
 
1012
                             (*args[2:], **kwargs) or True)
1195
1013
        
1196
1014
        logger.debug(u"Starting main loop")
1197
1015
        main_loop.run()
1198
1016
    except AvahiError, error:
1199
 
        logger.critical(u"AvahiError: %s", error)
 
1017
        logger.critical(u"AvahiError: %s" + unicode(error))
1200
1018
        sys.exit(1)
1201
1019
    except KeyboardInterrupt:
1202
1020
        if debug:
1203
 
            print >> sys.stderr
1204
 
        logger.debug("Server received KeyboardInterrupt")
1205
 
    logger.debug("Server exiting")
 
1021
            print
1206
1022
 
1207
1023
if __name__ == '__main__':
1208
1024
    main()