/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

working new feature: network-hooks - Enables user-scripts to take up
                     interfaces during bootup

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008-2012 Teddy Hogeborn
15
 
# Copyright © 2008-2012 Björn Påhlsson
 
14
# Copyright © 2008-2011 Teddy Hogeborn
 
15
# Copyright © 2008-2011 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
34
34
from __future__ import (division, absolute_import, print_function,
35
35
                        unicode_literals)
36
36
 
37
 
from future_builtins import *
38
 
 
39
37
import SocketServer as socketserver
40
38
import socket
41
39
import argparse
67
65
import types
68
66
import binascii
69
67
import tempfile
70
 
import itertools
71
 
import collections
72
68
 
73
69
import dbus
74
70
import dbus.service
89
85
    except ImportError:
90
86
        SO_BINDTODEVICE = None
91
87
 
92
 
version = "1.6.0"
 
88
version = "1.4.1"
93
89
stored_state_file = "clients.pickle"
94
90
 
95
91
logger = logging.getLogger()
114
110
        return interface_index
115
111
 
116
112
 
117
 
def initlogger(debug, level=logging.WARNING):
 
113
def initlogger(level=logging.WARNING):
118
114
    """init logger and add loglevel"""
119
115
    
120
116
    syslogger.setFormatter(logging.Formatter
122
118
                            ' %(message)s'))
123
119
    logger.addHandler(syslogger)
124
120
    
125
 
    if debug:
126
 
        console = logging.StreamHandler()
127
 
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
128
 
                                               ' [%(process)d]:'
129
 
                                               ' %(levelname)s:'
130
 
                                               ' %(message)s'))
131
 
        logger.addHandler(console)
 
121
    console = logging.StreamHandler()
 
122
    console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
 
123
                                           ' [%(process)d]:'
 
124
                                           ' %(levelname)s:'
 
125
                                           ' %(message)s'))
 
126
    logger.addHandler(console)
132
127
    logger.setLevel(level)
133
128
 
134
129
 
146
141
        self.gnupg.options.meta_interactive = False
147
142
        self.gnupg.options.homedir = self.tempdir
148
143
        self.gnupg.options.extra_args.extend(['--force-mdc',
149
 
                                              '--quiet',
150
 
                                              '--no-use-agent'])
 
144
                                              '--quiet'])
151
145
    
152
146
    def __enter__(self):
153
147
        return self
154
148
    
155
 
    def __exit__(self, exc_type, exc_value, traceback):
 
149
    def __exit__ (self, exc_type, exc_value, traceback):
156
150
        self._cleanup()
157
151
        return False
158
152
    
179
173
    
180
174
    def encrypt(self, data, password):
181
175
        self.gnupg.passphrase = self.password_encode(password)
182
 
        with open(os.devnull, "w") as devnull:
 
176
        with open(os.devnull) as devnull:
183
177
            try:
184
178
                proc = self.gnupg.run(['--symmetric'],
185
179
                                      create_fhs=['stdin', 'stdout'],
196
190
    
197
191
    def decrypt(self, data, password):
198
192
        self.gnupg.passphrase = self.password_encode(password)
199
 
        with open(os.devnull, "w") as devnull:
 
193
        with open(os.devnull) as devnull:
200
194
            try:
201
195
                proc = self.gnupg.run(['--decrypt'],
202
196
                                      create_fhs=['stdin', 'stdout'],
203
197
                                      attach_fhs={'stderr': devnull})
204
 
                with contextlib.closing(proc.handles['stdin']) as f:
 
198
                with contextlib.closing(proc.handles['stdin'] ) as f:
205
199
                    f.write(data)
206
200
                with contextlib.closing(proc.handles['stdout']) as f:
207
201
                    decrypted_plaintext = f.read()
212
206
        return decrypted_plaintext
213
207
 
214
208
 
 
209
 
215
210
class AvahiError(Exception):
216
211
    def __init__(self, value, *args, **kwargs):
217
212
        self.value = value
246
241
    server: D-Bus Server
247
242
    bus: dbus.SystemBus()
248
243
    """
249
 
    
250
244
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
251
245
                 servicetype = None, port = None, TXT = None,
252
246
                 domain = "", host = "", max_renames = 32768,
265
259
        self.server = None
266
260
        self.bus = bus
267
261
        self.entry_group_state_changed_match = None
268
 
    
269
262
    def rename(self):
270
263
        """Derived from the Avahi example code"""
271
264
        if self.rename_count >= self.max_renames:
281
274
        try:
282
275
            self.add()
283
276
        except dbus.exceptions.DBusException as error:
284
 
            logger.critical("D-Bus Exception", exc_info=error)
 
277
            logger.critical("DBusException: %s", error)
285
278
            self.cleanup()
286
279
            os._exit(1)
287
280
        self.rename_count += 1
288
 
    
289
281
    def remove(self):
290
282
        """Derived from the Avahi example code"""
291
283
        if self.entry_group_state_changed_match is not None:
293
285
            self.entry_group_state_changed_match = None
294
286
        if self.group is not None:
295
287
            self.group.Reset()
296
 
    
297
288
    def add(self):
298
289
        """Derived from the Avahi example code"""
299
290
        self.remove()
316
307
            dbus.UInt16(self.port),
317
308
            avahi.string_array_to_txt_array(self.TXT))
318
309
        self.group.Commit()
319
 
    
320
310
    def entry_group_state_changed(self, state, error):
321
311
        """Derived from the Avahi example code"""
322
312
        logger.debug("Avahi entry group state change: %i", state)
329
319
        elif state == avahi.ENTRY_GROUP_FAILURE:
330
320
            logger.critical("Avahi: Error in group state changed %s",
331
321
                            unicode(error))
332
 
            raise AvahiGroupError("State changed: {0!s}"
333
 
                                  .format(error))
334
 
    
 
322
            raise AvahiGroupError("State changed: %s"
 
323
                                  % unicode(error))
335
324
    def cleanup(self):
336
325
        """Derived from the Avahi example code"""
337
326
        if self.group is not None:
342
331
                pass
343
332
            self.group = None
344
333
        self.remove()
345
 
    
346
334
    def server_state_changed(self, state, error=None):
347
335
        """Derived from the Avahi example code"""
348
336
        logger.debug("Avahi server state change: %i", state)
367
355
                logger.debug("Unknown state: %r", state)
368
356
            else:
369
357
                logger.debug("Unknown state: %r: %r", state, error)
370
 
    
371
358
    def activate(self):
372
359
        """Derived from the Avahi example code"""
373
360
        if self.server is None:
380
367
                                 self.server_state_changed)
381
368
        self.server_state_changed(self.server.GetState())
382
369
 
383
 
 
384
370
class AvahiServiceToSyslog(AvahiService):
385
371
    def rename(self):
386
372
        """Add the new name to the syslog messages"""
387
373
        ret = AvahiService.rename(self)
388
374
        syslogger.setFormatter(logging.Formatter
389
 
                               ('Mandos ({0}) [%(process)d]:'
390
 
                                ' %(levelname)s: %(message)s'
391
 
                                .format(self.name)))
 
375
                               ('Mandos (%s) [%%(process)d]:'
 
376
                                ' %%(levelname)s: %%(message)s'
 
377
                                % self.name))
392
378
        return ret
393
379
 
394
 
 
395
380
def timedelta_to_milliseconds(td):
396
381
    "Convert a datetime.timedelta() to milliseconds"
397
382
    return ((td.days * 24 * 60 * 60 * 1000)
398
383
            + (td.seconds * 1000)
399
384
            + (td.microseconds // 1000))
400
 
 
401
 
 
 
385
        
402
386
class Client(object):
403
387
    """A representation of a client host served by this server.
404
388
    
429
413
    last_checked_ok: datetime.datetime(); (UTC) or None
430
414
    last_checker_status: integer between 0 and 255 reflecting exit
431
415
                         status of last checker. -1 reflects crashed
432
 
                         checker, -2 means no checker completed yet.
 
416
                         checker, or None.
433
417
    last_enabled: datetime.datetime(); (UTC) or None
434
418
    name:       string; from the config file, used in log messages and
435
419
                        D-Bus identifiers
436
420
    secret:     bytestring; sent verbatim (over TLS) to client
437
421
    timeout:    datetime.timedelta(); How long from last_checked_ok
438
422
                                      until this client is disabled
439
 
    extended_timeout:   extra long timeout when secret has been sent
 
423
    extended_timeout:   extra long timeout when password has been sent
440
424
    runtime_expansions: Allowed attributes for runtime expansion.
441
425
    expires:    datetime.datetime(); time (UTC) when a client will be
442
426
                disabled, or None
443
427
    """
444
428
    
445
429
    runtime_expansions = ("approval_delay", "approval_duration",
446
 
                          "created", "enabled", "expires",
447
 
                          "fingerprint", "host", "interval",
448
 
                          "last_approval_request", "last_checked_ok",
 
430
                          "created", "enabled", "fingerprint",
 
431
                          "host", "interval", "last_checked_ok",
449
432
                          "last_enabled", "name", "timeout")
450
 
    client_defaults = { "timeout": "PT5M",
451
 
                        "extended_timeout": "PT15M",
452
 
                        "interval": "PT2M",
 
433
    client_defaults = { "timeout": "5m",
 
434
                        "extended_timeout": "15m",
 
435
                        "interval": "2m",
453
436
                        "checker": "fping -q -- %%(host)s",
454
437
                        "host": "",
455
 
                        "approval_delay": "PT0S",
456
 
                        "approval_duration": "PT1S",
 
438
                        "approval_delay": "0s",
 
439
                        "approval_duration": "1s",
457
440
                        "approved_by_default": "True",
458
441
                        "enabled": "True",
459
442
                        }
472
455
    
473
456
    def approval_delay_milliseconds(self):
474
457
        return timedelta_to_milliseconds(self.approval_delay)
475
 
    
 
458
 
476
459
    @staticmethod
477
460
    def config_parser(config):
478
 
        """Construct a new dict of client settings of this form:
 
461
        """ Construct a new dict of client settings of this form:
479
462
        { client_name: {setting_name: value, ...}, ...}
480
 
        with exceptions for any special settings as defined above.
481
 
        NOTE: Must be a pure function. Must return the same result
482
 
        value given the same arguments.
483
 
        """
 
463
        with exceptions for any special settings as defined above"""
484
464
        settings = {}
485
465
        for client_name in config.sections():
486
466
            section = dict(config.items(client_name))
490
470
            # Reformat values from string types to Python types
491
471
            client["approved_by_default"] = config.getboolean(
492
472
                client_name, "approved_by_default")
493
 
            client["enabled"] = config.getboolean(client_name,
494
 
                                                  "enabled")
 
473
            client["enabled"] = config.getboolean(client_name, "enabled")
495
474
            
496
475
            client["fingerprint"] = (section["fingerprint"].upper()
497
476
                                     .replace(" ", ""))
503
482
                          "rb") as secfile:
504
483
                    client["secret"] = secfile.read()
505
484
            else:
506
 
                raise TypeError("No secret or secfile for section {0}"
507
 
                                .format(section))
 
485
                raise TypeError("No secret or secfile for section %s"
 
486
                                % section)
508
487
            client["timeout"] = string_to_delta(section["timeout"])
509
488
            client["extended_timeout"] = string_to_delta(
510
489
                section["extended_timeout"])
516
495
            client["checker_command"] = section["checker"]
517
496
            client["last_approval_request"] = None
518
497
            client["last_checked_ok"] = None
519
 
            client["last_checker_status"] = -2
520
 
        
 
498
            client["last_checker_status"] = None
 
499
            if client["enabled"]:
 
500
                client["last_enabled"] = datetime.datetime.utcnow()
 
501
                client["expires"] = (datetime.datetime.utcnow()
 
502
                                     + client["timeout"])
 
503
            else:
 
504
                client["last_enabled"] = None
 
505
                client["expires"] = None
 
506
 
521
507
        return settings
522
 
    
 
508
        
 
509
        
523
510
    def __init__(self, settings, name = None):
 
511
        """Note: the 'checker' key in 'config' sets the
 
512
        'checker_command' attribute and *not* the 'checker'
 
513
        attribute."""
524
514
        self.name = name
525
515
        # adding all client settings
526
516
        for setting, value in settings.iteritems():
527
517
            setattr(self, setting, value)
528
518
        
529
 
        if self.enabled:
530
 
            if not hasattr(self, "last_enabled"):
531
 
                self.last_enabled = datetime.datetime.utcnow()
532
 
            if not hasattr(self, "expires"):
533
 
                self.expires = (datetime.datetime.utcnow()
534
 
                                + self.timeout)
535
 
        else:
536
 
            self.last_enabled = None
537
 
            self.expires = None
538
 
        
539
519
        logger.debug("Creating client %r", self.name)
540
520
        # Uppercase and remove spaces from fingerprint for later
541
521
        # comparison purposes with return value from the fingerprint()
542
522
        # function
543
523
        logger.debug("  Fingerprint: %s", self.fingerprint)
544
 
        self.created = settings.get("created",
545
 
                                    datetime.datetime.utcnow())
546
 
        
 
524
        self.created = settings.get("created", datetime.datetime.utcnow())
 
525
 
547
526
        # attributes specific for this server instance
548
527
        self.checker = None
549
528
        self.checker_initiator_tag = None
577
556
        if getattr(self, "enabled", False):
578
557
            # Already enabled
579
558
            return
 
559
        self.send_changedstate()
580
560
        self.expires = datetime.datetime.utcnow() + self.timeout
581
561
        self.enabled = True
582
562
        self.last_enabled = datetime.datetime.utcnow()
583
563
        self.init_checker()
584
 
        self.send_changedstate()
585
564
    
586
565
    def disable(self, quiet=True):
587
566
        """Disable this client."""
588
567
        if not getattr(self, "enabled", False):
589
568
            return False
590
569
        if not quiet:
 
570
            self.send_changedstate()
 
571
        if not quiet:
591
572
            logger.info("Disabling client %s", self.name)
592
 
        if getattr(self, "disable_initiator_tag", None) is not None:
 
573
        if getattr(self, "disable_initiator_tag", False):
593
574
            gobject.source_remove(self.disable_initiator_tag)
594
575
            self.disable_initiator_tag = None
595
576
        self.expires = None
596
 
        if getattr(self, "checker_initiator_tag", None) is not None:
 
577
        if getattr(self, "checker_initiator_tag", False):
597
578
            gobject.source_remove(self.checker_initiator_tag)
598
579
            self.checker_initiator_tag = None
599
580
        self.stop_checker()
600
581
        self.enabled = False
601
 
        if not quiet:
602
 
            self.send_changedstate()
603
582
        # Do not run this again if called by a gobject.timeout_add
604
583
        return False
605
584
    
609
588
    def init_checker(self):
610
589
        # Schedule a new checker to be started an 'interval' from now,
611
590
        # and every interval from then on.
612
 
        if self.checker_initiator_tag is not None:
613
 
            gobject.source_remove(self.checker_initiator_tag)
614
591
        self.checker_initiator_tag = (gobject.timeout_add
615
592
                                      (self.interval_milliseconds(),
616
593
                                       self.start_checker))
617
594
        # Schedule a disable() when 'timeout' has passed
618
 
        if self.disable_initiator_tag is not None:
619
 
            gobject.source_remove(self.disable_initiator_tag)
620
595
        self.disable_initiator_tag = (gobject.timeout_add
621
596
                                   (self.timeout_milliseconds(),
622
597
                                    self.disable))
641
616
            logger.warning("Checker for %(name)s crashed?",
642
617
                           vars(self))
643
618
    
644
 
    def checked_ok(self):
645
 
        """Assert that the client has been seen, alive and well."""
646
 
        self.last_checked_ok = datetime.datetime.utcnow()
647
 
        self.last_checker_status = 0
648
 
        self.bump_timeout()
649
 
    
650
 
    def bump_timeout(self, timeout=None):
651
 
        """Bump up the timeout for this client."""
 
619
    def checked_ok(self, timeout=None):
 
620
        """Bump up the timeout for this client.
 
621
        
 
622
        This should only be called when the client has been seen,
 
623
        alive and well.
 
624
        """
652
625
        if timeout is None:
653
626
            timeout = self.timeout
 
627
        self.last_checked_ok = datetime.datetime.utcnow()
654
628
        if self.disable_initiator_tag is not None:
655
629
            gobject.source_remove(self.disable_initiator_tag)
656
 
            self.disable_initiator_tag = None
657
630
        if getattr(self, "enabled", False):
658
631
            self.disable_initiator_tag = (gobject.timeout_add
659
632
                                          (timedelta_to_milliseconds
669
642
        If a checker already exists, leave it running and do
670
643
        nothing."""
671
644
        # The reason for not killing a running checker is that if we
672
 
        # did that, and if a checker (for some reason) started running
673
 
        # slowly and taking more than 'interval' time, then the client
674
 
        # would inevitably timeout, since no checker would get a
675
 
        # chance to run to completion.  If we instead leave running
 
645
        # did that, then if a checker (for some reason) started
 
646
        # running slowly and taking more than 'interval' time, the
 
647
        # client would inevitably timeout, since no checker would get
 
648
        # a chance to run to completion.  If we instead leave running
676
649
        # checkers alone, the checker would have to take more time
677
650
        # than 'timeout' for the client to be disabled, which is as it
678
651
        # should be.
692
665
                                      self.current_checker_command)
693
666
        # Start a new checker if needed
694
667
        if self.checker is None:
695
 
            # Escape attributes for the shell
696
 
            escaped_attrs = dict(
697
 
                (attr, re.escape(unicode(getattr(self, attr))))
698
 
                for attr in
699
 
                self.runtime_expansions)
700
668
            try:
701
 
                command = self.checker_command % escaped_attrs
702
 
            except TypeError as error:
703
 
                logger.error('Could not format string "%s"',
704
 
                             self.checker_command, exc_info=error)
705
 
                return True # Try again later
 
669
                # In case checker_command has exactly one % operator
 
670
                command = self.checker_command % self.host
 
671
            except TypeError:
 
672
                # Escape attributes for the shell
 
673
                escaped_attrs = dict(
 
674
                    (attr,
 
675
                     re.escape(unicode(str(getattr(self, attr, "")),
 
676
                                       errors=
 
677
                                       'replace')))
 
678
                    for attr in
 
679
                    self.runtime_expansions)
 
680
                
 
681
                try:
 
682
                    command = self.checker_command % escaped_attrs
 
683
                except TypeError as error:
 
684
                    logger.error('Could not format string "%s":'
 
685
                                 ' %s', self.checker_command, error)
 
686
                    return True # Try again later
706
687
            self.current_checker_command = command
707
688
            try:
708
689
                logger.info("Starting checker %r for %s",
714
695
                self.checker = subprocess.Popen(command,
715
696
                                                close_fds=True,
716
697
                                                shell=True, cwd="/")
 
698
                self.checker_callback_tag = (gobject.child_watch_add
 
699
                                             (self.checker.pid,
 
700
                                              self.checker_callback,
 
701
                                              data=command))
 
702
                # The checker may have completed before the gobject
 
703
                # watch was added.  Check for this.
 
704
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
705
                if pid:
 
706
                    gobject.source_remove(self.checker_callback_tag)
 
707
                    self.checker_callback(pid, status, command)
717
708
            except OSError as error:
718
 
                logger.error("Failed to start subprocess",
719
 
                             exc_info=error)
720
 
            self.checker_callback_tag = (gobject.child_watch_add
721
 
                                         (self.checker.pid,
722
 
                                          self.checker_callback,
723
 
                                          data=command))
724
 
            # The checker may have completed before the gobject
725
 
            # watch was added.  Check for this.
726
 
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
727
 
            if pid:
728
 
                gobject.source_remove(self.checker_callback_tag)
729
 
                self.checker_callback(pid, status, command)
 
709
                logger.error("Failed to start subprocess: %s",
 
710
                             error)
730
711
        # Re-run this periodically if run by gobject.timeout_add
731
712
        return True
732
713
    
739
720
            return
740
721
        logger.debug("Stopping checker for %(name)s", vars(self))
741
722
        try:
742
 
            self.checker.terminate()
 
723
            os.kill(self.checker.pid, signal.SIGTERM)
743
724
            #time.sleep(0.5)
744
725
            #if self.checker.poll() is None:
745
 
            #    self.checker.kill()
 
726
            #    os.kill(self.checker.pid, signal.SIGKILL)
746
727
        except OSError as error:
747
728
            if error.errno != errno.ESRCH: # No such process
748
729
                raise
765
746
    # "Set" method, so we fail early here:
766
747
    if byte_arrays and signature != "ay":
767
748
        raise ValueError("Byte arrays not supported for non-'ay'"
768
 
                         " signature {0!r}".format(signature))
 
749
                         " signature %r" % signature)
769
750
    def decorator(func):
770
751
        func._dbus_is_property = True
771
752
        func._dbus_interface = dbus_interface
779
760
    return decorator
780
761
 
781
762
 
782
 
def dbus_interface_annotations(dbus_interface):
783
 
    """Decorator for marking functions returning interface annotations
784
 
    
785
 
    Usage:
786
 
    
787
 
    @dbus_interface_annotations("org.example.Interface")
788
 
    def _foo(self):  # Function name does not matter
789
 
        return {"org.freedesktop.DBus.Deprecated": "true",
790
 
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
791
 
                    "false"}
792
 
    """
793
 
    def decorator(func):
794
 
        func._dbus_is_interface = True
795
 
        func._dbus_interface = dbus_interface
796
 
        func._dbus_name = dbus_interface
797
 
        return func
798
 
    return decorator
799
 
 
800
 
 
801
 
def dbus_annotations(annotations):
802
 
    """Decorator to annotate D-Bus methods, signals or properties
803
 
    Usage:
804
 
    
805
 
    @dbus_service_property("org.example.Interface", signature="b",
806
 
                           access="r")
807
 
    @dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
808
 
                        "org.freedesktop.DBus.Property."
809
 
                        "EmitsChangedSignal": "false"})
810
 
    def Property_dbus_property(self):
811
 
        return dbus.Boolean(False)
812
 
    """
813
 
    def decorator(func):
814
 
        func._dbus_annotations = annotations
815
 
        return func
816
 
    return decorator
817
 
 
818
 
 
819
763
class DBusPropertyException(dbus.exceptions.DBusException):
820
764
    """A base class for D-Bus property-related exceptions
821
765
    """
844
788
    """
845
789
    
846
790
    @staticmethod
847
 
    def _is_dbus_thing(thing):
848
 
        """Returns a function testing if an attribute is a D-Bus thing
849
 
        
850
 
        If called like _is_dbus_thing("method") it returns a function
851
 
        suitable for use as predicate to inspect.getmembers().
852
 
        """
853
 
        return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
854
 
                                   False)
 
791
    def _is_dbus_property(obj):
 
792
        return getattr(obj, "_dbus_is_property", False)
855
793
    
856
 
    def _get_all_dbus_things(self, thing):
 
794
    def _get_all_dbus_properties(self):
857
795
        """Returns a generator of (name, attribute) pairs
858
796
        """
859
 
        return ((getattr(athing.__get__(self), "_dbus_name",
860
 
                         name),
861
 
                 athing.__get__(self))
 
797
        return ((prop.__get__(self)._dbus_name, prop.__get__(self))
862
798
                for cls in self.__class__.__mro__
863
 
                for name, athing in
864
 
                inspect.getmembers(cls,
865
 
                                   self._is_dbus_thing(thing)))
 
799
                for name, prop in
 
800
                inspect.getmembers(cls, self._is_dbus_property))
866
801
    
867
802
    def _get_dbus_property(self, interface_name, property_name):
868
803
        """Returns a bound method if one exists which is a D-Bus
870
805
        """
871
806
        for cls in  self.__class__.__mro__:
872
807
            for name, value in (inspect.getmembers
873
 
                                (cls,
874
 
                                 self._is_dbus_thing("property"))):
 
808
                                (cls, self._is_dbus_property)):
875
809
                if (value._dbus_name == property_name
876
810
                    and value._dbus_interface == interface_name):
877
811
                    return value.__get__(self)
906
840
            # signatures other than "ay".
907
841
            if prop._dbus_signature != "ay":
908
842
                raise ValueError
909
 
            value = dbus.ByteArray(b''.join(chr(byte)
910
 
                                            for byte in value))
 
843
            value = dbus.ByteArray(''.join(unichr(byte)
 
844
                                           for byte in value))
911
845
        prop(value)
912
846
    
913
847
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
919
853
        Note: Will not include properties with access="write".
920
854
        """
921
855
        properties = {}
922
 
        for name, prop in self._get_all_dbus_things("property"):
 
856
        for name, prop in self._get_all_dbus_properties():
923
857
            if (interface_name
924
858
                and interface_name != prop._dbus_interface):
925
859
                # Interface non-empty but did not match
940
874
                         path_keyword='object_path',
941
875
                         connection_keyword='connection')
942
876
    def Introspect(self, object_path, connection):
943
 
        """Overloading of standard D-Bus method.
944
 
        
945
 
        Inserts property tags and interface annotation tags.
 
877
        """Standard D-Bus method, overloaded to insert property tags.
946
878
        """
947
879
        xmlstring = dbus.service.Object.Introspect(self, object_path,
948
880
                                                   connection)
955
887
                e.setAttribute("access", prop._dbus_access)
956
888
                return e
957
889
            for if_tag in document.getElementsByTagName("interface"):
958
 
                # Add property tags
959
890
                for tag in (make_tag(document, name, prop)
960
891
                            for name, prop
961
 
                            in self._get_all_dbus_things("property")
 
892
                            in self._get_all_dbus_properties()
962
893
                            if prop._dbus_interface
963
894
                            == if_tag.getAttribute("name")):
964
895
                    if_tag.appendChild(tag)
965
 
                # Add annotation tags
966
 
                for typ in ("method", "signal", "property"):
967
 
                    for tag in if_tag.getElementsByTagName(typ):
968
 
                        annots = dict()
969
 
                        for name, prop in (self.
970
 
                                           _get_all_dbus_things(typ)):
971
 
                            if (name == tag.getAttribute("name")
972
 
                                and prop._dbus_interface
973
 
                                == if_tag.getAttribute("name")):
974
 
                                annots.update(getattr
975
 
                                              (prop,
976
 
                                               "_dbus_annotations",
977
 
                                               {}))
978
 
                        for name, value in annots.iteritems():
979
 
                            ann_tag = document.createElement(
980
 
                                "annotation")
981
 
                            ann_tag.setAttribute("name", name)
982
 
                            ann_tag.setAttribute("value", value)
983
 
                            tag.appendChild(ann_tag)
984
 
                # Add interface annotation tags
985
 
                for annotation, value in dict(
986
 
                    itertools.chain.from_iterable(
987
 
                        annotations().iteritems()
988
 
                        for name, annotations in
989
 
                        self._get_all_dbus_things("interface")
990
 
                        if name == if_tag.getAttribute("name")
991
 
                        )).iteritems():
992
 
                    ann_tag = document.createElement("annotation")
993
 
                    ann_tag.setAttribute("name", annotation)
994
 
                    ann_tag.setAttribute("value", value)
995
 
                    if_tag.appendChild(ann_tag)
996
896
                # Add the names to the return values for the
997
897
                # "org.freedesktop.DBus.Properties" methods
998
898
                if (if_tag.getAttribute("name")
1013
913
        except (AttributeError, xml.dom.DOMException,
1014
914
                xml.parsers.expat.ExpatError) as error:
1015
915
            logger.error("Failed to override Introspection method",
1016
 
                         exc_info=error)
 
916
                         error)
1017
917
        return xmlstring
1018
918
 
1019
919
 
1020
 
def datetime_to_dbus(dt, variant_level=0):
 
920
def datetime_to_dbus (dt, variant_level=0):
1021
921
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1022
922
    if dt is None:
1023
923
        return dbus.String("", variant_level = variant_level)
1025
925
                       variant_level=variant_level)
1026
926
 
1027
927
 
1028
 
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1029
 
    """A class decorator; applied to a subclass of
1030
 
    dbus.service.Object, it will add alternate D-Bus attributes with
1031
 
    interface names according to the "alt_interface_names" mapping.
1032
 
    Usage:
1033
 
    
1034
 
    @alternate_dbus_interfaces({"org.example.Interface":
1035
 
                                    "net.example.AlternateInterface"})
1036
 
    class SampleDBusObject(dbus.service.Object):
1037
 
        @dbus.service.method("org.example.Interface")
1038
 
        def SampleDBusMethod():
1039
 
            pass
1040
 
    
1041
 
    The above "SampleDBusMethod" on "SampleDBusObject" will be
1042
 
    reachable via two interfaces: "org.example.Interface" and
1043
 
    "net.example.AlternateInterface", the latter of which will have
1044
 
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1045
 
    "true", unless "deprecate" is passed with a False value.
1046
 
    
1047
 
    This works for methods and signals, and also for D-Bus properties
1048
 
    (from DBusObjectWithProperties) and interfaces (from the
1049
 
    dbus_interface_annotations decorator).
 
928
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
 
929
                                  .__metaclass__):
 
930
    """Applied to an empty subclass of a D-Bus object, this metaclass
 
931
    will add additional D-Bus attributes matching a certain pattern.
1050
932
    """
1051
 
    def wrapper(cls):
1052
 
        for orig_interface_name, alt_interface_name in (
1053
 
            alt_interface_names.iteritems()):
1054
 
            attr = {}
1055
 
            interface_names = set()
1056
 
            # Go though all attributes of the class
1057
 
            for attrname, attribute in inspect.getmembers(cls):
 
933
    def __new__(mcs, name, bases, attr):
 
934
        # Go through all the base classes which could have D-Bus
 
935
        # methods, signals, or properties in them
 
936
        for base in (b for b in bases
 
937
                     if issubclass(b, dbus.service.Object)):
 
938
            # Go though all attributes of the base class
 
939
            for attrname, attribute in inspect.getmembers(base):
1058
940
                # Ignore non-D-Bus attributes, and D-Bus attributes
1059
941
                # with the wrong interface name
1060
942
                if (not hasattr(attribute, "_dbus_interface")
1061
943
                    or not attribute._dbus_interface
1062
 
                    .startswith(orig_interface_name)):
 
944
                    .startswith("se.recompile.Mandos")):
1063
945
                    continue
1064
946
                # Create an alternate D-Bus interface name based on
1065
947
                # the current name
1066
948
                alt_interface = (attribute._dbus_interface
1067
 
                                 .replace(orig_interface_name,
1068
 
                                          alt_interface_name))
1069
 
                interface_names.add(alt_interface)
 
949
                                 .replace("se.recompile.Mandos",
 
950
                                          "se.bsnet.fukt.Mandos"))
1070
951
                # Is this a D-Bus signal?
1071
952
                if getattr(attribute, "_dbus_is_signal", False):
1072
953
                    # Extract the original non-method function by
1087
968
                                nonmethod_func.func_name,
1088
969
                                nonmethod_func.func_defaults,
1089
970
                                nonmethod_func.func_closure)))
1090
 
                    # Copy annotations, if any
1091
 
                    try:
1092
 
                        new_function._dbus_annotations = (
1093
 
                            dict(attribute._dbus_annotations))
1094
 
                    except AttributeError:
1095
 
                        pass
1096
971
                    # Define a creator of a function to call both the
1097
 
                    # original and alternate functions, so both the
1098
 
                    # original and alternate signals gets sent when
1099
 
                    # the function is called
 
972
                    # old and new functions, so both the old and new
 
973
                    # signals gets sent when the function is called
1100
974
                    def fixscope(func1, func2):
1101
975
                        """This function is a scope container to pass
1102
976
                        func1 and func2 to the "call_both" function
1109
983
                        return call_both
1110
984
                    # Create the "call_both" function and add it to
1111
985
                    # the class
1112
 
                    attr[attrname] = fixscope(attribute, new_function)
 
986
                    attr[attrname] = fixscope(attribute,
 
987
                                              new_function)
1113
988
                # Is this a D-Bus method?
1114
989
                elif getattr(attribute, "_dbus_is_method", False):
1115
990
                    # Create a new, but exactly alike, function
1126
1001
                                        attribute.func_name,
1127
1002
                                        attribute.func_defaults,
1128
1003
                                        attribute.func_closure)))
1129
 
                    # Copy annotations, if any
1130
 
                    try:
1131
 
                        attr[attrname]._dbus_annotations = (
1132
 
                            dict(attribute._dbus_annotations))
1133
 
                    except AttributeError:
1134
 
                        pass
1135
1004
                # Is this a D-Bus property?
1136
1005
                elif getattr(attribute, "_dbus_is_property", False):
1137
1006
                    # Create a new, but exactly alike, function
1151
1020
                                        attribute.func_name,
1152
1021
                                        attribute.func_defaults,
1153
1022
                                        attribute.func_closure)))
1154
 
                    # Copy annotations, if any
1155
 
                    try:
1156
 
                        attr[attrname]._dbus_annotations = (
1157
 
                            dict(attribute._dbus_annotations))
1158
 
                    except AttributeError:
1159
 
                        pass
1160
 
                # Is this a D-Bus interface?
1161
 
                elif getattr(attribute, "_dbus_is_interface", False):
1162
 
                    # Create a new, but exactly alike, function
1163
 
                    # object.  Decorate it to be a new D-Bus interface
1164
 
                    # with the alternate D-Bus interface name.  Add it
1165
 
                    # to the class.
1166
 
                    attr[attrname] = (dbus_interface_annotations
1167
 
                                      (alt_interface)
1168
 
                                      (types.FunctionType
1169
 
                                       (attribute.func_code,
1170
 
                                        attribute.func_globals,
1171
 
                                        attribute.func_name,
1172
 
                                        attribute.func_defaults,
1173
 
                                        attribute.func_closure)))
1174
 
            if deprecate:
1175
 
                # Deprecate all alternate interfaces
1176
 
                iname="_AlternateDBusNames_interface_annotation{0}"
1177
 
                for interface_name in interface_names:
1178
 
                    @dbus_interface_annotations(interface_name)
1179
 
                    def func(self):
1180
 
                        return { "org.freedesktop.DBus.Deprecated":
1181
 
                                     "true" }
1182
 
                    # Find an unused name
1183
 
                    for aname in (iname.format(i)
1184
 
                                  for i in itertools.count()):
1185
 
                        if aname not in attr:
1186
 
                            attr[aname] = func
1187
 
                            break
1188
 
            if interface_names:
1189
 
                # Replace the class with a new subclass of it with
1190
 
                # methods, signals, etc. as created above.
1191
 
                cls = type(b"{0}Alternate".format(cls.__name__),
1192
 
                           (cls,), attr)
1193
 
        return cls
1194
 
    return wrapper
1195
 
 
1196
 
 
1197
 
@alternate_dbus_interfaces({"se.recompile.Mandos":
1198
 
                                "se.bsnet.fukt.Mandos"})
 
1023
        return type.__new__(mcs, name, bases, attr)
 
1024
 
 
1025
 
1199
1026
class ClientDBus(Client, DBusObjectWithProperties):
1200
1027
    """A Client class using D-Bus
1201
1028
    
1212
1039
    def __init__(self, bus = None, *args, **kwargs):
1213
1040
        self.bus = bus
1214
1041
        Client.__init__(self, *args, **kwargs)
 
1042
        self._approvals_pending = 0
 
1043
        
 
1044
        self._approvals_pending = 0
1215
1045
        # Only now, when this client is initialized, can it show up on
1216
1046
        # the D-Bus
1217
1047
        client_object_name = unicode(self.name).translate(
1221
1051
                                 ("/clients/" + client_object_name))
1222
1052
        DBusObjectWithProperties.__init__(self, self.bus,
1223
1053
                                          self.dbus_object_path)
1224
 
    
 
1054
        
1225
1055
    def notifychangeproperty(transform_func,
1226
1056
                             dbus_name, type_func=lambda x: x,
1227
1057
                             variant_level=1):
1250
1080
        
1251
1081
        return property(lambda self: getattr(self, attrname), setter)
1252
1082
    
 
1083
    
1253
1084
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1254
1085
    approvals_pending = notifychangeproperty(dbus.Boolean,
1255
1086
                                             "ApprovalPending",
1262
1093
                                       checker is not None)
1263
1094
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
1264
1095
                                           "LastCheckedOK")
1265
 
    last_checker_status = notifychangeproperty(dbus.Int16,
1266
 
                                               "LastCheckerStatus")
1267
1096
    last_approval_request = notifychangeproperty(
1268
1097
        datetime_to_dbus, "LastApprovalRequest")
1269
1098
    approved_by_default = notifychangeproperty(dbus.Boolean,
1337
1166
        return False
1338
1167
    
1339
1168
    def approve(self, value=True):
 
1169
        self.send_changedstate()
1340
1170
        self.approved = value
1341
1171
        gobject.timeout_add(timedelta_to_milliseconds
1342
1172
                            (self.approval_duration),
1343
1173
                            self._reset_approved)
1344
 
        self.send_changedstate()
 
1174
    
1345
1175
    
1346
1176
    ## D-Bus methods, signals & properties
1347
1177
    _interface = "se.recompile.Mandos.Client"
1348
1178
    
1349
 
    ## Interfaces
1350
 
    
1351
 
    @dbus_interface_annotations(_interface)
1352
 
    def _foo(self):
1353
 
        return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
1354
 
                     "false"}
1355
 
    
1356
1179
    ## Signals
1357
1180
    
1358
1181
    # CheckerCompleted - signal
1394
1217
        "D-Bus signal"
1395
1218
        return self.need_approval()
1396
1219
    
 
1220
    # NeRwequest - signal
 
1221
    @dbus.service.signal(_interface, signature="s")
 
1222
    def NewRequest(self, ip):
 
1223
        """D-Bus signal
 
1224
        Is sent after a client request a password.
 
1225
        """
 
1226
        pass
 
1227
    
1397
1228
    ## Methods
1398
1229
    
1399
1230
    # Approve - method
1509
1340
            return
1510
1341
        return datetime_to_dbus(self.last_checked_ok)
1511
1342
    
1512
 
    # LastCheckerStatus - property
1513
 
    @dbus_service_property(_interface, signature="n",
1514
 
                           access="read")
1515
 
    def LastCheckerStatus_dbus_property(self):
1516
 
        return dbus.Int16(self.last_checker_status)
1517
 
    
1518
1343
    # Expires - property
1519
1344
    @dbus_service_property(_interface, signature="s", access="read")
1520
1345
    def Expires_dbus_property(self):
1531
1356
    def Timeout_dbus_property(self, value=None):
1532
1357
        if value is None:       # get
1533
1358
            return dbus.UInt64(self.timeout_milliseconds())
1534
 
        old_timeout = self.timeout
1535
1359
        self.timeout = datetime.timedelta(0, 0, 0, value)
1536
 
        # Reschedule disabling
1537
 
        if self.enabled:
1538
 
            now = datetime.datetime.utcnow()
1539
 
            self.expires += self.timeout - old_timeout
1540
 
            if self.expires <= now:
1541
 
                # The timeout has passed
1542
 
                self.disable()
1543
 
            else:
1544
 
                if (getattr(self, "disable_initiator_tag", None)
1545
 
                    is None):
1546
 
                    return
1547
 
                gobject.source_remove(self.disable_initiator_tag)
1548
 
                self.disable_initiator_tag = (
1549
 
                    gobject.timeout_add(
1550
 
                        timedelta_to_milliseconds(self.expires - now),
1551
 
                        self.disable))
 
1360
        if getattr(self, "disable_initiator_tag", None) is None:
 
1361
            return
 
1362
        # Reschedule timeout
 
1363
        gobject.source_remove(self.disable_initiator_tag)
 
1364
        self.disable_initiator_tag = None
 
1365
        self.expires = None
 
1366
        time_to_die = timedelta_to_milliseconds((self
 
1367
                                                 .last_checked_ok
 
1368
                                                 + self.timeout)
 
1369
                                                - datetime.datetime
 
1370
                                                .utcnow())
 
1371
        if time_to_die <= 0:
 
1372
            # The timeout has passed
 
1373
            self.disable()
 
1374
        else:
 
1375
            self.expires = (datetime.datetime.utcnow()
 
1376
                            + datetime.timedelta(milliseconds =
 
1377
                                                 time_to_die))
 
1378
            self.disable_initiator_tag = (gobject.timeout_add
 
1379
                                          (time_to_die, self.disable))
1552
1380
    
1553
1381
    # ExtendedTimeout - property
1554
1382
    @dbus_service_property(_interface, signature="t",
1633
1461
        self._pipe.send(('setattr', name, value))
1634
1462
 
1635
1463
 
 
1464
class ClientDBusTransitional(ClientDBus):
 
1465
    __metaclass__ = AlternateDBusNamesMetaclass
 
1466
 
 
1467
 
1636
1468
class ClientHandler(socketserver.BaseRequestHandler, object):
1637
1469
    """A class to handle client connections.
1638
1470
    
1706
1538
                except KeyError:
1707
1539
                    return
1708
1540
                
 
1541
                if self.server.use_dbus:
 
1542
                    # Emit D-Bus signal
 
1543
                    client.NewRequest(str(self.client_address))
 
1544
                
1709
1545
                if client.approval_delay:
1710
1546
                    delay = client.approval_delay
1711
1547
                    client.approvals_pending += 1
1742
1578
                    #wait until timeout or approved
1743
1579
                    time = datetime.datetime.now()
1744
1580
                    client.changedstate.acquire()
1745
 
                    client.changedstate.wait(
1746
 
                        float(timedelta_to_milliseconds(delay)
1747
 
                              / 1000))
 
1581
                    (client.changedstate.wait
 
1582
                     (float(client.timedelta_to_milliseconds(delay)
 
1583
                            / 1000)))
1748
1584
                    client.changedstate.release()
1749
1585
                    time2 = datetime.datetime.now()
1750
1586
                    if (time2 - time) >= delay:
1766
1602
                    try:
1767
1603
                        sent = session.send(client.secret[sent_size:])
1768
1604
                    except gnutls.errors.GNUTLSError as error:
1769
 
                        logger.warning("gnutls send failed",
1770
 
                                       exc_info=error)
 
1605
                        logger.warning("gnutls send failed")
1771
1606
                        return
1772
1607
                    logger.debug("Sent: %d, remaining: %d",
1773
1608
                                 sent, len(client.secret)
1776
1611
                
1777
1612
                logger.info("Sending secret to %s", client.name)
1778
1613
                # bump the timeout using extended_timeout
1779
 
                client.bump_timeout(client.extended_timeout)
 
1614
                client.checked_ok(client.extended_timeout)
1780
1615
                if self.server.use_dbus:
1781
1616
                    # Emit D-Bus signal
1782
1617
                    client.GotSecret()
1787
1622
                try:
1788
1623
                    session.bye()
1789
1624
                except gnutls.errors.GNUTLSError as error:
1790
 
                    logger.warning("GnuTLS bye failed",
1791
 
                                   exc_info=error)
 
1625
                    logger.warning("GnuTLS bye failed")
1792
1626
    
1793
1627
    @staticmethod
1794
1628
    def peer_certificate(session):
1866
1700
    def process_request(self, request, address):
1867
1701
        """Start a new process to process the request."""
1868
1702
        proc = multiprocessing.Process(target = self.sub_process_main,
1869
 
                                       args = (request, address))
 
1703
                                       args = (request,
 
1704
                                               address))
1870
1705
        proc.start()
1871
1706
        return proc
1872
1707
 
1900
1735
        use_ipv6:       Boolean; to use IPv6 or not
1901
1736
    """
1902
1737
    def __init__(self, server_address, RequestHandlerClass,
1903
 
                 interface=None, use_ipv6=True, socketfd=None):
1904
 
        """If socketfd is set, use that file descriptor instead of
1905
 
        creating a new one with socket.socket().
1906
 
        """
 
1738
                 interface=None, use_ipv6=True):
1907
1739
        self.interface = interface
1908
1740
        if use_ipv6:
1909
1741
            self.address_family = socket.AF_INET6
1910
 
        if socketfd is not None:
1911
 
            # Save the file descriptor
1912
 
            self.socketfd = socketfd
1913
 
            # Save the original socket.socket() function
1914
 
            self.socket_socket = socket.socket
1915
 
            # To implement --socket, we monkey patch socket.socket.
1916
 
            # 
1917
 
            # (When socketserver.TCPServer is a new-style class, we
1918
 
            # could make self.socket into a property instead of monkey
1919
 
            # patching socket.socket.)
1920
 
            # 
1921
 
            # Create a one-time-only replacement for socket.socket()
1922
 
            @functools.wraps(socket.socket)
1923
 
            def socket_wrapper(*args, **kwargs):
1924
 
                # Restore original function so subsequent calls are
1925
 
                # not affected.
1926
 
                socket.socket = self.socket_socket
1927
 
                del self.socket_socket
1928
 
                # This time only, return a new socket object from the
1929
 
                # saved file descriptor.
1930
 
                return socket.fromfd(self.socketfd, *args, **kwargs)
1931
 
            # Replace socket.socket() function with wrapper
1932
 
            socket.socket = socket_wrapper
1933
 
        # The socketserver.TCPServer.__init__ will call
1934
 
        # socket.socket(), which might be our replacement,
1935
 
        # socket_wrapper(), if socketfd was set.
1936
1742
        socketserver.TCPServer.__init__(self, server_address,
1937
1743
                                        RequestHandlerClass)
1938
 
    
1939
1744
    def server_bind(self):
1940
1745
        """This overrides the normal server_bind() function
1941
1746
        to bind to an interface if one was specified, and also NOT to
1949
1754
                try:
1950
1755
                    self.socket.setsockopt(socket.SOL_SOCKET,
1951
1756
                                           SO_BINDTODEVICE,
1952
 
                                           str(self.interface + '\0'))
 
1757
                                           str(self.interface
 
1758
                                               + '\0'))
1953
1759
                except socket.error as error:
1954
 
                    if error.errno == errno.EPERM:
1955
 
                        logger.error("No permission to bind to"
1956
 
                                     " interface %s", self.interface)
1957
 
                    elif error.errno == errno.ENOPROTOOPT:
 
1760
                    if error[0] == errno.EPERM:
 
1761
                        logger.error("No permission to"
 
1762
                                     " bind to interface %s",
 
1763
                                     self.interface)
 
1764
                    elif error[0] == errno.ENOPROTOOPT:
1958
1765
                        logger.error("SO_BINDTODEVICE not available;"
1959
1766
                                     " cannot bind to interface %s",
1960
1767
                                     self.interface)
1961
 
                    elif error.errno == errno.ENODEV:
1962
 
                        logger.error("Interface %s does not exist,"
1963
 
                                     " cannot bind", self.interface)
1964
1768
                    else:
1965
1769
                        raise
1966
1770
        # Only bind(2) the socket if we really need to.
1996
1800
    """
1997
1801
    def __init__(self, server_address, RequestHandlerClass,
1998
1802
                 interface=None, use_ipv6=True, clients=None,
1999
 
                 gnutls_priority=None, use_dbus=True, socketfd=None):
 
1803
                 gnutls_priority=None, use_dbus=True):
2000
1804
        self.enabled = False
2001
1805
        self.clients = clients
2002
1806
        if self.clients is None:
2006
1810
        IPv6_TCPServer.__init__(self, server_address,
2007
1811
                                RequestHandlerClass,
2008
1812
                                interface = interface,
2009
 
                                use_ipv6 = use_ipv6,
2010
 
                                socketfd = socketfd)
 
1813
                                use_ipv6 = use_ipv6)
2011
1814
    def server_activate(self):
2012
1815
        if self.enabled:
2013
1816
            return socketserver.TCPServer.server_activate(self)
2026
1829
    
2027
1830
    def handle_ipc(self, source, condition, parent_pipe=None,
2028
1831
                   proc = None, client_object=None):
 
1832
        condition_names = {
 
1833
            gobject.IO_IN: "IN",   # There is data to read.
 
1834
            gobject.IO_OUT: "OUT", # Data can be written (without
 
1835
                                    # blocking).
 
1836
            gobject.IO_PRI: "PRI", # There is urgent data to read.
 
1837
            gobject.IO_ERR: "ERR", # Error condition.
 
1838
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
 
1839
                                    # broken, usually for pipes and
 
1840
                                    # sockets).
 
1841
            }
 
1842
        conditions_string = ' | '.join(name
 
1843
                                       for cond, name in
 
1844
                                       condition_names.iteritems()
 
1845
                                       if cond & condition)
2029
1846
        # error, or the other end of multiprocessing.Pipe has closed
2030
 
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
 
1847
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2031
1848
            # Wait for other process to exit
2032
1849
            proc.join()
2033
1850
            return False
2091
1908
        return True
2092
1909
 
2093
1910
 
2094
 
def rfc3339_duration_to_delta(duration):
2095
 
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2096
 
    
2097
 
    >>> rfc3339_duration_to_delta("P7D")
2098
 
    datetime.timedelta(7)
2099
 
    >>> rfc3339_duration_to_delta("PT60S")
2100
 
    datetime.timedelta(0, 60)
2101
 
    >>> rfc3339_duration_to_delta("PT60M")
2102
 
    datetime.timedelta(0, 3600)
2103
 
    >>> rfc3339_duration_to_delta("PT24H")
2104
 
    datetime.timedelta(1)
2105
 
    >>> rfc3339_duration_to_delta("P1W")
2106
 
    datetime.timedelta(7)
2107
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2108
 
    datetime.timedelta(0, 330)
2109
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2110
 
    datetime.timedelta(1, 200)
2111
 
    """
2112
 
    
2113
 
    # Parsing an RFC 3339 duration with regular expressions is not
2114
 
    # possible - there would have to be multiple places for the same
2115
 
    # values, like seconds.  The current code, while more esoteric, is
2116
 
    # cleaner without depending on a parsing library.  If Python had a
2117
 
    # built-in library for parsing we would use it, but we'd like to
2118
 
    # avoid excessive use of external libraries.
2119
 
    
2120
 
    # New type for defining tokens, syntax, and semantics all-in-one
2121
 
    Token = collections.namedtuple("Token",
2122
 
                                   ("regexp", # To match token; if
2123
 
                                              # "value" is not None,
2124
 
                                              # must have a "group"
2125
 
                                              # containing digits
2126
 
                                    "value",  # datetime.timedelta or
2127
 
                                              # None
2128
 
                                    "followers")) # Tokens valid after
2129
 
                                                  # this token
2130
 
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
2131
 
    # the "duration" ABNF definition in RFC 3339, Appendix A.
2132
 
    token_end = Token(re.compile(r"$"), None, frozenset())
2133
 
    token_second = Token(re.compile(r"(\d+)S"),
2134
 
                         datetime.timedelta(seconds=1),
2135
 
                         frozenset((token_end,)))
2136
 
    token_minute = Token(re.compile(r"(\d+)M"),
2137
 
                         datetime.timedelta(minutes=1),
2138
 
                         frozenset((token_second, token_end)))
2139
 
    token_hour = Token(re.compile(r"(\d+)H"),
2140
 
                       datetime.timedelta(hours=1),
2141
 
                       frozenset((token_minute, token_end)))
2142
 
    token_time = Token(re.compile(r"T"),
2143
 
                       None,
2144
 
                       frozenset((token_hour, token_minute,
2145
 
                                  token_second)))
2146
 
    token_day = Token(re.compile(r"(\d+)D"),
2147
 
                      datetime.timedelta(days=1),
2148
 
                      frozenset((token_time, token_end)))
2149
 
    token_month = Token(re.compile(r"(\d+)M"),
2150
 
                        datetime.timedelta(weeks=4),
2151
 
                        frozenset((token_day, token_end)))
2152
 
    token_year = Token(re.compile(r"(\d+)Y"),
2153
 
                       datetime.timedelta(weeks=52),
2154
 
                       frozenset((token_month, token_end)))
2155
 
    token_week = Token(re.compile(r"(\d+)W"),
2156
 
                       datetime.timedelta(weeks=1),
2157
 
                       frozenset((token_end,)))
2158
 
    token_duration = Token(re.compile(r"P"), None,
2159
 
                           frozenset((token_year, token_month,
2160
 
                                      token_day, token_time,
2161
 
                                      token_week))),
2162
 
    # Define starting values
2163
 
    value = datetime.timedelta() # Value so far
2164
 
    found_token = None
2165
 
    followers = frozenset(token_duration,) # Following valid tokens
2166
 
    s = duration                # String left to parse
2167
 
    # Loop until end token is found
2168
 
    while found_token is not token_end:
2169
 
        # Search for any currently valid tokens
2170
 
        for token in followers:
2171
 
            match = token.regexp.match(s)
2172
 
            if match is not None:
2173
 
                # Token found
2174
 
                if token.value is not None:
2175
 
                    # Value found, parse digits
2176
 
                    factor = int(match.group(1), 10)
2177
 
                    # Add to value so far
2178
 
                    value += factor * token.value
2179
 
                # Strip token from string
2180
 
                s = token.regexp.sub("", s, 1)
2181
 
                # Go to found token
2182
 
                found_token = token
2183
 
                # Set valid next tokens
2184
 
                followers = found_token.followers
2185
 
                break
2186
 
        else:
2187
 
            # No currently valid tokens were found
2188
 
            raise ValueError("Invalid RFC 3339 duration")
2189
 
    # End token found
2190
 
    return value
2191
 
 
2192
 
 
2193
1911
def string_to_delta(interval):
2194
1912
    """Parse a string and return a datetime.timedelta
2195
1913
    
2206
1924
    >>> string_to_delta('5m 30s')
2207
1925
    datetime.timedelta(0, 330)
2208
1926
    """
2209
 
    
2210
 
    try:
2211
 
        return rfc3339_duration_to_delta(interval)
2212
 
    except ValueError:
2213
 
        pass
2214
 
    
2215
1927
    timevalue = datetime.timedelta(0)
2216
1928
    for s in interval.split():
2217
1929
        try:
2228
1940
            elif suffix == "w":
2229
1941
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2230
1942
            else:
2231
 
                raise ValueError("Unknown suffix {0!r}"
2232
 
                                 .format(suffix))
 
1943
                raise ValueError("Unknown suffix %r" % suffix)
2233
1944
        except (ValueError, IndexError) as e:
2234
1945
            raise ValueError(*(e.args))
2235
1946
        timevalue += delta
2249
1960
        sys.exit()
2250
1961
    if not noclose:
2251
1962
        # Close all standard open file descriptors
2252
 
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
 
1963
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2253
1964
        if not stat.S_ISCHR(os.fstat(null).st_mode):
2254
1965
            raise OSError(errno.ENODEV,
2255
 
                          "{0} not a character device"
2256
 
                          .format(os.devnull))
 
1966
                          "%s not a character device"
 
1967
                          % os.path.devnull)
2257
1968
        os.dup2(null, sys.stdin.fileno())
2258
1969
        os.dup2(null, sys.stdout.fileno())
2259
1970
        os.dup2(null, sys.stderr.fileno())
2268
1979
    
2269
1980
    parser = argparse.ArgumentParser()
2270
1981
    parser.add_argument("-v", "--version", action="version",
2271
 
                        version = "%(prog)s {0}".format(version),
 
1982
                        version = "%%(prog)s %s" % version,
2272
1983
                        help="show version number and exit")
2273
1984
    parser.add_argument("-i", "--interface", metavar="IF",
2274
1985
                        help="Bind to interface IF")
2299
2010
    parser.add_argument("--no-restore", action="store_false",
2300
2011
                        dest="restore", help="Do not restore stored"
2301
2012
                        " state")
2302
 
    parser.add_argument("--socket", type=int,
2303
 
                        help="Specify a file descriptor to a network"
2304
 
                        " socket to use instead of creating one")
2305
2013
    parser.add_argument("--statedir", metavar="DIR",
2306
2014
                        help="Directory to save/restore state in")
2307
 
    parser.add_argument("--foreground", action="store_true",
2308
 
                        help="Run in foreground")
2309
2015
    
2310
2016
    options = parser.parse_args()
2311
2017
    
2326
2032
                        "use_ipv6": "True",
2327
2033
                        "debuglevel": "",
2328
2034
                        "restore": "True",
2329
 
                        "socket": "",
2330
 
                        "statedir": "/var/lib/mandos",
2331
 
                        "foreground": "False",
 
2035
                        "statedir": "/var/lib/mandos"
2332
2036
                        }
2333
2037
    
2334
2038
    # Parse config file for server-global settings
2339
2043
    # Convert the SafeConfigParser object to a dict
2340
2044
    server_settings = server_config.defaults()
2341
2045
    # Use the appropriate methods on the non-string config options
2342
 
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
 
2046
    for option in ("debug", "use_dbus", "use_ipv6"):
2343
2047
        server_settings[option] = server_config.getboolean("DEFAULT",
2344
2048
                                                           option)
2345
2049
    if server_settings["port"]:
2346
2050
        server_settings["port"] = server_config.getint("DEFAULT",
2347
2051
                                                       "port")
2348
 
    if server_settings["socket"]:
2349
 
        server_settings["socket"] = server_config.getint("DEFAULT",
2350
 
                                                         "socket")
2351
 
        # Later, stdin will, and stdout and stderr might, be dup'ed
2352
 
        # over with an opened os.devnull.  But we don't want this to
2353
 
        # happen with a supplied network socket.
2354
 
        if 0 <= server_settings["socket"] <= 2:
2355
 
            server_settings["socket"] = os.dup(server_settings
2356
 
                                               ["socket"])
2357
2052
    del server_config
2358
2053
    
2359
2054
    # Override the settings from the config file with command line
2361
2056
    for option in ("interface", "address", "port", "debug",
2362
2057
                   "priority", "servicename", "configdir",
2363
2058
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2364
 
                   "statedir", "socket", "foreground"):
 
2059
                   "statedir"):
2365
2060
        value = getattr(options, option)
2366
2061
        if value is not None:
2367
2062
            server_settings[option] = value
2370
2065
    for option in server_settings.keys():
2371
2066
        if type(server_settings[option]) is str:
2372
2067
            server_settings[option] = unicode(server_settings[option])
2373
 
    # Debug implies foreground
2374
 
    if server_settings["debug"]:
2375
 
        server_settings["foreground"] = True
2376
2068
    # Now we have our good server settings in "server_settings"
2377
2069
    
2378
2070
    ##################################################################
2384
2076
    use_ipv6 = server_settings["use_ipv6"]
2385
2077
    stored_state_path = os.path.join(server_settings["statedir"],
2386
2078
                                     stored_state_file)
2387
 
    foreground = server_settings["foreground"]
2388
2079
    
2389
2080
    if debug:
2390
 
        initlogger(debug, logging.DEBUG)
 
2081
        initlogger(logging.DEBUG)
2391
2082
    else:
2392
2083
        if not debuglevel:
2393
 
            initlogger(debug)
 
2084
            initlogger()
2394
2085
        else:
2395
2086
            level = getattr(logging, debuglevel.upper())
2396
 
            initlogger(debug, level)
 
2087
            initlogger(level)
2397
2088
    
2398
2089
    if server_settings["servicename"] != "Mandos":
2399
2090
        syslogger.setFormatter(logging.Formatter
2400
 
                               ('Mandos ({0}) [%(process)d]:'
2401
 
                                ' %(levelname)s: %(message)s'
2402
 
                                .format(server_settings
2403
 
                                        ["servicename"])))
 
2091
                               ('Mandos (%s) [%%(process)d]:'
 
2092
                                ' %%(levelname)s: %%(message)s'
 
2093
                                % server_settings["servicename"]))
2404
2094
    
2405
2095
    # Parse config file with clients
2406
 
    client_config = configparser.SafeConfigParser(Client
2407
 
                                                  .client_defaults)
 
2096
    client_config = configparser.SafeConfigParser(Client.client_defaults)
2408
2097
    client_config.read(os.path.join(server_settings["configdir"],
2409
2098
                                    "clients.conf"))
2410
2099
    
2419
2108
                              use_ipv6=use_ipv6,
2420
2109
                              gnutls_priority=
2421
2110
                              server_settings["priority"],
2422
 
                              use_dbus=use_dbus,
2423
 
                              socketfd=(server_settings["socket"]
2424
 
                                        or None))
2425
 
    if not foreground:
 
2111
                              use_dbus=use_dbus)
 
2112
    if not debug:
2426
2113
        pidfilename = "/var/run/mandos.pid"
2427
 
        pidfile = None
2428
2114
        try:
2429
2115
            pidfile = open(pidfilename, "w")
2430
 
        except IOError as e:
2431
 
            logger.error("Could not open file %r", pidfilename,
2432
 
                         exc_info=e)
 
2116
        except IOError:
 
2117
            logger.error("Could not open file %r", pidfilename)
2433
2118
    
2434
 
    for name in ("_mandos", "mandos", "nobody"):
 
2119
    try:
 
2120
        uid = pwd.getpwnam("_mandos").pw_uid
 
2121
        gid = pwd.getpwnam("_mandos").pw_gid
 
2122
    except KeyError:
2435
2123
        try:
2436
 
            uid = pwd.getpwnam(name).pw_uid
2437
 
            gid = pwd.getpwnam(name).pw_gid
2438
 
            break
 
2124
            uid = pwd.getpwnam("mandos").pw_uid
 
2125
            gid = pwd.getpwnam("mandos").pw_gid
2439
2126
        except KeyError:
2440
 
            continue
2441
 
    else:
2442
 
        uid = 65534
2443
 
        gid = 65534
 
2127
            try:
 
2128
                uid = pwd.getpwnam("nobody").pw_uid
 
2129
                gid = pwd.getpwnam("nobody").pw_gid
 
2130
            except KeyError:
 
2131
                uid = 65534
 
2132
                gid = 65534
2444
2133
    try:
2445
2134
        os.setgid(gid)
2446
2135
        os.setuid(uid)
2447
2136
    except OSError as error:
2448
 
        if error.errno != errno.EPERM:
 
2137
        if error[0] != errno.EPERM:
2449
2138
            raise error
2450
2139
    
2451
2140
    if debug:
2463
2152
         .gnutls_global_set_log_function(debug_gnutls))
2464
2153
        
2465
2154
        # Redirect stdin so all checkers get /dev/null
2466
 
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
 
2155
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2467
2156
        os.dup2(null, sys.stdin.fileno())
2468
2157
        if null > 2:
2469
2158
            os.close(null)
 
2159
    else:
 
2160
        # No console logging
 
2161
        logger.removeHandler(console)
2470
2162
    
2471
2163
    # Need to fork before connecting to D-Bus
2472
 
    if not foreground:
 
2164
    if not debug:
2473
2165
        # Close all input and output, do double fork, etc.
2474
2166
        daemon()
2475
2167
    
2476
 
    # multiprocessing will use threads, so before we use gobject we
2477
 
    # need to inform gobject that threads will be used.
2478
 
    gobject.threads_init()
2479
 
    
2480
2168
    global main_loop
2481
2169
    # From the Avahi example code
2482
 
    DBusGMainLoop(set_as_default=True)
 
2170
    DBusGMainLoop(set_as_default=True )
2483
2171
    main_loop = gobject.MainLoop()
2484
2172
    bus = dbus.SystemBus()
2485
2173
    # End of Avahi example code
2491
2179
                            ("se.bsnet.fukt.Mandos", bus,
2492
2180
                             do_not_queue=True))
2493
2181
        except dbus.exceptions.NameExistsException as e:
2494
 
            logger.error("Disabling D-Bus:", exc_info=e)
 
2182
            logger.error(unicode(e) + ", disabling D-Bus")
2495
2183
            use_dbus = False
2496
2184
            server_settings["use_dbus"] = False
2497
2185
            tcp_server.use_dbus = False
2509
2197
    
2510
2198
    client_class = Client
2511
2199
    if use_dbus:
2512
 
        client_class = functools.partial(ClientDBus, bus = bus)
 
2200
        client_class = functools.partial(ClientDBusTransitional,
 
2201
                                         bus = bus)
2513
2202
    
2514
2203
    client_settings = Client.config_parser(client_config)
2515
2204
    old_client_settings = {}
2523
2212
                                                     (stored_state))
2524
2213
            os.remove(stored_state_path)
2525
2214
        except IOError as e:
2526
 
            if e.errno == errno.ENOENT:
2527
 
                logger.warning("Could not load persistent state: {0}"
2528
 
                                .format(os.strerror(e.errno)))
2529
 
            else:
2530
 
                logger.critical("Could not load persistent state:",
2531
 
                                exc_info=e)
 
2215
            logger.warning("Could not load persistent state: {0}"
 
2216
                           .format(e))
 
2217
            if e.errno != errno.ENOENT:
2532
2218
                raise
2533
 
        except EOFError as e:
2534
 
            logger.warning("Could not load persistent state: "
2535
 
                           "EOFError:", exc_info=e)
2536
2219
    
2537
2220
    with PGPEngine() as pgp:
2538
2221
        for client_name, client in clients_data.iteritems():
2555
2238
            
2556
2239
            # Clients who has passed its expire date can still be
2557
2240
            # enabled if its last checker was successful.  Clients
2558
 
            # whose checker succeeded before we stored its state is
2559
 
            # assumed to have successfully run all checkers during
2560
 
            # downtime.
 
2241
            # whose checker failed before we stored its state is
 
2242
            # assumed to have failed all checkers during downtime.
2561
2243
            if client["enabled"]:
2562
2244
                if datetime.datetime.utcnow() >= client["expires"]:
2563
2245
                    if not client["last_checked_ok"]:
2564
2246
                        logger.warning(
2565
2247
                            "disabling client {0} - Client never "
2566
 
                            "performed a successful checker"
2567
 
                            .format(client_name))
 
2248
                            "performed a successfull checker"
 
2249
                            .format(client["name"]))
2568
2250
                        client["enabled"] = False
2569
2251
                    elif client["last_checker_status"] != 0:
2570
2252
                        logger.warning(
2571
2253
                            "disabling client {0} - Client "
2572
2254
                            "last checker failed with error code {1}"
2573
 
                            .format(client_name,
 
2255
                            .format(client["name"],
2574
2256
                                    client["last_checker_status"]))
2575
2257
                        client["enabled"] = False
2576
2258
                    else:
2577
2259
                        client["expires"] = (datetime.datetime
2578
2260
                                             .utcnow()
2579
2261
                                             + client["timeout"])
2580
 
                        logger.debug("Last checker succeeded,"
2581
 
                                     " keeping {0} enabled"
2582
 
                                     .format(client_name))
 
2262
                    
2583
2263
            try:
2584
2264
                client["secret"] = (
2585
2265
                    pgp.decrypt(client["encrypted_secret"],
2591
2271
                             .format(client_name))
2592
2272
                client["secret"] = (
2593
2273
                    client_settings[client_name]["secret"])
 
2274
 
2594
2275
    
2595
2276
    # Add/remove clients based on new changes made to config
2596
 
    for client_name in (set(old_client_settings)
2597
 
                        - set(client_settings)):
 
2277
    for client_name in set(old_client_settings) - set(client_settings):
2598
2278
        del clients_data[client_name]
2599
 
    for client_name in (set(client_settings)
2600
 
                        - set(old_client_settings)):
 
2279
    for client_name in set(client_settings) - set(old_client_settings):
2601
2280
        clients_data[client_name] = client_settings[client_name]
2602
 
    
2603
 
    # Create all client objects
 
2281
 
 
2282
    # Create clients all clients
2604
2283
    for client_name, client in clients_data.iteritems():
2605
2284
        tcp_server.clients[client_name] = client_class(
2606
2285
            name = client_name, settings = client)
2607
2286
    
2608
2287
    if not tcp_server.clients:
2609
2288
        logger.warning("No clients defined")
2610
 
    
2611
 
    if not foreground:
2612
 
        if pidfile is not None:
2613
 
            try:
2614
 
                with pidfile:
2615
 
                    pid = os.getpid()
2616
 
                    pidfile.write(str(pid) + "\n".encode("utf-8"))
2617
 
            except IOError:
2618
 
                logger.error("Could not write to file %r with PID %d",
2619
 
                             pidfilename, pid)
2620
 
        del pidfile
 
2289
        
 
2290
    if not debug:
 
2291
        try:
 
2292
            with pidfile:
 
2293
                pid = os.getpid()
 
2294
                pidfile.write(str(pid) + "\n".encode("utf-8"))
 
2295
            del pidfile
 
2296
        except IOError:
 
2297
            logger.error("Could not write to file %r with PID %d",
 
2298
                         pidfilename, pid)
 
2299
        except NameError:
 
2300
            # "pidfile" was never created
 
2301
            pass
2621
2302
        del pidfilename
 
2303
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2622
2304
    
2623
2305
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2624
2306
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2625
2307
    
2626
2308
    if use_dbus:
2627
 
        @alternate_dbus_interfaces({"se.recompile.Mandos":
2628
 
                                        "se.bsnet.fukt.Mandos"})
2629
 
        class MandosDBusService(DBusObjectWithProperties):
 
2309
        class MandosDBusService(dbus.service.Object):
2630
2310
            """A D-Bus proxy object"""
2631
2311
            def __init__(self):
2632
2312
                dbus.service.Object.__init__(self, bus, "/")
2633
2313
            _interface = "se.recompile.Mandos"
2634
2314
            
2635
 
            @dbus_interface_annotations(_interface)
2636
 
            def _foo(self):
2637
 
                return { "org.freedesktop.DBus.Property"
2638
 
                         ".EmitsChangedSignal":
2639
 
                             "false"}
2640
 
            
2641
2315
            @dbus.service.signal(_interface, signature="o")
2642
2316
            def ClientAdded(self, objpath):
2643
2317
                "D-Bus signal"
2685
2359
            
2686
2360
            del _interface
2687
2361
        
2688
 
        mandos_dbus_service = MandosDBusService()
 
2362
        class MandosDBusServiceTransitional(MandosDBusService):
 
2363
            __metaclass__ = AlternateDBusNamesMetaclass
 
2364
        mandos_dbus_service = MandosDBusServiceTransitional()
2689
2365
    
2690
2366
    def cleanup():
2691
2367
        "Cleanup function; run on exit"
2724
2400
                del client_settings[client.name]["secret"]
2725
2401
        
2726
2402
        try:
2727
 
            with (tempfile.NamedTemporaryFile
2728
 
                  (mode='wb', suffix=".pickle", prefix='clients-',
2729
 
                   dir=os.path.dirname(stored_state_path),
2730
 
                   delete=False)) as stored_state:
 
2403
            with os.fdopen(os.open(stored_state_path,
 
2404
                                   os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
 
2405
                                   0600), "wb") as stored_state:
2731
2406
                pickle.dump((clients, client_settings), stored_state)
2732
 
                tempname=stored_state.name
2733
 
            os.rename(tempname, stored_state_path)
2734
2407
        except (IOError, OSError) as e:
2735
 
            if not debug:
2736
 
                try:
2737
 
                    os.remove(tempname)
2738
 
                except NameError:
2739
 
                    pass
2740
 
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2741
 
                logger.warning("Could not save persistent state: {0}"
2742
 
                               .format(os.strerror(e.errno)))
2743
 
            else:
2744
 
                logger.warning("Could not save persistent state:",
2745
 
                               exc_info=e)
2746
 
                raise e
 
2408
            logger.warning("Could not save persistent state: {0}"
 
2409
                           .format(e))
 
2410
            if e.errno not in (errno.ENOENT, errno.EACCES):
 
2411
                raise
2747
2412
        
2748
2413
        # Delete all clients, and settings from config
2749
2414
        while tcp_server.clients:
2776
2441
    service.port = tcp_server.socket.getsockname()[1]
2777
2442
    if use_ipv6:
2778
2443
        logger.info("Now listening on address %r, port %d,"
2779
 
                    " flowinfo %d, scope_id %d",
2780
 
                    *tcp_server.socket.getsockname())
 
2444
                    " flowinfo %d, scope_id %d"
 
2445
                    % tcp_server.socket.getsockname())
2781
2446
    else:                       # IPv4
2782
 
        logger.info("Now listening on address %r, port %d",
2783
 
                    *tcp_server.socket.getsockname())
 
2447
        logger.info("Now listening on address %r, port %d"
 
2448
                    % tcp_server.socket.getsockname())
2784
2449
    
2785
2450
    #service.interface = tcp_server.socket.getsockname()[3]
2786
2451
    
2789
2454
        try:
2790
2455
            service.activate()
2791
2456
        except dbus.exceptions.DBusException as error:
2792
 
            logger.critical("D-Bus Exception", exc_info=error)
 
2457
            logger.critical("DBusException: %s", error)
2793
2458
            cleanup()
2794
2459
            sys.exit(1)
2795
2460
        # End of Avahi example code
2802
2467
        logger.debug("Starting main loop")
2803
2468
        main_loop.run()
2804
2469
    except AvahiError as error:
2805
 
        logger.critical("Avahi Error", exc_info=error)
 
2470
        logger.critical("AvahiError: %s", error)
2806
2471
        cleanup()
2807
2472
        sys.exit(1)
2808
2473
    except KeyboardInterrupt: