/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2013-10-20 15:25:09 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 305.
  • Revision ID: teddy@recompile.se-20131020152509-zkhuy2yse76w10hg
* Makefile (CFLAGS, LDFLAGS): Keep default flags from environment.
  (purge-server): PID file changed to "/run/mandos.pid".
* debian/compat: Changed to "9".
* debian/control (Standards-Version): Updated to "3.9.4".
  (DM-Upload-Allowed): Removed.
  (mandos/Depends): Add "initscripts (>= 2.88dsf-13.3)" to be able to
                    use the "/run" directory (for mandos.pid).
* debian/copyright (Copyright): Update year.
* init.d-mandos (PIDFILE): Changed to "/run/mandos.pid".
* mandos: Update copyright year.
  (pidfilename): Changed to "/run/mandos.pid".
* mandos-clients.conf.xml (OPTIONS/approval_delay): Bug fix: default
                                                    is "PT0S" - using
                                                    the new RFC 3339
                                                    duration syntax.
* mandos-keygen: Update copyright year.
* mandos-monitor: - '' -
* mandos.conf.xml: - '' -
* mandos.xml: - '' -
  (FILES): PID file changed to "/run/mandos.pid".
* plugin-runner.c: Update copyright year.
* plugins.d/mandos-client.c: - '' -
* plugins.d/mandos-client.xml: - '' -
* plugins.d/password-prompt.c: - '' -
* plugins.d/plymouth.c: - '' -

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-2013 Teddy Hogeborn
 
15
# Copyright © 2008-2013 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
 
37
39
import SocketServer as socketserver
38
40
import socket
39
41
import argparse
66
68
import binascii
67
69
import tempfile
68
70
import itertools
 
71
import collections
69
72
 
70
73
import dbus
71
74
import dbus.service
76
79
import ctypes.util
77
80
import xml.dom.minidom
78
81
import inspect
79
 
import GnuPGInterface
80
82
 
81
83
try:
82
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
86
88
    except ImportError:
87
89
        SO_BINDTODEVICE = None
88
90
 
89
 
version = "1.5.3"
 
91
version = "1.6.1"
90
92
stored_state_file = "clients.pickle"
91
93
 
92
94
logger = logging.getLogger()
137
139
class PGPEngine(object):
138
140
    """A simple class for OpenPGP symmetric encryption & decryption"""
139
141
    def __init__(self):
140
 
        self.gnupg = GnuPGInterface.GnuPG()
141
142
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
142
 
        self.gnupg = GnuPGInterface.GnuPG()
143
 
        self.gnupg.options.meta_interactive = False
144
 
        self.gnupg.options.homedir = self.tempdir
145
 
        self.gnupg.options.extra_args.extend(['--force-mdc',
146
 
                                              '--quiet',
147
 
                                              '--no-use-agent'])
 
143
        self.gnupgargs = ['--batch',
 
144
                          '--home', self.tempdir,
 
145
                          '--force-mdc',
 
146
                          '--quiet',
 
147
                          '--no-use-agent']
148
148
    
149
149
    def __enter__(self):
150
150
        return self
151
151
    
152
 
    def __exit__ (self, exc_type, exc_value, traceback):
 
152
    def __exit__(self, exc_type, exc_value, traceback):
153
153
        self._cleanup()
154
154
        return False
155
155
    
175
175
        return b"mandos" + binascii.hexlify(password)
176
176
    
177
177
    def encrypt(self, data, password):
178
 
        self.gnupg.passphrase = self.password_encode(password)
179
 
        with open(os.devnull, "w") as devnull:
180
 
            try:
181
 
                proc = self.gnupg.run(['--symmetric'],
182
 
                                      create_fhs=['stdin', 'stdout'],
183
 
                                      attach_fhs={'stderr': devnull})
184
 
                with contextlib.closing(proc.handles['stdin']) as f:
185
 
                    f.write(data)
186
 
                with contextlib.closing(proc.handles['stdout']) as f:
187
 
                    ciphertext = f.read()
188
 
                proc.wait()
189
 
            except IOError as e:
190
 
                raise PGPError(e)
191
 
        self.gnupg.passphrase = None
 
178
        passphrase = self.password_encode(password)
 
179
        with tempfile.NamedTemporaryFile(dir=self.tempdir
 
180
                                         ) as passfile:
 
181
            passfile.write(passphrase)
 
182
            passfile.flush()
 
183
            proc = subprocess.Popen(['gpg', '--symmetric',
 
184
                                     '--passphrase-file',
 
185
                                     passfile.name]
 
186
                                    + self.gnupgargs,
 
187
                                    stdin = subprocess.PIPE,
 
188
                                    stdout = subprocess.PIPE,
 
189
                                    stderr = subprocess.PIPE)
 
190
            ciphertext, err = proc.communicate(input = data)
 
191
        if proc.returncode != 0:
 
192
            raise PGPError(err)
192
193
        return ciphertext
193
194
    
194
195
    def decrypt(self, data, password):
195
 
        self.gnupg.passphrase = self.password_encode(password)
196
 
        with open(os.devnull, "w") as devnull:
197
 
            try:
198
 
                proc = self.gnupg.run(['--decrypt'],
199
 
                                      create_fhs=['stdin', 'stdout'],
200
 
                                      attach_fhs={'stderr': devnull})
201
 
                with contextlib.closing(proc.handles['stdin']) as f:
202
 
                    f.write(data)
203
 
                with contextlib.closing(proc.handles['stdout']) as f:
204
 
                    decrypted_plaintext = f.read()
205
 
                proc.wait()
206
 
            except IOError as e:
207
 
                raise PGPError(e)
208
 
        self.gnupg.passphrase = None
 
196
        passphrase = self.password_encode(password)
 
197
        with tempfile.NamedTemporaryFile(dir = self.tempdir
 
198
                                         ) as passfile:
 
199
            passfile.write(passphrase)
 
200
            passfile.flush()
 
201
            proc = subprocess.Popen(['gpg', '--decrypt',
 
202
                                     '--passphrase-file',
 
203
                                     passfile.name]
 
204
                                    + self.gnupgargs,
 
205
                                    stdin = subprocess.PIPE,
 
206
                                    stdout = subprocess.PIPE,
 
207
                                    stderr = subprocess.PIPE)
 
208
            decrypted_plaintext, err = proc.communicate(input
 
209
                                                        = data)
 
210
        if proc.returncode != 0:
 
211
            raise PGPError(err)
209
212
        return decrypted_plaintext
210
213
 
211
214
 
231
234
               Used to optionally bind to the specified interface.
232
235
    name: string; Example: 'Mandos'
233
236
    type: string; Example: '_mandos._tcp'.
234
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
237
     See <https://www.iana.org/assignments/service-names-port-numbers>
235
238
    port: integer; what port to announce
236
239
    TXT: list of strings; TXT record for the service
237
240
    domain: string; Domain to publish on, default to .local if empty.
377
380
                                 self.server_state_changed)
378
381
        self.server_state_changed(self.server.GetState())
379
382
 
 
383
 
380
384
class AvahiServiceToSyslog(AvahiService):
381
385
    def rename(self):
382
386
        """Add the new name to the syslog messages"""
387
391
                                .format(self.name)))
388
392
        return ret
389
393
 
 
394
 
390
395
def timedelta_to_milliseconds(td):
391
396
    "Convert a datetime.timedelta() to milliseconds"
392
397
    return ((td.days * 24 * 60 * 60 * 1000)
393
398
            + (td.seconds * 1000)
394
399
            + (td.microseconds // 1000))
395
400
 
 
401
 
396
402
class Client(object):
397
403
    """A representation of a client host served by this server.
398
404
    
434
440
    runtime_expansions: Allowed attributes for runtime expansion.
435
441
    expires:    datetime.datetime(); time (UTC) when a client will be
436
442
                disabled, or None
 
443
    server_settings: The server_settings dict from main()
437
444
    """
438
445
    
439
446
    runtime_expansions = ("approval_delay", "approval_duration",
440
 
                          "created", "enabled", "fingerprint",
441
 
                          "host", "interval", "last_checked_ok",
 
447
                          "created", "enabled", "expires",
 
448
                          "fingerprint", "host", "interval",
 
449
                          "last_approval_request", "last_checked_ok",
442
450
                          "last_enabled", "name", "timeout")
443
 
    client_defaults = { "timeout": "5m",
444
 
                        "extended_timeout": "15m",
445
 
                        "interval": "2m",
 
451
    client_defaults = { "timeout": "PT5M",
 
452
                        "extended_timeout": "PT15M",
 
453
                        "interval": "PT2M",
446
454
                        "checker": "fping -q -- %%(host)s",
447
455
                        "host": "",
448
 
                        "approval_delay": "0s",
449
 
                        "approval_duration": "1s",
 
456
                        "approval_delay": "PT0S",
 
457
                        "approval_duration": "PT1S",
450
458
                        "approved_by_default": "True",
451
459
                        "enabled": "True",
452
460
                        }
513
521
        
514
522
        return settings
515
523
    
516
 
    def __init__(self, settings, name = None):
 
524
    def __init__(self, settings, name = None, server_settings=None):
517
525
        self.name = name
 
526
        if server_settings is None:
 
527
            server_settings = {}
 
528
        self.server_settings = server_settings
518
529
        # adding all client settings
519
530
        for setting, value in settings.iteritems():
520
531
            setattr(self, setting, value)
570
581
        if getattr(self, "enabled", False):
571
582
            # Already enabled
572
583
            return
573
 
        self.send_changedstate()
574
584
        self.expires = datetime.datetime.utcnow() + self.timeout
575
585
        self.enabled = True
576
586
        self.last_enabled = datetime.datetime.utcnow()
577
587
        self.init_checker()
 
588
        self.send_changedstate()
578
589
    
579
590
    def disable(self, quiet=True):
580
591
        """Disable this client."""
581
592
        if not getattr(self, "enabled", False):
582
593
            return False
583
594
        if not quiet:
584
 
            self.send_changedstate()
585
 
        if not quiet:
586
595
            logger.info("Disabling client %s", self.name)
587
 
        if getattr(self, "disable_initiator_tag", False):
 
596
        if getattr(self, "disable_initiator_tag", None) is not None:
588
597
            gobject.source_remove(self.disable_initiator_tag)
589
598
            self.disable_initiator_tag = None
590
599
        self.expires = None
591
 
        if getattr(self, "checker_initiator_tag", False):
 
600
        if getattr(self, "checker_initiator_tag", None) is not None:
592
601
            gobject.source_remove(self.checker_initiator_tag)
593
602
            self.checker_initiator_tag = None
594
603
        self.stop_checker()
595
604
        self.enabled = False
 
605
        if not quiet:
 
606
            self.send_changedstate()
596
607
        # Do not run this again if called by a gobject.timeout_add
597
608
        return False
598
609
    
602
613
    def init_checker(self):
603
614
        # Schedule a new checker to be started an 'interval' from now,
604
615
        # and every interval from then on.
 
616
        if self.checker_initiator_tag is not None:
 
617
            gobject.source_remove(self.checker_initiator_tag)
605
618
        self.checker_initiator_tag = (gobject.timeout_add
606
619
                                      (self.interval_milliseconds(),
607
620
                                       self.start_checker))
608
621
        # Schedule a disable() when 'timeout' has passed
 
622
        if self.disable_initiator_tag is not None:
 
623
            gobject.source_remove(self.disable_initiator_tag)
609
624
        self.disable_initiator_tag = (gobject.timeout_add
610
625
                                   (self.timeout_milliseconds(),
611
626
                                    self.disable))
642
657
            timeout = self.timeout
643
658
        if self.disable_initiator_tag is not None:
644
659
            gobject.source_remove(self.disable_initiator_tag)
 
660
            self.disable_initiator_tag = None
645
661
        if getattr(self, "enabled", False):
646
662
            self.disable_initiator_tag = (gobject.timeout_add
647
663
                                          (timedelta_to_milliseconds
657
673
        If a checker already exists, leave it running and do
658
674
        nothing."""
659
675
        # The reason for not killing a running checker is that if we
660
 
        # did that, then if a checker (for some reason) started
661
 
        # running slowly and taking more than 'interval' time, the
662
 
        # client would inevitably timeout, since no checker would get
663
 
        # a chance to run to completion.  If we instead leave running
 
676
        # did that, and if a checker (for some reason) started running
 
677
        # slowly and taking more than 'interval' time, then the client
 
678
        # would inevitably timeout, since no checker would get a
 
679
        # chance to run to completion.  If we instead leave running
664
680
        # checkers alone, the checker would have to take more time
665
681
        # than 'timeout' for the client to be disabled, which is as it
666
682
        # should be.
680
696
                                      self.current_checker_command)
681
697
        # Start a new checker if needed
682
698
        if self.checker is None:
 
699
            # Escape attributes for the shell
 
700
            escaped_attrs = dict(
 
701
                (attr, re.escape(unicode(getattr(self, attr))))
 
702
                for attr in
 
703
                self.runtime_expansions)
683
704
            try:
684
 
                # In case checker_command has exactly one % operator
685
 
                command = self.checker_command % self.host
686
 
            except TypeError:
687
 
                # Escape attributes for the shell
688
 
                escaped_attrs = dict(
689
 
                    (attr,
690
 
                     re.escape(unicode(str(getattr(self, attr, "")),
691
 
                                       errors=
692
 
                                       'replace')))
693
 
                    for attr in
694
 
                    self.runtime_expansions)
695
 
                
696
 
                try:
697
 
                    command = self.checker_command % escaped_attrs
698
 
                except TypeError as error:
699
 
                    logger.error('Could not format string "%s"',
700
 
                                 self.checker_command, exc_info=error)
701
 
                    return True # Try again later
 
705
                command = self.checker_command % escaped_attrs
 
706
            except TypeError as error:
 
707
                logger.error('Could not format string "%s"',
 
708
                             self.checker_command, exc_info=error)
 
709
                return True # Try again later
702
710
            self.current_checker_command = command
703
711
            try:
704
712
                logger.info("Starting checker %r for %s",
707
715
                # in normal mode, that is already done by daemon(),
708
716
                # and in debug mode we don't want to.  (Stdin is
709
717
                # always replaced by /dev/null.)
 
718
                # The exception is when not debugging but nevertheless
 
719
                # running in the foreground; use the previously
 
720
                # created wnull.
 
721
                popen_args = {}
 
722
                if (not self.server_settings["debug"]
 
723
                    and self.server_settings["foreground"]):
 
724
                    popen_args.update({"stdout": wnull,
 
725
                                       "stderr": wnull })
710
726
                self.checker = subprocess.Popen(command,
711
727
                                                close_fds=True,
712
 
                                                shell=True, cwd="/")
713
 
                self.checker_callback_tag = (gobject.child_watch_add
714
 
                                             (self.checker.pid,
715
 
                                              self.checker_callback,
716
 
                                              data=command))
717
 
                # The checker may have completed before the gobject
718
 
                # watch was added.  Check for this.
719
 
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
720
 
                if pid:
721
 
                    gobject.source_remove(self.checker_callback_tag)
722
 
                    self.checker_callback(pid, status, command)
 
728
                                                shell=True, cwd="/",
 
729
                                                **popen_args)
723
730
            except OSError as error:
724
731
                logger.error("Failed to start subprocess",
725
732
                             exc_info=error)
 
733
                return True
 
734
            self.checker_callback_tag = (gobject.child_watch_add
 
735
                                         (self.checker.pid,
 
736
                                          self.checker_callback,
 
737
                                          data=command))
 
738
            # The checker may have completed before the gobject
 
739
            # watch was added.  Check for this.
 
740
            try:
 
741
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
742
            except OSError as error:
 
743
                if error.errno == errno.ECHILD:
 
744
                    # This should never happen
 
745
                    logger.error("Child process vanished",
 
746
                                 exc_info=error)
 
747
                    return True
 
748
                raise
 
749
            if pid:
 
750
                gobject.source_remove(self.checker_callback_tag)
 
751
                self.checker_callback(pid, status, command)
726
752
        # Re-run this periodically if run by gobject.timeout_add
727
753
        return True
728
754
    
979
1005
                            tag.appendChild(ann_tag)
980
1006
                # Add interface annotation tags
981
1007
                for annotation, value in dict(
982
 
                    itertools.chain(
983
 
                        *(annotations().iteritems()
984
 
                          for name, annotations in
985
 
                          self._get_all_dbus_things("interface")
986
 
                          if name == if_tag.getAttribute("name")
987
 
                          ))).iteritems():
 
1008
                    itertools.chain.from_iterable(
 
1009
                        annotations().iteritems()
 
1010
                        for name, annotations in
 
1011
                        self._get_all_dbus_things("interface")
 
1012
                        if name == if_tag.getAttribute("name")
 
1013
                        )).iteritems():
988
1014
                    ann_tag = document.createElement("annotation")
989
1015
                    ann_tag.setAttribute("name", annotation)
990
1016
                    ann_tag.setAttribute("value", value)
1013
1039
        return xmlstring
1014
1040
 
1015
1041
 
1016
 
def datetime_to_dbus (dt, variant_level=0):
 
1042
def datetime_to_dbus(dt, variant_level=0):
1017
1043
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1018
1044
    if dt is None:
1019
1045
        return dbus.String("", variant_level = variant_level)
1021
1047
                       variant_level=variant_level)
1022
1048
 
1023
1049
 
1024
 
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
1025
 
                                  .__metaclass__):
1026
 
    """Applied to an empty subclass of a D-Bus object, this metaclass
1027
 
    will add additional D-Bus attributes matching a certain pattern.
 
1050
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
 
1051
    """A class decorator; applied to a subclass of
 
1052
    dbus.service.Object, it will add alternate D-Bus attributes with
 
1053
    interface names according to the "alt_interface_names" mapping.
 
1054
    Usage:
 
1055
    
 
1056
    @alternate_dbus_interfaces({"org.example.Interface":
 
1057
                                    "net.example.AlternateInterface"})
 
1058
    class SampleDBusObject(dbus.service.Object):
 
1059
        @dbus.service.method("org.example.Interface")
 
1060
        def SampleDBusMethod():
 
1061
            pass
 
1062
    
 
1063
    The above "SampleDBusMethod" on "SampleDBusObject" will be
 
1064
    reachable via two interfaces: "org.example.Interface" and
 
1065
    "net.example.AlternateInterface", the latter of which will have
 
1066
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
 
1067
    "true", unless "deprecate" is passed with a False value.
 
1068
    
 
1069
    This works for methods and signals, and also for D-Bus properties
 
1070
    (from DBusObjectWithProperties) and interfaces (from the
 
1071
    dbus_interface_annotations decorator).
1028
1072
    """
1029
 
    def __new__(mcs, name, bases, attr):
1030
 
        # Go through all the base classes which could have D-Bus
1031
 
        # methods, signals, or properties in them
1032
 
        old_interface_names = []
1033
 
        for base in (b for b in bases
1034
 
                     if issubclass(b, dbus.service.Object)):
1035
 
            # Go though all attributes of the base class
1036
 
            for attrname, attribute in inspect.getmembers(base):
 
1073
    def wrapper(cls):
 
1074
        for orig_interface_name, alt_interface_name in (
 
1075
            alt_interface_names.iteritems()):
 
1076
            attr = {}
 
1077
            interface_names = set()
 
1078
            # Go though all attributes of the class
 
1079
            for attrname, attribute in inspect.getmembers(cls):
1037
1080
                # Ignore non-D-Bus attributes, and D-Bus attributes
1038
1081
                # with the wrong interface name
1039
1082
                if (not hasattr(attribute, "_dbus_interface")
1040
1083
                    or not attribute._dbus_interface
1041
 
                    .startswith("se.recompile.Mandos")):
 
1084
                    .startswith(orig_interface_name)):
1042
1085
                    continue
1043
1086
                # Create an alternate D-Bus interface name based on
1044
1087
                # the current name
1045
1088
                alt_interface = (attribute._dbus_interface
1046
 
                                 .replace("se.recompile.Mandos",
1047
 
                                          "se.bsnet.fukt.Mandos"))
1048
 
                if alt_interface != attribute._dbus_interface:
1049
 
                    old_interface_names.append(alt_interface)
 
1089
                                 .replace(orig_interface_name,
 
1090
                                          alt_interface_name))
 
1091
                interface_names.add(alt_interface)
1050
1092
                # Is this a D-Bus signal?
1051
1093
                if getattr(attribute, "_dbus_is_signal", False):
1052
 
                    # Extract the original non-method function by
1053
 
                    # black magic
 
1094
                    # Extract the original non-method undecorated
 
1095
                    # function by black magic
1054
1096
                    nonmethod_func = (dict(
1055
1097
                            zip(attribute.func_code.co_freevars,
1056
1098
                                attribute.__closure__))["func"]
1074
1116
                    except AttributeError:
1075
1117
                        pass
1076
1118
                    # Define a creator of a function to call both the
1077
 
                    # old and new functions, so both the old and new
1078
 
                    # signals gets sent when the function is called
 
1119
                    # original and alternate functions, so both the
 
1120
                    # original and alternate signals gets sent when
 
1121
                    # the function is called
1079
1122
                    def fixscope(func1, func2):
1080
1123
                        """This function is a scope container to pass
1081
1124
                        func1 and func2 to the "call_both" function
1088
1131
                        return call_both
1089
1132
                    # Create the "call_both" function and add it to
1090
1133
                    # the class
1091
 
                    attr[attrname] = fixscope(attribute,
1092
 
                                              new_function)
 
1134
                    attr[attrname] = fixscope(attribute, new_function)
1093
1135
                # Is this a D-Bus method?
1094
1136
                elif getattr(attribute, "_dbus_is_method", False):
1095
1137
                    # Create a new, but exactly alike, function
1151
1193
                                        attribute.func_name,
1152
1194
                                        attribute.func_defaults,
1153
1195
                                        attribute.func_closure)))
1154
 
        # Deprecate all old interfaces
1155
 
        iname="_AlternateDBusNamesMetaclass_interface_annotation{0}"
1156
 
        for old_interface_name in old_interface_names:
1157
 
            @dbus_interface_annotations(old_interface_name)
1158
 
            def func(self):
1159
 
                return { "org.freedesktop.DBus.Deprecated": "true" }
1160
 
            # Find an unused name
1161
 
            for aname in (iname.format(i) for i in itertools.count()):
1162
 
                if aname not in attr:
1163
 
                    attr[aname] = func
1164
 
                    break
1165
 
        return type.__new__(mcs, name, bases, attr)
1166
 
 
1167
 
 
 
1196
            if deprecate:
 
1197
                # Deprecate all alternate interfaces
 
1198
                iname="_AlternateDBusNames_interface_annotation{0}"
 
1199
                for interface_name in interface_names:
 
1200
                    @dbus_interface_annotations(interface_name)
 
1201
                    def func(self):
 
1202
                        return { "org.freedesktop.DBus.Deprecated":
 
1203
                                     "true" }
 
1204
                    # Find an unused name
 
1205
                    for aname in (iname.format(i)
 
1206
                                  for i in itertools.count()):
 
1207
                        if aname not in attr:
 
1208
                            attr[aname] = func
 
1209
                            break
 
1210
            if interface_names:
 
1211
                # Replace the class with a new subclass of it with
 
1212
                # methods, signals, etc. as created above.
 
1213
                cls = type(b"{0}Alternate".format(cls.__name__),
 
1214
                           (cls,), attr)
 
1215
        return cls
 
1216
    return wrapper
 
1217
 
 
1218
 
 
1219
@alternate_dbus_interfaces({"se.recompile.Mandos":
 
1220
                                "se.bsnet.fukt.Mandos"})
1168
1221
class ClientDBus(Client, DBusObjectWithProperties):
1169
1222
    """A Client class using D-Bus
1170
1223
    
1306
1359
        return False
1307
1360
    
1308
1361
    def approve(self, value=True):
1309
 
        self.send_changedstate()
1310
1362
        self.approved = value
1311
1363
        gobject.timeout_add(timedelta_to_milliseconds
1312
1364
                            (self.approval_duration),
1313
1365
                            self._reset_approved)
 
1366
        self.send_changedstate()
1314
1367
    
1315
1368
    ## D-Bus methods, signals & properties
1316
1369
    _interface = "se.recompile.Mandos.Client"
1500
1553
    def Timeout_dbus_property(self, value=None):
1501
1554
        if value is None:       # get
1502
1555
            return dbus.UInt64(self.timeout_milliseconds())
 
1556
        old_timeout = self.timeout
1503
1557
        self.timeout = datetime.timedelta(0, 0, 0, value)
1504
 
        # Reschedule timeout
 
1558
        # Reschedule disabling
1505
1559
        if self.enabled:
1506
1560
            now = datetime.datetime.utcnow()
1507
 
            time_to_die = timedelta_to_milliseconds(
1508
 
                (self.last_checked_ok + self.timeout) - now)
1509
 
            if time_to_die <= 0:
 
1561
            self.expires += self.timeout - old_timeout
 
1562
            if self.expires <= now:
1510
1563
                # The timeout has passed
1511
1564
                self.disable()
1512
1565
            else:
1513
 
                self.expires = (now +
1514
 
                                datetime.timedelta(milliseconds =
1515
 
                                                   time_to_die))
1516
1566
                if (getattr(self, "disable_initiator_tag", None)
1517
1567
                    is None):
1518
1568
                    return
1519
1569
                gobject.source_remove(self.disable_initiator_tag)
1520
 
                self.disable_initiator_tag = (gobject.timeout_add
1521
 
                                              (time_to_die,
1522
 
                                               self.disable))
 
1570
                self.disable_initiator_tag = (
 
1571
                    gobject.timeout_add(
 
1572
                        timedelta_to_milliseconds(self.expires - now),
 
1573
                        self.disable))
1523
1574
    
1524
1575
    # ExtendedTimeout - property
1525
1576
    @dbus_service_property(_interface, signature="t",
1604
1655
        self._pipe.send(('setattr', name, value))
1605
1656
 
1606
1657
 
1607
 
class ClientDBusTransitional(ClientDBus):
1608
 
    __metaclass__ = AlternateDBusNamesMetaclass
1609
 
 
1610
 
 
1611
1658
class ClientHandler(socketserver.BaseRequestHandler, object):
1612
1659
    """A class to handle client connections.
1613
1660
    
1717
1764
                    #wait until timeout or approved
1718
1765
                    time = datetime.datetime.now()
1719
1766
                    client.changedstate.acquire()
1720
 
                    (client.changedstate.wait
1721
 
                     (float(client.timedelta_to_milliseconds(delay)
1722
 
                            / 1000)))
 
1767
                    client.changedstate.wait(
 
1768
                        float(timedelta_to_milliseconds(delay)
 
1769
                              / 1000))
1723
1770
                    client.changedstate.release()
1724
1771
                    time2 = datetime.datetime.now()
1725
1772
                    if (time2 - time) >= delay:
1841
1888
    def process_request(self, request, address):
1842
1889
        """Start a new process to process the request."""
1843
1890
        proc = multiprocessing.Process(target = self.sub_process_main,
1844
 
                                       args = (request,
1845
 
                                               address))
 
1891
                                       args = (request, address))
1846
1892
        proc.start()
1847
1893
        return proc
1848
1894
 
1876
1922
        use_ipv6:       Boolean; to use IPv6 or not
1877
1923
    """
1878
1924
    def __init__(self, server_address, RequestHandlerClass,
1879
 
                 interface=None, use_ipv6=True):
 
1925
                 interface=None, use_ipv6=True, socketfd=None):
 
1926
        """If socketfd is set, use that file descriptor instead of
 
1927
        creating a new one with socket.socket().
 
1928
        """
1880
1929
        self.interface = interface
1881
1930
        if use_ipv6:
1882
1931
            self.address_family = socket.AF_INET6
 
1932
        if socketfd is not None:
 
1933
            # Save the file descriptor
 
1934
            self.socketfd = socketfd
 
1935
            # Save the original socket.socket() function
 
1936
            self.socket_socket = socket.socket
 
1937
            # To implement --socket, we monkey patch socket.socket.
 
1938
            # 
 
1939
            # (When socketserver.TCPServer is a new-style class, we
 
1940
            # could make self.socket into a property instead of monkey
 
1941
            # patching socket.socket.)
 
1942
            # 
 
1943
            # Create a one-time-only replacement for socket.socket()
 
1944
            @functools.wraps(socket.socket)
 
1945
            def socket_wrapper(*args, **kwargs):
 
1946
                # Restore original function so subsequent calls are
 
1947
                # not affected.
 
1948
                socket.socket = self.socket_socket
 
1949
                del self.socket_socket
 
1950
                # This time only, return a new socket object from the
 
1951
                # saved file descriptor.
 
1952
                return socket.fromfd(self.socketfd, *args, **kwargs)
 
1953
            # Replace socket.socket() function with wrapper
 
1954
            socket.socket = socket_wrapper
 
1955
        # The socketserver.TCPServer.__init__ will call
 
1956
        # socket.socket(), which might be our replacement,
 
1957
        # socket_wrapper(), if socketfd was set.
1883
1958
        socketserver.TCPServer.__init__(self, server_address,
1884
1959
                                        RequestHandlerClass)
 
1960
    
1885
1961
    def server_bind(self):
1886
1962
        """This overrides the normal server_bind() function
1887
1963
        to bind to an interface if one was specified, and also NOT to
1895
1971
                try:
1896
1972
                    self.socket.setsockopt(socket.SOL_SOCKET,
1897
1973
                                           SO_BINDTODEVICE,
1898
 
                                           str(self.interface
1899
 
                                               + '\0'))
 
1974
                                           str(self.interface + '\0'))
1900
1975
                except socket.error as error:
1901
 
                    if error[0] == errno.EPERM:
1902
 
                        logger.error("No permission to"
1903
 
                                     " bind to interface %s",
1904
 
                                     self.interface)
1905
 
                    elif error[0] == errno.ENOPROTOOPT:
 
1976
                    if error.errno == errno.EPERM:
 
1977
                        logger.error("No permission to bind to"
 
1978
                                     " interface %s", self.interface)
 
1979
                    elif error.errno == errno.ENOPROTOOPT:
1906
1980
                        logger.error("SO_BINDTODEVICE not available;"
1907
1981
                                     " cannot bind to interface %s",
1908
1982
                                     self.interface)
 
1983
                    elif error.errno == errno.ENODEV:
 
1984
                        logger.error("Interface %s does not exist,"
 
1985
                                     " cannot bind", self.interface)
1909
1986
                    else:
1910
1987
                        raise
1911
1988
        # Only bind(2) the socket if we really need to.
1914
1991
                if self.address_family == socket.AF_INET6:
1915
1992
                    any_address = "::" # in6addr_any
1916
1993
                else:
1917
 
                    any_address = socket.INADDR_ANY
 
1994
                    any_address = "0.0.0.0" # INADDR_ANY
1918
1995
                self.server_address = (any_address,
1919
1996
                                       self.server_address[1])
1920
1997
            elif not self.server_address[1]:
1941
2018
    """
1942
2019
    def __init__(self, server_address, RequestHandlerClass,
1943
2020
                 interface=None, use_ipv6=True, clients=None,
1944
 
                 gnutls_priority=None, use_dbus=True):
 
2021
                 gnutls_priority=None, use_dbus=True, socketfd=None):
1945
2022
        self.enabled = False
1946
2023
        self.clients = clients
1947
2024
        if self.clients is None:
1951
2028
        IPv6_TCPServer.__init__(self, server_address,
1952
2029
                                RequestHandlerClass,
1953
2030
                                interface = interface,
1954
 
                                use_ipv6 = use_ipv6)
 
2031
                                use_ipv6 = use_ipv6,
 
2032
                                socketfd = socketfd)
1955
2033
    def server_activate(self):
1956
2034
        if self.enabled:
1957
2035
            return socketserver.TCPServer.server_activate(self)
1970
2048
    
1971
2049
    def handle_ipc(self, source, condition, parent_pipe=None,
1972
2050
                   proc = None, client_object=None):
1973
 
        condition_names = {
1974
 
            gobject.IO_IN: "IN",   # There is data to read.
1975
 
            gobject.IO_OUT: "OUT", # Data can be written (without
1976
 
                                    # blocking).
1977
 
            gobject.IO_PRI: "PRI", # There is urgent data to read.
1978
 
            gobject.IO_ERR: "ERR", # Error condition.
1979
 
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
1980
 
                                    # broken, usually for pipes and
1981
 
                                    # sockets).
1982
 
            }
1983
 
        conditions_string = ' | '.join(name
1984
 
                                       for cond, name in
1985
 
                                       condition_names.iteritems()
1986
 
                                       if cond & condition)
1987
2051
        # error, or the other end of multiprocessing.Pipe has closed
1988
 
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
2052
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
1989
2053
            # Wait for other process to exit
1990
2054
            proc.join()
1991
2055
            return False
2049
2113
        return True
2050
2114
 
2051
2115
 
 
2116
def rfc3339_duration_to_delta(duration):
 
2117
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2118
    
 
2119
    >>> rfc3339_duration_to_delta("P7D")
 
2120
    datetime.timedelta(7)
 
2121
    >>> rfc3339_duration_to_delta("PT60S")
 
2122
    datetime.timedelta(0, 60)
 
2123
    >>> rfc3339_duration_to_delta("PT60M")
 
2124
    datetime.timedelta(0, 3600)
 
2125
    >>> rfc3339_duration_to_delta("PT24H")
 
2126
    datetime.timedelta(1)
 
2127
    >>> rfc3339_duration_to_delta("P1W")
 
2128
    datetime.timedelta(7)
 
2129
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2130
    datetime.timedelta(0, 330)
 
2131
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2132
    datetime.timedelta(1, 200)
 
2133
    """
 
2134
    
 
2135
    # Parsing an RFC 3339 duration with regular expressions is not
 
2136
    # possible - there would have to be multiple places for the same
 
2137
    # values, like seconds.  The current code, while more esoteric, is
 
2138
    # cleaner without depending on a parsing library.  If Python had a
 
2139
    # built-in library for parsing we would use it, but we'd like to
 
2140
    # avoid excessive use of external libraries.
 
2141
    
 
2142
    # New type for defining tokens, syntax, and semantics all-in-one
 
2143
    Token = collections.namedtuple("Token",
 
2144
                                   ("regexp", # To match token; if
 
2145
                                              # "value" is not None,
 
2146
                                              # must have a "group"
 
2147
                                              # containing digits
 
2148
                                    "value",  # datetime.timedelta or
 
2149
                                              # None
 
2150
                                    "followers")) # Tokens valid after
 
2151
                                                  # this token
 
2152
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2153
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2154
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2155
    token_second = Token(re.compile(r"(\d+)S"),
 
2156
                         datetime.timedelta(seconds=1),
 
2157
                         frozenset((token_end,)))
 
2158
    token_minute = Token(re.compile(r"(\d+)M"),
 
2159
                         datetime.timedelta(minutes=1),
 
2160
                         frozenset((token_second, token_end)))
 
2161
    token_hour = Token(re.compile(r"(\d+)H"),
 
2162
                       datetime.timedelta(hours=1),
 
2163
                       frozenset((token_minute, token_end)))
 
2164
    token_time = Token(re.compile(r"T"),
 
2165
                       None,
 
2166
                       frozenset((token_hour, token_minute,
 
2167
                                  token_second)))
 
2168
    token_day = Token(re.compile(r"(\d+)D"),
 
2169
                      datetime.timedelta(days=1),
 
2170
                      frozenset((token_time, token_end)))
 
2171
    token_month = Token(re.compile(r"(\d+)M"),
 
2172
                        datetime.timedelta(weeks=4),
 
2173
                        frozenset((token_day, token_end)))
 
2174
    token_year = Token(re.compile(r"(\d+)Y"),
 
2175
                       datetime.timedelta(weeks=52),
 
2176
                       frozenset((token_month, token_end)))
 
2177
    token_week = Token(re.compile(r"(\d+)W"),
 
2178
                       datetime.timedelta(weeks=1),
 
2179
                       frozenset((token_end,)))
 
2180
    token_duration = Token(re.compile(r"P"), None,
 
2181
                           frozenset((token_year, token_month,
 
2182
                                      token_day, token_time,
 
2183
                                      token_week))),
 
2184
    # Define starting values
 
2185
    value = datetime.timedelta() # Value so far
 
2186
    found_token = None
 
2187
    followers = frozenset(token_duration,) # Following valid tokens
 
2188
    s = duration                # String left to parse
 
2189
    # Loop until end token is found
 
2190
    while found_token is not token_end:
 
2191
        # Search for any currently valid tokens
 
2192
        for token in followers:
 
2193
            match = token.regexp.match(s)
 
2194
            if match is not None:
 
2195
                # Token found
 
2196
                if token.value is not None:
 
2197
                    # Value found, parse digits
 
2198
                    factor = int(match.group(1), 10)
 
2199
                    # Add to value so far
 
2200
                    value += factor * token.value
 
2201
                # Strip token from string
 
2202
                s = token.regexp.sub("", s, 1)
 
2203
                # Go to found token
 
2204
                found_token = token
 
2205
                # Set valid next tokens
 
2206
                followers = found_token.followers
 
2207
                break
 
2208
        else:
 
2209
            # No currently valid tokens were found
 
2210
            raise ValueError("Invalid RFC 3339 duration")
 
2211
    # End token found
 
2212
    return value
 
2213
 
 
2214
 
2052
2215
def string_to_delta(interval):
2053
2216
    """Parse a string and return a datetime.timedelta
2054
2217
    
2065
2228
    >>> string_to_delta('5m 30s')
2066
2229
    datetime.timedelta(0, 330)
2067
2230
    """
 
2231
    
 
2232
    try:
 
2233
        return rfc3339_duration_to_delta(interval)
 
2234
    except ValueError:
 
2235
        pass
 
2236
    
2068
2237
    timevalue = datetime.timedelta(0)
2069
2238
    for s in interval.split():
2070
2239
        try:
2133
2302
                        help="Run self-test")
2134
2303
    parser.add_argument("--debug", action="store_true",
2135
2304
                        help="Debug mode; run in foreground and log"
2136
 
                        " to terminal")
 
2305
                        " to terminal", default=None)
2137
2306
    parser.add_argument("--debuglevel", metavar="LEVEL",
2138
2307
                        help="Debug level for stdout output")
2139
2308
    parser.add_argument("--priority", help="GnuTLS"
2146
2315
                        " files")
2147
2316
    parser.add_argument("--no-dbus", action="store_false",
2148
2317
                        dest="use_dbus", help="Do not provide D-Bus"
2149
 
                        " system bus interface")
 
2318
                        " system bus interface", default=None)
2150
2319
    parser.add_argument("--no-ipv6", action="store_false",
2151
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2320
                        dest="use_ipv6", help="Do not use IPv6",
 
2321
                        default=None)
2152
2322
    parser.add_argument("--no-restore", action="store_false",
2153
2323
                        dest="restore", help="Do not restore stored"
2154
 
                        " state")
 
2324
                        " state", default=None)
 
2325
    parser.add_argument("--socket", type=int,
 
2326
                        help="Specify a file descriptor to a network"
 
2327
                        " socket to use instead of creating one")
2155
2328
    parser.add_argument("--statedir", metavar="DIR",
2156
2329
                        help="Directory to save/restore state in")
 
2330
    parser.add_argument("--foreground", action="store_true",
 
2331
                        help="Run in foreground", default=None)
2157
2332
    
2158
2333
    options = parser.parse_args()
2159
2334
    
2168
2343
                        "port": "",
2169
2344
                        "debug": "False",
2170
2345
                        "priority":
2171
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2346
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224",
2172
2347
                        "servicename": "Mandos",
2173
2348
                        "use_dbus": "True",
2174
2349
                        "use_ipv6": "True",
2175
2350
                        "debuglevel": "",
2176
2351
                        "restore": "True",
2177
 
                        "statedir": "/var/lib/mandos"
 
2352
                        "socket": "",
 
2353
                        "statedir": "/var/lib/mandos",
 
2354
                        "foreground": "False",
2178
2355
                        }
2179
2356
    
2180
2357
    # Parse config file for server-global settings
2185
2362
    # Convert the SafeConfigParser object to a dict
2186
2363
    server_settings = server_config.defaults()
2187
2364
    # Use the appropriate methods on the non-string config options
2188
 
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2365
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2189
2366
        server_settings[option] = server_config.getboolean("DEFAULT",
2190
2367
                                                           option)
2191
2368
    if server_settings["port"]:
2192
2369
        server_settings["port"] = server_config.getint("DEFAULT",
2193
2370
                                                       "port")
 
2371
    if server_settings["socket"]:
 
2372
        server_settings["socket"] = server_config.getint("DEFAULT",
 
2373
                                                         "socket")
 
2374
        # Later, stdin will, and stdout and stderr might, be dup'ed
 
2375
        # over with an opened os.devnull.  But we don't want this to
 
2376
        # happen with a supplied network socket.
 
2377
        if 0 <= server_settings["socket"] <= 2:
 
2378
            server_settings["socket"] = os.dup(server_settings
 
2379
                                               ["socket"])
2194
2380
    del server_config
2195
2381
    
2196
2382
    # Override the settings from the config file with command line
2198
2384
    for option in ("interface", "address", "port", "debug",
2199
2385
                   "priority", "servicename", "configdir",
2200
2386
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2201
 
                   "statedir"):
 
2387
                   "statedir", "socket", "foreground"):
2202
2388
        value = getattr(options, option)
2203
2389
        if value is not None:
2204
2390
            server_settings[option] = value
2207
2393
    for option in server_settings.keys():
2208
2394
        if type(server_settings[option]) is str:
2209
2395
            server_settings[option] = unicode(server_settings[option])
 
2396
    # Force all boolean options to be boolean
 
2397
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2398
                   "foreground"):
 
2399
        server_settings[option] = bool(server_settings[option])
 
2400
    # Debug implies foreground
 
2401
    if server_settings["debug"]:
 
2402
        server_settings["foreground"] = True
2210
2403
    # Now we have our good server settings in "server_settings"
2211
2404
    
2212
2405
    ##################################################################
2218
2411
    use_ipv6 = server_settings["use_ipv6"]
2219
2412
    stored_state_path = os.path.join(server_settings["statedir"],
2220
2413
                                     stored_state_file)
 
2414
    foreground = server_settings["foreground"]
2221
2415
    
2222
2416
    if debug:
2223
2417
        initlogger(debug, logging.DEBUG)
2252
2446
                              use_ipv6=use_ipv6,
2253
2447
                              gnutls_priority=
2254
2448
                              server_settings["priority"],
2255
 
                              use_dbus=use_dbus)
2256
 
    if not debug:
2257
 
        pidfilename = "/var/run/mandos.pid"
 
2449
                              use_dbus=use_dbus,
 
2450
                              socketfd=(server_settings["socket"]
 
2451
                                        or None))
 
2452
    if not foreground:
 
2453
        pidfilename = "/run/mandos.pid"
 
2454
        pidfile = None
2258
2455
        try:
2259
2456
            pidfile = open(pidfilename, "w")
2260
2457
        except IOError as e:
2275
2472
        os.setgid(gid)
2276
2473
        os.setuid(uid)
2277
2474
    except OSError as error:
2278
 
        if error[0] != errno.EPERM:
 
2475
        if error.errno != errno.EPERM:
2279
2476
            raise error
2280
2477
    
2281
2478
    if debug:
2299
2496
            os.close(null)
2300
2497
    
2301
2498
    # Need to fork before connecting to D-Bus
2302
 
    if not debug:
 
2499
    if not foreground:
2303
2500
        # Close all input and output, do double fork, etc.
2304
2501
        daemon()
2305
2502
    
 
2503
    # multiprocessing will use threads, so before we use gobject we
 
2504
    # need to inform gobject that threads will be used.
2306
2505
    gobject.threads_init()
2307
2506
    
2308
2507
    global main_loop
2337
2536
    
2338
2537
    client_class = Client
2339
2538
    if use_dbus:
2340
 
        client_class = functools.partial(ClientDBusTransitional,
2341
 
                                         bus = bus)
 
2539
        client_class = functools.partial(ClientDBus, bus = bus)
2342
2540
    
2343
2541
    client_settings = Client.config_parser(client_config)
2344
2542
    old_client_settings = {}
2345
2543
    clients_data = {}
2346
2544
    
 
2545
    # This is used to redirect stdout and stderr for checker processes
 
2546
    global wnull
 
2547
    wnull = open(os.devnull, "w") # A writable /dev/null
 
2548
    # Only used if server is running in foreground but not in debug
 
2549
    # mode
 
2550
    if debug or not foreground:
 
2551
        wnull.close()
 
2552
    
2347
2553
    # Get client data and settings from last running state.
2348
2554
    if server_settings["restore"]:
2349
2555
        try:
2365
2571
    
2366
2572
    with PGPEngine() as pgp:
2367
2573
        for client_name, client in clients_data.iteritems():
 
2574
            # Skip removed clients
 
2575
            if client_name not in client_settings:
 
2576
                continue
 
2577
            
2368
2578
            # Decide which value to use after restoring saved state.
2369
2579
            # We have three different values: Old config file,
2370
2580
            # new config file, and saved state.
2432
2642
    # Create all client objects
2433
2643
    for client_name, client in clients_data.iteritems():
2434
2644
        tcp_server.clients[client_name] = client_class(
2435
 
            name = client_name, settings = client)
 
2645
            name = client_name, settings = client,
 
2646
            server_settings = server_settings)
2436
2647
    
2437
2648
    if not tcp_server.clients:
2438
2649
        logger.warning("No clients defined")
2439
2650
    
2440
 
    if not debug:
2441
 
        try:
2442
 
            with pidfile:
2443
 
                pid = os.getpid()
2444
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
2445
 
            del pidfile
2446
 
        except IOError:
2447
 
            logger.error("Could not write to file %r with PID %d",
2448
 
                         pidfilename, pid)
2449
 
        except NameError:
2450
 
            # "pidfile" was never created
2451
 
            pass
 
2651
    if not foreground:
 
2652
        if pidfile is not None:
 
2653
            try:
 
2654
                with pidfile:
 
2655
                    pid = os.getpid()
 
2656
                    pidfile.write(str(pid) + "\n".encode("utf-8"))
 
2657
            except IOError:
 
2658
                logger.error("Could not write to file %r with PID %d",
 
2659
                             pidfilename, pid)
 
2660
        del pidfile
2452
2661
        del pidfilename
2453
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2454
2662
    
2455
2663
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2456
2664
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2457
2665
    
2458
2666
    if use_dbus:
 
2667
        @alternate_dbus_interfaces({"se.recompile.Mandos":
 
2668
                                        "se.bsnet.fukt.Mandos"})
2459
2669
        class MandosDBusService(DBusObjectWithProperties):
2460
2670
            """A D-Bus proxy object"""
2461
2671
            def __init__(self):
2515
2725
            
2516
2726
            del _interface
2517
2727
        
2518
 
        class MandosDBusServiceTransitional(MandosDBusService):
2519
 
            __metaclass__ = AlternateDBusNamesMetaclass
2520
 
        mandos_dbus_service = MandosDBusServiceTransitional()
 
2728
        mandos_dbus_service = MandosDBusService()
2521
2729
    
2522
2730
    def cleanup():
2523
2731
        "Cleanup function; run on exit"
2524
2732
        service.cleanup()
2525
2733
        
2526
2734
        multiprocessing.active_children()
 
2735
        wnull.close()
2527
2736
        if not (tcp_server.clients or client_settings):
2528
2737
            return
2529
2738
        
2541
2750
                # A list of attributes that can not be pickled
2542
2751
                # + secret.
2543
2752
                exclude = set(("bus", "changedstate", "secret",
2544
 
                               "checker"))
 
2753
                               "checker", "server_settings"))
2545
2754
                for name, typ in (inspect.getmembers
2546
2755
                                  (dbus.service.Object)):
2547
2756
                    exclude.add(name)
2556
2765
                del client_settings[client.name]["secret"]
2557
2766
        
2558
2767
        try:
2559
 
            tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2560
 
                                                prefix="clients-",
2561
 
                                                dir=os.path.dirname
2562
 
                                                (stored_state_path))
2563
 
            with os.fdopen(tempfd, "wb") as stored_state:
 
2768
            with (tempfile.NamedTemporaryFile
 
2769
                  (mode='wb', suffix=".pickle", prefix='clients-',
 
2770
                   dir=os.path.dirname(stored_state_path),
 
2771
                   delete=False)) as stored_state:
2564
2772
                pickle.dump((clients, client_settings), stored_state)
 
2773
                tempname=stored_state.name
2565
2774
            os.rename(tempname, stored_state_path)
2566
2775
        except (IOError, OSError) as e:
2567
2776
            if not debug: