/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

merge

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 Teddy Hogeborn
15
 
# Copyright © 2008 Björn Påhlsson
 
14
# Copyright © 2008,2009 Teddy Hogeborn
 
15
# Copyright © 2008,2009 Björn Påhlsson
16
16
# 
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
35
35
 
36
36
import SocketServer
37
37
import socket
38
 
from optparse import OptionParser
 
38
import optparse
39
39
import datetime
40
40
import errno
41
41
import gnutls.crypto
66
66
import ctypes
67
67
import ctypes.util
68
68
 
69
 
version = "1.0.2"
 
69
version = "1.0.5"
70
70
 
71
71
logger = logging.Logger('mandos')
72
72
syslogger = (logging.handlers.SysLogHandler
82
82
logger.addHandler(console)
83
83
 
84
84
class AvahiError(Exception):
85
 
    def __init__(self, value):
 
85
    def __init__(self, value, *args, **kwargs):
86
86
        self.value = value
87
 
        super(AvahiError, self).__init__()
88
 
    def __str__(self):
89
 
        return repr(self.value)
 
87
        super(AvahiError, self).__init__(value, *args, **kwargs)
 
88
    def __unicode__(self):
 
89
        return unicode(repr(self.value))
90
90
 
91
91
class AvahiServiceError(AvahiError):
92
92
    pass
129
129
            logger.critical(u"No suitable Zeroconf service name found"
130
130
                            u" after %i retries, exiting.",
131
131
                            self.rename_count)
132
 
            raise AvahiServiceError("Too many renames")
 
132
            raise AvahiServiceError(u"Too many renames")
133
133
        self.name = server.GetAlternativeServiceName(self.name)
134
134
        logger.info(u"Changing Zeroconf service name to %r ...",
135
135
                    str(self.name))
178
178
class Client(dbus.service.Object):
179
179
    """A representation of a client host served by this server.
180
180
    Attributes:
181
 
    name:       string; from the config file, used in log messages
 
181
    name:       string; from the config file, used in log messages and
 
182
                        D-Bus identifiers
182
183
    fingerprint: string (40 or 32 hexadecimal digits); used to
183
184
                 uniquely identify the client
184
185
    secret:     bytestring; sent verbatim (over TLS) to client
201
202
                     client lives.  %() expansions are done at
202
203
                     runtime with vars(self) as dict, so that for
203
204
                     instance %(name)s can be used in the command.
204
 
    dbus_object_path: dbus.ObjectPath
205
 
    Private attibutes:
206
 
    _timeout: Real variable for 'timeout'
207
 
    _interval: Real variable for 'interval'
208
 
    _timeout_milliseconds: Used when calling gobject.timeout_add()
209
 
    _interval_milliseconds: - '' -
 
205
    use_dbus: bool(); Whether to provide D-Bus interface and signals
 
206
    dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
210
207
    """
211
 
    def _set_timeout(self, timeout):
212
 
        "Setter function for the 'timeout' attribute"
213
 
        self._timeout = timeout
214
 
        self._timeout_milliseconds = ((self.timeout.days
215
 
                                       * 24 * 60 * 60 * 1000)
216
 
                                      + (self.timeout.seconds * 1000)
217
 
                                      + (self.timeout.microseconds
218
 
                                         // 1000))
219
 
        # Emit D-Bus signal
220
 
        self.PropertyChanged(dbus.String(u"timeout"),
221
 
                             (dbus.UInt64(self._timeout_milliseconds,
222
 
                                          variant_level=1)))
223
 
    timeout = property(lambda self: self._timeout, _set_timeout)
224
 
    del _set_timeout
225
 
    
226
 
    def _set_interval(self, interval):
227
 
        "Setter function for the 'interval' attribute"
228
 
        self._interval = interval
229
 
        self._interval_milliseconds = ((self.interval.days
230
 
                                        * 24 * 60 * 60 * 1000)
231
 
                                       + (self.interval.seconds
232
 
                                          * 1000)
233
 
                                       + (self.interval.microseconds
234
 
                                          // 1000))
235
 
        # Emit D-Bus signal
236
 
        self.PropertyChanged(dbus.String(u"interval"),
237
 
                             (dbus.UInt64(self._interval_milliseconds,
238
 
                                          variant_level=1)))
239
 
    interval = property(lambda self: self._interval, _set_interval)
240
 
    del _set_interval
241
 
    
242
 
    def __init__(self, name = None, disable_hook=None, config=None):
 
208
    def timeout_milliseconds(self):
 
209
        "Return the 'timeout' attribute in milliseconds"
 
210
        return ((self.timeout.days * 24 * 60 * 60 * 1000)
 
211
                + (self.timeout.seconds * 1000)
 
212
                + (self.timeout.microseconds // 1000))
 
213
    
 
214
    def interval_milliseconds(self):
 
215
        "Return the 'interval' attribute in milliseconds"
 
216
        return ((self.interval.days * 24 * 60 * 60 * 1000)
 
217
                + (self.interval.seconds * 1000)
 
218
                + (self.interval.microseconds // 1000))
 
219
    
 
220
    def __init__(self, name = None, disable_hook=None, config=None,
 
221
                 use_dbus=True):
243
222
        """Note: the 'checker' key in 'config' sets the
244
223
        'checker_command' attribute and *not* the 'checker'
245
224
        attribute."""
246
 
        self.dbus_object_path = (dbus.ObjectPath
247
 
                                 ("/Mandos/clients/"
248
 
                                  + name.replace(".", "_")))
249
 
        dbus.service.Object.__init__(self, bus,
250
 
                                     self.dbus_object_path)
 
225
        self.name = name
251
226
        if config is None:
252
227
            config = {}
253
 
        self.name = name
254
228
        logger.debug(u"Creating client %r", self.name)
 
229
        self.use_dbus = False   # During __init__
255
230
        # Uppercase and remove spaces from fingerprint for later
256
231
        # comparison purposes with return value from the fingerprint()
257
232
        # function
281
256
        self.disable_initiator_tag = None
282
257
        self.checker_callback_tag = None
283
258
        self.checker_command = config["checker"]
 
259
        self.last_connect = None
 
260
        # Only now, when this client is initialized, can it show up on
 
261
        # the D-Bus
 
262
        self.use_dbus = use_dbus
 
263
        if self.use_dbus:
 
264
            self.dbus_object_path = (dbus.ObjectPath
 
265
                                     ("/clients/"
 
266
                                      + self.name.replace(".", "_")))
 
267
            dbus.service.Object.__init__(self, bus,
 
268
                                         self.dbus_object_path)
284
269
    
285
270
    def enable(self):
286
271
        """Start this client's checker and timeout hooks"""
288
273
        # Schedule a new checker to be started an 'interval' from now,
289
274
        # and every interval from then on.
290
275
        self.checker_initiator_tag = (gobject.timeout_add
291
 
                                      (self._interval_milliseconds,
 
276
                                      (self.interval_milliseconds(),
292
277
                                       self.start_checker))
293
278
        # Also start a new checker *right now*.
294
279
        self.start_checker()
295
280
        # Schedule a disable() when 'timeout' has passed
296
281
        self.disable_initiator_tag = (gobject.timeout_add
297
 
                                   (self._timeout_milliseconds,
 
282
                                   (self.timeout_milliseconds(),
298
283
                                    self.disable))
299
284
        self.enabled = True
300
 
        # Emit D-Bus signal
301
 
        self.PropertyChanged(dbus.String(u"enabled"),
302
 
                             dbus.Boolean(True, variant_level=1))
303
 
        self.PropertyChanged(dbus.String(u"last_enabled"),
304
 
                             (_datetime_to_dbus(self.last_enabled,
305
 
                                                variant_level=1)))
 
285
        if self.use_dbus:
 
286
            # Emit D-Bus signals
 
287
            self.PropertyChanged(dbus.String(u"enabled"),
 
288
                                 dbus.Boolean(True, variant_level=1))
 
289
            self.PropertyChanged(dbus.String(u"last_enabled"),
 
290
                                 (_datetime_to_dbus(self.last_enabled,
 
291
                                                    variant_level=1)))
306
292
    
307
293
    def disable(self):
308
294
        """Disable this client."""
319
305
        if self.disable_hook:
320
306
            self.disable_hook(self)
321
307
        self.enabled = False
322
 
        # Emit D-Bus signal
323
 
        self.PropertyChanged(dbus.String(u"enabled"),
324
 
                             dbus.Boolean(False, variant_level=1))
 
308
        if self.use_dbus:
 
309
            # Emit D-Bus signal
 
310
            self.PropertyChanged(dbus.String(u"enabled"),
 
311
                                 dbus.Boolean(False, variant_level=1))
325
312
        # Do not run this again if called by a gobject.timeout_add
326
313
        return False
327
314
    
333
320
        """The checker has completed, so take appropriate actions."""
334
321
        self.checker_callback_tag = None
335
322
        self.checker = None
336
 
        # Emit D-Bus signal
337
 
        self.PropertyChanged(dbus.String(u"checker_running"),
338
 
                             dbus.Boolean(False, variant_level=1))
339
 
        if (os.WIFEXITED(condition)
340
 
            and (os.WEXITSTATUS(condition) == 0)):
341
 
            logger.info(u"Checker for %(name)s succeeded",
342
 
                        vars(self))
 
323
        if self.use_dbus:
343
324
            # Emit D-Bus signal
344
 
            self.CheckerCompleted(dbus.Boolean(True),
345
 
                                  dbus.UInt16(condition),
346
 
                                  dbus.String(command))
347
 
            self.bump_timeout()
348
 
        elif not os.WIFEXITED(condition):
 
325
            self.PropertyChanged(dbus.String(u"checker_running"),
 
326
                                 dbus.Boolean(False, variant_level=1))
 
327
        if os.WIFEXITED(condition):
 
328
            exitstatus = os.WEXITSTATUS(condition)
 
329
            if exitstatus == 0:
 
330
                logger.info(u"Checker for %(name)s succeeded",
 
331
                            vars(self))
 
332
                self.bump_timeout()
 
333
            else:
 
334
                logger.info(u"Checker for %(name)s failed",
 
335
                            vars(self))
 
336
            if self.use_dbus:
 
337
                # Emit D-Bus signal
 
338
                self.CheckerCompleted(dbus.Int16(exitstatus),
 
339
                                      dbus.Int64(condition),
 
340
                                      dbus.String(command))
 
341
        else:
349
342
            logger.warning(u"Checker for %(name)s crashed?",
350
343
                           vars(self))
351
 
            # Emit D-Bus signal
352
 
            self.CheckerCompleted(dbus.Boolean(False),
353
 
                                  dbus.UInt16(condition),
354
 
                                  dbus.String(command))
355
 
        else:
356
 
            logger.info(u"Checker for %(name)s failed",
357
 
                        vars(self))
358
 
            # Emit D-Bus signal
359
 
            self.CheckerCompleted(dbus.Boolean(False),
360
 
                                  dbus.UInt16(condition),
361
 
                                  dbus.String(command))
 
344
            if self.use_dbus:
 
345
                # Emit D-Bus signal
 
346
                self.CheckerCompleted(dbus.Int16(-1),
 
347
                                      dbus.Int64(condition),
 
348
                                      dbus.String(command))
362
349
    
363
350
    def bump_timeout(self):
364
351
        """Bump up the timeout for this client.
368
355
        self.last_checked_ok = datetime.datetime.utcnow()
369
356
        gobject.source_remove(self.disable_initiator_tag)
370
357
        self.disable_initiator_tag = (gobject.timeout_add
371
 
                                      (self._timeout_milliseconds,
 
358
                                      (self.timeout_milliseconds(),
372
359
                                       self.disable))
373
 
        self.PropertyChanged(dbus.String(u"last_checked_ok"),
374
 
                             (_datetime_to_dbus(self.last_checked_ok,
375
 
                                                variant_level=1)))
 
360
        if self.use_dbus:
 
361
            # Emit D-Bus signal
 
362
            self.PropertyChanged(
 
363
                dbus.String(u"last_checked_ok"),
 
364
                (_datetime_to_dbus(self.last_checked_ok,
 
365
                                   variant_level=1)))
376
366
    
377
367
    def start_checker(self):
378
368
        """Start a new checker subprocess if one is not running.
411
401
                self.checker = subprocess.Popen(command,
412
402
                                                close_fds=True,
413
403
                                                shell=True, cwd="/")
414
 
                # Emit D-Bus signal
415
 
                self.CheckerStarted(command)
416
 
                self.PropertyChanged(dbus.String("checker_running"),
417
 
                                     dbus.Boolean(True, variant_level=1))
 
404
                if self.use_dbus:
 
405
                    # Emit D-Bus signal
 
406
                    self.CheckerStarted(command)
 
407
                    self.PropertyChanged(
 
408
                        dbus.String("checker_running"),
 
409
                        dbus.Boolean(True, variant_level=1))
418
410
                self.checker_callback_tag = (gobject.child_watch_add
419
411
                                             (self.checker.pid,
420
412
                                              self.checker_callback,
442
434
            if error.errno != errno.ESRCH: # No such process
443
435
                raise
444
436
        self.checker = None
445
 
        self.PropertyChanged(dbus.String(u"checker_running"),
446
 
                             dbus.Boolean(False, variant_level=1))
 
437
        if self.use_dbus:
 
438
            self.PropertyChanged(dbus.String(u"checker_running"),
 
439
                                 dbus.Boolean(False, variant_level=1))
447
440
    
448
441
    def still_valid(self):
449
442
        """Has the timeout not yet passed for this client?"""
456
449
            return now < (self.last_checked_ok + self.timeout)
457
450
    
458
451
    ## D-Bus methods & signals
459
 
    _interface = u"org.mandos_system.Mandos.Client"
 
452
    _interface = u"se.bsnet.fukt.Mandos.Client"
460
453
    
461
454
    # BumpTimeout - method
462
455
    BumpTimeout = dbus.service.method(_interface)(bump_timeout)
463
456
    BumpTimeout.__name__ = "BumpTimeout"
464
457
    
465
458
    # CheckerCompleted - signal
466
 
    @dbus.service.signal(_interface, signature="bqs")
467
 
    def CheckerCompleted(self, success, condition, command):
 
459
    @dbus.service.signal(_interface, signature="nxs")
 
460
    def CheckerCompleted(self, exitcode, waitstatus, command):
468
461
        "D-Bus signal"
469
462
        pass
470
463
    
500
493
                     if self.last_checked_ok is not None
501
494
                     else dbus.Boolean (False, variant_level=1)),
502
495
                dbus.String("timeout"):
503
 
                    dbus.UInt64(self._timeout_milliseconds,
 
496
                    dbus.UInt64(self.timeout_milliseconds(),
504
497
                                variant_level=1),
505
498
                dbus.String("interval"):
506
 
                    dbus.UInt64(self._interval_milliseconds,
 
499
                    dbus.UInt64(self.interval_milliseconds(),
507
500
                                variant_level=1),
508
501
                dbus.String("checker"):
509
502
                    dbus.String(self.checker_command,
511
504
                dbus.String("checker_running"):
512
505
                    dbus.Boolean(self.checker is not None,
513
506
                                 variant_level=1),
 
507
                dbus.String("object_path"):
 
508
                    dbus.ObjectPath(self.dbus_object_path,
 
509
                                    variant_level=1)
514
510
                }, signature="sv")
515
511
    
516
512
    # IsStillValid - method
529
525
    def SetChecker(self, checker):
530
526
        "D-Bus setter method"
531
527
        self.checker_command = checker
 
528
        # Emit D-Bus signal
 
529
        self.PropertyChanged(dbus.String(u"checker"),
 
530
                             dbus.String(self.checker_command,
 
531
                                         variant_level=1))
532
532
    
533
533
    # SetHost - method
534
534
    @dbus.service.method(_interface, in_signature="s")
535
535
    def SetHost(self, host):
536
536
        "D-Bus setter method"
537
537
        self.host = host
 
538
        # Emit D-Bus signal
 
539
        self.PropertyChanged(dbus.String(u"host"),
 
540
                             dbus.String(self.host, variant_level=1))
538
541
    
539
542
    # SetInterval - method
540
543
    @dbus.service.method(_interface, in_signature="t")
541
544
    def SetInterval(self, milliseconds):
542
 
        self.interval = datetime.timdeelta(0, 0, 0, milliseconds)
 
545
        self.interval = datetime.timedelta(0, 0, 0, milliseconds)
 
546
        # Emit D-Bus signal
 
547
        self.PropertyChanged(dbus.String(u"interval"),
 
548
                             (dbus.UInt64(self.interval_milliseconds(),
 
549
                                          variant_level=1)))
543
550
    
544
551
    # SetSecret - method
545
552
    @dbus.service.method(_interface, in_signature="ay",
552
559
    @dbus.service.method(_interface, in_signature="t")
553
560
    def SetTimeout(self, milliseconds):
554
561
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
 
562
        # Emit D-Bus signal
 
563
        self.PropertyChanged(dbus.String(u"timeout"),
 
564
                             (dbus.UInt64(self.timeout_milliseconds(),
 
565
                                          variant_level=1)))
555
566
    
556
567
    # Enable - method
557
568
    Enable = dbus.service.method(_interface)(enable)
833
844
    elif state == avahi.ENTRY_GROUP_FAILURE:
834
845
        logger.critical(u"Avahi: Error in group state changed %s",
835
846
                        unicode(error))
836
 
        raise AvahiGroupError("State changed: %s", str(error))
 
847
        raise AvahiGroupError(u"State changed: %s" % unicode(error))
837
848
 
838
849
def if_nametoindex(interface):
839
850
    """Call the C function if_nametoindex(), or equivalent"""
882
893
 
883
894
 
884
895
def main():
885
 
    parser = OptionParser(version = "%%prog %s" % version)
 
896
    parser = optparse.OptionParser(version = "%%prog %s" % version)
886
897
    parser.add_option("-i", "--interface", type="string",
887
898
                      metavar="IF", help="Bind to interface IF")
888
899
    parser.add_option("-a", "--address", type="string",
889
900
                      help="Address to listen for requests on")
890
901
    parser.add_option("-p", "--port", type="int",
891
902
                      help="Port number to receive requests on")
892
 
    parser.add_option("--check", action="store_true", default=False,
 
903
    parser.add_option("--check", action="store_true",
893
904
                      help="Run self-test")
894
905
    parser.add_option("--debug", action="store_true",
895
906
                      help="Debug mode; run in foreground and log to"
902
913
                      default="/etc/mandos", metavar="DIR",
903
914
                      help="Directory to search for configuration"
904
915
                      " files")
 
916
    parser.add_option("--no-dbus", action="store_false",
 
917
                      dest="use_dbus",
 
918
                      help="Do not provide D-Bus system bus"
 
919
                      " interface")
905
920
    options = parser.parse_args()[0]
906
921
    
907
922
    if options.check:
917
932
                        "priority":
918
933
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
919
934
                        "servicename": "Mandos",
 
935
                        "use_dbus": "True",
920
936
                        }
921
937
    
922
938
    # Parse config file for server-global settings
925
941
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
926
942
    # Convert the SafeConfigParser object to a dict
927
943
    server_settings = server_config.defaults()
928
 
    # Use getboolean on the boolean config option
 
944
    # Use getboolean on the boolean config options
929
945
    server_settings["debug"] = (server_config.getboolean
930
946
                                ("DEFAULT", "debug"))
 
947
    server_settings["use_dbus"] = (server_config.getboolean
 
948
                                   ("DEFAULT", "use_dbus"))
931
949
    del server_config
932
950
    
933
951
    # Override the settings from the config file with command line
934
952
    # options, if set.
935
953
    for option in ("interface", "address", "port", "debug",
936
 
                   "priority", "servicename", "configdir"):
 
954
                   "priority", "servicename", "configdir",
 
955
                   "use_dbus"):
937
956
        value = getattr(options, option)
938
957
        if value is not None:
939
958
            server_settings[option] = value
940
959
    del options
941
960
    # Now we have our good server settings in "server_settings"
942
961
    
 
962
    # For convenience
943
963
    debug = server_settings["debug"]
 
964
    use_dbus = server_settings["use_dbus"]
944
965
    
945
966
    if not debug:
946
967
        syslogger.setLevel(logging.WARNING)
955
976
    # Parse config file with clients
956
977
    client_defaults = { "timeout": "1h",
957
978
                        "interval": "5m",
958
 
                        "checker": "fping -q -- %(host)s",
 
979
                        "checker": "fping -q -- %%(host)s",
959
980
                        "host": "",
960
981
                        }
961
982
    client_config = ConfigParser.SafeConfigParser(client_defaults)
976
997
    
977
998
    try:
978
999
        uid = pwd.getpwnam("_mandos").pw_uid
 
1000
        gid = pwd.getpwnam("_mandos").pw_gid
979
1001
    except KeyError:
980
1002
        try:
981
1003
            uid = pwd.getpwnam("mandos").pw_uid
 
1004
            gid = pwd.getpwnam("mandos").pw_gid
982
1005
        except KeyError:
983
1006
            try:
984
1007
                uid = pwd.getpwnam("nobody").pw_uid
 
1008
                gid = pwd.getpwnam("nogroup").pw_gid
985
1009
            except KeyError:
986
1010
                uid = 65534
987
 
    try:
988
 
        gid = pwd.getpwnam("_mandos").pw_gid
989
 
    except KeyError:
990
 
        try:
991
 
            gid = pwd.getpwnam("mandos").pw_gid
992
 
        except KeyError:
993
 
            try:
994
 
                gid = pwd.getpwnam("nogroup").pw_gid
995
 
            except KeyError:
996
1011
                gid = 65534
997
1012
    try:
998
1013
        os.setuid(uid)
1019
1034
                                           avahi.DBUS_PATH_SERVER),
1020
1035
                            avahi.DBUS_INTERFACE_SERVER)
1021
1036
    # End of Avahi example code
1022
 
    bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)
 
1037
    if use_dbus:
 
1038
        bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1023
1039
    
1024
1040
    clients.update(Set(Client(name = section,
1025
1041
                              config
1026
 
                              = dict(client_config.items(section)))
 
1042
                              = dict(client_config.items(section)),
 
1043
                              use_dbus = use_dbus)
1027
1044
                       for section in client_config.sections()))
1028
1045
    if not clients:
1029
 
        logger.critical(u"No clients defined")
1030
 
        sys.exit(1)
 
1046
        logger.warning(u"No clients defined")
1031
1047
    
1032
1048
    if debug:
1033
1049
        # Redirect stdin so all checkers get /dev/null
1075
1091
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1076
1092
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1077
1093
    
1078
 
    class MandosServer(dbus.service.Object):
1079
 
        """A D-Bus proxy object"""
1080
 
        def __init__(self):
1081
 
            dbus.service.Object.__init__(self, bus,
1082
 
                                         "/Mandos")
1083
 
        _interface = u"org.mandos_system.Mandos"
1084
 
        
1085
 
        @dbus.service.signal(_interface, signature="oa{sv}")
1086
 
        def ClientAdded(self, objpath, properties):
1087
 
            "D-Bus signal"
1088
 
            pass
1089
 
        
1090
 
        @dbus.service.signal(_interface, signature="o")
1091
 
        def ClientRemoved(self, objpath):
1092
 
            "D-Bus signal"
1093
 
            pass
1094
 
        
1095
 
        @dbus.service.method(_interface, out_signature="ao")
1096
 
        def GetAllClients(self):
1097
 
            return dbus.Array(c.dbus_object_path for c in clients)
1098
 
        
1099
 
        @dbus.service.method(_interface, out_signature="a{oa{sv}}")
1100
 
        def GetAllClientsWithProperties(self):
1101
 
            return dbus.Dictionary(
1102
 
                ((c.dbus_object_path, c.GetAllProperties())
1103
 
                 for c in clients),
1104
 
                signature="oa{sv}")
1105
 
        
1106
 
        @dbus.service.method(_interface, in_signature="o")
1107
 
        def RemoveClient(self, object_path):
1108
 
            for c in clients:
1109
 
                if c.dbus_object_path == object_path:
1110
 
                    c.disable()
1111
 
                    clients.remove(c)
1112
 
                    return
1113
 
            raise KeyError
1114
 
        
1115
 
        del _interface
1116
 
    
1117
 
    mandos_server = MandosServer()
 
1094
    if use_dbus:
 
1095
        class MandosServer(dbus.service.Object):
 
1096
            """A D-Bus proxy object"""
 
1097
            def __init__(self):
 
1098
                dbus.service.Object.__init__(self, bus, "/")
 
1099
            _interface = u"se.bsnet.fukt.Mandos"
 
1100
            
 
1101
            @dbus.service.signal(_interface, signature="oa{sv}")
 
1102
            def ClientAdded(self, objpath, properties):
 
1103
                "D-Bus signal"
 
1104
                pass
 
1105
            
 
1106
            @dbus.service.signal(_interface, signature="os")
 
1107
            def ClientRemoved(self, objpath, name):
 
1108
                "D-Bus signal"
 
1109
                pass
 
1110
            
 
1111
            @dbus.service.method(_interface, out_signature="ao")
 
1112
            def GetAllClients(self):
 
1113
                return dbus.Array(c.dbus_object_path for c in clients)
 
1114
            
 
1115
            @dbus.service.method(_interface, out_signature="a{oa{sv}}")
 
1116
            def GetAllClientsWithProperties(self):
 
1117
                return dbus.Dictionary(
 
1118
                    ((c.dbus_object_path, c.GetAllProperties())
 
1119
                     for c in clients),
 
1120
                    signature="oa{sv}")
 
1121
            
 
1122
            @dbus.service.method(_interface, in_signature="o")
 
1123
            def RemoveClient(self, object_path):
 
1124
                for c in clients:
 
1125
                    if c.dbus_object_path == object_path:
 
1126
                        clients.remove(c)
 
1127
                        # Don't signal anything except ClientRemoved
 
1128
                        c.use_dbus = False
 
1129
                        c.disable()
 
1130
                        # Emit D-Bus signal
 
1131
                        self.ClientRemoved(object_path, c.name)
 
1132
                        return
 
1133
                raise KeyError
 
1134
            
 
1135
            del _interface
 
1136
        
 
1137
        mandos_server = MandosServer()
1118
1138
    
1119
1139
    for client in clients:
1120
 
        # Emit D-Bus signal
1121
 
        mandos_server.ClientAdded(client.dbus_object_path,
1122
 
                                  client.GetAllProperties())
 
1140
        if use_dbus:
 
1141
            # Emit D-Bus signal
 
1142
            mandos_server.ClientAdded(client.dbus_object_path,
 
1143
                                      client.GetAllProperties())
1123
1144
        client.enable()
1124
1145
    
1125
1146
    tcp_server.enable()
1150
1171
        logger.debug(u"Starting main loop")
1151
1172
        main_loop.run()
1152
1173
    except AvahiError, error:
1153
 
        logger.critical(u"AvahiError: %s" + unicode(error))
 
1174
        logger.critical(u"AvahiError: %s", error)
1154
1175
        sys.exit(1)
1155
1176
    except KeyboardInterrupt:
1156
1177
        if debug: