/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

  • Committer: Teddy Hogeborn
  • Date: 2014-02-16 02:42:42 UTC
  • Revision ID: teddy@recompile.se-20140216024242-9wiw1nkxgt7ohovj
Fix running of self-tests.

* debian/control (Build-Depends): Add Python dependencies to
                                  successfully run self-tests.
* debian/copyright: GPLv3 now has its own license file - use it.
* debian/watch: Set PGP signature URL.
* mandos (main): Bug fix: When running self-tests, set exit code.
* mandos-ctl (main): Cosmetic fix; use os.EX_OK instead of plain 0.

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-2014 Teddy Hogeborn
 
15
# Copyright © 2008-2014 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
68
68
import binascii
69
69
import tempfile
70
70
import itertools
 
71
import collections
71
72
 
72
73
import dbus
73
74
import dbus.service
78
79
import ctypes.util
79
80
import xml.dom.minidom
80
81
import inspect
81
 
import GnuPGInterface
82
82
 
83
83
try:
84
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
88
    except ImportError:
89
89
        SO_BINDTODEVICE = None
90
90
 
91
 
version = "1.5.3"
 
91
version = "1.6.3"
92
92
stored_state_file = "clients.pickle"
93
93
 
94
94
logger = logging.getLogger()
139
139
class PGPEngine(object):
140
140
    """A simple class for OpenPGP symmetric encryption & decryption"""
141
141
    def __init__(self):
142
 
        self.gnupg = GnuPGInterface.GnuPG()
143
142
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
144
 
        self.gnupg = GnuPGInterface.GnuPG()
145
 
        self.gnupg.options.meta_interactive = False
146
 
        self.gnupg.options.homedir = self.tempdir
147
 
        self.gnupg.options.extra_args.extend(['--force-mdc',
148
 
                                              '--quiet',
149
 
                                              '--no-use-agent'])
 
143
        self.gnupgargs = ['--batch',
 
144
                          '--home', self.tempdir,
 
145
                          '--force-mdc',
 
146
                          '--quiet',
 
147
                          '--no-use-agent']
150
148
    
151
149
    def __enter__(self):
152
150
        return self
153
151
    
154
 
    def __exit__ (self, exc_type, exc_value, traceback):
 
152
    def __exit__(self, exc_type, exc_value, traceback):
155
153
        self._cleanup()
156
154
        return False
157
155
    
174
172
    def password_encode(self, password):
175
173
        # Passphrase can not be empty and can not contain newlines or
176
174
        # NUL bytes.  So we prefix it and hex encode it.
177
 
        return b"mandos" + binascii.hexlify(password)
 
175
        encoded = b"mandos" + binascii.hexlify(password)
 
176
        if len(encoded) > 2048:
 
177
            # GnuPG can't handle long passwords, so encode differently
 
178
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
 
179
                       .replace(b"\n", b"\\n")
 
180
                       .replace(b"\0", b"\\x00"))
 
181
        return encoded
178
182
    
179
183
    def encrypt(self, data, password):
180
 
        self.gnupg.passphrase = self.password_encode(password)
181
 
        with open(os.devnull, "w") as devnull:
182
 
            try:
183
 
                proc = self.gnupg.run(['--symmetric'],
184
 
                                      create_fhs=['stdin', 'stdout'],
185
 
                                      attach_fhs={'stderr': devnull})
186
 
                with contextlib.closing(proc.handles['stdin']) as f:
187
 
                    f.write(data)
188
 
                with contextlib.closing(proc.handles['stdout']) as f:
189
 
                    ciphertext = f.read()
190
 
                proc.wait()
191
 
            except IOError as e:
192
 
                raise PGPError(e)
193
 
        self.gnupg.passphrase = None
 
184
        passphrase = self.password_encode(password)
 
185
        with tempfile.NamedTemporaryFile(dir=self.tempdir
 
186
                                         ) as passfile:
 
187
            passfile.write(passphrase)
 
188
            passfile.flush()
 
189
            proc = subprocess.Popen(['gpg', '--symmetric',
 
190
                                     '--passphrase-file',
 
191
                                     passfile.name]
 
192
                                    + self.gnupgargs,
 
193
                                    stdin = subprocess.PIPE,
 
194
                                    stdout = subprocess.PIPE,
 
195
                                    stderr = subprocess.PIPE)
 
196
            ciphertext, err = proc.communicate(input = data)
 
197
        if proc.returncode != 0:
 
198
            raise PGPError(err)
194
199
        return ciphertext
195
200
    
196
201
    def decrypt(self, data, password):
197
 
        self.gnupg.passphrase = self.password_encode(password)
198
 
        with open(os.devnull, "w") as devnull:
199
 
            try:
200
 
                proc = self.gnupg.run(['--decrypt'],
201
 
                                      create_fhs=['stdin', 'stdout'],
202
 
                                      attach_fhs={'stderr': devnull})
203
 
                with contextlib.closing(proc.handles['stdin']) as f:
204
 
                    f.write(data)
205
 
                with contextlib.closing(proc.handles['stdout']) as f:
206
 
                    decrypted_plaintext = f.read()
207
 
                proc.wait()
208
 
            except IOError as e:
209
 
                raise PGPError(e)
210
 
        self.gnupg.passphrase = None
 
202
        passphrase = self.password_encode(password)
 
203
        with tempfile.NamedTemporaryFile(dir = self.tempdir
 
204
                                         ) as passfile:
 
205
            passfile.write(passphrase)
 
206
            passfile.flush()
 
207
            proc = subprocess.Popen(['gpg', '--decrypt',
 
208
                                     '--passphrase-file',
 
209
                                     passfile.name]
 
210
                                    + self.gnupgargs,
 
211
                                    stdin = subprocess.PIPE,
 
212
                                    stdout = subprocess.PIPE,
 
213
                                    stderr = subprocess.PIPE)
 
214
            decrypted_plaintext, err = proc.communicate(input
 
215
                                                        = data)
 
216
        if proc.returncode != 0:
 
217
            raise PGPError(err)
211
218
        return decrypted_plaintext
212
219
 
213
220
 
233
240
               Used to optionally bind to the specified interface.
234
241
    name: string; Example: 'Mandos'
235
242
    type: string; Example: '_mandos._tcp'.
236
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
243
     See <https://www.iana.org/assignments/service-names-port-numbers>
237
244
    port: integer; what port to announce
238
245
    TXT: list of strings; TXT record for the service
239
246
    domain: string; Domain to publish on, default to .local if empty.
439
446
    runtime_expansions: Allowed attributes for runtime expansion.
440
447
    expires:    datetime.datetime(); time (UTC) when a client will be
441
448
                disabled, or None
 
449
    server_settings: The server_settings dict from main()
442
450
    """
443
451
    
444
452
    runtime_expansions = ("approval_delay", "approval_duration",
446
454
                          "fingerprint", "host", "interval",
447
455
                          "last_approval_request", "last_checked_ok",
448
456
                          "last_enabled", "name", "timeout")
449
 
    client_defaults = { "timeout": "5m",
450
 
                        "extended_timeout": "15m",
451
 
                        "interval": "2m",
 
457
    client_defaults = { "timeout": "PT5M",
 
458
                        "extended_timeout": "PT15M",
 
459
                        "interval": "PT2M",
452
460
                        "checker": "fping -q -- %%(host)s",
453
461
                        "host": "",
454
 
                        "approval_delay": "0s",
455
 
                        "approval_duration": "1s",
 
462
                        "approval_delay": "PT0S",
 
463
                        "approval_duration": "PT1S",
456
464
                        "approved_by_default": "True",
457
465
                        "enabled": "True",
458
466
                        }
519
527
        
520
528
        return settings
521
529
    
522
 
    def __init__(self, settings, name = None):
 
530
    def __init__(self, settings, name = None, server_settings=None):
523
531
        self.name = name
 
532
        if server_settings is None:
 
533
            server_settings = {}
 
534
        self.server_settings = server_settings
524
535
        # adding all client settings
525
536
        for setting, value in settings.iteritems():
526
537
            setattr(self, setting, value)
679
690
        # If a checker exists, make sure it is not a zombie
680
691
        try:
681
692
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
682
 
        except (AttributeError, OSError) as error:
683
 
            if (isinstance(error, OSError)
684
 
                and error.errno != errno.ECHILD):
685
 
                raise error
 
693
        except AttributeError:
 
694
            pass
 
695
        except OSError as error:
 
696
            if error.errno != errno.ECHILD:
 
697
                raise
686
698
        else:
687
699
            if pid:
688
700
                logger.warning("Checker was a zombie")
710
722
                # in normal mode, that is already done by daemon(),
711
723
                # and in debug mode we don't want to.  (Stdin is
712
724
                # always replaced by /dev/null.)
 
725
                # The exception is when not debugging but nevertheless
 
726
                # running in the foreground; use the previously
 
727
                # created wnull.
 
728
                popen_args = {}
 
729
                if (not self.server_settings["debug"]
 
730
                    and self.server_settings["foreground"]):
 
731
                    popen_args.update({"stdout": wnull,
 
732
                                       "stderr": wnull })
713
733
                self.checker = subprocess.Popen(command,
714
734
                                                close_fds=True,
715
 
                                                shell=True, cwd="/")
 
735
                                                shell=True, cwd="/",
 
736
                                                **popen_args)
716
737
            except OSError as error:
717
738
                logger.error("Failed to start subprocess",
718
739
                             exc_info=error)
 
740
                return True
719
741
            self.checker_callback_tag = (gobject.child_watch_add
720
742
                                         (self.checker.pid,
721
743
                                          self.checker_callback,
722
744
                                          data=command))
723
745
            # The checker may have completed before the gobject
724
746
            # watch was added.  Check for this.
725
 
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
747
            try:
 
748
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
749
            except OSError as error:
 
750
                if error.errno == errno.ECHILD:
 
751
                    # This should never happen
 
752
                    logger.error("Child process vanished",
 
753
                                 exc_info=error)
 
754
                    return True
 
755
                raise
726
756
            if pid:
727
757
                gobject.source_remove(self.checker_callback_tag)
728
758
                self.checker_callback(pid, status, command)
904
934
            # The byte_arrays option is not supported yet on
905
935
            # signatures other than "ay".
906
936
            if prop._dbus_signature != "ay":
907
 
                raise ValueError
 
937
                raise ValueError("Byte arrays not supported for non-"
 
938
                                 "'ay' signature {0!r}"
 
939
                                 .format(prop._dbus_signature))
908
940
            value = dbus.ByteArray(b''.join(chr(byte)
909
941
                                            for byte in value))
910
942
        prop(value)
1016
1048
        return xmlstring
1017
1049
 
1018
1050
 
1019
 
def datetime_to_dbus (dt, variant_level=0):
 
1051
def datetime_to_dbus(dt, variant_level=0):
1020
1052
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1021
1053
    if dt is None:
1022
1054
        return dbus.String("", variant_level = variant_level)
1030
1062
    interface names according to the "alt_interface_names" mapping.
1031
1063
    Usage:
1032
1064
    
1033
 
    @alternate_dbus_names({"org.example.Interface":
1034
 
                               "net.example.AlternateInterface"})
 
1065
    @alternate_dbus_interfaces({"org.example.Interface":
 
1066
                                    "net.example.AlternateInterface"})
1035
1067
    class SampleDBusObject(dbus.service.Object):
1036
1068
        @dbus.service.method("org.example.Interface")
1037
1069
        def SampleDBusMethod():
1068
1100
                interface_names.add(alt_interface)
1069
1101
                # Is this a D-Bus signal?
1070
1102
                if getattr(attribute, "_dbus_is_signal", False):
1071
 
                    # Extract the original non-method function by
1072
 
                    # black magic
 
1103
                    # Extract the original non-method undecorated
 
1104
                    # function by black magic
1073
1105
                    nonmethod_func = (dict(
1074
1106
                            zip(attribute.func_code.co_freevars,
1075
1107
                                attribute.__closure__))["func"]
1673
1705
            logger.debug("Protocol version: %r", line)
1674
1706
            try:
1675
1707
                if int(line.strip().split()[0]) > 1:
1676
 
                    raise RuntimeError
 
1708
                    raise RuntimeError(line)
1677
1709
            except (ValueError, IndexError, RuntimeError) as error:
1678
1710
                logger.error("Unknown protocol version: %s", error)
1679
1711
                return
1886
1918
    
1887
1919
    def add_pipe(self, parent_pipe, proc):
1888
1920
        """Dummy function; override as necessary"""
1889
 
        raise NotImplementedError
 
1921
        raise NotImplementedError()
1890
1922
 
1891
1923
 
1892
1924
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1899
1931
        use_ipv6:       Boolean; to use IPv6 or not
1900
1932
    """
1901
1933
    def __init__(self, server_address, RequestHandlerClass,
1902
 
                 interface=None, use_ipv6=True):
 
1934
                 interface=None, use_ipv6=True, socketfd=None):
 
1935
        """If socketfd is set, use that file descriptor instead of
 
1936
        creating a new one with socket.socket().
 
1937
        """
1903
1938
        self.interface = interface
1904
1939
        if use_ipv6:
1905
1940
            self.address_family = socket.AF_INET6
 
1941
        if socketfd is not None:
 
1942
            # Save the file descriptor
 
1943
            self.socketfd = socketfd
 
1944
            # Save the original socket.socket() function
 
1945
            self.socket_socket = socket.socket
 
1946
            # To implement --socket, we monkey patch socket.socket.
 
1947
            # 
 
1948
            # (When socketserver.TCPServer is a new-style class, we
 
1949
            # could make self.socket into a property instead of monkey
 
1950
            # patching socket.socket.)
 
1951
            # 
 
1952
            # Create a one-time-only replacement for socket.socket()
 
1953
            @functools.wraps(socket.socket)
 
1954
            def socket_wrapper(*args, **kwargs):
 
1955
                # Restore original function so subsequent calls are
 
1956
                # not affected.
 
1957
                socket.socket = self.socket_socket
 
1958
                del self.socket_socket
 
1959
                # This time only, return a new socket object from the
 
1960
                # saved file descriptor.
 
1961
                return socket.fromfd(self.socketfd, *args, **kwargs)
 
1962
            # Replace socket.socket() function with wrapper
 
1963
            socket.socket = socket_wrapper
 
1964
        # The socketserver.TCPServer.__init__ will call
 
1965
        # socket.socket(), which might be our replacement,
 
1966
        # socket_wrapper(), if socketfd was set.
1906
1967
        socketserver.TCPServer.__init__(self, server_address,
1907
1968
                                        RequestHandlerClass)
 
1969
    
1908
1970
    def server_bind(self):
1909
1971
        """This overrides the normal server_bind() function
1910
1972
        to bind to an interface if one was specified, and also NOT to
1918
1980
                try:
1919
1981
                    self.socket.setsockopt(socket.SOL_SOCKET,
1920
1982
                                           SO_BINDTODEVICE,
1921
 
                                           str(self.interface
1922
 
                                               + '\0'))
 
1983
                                           str(self.interface + '\0'))
1923
1984
                except socket.error as error:
1924
1985
                    if error.errno == errno.EPERM:
1925
 
                        logger.error("No permission to"
1926
 
                                     " bind to interface %s",
1927
 
                                     self.interface)
 
1986
                        logger.error("No permission to bind to"
 
1987
                                     " interface %s", self.interface)
1928
1988
                    elif error.errno == errno.ENOPROTOOPT:
1929
1989
                        logger.error("SO_BINDTODEVICE not available;"
1930
1990
                                     " cannot bind to interface %s",
1931
1991
                                     self.interface)
1932
1992
                    elif error.errno == errno.ENODEV:
1933
 
                        logger.error("Interface %s does not"
1934
 
                                     " exist, cannot bind",
1935
 
                                     self.interface)
 
1993
                        logger.error("Interface %s does not exist,"
 
1994
                                     " cannot bind", self.interface)
1936
1995
                    else:
1937
1996
                        raise
1938
1997
        # Only bind(2) the socket if we really need to.
1941
2000
                if self.address_family == socket.AF_INET6:
1942
2001
                    any_address = "::" # in6addr_any
1943
2002
                else:
1944
 
                    any_address = socket.INADDR_ANY
 
2003
                    any_address = "0.0.0.0" # INADDR_ANY
1945
2004
                self.server_address = (any_address,
1946
2005
                                       self.server_address[1])
1947
2006
            elif not self.server_address[1]:
1968
2027
    """
1969
2028
    def __init__(self, server_address, RequestHandlerClass,
1970
2029
                 interface=None, use_ipv6=True, clients=None,
1971
 
                 gnutls_priority=None, use_dbus=True):
 
2030
                 gnutls_priority=None, use_dbus=True, socketfd=None):
1972
2031
        self.enabled = False
1973
2032
        self.clients = clients
1974
2033
        if self.clients is None:
1978
2037
        IPv6_TCPServer.__init__(self, server_address,
1979
2038
                                RequestHandlerClass,
1980
2039
                                interface = interface,
1981
 
                                use_ipv6 = use_ipv6)
 
2040
                                use_ipv6 = use_ipv6,
 
2041
                                socketfd = socketfd)
1982
2042
    def server_activate(self):
1983
2043
        if self.enabled:
1984
2044
            return socketserver.TCPServer.server_activate(self)
2062
2122
        return True
2063
2123
 
2064
2124
 
 
2125
def rfc3339_duration_to_delta(duration):
 
2126
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2127
    
 
2128
    >>> rfc3339_duration_to_delta("P7D")
 
2129
    datetime.timedelta(7)
 
2130
    >>> rfc3339_duration_to_delta("PT60S")
 
2131
    datetime.timedelta(0, 60)
 
2132
    >>> rfc3339_duration_to_delta("PT60M")
 
2133
    datetime.timedelta(0, 3600)
 
2134
    >>> rfc3339_duration_to_delta("PT24H")
 
2135
    datetime.timedelta(1)
 
2136
    >>> rfc3339_duration_to_delta("P1W")
 
2137
    datetime.timedelta(7)
 
2138
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2139
    datetime.timedelta(0, 330)
 
2140
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2141
    datetime.timedelta(1, 200)
 
2142
    """
 
2143
    
 
2144
    # Parsing an RFC 3339 duration with regular expressions is not
 
2145
    # possible - there would have to be multiple places for the same
 
2146
    # values, like seconds.  The current code, while more esoteric, is
 
2147
    # cleaner without depending on a parsing library.  If Python had a
 
2148
    # built-in library for parsing we would use it, but we'd like to
 
2149
    # avoid excessive use of external libraries.
 
2150
    
 
2151
    # New type for defining tokens, syntax, and semantics all-in-one
 
2152
    Token = collections.namedtuple("Token",
 
2153
                                   ("regexp", # To match token; if
 
2154
                                              # "value" is not None,
 
2155
                                              # must have a "group"
 
2156
                                              # containing digits
 
2157
                                    "value",  # datetime.timedelta or
 
2158
                                              # None
 
2159
                                    "followers")) # Tokens valid after
 
2160
                                                  # this token
 
2161
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2162
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2163
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2164
    token_second = Token(re.compile(r"(\d+)S"),
 
2165
                         datetime.timedelta(seconds=1),
 
2166
                         frozenset((token_end,)))
 
2167
    token_minute = Token(re.compile(r"(\d+)M"),
 
2168
                         datetime.timedelta(minutes=1),
 
2169
                         frozenset((token_second, token_end)))
 
2170
    token_hour = Token(re.compile(r"(\d+)H"),
 
2171
                       datetime.timedelta(hours=1),
 
2172
                       frozenset((token_minute, token_end)))
 
2173
    token_time = Token(re.compile(r"T"),
 
2174
                       None,
 
2175
                       frozenset((token_hour, token_minute,
 
2176
                                  token_second)))
 
2177
    token_day = Token(re.compile(r"(\d+)D"),
 
2178
                      datetime.timedelta(days=1),
 
2179
                      frozenset((token_time, token_end)))
 
2180
    token_month = Token(re.compile(r"(\d+)M"),
 
2181
                        datetime.timedelta(weeks=4),
 
2182
                        frozenset((token_day, token_end)))
 
2183
    token_year = Token(re.compile(r"(\d+)Y"),
 
2184
                       datetime.timedelta(weeks=52),
 
2185
                       frozenset((token_month, token_end)))
 
2186
    token_week = Token(re.compile(r"(\d+)W"),
 
2187
                       datetime.timedelta(weeks=1),
 
2188
                       frozenset((token_end,)))
 
2189
    token_duration = Token(re.compile(r"P"), None,
 
2190
                           frozenset((token_year, token_month,
 
2191
                                      token_day, token_time,
 
2192
                                      token_week))),
 
2193
    # Define starting values
 
2194
    value = datetime.timedelta() # Value so far
 
2195
    found_token = None
 
2196
    followers = frozenset(token_duration,) # Following valid tokens
 
2197
    s = duration                # String left to parse
 
2198
    # Loop until end token is found
 
2199
    while found_token is not token_end:
 
2200
        # Search for any currently valid tokens
 
2201
        for token in followers:
 
2202
            match = token.regexp.match(s)
 
2203
            if match is not None:
 
2204
                # Token found
 
2205
                if token.value is not None:
 
2206
                    # Value found, parse digits
 
2207
                    factor = int(match.group(1), 10)
 
2208
                    # Add to value so far
 
2209
                    value += factor * token.value
 
2210
                # Strip token from string
 
2211
                s = token.regexp.sub("", s, 1)
 
2212
                # Go to found token
 
2213
                found_token = token
 
2214
                # Set valid next tokens
 
2215
                followers = found_token.followers
 
2216
                break
 
2217
        else:
 
2218
            # No currently valid tokens were found
 
2219
            raise ValueError("Invalid RFC 3339 duration")
 
2220
    # End token found
 
2221
    return value
 
2222
 
 
2223
 
2065
2224
def string_to_delta(interval):
2066
2225
    """Parse a string and return a datetime.timedelta
2067
2226
    
2078
2237
    >>> string_to_delta('5m 30s')
2079
2238
    datetime.timedelta(0, 330)
2080
2239
    """
 
2240
    
 
2241
    try:
 
2242
        return rfc3339_duration_to_delta(interval)
 
2243
    except ValueError:
 
2244
        pass
 
2245
    
2081
2246
    timevalue = datetime.timedelta(0)
2082
2247
    for s in interval.split():
2083
2248
        try:
2096
2261
            else:
2097
2262
                raise ValueError("Unknown suffix {0!r}"
2098
2263
                                 .format(suffix))
2099
 
        except (ValueError, IndexError) as e:
 
2264
        except IndexError as e:
2100
2265
            raise ValueError(*(e.args))
2101
2266
        timevalue += delta
2102
2267
    return timevalue
2146
2311
                        help="Run self-test")
2147
2312
    parser.add_argument("--debug", action="store_true",
2148
2313
                        help="Debug mode; run in foreground and log"
2149
 
                        " to terminal")
 
2314
                        " to terminal", default=None)
2150
2315
    parser.add_argument("--debuglevel", metavar="LEVEL",
2151
2316
                        help="Debug level for stdout output")
2152
2317
    parser.add_argument("--priority", help="GnuTLS"
2159
2324
                        " files")
2160
2325
    parser.add_argument("--no-dbus", action="store_false",
2161
2326
                        dest="use_dbus", help="Do not provide D-Bus"
2162
 
                        " system bus interface")
 
2327
                        " system bus interface", default=None)
2163
2328
    parser.add_argument("--no-ipv6", action="store_false",
2164
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2329
                        dest="use_ipv6", help="Do not use IPv6",
 
2330
                        default=None)
2165
2331
    parser.add_argument("--no-restore", action="store_false",
2166
2332
                        dest="restore", help="Do not restore stored"
2167
 
                        " state")
 
2333
                        " state", default=None)
 
2334
    parser.add_argument("--socket", type=int,
 
2335
                        help="Specify a file descriptor to a network"
 
2336
                        " socket to use instead of creating one")
2168
2337
    parser.add_argument("--statedir", metavar="DIR",
2169
2338
                        help="Directory to save/restore state in")
 
2339
    parser.add_argument("--foreground", action="store_true",
 
2340
                        help="Run in foreground", default=None)
2170
2341
    
2171
2342
    options = parser.parse_args()
2172
2343
    
2173
2344
    if options.check:
2174
2345
        import doctest
2175
 
        doctest.testmod()
2176
 
        sys.exit()
 
2346
        fail_count, test_count = doctest.testmod()
 
2347
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2177
2348
    
2178
2349
    # Default values for config file for server-global settings
2179
2350
    server_defaults = { "interface": "",
2181
2352
                        "port": "",
2182
2353
                        "debug": "False",
2183
2354
                        "priority":
2184
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2355
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2185
2356
                        "servicename": "Mandos",
2186
2357
                        "use_dbus": "True",
2187
2358
                        "use_ipv6": "True",
2188
2359
                        "debuglevel": "",
2189
2360
                        "restore": "True",
2190
 
                        "statedir": "/var/lib/mandos"
 
2361
                        "socket": "",
 
2362
                        "statedir": "/var/lib/mandos",
 
2363
                        "foreground": "False",
2191
2364
                        }
2192
2365
    
2193
2366
    # Parse config file for server-global settings
2198
2371
    # Convert the SafeConfigParser object to a dict
2199
2372
    server_settings = server_config.defaults()
2200
2373
    # Use the appropriate methods on the non-string config options
2201
 
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2374
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2202
2375
        server_settings[option] = server_config.getboolean("DEFAULT",
2203
2376
                                                           option)
2204
2377
    if server_settings["port"]:
2205
2378
        server_settings["port"] = server_config.getint("DEFAULT",
2206
2379
                                                       "port")
 
2380
    if server_settings["socket"]:
 
2381
        server_settings["socket"] = server_config.getint("DEFAULT",
 
2382
                                                         "socket")
 
2383
        # Later, stdin will, and stdout and stderr might, be dup'ed
 
2384
        # over with an opened os.devnull.  But we don't want this to
 
2385
        # happen with a supplied network socket.
 
2386
        if 0 <= server_settings["socket"] <= 2:
 
2387
            server_settings["socket"] = os.dup(server_settings
 
2388
                                               ["socket"])
2207
2389
    del server_config
2208
2390
    
2209
2391
    # Override the settings from the config file with command line
2211
2393
    for option in ("interface", "address", "port", "debug",
2212
2394
                   "priority", "servicename", "configdir",
2213
2395
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2214
 
                   "statedir"):
 
2396
                   "statedir", "socket", "foreground"):
2215
2397
        value = getattr(options, option)
2216
2398
        if value is not None:
2217
2399
            server_settings[option] = value
2220
2402
    for option in server_settings.keys():
2221
2403
        if type(server_settings[option]) is str:
2222
2404
            server_settings[option] = unicode(server_settings[option])
 
2405
    # Force all boolean options to be boolean
 
2406
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2407
                   "foreground"):
 
2408
        server_settings[option] = bool(server_settings[option])
 
2409
    # Debug implies foreground
 
2410
    if server_settings["debug"]:
 
2411
        server_settings["foreground"] = True
2223
2412
    # Now we have our good server settings in "server_settings"
2224
2413
    
2225
2414
    ##################################################################
2231
2420
    use_ipv6 = server_settings["use_ipv6"]
2232
2421
    stored_state_path = os.path.join(server_settings["statedir"],
2233
2422
                                     stored_state_file)
 
2423
    foreground = server_settings["foreground"]
2234
2424
    
2235
2425
    if debug:
2236
2426
        initlogger(debug, logging.DEBUG)
2265
2455
                              use_ipv6=use_ipv6,
2266
2456
                              gnutls_priority=
2267
2457
                              server_settings["priority"],
2268
 
                              use_dbus=use_dbus)
2269
 
    if not debug:
2270
 
        pidfilename = "/var/run/mandos.pid"
 
2458
                              use_dbus=use_dbus,
 
2459
                              socketfd=(server_settings["socket"]
 
2460
                                        or None))
 
2461
    if not foreground:
 
2462
        pidfilename = "/run/mandos.pid"
 
2463
        if not os.path.isdir("/run/."):
 
2464
            pidfilename = "/var/run/mandos.pid"
 
2465
        pidfile = None
2271
2466
        try:
2272
2467
            pidfile = open(pidfilename, "w")
2273
2468
        except IOError as e:
2289
2484
        os.setuid(uid)
2290
2485
    except OSError as error:
2291
2486
        if error.errno != errno.EPERM:
2292
 
            raise error
 
2487
            raise
2293
2488
    
2294
2489
    if debug:
2295
2490
        # Enable all possible GnuTLS debugging
2312
2507
            os.close(null)
2313
2508
    
2314
2509
    # Need to fork before connecting to D-Bus
2315
 
    if not debug:
 
2510
    if not foreground:
2316
2511
        # Close all input and output, do double fork, etc.
2317
2512
        daemon()
2318
2513
    
 
2514
    # multiprocessing will use threads, so before we use gobject we
 
2515
    # need to inform gobject that threads will be used.
2319
2516
    gobject.threads_init()
2320
2517
    
2321
2518
    global main_loop
2356
2553
    old_client_settings = {}
2357
2554
    clients_data = {}
2358
2555
    
 
2556
    # This is used to redirect stdout and stderr for checker processes
 
2557
    global wnull
 
2558
    wnull = open(os.devnull, "w") # A writable /dev/null
 
2559
    # Only used if server is running in foreground but not in debug
 
2560
    # mode
 
2561
    if debug or not foreground:
 
2562
        wnull.close()
 
2563
    
2359
2564
    # Get client data and settings from last running state.
2360
2565
    if server_settings["restore"]:
2361
2566
        try:
2377
2582
    
2378
2583
    with PGPEngine() as pgp:
2379
2584
        for client_name, client in clients_data.iteritems():
 
2585
            # Skip removed clients
 
2586
            if client_name not in client_settings:
 
2587
                continue
 
2588
            
2380
2589
            # Decide which value to use after restoring saved state.
2381
2590
            # We have three different values: Old config file,
2382
2591
            # new config file, and saved state.
2444
2653
    # Create all client objects
2445
2654
    for client_name, client in clients_data.iteritems():
2446
2655
        tcp_server.clients[client_name] = client_class(
2447
 
            name = client_name, settings = client)
 
2656
            name = client_name, settings = client,
 
2657
            server_settings = server_settings)
2448
2658
    
2449
2659
    if not tcp_server.clients:
2450
2660
        logger.warning("No clients defined")
2451
2661
    
2452
 
    if not debug:
2453
 
        try:
2454
 
            with pidfile:
2455
 
                pid = os.getpid()
2456
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
2457
 
            del pidfile
2458
 
        except IOError:
2459
 
            logger.error("Could not write to file %r with PID %d",
2460
 
                         pidfilename, pid)
2461
 
        except NameError:
2462
 
            # "pidfile" was never created
2463
 
            pass
 
2662
    if not foreground:
 
2663
        if pidfile is not None:
 
2664
            try:
 
2665
                with pidfile:
 
2666
                    pid = os.getpid()
 
2667
                    pidfile.write(str(pid) + "\n".encode("utf-8"))
 
2668
            except IOError:
 
2669
                logger.error("Could not write to file %r with PID %d",
 
2670
                             pidfilename, pid)
 
2671
        del pidfile
2464
2672
        del pidfilename
2465
2673
    
2466
2674
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2535
2743
        service.cleanup()
2536
2744
        
2537
2745
        multiprocessing.active_children()
 
2746
        wnull.close()
2538
2747
        if not (tcp_server.clients or client_settings):
2539
2748
            return
2540
2749
        
2552
2761
                # A list of attributes that can not be pickled
2553
2762
                # + secret.
2554
2763
                exclude = set(("bus", "changedstate", "secret",
2555
 
                               "checker"))
 
2764
                               "checker", "server_settings"))
2556
2765
                for name, typ in (inspect.getmembers
2557
2766
                                  (dbus.service.Object)):
2558
2767
                    exclude.add(name)
2586
2795
            else:
2587
2796
                logger.warning("Could not save persistent state:",
2588
2797
                               exc_info=e)
2589
 
                raise e
 
2798
                raise
2590
2799
        
2591
2800
        # Delete all clients, and settings from config
2592
2801
        while tcp_server.clients: