/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-02-05 21:39:28 UTC
  • Revision ID: teddy@recompile.se-20200205213928-vpvt0fwfg47ikv6f
Allow users to alter ask-password-mandos.service

If a user uses dracut with systemd and wishes to modify the options
passed to password-agent(8mandos) or mandos-client(8mandos), they
should be able to do so by simply creating a file
/etc/systemd/system/ask-password-mandos.service.d/override.conf,
containing, for instance:

[Service]
Environment=MANDOS_CLIENT_OPTIONS=--debug

Adding PASSWORD_AGENT_OPTIONS should also be possible (but should not
normally be needed).

* dracut-module/ask-password-mandos.service ([Service]/ExecStart): Add
  $PASSWORD_AGENT_OPTIONS before "--" and "$MANDOS_CLIENT_OPTIONS" to
  end of line.
* dracut-module/module-setup.sh (install): Install all files named
  /etc/systemd/system/ask-password-mandos.service.d/*.conf if any
  exists.  Also add --dh-params before $MANDOS_CLIENT_OPTIONS instead
  of at end of line.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
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
#
77
77
import itertools
78
78
import collections
79
79
import codecs
 
80
import unittest
 
81
import random
80
82
 
81
83
import dbus
82
84
import dbus.service
 
85
import gi
83
86
from gi.repository import GLib
84
87
from dbus.mainloop.glib import DBusGMainLoop
85
88
import ctypes
87
90
import xml.dom.minidom
88
91
import inspect
89
92
 
 
93
if sys.version_info.major == 2:
 
94
    __metaclass__ = type
 
95
    str = unicode
 
96
 
 
97
# Show warnings by default
 
98
if not sys.warnoptions:
 
99
    import warnings
 
100
    warnings.simplefilter("default")
 
101
 
90
102
# Try to find the value of SO_BINDTODEVICE:
91
103
try:
92
104
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
112
124
            # No value found
113
125
            SO_BINDTODEVICE = None
114
126
 
115
 
if sys.version_info.major == 2:
116
 
    str = unicode
 
127
if sys.version_info < (3, 2):
 
128
    configparser.Configparser = configparser.SafeConfigParser
117
129
 
118
 
version = "1.8.2"
 
130
version = "1.8.9"
119
131
stored_state_file = "clients.pickle"
120
132
 
121
133
logger = logging.getLogger()
 
134
logging.captureWarnings(True)   # Show warnings via the logging system
122
135
syslogger = None
123
136
 
124
137
try:
179
192
    pass
180
193
 
181
194
 
182
 
class PGPEngine(object):
 
195
class PGPEngine:
183
196
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
197
 
185
198
    def __init__(self):
189
202
            output = subprocess.check_output(["gpgconf"])
190
203
            for line in output.splitlines():
191
204
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
205
                if name == b"gpg":
193
206
                    self.gpg = path
194
207
                    break
195
208
        except OSError as e:
200
213
                          '--force-mdc',
201
214
                          '--quiet']
202
215
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
216
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
217
            self.gnupgargs.append("--no-use-agent")
205
218
 
206
219
    def __enter__(self):
275
288
 
276
289
 
277
290
# 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."""
 
291
class avahi:
 
292
    """This isn't so much a class as it is a module-like namespace."""
281
293
    IF_UNSPEC = -1               # avahi-common/address.h
282
294
    PROTO_UNSPEC = -1            # avahi-common/address.h
283
295
    PROTO_INET = 0               # avahi-common/address.h
287
299
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
288
300
    DBUS_PATH_SERVER = "/"
289
301
 
290
 
    def string_array_to_txt_array(self, t):
 
302
    @staticmethod
 
303
    def string_array_to_txt_array(t):
291
304
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
292
305
                           for s in t), signature="ay")
293
306
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
298
311
    SERVER_RUNNING = 2           # avahi-common/defs.h
299
312
    SERVER_COLLISION = 3         # avahi-common/defs.h
300
313
    SERVER_FAILURE = 4           # avahi-common/defs.h
301
 
avahi = Avahi()
302
314
 
303
315
 
304
316
class AvahiError(Exception):
316
328
    pass
317
329
 
318
330
 
319
 
class AvahiService(object):
 
331
class AvahiService:
320
332
    """An Avahi (Zeroconf) service.
321
333
 
322
334
    Attributes:
504
516
 
505
517
 
506
518
# 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."""
 
519
class gnutls:
 
520
    """This isn't so much a class as it is a module-like namespace."""
510
521
 
511
522
    library = ctypes.util.find_library("gnutls")
512
523
    if library is None:
513
524
        library = ctypes.util.find_library("gnutls-deb0")
514
525
    _library = ctypes.cdll.LoadLibrary(library)
515
526
    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
527
 
526
528
    # Unless otherwise indicated, the constants and types below are
527
529
    # all from the gnutls/gnutls.h C header file.
569
571
 
570
572
    # Exceptions
571
573
    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
574
        def __init__(self, message=None, code=None, args=()):
577
575
            # Default usage is by a message string, but if a return
578
576
            # code is passed, convert it to a string with
579
577
            # gnutls.strerror()
580
578
            self.code = code
581
579
            if message is None and code is not None:
582
 
                message = GnuTLS.strerror(code)
583
 
            return super(GnuTLS.Error, self).__init__(
 
580
                message = gnutls.strerror(code)
 
581
            return super(gnutls.Error, self).__init__(
584
582
                message, *args)
585
583
 
586
584
    class CertificateSecurityError(Error):
587
585
        pass
588
586
 
589
587
    # Classes
590
 
    class Credentials(object):
 
588
    class Credentials:
591
589
        def __init__(self):
592
590
            self._c_object = gnutls.certificate_credentials_t()
593
591
            gnutls.certificate_allocate_credentials(
597
595
        def __del__(self):
598
596
            gnutls.certificate_free_credentials(self._c_object)
599
597
 
600
 
    class ClientSession(object):
 
598
    class ClientSession:
601
599
        def __init__(self, socket, credentials=None):
602
600
            self._c_object = gnutls.session_t()
603
601
            gnutls_flags = gnutls.CLIENT
604
 
            if gnutls.check_version("3.5.6"):
 
602
            if gnutls.check_version(b"3.5.6"):
605
603
                gnutls_flags |= gnutls.NO_TICKETS
606
604
            if gnutls.has_rawpk:
607
605
                gnutls_flags |= gnutls.ENABLE_RAWPK
744
742
    check_version.argtypes = [ctypes.c_char_p]
745
743
    check_version.restype = ctypes.c_char_p
746
744
 
 
745
    _need_version = b"3.3.0"
 
746
    if check_version(_need_version) is None:
 
747
        raise self.Error("Needs GnuTLS {} or later"
 
748
                         .format(_need_version))
 
749
 
 
750
    _tls_rawpk_version = b"3.6.6"
747
751
    has_rawpk = bool(check_version(_tls_rawpk_version))
748
752
 
749
753
    if has_rawpk:
803
807
                                                    ctypes.c_size_t)]
804
808
        openpgp_crt_get_fingerprint.restype = _error_code
805
809
 
806
 
    if check_version("3.6.4"):
 
810
    if check_version(b"3.6.4"):
807
811
        certificate_type_get2 = _library.gnutls_certificate_type_get2
808
812
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
809
813
        certificate_type_get2.restype = _error_code
810
814
 
811
815
    # Remove non-public functions
812
816
    del _error_code, _retry_on_error
813
 
# Create the global "gnutls" object, simulating a module
814
 
gnutls = GnuTLS()
815
817
 
816
818
 
817
819
def call_pipe(connection,       # : multiprocessing.Connection
825
827
    connection.close()
826
828
 
827
829
 
828
 
class Client(object):
 
830
class Client:
829
831
    """A representation of a client host served by this server.
830
832
 
831
833
    Attributes:
832
834
    approved:   bool(); 'None' if not yet approved/disapproved
833
835
    approval_delay: datetime.timedelta(); Time to wait for approval
834
836
    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.
 
837
    checker: multiprocessing.Process(); a running checker process used
 
838
             to see if the client lives. 'None' if no process is
 
839
             running.
838
840
    checker_callback_tag: a GLib event source tag, or None
839
841
    checker_command: string; External command which is run to check
840
842
                     if client lives.  %() expansions are done at
1034
1036
        if self.checker_initiator_tag is not None:
1035
1037
            GLib.source_remove(self.checker_initiator_tag)
1036
1038
        self.checker_initiator_tag = GLib.timeout_add(
1037
 
            int(self.interval.total_seconds() * 1000),
 
1039
            random.randrange(int(self.interval.total_seconds() * 1000
 
1040
                                 + 1)),
1038
1041
            self.start_checker)
1039
1042
        # Schedule a disable() when 'timeout' has passed
1040
1043
        if self.disable_initiator_tag is not None:
1047
1050
    def checker_callback(self, source, condition, connection,
1048
1051
                         command):
1049
1052
        """The checker has completed, so take appropriate actions."""
1050
 
        self.checker_callback_tag = None
1051
 
        self.checker = None
1052
1053
        # Read return code from connection (see call_pipe)
1053
1054
        returncode = connection.recv()
1054
1055
        connection.close()
 
1056
        if self.checker is not None:
 
1057
            self.checker.join()
 
1058
        self.checker_callback_tag = None
 
1059
        self.checker = None
1055
1060
 
1056
1061
        if returncode >= 0:
1057
1062
            self.last_checker_status = returncode
1146
1151
                kwargs=popen_args)
1147
1152
            self.checker.start()
1148
1153
            self.checker_callback_tag = GLib.io_add_watch(
1149
 
                pipe[0].fileno(), GLib.IO_IN,
 
1154
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1155
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1150
1156
                self.checker_callback, pipe[0], command)
1151
1157
        # Re-run this periodically if run by GLib.timeout_add
1152
1158
        return True
1407
1413
                raise ValueError("Byte arrays not supported for non-"
1408
1414
                                 "'ay' signature {!r}"
1409
1415
                                 .format(prop._dbus_signature))
1410
 
            value = dbus.ByteArray(b''.join(chr(byte)
1411
 
                                            for byte in value))
 
1416
            value = dbus.ByteArray(bytes(value))
1412
1417
        prop(value)
1413
1418
 
1414
1419
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2219
2224
    del _interface
2220
2225
 
2221
2226
 
2222
 
class ProxyClient(object):
 
2227
class ProxyClient:
2223
2228
    def __init__(self, child_pipe, key_id, fpr, address):
2224
2229
        self._pipe = child_pipe
2225
2230
        self._pipe.send(('init', key_id, fpr, address))
2298
2303
            approval_required = False
2299
2304
            try:
2300
2305
                if gnutls.has_rawpk:
2301
 
                    fpr = ""
 
2306
                    fpr = b""
2302
2307
                    try:
2303
2308
                        key_id = self.key_id(
2304
2309
                            self.peer_certificate(session))
2308
2313
                    logger.debug("Key ID: %s", key_id)
2309
2314
 
2310
2315
                else:
2311
 
                    key_id = ""
 
2316
                    key_id = b""
2312
2317
                    try:
2313
2318
                        fpr = self.fingerprint(
2314
2319
                            self.peer_certificate(session))
2498
2503
        return hex_fpr
2499
2504
 
2500
2505
 
2501
 
class MultiprocessingMixIn(object):
 
2506
class MultiprocessingMixIn:
2502
2507
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2503
2508
 
2504
2509
    def sub_process_main(self, request, address):
2516
2521
        return proc
2517
2522
 
2518
2523
 
2519
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2524
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2520
2525
    """ adds a pipe to the MixIn """
2521
2526
 
2522
2527
    def process_request(self, request, client_address):
2537
2542
 
2538
2543
 
2539
2544
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2540
 
                     socketserver.TCPServer, object):
 
2545
                     socketserver.TCPServer):
2541
2546
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
2542
2547
 
2543
2548
    Attributes:
2616
2621
                    raise
2617
2622
        # Only bind(2) the socket if we really need to.
2618
2623
        if self.server_address[0] or self.server_address[1]:
 
2624
            if self.server_address[1]:
 
2625
                self.allow_reuse_address = True
2619
2626
            if not self.server_address[0]:
2620
2627
                if self.address_family == socket.AF_INET6:
2621
2628
                    any_address = "::"  # in6addr_any
2674
2681
    def add_pipe(self, parent_pipe, proc):
2675
2682
        # Call "handle_ipc" for both data and EOF events
2676
2683
        GLib.io_add_watch(
2677
 
            parent_pipe.fileno(),
2678
 
            GLib.IO_IN | GLib.IO_HUP,
 
2684
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2685
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2679
2686
            functools.partial(self.handle_ipc,
2680
2687
                              parent_pipe=parent_pipe,
2681
2688
                              proc=proc))
2719
2726
                return False
2720
2727
 
2721
2728
            GLib.io_add_watch(
2722
 
                parent_pipe.fileno(),
2723
 
                GLib.IO_IN | GLib.IO_HUP,
 
2729
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2730
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2724
2731
                functools.partial(self.handle_ipc,
2725
2732
                                  parent_pipe=parent_pipe,
2726
2733
                                  proc=proc,
2758
2765
def rfc3339_duration_to_delta(duration):
2759
2766
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2760
2767
 
2761
 
    >>> rfc3339_duration_to_delta("P7D")
2762
 
    datetime.timedelta(7)
2763
 
    >>> rfc3339_duration_to_delta("PT60S")
2764
 
    datetime.timedelta(0, 60)
2765
 
    >>> rfc3339_duration_to_delta("PT60M")
2766
 
    datetime.timedelta(0, 3600)
2767
 
    >>> rfc3339_duration_to_delta("PT24H")
2768
 
    datetime.timedelta(1)
2769
 
    >>> rfc3339_duration_to_delta("P1W")
2770
 
    datetime.timedelta(7)
2771
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2772
 
    datetime.timedelta(0, 330)
2773
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2774
 
    datetime.timedelta(1, 200)
 
2768
    >>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
 
2769
    True
 
2770
    >>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
 
2771
    True
 
2772
    >>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
 
2773
    True
 
2774
    >>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
 
2775
    True
 
2776
    >>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
 
2777
    True
 
2778
    >>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
 
2779
    True
 
2780
    >>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
 
2781
    True
2775
2782
    """
2776
2783
 
2777
2784
    # Parsing an RFC 3339 duration with regular expressions is not
2857
2864
def string_to_delta(interval):
2858
2865
    """Parse a string and return a datetime.timedelta
2859
2866
 
2860
 
    >>> string_to_delta('7d')
2861
 
    datetime.timedelta(7)
2862
 
    >>> string_to_delta('60s')
2863
 
    datetime.timedelta(0, 60)
2864
 
    >>> string_to_delta('60m')
2865
 
    datetime.timedelta(0, 3600)
2866
 
    >>> string_to_delta('24h')
2867
 
    datetime.timedelta(1)
2868
 
    >>> string_to_delta('1w')
2869
 
    datetime.timedelta(7)
2870
 
    >>> string_to_delta('5m 30s')
2871
 
    datetime.timedelta(0, 330)
 
2867
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2868
    True
 
2869
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2870
    True
 
2871
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2872
    True
 
2873
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2874
    True
 
2875
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2876
    True
 
2877
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2878
    True
2872
2879
    """
2873
2880
 
2874
2881
    try:
2976
2983
 
2977
2984
    options = parser.parse_args()
2978
2985
 
2979
 
    if options.check:
2980
 
        import doctest
2981
 
        fail_count, test_count = doctest.testmod()
2982
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2983
 
 
2984
2986
    # Default values for config file for server-global settings
2985
2987
    if gnutls.has_rawpk:
2986
2988
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3006
3008
    del priority
3007
3009
 
3008
3010
    # Parse config file for server-global settings
3009
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3011
    server_config = configparser.ConfigParser(server_defaults)
3010
3012
    del server_defaults
3011
3013
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3012
 
    # Convert the SafeConfigParser object to a dict
 
3014
    # Convert the ConfigParser object to a dict
3013
3015
    server_settings = server_config.defaults()
3014
3016
    # Use the appropriate methods on the non-string config options
3015
3017
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3087
3089
                                  server_settings["servicename"])))
3088
3090
 
3089
3091
    # Parse config file with clients
3090
 
    client_config = configparser.SafeConfigParser(Client
3091
 
                                                  .client_defaults)
 
3092
    client_config = configparser.ConfigParser(Client.client_defaults)
3092
3093
    client_config.read(os.path.join(server_settings["configdir"],
3093
3094
                                    "clients.conf"))
3094
3095
 
3165
3166
        # Close all input and output, do double fork, etc.
3166
3167
        daemon()
3167
3168
 
3168
 
    # multiprocessing will use threads, so before we use GLib we need
3169
 
    # to inform GLib that threads will be used.
3170
 
    GLib.threads_init()
 
3169
    if gi.version_info < (3, 10, 2):
 
3170
        # multiprocessing will use threads, so before we use GLib we
 
3171
        # need to inform GLib that threads will be used.
 
3172
        GLib.threads_init()
3171
3173
 
3172
3174
    global main_loop
3173
3175
    # From the Avahi example code
3249
3251
                             if isinstance(s, bytes)
3250
3252
                             else s) for s in
3251
3253
                            value["client_structure"]]
3252
 
                        # .name & .host
3253
 
                        for k in ("name", "host"):
 
3254
                        # .name, .host, and .checker_command
 
3255
                        for k in ("name", "host", "checker_command"):
3254
3256
                            if isinstance(value[k], bytes):
3255
3257
                                value[k] = value[k].decode("utf-8")
3256
 
                        if not value.has_key("key_id"):
 
3258
                        if "key_id" not in value:
3257
3259
                            value["key_id"] = ""
3258
 
                        elif not value.has_key("fingerprint"):
 
3260
                        elif "fingerprint" not in value:
3259
3261
                            value["fingerprint"] = ""
3260
3262
                    #  old_client_settings
3261
3263
                    # .keys()
3266
3268
                        for key, value in
3267
3269
                        bytes_old_client_settings.items()}
3268
3270
                    del bytes_old_client_settings
3269
 
                    # .host
 
3271
                    # .host and .checker_command
3270
3272
                    for value in old_client_settings.values():
3271
 
                        if isinstance(value["host"], bytes):
3272
 
                            value["host"] = (value["host"]
3273
 
                                             .decode("utf-8"))
 
3273
                        for attribute in ("host", "checker_command"):
 
3274
                            if isinstance(value[attribute], bytes):
 
3275
                                value[attribute] = (value[attribute]
 
3276
                                                    .decode("utf-8"))
3274
3277
            os.remove(stored_state_path)
3275
3278
        except IOError as e:
3276
3279
            if e.errno == errno.ENOENT:
3601
3604
                sys.exit(1)
3602
3605
            # End of Avahi example code
3603
3606
 
3604
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3605
 
                          lambda *args, **kwargs:
3606
 
                          (tcp_server.handle_request
3607
 
                           (*args[2:], **kwargs) or True))
 
3607
        GLib.io_add_watch(
 
3608
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3609
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3610
            lambda *args, **kwargs: (tcp_server.handle_request
 
3611
                                     (*args[2:], **kwargs) or True))
3608
3612
 
3609
3613
        logger.debug("Starting main loop")
3610
3614
        main_loop.run()
3620
3624
    # Must run before the D-Bus bus name gets deregistered
3621
3625
    cleanup()
3622
3626
 
 
3627
 
 
3628
def should_only_run_tests():
 
3629
    parser = argparse.ArgumentParser(add_help=False)
 
3630
    parser.add_argument("--check", action='store_true')
 
3631
    args, unknown_args = parser.parse_known_args()
 
3632
    run_tests = args.check
 
3633
    if run_tests:
 
3634
        # Remove --check argument from sys.argv
 
3635
        sys.argv[1:] = unknown_args
 
3636
    return run_tests
 
3637
 
 
3638
# Add all tests from doctest strings
 
3639
def load_tests(loader, tests, none):
 
3640
    import doctest
 
3641
    tests.addTests(doctest.DocTestSuite())
 
3642
    return tests
3623
3643
 
3624
3644
if __name__ == '__main__':
3625
 
    main()
 
3645
    try:
 
3646
        if should_only_run_tests():
 
3647
            # Call using ./mandos --check [--verbose]
 
3648
            unittest.main()
 
3649
        else:
 
3650
            main()
 
3651
    finally:
 
3652
        logging.shutdown()