/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: 2012-05-24 18:10:10 UTC
  • Revision ID: teddy@recompile.se-20120524181010-cg4zcc6e5igbanbc
* Makefile (DOCBOOKTOMAN): Only run man --warnings if both "man" and
                           the en_US.utf8 locale exists.
* debian/control (Build-Depends): Removed "man, locales-all".
  (Standards-Version): Updated to "3.9.3".
* debian/copyright (Format): Updated to
  "http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/".
* mandos (PGPEngine.__exit__, datetime_to_dbus): White space fixes.
  (alternate_dbus_interfaces): Doc string fix.

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