/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-12-03 20:30:45 UTC
  • Revision ID: teddy@recompile.se-20201203203045-iqd6nq9y5nwalh1x
Minor fix of a test function

In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket.  Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.

This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer.  The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)

* dracut-module/password-agent.c
  (test_send_password_to_socket_EMSGSIZE): Break out early when ssret
  < 0 and errno == EMSGSIZE; don't allow loop to increase message_size
  again.

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-2019 Teddy Hogeborn
15
 
# Copyright © 2008-2019 Björn Påhlsson
 
14
# Copyright © 2008-2020 Teddy Hogeborn
 
15
# Copyright © 2008-2020 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.8.4"
 
146
version = "1.8.13"
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):
 
307
class avahi:
279
308
    """This isn't so much a class as it is a module-like namespace."""
280
309
    IF_UNSPEC = -1               # avahi-common/address.h
281
310
    PROTO_UNSPEC = -1            # avahi-common/address.h
315
344
    pass
316
345
 
317
346
 
318
 
class AvahiService(object):
 
347
class AvahiService:
319
348
    """An Avahi (Zeroconf) service.
320
349
 
321
350
    Attributes:
495
524
class AvahiServiceToSyslog(AvahiService):
496
525
    def rename(self, *args, **kwargs):
497
526
        """Add the new name to the syslog messages"""
498
 
        ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
 
527
        ret = super(AvahiServiceToSyslog, self).rename(*args,
 
528
                                                       **kwargs)
499
529
        syslogger.setFormatter(logging.Formatter(
500
530
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
501
531
            .format(self.name)))
503
533
 
504
534
 
505
535
# Pretend that we have a GnuTLS module
506
 
class gnutls(object):
 
536
class gnutls:
507
537
    """This isn't so much a class as it is a module-like namespace."""
508
538
 
509
539
    library = ctypes.util.find_library("gnutls")
572
602
        pass
573
603
 
574
604
    # Classes
575
 
    class Credentials(object):
 
605
    class Credentials:
576
606
        def __init__(self):
577
607
            self._c_object = gnutls.certificate_credentials_t()
578
608
            gnutls.certificate_allocate_credentials(
582
612
        def __del__(self):
583
613
            gnutls.certificate_free_credentials(self._c_object)
584
614
 
585
 
    class ClientSession(object):
 
615
    class ClientSession:
586
616
        def __init__(self, socket, credentials=None):
587
617
            self._c_object = gnutls.session_t()
588
618
            gnutls_flags = gnutls.CLIENT
589
 
            if gnutls.check_version("3.5.6"):
 
619
            if gnutls.check_version(b"3.5.6"):
590
620
                gnutls_flags |= gnutls.NO_TICKETS
591
621
            if gnutls.has_rawpk:
592
622
                gnutls_flags |= gnutls.ENABLE_RAWPK
745
775
 
746
776
        x509_crt_fmt_t = ctypes.c_int
747
777
 
748
 
        # All the function declarations below are from gnutls/abstract.h
 
778
        # All the function declarations below are from
 
779
        # gnutls/abstract.h
749
780
        pubkey_init = _library.gnutls_pubkey_init
750
781
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
751
782
        pubkey_init.restype = _error_code
765
796
        pubkey_deinit.argtypes = [pubkey_t]
766
797
        pubkey_deinit.restype = None
767
798
    else:
768
 
        # All the function declarations below are from gnutls/openpgp.h
 
799
        # All the function declarations below are from
 
800
        # gnutls/openpgp.h
769
801
 
770
802
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
771
803
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
777
809
                                       openpgp_crt_fmt_t]
778
810
        openpgp_crt_import.restype = _error_code
779
811
 
780
 
        openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
781
 
        openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
782
 
                                            ctypes.POINTER(ctypes.c_uint)]
 
812
        openpgp_crt_verify_self = \
 
813
            _library.gnutls_openpgp_crt_verify_self
 
814
        openpgp_crt_verify_self.argtypes = [
 
815
            openpgp_crt_t,
 
816
            ctypes.c_uint,
 
817
            ctypes.POINTER(ctypes.c_uint),
 
818
        ]
783
819
        openpgp_crt_verify_self.restype = _error_code
784
820
 
785
821
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
794
830
                                                    ctypes.c_size_t)]
795
831
        openpgp_crt_get_fingerprint.restype = _error_code
796
832
 
797
 
    if check_version("3.6.4"):
 
833
    if check_version(b"3.6.4"):
798
834
        certificate_type_get2 = _library.gnutls_certificate_type_get2
799
835
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
800
836
        certificate_type_get2.restype = _error_code
814
850
    connection.close()
815
851
 
816
852
 
817
 
class Client(object):
 
853
class Client:
818
854
    """A representation of a client host served by this server.
819
855
 
820
856
    Attributes:
821
857
    approved:   bool(); 'None' if not yet approved/disapproved
822
858
    approval_delay: datetime.timedelta(); Time to wait for approval
823
859
    approval_duration: datetime.timedelta(); Duration of one approval
824
 
    checker:    subprocess.Popen(); a running checker process used
825
 
                                    to see if the client lives.
826
 
                                    'None' if no process is running.
 
860
    checker: multiprocessing.Process(); a running checker process used
 
861
             to see if the client lives. 'None' if no process is
 
862
             running.
827
863
    checker_callback_tag: a GLib event source tag, or None
828
864
    checker_command: string; External command which is run to check
829
865
                     if client lives.  %() expansions are done at
1023
1059
        if self.checker_initiator_tag is not None:
1024
1060
            GLib.source_remove(self.checker_initiator_tag)
1025
1061
        self.checker_initiator_tag = GLib.timeout_add(
1026
 
            int(self.interval.total_seconds() * 1000),
 
1062
            random.randrange(int(self.interval.total_seconds() * 1000
 
1063
                                 + 1)),
1027
1064
            self.start_checker)
1028
1065
        # Schedule a disable() when 'timeout' has passed
1029
1066
        if self.disable_initiator_tag is not None:
1036
1073
    def checker_callback(self, source, condition, connection,
1037
1074
                         command):
1038
1075
        """The checker has completed, so take appropriate actions."""
1039
 
        self.checker_callback_tag = None
1040
 
        self.checker = None
1041
1076
        # Read return code from connection (see call_pipe)
1042
1077
        returncode = connection.recv()
1043
1078
        connection.close()
 
1079
        if self.checker is not None:
 
1080
            self.checker.join()
 
1081
        self.checker_callback_tag = None
 
1082
        self.checker = None
1044
1083
 
1045
1084
        if returncode >= 0:
1046
1085
            self.last_checker_status = returncode
1102
1141
        if self.checker is None:
1103
1142
            # Escape attributes for the shell
1104
1143
            escaped_attrs = {
1105
 
                attr: re.escape(str(getattr(self, attr)))
 
1144
                attr: shlex.quote(str(getattr(self, attr)))
1106
1145
                for attr in self.runtime_expansions}
1107
1146
            try:
1108
1147
                command = self.checker_command % escaped_attrs
1135
1174
                kwargs=popen_args)
1136
1175
            self.checker.start()
1137
1176
            self.checker_callback_tag = GLib.io_add_watch(
1138
 
                pipe[0].fileno(), GLib.IO_IN,
 
1177
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1178
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1139
1179
                self.checker_callback, pipe[0], command)
1140
1180
        # Re-run this periodically if run by GLib.timeout_add
1141
1181
        return True
1396
1436
                raise ValueError("Byte arrays not supported for non-"
1397
1437
                                 "'ay' signature {!r}"
1398
1438
                                 .format(prop._dbus_signature))
1399
 
            value = dbus.ByteArray(b''.join(chr(byte)
1400
 
                                            for byte in value))
 
1439
            value = dbus.ByteArray(bytes(value))
1401
1440
        prop(value)
1402
1441
 
1403
1442
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2208
2247
    del _interface
2209
2248
 
2210
2249
 
2211
 
class ProxyClient(object):
 
2250
class ProxyClient:
2212
2251
    def __init__(self, child_pipe, key_id, fpr, address):
2213
2252
        self._pipe = child_pipe
2214
2253
        self._pipe.send(('init', key_id, fpr, address))
2287
2326
            approval_required = False
2288
2327
            try:
2289
2328
                if gnutls.has_rawpk:
2290
 
                    fpr = ""
 
2329
                    fpr = b""
2291
2330
                    try:
2292
2331
                        key_id = self.key_id(
2293
2332
                            self.peer_certificate(session))
2297
2336
                    logger.debug("Key ID: %s", key_id)
2298
2337
 
2299
2338
                else:
2300
 
                    key_id = ""
 
2339
                    key_id = b""
2301
2340
                    try:
2302
2341
                        fpr = self.fingerprint(
2303
2342
                            self.peer_certificate(session))
2436
2475
        buf = ctypes.create_string_buffer(32)
2437
2476
        buf_len = ctypes.c_size_t(len(buf))
2438
2477
        # Get the key ID from the raw public key into the buffer
2439
 
        gnutls.pubkey_get_key_id(pubkey,
2440
 
                                 gnutls.KEYID_USE_SHA256,
2441
 
                                 ctypes.cast(ctypes.byref(buf),
2442
 
                                             ctypes.POINTER(ctypes.c_ubyte)),
2443
 
                                 ctypes.byref(buf_len))
 
2478
        gnutls.pubkey_get_key_id(
 
2479
            pubkey,
 
2480
            gnutls.KEYID_USE_SHA256,
 
2481
            ctypes.cast(ctypes.byref(buf),
 
2482
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2483
            ctypes.byref(buf_len))
2444
2484
        # Deinit the certificate
2445
2485
        gnutls.pubkey_deinit(pubkey)
2446
2486
 
2487
2527
        return hex_fpr
2488
2528
 
2489
2529
 
2490
 
class MultiprocessingMixIn(object):
 
2530
class MultiprocessingMixIn:
2491
2531
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2492
2532
 
2493
2533
    def sub_process_main(self, request, address):
2505
2545
        return proc
2506
2546
 
2507
2547
 
2508
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2548
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2509
2549
    """ adds a pipe to the MixIn """
2510
2550
 
2511
2551
    def process_request(self, request, client_address):
2526
2566
 
2527
2567
 
2528
2568
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2529
 
                     socketserver.TCPServer, object):
 
2569
                     socketserver.TCPServer):
2530
2570
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2531
2571
 
2532
2572
    Attributes:
2605
2645
                    raise
2606
2646
        # Only bind(2) the socket if we really need to.
2607
2647
        if self.server_address[0] or self.server_address[1]:
 
2648
            if self.server_address[1]:
 
2649
                self.allow_reuse_address = True
2608
2650
            if not self.server_address[0]:
2609
2651
                if self.address_family == socket.AF_INET6:
2610
2652
                    any_address = "::"  # in6addr_any
2663
2705
    def add_pipe(self, parent_pipe, proc):
2664
2706
        # Call "handle_ipc" for both data and EOF events
2665
2707
        GLib.io_add_watch(
2666
 
            parent_pipe.fileno(),
2667
 
            GLib.IO_IN | GLib.IO_HUP,
 
2708
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2709
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2668
2710
            functools.partial(self.handle_ipc,
2669
2711
                              parent_pipe=parent_pipe,
2670
2712
                              proc=proc))
2689
2731
            address = request[3]
2690
2732
 
2691
2733
            for c in self.clients.values():
2692
 
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
 
2734
                if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
 
2735
                              "27AE41E4649B934CA495991B7852B855"):
2693
2736
                    continue
2694
2737
                if key_id and c.key_id == key_id:
2695
2738
                    client = c
2708
2751
                return False
2709
2752
 
2710
2753
            GLib.io_add_watch(
2711
 
                parent_pipe.fileno(),
2712
 
                GLib.IO_IN | GLib.IO_HUP,
 
2754
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2755
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2713
2756
                functools.partial(self.handle_ipc,
2714
2757
                                  parent_pipe=parent_pipe,
2715
2758
                                  proc=proc,
2730
2773
        if command == 'getattr':
2731
2774
            attrname = request[1]
2732
2775
            if isinstance(client_object.__getattribute__(attrname),
2733
 
                          collections.Callable):
 
2776
                          collections.abc.Callable):
2734
2777
                parent_pipe.send(('function', ))
2735
2778
            else:
2736
2779
                parent_pipe.send((
2747
2790
def rfc3339_duration_to_delta(duration):
2748
2791
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2749
2792
 
2750
 
    >>> rfc3339_duration_to_delta("P7D")
2751
 
    datetime.timedelta(7)
2752
 
    >>> rfc3339_duration_to_delta("PT60S")
2753
 
    datetime.timedelta(0, 60)
2754
 
    >>> rfc3339_duration_to_delta("PT60M")
2755
 
    datetime.timedelta(0, 3600)
2756
 
    >>> rfc3339_duration_to_delta("PT24H")
2757
 
    datetime.timedelta(1)
2758
 
    >>> rfc3339_duration_to_delta("P1W")
2759
 
    datetime.timedelta(7)
2760
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2761
 
    datetime.timedelta(0, 330)
2762
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2763
 
    datetime.timedelta(1, 200)
 
2793
    >>> timedelta = datetime.timedelta
 
2794
    >>> rfc3339_duration_to_delta("P7D") == timedelta(7)
 
2795
    True
 
2796
    >>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
 
2797
    True
 
2798
    >>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
 
2799
    True
 
2800
    >>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
 
2801
    True
 
2802
    >>> rfc3339_duration_to_delta("P1W") == timedelta(7)
 
2803
    True
 
2804
    >>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
 
2805
    True
 
2806
    >>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
 
2807
    True
 
2808
    >>> del timedelta
2764
2809
    """
2765
2810
 
2766
2811
    # Parsing an RFC 3339 duration with regular expressions is not
2846
2891
def string_to_delta(interval):
2847
2892
    """Parse a string and return a datetime.timedelta
2848
2893
 
2849
 
    >>> string_to_delta('7d')
2850
 
    datetime.timedelta(7)
2851
 
    >>> string_to_delta('60s')
2852
 
    datetime.timedelta(0, 60)
2853
 
    >>> string_to_delta('60m')
2854
 
    datetime.timedelta(0, 3600)
2855
 
    >>> string_to_delta('24h')
2856
 
    datetime.timedelta(1)
2857
 
    >>> string_to_delta('1w')
2858
 
    datetime.timedelta(7)
2859
 
    >>> string_to_delta('5m 30s')
2860
 
    datetime.timedelta(0, 330)
 
2894
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2895
    True
 
2896
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2897
    True
 
2898
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2899
    True
 
2900
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2901
    True
 
2902
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2903
    True
 
2904
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2905
    True
2861
2906
    """
2862
2907
 
2863
2908
    try:
2965
3010
 
2966
3011
    options = parser.parse_args()
2967
3012
 
2968
 
    if options.check:
2969
 
        import doctest
2970
 
        fail_count, test_count = doctest.testmod()
2971
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2972
 
 
2973
3013
    # Default values for config file for server-global settings
2974
3014
    if gnutls.has_rawpk:
2975
3015
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2995
3035
    del priority
2996
3036
 
2997
3037
    # Parse config file for server-global settings
2998
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3038
    server_config = configparser.ConfigParser(server_defaults)
2999
3039
    del server_defaults
3000
3040
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3001
 
    # Convert the SafeConfigParser object to a dict
 
3041
    # Convert the ConfigParser object to a dict
3002
3042
    server_settings = server_config.defaults()
3003
3043
    # Use the appropriate methods on the non-string config options
3004
3044
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3076
3116
                                  server_settings["servicename"])))
3077
3117
 
3078
3118
    # Parse config file with clients
3079
 
    client_config = configparser.SafeConfigParser(Client
3080
 
                                                  .client_defaults)
 
3119
    client_config = configparser.ConfigParser(Client.client_defaults)
3081
3120
    client_config.read(os.path.join(server_settings["configdir"],
3082
3121
                                    "clients.conf"))
3083
3122
 
3154
3193
        # Close all input and output, do double fork, etc.
3155
3194
        daemon()
3156
3195
 
3157
 
    # multiprocessing will use threads, so before we use GLib we need
3158
 
    # to inform GLib that threads will be used.
3159
 
    GLib.threads_init()
 
3196
    if gi.version_info < (3, 10, 2):
 
3197
        # multiprocessing will use threads, so before we use GLib we
 
3198
        # need to inform GLib that threads will be used.
 
3199
        GLib.threads_init()
3160
3200
 
3161
3201
    global main_loop
3162
3202
    # From the Avahi example code
3238
3278
                             if isinstance(s, bytes)
3239
3279
                             else s) for s in
3240
3280
                            value["client_structure"]]
3241
 
                        # .name & .host
3242
 
                        for k in ("name", "host"):
 
3281
                        # .name, .host, and .checker_command
 
3282
                        for k in ("name", "host", "checker_command"):
3243
3283
                            if isinstance(value[k], bytes):
3244
3284
                                value[k] = value[k].decode("utf-8")
3245
 
                        if not value.has_key("key_id"):
 
3285
                        if "key_id" not in value:
3246
3286
                            value["key_id"] = ""
3247
 
                        elif not value.has_key("fingerprint"):
 
3287
                        elif "fingerprint" not in value:
3248
3288
                            value["fingerprint"] = ""
3249
3289
                    #  old_client_settings
3250
3290
                    # .keys()
3255
3295
                        for key, value in
3256
3296
                        bytes_old_client_settings.items()}
3257
3297
                    del bytes_old_client_settings
3258
 
                    # .host
 
3298
                    # .host and .checker_command
3259
3299
                    for value in old_client_settings.values():
3260
 
                        if isinstance(value["host"], bytes):
3261
 
                            value["host"] = (value["host"]
3262
 
                                             .decode("utf-8"))
 
3300
                        for attribute in ("host", "checker_command"):
 
3301
                            if isinstance(value[attribute], bytes):
 
3302
                                value[attribute] = (value[attribute]
 
3303
                                                    .decode("utf-8"))
3263
3304
            os.remove(stored_state_path)
3264
3305
        except IOError as e:
3265
3306
            if e.errno == errno.ENOENT:
3590
3631
                sys.exit(1)
3591
3632
            # End of Avahi example code
3592
3633
 
3593
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3594
 
                          lambda *args, **kwargs:
3595
 
                          (tcp_server.handle_request
3596
 
                           (*args[2:], **kwargs) or True))
 
3634
        GLib.io_add_watch(
 
3635
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3636
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3637
            lambda *args, **kwargs: (tcp_server.handle_request
 
3638
                                     (*args[2:], **kwargs) or True))
3597
3639
 
3598
3640
        logger.debug("Starting main loop")
3599
3641
        main_loop.run()
3609
3651
    # Must run before the D-Bus bus name gets deregistered
3610
3652
    cleanup()
3611
3653
 
 
3654
 
 
3655
def should_only_run_tests():
 
3656
    parser = argparse.ArgumentParser(add_help=False)
 
3657
    parser.add_argument("--check", action='store_true')
 
3658
    args, unknown_args = parser.parse_known_args()
 
3659
    run_tests = args.check
 
3660
    if run_tests:
 
3661
        # Remove --check argument from sys.argv
 
3662
        sys.argv[1:] = unknown_args
 
3663
    return run_tests
 
3664
 
 
3665
# Add all tests from doctest strings
 
3666
def load_tests(loader, tests, none):
 
3667
    import doctest
 
3668
    tests.addTests(doctest.DocTestSuite())
 
3669
    return tests
3612
3670
 
3613
3671
if __name__ == '__main__':
3614
 
    main()
 
3672
    try:
 
3673
        if should_only_run_tests():
 
3674
            # Call using ./mandos --check [--verbose]
 
3675
            unittest.main()
 
3676
        else:
 
3677
            main()
 
3678
    finally:
 
3679
        logging.shutdown()