/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 at recompile
  • Date: 2020-07-04 08:59:37 UTC
  • Revision ID: teddy@recompile.se-20200704085937-r495zb32nfng9lnt
In initramfs-tools boots, only use setsid when available

* initramfs-tools-script: If available, use setsid to start
  mandos-to-cryptroot-unlock.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/python
2
 
# -*- mode: python; coding: utf-8 -*-
 
1
#!/usr/bin/python3 -bI
 
2
# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
5
#
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
 
# Copyright © 2008-2018 Teddy Hogeborn
15
 
# Copyright © 2008-2018 Björn Påhlsson
 
14
# Copyright © 2008-2019 Teddy Hogeborn
 
15
# Copyright © 2008-2019 Björn Påhlsson
16
16
#
17
17
# This file is part of Mandos.
18
18
#
77
77
import itertools
78
78
import collections
79
79
import codecs
 
80
import unittest
 
81
import random
 
82
import shlex
80
83
 
81
84
import dbus
82
85
import dbus.service
 
86
import gi
83
87
from gi.repository import GLib
84
88
from dbus.mainloop.glib import DBusGMainLoop
85
89
import ctypes
87
91
import xml.dom.minidom
88
92
import inspect
89
93
 
 
94
if sys.version_info.major == 2:
 
95
    __metaclass__ = type
 
96
    str = unicode
 
97
 
 
98
# Add collections.abc.Callable if it does not exist
 
99
try:
 
100
    collections.abc.Callable
 
101
except AttributeError:
 
102
    class abc:
 
103
        Callable = collections.Callable
 
104
    collections.abc = abc
 
105
    del abc
 
106
 
 
107
# Add shlex.quote if it does not exist
 
108
try:
 
109
    shlex.quote
 
110
except AttributeError:
 
111
    shlex.quote = re.escape
 
112
 
 
113
# Show warnings by default
 
114
if not sys.warnoptions:
 
115
    import warnings
 
116
    warnings.simplefilter("default")
 
117
 
90
118
# Try to find the value of SO_BINDTODEVICE:
91
119
try:
92
120
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
112
140
            # No value found
113
141
            SO_BINDTODEVICE = None
114
142
 
115
 
if sys.version_info.major == 2:
116
 
    str = unicode
 
143
if sys.version_info < (3, 2):
 
144
    configparser.Configparser = configparser.SafeConfigParser
117
145
 
118
 
version = "1.7.20"
 
146
version = "1.8.11"
119
147
stored_state_file = "clients.pickle"
120
148
 
121
149
logger = logging.getLogger()
 
150
logging.captureWarnings(True)   # Show warnings via the logging system
122
151
syslogger = None
123
152
 
124
153
try:
179
208
    pass
180
209
 
181
210
 
182
 
class PGPEngine(object):
 
211
class PGPEngine:
183
212
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
213
 
185
214
    def __init__(self):
189
218
            output = subprocess.check_output(["gpgconf"])
190
219
            for line in output.splitlines():
191
220
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
221
                if name == b"gpg":
193
222
                    self.gpg = path
194
223
                    break
195
224
        except OSError as e:
200
229
                          '--force-mdc',
201
230
                          '--quiet']
202
231
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
232
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
233
            self.gnupgargs.append("--no-use-agent")
205
234
 
206
235
    def __enter__(self):
275
304
 
276
305
 
277
306
# Pretend that we have an Avahi module
278
 
class Avahi(object):
279
 
    """This isn't so much a class as it is a module-like namespace.
280
 
    It is instantiated once, and simulates having an Avahi module."""
 
307
class avahi:
 
308
    """This isn't so much a class as it is a module-like namespace."""
281
309
    IF_UNSPEC = -1               # avahi-common/address.h
282
310
    PROTO_UNSPEC = -1            # avahi-common/address.h
283
311
    PROTO_INET = 0               # avahi-common/address.h
287
315
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
288
316
    DBUS_PATH_SERVER = "/"
289
317
 
290
 
    def string_array_to_txt_array(self, t):
 
318
    @staticmethod
 
319
    def string_array_to_txt_array(t):
291
320
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
292
321
                           for s in t), signature="ay")
293
322
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
298
327
    SERVER_RUNNING = 2           # avahi-common/defs.h
299
328
    SERVER_COLLISION = 3         # avahi-common/defs.h
300
329
    SERVER_FAILURE = 4           # avahi-common/defs.h
301
 
avahi = Avahi()
302
330
 
303
331
 
304
332
class AvahiError(Exception):
316
344
    pass
317
345
 
318
346
 
319
 
class AvahiService(object):
 
347
class AvahiService:
320
348
    """An Avahi (Zeroconf) service.
321
349
 
322
350
    Attributes:
504
532
 
505
533
 
506
534
# Pretend that we have a GnuTLS module
507
 
class GnuTLS(object):
508
 
    """This isn't so much a class as it is a module-like namespace.
509
 
    It is instantiated once, and simulates having a GnuTLS module."""
 
535
class gnutls:
 
536
    """This isn't so much a class as it is a module-like namespace."""
510
537
 
511
538
    library = ctypes.util.find_library("gnutls")
512
539
    if library is None:
513
540
        library = ctypes.util.find_library("gnutls-deb0")
514
541
    _library = ctypes.cdll.LoadLibrary(library)
515
542
    del library
516
 
    _need_version = b"3.3.0"
517
 
    _tls_rawpk_version = b"3.6.6"
518
 
 
519
 
    def __init__(self):
520
 
        # Need to use "self" here, since this method is called before
521
 
        # the assignment to the "gnutls" global variable happens.
522
 
        if self.check_version(self._need_version) is None:
523
 
            raise self.Error("Needs GnuTLS {} or later"
524
 
                             .format(self._need_version))
525
543
 
526
544
    # Unless otherwise indicated, the constants and types below are
527
545
    # all from the gnutls/gnutls.h C header file.
569
587
 
570
588
    # Exceptions
571
589
    class Error(Exception):
572
 
        # We need to use the class name "GnuTLS" here, since this
573
 
        # exception might be raised from within GnuTLS.__init__,
574
 
        # which is called before the assignment to the "gnutls"
575
 
        # global variable has happened.
576
590
        def __init__(self, message=None, code=None, args=()):
577
591
            # Default usage is by a message string, but if a return
578
592
            # code is passed, convert it to a string with
579
593
            # gnutls.strerror()
580
594
            self.code = code
581
595
            if message is None and code is not None:
582
 
                message = GnuTLS.strerror(code)
583
 
            return super(GnuTLS.Error, self).__init__(
 
596
                message = gnutls.strerror(code)
 
597
            return super(gnutls.Error, self).__init__(
584
598
                message, *args)
585
599
 
586
600
    class CertificateSecurityError(Error):
587
601
        pass
588
602
 
589
603
    # Classes
590
 
    class Credentials(object):
 
604
    class Credentials:
591
605
        def __init__(self):
592
606
            self._c_object = gnutls.certificate_credentials_t()
593
607
            gnutls.certificate_allocate_credentials(
597
611
        def __del__(self):
598
612
            gnutls.certificate_free_credentials(self._c_object)
599
613
 
600
 
    class ClientSession(object):
 
614
    class ClientSession:
601
615
        def __init__(self, socket, credentials=None):
602
616
            self._c_object = gnutls.session_t()
603
617
            gnutls_flags = gnutls.CLIENT
604
 
            if gnutls.check_version("3.5.6"):
 
618
            if gnutls.check_version(b"3.5.6"):
605
619
                gnutls_flags |= gnutls.NO_TICKETS
606
620
            if gnutls.has_rawpk:
607
621
                gnutls_flags |= gnutls.ENABLE_RAWPK
744
758
    check_version.argtypes = [ctypes.c_char_p]
745
759
    check_version.restype = ctypes.c_char_p
746
760
 
 
761
    _need_version = b"3.3.0"
 
762
    if check_version(_need_version) is None:
 
763
        raise self.Error("Needs GnuTLS {} or later"
 
764
                         .format(_need_version))
 
765
 
 
766
    _tls_rawpk_version = b"3.6.6"
747
767
    has_rawpk = bool(check_version(_tls_rawpk_version))
748
768
 
749
769
    if has_rawpk:
803
823
                                                    ctypes.c_size_t)]
804
824
        openpgp_crt_get_fingerprint.restype = _error_code
805
825
 
806
 
    if check_version("3.6.4"):
 
826
    if check_version(b"3.6.4"):
807
827
        certificate_type_get2 = _library.gnutls_certificate_type_get2
808
828
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
809
829
        certificate_type_get2.restype = _error_code
810
830
 
811
831
    # Remove non-public functions
812
832
    del _error_code, _retry_on_error
813
 
# Create the global "gnutls" object, simulating a module
814
 
gnutls = GnuTLS()
815
833
 
816
834
 
817
835
def call_pipe(connection,       # : multiprocessing.Connection
825
843
    connection.close()
826
844
 
827
845
 
828
 
class Client(object):
 
846
class Client:
829
847
    """A representation of a client host served by this server.
830
848
 
831
849
    Attributes:
832
850
    approved:   bool(); 'None' if not yet approved/disapproved
833
851
    approval_delay: datetime.timedelta(); Time to wait for approval
834
852
    approval_duration: datetime.timedelta(); Duration of one approval
835
 
    checker:    subprocess.Popen(); a running checker process used
836
 
                                    to see if the client lives.
837
 
                                    'None' if no process is running.
 
853
    checker: multiprocessing.Process(); a running checker process used
 
854
             to see if the client lives. 'None' if no process is
 
855
             running.
838
856
    checker_callback_tag: a GLib event source tag, or None
839
857
    checker_command: string; External command which is run to check
840
858
                     if client lives.  %() expansions are done at
1034
1052
        if self.checker_initiator_tag is not None:
1035
1053
            GLib.source_remove(self.checker_initiator_tag)
1036
1054
        self.checker_initiator_tag = GLib.timeout_add(
1037
 
            int(self.interval.total_seconds() * 1000),
 
1055
            random.randrange(int(self.interval.total_seconds() * 1000
 
1056
                                 + 1)),
1038
1057
            self.start_checker)
1039
1058
        # Schedule a disable() when 'timeout' has passed
1040
1059
        if self.disable_initiator_tag is not None:
1047
1066
    def checker_callback(self, source, condition, connection,
1048
1067
                         command):
1049
1068
        """The checker has completed, so take appropriate actions."""
1050
 
        self.checker_callback_tag = None
1051
 
        self.checker = None
1052
1069
        # Read return code from connection (see call_pipe)
1053
1070
        returncode = connection.recv()
1054
1071
        connection.close()
 
1072
        if self.checker is not None:
 
1073
            self.checker.join()
 
1074
        self.checker_callback_tag = None
 
1075
        self.checker = None
1055
1076
 
1056
1077
        if returncode >= 0:
1057
1078
            self.last_checker_status = returncode
1113
1134
        if self.checker is None:
1114
1135
            # Escape attributes for the shell
1115
1136
            escaped_attrs = {
1116
 
                attr: re.escape(str(getattr(self, attr)))
 
1137
                attr: shlex.quote(str(getattr(self, attr)))
1117
1138
                for attr in self.runtime_expansions}
1118
1139
            try:
1119
1140
                command = self.checker_command % escaped_attrs
1146
1167
                kwargs=popen_args)
1147
1168
            self.checker.start()
1148
1169
            self.checker_callback_tag = GLib.io_add_watch(
1149
 
                pipe[0].fileno(), GLib.IO_IN,
 
1170
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1171
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1150
1172
                self.checker_callback, pipe[0], command)
1151
1173
        # Re-run this periodically if run by GLib.timeout_add
1152
1174
        return True
1407
1429
                raise ValueError("Byte arrays not supported for non-"
1408
1430
                                 "'ay' signature {!r}"
1409
1431
                                 .format(prop._dbus_signature))
1410
 
            value = dbus.ByteArray(b''.join(chr(byte)
1411
 
                                            for byte in value))
 
1432
            value = dbus.ByteArray(bytes(value))
1412
1433
        prop(value)
1413
1434
 
1414
1435
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2219
2240
    del _interface
2220
2241
 
2221
2242
 
2222
 
class ProxyClient(object):
 
2243
class ProxyClient:
2223
2244
    def __init__(self, child_pipe, key_id, fpr, address):
2224
2245
        self._pipe = child_pipe
2225
2246
        self._pipe.send(('init', key_id, fpr, address))
2298
2319
            approval_required = False
2299
2320
            try:
2300
2321
                if gnutls.has_rawpk:
2301
 
                    fpr = ""
 
2322
                    fpr = b""
2302
2323
                    try:
2303
2324
                        key_id = self.key_id(
2304
2325
                            self.peer_certificate(session))
2308
2329
                    logger.debug("Key ID: %s", key_id)
2309
2330
 
2310
2331
                else:
2311
 
                    key_id = ""
 
2332
                    key_id = b""
2312
2333
                    try:
2313
2334
                        fpr = self.fingerprint(
2314
2335
                            self.peer_certificate(session))
2498
2519
        return hex_fpr
2499
2520
 
2500
2521
 
2501
 
class MultiprocessingMixIn(object):
 
2522
class MultiprocessingMixIn:
2502
2523
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2503
2524
 
2504
2525
    def sub_process_main(self, request, address):
2516
2537
        return proc
2517
2538
 
2518
2539
 
2519
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2540
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2520
2541
    """ adds a pipe to the MixIn """
2521
2542
 
2522
2543
    def process_request(self, request, client_address):
2537
2558
 
2538
2559
 
2539
2560
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2540
 
                     socketserver.TCPServer, object):
 
2561
                     socketserver.TCPServer):
2541
2562
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2542
2563
 
2543
2564
    Attributes:
2616
2637
                    raise
2617
2638
        # Only bind(2) the socket if we really need to.
2618
2639
        if self.server_address[0] or self.server_address[1]:
 
2640
            if self.server_address[1]:
 
2641
                self.allow_reuse_address = True
2619
2642
            if not self.server_address[0]:
2620
2643
                if self.address_family == socket.AF_INET6:
2621
2644
                    any_address = "::"  # in6addr_any
2674
2697
    def add_pipe(self, parent_pipe, proc):
2675
2698
        # Call "handle_ipc" for both data and EOF events
2676
2699
        GLib.io_add_watch(
2677
 
            parent_pipe.fileno(),
2678
 
            GLib.IO_IN | GLib.IO_HUP,
 
2700
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2701
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2679
2702
            functools.partial(self.handle_ipc,
2680
2703
                              parent_pipe=parent_pipe,
2681
2704
                              proc=proc))
2700
2723
            address = request[3]
2701
2724
 
2702
2725
            for c in self.clients.values():
 
2726
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
 
2727
                    continue
2703
2728
                if key_id and c.key_id == key_id:
2704
2729
                    client = c
2705
2730
                    break
2717
2742
                return False
2718
2743
 
2719
2744
            GLib.io_add_watch(
2720
 
                parent_pipe.fileno(),
2721
 
                GLib.IO_IN | GLib.IO_HUP,
 
2745
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2746
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2722
2747
                functools.partial(self.handle_ipc,
2723
2748
                                  parent_pipe=parent_pipe,
2724
2749
                                  proc=proc,
2739
2764
        if command == 'getattr':
2740
2765
            attrname = request[1]
2741
2766
            if isinstance(client_object.__getattribute__(attrname),
2742
 
                          collections.Callable):
 
2767
                          collections.abc.Callable):
2743
2768
                parent_pipe.send(('function', ))
2744
2769
            else:
2745
2770
                parent_pipe.send((
2756
2781
def rfc3339_duration_to_delta(duration):
2757
2782
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2758
2783
 
2759
 
    >>> rfc3339_duration_to_delta("P7D")
2760
 
    datetime.timedelta(7)
2761
 
    >>> rfc3339_duration_to_delta("PT60S")
2762
 
    datetime.timedelta(0, 60)
2763
 
    >>> rfc3339_duration_to_delta("PT60M")
2764
 
    datetime.timedelta(0, 3600)
2765
 
    >>> rfc3339_duration_to_delta("PT24H")
2766
 
    datetime.timedelta(1)
2767
 
    >>> rfc3339_duration_to_delta("P1W")
2768
 
    datetime.timedelta(7)
2769
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2770
 
    datetime.timedelta(0, 330)
2771
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2772
 
    datetime.timedelta(1, 200)
 
2784
    >>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
 
2785
    True
 
2786
    >>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
 
2787
    True
 
2788
    >>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
 
2789
    True
 
2790
    >>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
 
2791
    True
 
2792
    >>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
 
2793
    True
 
2794
    >>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
 
2795
    True
 
2796
    >>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
 
2797
    True
2773
2798
    """
2774
2799
 
2775
2800
    # Parsing an RFC 3339 duration with regular expressions is not
2855
2880
def string_to_delta(interval):
2856
2881
    """Parse a string and return a datetime.timedelta
2857
2882
 
2858
 
    >>> string_to_delta('7d')
2859
 
    datetime.timedelta(7)
2860
 
    >>> string_to_delta('60s')
2861
 
    datetime.timedelta(0, 60)
2862
 
    >>> string_to_delta('60m')
2863
 
    datetime.timedelta(0, 3600)
2864
 
    >>> string_to_delta('24h')
2865
 
    datetime.timedelta(1)
2866
 
    >>> string_to_delta('1w')
2867
 
    datetime.timedelta(7)
2868
 
    >>> string_to_delta('5m 30s')
2869
 
    datetime.timedelta(0, 330)
 
2883
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2884
    True
 
2885
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2886
    True
 
2887
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2888
    True
 
2889
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2890
    True
 
2891
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2892
    True
 
2893
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2894
    True
2870
2895
    """
2871
2896
 
2872
2897
    try:
2974
2999
 
2975
3000
    options = parser.parse_args()
2976
3001
 
2977
 
    if options.check:
2978
 
        import doctest
2979
 
        fail_count, test_count = doctest.testmod()
2980
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2981
 
 
2982
3002
    # Default values for config file for server-global settings
2983
3003
    if gnutls.has_rawpk:
2984
3004
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3004
3024
    del priority
3005
3025
 
3006
3026
    # Parse config file for server-global settings
3007
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3027
    server_config = configparser.ConfigParser(server_defaults)
3008
3028
    del server_defaults
3009
3029
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3010
 
    # Convert the SafeConfigParser object to a dict
 
3030
    # Convert the ConfigParser object to a dict
3011
3031
    server_settings = server_config.defaults()
3012
3032
    # Use the appropriate methods on the non-string config options
3013
3033
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3085
3105
                                  server_settings["servicename"])))
3086
3106
 
3087
3107
    # Parse config file with clients
3088
 
    client_config = configparser.SafeConfigParser(Client
3089
 
                                                  .client_defaults)
 
3108
    client_config = configparser.ConfigParser(Client.client_defaults)
3090
3109
    client_config.read(os.path.join(server_settings["configdir"],
3091
3110
                                    "clients.conf"))
3092
3111
 
3163
3182
        # Close all input and output, do double fork, etc.
3164
3183
        daemon()
3165
3184
 
3166
 
    # multiprocessing will use threads, so before we use GLib we need
3167
 
    # to inform GLib that threads will be used.
3168
 
    GLib.threads_init()
 
3185
    if gi.version_info < (3, 10, 2):
 
3186
        # multiprocessing will use threads, so before we use GLib we
 
3187
        # need to inform GLib that threads will be used.
 
3188
        GLib.threads_init()
3169
3189
 
3170
3190
    global main_loop
3171
3191
    # From the Avahi example code
3247
3267
                             if isinstance(s, bytes)
3248
3268
                             else s) for s in
3249
3269
                            value["client_structure"]]
3250
 
                        # .name & .host
3251
 
                        for k in ("name", "host"):
 
3270
                        # .name, .host, and .checker_command
 
3271
                        for k in ("name", "host", "checker_command"):
3252
3272
                            if isinstance(value[k], bytes):
3253
3273
                                value[k] = value[k].decode("utf-8")
3254
 
                        if not value.has_key("key_id"):
 
3274
                        if "key_id" not in value:
3255
3275
                            value["key_id"] = ""
3256
 
                        elif not value.has_key("fingerprint"):
 
3276
                        elif "fingerprint" not in value:
3257
3277
                            value["fingerprint"] = ""
3258
3278
                    #  old_client_settings
3259
3279
                    # .keys()
3264
3284
                        for key, value in
3265
3285
                        bytes_old_client_settings.items()}
3266
3286
                    del bytes_old_client_settings
3267
 
                    # .host
 
3287
                    # .host and .checker_command
3268
3288
                    for value in old_client_settings.values():
3269
 
                        if isinstance(value["host"], bytes):
3270
 
                            value["host"] = (value["host"]
3271
 
                                             .decode("utf-8"))
 
3289
                        for attribute in ("host", "checker_command"):
 
3290
                            if isinstance(value[attribute], bytes):
 
3291
                                value[attribute] = (value[attribute]
 
3292
                                                    .decode("utf-8"))
3272
3293
            os.remove(stored_state_path)
3273
3294
        except IOError as e:
3274
3295
            if e.errno == errno.ENOENT:
3599
3620
                sys.exit(1)
3600
3621
            # End of Avahi example code
3601
3622
 
3602
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3603
 
                          lambda *args, **kwargs:
3604
 
                          (tcp_server.handle_request
3605
 
                           (*args[2:], **kwargs) or True))
 
3623
        GLib.io_add_watch(
 
3624
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3625
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3626
            lambda *args, **kwargs: (tcp_server.handle_request
 
3627
                                     (*args[2:], **kwargs) or True))
3606
3628
 
3607
3629
        logger.debug("Starting main loop")
3608
3630
        main_loop.run()
3618
3640
    # Must run before the D-Bus bus name gets deregistered
3619
3641
    cleanup()
3620
3642
 
 
3643
 
 
3644
def should_only_run_tests():
 
3645
    parser = argparse.ArgumentParser(add_help=False)
 
3646
    parser.add_argument("--check", action='store_true')
 
3647
    args, unknown_args = parser.parse_known_args()
 
3648
    run_tests = args.check
 
3649
    if run_tests:
 
3650
        # Remove --check argument from sys.argv
 
3651
        sys.argv[1:] = unknown_args
 
3652
    return run_tests
 
3653
 
 
3654
# Add all tests from doctest strings
 
3655
def load_tests(loader, tests, none):
 
3656
    import doctest
 
3657
    tests.addTests(doctest.DocTestSuite())
 
3658
    return tests
3621
3659
 
3622
3660
if __name__ == '__main__':
3623
 
    main()
 
3661
    try:
 
3662
        if should_only_run_tests():
 
3663
            # Call using ./mandos --check [--verbose]
 
3664
            unittest.main()
 
3665
        else:
 
3666
            main()
 
3667
    finally:
 
3668
        logging.shutdown()