/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: 2025-06-14 15:37:45 UTC
  • Revision ID: teddy@recompile.se-20250614153745-1labvcqq11fuijy4
debian/control: Require cryptsetup support in systemd

* debian/control (Package: mandos-client/Depends): Add dependency on
  "systemd-cryptsetup" (for newer systemd), or "systemd (<< 256-2)"
  for when cryptsetup support was included in the systemd package
  itself, or "sysvinit-core" for installations without systemd.

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
# -*- coding: utf-8; lexical-binding: t -*-
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-2022 Teddy Hogeborn
 
15
# Copyright © 2008-2022 Björn Påhlsson
16
16
#
17
17
# This file is part of Mandos.
18
18
#
31
31
#
32
32
# Contact the authors at <mandos@recompile.se>.
33
33
#
34
 
 
35
34
from __future__ import (division, absolute_import, print_function,
36
35
                        unicode_literals)
37
36
 
40
39
except ImportError:
41
40
    pass
42
41
 
 
42
import sys
 
43
import unittest
 
44
import argparse
 
45
import logging
 
46
import os
43
47
try:
44
48
    import SocketServer as socketserver
45
49
except ImportError:
46
50
    import socketserver
47
51
import socket
48
 
import argparse
49
52
import datetime
50
53
import errno
51
54
try:
52
55
    import ConfigParser as configparser
53
56
except ImportError:
54
57
    import configparser
55
 
import sys
56
58
import re
57
 
import os
58
59
import signal
59
60
import subprocess
60
61
import atexit
61
62
import stat
62
 
import logging
63
63
import logging.handlers
64
64
import pwd
65
65
import contextlib
77
77
import itertools
78
78
import collections
79
79
import codecs
 
80
import random
 
81
import shlex
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
    input = raw_input
 
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
# Add os.set_inheritable if it does not exist
 
114
try:
 
115
    os.set_inheritable
 
116
except AttributeError:
 
117
    def set_inheritable(fd, inheritable):
 
118
        flags = fcntl.fcntl(fd, fcntl.F_GETFD)
 
119
        if inheritable and ((flags & fcntl.FD_CLOEXEC) != 0):
 
120
            fcntl.fcntl(fd, fcntl.F_SETFL, flags & ~fcntl.FD_CLOEXEC)
 
121
        elif (not inheritable) and ((flags & fcntl.FD_CLOEXEC) == 0):
 
122
            fcntl.fcntl(fd, fcntl.F_SETFL, flags | fcntl.FD_CLOEXEC)
 
123
    os.set_inheritable = set_inheritable
 
124
    del set_inheritable
 
125
 
 
126
# Show warnings by default
 
127
if not sys.warnoptions:
 
128
    import warnings
 
129
    warnings.simplefilter("default")
 
130
 
90
131
# Try to find the value of SO_BINDTODEVICE:
91
132
try:
92
133
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
112
153
            # No value found
113
154
            SO_BINDTODEVICE = None
114
155
 
115
 
if sys.version_info.major == 2:
116
 
    str = unicode
 
156
if sys.version_info < (3, 2):
 
157
    configparser.Configparser = configparser.SafeConfigParser
117
158
 
118
 
version = "1.8.4"
 
159
version = "1.8.18"
119
160
stored_state_file = "clients.pickle"
120
161
 
121
 
logger = logging.getLogger()
 
162
log = logging.getLogger(os.path.basename(sys.argv[0]))
 
163
logging.captureWarnings(True)   # Show warnings via the logging system
122
164
syslogger = None
123
165
 
124
166
try:
160
202
        facility=logging.handlers.SysLogHandler.LOG_DAEMON,
161
203
        address="/dev/log"))
162
204
    syslogger.setFormatter(logging.Formatter
163
 
                           ('Mandos [%(process)d]: %(levelname)s:'
164
 
                            ' %(message)s'))
165
 
    logger.addHandler(syslogger)
 
205
                           ("Mandos [%(process)d]: %(levelname)s:"
 
206
                            " %(message)s"))
 
207
    log.addHandler(syslogger)
166
208
 
167
209
    if debug:
168
210
        console = logging.StreamHandler()
169
 
        console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
170
 
                                               ' [%(process)d]:'
171
 
                                               ' %(levelname)s:'
172
 
                                               ' %(message)s'))
173
 
        logger.addHandler(console)
174
 
    logger.setLevel(level)
 
211
        console.setFormatter(logging.Formatter("%(asctime)s %(name)s"
 
212
                                               " [%(process)d]:"
 
213
                                               " %(levelname)s:"
 
214
                                               " %(message)s"))
 
215
        log.addHandler(console)
 
216
    log.setLevel(level)
175
217
 
176
218
 
177
219
class PGPError(Exception):
179
221
    pass
180
222
 
181
223
 
182
 
class PGPEngine(object):
 
224
class PGPEngine:
183
225
    """A simple class for OpenPGP symmetric encryption & decryption"""
184
226
 
185
227
    def __init__(self):
189
231
            output = subprocess.check_output(["gpgconf"])
190
232
            for line in output.splitlines():
191
233
                name, text, path = line.split(b":")
192
 
                if name == "gpg":
 
234
                if name == b"gpg":
193
235
                    self.gpg = path
194
236
                    break
195
237
        except OSError as e:
196
238
            if e.errno != errno.ENOENT:
197
239
                raise
198
 
        self.gnupgargs = ['--batch',
199
 
                          '--homedir', self.tempdir,
200
 
                          '--force-mdc',
201
 
                          '--quiet']
 
240
        self.gnupgargs = ["--batch",
 
241
                          "--homedir", self.tempdir,
 
242
                          "--force-mdc",
 
243
                          "--quiet"]
202
244
        # Only GPG version 1 has the --no-use-agent option.
203
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
245
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
204
246
            self.gnupgargs.append("--no-use-agent")
205
247
 
206
248
    def __enter__(self):
243
285
                dir=self.tempdir) as passfile:
244
286
            passfile.write(passphrase)
245
287
            passfile.flush()
246
 
            proc = subprocess.Popen([self.gpg, '--symmetric',
247
 
                                     '--passphrase-file',
 
288
            proc = subprocess.Popen([self.gpg, "--symmetric",
 
289
                                     "--passphrase-file",
248
290
                                     passfile.name]
249
291
                                    + self.gnupgargs,
250
292
                                    stdin=subprocess.PIPE,
261
303
                dir=self.tempdir) as passfile:
262
304
            passfile.write(passphrase)
263
305
            passfile.flush()
264
 
            proc = subprocess.Popen([self.gpg, '--decrypt',
265
 
                                     '--passphrase-file',
 
306
            proc = subprocess.Popen([self.gpg, "--decrypt",
 
307
                                     "--passphrase-file",
266
308
                                     passfile.name]
267
309
                                    + self.gnupgargs,
268
310
                                    stdin=subprocess.PIPE,
275
317
 
276
318
 
277
319
# Pretend that we have an Avahi module
278
 
class avahi(object):
 
320
class avahi:
279
321
    """This isn't so much a class as it is a module-like namespace."""
280
322
    IF_UNSPEC = -1               # avahi-common/address.h
281
323
    PROTO_UNSPEC = -1            # avahi-common/address.h
315
357
    pass
316
358
 
317
359
 
318
 
class AvahiService(object):
 
360
class AvahiService:
319
361
    """An Avahi (Zeroconf) service.
320
362
 
321
363
    Attributes:
322
364
    interface: integer; avahi.IF_UNSPEC or an interface index.
323
365
               Used to optionally bind to the specified interface.
324
 
    name: string; Example: 'Mandos'
325
 
    type: string; Example: '_mandos._tcp'.
 
366
    name: string; Example: "Mandos"
 
367
    type: string; Example: "_mandos._tcp".
326
368
     See <https://www.iana.org/assignments/service-names-port-numbers>
327
369
    port: integer; what port to announce
328
370
    TXT: list of strings; TXT record for the service
365
407
    def rename(self, remove=True):
366
408
        """Derived from the Avahi example code"""
367
409
        if self.rename_count >= self.max_renames:
368
 
            logger.critical("No suitable Zeroconf service name found"
369
 
                            " after %i retries, exiting.",
370
 
                            self.rename_count)
 
410
            log.critical("No suitable Zeroconf service name found"
 
411
                         " after %i retries, exiting.",
 
412
                         self.rename_count)
371
413
            raise AvahiServiceError("Too many renames")
372
414
        self.name = str(
373
415
            self.server.GetAlternativeServiceName(self.name))
374
416
        self.rename_count += 1
375
 
        logger.info("Changing Zeroconf service name to %r ...",
376
 
                    self.name)
 
417
        log.info("Changing Zeroconf service name to %r ...",
 
418
                 self.name)
377
419
        if remove:
378
420
            self.remove()
379
421
        try:
381
423
        except dbus.exceptions.DBusException as error:
382
424
            if (error.get_dbus_name()
383
425
                == "org.freedesktop.Avahi.CollisionError"):
384
 
                logger.info("Local Zeroconf service name collision.")
 
426
                log.info("Local Zeroconf service name collision.")
385
427
                return self.rename(remove=False)
386
428
            else:
387
 
                logger.critical("D-Bus Exception", exc_info=error)
 
429
                log.critical("D-Bus Exception", exc_info=error)
388
430
                self.cleanup()
389
431
                os._exit(1)
390
432
 
406
448
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
407
449
        self.entry_group_state_changed_match = (
408
450
            self.group.connect_to_signal(
409
 
                'StateChanged', self.entry_group_state_changed))
410
 
        logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
411
 
                     self.name, self.type)
 
451
                "StateChanged", self.entry_group_state_changed))
 
452
        log.debug("Adding Zeroconf service '%s' of type '%s' ...",
 
453
                  self.name, self.type)
412
454
        self.group.AddService(
413
455
            self.interface,
414
456
            self.protocol,
421
463
 
422
464
    def entry_group_state_changed(self, state, error):
423
465
        """Derived from the Avahi example code"""
424
 
        logger.debug("Avahi entry group state change: %i", state)
 
466
        log.debug("Avahi entry group state change: %i", state)
425
467
 
426
468
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
427
 
            logger.debug("Zeroconf service established.")
 
469
            log.debug("Zeroconf service established.")
428
470
        elif state == avahi.ENTRY_GROUP_COLLISION:
429
 
            logger.info("Zeroconf service name collision.")
 
471
            log.info("Zeroconf service name collision.")
430
472
            self.rename()
431
473
        elif state == avahi.ENTRY_GROUP_FAILURE:
432
 
            logger.critical("Avahi: Error in group state changed %s",
433
 
                            str(error))
 
474
            log.critical("Avahi: Error in group state changed %s",
 
475
                         str(error))
434
476
            raise AvahiGroupError("State changed: {!s}".format(error))
435
477
 
436
478
    def cleanup(self):
446
488
 
447
489
    def server_state_changed(self, state, error=None):
448
490
        """Derived from the Avahi example code"""
449
 
        logger.debug("Avahi server state change: %i", state)
 
491
        log.debug("Avahi server state change: %i", state)
450
492
        bad_states = {
451
493
            avahi.SERVER_INVALID: "Zeroconf server invalid",
452
494
            avahi.SERVER_REGISTERING: None,
456
498
        if state in bad_states:
457
499
            if bad_states[state] is not None:
458
500
                if error is None:
459
 
                    logger.error(bad_states[state])
 
501
                    log.error(bad_states[state])
460
502
                else:
461
 
                    logger.error(bad_states[state] + ": %r", error)
 
503
                    log.error(bad_states[state] + ": %r", error)
462
504
            self.cleanup()
463
505
        elif state == avahi.SERVER_RUNNING:
464
506
            try:
466
508
            except dbus.exceptions.DBusException as error:
467
509
                if (error.get_dbus_name()
468
510
                    == "org.freedesktop.Avahi.CollisionError"):
469
 
                    logger.info("Local Zeroconf service name"
470
 
                                " collision.")
 
511
                    log.info("Local Zeroconf service name collision.")
471
512
                    return self.rename(remove=False)
472
513
                else:
473
 
                    logger.critical("D-Bus Exception", exc_info=error)
 
514
                    log.critical("D-Bus Exception", exc_info=error)
474
515
                    self.cleanup()
475
516
                    os._exit(1)
476
517
        else:
477
518
            if error is None:
478
 
                logger.debug("Unknown state: %r", state)
 
519
                log.debug("Unknown state: %r", state)
479
520
            else:
480
 
                logger.debug("Unknown state: %r: %r", state, error)
 
521
                log.debug("Unknown state: %r: %r", state, error)
481
522
 
482
523
    def activate(self):
483
524
        """Derived from the Avahi example code"""
495
536
class AvahiServiceToSyslog(AvahiService):
496
537
    def rename(self, *args, **kwargs):
497
538
        """Add the new name to the syslog messages"""
498
 
        ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
 
539
        ret = super(AvahiServiceToSyslog, self).rename(*args,
 
540
                                                       **kwargs)
499
541
        syslogger.setFormatter(logging.Formatter(
500
 
            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
 
542
            "Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
501
543
            .format(self.name)))
502
544
        return ret
503
545
 
504
546
 
505
547
# Pretend that we have a GnuTLS module
506
 
class gnutls(object):
 
548
class gnutls:
507
549
    """This isn't so much a class as it is a module-like namespace."""
508
550
 
509
551
    library = ctypes.util.find_library("gnutls")
533
575
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
534
576
 
535
577
    # Types
536
 
    class session_int(ctypes.Structure):
 
578
    class _session_int(ctypes.Structure):
537
579
        _fields_ = []
538
 
    session_t = ctypes.POINTER(session_int)
 
580
    session_t = ctypes.POINTER(_session_int)
539
581
 
540
582
    class certificate_credentials_st(ctypes.Structure):
541
583
        _fields_ = []
544
586
    certificate_type_t = ctypes.c_int
545
587
 
546
588
    class datum_t(ctypes.Structure):
547
 
        _fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
548
 
                    ('size', ctypes.c_uint)]
 
589
        _fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
 
590
                    ("size", ctypes.c_uint)]
549
591
 
550
 
    class openpgp_crt_int(ctypes.Structure):
 
592
    class _openpgp_crt_int(ctypes.Structure):
551
593
        _fields_ = []
552
 
    openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
 
594
    openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
553
595
    openpgp_crt_fmt_t = ctypes.c_int  # gnutls/openpgp.h
554
596
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
555
597
    credentials_type_t = ctypes.c_int
564
606
            # gnutls.strerror()
565
607
            self.code = code
566
608
            if message is None and code is not None:
567
 
                message = gnutls.strerror(code)
 
609
                message = gnutls.strerror(code).decode(
 
610
                    "utf-8", errors="replace")
568
611
            return super(gnutls.Error, self).__init__(
569
612
                message, *args)
570
613
 
571
614
    class CertificateSecurityError(Error):
572
615
        pass
573
616
 
 
617
    class PointerTo:
 
618
        def __init__(self, cls):
 
619
            self.cls = cls
 
620
 
 
621
        def from_param(self, obj):
 
622
            if not isinstance(obj, self.cls):
 
623
                raise TypeError("Not of type {}: {!r}"
 
624
                                .format(self.cls.__name__, obj))
 
625
            return ctypes.byref(obj.from_param(obj))
 
626
 
 
627
    class CastToVoidPointer:
 
628
        def __init__(self, cls):
 
629
            self.cls = cls
 
630
 
 
631
        def from_param(self, obj):
 
632
            if not isinstance(obj, self.cls):
 
633
                raise TypeError("Not of type {}: {!r}"
 
634
                                .format(self.cls.__name__, obj))
 
635
            return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
 
636
 
 
637
    class With_from_param:
 
638
        @classmethod
 
639
        def from_param(cls, obj):
 
640
            return obj._as_parameter_
 
641
 
574
642
    # Classes
575
 
    class Credentials(object):
 
643
    class Credentials(With_from_param):
576
644
        def __init__(self):
577
 
            self._c_object = gnutls.certificate_credentials_t()
578
 
            gnutls.certificate_allocate_credentials(
579
 
                ctypes.byref(self._c_object))
 
645
            self._as_parameter_ = gnutls.certificate_credentials_t()
 
646
            gnutls.certificate_allocate_credentials(self)
580
647
            self.type = gnutls.CRD_CERTIFICATE
581
648
 
582
649
        def __del__(self):
583
 
            gnutls.certificate_free_credentials(self._c_object)
 
650
            gnutls.certificate_free_credentials(self)
584
651
 
585
 
    class ClientSession(object):
 
652
    class ClientSession(With_from_param):
586
653
        def __init__(self, socket, credentials=None):
587
 
            self._c_object = gnutls.session_t()
 
654
            self._as_parameter_ = gnutls.session_t()
588
655
            gnutls_flags = gnutls.CLIENT
589
 
            if gnutls.check_version("3.5.6"):
 
656
            if gnutls.check_version(b"3.5.6"):
590
657
                gnutls_flags |= gnutls.NO_TICKETS
591
658
            if gnutls.has_rawpk:
592
659
                gnutls_flags |= gnutls.ENABLE_RAWPK
593
 
            gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
 
660
            gnutls.init(self, gnutls_flags)
594
661
            del gnutls_flags
595
 
            gnutls.set_default_priority(self._c_object)
596
 
            gnutls.transport_set_ptr(self._c_object, socket.fileno())
597
 
            gnutls.handshake_set_private_extensions(self._c_object,
598
 
                                                    True)
 
662
            gnutls.set_default_priority(self)
 
663
            gnutls.transport_set_ptr(self, socket.fileno())
 
664
            gnutls.handshake_set_private_extensions(self, True)
599
665
            self.socket = socket
600
666
            if credentials is None:
601
667
                credentials = gnutls.Credentials()
602
 
            gnutls.credentials_set(self._c_object, credentials.type,
603
 
                                   ctypes.cast(credentials._c_object,
604
 
                                               ctypes.c_void_p))
 
668
            gnutls.credentials_set(self, credentials.type,
 
669
                                   credentials)
605
670
            self.credentials = credentials
606
671
 
607
672
        def __del__(self):
608
 
            gnutls.deinit(self._c_object)
 
673
            gnutls.deinit(self)
609
674
 
610
675
        def handshake(self):
611
 
            return gnutls.handshake(self._c_object)
 
676
            return gnutls.handshake(self)
612
677
 
613
678
        def send(self, data):
614
679
            data = bytes(data)
615
680
            data_len = len(data)
616
681
            while data_len > 0:
617
 
                data_len -= gnutls.record_send(self._c_object,
618
 
                                               data[-data_len:],
 
682
                data_len -= gnutls.record_send(self, data[-data_len:],
619
683
                                               data_len)
620
684
 
621
685
        def bye(self):
622
 
            return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
 
686
            return gnutls.bye(self, gnutls.SHUT_RDWR)
623
687
 
624
688
    # Error handling functions
625
689
    def _error_code(result):
626
690
        """A function to raise exceptions on errors, suitable
627
 
        for the 'restype' attribute on ctypes functions"""
628
 
        if result >= 0:
 
691
        for the "restype" attribute on ctypes functions"""
 
692
        if result >= gnutls.E_SUCCESS:
629
693
            return result
630
694
        if result == gnutls.E_NO_CERTIFICATE_FOUND:
631
695
            raise gnutls.CertificateSecurityError(code=result)
632
696
        raise gnutls.Error(code=result)
633
697
 
634
 
    def _retry_on_error(result, func, arguments):
 
698
    def _retry_on_error(result, func, arguments,
 
699
                        _error_code=_error_code):
635
700
        """A function to retry on some errors, suitable
636
 
        for the 'errcheck' attribute on ctypes functions"""
637
 
        while result < 0:
 
701
        for the "errcheck" attribute on ctypes functions"""
 
702
        while result < gnutls.E_SUCCESS:
638
703
            if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
639
704
                return _error_code(result)
640
705
            result = func(*arguments)
645
710
 
646
711
    # Functions
647
712
    priority_set_direct = _library.gnutls_priority_set_direct
648
 
    priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
 
713
    priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
649
714
                                    ctypes.POINTER(ctypes.c_char_p)]
650
715
    priority_set_direct.restype = _error_code
651
716
 
652
717
    init = _library.gnutls_init
653
 
    init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
 
718
    init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
654
719
    init.restype = _error_code
655
720
 
656
721
    set_default_priority = _library.gnutls_set_default_priority
657
 
    set_default_priority.argtypes = [session_t]
 
722
    set_default_priority.argtypes = [ClientSession]
658
723
    set_default_priority.restype = _error_code
659
724
 
660
725
    record_send = _library.gnutls_record_send
661
 
    record_send.argtypes = [session_t, ctypes.c_void_p,
 
726
    record_send.argtypes = [ClientSession, ctypes.c_void_p,
662
727
                            ctypes.c_size_t]
663
728
    record_send.restype = ctypes.c_ssize_t
664
729
    record_send.errcheck = _retry_on_error
666
731
    certificate_allocate_credentials = (
667
732
        _library.gnutls_certificate_allocate_credentials)
668
733
    certificate_allocate_credentials.argtypes = [
669
 
        ctypes.POINTER(certificate_credentials_t)]
 
734
        PointerTo(Credentials)]
670
735
    certificate_allocate_credentials.restype = _error_code
671
736
 
672
737
    certificate_free_credentials = (
673
738
        _library.gnutls_certificate_free_credentials)
674
 
    certificate_free_credentials.argtypes = [
675
 
        certificate_credentials_t]
 
739
    certificate_free_credentials.argtypes = [Credentials]
676
740
    certificate_free_credentials.restype = None
677
741
 
678
742
    handshake_set_private_extensions = (
679
743
        _library.gnutls_handshake_set_private_extensions)
680
 
    handshake_set_private_extensions.argtypes = [session_t,
 
744
    handshake_set_private_extensions.argtypes = [ClientSession,
681
745
                                                 ctypes.c_int]
682
746
    handshake_set_private_extensions.restype = None
683
747
 
684
748
    credentials_set = _library.gnutls_credentials_set
685
 
    credentials_set.argtypes = [session_t, credentials_type_t,
686
 
                                ctypes.c_void_p]
 
749
    credentials_set.argtypes = [ClientSession, credentials_type_t,
 
750
                                CastToVoidPointer(Credentials)]
687
751
    credentials_set.restype = _error_code
688
752
 
689
753
    strerror = _library.gnutls_strerror
691
755
    strerror.restype = ctypes.c_char_p
692
756
 
693
757
    certificate_type_get = _library.gnutls_certificate_type_get
694
 
    certificate_type_get.argtypes = [session_t]
 
758
    certificate_type_get.argtypes = [ClientSession]
695
759
    certificate_type_get.restype = _error_code
696
760
 
697
761
    certificate_get_peers = _library.gnutls_certificate_get_peers
698
 
    certificate_get_peers.argtypes = [session_t,
 
762
    certificate_get_peers.argtypes = [ClientSession,
699
763
                                      ctypes.POINTER(ctypes.c_uint)]
700
764
    certificate_get_peers.restype = ctypes.POINTER(datum_t)
701
765
 
708
772
    global_set_log_function.restype = None
709
773
 
710
774
    deinit = _library.gnutls_deinit
711
 
    deinit.argtypes = [session_t]
 
775
    deinit.argtypes = [ClientSession]
712
776
    deinit.restype = None
713
777
 
714
778
    handshake = _library.gnutls_handshake
715
 
    handshake.argtypes = [session_t]
716
 
    handshake.restype = _error_code
 
779
    handshake.argtypes = [ClientSession]
 
780
    handshake.restype = ctypes.c_int
717
781
    handshake.errcheck = _retry_on_error
718
782
 
719
783
    transport_set_ptr = _library.gnutls_transport_set_ptr
720
 
    transport_set_ptr.argtypes = [session_t, transport_ptr_t]
 
784
    transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
721
785
    transport_set_ptr.restype = None
722
786
 
723
787
    bye = _library.gnutls_bye
724
 
    bye.argtypes = [session_t, close_request_t]
725
 
    bye.restype = _error_code
 
788
    bye.argtypes = [ClientSession, close_request_t]
 
789
    bye.restype = ctypes.c_int
726
790
    bye.errcheck = _retry_on_error
727
791
 
728
792
    check_version = _library.gnutls_check_version
745
809
 
746
810
        x509_crt_fmt_t = ctypes.c_int
747
811
 
748
 
        # All the function declarations below are from gnutls/abstract.h
 
812
        # All the function declarations below are from
 
813
        # gnutls/abstract.h
749
814
        pubkey_init = _library.gnutls_pubkey_init
750
815
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
751
816
        pubkey_init.restype = _error_code
765
830
        pubkey_deinit.argtypes = [pubkey_t]
766
831
        pubkey_deinit.restype = None
767
832
    else:
768
 
        # All the function declarations below are from gnutls/openpgp.h
 
833
        # All the function declarations below are from
 
834
        # gnutls/openpgp.h
769
835
 
770
836
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
771
837
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
777
843
                                       openpgp_crt_fmt_t]
778
844
        openpgp_crt_import.restype = _error_code
779
845
 
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)]
 
846
        openpgp_crt_verify_self = \
 
847
            _library.gnutls_openpgp_crt_verify_self
 
848
        openpgp_crt_verify_self.argtypes = [
 
849
            openpgp_crt_t,
 
850
            ctypes.c_uint,
 
851
            ctypes.POINTER(ctypes.c_uint),
 
852
        ]
783
853
        openpgp_crt_verify_self.restype = _error_code
784
854
 
785
855
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
794
864
                                                    ctypes.c_size_t)]
795
865
        openpgp_crt_get_fingerprint.restype = _error_code
796
866
 
797
 
    if check_version("3.6.4"):
 
867
    if check_version(b"3.6.4"):
798
868
        certificate_type_get2 = _library.gnutls_certificate_type_get2
799
 
        certificate_type_get2.argtypes = [session_t, ctypes.c_int]
 
869
        certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
800
870
        certificate_type_get2.restype = _error_code
801
871
 
802
872
    # Remove non-public functions
814
884
    connection.close()
815
885
 
816
886
 
817
 
class Client(object):
 
887
class Client:
818
888
    """A representation of a client host served by this server.
819
889
 
820
890
    Attributes:
821
 
    approved:   bool(); 'None' if not yet approved/disapproved
 
891
    approved:   bool(); None if not yet approved/disapproved
822
892
    approval_delay: datetime.timedelta(); Time to wait for approval
823
893
    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.
 
894
    checker: multiprocessing.Process(); a running checker process used
 
895
             to see if the client lives. None if no process is
 
896
             running.
827
897
    checker_callback_tag: a GLib event source tag, or None
828
898
    checker_command: string; External command which is run to check
829
899
                     if client lives.  %() expansions are done at
904
974
            # key_id() and fingerprint() functions
905
975
            client["key_id"] = (section.get("key_id", "").upper()
906
976
                                .replace(" ", ""))
907
 
            client["fingerprint"] = (section["fingerprint"].upper()
 
977
            client["fingerprint"] = (section.get("fingerprint",
 
978
                                                 "").upper()
908
979
                                     .replace(" ", ""))
 
980
            if not (client["key_id"] or client["fingerprint"]):
 
981
                log.error("Skipping client %s without key_id or"
 
982
                          " fingerprint", client_name)
 
983
                del settings[client_name]
 
984
                continue
909
985
            if "secret" in section:
910
986
                client["secret"] = codecs.decode(section["secret"]
911
987
                                                 .encode("utf-8"),
952
1028
            self.last_enabled = None
953
1029
            self.expires = None
954
1030
 
955
 
        logger.debug("Creating client %r", self.name)
956
 
        logger.debug("  Key ID: %s", self.key_id)
957
 
        logger.debug("  Fingerprint: %s", self.fingerprint)
 
1031
        log.debug("Creating client %r", self.name)
 
1032
        log.debug("  Key ID: %s", self.key_id)
 
1033
        log.debug("  Fingerprint: %s", self.fingerprint)
958
1034
        self.created = settings.get("created",
959
1035
                                    datetime.datetime.utcnow())
960
1036
 
988
1064
        if getattr(self, "enabled", False):
989
1065
            # Already enabled
990
1066
            return
991
 
        self.expires = datetime.datetime.utcnow() + self.timeout
992
1067
        self.enabled = True
993
1068
        self.last_enabled = datetime.datetime.utcnow()
994
1069
        self.init_checker()
999
1074
        if not getattr(self, "enabled", False):
1000
1075
            return False
1001
1076
        if not quiet:
1002
 
            logger.info("Disabling client %s", self.name)
 
1077
            log.info("Disabling client %s", self.name)
1003
1078
        if getattr(self, "disable_initiator_tag", None) is not None:
1004
1079
            GLib.source_remove(self.disable_initiator_tag)
1005
1080
            self.disable_initiator_tag = None
1017
1092
    def __del__(self):
1018
1093
        self.disable()
1019
1094
 
1020
 
    def init_checker(self):
1021
 
        # Schedule a new checker to be started an 'interval' from now,
1022
 
        # and every interval from then on.
 
1095
    def init_checker(self, randomize_start=False):
 
1096
        # Schedule a new checker to be started a randomly selected
 
1097
        # time (a fraction of 'interval') from now.  This spreads out
 
1098
        # the startup of checkers over time when the server is
 
1099
        # started.
1023
1100
        if self.checker_initiator_tag is not None:
1024
1101
            GLib.source_remove(self.checker_initiator_tag)
 
1102
        interval_milliseconds = int(self.interval.total_seconds()
 
1103
                                    * 1000)
 
1104
        if randomize_start:
 
1105
            delay_milliseconds = random.randrange(
 
1106
                interval_milliseconds + 1)
 
1107
        else:
 
1108
            delay_milliseconds = interval_milliseconds
1025
1109
        self.checker_initiator_tag = GLib.timeout_add(
1026
 
            int(self.interval.total_seconds() * 1000),
1027
 
            self.start_checker)
1028
 
        # Schedule a disable() when 'timeout' has passed
 
1110
            delay_milliseconds, self.start_checker, randomize_start)
 
1111
        delay = datetime.timedelta(0, 0, 0, delay_milliseconds)
 
1112
        # A checker might take up to an 'interval' of time, so we can
 
1113
        # expire at the soonest one interval after a checker was
 
1114
        # started.  Since the initial checker is delayed, the expire
 
1115
        # time might have to be extended.
 
1116
        now = datetime.datetime.utcnow()
 
1117
        self.expires = now + delay + self.interval
 
1118
        # Schedule a disable() at expire time
1029
1119
        if self.disable_initiator_tag is not None:
1030
1120
            GLib.source_remove(self.disable_initiator_tag)
1031
1121
        self.disable_initiator_tag = GLib.timeout_add(
1032
 
            int(self.timeout.total_seconds() * 1000), self.disable)
1033
 
        # Also start a new checker *right now*.
1034
 
        self.start_checker()
 
1122
            int((self.expires - now).total_seconds() * 1000),
 
1123
            self.disable)
1035
1124
 
1036
1125
    def checker_callback(self, source, condition, connection,
1037
1126
                         command):
1038
1127
        """The checker has completed, so take appropriate actions."""
1039
 
        self.checker_callback_tag = None
1040
 
        self.checker = None
1041
1128
        # Read return code from connection (see call_pipe)
1042
1129
        returncode = connection.recv()
1043
1130
        connection.close()
 
1131
        if self.checker is not None:
 
1132
            self.checker.join()
 
1133
        self.checker_callback_tag = None
 
1134
        self.checker = None
1044
1135
 
1045
1136
        if returncode >= 0:
1046
1137
            self.last_checker_status = returncode
1047
1138
            self.last_checker_signal = None
1048
1139
            if self.last_checker_status == 0:
1049
 
                logger.info("Checker for %(name)s succeeded",
1050
 
                            vars(self))
 
1140
                log.info("Checker for %(name)s succeeded", vars(self))
1051
1141
                self.checked_ok()
1052
1142
            else:
1053
 
                logger.info("Checker for %(name)s failed", vars(self))
 
1143
                log.info("Checker for %(name)s failed", vars(self))
1054
1144
        else:
1055
1145
            self.last_checker_status = -1
1056
1146
            self.last_checker_signal = -returncode
1057
 
            logger.warning("Checker for %(name)s crashed?",
1058
 
                           vars(self))
 
1147
            log.warning("Checker for %(name)s crashed?", vars(self))
1059
1148
        return False
1060
1149
 
1061
1150
    def checked_ok(self):
1080
1169
    def need_approval(self):
1081
1170
        self.last_approval_request = datetime.datetime.utcnow()
1082
1171
 
1083
 
    def start_checker(self):
 
1172
    def start_checker(self, start_was_randomized=False):
1084
1173
        """Start a new checker subprocess if one is not running.
1085
1174
 
1086
1175
        If a checker already exists, leave it running and do
1095
1184
        # should be.
1096
1185
 
1097
1186
        if self.checker is not None and not self.checker.is_alive():
1098
 
            logger.warning("Checker was not alive; joining")
 
1187
            log.warning("Checker was not alive; joining")
1099
1188
            self.checker.join()
1100
1189
            self.checker = None
1101
1190
        # Start a new checker if needed
1102
1191
        if self.checker is None:
1103
1192
            # Escape attributes for the shell
1104
1193
            escaped_attrs = {
1105
 
                attr: re.escape(str(getattr(self, attr)))
 
1194
                attr: shlex.quote(str(getattr(self, attr)))
1106
1195
                for attr in self.runtime_expansions}
1107
1196
            try:
1108
1197
                command = self.checker_command % escaped_attrs
1109
1198
            except TypeError as error:
1110
 
                logger.error('Could not format string "%s"',
1111
 
                             self.checker_command,
1112
 
                             exc_info=error)
 
1199
                log.error('Could not format string "%s"',
 
1200
                          self.checker_command, exc_info=error)
1113
1201
                return True     # Try again later
1114
1202
            self.current_checker_command = command
1115
 
            logger.info("Starting checker %r for %s", command,
1116
 
                        self.name)
 
1203
            log.info("Starting checker %r for %s", command, self.name)
1117
1204
            # We don't need to redirect stdout and stderr, since
1118
1205
            # in normal mode, that is already done by daemon(),
1119
1206
            # and in debug mode we don't want to.  (Stdin is
1135
1222
                kwargs=popen_args)
1136
1223
            self.checker.start()
1137
1224
            self.checker_callback_tag = GLib.io_add_watch(
1138
 
                pipe[0].fileno(), GLib.IO_IN,
 
1225
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1226
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1139
1227
                self.checker_callback, pipe[0], command)
 
1228
        if start_was_randomized:
 
1229
            # We were started after a random delay; Schedule a new
 
1230
            # checker to be started an 'interval' from now, and every
 
1231
            # interval from then on.
 
1232
            now = datetime.datetime.utcnow()
 
1233
            self.checker_initiator_tag = GLib.timeout_add(
 
1234
                int(self.interval.total_seconds() * 1000),
 
1235
                self.start_checker)
 
1236
            self.expires = max(self.expires, now + self.interval)
 
1237
            # Don't start a new checker again after same random delay
 
1238
            return False
1140
1239
        # Re-run this periodically if run by GLib.timeout_add
1141
1240
        return True
1142
1241
 
1147
1246
            self.checker_callback_tag = None
1148
1247
        if getattr(self, "checker", None) is None:
1149
1248
            return
1150
 
        logger.debug("Stopping checker for %(name)s", vars(self))
 
1249
        log.debug("Stopping checker for %(name)s", vars(self))
1151
1250
        self.checker.terminate()
1152
1251
        self.checker = None
1153
1252
 
1180
1279
        func._dbus_name = func.__name__
1181
1280
        if func._dbus_name.endswith("_dbus_property"):
1182
1281
            func._dbus_name = func._dbus_name[:-14]
1183
 
        func._dbus_get_args_options = {'byte_arrays': byte_arrays}
 
1282
        func._dbus_get_args_options = {"byte_arrays": byte_arrays}
1184
1283
        return func
1185
1284
 
1186
1285
    return decorator
1275
1374
 
1276
1375
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1277
1376
                         out_signature="s",
1278
 
                         path_keyword='object_path',
1279
 
                         connection_keyword='connection')
 
1377
                         path_keyword="object_path",
 
1378
                         connection_keyword="connection")
1280
1379
    def Introspect(self, object_path, connection):
1281
1380
        """Overloading of standard D-Bus method.
1282
1381
 
1331
1430
            document.unlink()
1332
1431
        except (AttributeError, xml.dom.DOMException,
1333
1432
                xml.parsers.expat.ExpatError) as error:
1334
 
            logger.error("Failed to override Introspection method",
1335
 
                         exc_info=error)
 
1433
            log.error("Failed to override Introspection method",
 
1434
                      exc_info=error)
1336
1435
        return xmlstring
1337
1436
 
1338
1437
 
1396
1495
                raise ValueError("Byte arrays not supported for non-"
1397
1496
                                 "'ay' signature {!r}"
1398
1497
                                 .format(prop._dbus_signature))
1399
 
            value = dbus.ByteArray(b''.join(chr(byte)
1400
 
                                            for byte in value))
 
1498
            value = dbus.ByteArray(bytes(value))
1401
1499
        prop(value)
1402
1500
 
1403
1501
    @dbus.service.method(dbus.PROPERTIES_IFACE,
1436
1534
 
1437
1535
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1438
1536
                         out_signature="s",
1439
 
                         path_keyword='object_path',
1440
 
                         connection_keyword='connection')
 
1537
                         path_keyword="object_path",
 
1538
                         connection_keyword="connection")
1441
1539
    def Introspect(self, object_path, connection):
1442
1540
        """Overloading of standard D-Bus method.
1443
1541
 
1499
1597
            document.unlink()
1500
1598
        except (AttributeError, xml.dom.DOMException,
1501
1599
                xml.parsers.expat.ExpatError) as error:
1502
 
            logger.error("Failed to override Introspection method",
1503
 
                         exc_info=error)
 
1600
            log.error("Failed to override Introspection method",
 
1601
                      exc_info=error)
1504
1602
        return xmlstring
1505
1603
 
1506
1604
 
1538
1636
 
1539
1637
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1540
1638
                         out_signature="s",
1541
 
                         path_keyword='object_path',
1542
 
                         connection_keyword='connection')
 
1639
                         path_keyword="object_path",
 
1640
                         connection_keyword="connection")
1543
1641
    def Introspect(self, object_path, connection):
1544
1642
        """Overloading of standard D-Bus method.
1545
1643
 
1570
1668
            document.unlink()
1571
1669
        except (AttributeError, xml.dom.DOMException,
1572
1670
                xml.parsers.expat.ExpatError) as error:
1573
 
            logger.error("Failed to override Introspection method",
1574
 
                         exc_info=error)
 
1671
            log.error("Failed to override Introspection method",
 
1672
                      exc_info=error)
1575
1673
        return xmlstring
1576
1674
 
1577
1675
 
2208
2306
    del _interface
2209
2307
 
2210
2308
 
2211
 
class ProxyClient(object):
 
2309
class ProxyClient:
2212
2310
    def __init__(self, child_pipe, key_id, fpr, address):
2213
2311
        self._pipe = child_pipe
2214
 
        self._pipe.send(('init', key_id, fpr, address))
 
2312
        self._pipe.send(("init", key_id, fpr, address))
2215
2313
        if not self._pipe.recv():
2216
2314
            raise KeyError(key_id or fpr)
2217
2315
 
2218
2316
    def __getattribute__(self, name):
2219
 
        if name == '_pipe':
 
2317
        if name == "_pipe":
2220
2318
            return super(ProxyClient, self).__getattribute__(name)
2221
 
        self._pipe.send(('getattr', name))
 
2319
        self._pipe.send(("getattr", name))
2222
2320
        data = self._pipe.recv()
2223
 
        if data[0] == 'data':
 
2321
        if data[0] == "data":
2224
2322
            return data[1]
2225
 
        if data[0] == 'function':
 
2323
        if data[0] == "function":
2226
2324
 
2227
2325
            def func(*args, **kwargs):
2228
 
                self._pipe.send(('funcall', name, args, kwargs))
 
2326
                self._pipe.send(("funcall", name, args, kwargs))
2229
2327
                return self._pipe.recv()[1]
2230
2328
 
2231
2329
            return func
2232
2330
 
2233
2331
    def __setattr__(self, name, value):
2234
 
        if name == '_pipe':
 
2332
        if name == "_pipe":
2235
2333
            return super(ProxyClient, self).__setattr__(name, value)
2236
 
        self._pipe.send(('setattr', name, value))
 
2334
        self._pipe.send(("setattr", name, value))
2237
2335
 
2238
2336
 
2239
2337
class ClientHandler(socketserver.BaseRequestHandler, object):
2244
2342
 
2245
2343
    def handle(self):
2246
2344
        with contextlib.closing(self.server.child_pipe) as child_pipe:
2247
 
            logger.info("TCP connection from: %s",
2248
 
                        str(self.client_address))
2249
 
            logger.debug("Pipe FD: %d",
2250
 
                         self.server.child_pipe.fileno())
 
2345
            log.info("TCP connection from: %s",
 
2346
                     str(self.client_address))
 
2347
            log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2251
2348
 
2252
2349
            session = gnutls.ClientSession(self.request)
2253
2350
 
2254
 
            # priority = ':'.join(("NONE", "+VERS-TLS1.1",
 
2351
            # priority = ":".join(("NONE", "+VERS-TLS1.1",
2255
2352
            #                       "+AES-256-CBC", "+SHA1",
2256
2353
            #                       "+COMP-NULL", "+CTYPE-OPENPGP",
2257
2354
            #                       "+DHE-DSS"))
2259
2356
            priority = self.server.gnutls_priority
2260
2357
            if priority is None:
2261
2358
                priority = "NORMAL"
2262
 
            gnutls.priority_set_direct(session._c_object,
2263
 
                                       priority.encode("utf-8"),
2264
 
                                       None)
 
2359
            gnutls.priority_set_direct(session,
 
2360
                                       priority.encode("utf-8"), None)
2265
2361
 
2266
2362
            # Start communication using the Mandos protocol
2267
2363
            # Get protocol number
2268
2364
            line = self.request.makefile().readline()
2269
 
            logger.debug("Protocol version: %r", line)
 
2365
            log.debug("Protocol version: %r", line)
2270
2366
            try:
2271
2367
                if int(line.strip().split()[0]) > 1:
2272
2368
                    raise RuntimeError(line)
2273
2369
            except (ValueError, IndexError, RuntimeError) as error:
2274
 
                logger.error("Unknown protocol version: %s", error)
 
2370
                log.error("Unknown protocol version: %s", error)
2275
2371
                return
2276
2372
 
2277
2373
            # Start GnuTLS connection
2278
2374
            try:
2279
2375
                session.handshake()
2280
2376
            except gnutls.Error as error:
2281
 
                logger.warning("Handshake failed: %s", error)
 
2377
                log.warning("Handshake failed: %s", error)
2282
2378
                # Do not run session.bye() here: the session is not
2283
2379
                # established.  Just abandon the request.
2284
2380
                return
2285
 
            logger.debug("Handshake succeeded")
 
2381
            log.debug("Handshake succeeded")
2286
2382
 
2287
2383
            approval_required = False
2288
2384
            try:
2289
2385
                if gnutls.has_rawpk:
2290
 
                    fpr = ""
 
2386
                    fpr = b""
2291
2387
                    try:
2292
2388
                        key_id = self.key_id(
2293
2389
                            self.peer_certificate(session))
2294
2390
                    except (TypeError, gnutls.Error) as error:
2295
 
                        logger.warning("Bad certificate: %s", error)
 
2391
                        log.warning("Bad certificate: %s", error)
2296
2392
                        return
2297
 
                    logger.debug("Key ID: %s", key_id)
 
2393
                    log.debug("Key ID: %s",
 
2394
                              key_id.decode("utf-8",
 
2395
                                            errors="replace"))
2298
2396
 
2299
2397
                else:
2300
 
                    key_id = ""
 
2398
                    key_id = b""
2301
2399
                    try:
2302
2400
                        fpr = self.fingerprint(
2303
2401
                            self.peer_certificate(session))
2304
2402
                    except (TypeError, gnutls.Error) as error:
2305
 
                        logger.warning("Bad certificate: %s", error)
 
2403
                        log.warning("Bad certificate: %s", error)
2306
2404
                        return
2307
 
                    logger.debug("Fingerprint: %s", fpr)
 
2405
                    log.debug("Fingerprint: %s", fpr)
2308
2406
 
2309
2407
                try:
2310
2408
                    client = ProxyClient(child_pipe, key_id, fpr,
2319
2417
 
2320
2418
                while True:
2321
2419
                    if not client.enabled:
2322
 
                        logger.info("Client %s is disabled",
2323
 
                                    client.name)
 
2420
                        log.info("Client %s is disabled", client.name)
2324
2421
                        if self.server.use_dbus:
2325
2422
                            # Emit D-Bus signal
2326
2423
                            client.Rejected("Disabled")
2330
2427
                        # We are approved or approval is disabled
2331
2428
                        break
2332
2429
                    elif client.approved is None:
2333
 
                        logger.info("Client %s needs approval",
2334
 
                                    client.name)
 
2430
                        log.info("Client %s needs approval",
 
2431
                                 client.name)
2335
2432
                        if self.server.use_dbus:
2336
2433
                            # Emit D-Bus signal
2337
2434
                            client.NeedApproval(
2338
2435
                                client.approval_delay.total_seconds()
2339
2436
                                * 1000, client.approved_by_default)
2340
2437
                    else:
2341
 
                        logger.warning("Client %s was not approved",
2342
 
                                       client.name)
 
2438
                        log.warning("Client %s was not approved",
 
2439
                                    client.name)
2343
2440
                        if self.server.use_dbus:
2344
2441
                            # Emit D-Bus signal
2345
2442
                            client.Rejected("Denied")
2353
2450
                    time2 = datetime.datetime.now()
2354
2451
                    if (time2 - time) >= delay:
2355
2452
                        if not client.approved_by_default:
2356
 
                            logger.warning("Client %s timed out while"
2357
 
                                           " waiting for approval",
2358
 
                                           client.name)
 
2453
                            log.warning("Client %s timed out while"
 
2454
                                        " waiting for approval",
 
2455
                                        client.name)
2359
2456
                            if self.server.use_dbus:
2360
2457
                                # Emit D-Bus signal
2361
2458
                                client.Rejected("Approval timed out")
2368
2465
                try:
2369
2466
                    session.send(client.secret)
2370
2467
                except gnutls.Error as error:
2371
 
                    logger.warning("gnutls send failed",
2372
 
                                   exc_info=error)
 
2468
                    log.warning("gnutls send failed", exc_info=error)
2373
2469
                    return
2374
2470
 
2375
 
                logger.info("Sending secret to %s", client.name)
 
2471
                log.info("Sending secret to %s", client.name)
2376
2472
                # bump the timeout using extended_timeout
2377
2473
                client.bump_timeout(client.extended_timeout)
2378
2474
                if self.server.use_dbus:
2385
2481
                try:
2386
2482
                    session.bye()
2387
2483
                except gnutls.Error as error:
2388
 
                    logger.warning("GnuTLS bye failed",
2389
 
                                   exc_info=error)
 
2484
                    log.warning("GnuTLS bye failed", exc_info=error)
2390
2485
 
2391
2486
    @staticmethod
2392
2487
    def peer_certificate(session):
2393
2488
        "Return the peer's certificate as a bytestring"
2394
2489
        try:
2395
 
            cert_type = gnutls.certificate_type_get2(session._c_object,
2396
 
                                                     gnutls.CTYPE_PEERS)
 
2490
            cert_type = gnutls.certificate_type_get2(
 
2491
                session, gnutls.CTYPE_PEERS)
2397
2492
        except AttributeError:
2398
 
            cert_type = gnutls.certificate_type_get(session._c_object)
 
2493
            cert_type = gnutls.certificate_type_get(session)
2399
2494
        if gnutls.has_rawpk:
2400
2495
            valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2401
2496
        else:
2402
2497
            valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2403
2498
        # If not a valid certificate type...
2404
2499
        if cert_type not in valid_cert_types:
2405
 
            logger.info("Cert type %r not in %r", cert_type,
2406
 
                        valid_cert_types)
 
2500
            log.info("Cert type %r not in %r", cert_type,
 
2501
                     valid_cert_types)
2407
2502
            # ...return invalid data
2408
2503
            return b""
2409
2504
        list_size = ctypes.c_uint(1)
2410
2505
        cert_list = (gnutls.certificate_get_peers
2411
 
                     (session._c_object, ctypes.byref(list_size)))
 
2506
                     (session, ctypes.byref(list_size)))
2412
2507
        if not bool(cert_list) and list_size.value != 0:
2413
2508
            raise gnutls.Error("error getting peer certificate")
2414
2509
        if list_size.value == 0:
2436
2531
        buf = ctypes.create_string_buffer(32)
2437
2532
        buf_len = ctypes.c_size_t(len(buf))
2438
2533
        # 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))
 
2534
        gnutls.pubkey_get_key_id(
 
2535
            pubkey,
 
2536
            gnutls.KEYID_USE_SHA256,
 
2537
            ctypes.cast(ctypes.byref(buf),
 
2538
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2539
            ctypes.byref(buf_len))
2444
2540
        # Deinit the certificate
2445
2541
        gnutls.pubkey_deinit(pubkey)
2446
2542
 
2487
2583
        return hex_fpr
2488
2584
 
2489
2585
 
2490
 
class MultiprocessingMixIn(object):
 
2586
class MultiprocessingMixIn:
2491
2587
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
2492
2588
 
2493
2589
    def sub_process_main(self, request, address):
2505
2601
        return proc
2506
2602
 
2507
2603
 
2508
 
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
2604
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2509
2605
    """ adds a pipe to the MixIn """
2510
2606
 
2511
2607
    def process_request(self, request, client_address):
2526
2622
 
2527
2623
 
2528
2624
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2529
 
                     socketserver.TCPServer, object):
2530
 
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
 
2625
                     socketserver.TCPServer):
 
2626
    """IPv6-capable TCP server.  Accepts None as address and/or port
2531
2627
 
2532
2628
    Attributes:
2533
2629
        enabled:        Boolean; whether this server is activated yet
2584
2680
            if SO_BINDTODEVICE is None:
2585
2681
                # Fall back to a hard-coded value which seems to be
2586
2682
                # common enough.
2587
 
                logger.warning("SO_BINDTODEVICE not found, trying 25")
 
2683
                log.warning("SO_BINDTODEVICE not found, trying 25")
2588
2684
                SO_BINDTODEVICE = 25
2589
2685
            try:
2590
2686
                self.socket.setsockopt(
2592
2688
                    (self.interface + "\0").encode("utf-8"))
2593
2689
            except socket.error as error:
2594
2690
                if error.errno == errno.EPERM:
2595
 
                    logger.error("No permission to bind to"
2596
 
                                 " interface %s", self.interface)
 
2691
                    log.error("No permission to bind to interface %s",
 
2692
                              self.interface)
2597
2693
                elif error.errno == errno.ENOPROTOOPT:
2598
 
                    logger.error("SO_BINDTODEVICE not available;"
2599
 
                                 " cannot bind to interface %s",
2600
 
                                 self.interface)
 
2694
                    log.error("SO_BINDTODEVICE not available; cannot"
 
2695
                              " bind to interface %s", self.interface)
2601
2696
                elif error.errno == errno.ENODEV:
2602
 
                    logger.error("Interface %s does not exist,"
2603
 
                                 " cannot bind", self.interface)
 
2697
                    log.error("Interface %s does not exist, cannot"
 
2698
                              " bind", self.interface)
2604
2699
                else:
2605
2700
                    raise
2606
2701
        # Only bind(2) the socket if we really need to.
2665
2760
    def add_pipe(self, parent_pipe, proc):
2666
2761
        # Call "handle_ipc" for both data and EOF events
2667
2762
        GLib.io_add_watch(
2668
 
            parent_pipe.fileno(),
2669
 
            GLib.IO_IN | GLib.IO_HUP,
 
2763
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2764
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2670
2765
            functools.partial(self.handle_ipc,
2671
2766
                              parent_pipe=parent_pipe,
2672
2767
                              proc=proc))
2685
2780
        request = parent_pipe.recv()
2686
2781
        command = request[0]
2687
2782
 
2688
 
        if command == 'init':
 
2783
        if command == "init":
2689
2784
            key_id = request[1].decode("ascii")
2690
2785
            fpr = request[2].decode("ascii")
2691
2786
            address = request[3]
2692
2787
 
2693
2788
            for c in self.clients.values():
2694
 
                if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
 
2789
                if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
 
2790
                              "27AE41E4649B934CA495991B7852B855"):
2695
2791
                    continue
2696
2792
                if key_id and c.key_id == key_id:
2697
2793
                    client = c
2700
2796
                    client = c
2701
2797
                    break
2702
2798
            else:
2703
 
                logger.info("Client not found for key ID: %s, address"
2704
 
                            ": %s", key_id or fpr, address)
 
2799
                log.info("Client not found for key ID: %s, address:"
 
2800
                         " %s", key_id or fpr, address)
2705
2801
                if self.use_dbus:
2706
2802
                    # Emit D-Bus signal
2707
2803
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
2710
2806
                return False
2711
2807
 
2712
2808
            GLib.io_add_watch(
2713
 
                parent_pipe.fileno(),
2714
 
                GLib.IO_IN | GLib.IO_HUP,
 
2809
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2810
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2715
2811
                functools.partial(self.handle_ipc,
2716
2812
                                  parent_pipe=parent_pipe,
2717
2813
                                  proc=proc,
2720
2816
            # remove the old hook in favor of the new above hook on
2721
2817
            # same fileno
2722
2818
            return False
2723
 
        if command == 'funcall':
 
2819
        if command == "funcall":
2724
2820
            funcname = request[1]
2725
2821
            args = request[2]
2726
2822
            kwargs = request[3]
2727
2823
 
2728
 
            parent_pipe.send(('data', getattr(client_object,
 
2824
            parent_pipe.send(("data", getattr(client_object,
2729
2825
                                              funcname)(*args,
2730
2826
                                                        **kwargs)))
2731
2827
 
2732
 
        if command == 'getattr':
 
2828
        if command == "getattr":
2733
2829
            attrname = request[1]
2734
2830
            if isinstance(client_object.__getattribute__(attrname),
2735
 
                          collections.Callable):
2736
 
                parent_pipe.send(('function', ))
 
2831
                          collections.abc.Callable):
 
2832
                parent_pipe.send(("function", ))
2737
2833
            else:
2738
2834
                parent_pipe.send((
2739
 
                    'data', client_object.__getattribute__(attrname)))
 
2835
                    "data", client_object.__getattribute__(attrname)))
2740
2836
 
2741
 
        if command == 'setattr':
 
2837
        if command == "setattr":
2742
2838
            attrname = request[1]
2743
2839
            value = request[2]
2744
2840
            setattr(client_object, attrname, value)
2749
2845
def rfc3339_duration_to_delta(duration):
2750
2846
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2751
2847
 
2752
 
    >>> rfc3339_duration_to_delta("P7D")
2753
 
    datetime.timedelta(7)
2754
 
    >>> rfc3339_duration_to_delta("PT60S")
2755
 
    datetime.timedelta(0, 60)
2756
 
    >>> rfc3339_duration_to_delta("PT60M")
2757
 
    datetime.timedelta(0, 3600)
2758
 
    >>> rfc3339_duration_to_delta("PT24H")
2759
 
    datetime.timedelta(1)
2760
 
    >>> rfc3339_duration_to_delta("P1W")
2761
 
    datetime.timedelta(7)
2762
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2763
 
    datetime.timedelta(0, 330)
2764
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2765
 
    datetime.timedelta(1, 200)
 
2848
    >>> timedelta = datetime.timedelta
 
2849
    >>> rfc3339_duration_to_delta("P7D") == timedelta(7)
 
2850
    True
 
2851
    >>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
 
2852
    True
 
2853
    >>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
 
2854
    True
 
2855
    >>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
 
2856
    True
 
2857
    >>> rfc3339_duration_to_delta("P1W") == timedelta(7)
 
2858
    True
 
2859
    >>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
 
2860
    True
 
2861
    >>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
 
2862
    True
 
2863
    >>> del timedelta
2766
2864
    """
2767
2865
 
2768
2866
    # Parsing an RFC 3339 duration with regular expressions is not
2848
2946
def string_to_delta(interval):
2849
2947
    """Parse a string and return a datetime.timedelta
2850
2948
 
2851
 
    >>> string_to_delta('7d')
2852
 
    datetime.timedelta(7)
2853
 
    >>> string_to_delta('60s')
2854
 
    datetime.timedelta(0, 60)
2855
 
    >>> string_to_delta('60m')
2856
 
    datetime.timedelta(0, 3600)
2857
 
    >>> string_to_delta('24h')
2858
 
    datetime.timedelta(1)
2859
 
    >>> string_to_delta('1w')
2860
 
    datetime.timedelta(7)
2861
 
    >>> string_to_delta('5m 30s')
2862
 
    datetime.timedelta(0, 330)
 
2949
    >>> string_to_delta("7d") == datetime.timedelta(7)
 
2950
    True
 
2951
    >>> string_to_delta("60s") == datetime.timedelta(0, 60)
 
2952
    True
 
2953
    >>> string_to_delta("60m") == datetime.timedelta(0, 3600)
 
2954
    True
 
2955
    >>> string_to_delta("24h") == datetime.timedelta(1)
 
2956
    True
 
2957
    >>> string_to_delta("1w") == datetime.timedelta(7)
 
2958
    True
 
2959
    >>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
 
2960
    True
2863
2961
    """
2864
2962
 
2865
2963
    try:
2967
3065
 
2968
3066
    options = parser.parse_args()
2969
3067
 
2970
 
    if options.check:
2971
 
        import doctest
2972
 
        fail_count, test_count = doctest.testmod()
2973
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2974
 
 
2975
3068
    # Default values for config file for server-global settings
2976
3069
    if gnutls.has_rawpk:
2977
3070
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2997
3090
    del priority
2998
3091
 
2999
3092
    # Parse config file for server-global settings
3000
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
3093
    server_config = configparser.ConfigParser(server_defaults)
3001
3094
    del server_defaults
3002
3095
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
3003
 
    # Convert the SafeConfigParser object to a dict
 
3096
    # Convert the ConfigParser object to a dict
3004
3097
    server_settings = server_config.defaults()
3005
3098
    # Use the appropriate methods on the non-string config options
3006
3099
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
3016
3109
        # Later, stdin will, and stdout and stderr might, be dup'ed
3017
3110
        # over with an opened os.devnull.  But we don't want this to
3018
3111
        # happen with a supplied network socket.
3019
 
        if 0 <= server_settings["socket"] <= 2:
 
3112
        while 0 <= server_settings["socket"] <= 2:
3020
3113
            server_settings["socket"] = os.dup(server_settings
3021
3114
                                               ["socket"])
 
3115
        os.set_inheritable(server_settings["socket"], False)
3022
3116
    del server_config
3023
3117
 
3024
3118
    # Override the settings from the config file with command line
3073
3167
 
3074
3168
    if server_settings["servicename"] != "Mandos":
3075
3169
        syslogger.setFormatter(
3076
 
            logging.Formatter('Mandos ({}) [%(process)d]:'
3077
 
                              ' %(levelname)s: %(message)s'.format(
 
3170
            logging.Formatter("Mandos ({}) [%(process)d]:"
 
3171
                              " %(levelname)s: %(message)s".format(
3078
3172
                                  server_settings["servicename"])))
3079
3173
 
3080
3174
    # Parse config file with clients
3081
 
    client_config = configparser.SafeConfigParser(Client
3082
 
                                                  .client_defaults)
 
3175
    client_config = configparser.ConfigParser(Client.client_defaults)
3083
3176
    client_config.read(os.path.join(server_settings["configdir"],
3084
3177
                                    "clients.conf"))
3085
3178
 
3105
3198
        try:
3106
3199
            pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3107
3200
        except IOError as e:
3108
 
            logger.error("Could not open file %r", pidfilename,
3109
 
                         exc_info=e)
 
3201
            log.error("Could not open file %r", pidfilename,
 
3202
                      exc_info=e)
3110
3203
 
3111
3204
    for name, group in (("_mandos", "_mandos"),
3112
3205
                        ("mandos", "mandos"),
3123
3216
    try:
3124
3217
        os.setgid(gid)
3125
3218
        os.setuid(uid)
3126
 
        if debug:
3127
 
            logger.debug("Did setuid/setgid to {}:{}".format(uid,
3128
 
                                                             gid))
 
3219
        log.debug("Did setuid/setgid to %s:%s", uid, gid)
3129
3220
    except OSError as error:
3130
 
        logger.warning("Failed to setuid/setgid to {}:{}: {}"
3131
 
                       .format(uid, gid, os.strerror(error.errno)))
 
3221
        log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,
 
3222
                    os.strerror(error.errno))
3132
3223
        if error.errno != errno.EPERM:
3133
3224
            raise
3134
3225
 
3141
3232
 
3142
3233
        @gnutls.log_func
3143
3234
        def debug_gnutls(level, string):
3144
 
            logger.debug("GnuTLS: %s", string[:-1])
 
3235
            log.debug("GnuTLS: %s",
 
3236
                      string[:-1].decode("utf-8", errors="replace"))
3145
3237
 
3146
3238
        gnutls.global_set_log_function(debug_gnutls)
3147
3239
 
3156
3248
        # Close all input and output, do double fork, etc.
3157
3249
        daemon()
3158
3250
 
3159
 
    # multiprocessing will use threads, so before we use GLib we need
3160
 
    # to inform GLib that threads will be used.
3161
 
    GLib.threads_init()
 
3251
    if gi.version_info < (3, 10, 2):
 
3252
        # multiprocessing will use threads, so before we use GLib we
 
3253
        # need to inform GLib that threads will be used.
 
3254
        GLib.threads_init()
3162
3255
 
3163
3256
    global main_loop
3164
3257
    # From the Avahi example code
3165
3258
    DBusGMainLoop(set_as_default=True)
3166
3259
    main_loop = GLib.MainLoop()
3167
 
    bus = dbus.SystemBus()
 
3260
    if use_dbus or zeroconf:
 
3261
        bus = dbus.SystemBus()
3168
3262
    # End of Avahi example code
3169
3263
    if use_dbus:
3170
3264
        try:
3175
3269
                "se.bsnet.fukt.Mandos", bus,
3176
3270
                do_not_queue=True)
3177
3271
        except dbus.exceptions.DBusException as e:
3178
 
            logger.error("Disabling D-Bus:", exc_info=e)
 
3272
            log.error("Disabling D-Bus:", exc_info=e)
3179
3273
            use_dbus = False
3180
3274
            server_settings["use_dbus"] = False
3181
3275
            tcp_server.use_dbus = False
3240
3334
                             if isinstance(s, bytes)
3241
3335
                             else s) for s in
3242
3336
                            value["client_structure"]]
3243
 
                        # .name & .host
3244
 
                        for k in ("name", "host"):
 
3337
                        # .name, .host, and .checker_command
 
3338
                        for k in ("name", "host", "checker_command"):
3245
3339
                            if isinstance(value[k], bytes):
3246
3340
                                value[k] = value[k].decode("utf-8")
3247
 
                        if not value.has_key("key_id"):
 
3341
                        if "key_id" not in value:
3248
3342
                            value["key_id"] = ""
3249
 
                        elif not value.has_key("fingerprint"):
 
3343
                        elif "fingerprint" not in value:
3250
3344
                            value["fingerprint"] = ""
3251
3345
                    #  old_client_settings
3252
3346
                    # .keys()
3257
3351
                        for key, value in
3258
3352
                        bytes_old_client_settings.items()}
3259
3353
                    del bytes_old_client_settings
3260
 
                    # .host
 
3354
                    # .host and .checker_command
3261
3355
                    for value in old_client_settings.values():
3262
 
                        if isinstance(value["host"], bytes):
3263
 
                            value["host"] = (value["host"]
3264
 
                                             .decode("utf-8"))
 
3356
                        for attribute in ("host", "checker_command"):
 
3357
                            if isinstance(value[attribute], bytes):
 
3358
                                value[attribute] = (value[attribute]
 
3359
                                                    .decode("utf-8"))
3265
3360
            os.remove(stored_state_path)
3266
3361
        except IOError as e:
3267
3362
            if e.errno == errno.ENOENT:
3268
 
                logger.warning("Could not load persistent state:"
3269
 
                               " {}".format(os.strerror(e.errno)))
 
3363
                log.warning("Could not load persistent state:"
 
3364
                            " %s", os.strerror(e.errno))
3270
3365
            else:
3271
 
                logger.critical("Could not load persistent state:",
3272
 
                                exc_info=e)
 
3366
                log.critical("Could not load persistent state:",
 
3367
                             exc_info=e)
3273
3368
                raise
3274
3369
        except EOFError as e:
3275
 
            logger.warning("Could not load persistent state: "
3276
 
                           "EOFError:",
3277
 
                           exc_info=e)
 
3370
            log.warning("Could not load persistent state: EOFError:",
 
3371
                        exc_info=e)
3278
3372
 
3279
3373
    with PGPEngine() as pgp:
3280
3374
        for client_name, client in clients_data.items():
3307
3401
            if client["enabled"]:
3308
3402
                if datetime.datetime.utcnow() >= client["expires"]:
3309
3403
                    if not client["last_checked_ok"]:
3310
 
                        logger.warning(
3311
 
                            "disabling client {} - Client never "
3312
 
                            "performed a successful checker".format(
3313
 
                                client_name))
 
3404
                        log.warning("disabling client %s - Client"
 
3405
                                    " never performed a successful"
 
3406
                                    " checker", client_name)
3314
3407
                        client["enabled"] = False
3315
3408
                    elif client["last_checker_status"] != 0:
3316
 
                        logger.warning(
3317
 
                            "disabling client {} - Client last"
3318
 
                            " checker failed with error code"
3319
 
                            " {}".format(
3320
 
                                client_name,
3321
 
                                client["last_checker_status"]))
 
3409
                        log.warning("disabling client %s - Client"
 
3410
                                    " last checker failed with error"
 
3411
                                    " code %s", client_name,
 
3412
                                    client["last_checker_status"])
3322
3413
                        client["enabled"] = False
3323
3414
                    else:
3324
3415
                        client["expires"] = (
3325
3416
                            datetime.datetime.utcnow()
3326
3417
                            + client["timeout"])
3327
 
                        logger.debug("Last checker succeeded,"
3328
 
                                     " keeping {} enabled".format(
3329
 
                                         client_name))
 
3418
                        log.debug("Last checker succeeded, keeping %s"
 
3419
                                  " enabled", client_name)
3330
3420
            try:
3331
3421
                client["secret"] = pgp.decrypt(
3332
3422
                    client["encrypted_secret"],
3333
3423
                    client_settings[client_name]["secret"])
3334
3424
            except PGPError:
3335
3425
                # If decryption fails, we use secret from new settings
3336
 
                logger.debug("Failed to decrypt {} old secret".format(
3337
 
                    client_name))
 
3426
                log.debug("Failed to decrypt %s old secret",
 
3427
                          client_name)
3338
3428
                client["secret"] = (client_settings[client_name]
3339
3429
                                    ["secret"])
3340
3430
 
3354
3444
            server_settings=server_settings)
3355
3445
 
3356
3446
    if not tcp_server.clients:
3357
 
        logger.warning("No clients defined")
 
3447
        log.warning("No clients defined")
3358
3448
 
3359
3449
    if not foreground:
3360
3450
        if pidfile is not None:
3363
3453
                with pidfile:
3364
3454
                    print(pid, file=pidfile)
3365
3455
            except IOError:
3366
 
                logger.error("Could not write to file %r with PID %d",
3367
 
                             pidfilename, pid)
 
3456
                log.error("Could not write to file %r with PID %d",
 
3457
                          pidfilename, pid)
3368
3458
        del pidfile
3369
3459
        del pidfilename
3370
3460
 
3520
3610
 
3521
3611
        try:
3522
3612
            with tempfile.NamedTemporaryFile(
3523
 
                    mode='wb',
 
3613
                    mode="wb",
3524
3614
                    suffix=".pickle",
3525
 
                    prefix='clients-',
 
3615
                    prefix="clients-",
3526
3616
                    dir=os.path.dirname(stored_state_path),
3527
3617
                    delete=False) as stored_state:
3528
3618
                pickle.dump((clients, client_settings), stored_state,
3536
3626
                except NameError:
3537
3627
                    pass
3538
3628
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3539
 
                logger.warning("Could not save persistent state: {}"
3540
 
                               .format(os.strerror(e.errno)))
 
3629
                log.warning("Could not save persistent state: %s",
 
3630
                            os.strerror(e.errno))
3541
3631
            else:
3542
 
                logger.warning("Could not save persistent state:",
3543
 
                               exc_info=e)
 
3632
                log.warning("Could not save persistent state:",
 
3633
                            exc_info=e)
3544
3634
                raise
3545
3635
 
3546
3636
        # Delete all clients, and settings from config
3563
3653
            mandos_dbus_service.client_added_signal(client)
3564
3654
        # Need to initiate checking of clients
3565
3655
        if client.enabled:
3566
 
            client.init_checker()
 
3656
            client.init_checker(randomize_start=True)
3567
3657
 
3568
3658
    tcp_server.enable()
3569
3659
    tcp_server.server_activate()
3572
3662
    if zeroconf:
3573
3663
        service.port = tcp_server.socket.getsockname()[1]
3574
3664
    if use_ipv6:
3575
 
        logger.info("Now listening on address %r, port %d,"
3576
 
                    " flowinfo %d, scope_id %d",
3577
 
                    *tcp_server.socket.getsockname())
 
3665
        log.info("Now listening on address %r, port %d, flowinfo %d,"
 
3666
                 " scope_id %d", *tcp_server.socket.getsockname())
3578
3667
    else:                       # IPv4
3579
 
        logger.info("Now listening on address %r, port %d",
3580
 
                    *tcp_server.socket.getsockname())
 
3668
        log.info("Now listening on address %r, port %d",
 
3669
                 *tcp_server.socket.getsockname())
3581
3670
 
3582
3671
    # service.interface = tcp_server.socket.getsockname()[3]
3583
3672
 
3587
3676
            try:
3588
3677
                service.activate()
3589
3678
            except dbus.exceptions.DBusException as error:
3590
 
                logger.critical("D-Bus Exception", exc_info=error)
 
3679
                log.critical("D-Bus Exception", exc_info=error)
3591
3680
                cleanup()
3592
3681
                sys.exit(1)
3593
3682
            # End of Avahi example code
3594
3683
 
3595
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3596
 
                          lambda *args, **kwargs:
3597
 
                          (tcp_server.handle_request
3598
 
                           (*args[2:], **kwargs) or True))
 
3684
        GLib.io_add_watch(
 
3685
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3686
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3687
            lambda *args, **kwargs: (tcp_server.handle_request
 
3688
                                     (*args[2:], **kwargs) or True))
3599
3689
 
3600
 
        logger.debug("Starting main loop")
 
3690
        log.debug("Starting main loop")
3601
3691
        main_loop.run()
3602
3692
    except AvahiError as error:
3603
 
        logger.critical("Avahi Error", exc_info=error)
 
3693
        log.critical("Avahi Error", exc_info=error)
3604
3694
        cleanup()
3605
3695
        sys.exit(1)
3606
3696
    except KeyboardInterrupt:
3607
3697
        if debug:
3608
3698
            print("", file=sys.stderr)
3609
 
        logger.debug("Server received KeyboardInterrupt")
3610
 
    logger.debug("Server exiting")
 
3699
        log.debug("Server received KeyboardInterrupt")
 
3700
    log.debug("Server exiting")
3611
3701
    # Must run before the D-Bus bus name gets deregistered
3612
3702
    cleanup()
3613
3703
 
3614
 
 
3615
 
if __name__ == '__main__':
3616
 
    main()
 
3704
 
 
3705
def parse_test_args():
 
3706
    # type: () -> argparse.Namespace
 
3707
    parser = argparse.ArgumentParser(add_help=False)
 
3708
    parser.add_argument("--check", action="store_true")
 
3709
    parser.add_argument("--prefix", )
 
3710
    args, unknown_args = parser.parse_known_args()
 
3711
    if args.check:
 
3712
        # Remove test options from sys.argv
 
3713
        sys.argv[1:] = unknown_args
 
3714
    return args
 
3715
 
 
3716
# Add all tests from doctest strings
 
3717
def load_tests(loader, tests, none):
 
3718
    import doctest
 
3719
    tests.addTests(doctest.DocTestSuite())
 
3720
    return tests
 
3721
 
 
3722
if __name__ == "__main__":
 
3723
    options = parse_test_args()
 
3724
    try:
 
3725
        if options.check:
 
3726
            extra_test_prefix = options.prefix
 
3727
            if extra_test_prefix is not None:
 
3728
                if not (unittest.main(argv=[""], exit=False)
 
3729
                        .result.wasSuccessful()):
 
3730
                    sys.exit(1)
 
3731
                class ExtraTestLoader(unittest.TestLoader):
 
3732
                    testMethodPrefix = extra_test_prefix
 
3733
                # Call using ./scriptname --test [--verbose]
 
3734
                unittest.main(argv=[""], testLoader=ExtraTestLoader())
 
3735
            else:
 
3736
                unittest.main(argv=[""])
 
3737
        else:
 
3738
            main()
 
3739
    finally:
 
3740
        logging.shutdown()
 
3741
 
 
3742
# Local Variables:
 
3743
# run-tests:
 
3744
# (lambda (&optional extra)
 
3745
#   (if (not (funcall run-tests-in-test-buffer default-directory
 
3746
#             extra))
 
3747
#       (funcall show-test-buffer-in-test-window)
 
3748
#     (funcall remove-test-window)
 
3749
#     (if extra (message "Extra tests run successfully!"))))
 
3750
# run-tests-in-test-buffer:
 
3751
# (lambda (dir &optional extra)
 
3752
#   (with-current-buffer (get-buffer-create "*Test*")
 
3753
#     (setq buffer-read-only nil
 
3754
#           default-directory dir)
 
3755
#     (erase-buffer)
 
3756
#     (compilation-mode))
 
3757
#   (let ((process-result
 
3758
#          (let ((inhibit-read-only t))
 
3759
#            (process-file-shell-command
 
3760
#             (funcall get-command-line extra) nil "*Test*"))))
 
3761
#     (and (numberp process-result)
 
3762
#          (= process-result 0))))
 
3763
# get-command-line:
 
3764
# (lambda (&optional extra)
 
3765
#   (let ((quoted-script
 
3766
#          (shell-quote-argument (funcall get-script-name))))
 
3767
#     (format
 
3768
#      (concat "%s --check" (if extra " --prefix=atest" ""))
 
3769
#      quoted-script)))
 
3770
# get-script-name:
 
3771
# (lambda ()
 
3772
#   (if (fboundp 'file-local-name)
 
3773
#       (file-local-name (buffer-file-name))
 
3774
#     (or (file-remote-p (buffer-file-name) 'localname)
 
3775
#         (buffer-file-name))))
 
3776
# remove-test-window:
 
3777
# (lambda ()
 
3778
#   (let ((test-window (get-buffer-window "*Test*")))
 
3779
#     (if test-window (delete-window test-window))))
 
3780
# show-test-buffer-in-test-window:
 
3781
# (lambda ()
 
3782
#   (when (not (get-buffer-window-list "*Test*"))
 
3783
#     (setq next-error-last-buffer (get-buffer "*Test*"))
 
3784
#     (let* ((side (if (>= (window-width) 146) 'right 'bottom))
 
3785
#            (display-buffer-overriding-action
 
3786
#             `((display-buffer-in-side-window) (side . ,side)
 
3787
#               (window-height . fit-window-to-buffer)
 
3788
#               (window-width . fit-window-to-buffer))))
 
3789
#       (display-buffer "*Test*"))))
 
3790
# eval:
 
3791
# (progn
 
3792
#   (let* ((run-extra-tests (lambda () (interactive)
 
3793
#                             (funcall run-tests t)))
 
3794
#          (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
 
3795
#          (outer-keymap `(keymap (3 . ,inner-keymap))))     ; C-c
 
3796
#     (setq minor-mode-overriding-map-alist
 
3797
#           (cons `(run-tests . ,outer-keymap)
 
3798
#                 minor-mode-overriding-map-alist)))
 
3799
#   (add-hook 'after-save-hook run-tests 90 t))
 
3800
# End: