/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: 2022-04-25 18:46:48 UTC
  • mto: This revision was merged to the branch mainline in revision 1261.
  • Revision ID: teddy@recompile.se-20220425184648-w9nas5qn94qcllum
Tags: version-1.8.15-1
Version 1.8.15-1

* Makefile (version): Change to "1.8.15".
* NEWS (Version 1.8.15): Add new entry.
* debian/changelog (1.8.15-1): - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/python
2
 
# -*- mode: python; coding: utf-8 -*-
3
 
 
1
#!/usr/bin/python3 -bI
 
2
# -*- coding: utf-8; lexical-binding: t -*-
 
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
 
 
5
#
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>.  This includes the
9
 
# methods "add" and "remove" in the "AvahiService" class, the
10
 
# "server_state_changed" and "entry_group_state_changed" functions,
11
 
# and some lines in "main".
12
 
 
9
# methods "add", "remove", "server_state_changed",
 
10
# "entry_group_state_changed", "cleanup", and "activate" in the
 
11
# "AvahiService" class, and some lines in "main".
 
12
#
13
13
# Everything else is
14
 
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
15
 
16
 
# This program is free software: you can redistribute it and/or modify
17
 
# it under the terms of the GNU General Public License as published by
 
14
# Copyright © 2008-2022 Teddy Hogeborn
 
15
# Copyright © 2008-2022 Björn Påhlsson
 
16
#
 
17
# This file is part of Mandos.
 
18
#
 
19
# Mandos is free software: you can redistribute it and/or modify it
 
20
# under the terms of the GNU General Public License as published by
18
21
# the Free Software Foundation, either version 3 of the License, or
19
22
# (at your option) any later version.
20
23
#
21
 
#     This program is distributed in the hope that it will be useful,
22
 
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
24
#     Mandos is distributed in the hope that it will be useful, but
 
25
#     WITHOUT ANY WARRANTY; without even the implied warranty of
23
26
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24
27
#     GNU General Public License for more details.
25
 
 
28
#
26
29
# You should have received a copy of the GNU General Public License
27
 
# along with this program.  If not, see
28
 
# <http://www.gnu.org/licenses/>.
29
 
30
 
# Contact the authors at <mandos@fukt.bsnet.se>.
31
 
32
 
 
33
 
from __future__ import division
34
 
 
35
 
import SocketServer
 
30
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
31
#
 
32
# Contact the authors at <mandos@recompile.se>.
 
33
#
 
34
from __future__ import (division, absolute_import, print_function,
 
35
                        unicode_literals)
 
36
 
 
37
try:
 
38
    from future_builtins import *
 
39
except ImportError:
 
40
    pass
 
41
 
 
42
import sys
 
43
import unittest
 
44
import argparse
 
45
import logging
 
46
import os
 
47
try:
 
48
    import SocketServer as socketserver
 
49
except ImportError:
 
50
    import socketserver
36
51
import socket
37
 
import select
38
 
from optparse import OptionParser
39
52
import datetime
40
53
import errno
41
 
import gnutls.crypto
42
 
import gnutls.connection
43
 
import gnutls.errors
44
 
import gnutls.library.functions
45
 
import gnutls.library.constants
46
 
import gnutls.library.types
47
 
import ConfigParser
48
 
import sys
 
54
try:
 
55
    import ConfigParser as configparser
 
56
except ImportError:
 
57
    import configparser
49
58
import re
50
 
import os
51
59
import signal
52
 
from sets import Set
53
60
import subprocess
54
61
import atexit
55
62
import stat
56
 
import logging
57
63
import logging.handlers
 
64
import pwd
 
65
import contextlib
 
66
import struct
 
67
import fcntl
 
68
import functools
 
69
try:
 
70
    import cPickle as pickle
 
71
except ImportError:
 
72
    import pickle
 
73
import multiprocessing
 
74
import types
 
75
import binascii
 
76
import tempfile
 
77
import itertools
 
78
import collections
 
79
import codecs
 
80
import random
 
81
import shlex
58
82
 
59
83
import dbus
60
 
import gobject
61
 
import avahi
 
84
import dbus.service
 
85
import gi
 
86
from gi.repository import GLib
62
87
from dbus.mainloop.glib import DBusGMainLoop
63
88
import ctypes
64
 
 
65
 
version = "1.0"
66
 
 
67
 
logger = logging.Logger('mandos')
68
 
syslogger = logging.handlers.SysLogHandler\
69
 
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
70
 
             address = "/dev/log")
71
 
syslogger.setFormatter(logging.Formatter\
72
 
                        ('Mandos: %(levelname)s: %(message)s'))
73
 
logger.addHandler(syslogger)
74
 
 
75
 
console = logging.StreamHandler()
76
 
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
77
 
                                       ' %(message)s'))
78
 
logger.addHandler(console)
 
89
import ctypes.util
 
90
import xml.dom.minidom
 
91
import inspect
 
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
# Show warnings by default
 
114
if not sys.warnoptions:
 
115
    import warnings
 
116
    warnings.simplefilter("default")
 
117
 
 
118
# Try to find the value of SO_BINDTODEVICE:
 
119
try:
 
120
    # This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
 
121
    # newer, and it is also the most natural place for it:
 
122
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
 
123
except AttributeError:
 
124
    try:
 
125
        # This is where SO_BINDTODEVICE was up to and including Python
 
126
        # 2.6, and also 3.2:
 
127
        from IN import SO_BINDTODEVICE
 
128
    except ImportError:
 
129
        # In Python 2.7 it seems to have been removed entirely.
 
130
        # Try running the C preprocessor:
 
131
        try:
 
132
            cc = subprocess.Popen(["cc", "--language=c", "-E",
 
133
                                   "/dev/stdin"],
 
134
                                  stdin=subprocess.PIPE,
 
135
                                  stdout=subprocess.PIPE)
 
136
            stdout = cc.communicate(
 
137
                "#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
 
138
            SO_BINDTODEVICE = int(stdout.splitlines()[-1])
 
139
        except (OSError, ValueError, IndexError):
 
140
            # No value found
 
141
            SO_BINDTODEVICE = None
 
142
 
 
143
if sys.version_info < (3, 2):
 
144
    configparser.Configparser = configparser.SafeConfigParser
 
145
 
 
146
version = "1.8.15"
 
147
stored_state_file = "clients.pickle"
 
148
 
 
149
log = logging.getLogger(os.path.basename(sys.argv[0]))
 
150
logging.captureWarnings(True)   # Show warnings via the logging system
 
151
syslogger = None
 
152
 
 
153
try:
 
154
    if_nametoindex = ctypes.cdll.LoadLibrary(
 
155
        ctypes.util.find_library("c")).if_nametoindex
 
156
except (OSError, AttributeError):
 
157
 
 
158
    def if_nametoindex(interface):
 
159
        "Get an interface index the hard way, i.e. using fcntl()"
 
160
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
 
161
        with contextlib.closing(socket.socket()) as s:
 
162
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
163
                                struct.pack(b"16s16x", interface))
 
164
        interface_index = struct.unpack("I", ifreq[16:20])[0]
 
165
        return interface_index
 
166
 
 
167
 
 
168
def copy_function(func):
 
169
    """Make a copy of a function"""
 
170
    if sys.version_info.major == 2:
 
171
        return types.FunctionType(func.func_code,
 
172
                                  func.func_globals,
 
173
                                  func.func_name,
 
174
                                  func.func_defaults,
 
175
                                  func.func_closure)
 
176
    else:
 
177
        return types.FunctionType(func.__code__,
 
178
                                  func.__globals__,
 
179
                                  func.__name__,
 
180
                                  func.__defaults__,
 
181
                                  func.__closure__)
 
182
 
 
183
 
 
184
def initlogger(debug, level=logging.WARNING):
 
185
    """init logger and add loglevel"""
 
186
 
 
187
    global syslogger
 
188
    syslogger = (logging.handlers.SysLogHandler(
 
189
        facility=logging.handlers.SysLogHandler.LOG_DAEMON,
 
190
        address="/dev/log"))
 
191
    syslogger.setFormatter(logging.Formatter
 
192
                           ("Mandos [%(process)d]: %(levelname)s:"
 
193
                            " %(message)s"))
 
194
    log.addHandler(syslogger)
 
195
 
 
196
    if debug:
 
197
        console = logging.StreamHandler()
 
198
        console.setFormatter(logging.Formatter("%(asctime)s %(name)s"
 
199
                                               " [%(process)d]:"
 
200
                                               " %(levelname)s:"
 
201
                                               " %(message)s"))
 
202
        log.addHandler(console)
 
203
    log.setLevel(level)
 
204
 
 
205
 
 
206
class PGPError(Exception):
 
207
    """Exception if encryption/decryption fails"""
 
208
    pass
 
209
 
 
210
 
 
211
class PGPEngine:
 
212
    """A simple class for OpenPGP symmetric encryption & decryption"""
 
213
 
 
214
    def __init__(self):
 
215
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
 
216
        self.gpg = "gpg"
 
217
        try:
 
218
            output = subprocess.check_output(["gpgconf"])
 
219
            for line in output.splitlines():
 
220
                name, text, path = line.split(b":")
 
221
                if name == b"gpg":
 
222
                    self.gpg = path
 
223
                    break
 
224
        except OSError as e:
 
225
            if e.errno != errno.ENOENT:
 
226
                raise
 
227
        self.gnupgargs = ["--batch",
 
228
                          "--homedir", self.tempdir,
 
229
                          "--force-mdc",
 
230
                          "--quiet"]
 
231
        # Only GPG version 1 has the --no-use-agent option.
 
232
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
 
233
            self.gnupgargs.append("--no-use-agent")
 
234
 
 
235
    def __enter__(self):
 
236
        return self
 
237
 
 
238
    def __exit__(self, exc_type, exc_value, traceback):
 
239
        self._cleanup()
 
240
        return False
 
241
 
 
242
    def __del__(self):
 
243
        self._cleanup()
 
244
 
 
245
    def _cleanup(self):
 
246
        if self.tempdir is not None:
 
247
            # Delete contents of tempdir
 
248
            for root, dirs, files in os.walk(self.tempdir,
 
249
                                             topdown=False):
 
250
                for filename in files:
 
251
                    os.remove(os.path.join(root, filename))
 
252
                for dirname in dirs:
 
253
                    os.rmdir(os.path.join(root, dirname))
 
254
            # Remove tempdir
 
255
            os.rmdir(self.tempdir)
 
256
            self.tempdir = None
 
257
 
 
258
    def password_encode(self, password):
 
259
        # Passphrase can not be empty and can not contain newlines or
 
260
        # NUL bytes.  So we prefix it and hex encode it.
 
261
        encoded = b"mandos" + binascii.hexlify(password)
 
262
        if len(encoded) > 2048:
 
263
            # GnuPG can't handle long passwords, so encode differently
 
264
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
 
265
                       .replace(b"\n", b"\\n")
 
266
                       .replace(b"\0", b"\\x00"))
 
267
        return encoded
 
268
 
 
269
    def encrypt(self, data, password):
 
270
        passphrase = self.password_encode(password)
 
271
        with tempfile.NamedTemporaryFile(
 
272
                dir=self.tempdir) as passfile:
 
273
            passfile.write(passphrase)
 
274
            passfile.flush()
 
275
            proc = subprocess.Popen([self.gpg, "--symmetric",
 
276
                                     "--passphrase-file",
 
277
                                     passfile.name]
 
278
                                    + self.gnupgargs,
 
279
                                    stdin=subprocess.PIPE,
 
280
                                    stdout=subprocess.PIPE,
 
281
                                    stderr=subprocess.PIPE)
 
282
            ciphertext, err = proc.communicate(input=data)
 
283
        if proc.returncode != 0:
 
284
            raise PGPError(err)
 
285
        return ciphertext
 
286
 
 
287
    def decrypt(self, data, password):
 
288
        passphrase = self.password_encode(password)
 
289
        with tempfile.NamedTemporaryFile(
 
290
                dir=self.tempdir) as passfile:
 
291
            passfile.write(passphrase)
 
292
            passfile.flush()
 
293
            proc = subprocess.Popen([self.gpg, "--decrypt",
 
294
                                     "--passphrase-file",
 
295
                                     passfile.name]
 
296
                                    + self.gnupgargs,
 
297
                                    stdin=subprocess.PIPE,
 
298
                                    stdout=subprocess.PIPE,
 
299
                                    stderr=subprocess.PIPE)
 
300
            decrypted_plaintext, err = proc.communicate(input=data)
 
301
        if proc.returncode != 0:
 
302
            raise PGPError(err)
 
303
        return decrypted_plaintext
 
304
 
 
305
 
 
306
# Pretend that we have an Avahi module
 
307
class avahi:
 
308
    """This isn't so much a class as it is a module-like namespace."""
 
309
    IF_UNSPEC = -1               # avahi-common/address.h
 
310
    PROTO_UNSPEC = -1            # avahi-common/address.h
 
311
    PROTO_INET = 0               # avahi-common/address.h
 
312
    PROTO_INET6 = 1              # avahi-common/address.h
 
313
    DBUS_NAME = "org.freedesktop.Avahi"
 
314
    DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
 
315
    DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
 
316
    DBUS_PATH_SERVER = "/"
 
317
 
 
318
    @staticmethod
 
319
    def string_array_to_txt_array(t):
 
320
        return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
 
321
                           for s in t), signature="ay")
 
322
    ENTRY_GROUP_ESTABLISHED = 2  # avahi-common/defs.h
 
323
    ENTRY_GROUP_COLLISION = 3    # avahi-common/defs.h
 
324
    ENTRY_GROUP_FAILURE = 4      # avahi-common/defs.h
 
325
    SERVER_INVALID = 0           # avahi-common/defs.h
 
326
    SERVER_REGISTERING = 1       # avahi-common/defs.h
 
327
    SERVER_RUNNING = 2           # avahi-common/defs.h
 
328
    SERVER_COLLISION = 3         # avahi-common/defs.h
 
329
    SERVER_FAILURE = 4           # avahi-common/defs.h
 
330
 
79
331
 
80
332
class AvahiError(Exception):
81
 
    def __init__(self, value):
 
333
    def __init__(self, value, *args, **kwargs):
82
334
        self.value = value
83
 
    def __str__(self):
84
 
        return repr(self.value)
 
335
        return super(AvahiError, self).__init__(value, *args,
 
336
                                                **kwargs)
 
337
 
85
338
 
86
339
class AvahiServiceError(AvahiError):
87
340
    pass
88
341
 
 
342
 
89
343
class AvahiGroupError(AvahiError):
90
344
    pass
91
345
 
92
346
 
93
 
class AvahiService(object):
 
347
class AvahiService:
94
348
    """An Avahi (Zeroconf) service.
 
349
 
95
350
    Attributes:
96
351
    interface: integer; avahi.IF_UNSPEC or an interface index.
97
352
               Used to optionally bind to the specified interface.
98
 
    name: string; Example: 'Mandos'
99
 
    type: string; Example: '_mandos._tcp'.
100
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
353
    name: string; Example: "Mandos"
 
354
    type: string; Example: "_mandos._tcp".
 
355
     See <https://www.iana.org/assignments/service-names-port-numbers>
101
356
    port: integer; what port to announce
102
357
    TXT: list of strings; TXT record for the service
103
358
    domain: string; Domain to publish on, default to .local if empty.
105
360
    max_renames: integer; maximum number of renames
106
361
    rename_count: integer; counter so we only rename after collisions
107
362
                  a sensible number of times
 
363
    group: D-Bus Entry Group
 
364
    server: D-Bus Server
 
365
    bus: dbus.SystemBus()
108
366
    """
109
 
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
110
 
                 type = None, port = None, TXT = None, domain = "",
111
 
                 host = "", max_renames = 32768):
 
367
 
 
368
    def __init__(self,
 
369
                 interface=avahi.IF_UNSPEC,
 
370
                 name=None,
 
371
                 servicetype=None,
 
372
                 port=None,
 
373
                 TXT=None,
 
374
                 domain="",
 
375
                 host="",
 
376
                 max_renames=32768,
 
377
                 protocol=avahi.PROTO_UNSPEC,
 
378
                 bus=None):
112
379
        self.interface = interface
113
380
        self.name = name
114
 
        self.type = type
 
381
        self.type = servicetype
115
382
        self.port = port
116
 
        if TXT is None:
117
 
            self.TXT = []
118
 
        else:
119
 
            self.TXT = TXT
 
383
        self.TXT = TXT if TXT is not None else []
120
384
        self.domain = domain
121
385
        self.host = host
122
386
        self.rename_count = 0
123
387
        self.max_renames = max_renames
124
 
    def rename(self):
 
388
        self.protocol = protocol
 
389
        self.group = None       # our entry group
 
390
        self.server = None
 
391
        self.bus = bus
 
392
        self.entry_group_state_changed_match = None
 
393
 
 
394
    def rename(self, remove=True):
125
395
        """Derived from the Avahi example code"""
126
396
        if self.rename_count >= self.max_renames:
127
 
            logger.critical(u"No suitable Zeroconf service name found"
128
 
                            u" after %i retries, exiting.",
129
 
                            rename_count)
 
397
            log.critical("No suitable Zeroconf service name found"
 
398
                         " after %i retries, exiting.",
 
399
                         self.rename_count)
130
400
            raise AvahiServiceError("Too many renames")
131
 
        self.name = server.GetAlternativeServiceName(self.name)
132
 
        logger.info(u"Changing Zeroconf service name to %r ...",
133
 
                    str(self.name))
134
 
        syslogger.setFormatter(logging.Formatter\
135
 
                               ('Mandos (%s): %%(levelname)s:'
136
 
                               ' %%(message)s' % self.name))
137
 
        self.remove()
138
 
        self.add()
 
401
        self.name = str(
 
402
            self.server.GetAlternativeServiceName(self.name))
139
403
        self.rename_count += 1
 
404
        log.info("Changing Zeroconf service name to %r ...",
 
405
                 self.name)
 
406
        if remove:
 
407
            self.remove()
 
408
        try:
 
409
            self.add()
 
410
        except dbus.exceptions.DBusException as error:
 
411
            if (error.get_dbus_name()
 
412
                == "org.freedesktop.Avahi.CollisionError"):
 
413
                log.info("Local Zeroconf service name collision.")
 
414
                return self.rename(remove=False)
 
415
            else:
 
416
                log.critical("D-Bus Exception", exc_info=error)
 
417
                self.cleanup()
 
418
                os._exit(1)
 
419
 
140
420
    def remove(self):
141
421
        """Derived from the Avahi example code"""
142
 
        if group is not None:
143
 
            group.Reset()
 
422
        if self.entry_group_state_changed_match is not None:
 
423
            self.entry_group_state_changed_match.remove()
 
424
            self.entry_group_state_changed_match = None
 
425
        if self.group is not None:
 
426
            self.group.Reset()
 
427
 
144
428
    def add(self):
145
429
        """Derived from the Avahi example code"""
146
 
        global group
147
 
        if group is None:
148
 
            group = dbus.Interface\
149
 
                    (bus.get_object(avahi.DBUS_NAME,
150
 
                                    server.EntryGroupNew()),
151
 
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
152
 
            group.connect_to_signal('StateChanged',
153
 
                                    entry_group_state_changed)
154
 
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
155
 
                     service.name, service.type)
156
 
        group.AddService(
157
 
                self.interface,         # interface
158
 
                avahi.PROTO_INET6,      # protocol
159
 
                dbus.UInt32(0),         # flags
160
 
                self.name, self.type,
161
 
                self.domain, self.host,
162
 
                dbus.UInt16(self.port),
163
 
                avahi.string_array_to_txt_array(self.TXT))
164
 
        group.Commit()
165
 
 
166
 
# From the Avahi example code:
167
 
group = None                            # our entry group
168
 
# End of Avahi example code
169
 
 
170
 
 
171
 
class Client(object):
 
430
        self.remove()
 
431
        if self.group is None:
 
432
            self.group = dbus.Interface(
 
433
                self.bus.get_object(avahi.DBUS_NAME,
 
434
                                    self.server.EntryGroupNew()),
 
435
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
436
        self.entry_group_state_changed_match = (
 
437
            self.group.connect_to_signal(
 
438
                "StateChanged", self.entry_group_state_changed))
 
439
        log.debug("Adding Zeroconf service '%s' of type '%s' ...",
 
440
                  self.name, self.type)
 
441
        self.group.AddService(
 
442
            self.interface,
 
443
            self.protocol,
 
444
            dbus.UInt32(0),     # flags
 
445
            self.name, self.type,
 
446
            self.domain, self.host,
 
447
            dbus.UInt16(self.port),
 
448
            avahi.string_array_to_txt_array(self.TXT))
 
449
        self.group.Commit()
 
450
 
 
451
    def entry_group_state_changed(self, state, error):
 
452
        """Derived from the Avahi example code"""
 
453
        log.debug("Avahi entry group state change: %i", state)
 
454
 
 
455
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
 
456
            log.debug("Zeroconf service established.")
 
457
        elif state == avahi.ENTRY_GROUP_COLLISION:
 
458
            log.info("Zeroconf service name collision.")
 
459
            self.rename()
 
460
        elif state == avahi.ENTRY_GROUP_FAILURE:
 
461
            log.critical("Avahi: Error in group state changed %s",
 
462
                         str(error))
 
463
            raise AvahiGroupError("State changed: {!s}".format(error))
 
464
 
 
465
    def cleanup(self):
 
466
        """Derived from the Avahi example code"""
 
467
        if self.group is not None:
 
468
            try:
 
469
                self.group.Free()
 
470
            except (dbus.exceptions.UnknownMethodException,
 
471
                    dbus.exceptions.DBusException):
 
472
                pass
 
473
            self.group = None
 
474
        self.remove()
 
475
 
 
476
    def server_state_changed(self, state, error=None):
 
477
        """Derived from the Avahi example code"""
 
478
        log.debug("Avahi server state change: %i", state)
 
479
        bad_states = {
 
480
            avahi.SERVER_INVALID: "Zeroconf server invalid",
 
481
            avahi.SERVER_REGISTERING: None,
 
482
            avahi.SERVER_COLLISION: "Zeroconf server name collision",
 
483
            avahi.SERVER_FAILURE: "Zeroconf server failure",
 
484
        }
 
485
        if state in bad_states:
 
486
            if bad_states[state] is not None:
 
487
                if error is None:
 
488
                    log.error(bad_states[state])
 
489
                else:
 
490
                    log.error(bad_states[state] + ": %r", error)
 
491
            self.cleanup()
 
492
        elif state == avahi.SERVER_RUNNING:
 
493
            try:
 
494
                self.add()
 
495
            except dbus.exceptions.DBusException as error:
 
496
                if (error.get_dbus_name()
 
497
                    == "org.freedesktop.Avahi.CollisionError"):
 
498
                    log.info("Local Zeroconf service name collision.")
 
499
                    return self.rename(remove=False)
 
500
                else:
 
501
                    log.critical("D-Bus Exception", exc_info=error)
 
502
                    self.cleanup()
 
503
                    os._exit(1)
 
504
        else:
 
505
            if error is None:
 
506
                log.debug("Unknown state: %r", state)
 
507
            else:
 
508
                log.debug("Unknown state: %r: %r", state, error)
 
509
 
 
510
    def activate(self):
 
511
        """Derived from the Avahi example code"""
 
512
        if self.server is None:
 
513
            self.server = dbus.Interface(
 
514
                self.bus.get_object(avahi.DBUS_NAME,
 
515
                                    avahi.DBUS_PATH_SERVER,
 
516
                                    follow_name_owner_changes=True),
 
517
                avahi.DBUS_INTERFACE_SERVER)
 
518
        self.server.connect_to_signal("StateChanged",
 
519
                                      self.server_state_changed)
 
520
        self.server_state_changed(self.server.GetState())
 
521
 
 
522
 
 
523
class AvahiServiceToSyslog(AvahiService):
 
524
    def rename(self, *args, **kwargs):
 
525
        """Add the new name to the syslog messages"""
 
526
        ret = super(AvahiServiceToSyslog, self).rename(*args,
 
527
                                                       **kwargs)
 
528
        syslogger.setFormatter(logging.Formatter(
 
529
            "Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
 
530
            .format(self.name)))
 
531
        return ret
 
532
 
 
533
 
 
534
# Pretend that we have a GnuTLS module
 
535
class gnutls:
 
536
    """This isn't so much a class as it is a module-like namespace."""
 
537
 
 
538
    library = ctypes.util.find_library("gnutls")
 
539
    if library is None:
 
540
        library = ctypes.util.find_library("gnutls-deb0")
 
541
    _library = ctypes.cdll.LoadLibrary(library)
 
542
    del library
 
543
 
 
544
    # Unless otherwise indicated, the constants and types below are
 
545
    # all from the gnutls/gnutls.h C header file.
 
546
 
 
547
    # Constants
 
548
    E_SUCCESS = 0
 
549
    E_INTERRUPTED = -52
 
550
    E_AGAIN = -28
 
551
    CRT_OPENPGP = 2
 
552
    CRT_RAWPK = 3
 
553
    CLIENT = 2
 
554
    SHUT_RDWR = 0
 
555
    CRD_CERTIFICATE = 1
 
556
    E_NO_CERTIFICATE_FOUND = -49
 
557
    X509_FMT_DER = 0
 
558
    NO_TICKETS = 1<<10
 
559
    ENABLE_RAWPK = 1<<18
 
560
    CTYPE_PEERS = 3
 
561
    KEYID_USE_SHA256 = 1        # gnutls/x509.h
 
562
    OPENPGP_FMT_RAW = 0         # gnutls/openpgp.h
 
563
 
 
564
    # Types
 
565
    class _session_int(ctypes.Structure):
 
566
        _fields_ = []
 
567
    session_t = ctypes.POINTER(_session_int)
 
568
 
 
569
    class certificate_credentials_st(ctypes.Structure):
 
570
        _fields_ = []
 
571
    certificate_credentials_t = ctypes.POINTER(
 
572
        certificate_credentials_st)
 
573
    certificate_type_t = ctypes.c_int
 
574
 
 
575
    class datum_t(ctypes.Structure):
 
576
        _fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
 
577
                    ("size", ctypes.c_uint)]
 
578
 
 
579
    class _openpgp_crt_int(ctypes.Structure):
 
580
        _fields_ = []
 
581
    openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
 
582
    openpgp_crt_fmt_t = ctypes.c_int  # gnutls/openpgp.h
 
583
    log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
 
584
    credentials_type_t = ctypes.c_int
 
585
    transport_ptr_t = ctypes.c_void_p
 
586
    close_request_t = ctypes.c_int
 
587
 
 
588
    # Exceptions
 
589
    class Error(Exception):
 
590
        def __init__(self, message=None, code=None, args=()):
 
591
            # Default usage is by a message string, but if a return
 
592
            # code is passed, convert it to a string with
 
593
            # gnutls.strerror()
 
594
            self.code = code
 
595
            if message is None and code is not None:
 
596
                message = gnutls.strerror(code).decode(
 
597
                    "utf-8", errors="replace")
 
598
            return super(gnutls.Error, self).__init__(
 
599
                message, *args)
 
600
 
 
601
    class CertificateSecurityError(Error):
 
602
        pass
 
603
 
 
604
    class PointerTo:
 
605
        def __init__(self, cls):
 
606
            self.cls = cls
 
607
 
 
608
        def from_param(self, obj):
 
609
            if not isinstance(obj, self.cls):
 
610
                raise TypeError("Not of type {}: {!r}"
 
611
                                .format(self.cls.__name__, obj))
 
612
            return ctypes.byref(obj.from_param(obj))
 
613
 
 
614
    class CastToVoidPointer:
 
615
        def __init__(self, cls):
 
616
            self.cls = cls
 
617
 
 
618
        def from_param(self, obj):
 
619
            if not isinstance(obj, self.cls):
 
620
                raise TypeError("Not of type {}: {!r}"
 
621
                                .format(self.cls.__name__, obj))
 
622
            return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
 
623
 
 
624
    class With_from_param:
 
625
        @classmethod
 
626
        def from_param(cls, obj):
 
627
            return obj._as_parameter_
 
628
 
 
629
    # Classes
 
630
    class Credentials(With_from_param):
 
631
        def __init__(self):
 
632
            self._as_parameter_ = gnutls.certificate_credentials_t()
 
633
            gnutls.certificate_allocate_credentials(self)
 
634
            self.type = gnutls.CRD_CERTIFICATE
 
635
 
 
636
        def __del__(self):
 
637
            gnutls.certificate_free_credentials(self)
 
638
 
 
639
    class ClientSession(With_from_param):
 
640
        def __init__(self, socket, credentials=None):
 
641
            self._as_parameter_ = gnutls.session_t()
 
642
            gnutls_flags = gnutls.CLIENT
 
643
            if gnutls.check_version(b"3.5.6"):
 
644
                gnutls_flags |= gnutls.NO_TICKETS
 
645
            if gnutls.has_rawpk:
 
646
                gnutls_flags |= gnutls.ENABLE_RAWPK
 
647
            gnutls.init(self, gnutls_flags)
 
648
            del gnutls_flags
 
649
            gnutls.set_default_priority(self)
 
650
            gnutls.transport_set_ptr(self, socket.fileno())
 
651
            gnutls.handshake_set_private_extensions(self, True)
 
652
            self.socket = socket
 
653
            if credentials is None:
 
654
                credentials = gnutls.Credentials()
 
655
            gnutls.credentials_set(self, credentials.type,
 
656
                                   credentials)
 
657
            self.credentials = credentials
 
658
 
 
659
        def __del__(self):
 
660
            gnutls.deinit(self)
 
661
 
 
662
        def handshake(self):
 
663
            return gnutls.handshake(self)
 
664
 
 
665
        def send(self, data):
 
666
            data = bytes(data)
 
667
            data_len = len(data)
 
668
            while data_len > 0:
 
669
                data_len -= gnutls.record_send(self, data[-data_len:],
 
670
                                               data_len)
 
671
 
 
672
        def bye(self):
 
673
            return gnutls.bye(self, gnutls.SHUT_RDWR)
 
674
 
 
675
    # Error handling functions
 
676
    def _error_code(result):
 
677
        """A function to raise exceptions on errors, suitable
 
678
        for the "restype" attribute on ctypes functions"""
 
679
        if result >= gnutls.E_SUCCESS:
 
680
            return result
 
681
        if result == gnutls.E_NO_CERTIFICATE_FOUND:
 
682
            raise gnutls.CertificateSecurityError(code=result)
 
683
        raise gnutls.Error(code=result)
 
684
 
 
685
    def _retry_on_error(result, func, arguments,
 
686
                        _error_code=_error_code):
 
687
        """A function to retry on some errors, suitable
 
688
        for the "errcheck" attribute on ctypes functions"""
 
689
        while result < gnutls.E_SUCCESS:
 
690
            if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
 
691
                return _error_code(result)
 
692
            result = func(*arguments)
 
693
        return result
 
694
 
 
695
    # Unless otherwise indicated, the function declarations below are
 
696
    # all from the gnutls/gnutls.h C header file.
 
697
 
 
698
    # Functions
 
699
    priority_set_direct = _library.gnutls_priority_set_direct
 
700
    priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
 
701
                                    ctypes.POINTER(ctypes.c_char_p)]
 
702
    priority_set_direct.restype = _error_code
 
703
 
 
704
    init = _library.gnutls_init
 
705
    init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
 
706
    init.restype = _error_code
 
707
 
 
708
    set_default_priority = _library.gnutls_set_default_priority
 
709
    set_default_priority.argtypes = [ClientSession]
 
710
    set_default_priority.restype = _error_code
 
711
 
 
712
    record_send = _library.gnutls_record_send
 
713
    record_send.argtypes = [ClientSession, ctypes.c_void_p,
 
714
                            ctypes.c_size_t]
 
715
    record_send.restype = ctypes.c_ssize_t
 
716
    record_send.errcheck = _retry_on_error
 
717
 
 
718
    certificate_allocate_credentials = (
 
719
        _library.gnutls_certificate_allocate_credentials)
 
720
    certificate_allocate_credentials.argtypes = [
 
721
        PointerTo(Credentials)]
 
722
    certificate_allocate_credentials.restype = _error_code
 
723
 
 
724
    certificate_free_credentials = (
 
725
        _library.gnutls_certificate_free_credentials)
 
726
    certificate_free_credentials.argtypes = [Credentials]
 
727
    certificate_free_credentials.restype = None
 
728
 
 
729
    handshake_set_private_extensions = (
 
730
        _library.gnutls_handshake_set_private_extensions)
 
731
    handshake_set_private_extensions.argtypes = [ClientSession,
 
732
                                                 ctypes.c_int]
 
733
    handshake_set_private_extensions.restype = None
 
734
 
 
735
    credentials_set = _library.gnutls_credentials_set
 
736
    credentials_set.argtypes = [ClientSession, credentials_type_t,
 
737
                                CastToVoidPointer(Credentials)]
 
738
    credentials_set.restype = _error_code
 
739
 
 
740
    strerror = _library.gnutls_strerror
 
741
    strerror.argtypes = [ctypes.c_int]
 
742
    strerror.restype = ctypes.c_char_p
 
743
 
 
744
    certificate_type_get = _library.gnutls_certificate_type_get
 
745
    certificate_type_get.argtypes = [ClientSession]
 
746
    certificate_type_get.restype = _error_code
 
747
 
 
748
    certificate_get_peers = _library.gnutls_certificate_get_peers
 
749
    certificate_get_peers.argtypes = [ClientSession,
 
750
                                      ctypes.POINTER(ctypes.c_uint)]
 
751
    certificate_get_peers.restype = ctypes.POINTER(datum_t)
 
752
 
 
753
    global_set_log_level = _library.gnutls_global_set_log_level
 
754
    global_set_log_level.argtypes = [ctypes.c_int]
 
755
    global_set_log_level.restype = None
 
756
 
 
757
    global_set_log_function = _library.gnutls_global_set_log_function
 
758
    global_set_log_function.argtypes = [log_func]
 
759
    global_set_log_function.restype = None
 
760
 
 
761
    deinit = _library.gnutls_deinit
 
762
    deinit.argtypes = [ClientSession]
 
763
    deinit.restype = None
 
764
 
 
765
    handshake = _library.gnutls_handshake
 
766
    handshake.argtypes = [ClientSession]
 
767
    handshake.restype = ctypes.c_int
 
768
    handshake.errcheck = _retry_on_error
 
769
 
 
770
    transport_set_ptr = _library.gnutls_transport_set_ptr
 
771
    transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
 
772
    transport_set_ptr.restype = None
 
773
 
 
774
    bye = _library.gnutls_bye
 
775
    bye.argtypes = [ClientSession, close_request_t]
 
776
    bye.restype = ctypes.c_int
 
777
    bye.errcheck = _retry_on_error
 
778
 
 
779
    check_version = _library.gnutls_check_version
 
780
    check_version.argtypes = [ctypes.c_char_p]
 
781
    check_version.restype = ctypes.c_char_p
 
782
 
 
783
    _need_version = b"3.3.0"
 
784
    if check_version(_need_version) is None:
 
785
        raise self.Error("Needs GnuTLS {} or later"
 
786
                         .format(_need_version))
 
787
 
 
788
    _tls_rawpk_version = b"3.6.6"
 
789
    has_rawpk = bool(check_version(_tls_rawpk_version))
 
790
 
 
791
    if has_rawpk:
 
792
        # Types
 
793
        class pubkey_st(ctypes.Structure):
 
794
            _fields = []
 
795
        pubkey_t = ctypes.POINTER(pubkey_st)
 
796
 
 
797
        x509_crt_fmt_t = ctypes.c_int
 
798
 
 
799
        # All the function declarations below are from
 
800
        # gnutls/abstract.h
 
801
        pubkey_init = _library.gnutls_pubkey_init
 
802
        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
 
803
        pubkey_init.restype = _error_code
 
804
 
 
805
        pubkey_import = _library.gnutls_pubkey_import
 
806
        pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
 
807
                                  x509_crt_fmt_t]
 
808
        pubkey_import.restype = _error_code
 
809
 
 
810
        pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
 
811
        pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
 
812
                                      ctypes.POINTER(ctypes.c_ubyte),
 
813
                                      ctypes.POINTER(ctypes.c_size_t)]
 
814
        pubkey_get_key_id.restype = _error_code
 
815
 
 
816
        pubkey_deinit = _library.gnutls_pubkey_deinit
 
817
        pubkey_deinit.argtypes = [pubkey_t]
 
818
        pubkey_deinit.restype = None
 
819
    else:
 
820
        # All the function declarations below are from
 
821
        # gnutls/openpgp.h
 
822
 
 
823
        openpgp_crt_init = _library.gnutls_openpgp_crt_init
 
824
        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
 
825
        openpgp_crt_init.restype = _error_code
 
826
 
 
827
        openpgp_crt_import = _library.gnutls_openpgp_crt_import
 
828
        openpgp_crt_import.argtypes = [openpgp_crt_t,
 
829
                                       ctypes.POINTER(datum_t),
 
830
                                       openpgp_crt_fmt_t]
 
831
        openpgp_crt_import.restype = _error_code
 
832
 
 
833
        openpgp_crt_verify_self = \
 
834
            _library.gnutls_openpgp_crt_verify_self
 
835
        openpgp_crt_verify_self.argtypes = [
 
836
            openpgp_crt_t,
 
837
            ctypes.c_uint,
 
838
            ctypes.POINTER(ctypes.c_uint),
 
839
        ]
 
840
        openpgp_crt_verify_self.restype = _error_code
 
841
 
 
842
        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
 
843
        openpgp_crt_deinit.argtypes = [openpgp_crt_t]
 
844
        openpgp_crt_deinit.restype = None
 
845
 
 
846
        openpgp_crt_get_fingerprint = (
 
847
            _library.gnutls_openpgp_crt_get_fingerprint)
 
848
        openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
 
849
                                                ctypes.c_void_p,
 
850
                                                ctypes.POINTER(
 
851
                                                    ctypes.c_size_t)]
 
852
        openpgp_crt_get_fingerprint.restype = _error_code
 
853
 
 
854
    if check_version(b"3.6.4"):
 
855
        certificate_type_get2 = _library.gnutls_certificate_type_get2
 
856
        certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
 
857
        certificate_type_get2.restype = _error_code
 
858
 
 
859
    # Remove non-public functions
 
860
    del _error_code, _retry_on_error
 
861
 
 
862
 
 
863
def call_pipe(connection,       # : multiprocessing.Connection
 
864
              func, *args, **kwargs):
 
865
    """This function is meant to be called by multiprocessing.Process
 
866
 
 
867
    This function runs func(*args, **kwargs), and writes the resulting
 
868
    return value on the provided multiprocessing.Connection.
 
869
    """
 
870
    connection.send(func(*args, **kwargs))
 
871
    connection.close()
 
872
 
 
873
 
 
874
class Client:
172
875
    """A representation of a client host served by this server.
 
876
 
173
877
    Attributes:
174
 
    name:      string; from the config file, used in log messages
175
 
    fingerprint: string (40 or 32 hexadecimal digits); used to
176
 
                 uniquely identify the client
177
 
    secret:    bytestring; sent verbatim (over TLS) to client
178
 
    host:      string; available for use by the checker command
179
 
    created:   datetime.datetime(); object creation, not client host
180
 
    last_checked_ok: datetime.datetime() or None if not yet checked OK
181
 
    timeout:   datetime.timedelta(); How long from last_checked_ok
182
 
                                     until this client is invalid
183
 
    interval:  datetime.timedelta(); How often to start a new checker
184
 
    stop_hook: If set, called by stop() as stop_hook(self)
185
 
    checker:   subprocess.Popen(); a running checker process used
186
 
                                   to see if the client lives.
187
 
                                   'None' if no process is running.
188
 
    checker_initiator_tag: a gobject event source tag, or None
189
 
    stop_initiator_tag:    - '' -
190
 
    checker_callback_tag:  - '' -
191
 
    checker_command: string; External command which is run to check if
192
 
                     client lives.  %() expansions are done at
 
878
    approved:   bool(); None if not yet approved/disapproved
 
879
    approval_delay: datetime.timedelta(); Time to wait for approval
 
880
    approval_duration: datetime.timedelta(); Duration of one approval
 
881
    checker: multiprocessing.Process(); a running checker process used
 
882
             to see if the client lives. None if no process is
 
883
             running.
 
884
    checker_callback_tag: a GLib event source tag, or None
 
885
    checker_command: string; External command which is run to check
 
886
                     if client lives.  %() expansions are done at
193
887
                     runtime with vars(self) as dict, so that for
194
888
                     instance %(name)s can be used in the command.
195
 
    Private attibutes:
196
 
    _timeout: Real variable for 'timeout'
197
 
    _interval: Real variable for 'interval'
198
 
    _timeout_milliseconds: Used when calling gobject.timeout_add()
199
 
    _interval_milliseconds: - '' -
 
889
    checker_initiator_tag: a GLib event source tag, or None
 
890
    created:    datetime.datetime(); (UTC) object creation
 
891
    client_structure: Object describing what attributes a client has
 
892
                      and is used for storing the client at exit
 
893
    current_checker_command: string; current running checker_command
 
894
    disable_initiator_tag: a GLib event source tag, or None
 
895
    enabled:    bool()
 
896
    fingerprint: string (40 or 32 hexadecimal digits); used to
 
897
                 uniquely identify an OpenPGP client
 
898
    key_id: string (64 hexadecimal digits); used to uniquely identify
 
899
            a client using raw public keys
 
900
    host:       string; available for use by the checker command
 
901
    interval:   datetime.timedelta(); How often to start a new checker
 
902
    last_approval_request: datetime.datetime(); (UTC) or None
 
903
    last_checked_ok: datetime.datetime(); (UTC) or None
 
904
    last_checker_status: integer between 0 and 255 reflecting exit
 
905
                         status of last checker. -1 reflects crashed
 
906
                         checker, -2 means no checker completed yet.
 
907
    last_checker_signal: The signal which killed the last checker, if
 
908
                         last_checker_status is -1
 
909
    last_enabled: datetime.datetime(); (UTC) or None
 
910
    name:       string; from the config file, used in log messages and
 
911
                        D-Bus identifiers
 
912
    secret:     bytestring; sent verbatim (over TLS) to client
 
913
    timeout:    datetime.timedelta(); How long from last_checked_ok
 
914
                                      until this client is disabled
 
915
    extended_timeout:   extra long timeout when secret has been sent
 
916
    runtime_expansions: Allowed attributes for runtime expansion.
 
917
    expires:    datetime.datetime(); time (UTC) when a client will be
 
918
                disabled, or None
 
919
    server_settings: The server_settings dict from main()
200
920
    """
201
 
    def _set_timeout(self, timeout):
202
 
        "Setter function for 'timeout' attribute"
203
 
        self._timeout = timeout
204
 
        self._timeout_milliseconds = ((self.timeout.days
205
 
                                       * 24 * 60 * 60 * 1000)
206
 
                                      + (self.timeout.seconds * 1000)
207
 
                                      + (self.timeout.microseconds
208
 
                                         // 1000))
209
 
    timeout = property(lambda self: self._timeout,
210
 
                       _set_timeout)
211
 
    del _set_timeout
212
 
    def _set_interval(self, interval):
213
 
        "Setter function for 'interval' attribute"
214
 
        self._interval = interval
215
 
        self._interval_milliseconds = ((self.interval.days
216
 
                                        * 24 * 60 * 60 * 1000)
217
 
                                       + (self.interval.seconds
218
 
                                          * 1000)
219
 
                                       + (self.interval.microseconds
220
 
                                          // 1000))
221
 
    interval = property(lambda self: self._interval,
222
 
                        _set_interval)
223
 
    del _set_interval
224
 
    def __init__(self, name = None, stop_hook=None, config={}):
225
 
        """Note: the 'checker' key in 'config' sets the
226
 
        'checker_command' attribute and *not* the 'checker'
227
 
        attribute."""
 
921
 
 
922
    runtime_expansions = ("approval_delay", "approval_duration",
 
923
                          "created", "enabled", "expires", "key_id",
 
924
                          "fingerprint", "host", "interval",
 
925
                          "last_approval_request", "last_checked_ok",
 
926
                          "last_enabled", "name", "timeout")
 
927
    client_defaults = {
 
928
        "timeout": "PT5M",
 
929
        "extended_timeout": "PT15M",
 
930
        "interval": "PT2M",
 
931
        "checker": "fping -q -- %%(host)s",
 
932
        "host": "",
 
933
        "approval_delay": "PT0S",
 
934
        "approval_duration": "PT1S",
 
935
        "approved_by_default": "True",
 
936
        "enabled": "True",
 
937
    }
 
938
 
 
939
    @staticmethod
 
940
    def config_parser(config):
 
941
        """Construct a new dict of client settings of this form:
 
942
        { client_name: {setting_name: value, ...}, ...}
 
943
        with exceptions for any special settings as defined above.
 
944
        NOTE: Must be a pure function. Must return the same result
 
945
        value given the same arguments.
 
946
        """
 
947
        settings = {}
 
948
        for client_name in config.sections():
 
949
            section = dict(config.items(client_name))
 
950
            client = settings[client_name] = {}
 
951
 
 
952
            client["host"] = section["host"]
 
953
            # Reformat values from string types to Python types
 
954
            client["approved_by_default"] = config.getboolean(
 
955
                client_name, "approved_by_default")
 
956
            client["enabled"] = config.getboolean(client_name,
 
957
                                                  "enabled")
 
958
 
 
959
            # Uppercase and remove spaces from key_id and fingerprint
 
960
            # for later comparison purposes with return value from the
 
961
            # key_id() and fingerprint() functions
 
962
            client["key_id"] = (section.get("key_id", "").upper()
 
963
                                .replace(" ", ""))
 
964
            client["fingerprint"] = (section["fingerprint"].upper()
 
965
                                     .replace(" ", ""))
 
966
            if "secret" in section:
 
967
                client["secret"] = codecs.decode(section["secret"]
 
968
                                                 .encode("utf-8"),
 
969
                                                 "base64")
 
970
            elif "secfile" in section:
 
971
                with open(os.path.expanduser(os.path.expandvars
 
972
                                             (section["secfile"])),
 
973
                          "rb") as secfile:
 
974
                    client["secret"] = secfile.read()
 
975
            else:
 
976
                raise TypeError("No secret or secfile for section {}"
 
977
                                .format(section))
 
978
            client["timeout"] = string_to_delta(section["timeout"])
 
979
            client["extended_timeout"] = string_to_delta(
 
980
                section["extended_timeout"])
 
981
            client["interval"] = string_to_delta(section["interval"])
 
982
            client["approval_delay"] = string_to_delta(
 
983
                section["approval_delay"])
 
984
            client["approval_duration"] = string_to_delta(
 
985
                section["approval_duration"])
 
986
            client["checker_command"] = section["checker"]
 
987
            client["last_approval_request"] = None
 
988
            client["last_checked_ok"] = None
 
989
            client["last_checker_status"] = -2
 
990
 
 
991
        return settings
 
992
 
 
993
    def __init__(self, settings, name=None, server_settings=None):
228
994
        self.name = name
229
 
        logger.debug(u"Creating client %r", self.name)
230
 
        # Uppercase and remove spaces from fingerprint for later
231
 
        # comparison purposes with return value from the fingerprint()
232
 
        # function
233
 
        self.fingerprint = config["fingerprint"].upper()\
234
 
                           .replace(u" ", u"")
235
 
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
236
 
        if "secret" in config:
237
 
            self.secret = config["secret"].decode(u"base64")
238
 
        elif "secfile" in config:
239
 
            sf = open(config["secfile"])
240
 
            self.secret = sf.read()
241
 
            sf.close()
 
995
        if server_settings is None:
 
996
            server_settings = {}
 
997
        self.server_settings = server_settings
 
998
        # adding all client settings
 
999
        for setting, value in settings.items():
 
1000
            setattr(self, setting, value)
 
1001
 
 
1002
        if self.enabled:
 
1003
            if not hasattr(self, "last_enabled"):
 
1004
                self.last_enabled = datetime.datetime.utcnow()
 
1005
            if not hasattr(self, "expires"):
 
1006
                self.expires = (datetime.datetime.utcnow()
 
1007
                                + self.timeout)
242
1008
        else:
243
 
            raise TypeError(u"No secret or secfile for client %s"
244
 
                            % self.name)
245
 
        self.host = config.get("host", "")
246
 
        self.created = datetime.datetime.now()
247
 
        self.last_checked_ok = None
248
 
        self.timeout = string_to_delta(config["timeout"])
249
 
        self.interval = string_to_delta(config["interval"])
250
 
        self.stop_hook = stop_hook
 
1009
            self.last_enabled = None
 
1010
            self.expires = None
 
1011
 
 
1012
        log.debug("Creating client %r", self.name)
 
1013
        log.debug("  Key ID: %s", self.key_id)
 
1014
        log.debug("  Fingerprint: %s", self.fingerprint)
 
1015
        self.created = settings.get("created",
 
1016
                                    datetime.datetime.utcnow())
 
1017
 
 
1018
        # attributes specific for this server instance
251
1019
        self.checker = None
252
1020
        self.checker_initiator_tag = None
253
 
        self.stop_initiator_tag = None
 
1021
        self.disable_initiator_tag = None
254
1022
        self.checker_callback_tag = None
255
 
        self.check_command = config["checker"]
256
 
    def start(self):
 
1023
        self.current_checker_command = None
 
1024
        self.approved = None
 
1025
        self.approvals_pending = 0
 
1026
        self.changedstate = multiprocessing_manager.Condition(
 
1027
            multiprocessing_manager.Lock())
 
1028
        self.client_structure = [attr
 
1029
                                 for attr in self.__dict__.keys()
 
1030
                                 if not attr.startswith("_")]
 
1031
        self.client_structure.append("client_structure")
 
1032
 
 
1033
        for name, t in inspect.getmembers(
 
1034
                type(self), lambda obj: isinstance(obj, property)):
 
1035
            if not name.startswith("_"):
 
1036
                self.client_structure.append(name)
 
1037
 
 
1038
    # Send notice to process children that client state has changed
 
1039
    def send_changedstate(self):
 
1040
        with self.changedstate:
 
1041
            self.changedstate.notify_all()
 
1042
 
 
1043
    def enable(self):
257
1044
        """Start this client's checker and timeout hooks"""
 
1045
        if getattr(self, "enabled", False):
 
1046
            # Already enabled
 
1047
            return
 
1048
        self.expires = datetime.datetime.utcnow() + self.timeout
 
1049
        self.enabled = True
 
1050
        self.last_enabled = datetime.datetime.utcnow()
 
1051
        self.init_checker()
 
1052
        self.send_changedstate()
 
1053
 
 
1054
    def disable(self, quiet=True):
 
1055
        """Disable this client."""
 
1056
        if not getattr(self, "enabled", False):
 
1057
            return False
 
1058
        if not quiet:
 
1059
            log.info("Disabling client %s", self.name)
 
1060
        if getattr(self, "disable_initiator_tag", None) is not None:
 
1061
            GLib.source_remove(self.disable_initiator_tag)
 
1062
            self.disable_initiator_tag = None
 
1063
        self.expires = None
 
1064
        if getattr(self, "checker_initiator_tag", None) is not None:
 
1065
            GLib.source_remove(self.checker_initiator_tag)
 
1066
            self.checker_initiator_tag = None
 
1067
        self.stop_checker()
 
1068
        self.enabled = False
 
1069
        if not quiet:
 
1070
            self.send_changedstate()
 
1071
        # Do not run this again if called by a GLib.timeout_add
 
1072
        return False
 
1073
 
 
1074
    def __del__(self):
 
1075
        self.disable()
 
1076
 
 
1077
    def init_checker(self):
258
1078
        # Schedule a new checker to be started an 'interval' from now,
259
1079
        # and every interval from then on.
260
 
        self.checker_initiator_tag = gobject.timeout_add\
261
 
                                     (self._interval_milliseconds,
262
 
                                      self.start_checker)
 
1080
        if self.checker_initiator_tag is not None:
 
1081
            GLib.source_remove(self.checker_initiator_tag)
 
1082
        self.checker_initiator_tag = GLib.timeout_add(
 
1083
            random.randrange(int(self.interval.total_seconds() * 1000
 
1084
                                 + 1)),
 
1085
            self.start_checker)
 
1086
        # Schedule a disable() when 'timeout' has passed
 
1087
        if self.disable_initiator_tag is not None:
 
1088
            GLib.source_remove(self.disable_initiator_tag)
 
1089
        self.disable_initiator_tag = GLib.timeout_add(
 
1090
            int(self.timeout.total_seconds() * 1000), self.disable)
263
1091
        # Also start a new checker *right now*.
264
1092
        self.start_checker()
265
 
        # Schedule a stop() when 'timeout' has passed
266
 
        self.stop_initiator_tag = gobject.timeout_add\
267
 
                                  (self._timeout_milliseconds,
268
 
                                   self.stop)
269
 
    def stop(self):
270
 
        """Stop this client.
271
 
        The possibility that a client might be restarted is left open,
272
 
        but not currently used."""
273
 
        # If this client doesn't have a secret, it is already stopped.
274
 
        if hasattr(self, "secret") and self.secret:
275
 
            logger.info(u"Stopping client %s", self.name)
276
 
            self.secret = None
277
 
        else:
278
 
            return False
279
 
        if getattr(self, "stop_initiator_tag", False):
280
 
            gobject.source_remove(self.stop_initiator_tag)
281
 
            self.stop_initiator_tag = None
282
 
        if getattr(self, "checker_initiator_tag", False):
283
 
            gobject.source_remove(self.checker_initiator_tag)
284
 
            self.checker_initiator_tag = None
285
 
        self.stop_checker()
286
 
        if self.stop_hook:
287
 
            self.stop_hook(self)
288
 
        # Do not run this again if called by a gobject.timeout_add
289
 
        return False
290
 
    def __del__(self):
291
 
        self.stop_hook = None
292
 
        self.stop()
293
 
    def checker_callback(self, pid, condition):
 
1093
 
 
1094
    def checker_callback(self, source, condition, connection,
 
1095
                         command):
294
1096
        """The checker has completed, so take appropriate actions."""
295
 
        now = datetime.datetime.now()
 
1097
        # Read return code from connection (see call_pipe)
 
1098
        returncode = connection.recv()
 
1099
        connection.close()
 
1100
        if self.checker is not None:
 
1101
            self.checker.join()
296
1102
        self.checker_callback_tag = None
297
1103
        self.checker = None
298
 
        if os.WIFEXITED(condition) \
299
 
               and (os.WEXITSTATUS(condition) == 0):
300
 
            logger.info(u"Checker for %(name)s succeeded",
301
 
                        vars(self))
302
 
            self.last_checked_ok = now
303
 
            gobject.source_remove(self.stop_initiator_tag)
304
 
            self.stop_initiator_tag = gobject.timeout_add\
305
 
                                      (self._timeout_milliseconds,
306
 
                                       self.stop)
307
 
        elif not os.WIFEXITED(condition):
308
 
            logger.warning(u"Checker for %(name)s crashed?",
309
 
                           vars(self))
 
1104
 
 
1105
        if returncode >= 0:
 
1106
            self.last_checker_status = returncode
 
1107
            self.last_checker_signal = None
 
1108
            if self.last_checker_status == 0:
 
1109
                log.info("Checker for %(name)s succeeded", vars(self))
 
1110
                self.checked_ok()
 
1111
            else:
 
1112
                log.info("Checker for %(name)s failed", vars(self))
310
1113
        else:
311
 
            logger.info(u"Checker for %(name)s failed",
312
 
                        vars(self))
 
1114
            self.last_checker_status = -1
 
1115
            self.last_checker_signal = -returncode
 
1116
            log.warning("Checker for %(name)s crashed?", vars(self))
 
1117
        return False
 
1118
 
 
1119
    def checked_ok(self):
 
1120
        """Assert that the client has been seen, alive and well."""
 
1121
        self.last_checked_ok = datetime.datetime.utcnow()
 
1122
        self.last_checker_status = 0
 
1123
        self.last_checker_signal = None
 
1124
        self.bump_timeout()
 
1125
 
 
1126
    def bump_timeout(self, timeout=None):
 
1127
        """Bump up the timeout for this client."""
 
1128
        if timeout is None:
 
1129
            timeout = self.timeout
 
1130
        if self.disable_initiator_tag is not None:
 
1131
            GLib.source_remove(self.disable_initiator_tag)
 
1132
            self.disable_initiator_tag = None
 
1133
        if getattr(self, "enabled", False):
 
1134
            self.disable_initiator_tag = GLib.timeout_add(
 
1135
                int(timeout.total_seconds() * 1000), self.disable)
 
1136
            self.expires = datetime.datetime.utcnow() + timeout
 
1137
 
 
1138
    def need_approval(self):
 
1139
        self.last_approval_request = datetime.datetime.utcnow()
 
1140
 
313
1141
    def start_checker(self):
314
1142
        """Start a new checker subprocess if one is not running.
 
1143
 
315
1144
        If a checker already exists, leave it running and do
316
1145
        nothing."""
317
1146
        # The reason for not killing a running checker is that if we
318
 
        # did that, then if a checker (for some reason) started
319
 
        # running slowly and taking more than 'interval' time, the
320
 
        # client would inevitably timeout, since no checker would get
321
 
        # a chance to run to completion.  If we instead leave running
 
1147
        # did that, and if a checker (for some reason) started running
 
1148
        # slowly and taking more than 'interval' time, then the client
 
1149
        # would inevitably timeout, since no checker would get a
 
1150
        # chance to run to completion.  If we instead leave running
322
1151
        # checkers alone, the checker would have to take more time
323
 
        # than 'timeout' for the client to be declared invalid, which
324
 
        # is as it should be.
 
1152
        # than 'timeout' for the client to be disabled, which is as it
 
1153
        # should be.
 
1154
 
 
1155
        if self.checker is not None and not self.checker.is_alive():
 
1156
            log.warning("Checker was not alive; joining")
 
1157
            self.checker.join()
 
1158
            self.checker = None
 
1159
        # Start a new checker if needed
325
1160
        if self.checker is None:
326
 
            try:
327
 
                # In case check_command has exactly one % operator
328
 
                command = self.check_command % self.host
329
 
            except TypeError:
330
 
                # Escape attributes for the shell
331
 
                escaped_attrs = dict((key, re.escape(str(val)))
332
 
                                     for key, val in
333
 
                                     vars(self).iteritems())
334
 
                try:
335
 
                    command = self.check_command % escaped_attrs
336
 
                except TypeError, error:
337
 
                    logger.error(u'Could not format string "%s":'
338
 
                                 u' %s', self.check_command, error)
339
 
                    return True # Try again later
340
 
            try:
341
 
                logger.info(u"Starting checker %r for %s",
342
 
                            command, self.name)
343
 
                # We don't need to redirect stdout and stderr, since
344
 
                # in normal mode, that is already done by daemon(),
345
 
                # and in debug mode we don't want to.  (Stdin is
346
 
                # always replaced by /dev/null.)
347
 
                self.checker = subprocess.Popen(command,
348
 
                                                close_fds=True,
349
 
                                                shell=True, cwd="/")
350
 
                self.checker_callback_tag = gobject.child_watch_add\
351
 
                                            (self.checker.pid,
352
 
                                             self.checker_callback)
353
 
            except OSError, error:
354
 
                logger.error(u"Failed to start subprocess: %s",
355
 
                             error)
356
 
        # Re-run this periodically if run by gobject.timeout_add
 
1161
            # Escape attributes for the shell
 
1162
            escaped_attrs = {
 
1163
                attr: shlex.quote(str(getattr(self, attr)))
 
1164
                for attr in self.runtime_expansions}
 
1165
            try:
 
1166
                command = self.checker_command % escaped_attrs
 
1167
            except TypeError as error:
 
1168
                log.error('Could not format string "%s"',
 
1169
                          self.checker_command, exc_info=error)
 
1170
                return True     # Try again later
 
1171
            self.current_checker_command = command
 
1172
            log.info("Starting checker %r for %s", command, self.name)
 
1173
            # We don't need to redirect stdout and stderr, since
 
1174
            # in normal mode, that is already done by daemon(),
 
1175
            # and in debug mode we don't want to.  (Stdin is
 
1176
            # always replaced by /dev/null.)
 
1177
            # The exception is when not debugging but nevertheless
 
1178
            # running in the foreground; use the previously
 
1179
            # created wnull.
 
1180
            popen_args = {"close_fds": True,
 
1181
                          "shell": True,
 
1182
                          "cwd": "/"}
 
1183
            if (not self.server_settings["debug"]
 
1184
                and self.server_settings["foreground"]):
 
1185
                popen_args.update({"stdout": wnull,
 
1186
                                   "stderr": wnull})
 
1187
            pipe = multiprocessing.Pipe(duplex=False)
 
1188
            self.checker = multiprocessing.Process(
 
1189
                target=call_pipe,
 
1190
                args=(pipe[1], subprocess.call, command),
 
1191
                kwargs=popen_args)
 
1192
            self.checker.start()
 
1193
            self.checker_callback_tag = GLib.io_add_watch(
 
1194
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1195
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
1196
                self.checker_callback, pipe[0], command)
 
1197
        # Re-run this periodically if run by GLib.timeout_add
357
1198
        return True
 
1199
 
358
1200
    def stop_checker(self):
359
1201
        """Force the checker process, if any, to stop."""
360
1202
        if self.checker_callback_tag:
361
 
            gobject.source_remove(self.checker_callback_tag)
 
1203
            GLib.source_remove(self.checker_callback_tag)
362
1204
            self.checker_callback_tag = None
363
1205
        if getattr(self, "checker", None) is None:
364
1206
            return
365
 
        logger.debug(u"Stopping checker for %(name)s", vars(self))
366
 
        try:
367
 
            os.kill(self.checker.pid, signal.SIGTERM)
368
 
            #os.sleep(0.5)
369
 
            #if self.checker.poll() is None:
370
 
            #    os.kill(self.checker.pid, signal.SIGKILL)
371
 
        except OSError, error:
372
 
            if error.errno != errno.ESRCH: # No such process
373
 
                raise
 
1207
        log.debug("Stopping checker for %(name)s", vars(self))
 
1208
        self.checker.terminate()
374
1209
        self.checker = None
375
 
    def still_valid(self):
376
 
        """Has the timeout not yet passed for this client?"""
377
 
        now = datetime.datetime.now()
378
 
        if self.last_checked_ok is None:
379
 
            return now < (self.created + self.timeout)
380
 
        else:
381
 
            return now < (self.last_checked_ok + self.timeout)
382
 
 
383
 
 
384
 
def peer_certificate(session):
385
 
    "Return the peer's OpenPGP certificate as a bytestring"
386
 
    # If not an OpenPGP certificate...
387
 
    if gnutls.library.functions.gnutls_certificate_type_get\
388
 
            (session._c_object) \
389
 
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
390
 
        # ...do the normal thing
391
 
        return session.peer_certificate
392
 
    list_size = ctypes.c_uint()
393
 
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
394
 
        (session._c_object, ctypes.byref(list_size))
395
 
    if list_size.value == 0:
396
 
        return None
397
 
    cert = cert_list[0]
398
 
    return ctypes.string_at(cert.data, cert.size)
399
 
 
400
 
 
401
 
def fingerprint(openpgp):
402
 
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
403
 
    # New GnuTLS "datum" with the OpenPGP public key
404
 
    datum = gnutls.library.types.gnutls_datum_t\
405
 
        (ctypes.cast(ctypes.c_char_p(openpgp),
406
 
                     ctypes.POINTER(ctypes.c_ubyte)),
407
 
         ctypes.c_uint(len(openpgp)))
408
 
    # New empty GnuTLS certificate
409
 
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
410
 
    gnutls.library.functions.gnutls_openpgp_crt_init\
411
 
        (ctypes.byref(crt))
412
 
    # Import the OpenPGP public key into the certificate
413
 
    gnutls.library.functions.gnutls_openpgp_crt_import\
414
 
                    (crt, ctypes.byref(datum),
415
 
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
416
 
    # Verify the self signature in the key
417
 
    crtverify = ctypes.c_uint();
418
 
    gnutls.library.functions.gnutls_openpgp_crt_verify_self\
419
 
        (crt, 0, ctypes.byref(crtverify))
420
 
    if crtverify.value != 0:
421
 
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
422
 
        raise gnutls.errors.CertificateSecurityError("Verify failed")
423
 
    # New buffer for the fingerprint
424
 
    buffer = ctypes.create_string_buffer(20)
425
 
    buffer_length = ctypes.c_size_t()
426
 
    # Get the fingerprint from the certificate into the buffer
427
 
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
428
 
        (crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
429
 
    # Deinit the certificate
430
 
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
431
 
    # Convert the buffer to a Python bytestring
432
 
    fpr = ctypes.string_at(buffer, buffer_length.value)
433
 
    # Convert the bytestring to hexadecimal notation
434
 
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
435
 
    return hex_fpr
436
 
 
437
 
 
438
 
class tcp_handler(SocketServer.BaseRequestHandler, object):
439
 
    """A TCP request handler class.
440
 
    Instantiated by IPv6_TCPServer for each request to handle it.
 
1210
 
 
1211
 
 
1212
def dbus_service_property(dbus_interface,
 
1213
                          signature="v",
 
1214
                          access="readwrite",
 
1215
                          byte_arrays=False):
 
1216
    """Decorators for marking methods of a DBusObjectWithProperties to
 
1217
    become properties on the D-Bus.
 
1218
 
 
1219
    The decorated method will be called with no arguments by "Get"
 
1220
    and with one argument by "Set".
 
1221
 
 
1222
    The parameters, where they are supported, are the same as
 
1223
    dbus.service.method, except there is only "signature", since the
 
1224
    type from Get() and the type sent to Set() is the same.
 
1225
    """
 
1226
    # Encoding deeply encoded byte arrays is not supported yet by the
 
1227
    # "Set" method, so we fail early here:
 
1228
    if byte_arrays and signature != "ay":
 
1229
        raise ValueError("Byte arrays not supported for non-'ay'"
 
1230
                         " signature {!r}".format(signature))
 
1231
 
 
1232
    def decorator(func):
 
1233
        func._dbus_is_property = True
 
1234
        func._dbus_interface = dbus_interface
 
1235
        func._dbus_signature = signature
 
1236
        func._dbus_access = access
 
1237
        func._dbus_name = func.__name__
 
1238
        if func._dbus_name.endswith("_dbus_property"):
 
1239
            func._dbus_name = func._dbus_name[:-14]
 
1240
        func._dbus_get_args_options = {"byte_arrays": byte_arrays}
 
1241
        return func
 
1242
 
 
1243
    return decorator
 
1244
 
 
1245
 
 
1246
def dbus_interface_annotations(dbus_interface):
 
1247
    """Decorator for marking functions returning interface annotations
 
1248
 
 
1249
    Usage:
 
1250
 
 
1251
    @dbus_interface_annotations("org.example.Interface")
 
1252
    def _foo(self):  # Function name does not matter
 
1253
        return {"org.freedesktop.DBus.Deprecated": "true",
 
1254
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
1255
                    "false"}
 
1256
    """
 
1257
 
 
1258
    def decorator(func):
 
1259
        func._dbus_is_interface = True
 
1260
        func._dbus_interface = dbus_interface
 
1261
        func._dbus_name = dbus_interface
 
1262
        return func
 
1263
 
 
1264
    return decorator
 
1265
 
 
1266
 
 
1267
def dbus_annotations(annotations):
 
1268
    """Decorator to annotate D-Bus methods, signals or properties
 
1269
    Usage:
 
1270
 
 
1271
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
 
1272
                       "org.freedesktop.DBus.Property."
 
1273
                       "EmitsChangedSignal": "false"})
 
1274
    @dbus_service_property("org.example.Interface", signature="b",
 
1275
                           access="r")
 
1276
    def Property_dbus_property(self):
 
1277
        return dbus.Boolean(False)
 
1278
 
 
1279
    See also the DBusObjectWithAnnotations class.
 
1280
    """
 
1281
 
 
1282
    def decorator(func):
 
1283
        func._dbus_annotations = annotations
 
1284
        return func
 
1285
 
 
1286
    return decorator
 
1287
 
 
1288
 
 
1289
class DBusPropertyException(dbus.exceptions.DBusException):
 
1290
    """A base class for D-Bus property-related exceptions
 
1291
    """
 
1292
    pass
 
1293
 
 
1294
 
 
1295
class DBusPropertyAccessException(DBusPropertyException):
 
1296
    """A property's access permissions disallows an operation.
 
1297
    """
 
1298
    pass
 
1299
 
 
1300
 
 
1301
class DBusPropertyNotFound(DBusPropertyException):
 
1302
    """An attempt was made to access a non-existing property.
 
1303
    """
 
1304
    pass
 
1305
 
 
1306
 
 
1307
class DBusObjectWithAnnotations(dbus.service.Object):
 
1308
    """A D-Bus object with annotations.
 
1309
 
 
1310
    Classes inheriting from this can use the dbus_annotations
 
1311
    decorator to add annotations to methods or signals.
 
1312
    """
 
1313
 
 
1314
    @staticmethod
 
1315
    def _is_dbus_thing(thing):
 
1316
        """Returns a function testing if an attribute is a D-Bus thing
 
1317
 
 
1318
        If called like _is_dbus_thing("method") it returns a function
 
1319
        suitable for use as predicate to inspect.getmembers().
 
1320
        """
 
1321
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
 
1322
                                   False)
 
1323
 
 
1324
    def _get_all_dbus_things(self, thing):
 
1325
        """Returns a generator of (name, attribute) pairs
 
1326
        """
 
1327
        return ((getattr(athing.__get__(self), "_dbus_name", name),
 
1328
                 athing.__get__(self))
 
1329
                for cls in self.__class__.__mro__
 
1330
                for name, athing in
 
1331
                inspect.getmembers(cls, self._is_dbus_thing(thing)))
 
1332
 
 
1333
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
1334
                         out_signature="s",
 
1335
                         path_keyword="object_path",
 
1336
                         connection_keyword="connection")
 
1337
    def Introspect(self, object_path, connection):
 
1338
        """Overloading of standard D-Bus method.
 
1339
 
 
1340
        Inserts annotation tags on methods and signals.
 
1341
        """
 
1342
        xmlstring = dbus.service.Object.Introspect(self, object_path,
 
1343
                                                   connection)
 
1344
        try:
 
1345
            document = xml.dom.minidom.parseString(xmlstring)
 
1346
 
 
1347
            for if_tag in document.getElementsByTagName("interface"):
 
1348
                # Add annotation tags
 
1349
                for typ in ("method", "signal"):
 
1350
                    for tag in if_tag.getElementsByTagName(typ):
 
1351
                        annots = dict()
 
1352
                        for name, prop in (self.
 
1353
                                           _get_all_dbus_things(typ)):
 
1354
                            if (name == tag.getAttribute("name")
 
1355
                                and prop._dbus_interface
 
1356
                                == if_tag.getAttribute("name")):
 
1357
                                annots.update(getattr(
 
1358
                                    prop, "_dbus_annotations", {}))
 
1359
                        for name, value in annots.items():
 
1360
                            ann_tag = document.createElement(
 
1361
                                "annotation")
 
1362
                            ann_tag.setAttribute("name", name)
 
1363
                            ann_tag.setAttribute("value", value)
 
1364
                            tag.appendChild(ann_tag)
 
1365
                # Add interface annotation tags
 
1366
                for annotation, value in dict(
 
1367
                    itertools.chain.from_iterable(
 
1368
                        annotations().items()
 
1369
                        for name, annotations
 
1370
                        in self._get_all_dbus_things("interface")
 
1371
                        if name == if_tag.getAttribute("name")
 
1372
                        )).items():
 
1373
                    ann_tag = document.createElement("annotation")
 
1374
                    ann_tag.setAttribute("name", annotation)
 
1375
                    ann_tag.setAttribute("value", value)
 
1376
                    if_tag.appendChild(ann_tag)
 
1377
                # Fix argument name for the Introspect method itself
 
1378
                if (if_tag.getAttribute("name")
 
1379
                    == dbus.INTROSPECTABLE_IFACE):
 
1380
                    for cn in if_tag.getElementsByTagName("method"):
 
1381
                        if cn.getAttribute("name") == "Introspect":
 
1382
                            for arg in cn.getElementsByTagName("arg"):
 
1383
                                if (arg.getAttribute("direction")
 
1384
                                    == "out"):
 
1385
                                    arg.setAttribute("name",
 
1386
                                                     "xml_data")
 
1387
            xmlstring = document.toxml("utf-8")
 
1388
            document.unlink()
 
1389
        except (AttributeError, xml.dom.DOMException,
 
1390
                xml.parsers.expat.ExpatError) as error:
 
1391
            log.error("Failed to override Introspection method",
 
1392
                      exc_info=error)
 
1393
        return xmlstring
 
1394
 
 
1395
 
 
1396
class DBusObjectWithProperties(DBusObjectWithAnnotations):
 
1397
    """A D-Bus object with properties.
 
1398
 
 
1399
    Classes inheriting from this can use the dbus_service_property
 
1400
    decorator to expose methods as D-Bus properties.  It exposes the
 
1401
    standard Get(), Set(), and GetAll() methods on the D-Bus.
 
1402
    """
 
1403
 
 
1404
    def _get_dbus_property(self, interface_name, property_name):
 
1405
        """Returns a bound method if one exists which is a D-Bus
 
1406
        property with the specified name and interface.
 
1407
        """
 
1408
        for cls in self.__class__.__mro__:
 
1409
            for name, value in inspect.getmembers(
 
1410
                    cls, self._is_dbus_thing("property")):
 
1411
                if (value._dbus_name == property_name
 
1412
                    and value._dbus_interface == interface_name):
 
1413
                    return value.__get__(self)
 
1414
 
 
1415
        # No such property
 
1416
        raise DBusPropertyNotFound("{}:{}.{}".format(
 
1417
            self.dbus_object_path, interface_name, property_name))
 
1418
 
 
1419
    @classmethod
 
1420
    def _get_all_interface_names(cls):
 
1421
        """Get a sequence of all interfaces supported by an object"""
 
1422
        return (name for name in set(getattr(getattr(x, attr),
 
1423
                                             "_dbus_interface", None)
 
1424
                                     for x in (inspect.getmro(cls))
 
1425
                                     for attr in dir(x))
 
1426
                if name is not None)
 
1427
 
 
1428
    @dbus.service.method(dbus.PROPERTIES_IFACE,
 
1429
                         in_signature="ss",
 
1430
                         out_signature="v")
 
1431
    def Get(self, interface_name, property_name):
 
1432
        """Standard D-Bus property Get() method, see D-Bus standard.
 
1433
        """
 
1434
        prop = self._get_dbus_property(interface_name, property_name)
 
1435
        if prop._dbus_access == "write":
 
1436
            raise DBusPropertyAccessException(property_name)
 
1437
        value = prop()
 
1438
        if not hasattr(value, "variant_level"):
 
1439
            return value
 
1440
        return type(value)(value, variant_level=value.variant_level+1)
 
1441
 
 
1442
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
 
1443
    def Set(self, interface_name, property_name, value):
 
1444
        """Standard D-Bus property Set() method, see D-Bus standard.
 
1445
        """
 
1446
        prop = self._get_dbus_property(interface_name, property_name)
 
1447
        if prop._dbus_access == "read":
 
1448
            raise DBusPropertyAccessException(property_name)
 
1449
        if prop._dbus_get_args_options["byte_arrays"]:
 
1450
            # The byte_arrays option is not supported yet on
 
1451
            # signatures other than "ay".
 
1452
            if prop._dbus_signature != "ay":
 
1453
                raise ValueError("Byte arrays not supported for non-"
 
1454
                                 "'ay' signature {!r}"
 
1455
                                 .format(prop._dbus_signature))
 
1456
            value = dbus.ByteArray(bytes(value))
 
1457
        prop(value)
 
1458
 
 
1459
    @dbus.service.method(dbus.PROPERTIES_IFACE,
 
1460
                         in_signature="s",
 
1461
                         out_signature="a{sv}")
 
1462
    def GetAll(self, interface_name):
 
1463
        """Standard D-Bus property GetAll() method, see D-Bus
 
1464
        standard.
 
1465
 
 
1466
        Note: Will not include properties with access="write".
 
1467
        """
 
1468
        properties = {}
 
1469
        for name, prop in self._get_all_dbus_things("property"):
 
1470
            if (interface_name
 
1471
                and interface_name != prop._dbus_interface):
 
1472
                # Interface non-empty but did not match
 
1473
                continue
 
1474
            # Ignore write-only properties
 
1475
            if prop._dbus_access == "write":
 
1476
                continue
 
1477
            value = prop()
 
1478
            if not hasattr(value, "variant_level"):
 
1479
                properties[name] = value
 
1480
                continue
 
1481
            properties[name] = type(value)(
 
1482
                value, variant_level=value.variant_level + 1)
 
1483
        return dbus.Dictionary(properties, signature="sv")
 
1484
 
 
1485
    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
 
1486
    def PropertiesChanged(self, interface_name, changed_properties,
 
1487
                          invalidated_properties):
 
1488
        """Standard D-Bus PropertiesChanged() signal, see D-Bus
 
1489
        standard.
 
1490
        """
 
1491
        pass
 
1492
 
 
1493
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
1494
                         out_signature="s",
 
1495
                         path_keyword="object_path",
 
1496
                         connection_keyword="connection")
 
1497
    def Introspect(self, object_path, connection):
 
1498
        """Overloading of standard D-Bus method.
 
1499
 
 
1500
        Inserts property tags and interface annotation tags.
 
1501
        """
 
1502
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
 
1503
                                                         object_path,
 
1504
                                                         connection)
 
1505
        try:
 
1506
            document = xml.dom.minidom.parseString(xmlstring)
 
1507
 
 
1508
            def make_tag(document, name, prop):
 
1509
                e = document.createElement("property")
 
1510
                e.setAttribute("name", name)
 
1511
                e.setAttribute("type", prop._dbus_signature)
 
1512
                e.setAttribute("access", prop._dbus_access)
 
1513
                return e
 
1514
 
 
1515
            for if_tag in document.getElementsByTagName("interface"):
 
1516
                # Add property tags
 
1517
                for tag in (make_tag(document, name, prop)
 
1518
                            for name, prop
 
1519
                            in self._get_all_dbus_things("property")
 
1520
                            if prop._dbus_interface
 
1521
                            == if_tag.getAttribute("name")):
 
1522
                    if_tag.appendChild(tag)
 
1523
                # Add annotation tags for properties
 
1524
                for tag in if_tag.getElementsByTagName("property"):
 
1525
                    annots = dict()
 
1526
                    for name, prop in self._get_all_dbus_things(
 
1527
                            "property"):
 
1528
                        if (name == tag.getAttribute("name")
 
1529
                            and prop._dbus_interface
 
1530
                            == if_tag.getAttribute("name")):
 
1531
                            annots.update(getattr(
 
1532
                                prop, "_dbus_annotations", {}))
 
1533
                    for name, value in annots.items():
 
1534
                        ann_tag = document.createElement(
 
1535
                            "annotation")
 
1536
                        ann_tag.setAttribute("name", name)
 
1537
                        ann_tag.setAttribute("value", value)
 
1538
                        tag.appendChild(ann_tag)
 
1539
                # Add the names to the return values for the
 
1540
                # "org.freedesktop.DBus.Properties" methods
 
1541
                if (if_tag.getAttribute("name")
 
1542
                    == "org.freedesktop.DBus.Properties"):
 
1543
                    for cn in if_tag.getElementsByTagName("method"):
 
1544
                        if cn.getAttribute("name") == "Get":
 
1545
                            for arg in cn.getElementsByTagName("arg"):
 
1546
                                if (arg.getAttribute("direction")
 
1547
                                    == "out"):
 
1548
                                    arg.setAttribute("name", "value")
 
1549
                        elif cn.getAttribute("name") == "GetAll":
 
1550
                            for arg in cn.getElementsByTagName("arg"):
 
1551
                                if (arg.getAttribute("direction")
 
1552
                                    == "out"):
 
1553
                                    arg.setAttribute("name", "props")
 
1554
            xmlstring = document.toxml("utf-8")
 
1555
            document.unlink()
 
1556
        except (AttributeError, xml.dom.DOMException,
 
1557
                xml.parsers.expat.ExpatError) as error:
 
1558
            log.error("Failed to override Introspection method",
 
1559
                      exc_info=error)
 
1560
        return xmlstring
 
1561
 
 
1562
 
 
1563
try:
 
1564
    dbus.OBJECT_MANAGER_IFACE
 
1565
except AttributeError:
 
1566
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
 
1567
 
 
1568
 
 
1569
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
 
1570
    """A D-Bus object with an ObjectManager.
 
1571
 
 
1572
    Classes inheriting from this exposes the standard
 
1573
    GetManagedObjects call and the InterfacesAdded and
 
1574
    InterfacesRemoved signals on the standard
 
1575
    "org.freedesktop.DBus.ObjectManager" interface.
 
1576
 
 
1577
    Note: No signals are sent automatically; they must be sent
 
1578
    manually.
 
1579
    """
 
1580
    @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
 
1581
                         out_signature="a{oa{sa{sv}}}")
 
1582
    def GetManagedObjects(self):
 
1583
        """This function must be overridden"""
 
1584
        raise NotImplementedError()
 
1585
 
 
1586
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
 
1587
                         signature="oa{sa{sv}}")
 
1588
    def InterfacesAdded(self, object_path, interfaces_and_properties):
 
1589
        pass
 
1590
 
 
1591
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
 
1592
    def InterfacesRemoved(self, object_path, interfaces):
 
1593
        pass
 
1594
 
 
1595
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
1596
                         out_signature="s",
 
1597
                         path_keyword="object_path",
 
1598
                         connection_keyword="connection")
 
1599
    def Introspect(self, object_path, connection):
 
1600
        """Overloading of standard D-Bus method.
 
1601
 
 
1602
        Override return argument name of GetManagedObjects to be
 
1603
        "objpath_interfaces_and_properties"
 
1604
        """
 
1605
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
 
1606
                                                         object_path,
 
1607
                                                         connection)
 
1608
        try:
 
1609
            document = xml.dom.minidom.parseString(xmlstring)
 
1610
 
 
1611
            for if_tag in document.getElementsByTagName("interface"):
 
1612
                # Fix argument name for the GetManagedObjects method
 
1613
                if (if_tag.getAttribute("name")
 
1614
                    == dbus.OBJECT_MANAGER_IFACE):
 
1615
                    for cn in if_tag.getElementsByTagName("method"):
 
1616
                        if (cn.getAttribute("name")
 
1617
                            == "GetManagedObjects"):
 
1618
                            for arg in cn.getElementsByTagName("arg"):
 
1619
                                if (arg.getAttribute("direction")
 
1620
                                    == "out"):
 
1621
                                    arg.setAttribute(
 
1622
                                        "name",
 
1623
                                        "objpath_interfaces"
 
1624
                                        "_and_properties")
 
1625
            xmlstring = document.toxml("utf-8")
 
1626
            document.unlink()
 
1627
        except (AttributeError, xml.dom.DOMException,
 
1628
                xml.parsers.expat.ExpatError) as error:
 
1629
            log.error("Failed to override Introspection method",
 
1630
                      exc_info=error)
 
1631
        return xmlstring
 
1632
 
 
1633
 
 
1634
def datetime_to_dbus(dt, variant_level=0):
 
1635
    """Convert a UTC datetime.datetime() to a D-Bus type."""
 
1636
    if dt is None:
 
1637
        return dbus.String("", variant_level=variant_level)
 
1638
    return dbus.String(dt.isoformat(), variant_level=variant_level)
 
1639
 
 
1640
 
 
1641
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
 
1642
    """A class decorator; applied to a subclass of
 
1643
    dbus.service.Object, it will add alternate D-Bus attributes with
 
1644
    interface names according to the "alt_interface_names" mapping.
 
1645
    Usage:
 
1646
 
 
1647
    @alternate_dbus_interfaces({"org.example.Interface":
 
1648
                                    "net.example.AlternateInterface"})
 
1649
    class SampleDBusObject(dbus.service.Object):
 
1650
        @dbus.service.method("org.example.Interface")
 
1651
        def SampleDBusMethod():
 
1652
            pass
 
1653
 
 
1654
    The above "SampleDBusMethod" on "SampleDBusObject" will be
 
1655
    reachable via two interfaces: "org.example.Interface" and
 
1656
    "net.example.AlternateInterface", the latter of which will have
 
1657
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
 
1658
    "true", unless "deprecate" is passed with a False value.
 
1659
 
 
1660
    This works for methods and signals, and also for D-Bus properties
 
1661
    (from DBusObjectWithProperties) and interfaces (from the
 
1662
    dbus_interface_annotations decorator).
 
1663
    """
 
1664
 
 
1665
    def wrapper(cls):
 
1666
        for orig_interface_name, alt_interface_name in (
 
1667
                alt_interface_names.items()):
 
1668
            attr = {}
 
1669
            interface_names = set()
 
1670
            # Go though all attributes of the class
 
1671
            for attrname, attribute in inspect.getmembers(cls):
 
1672
                # Ignore non-D-Bus attributes, and D-Bus attributes
 
1673
                # with the wrong interface name
 
1674
                if (not hasattr(attribute, "_dbus_interface")
 
1675
                    or not attribute._dbus_interface.startswith(
 
1676
                        orig_interface_name)):
 
1677
                    continue
 
1678
                # Create an alternate D-Bus interface name based on
 
1679
                # the current name
 
1680
                alt_interface = attribute._dbus_interface.replace(
 
1681
                    orig_interface_name, alt_interface_name)
 
1682
                interface_names.add(alt_interface)
 
1683
                # Is this a D-Bus signal?
 
1684
                if getattr(attribute, "_dbus_is_signal", False):
 
1685
                    # Extract the original non-method undecorated
 
1686
                    # function by black magic
 
1687
                    if sys.version_info.major == 2:
 
1688
                        nonmethod_func = (dict(
 
1689
                            zip(attribute.func_code.co_freevars,
 
1690
                                attribute.__closure__))
 
1691
                                          ["func"].cell_contents)
 
1692
                    else:
 
1693
                        nonmethod_func = (dict(
 
1694
                            zip(attribute.__code__.co_freevars,
 
1695
                                attribute.__closure__))
 
1696
                                          ["func"].cell_contents)
 
1697
                    # Create a new, but exactly alike, function
 
1698
                    # object, and decorate it to be a new D-Bus signal
 
1699
                    # with the alternate D-Bus interface name
 
1700
                    new_function = copy_function(nonmethod_func)
 
1701
                    new_function = (dbus.service.signal(
 
1702
                        alt_interface,
 
1703
                        attribute._dbus_signature)(new_function))
 
1704
                    # Copy annotations, if any
 
1705
                    try:
 
1706
                        new_function._dbus_annotations = dict(
 
1707
                            attribute._dbus_annotations)
 
1708
                    except AttributeError:
 
1709
                        pass
 
1710
 
 
1711
                    # Define a creator of a function to call both the
 
1712
                    # original and alternate functions, so both the
 
1713
                    # original and alternate signals gets sent when
 
1714
                    # the function is called
 
1715
                    def fixscope(func1, func2):
 
1716
                        """This function is a scope container to pass
 
1717
                        func1 and func2 to the "call_both" function
 
1718
                        outside of its arguments"""
 
1719
 
 
1720
                        @functools.wraps(func2)
 
1721
                        def call_both(*args, **kwargs):
 
1722
                            """This function will emit two D-Bus
 
1723
                            signals by calling func1 and func2"""
 
1724
                            func1(*args, **kwargs)
 
1725
                            func2(*args, **kwargs)
 
1726
                        # Make wrapper function look like a D-Bus
 
1727
                        # signal
 
1728
                        for name, attr in inspect.getmembers(func2):
 
1729
                            if name.startswith("_dbus_"):
 
1730
                                setattr(call_both, name, attr)
 
1731
 
 
1732
                        return call_both
 
1733
                    # Create the "call_both" function and add it to
 
1734
                    # the class
 
1735
                    attr[attrname] = fixscope(attribute, new_function)
 
1736
                # Is this a D-Bus method?
 
1737
                elif getattr(attribute, "_dbus_is_method", False):
 
1738
                    # Create a new, but exactly alike, function
 
1739
                    # object.  Decorate it to be a new D-Bus method
 
1740
                    # with the alternate D-Bus interface name.  Add it
 
1741
                    # to the class.
 
1742
                    attr[attrname] = (
 
1743
                        dbus.service.method(
 
1744
                            alt_interface,
 
1745
                            attribute._dbus_in_signature,
 
1746
                            attribute._dbus_out_signature)
 
1747
                        (copy_function(attribute)))
 
1748
                    # Copy annotations, if any
 
1749
                    try:
 
1750
                        attr[attrname]._dbus_annotations = dict(
 
1751
                            attribute._dbus_annotations)
 
1752
                    except AttributeError:
 
1753
                        pass
 
1754
                # Is this a D-Bus property?
 
1755
                elif getattr(attribute, "_dbus_is_property", False):
 
1756
                    # Create a new, but exactly alike, function
 
1757
                    # object, and decorate it to be a new D-Bus
 
1758
                    # property with the alternate D-Bus interface
 
1759
                    # name.  Add it to the class.
 
1760
                    attr[attrname] = (dbus_service_property(
 
1761
                        alt_interface, attribute._dbus_signature,
 
1762
                        attribute._dbus_access,
 
1763
                        attribute._dbus_get_args_options
 
1764
                        ["byte_arrays"])
 
1765
                                      (copy_function(attribute)))
 
1766
                    # Copy annotations, if any
 
1767
                    try:
 
1768
                        attr[attrname]._dbus_annotations = dict(
 
1769
                            attribute._dbus_annotations)
 
1770
                    except AttributeError:
 
1771
                        pass
 
1772
                # Is this a D-Bus interface?
 
1773
                elif getattr(attribute, "_dbus_is_interface", False):
 
1774
                    # Create a new, but exactly alike, function
 
1775
                    # object.  Decorate it to be a new D-Bus interface
 
1776
                    # with the alternate D-Bus interface name.  Add it
 
1777
                    # to the class.
 
1778
                    attr[attrname] = (
 
1779
                        dbus_interface_annotations(alt_interface)
 
1780
                        (copy_function(attribute)))
 
1781
            if deprecate:
 
1782
                # Deprecate all alternate interfaces
 
1783
                iname = "_AlternateDBusNames_interface_annotation{}"
 
1784
                for interface_name in interface_names:
 
1785
 
 
1786
                    @dbus_interface_annotations(interface_name)
 
1787
                    def func(self):
 
1788
                        return {"org.freedesktop.DBus.Deprecated":
 
1789
                                "true"}
 
1790
                    # Find an unused name
 
1791
                    for aname in (iname.format(i)
 
1792
                                  for i in itertools.count()):
 
1793
                        if aname not in attr:
 
1794
                            attr[aname] = func
 
1795
                            break
 
1796
            if interface_names:
 
1797
                # Replace the class with a new subclass of it with
 
1798
                # methods, signals, etc. as created above.
 
1799
                if sys.version_info.major == 2:
 
1800
                    cls = type(b"{}Alternate".format(cls.__name__),
 
1801
                               (cls, ), attr)
 
1802
                else:
 
1803
                    cls = type("{}Alternate".format(cls.__name__),
 
1804
                               (cls, ), attr)
 
1805
        return cls
 
1806
 
 
1807
    return wrapper
 
1808
 
 
1809
 
 
1810
@alternate_dbus_interfaces({"se.recompile.Mandos":
 
1811
                            "se.bsnet.fukt.Mandos"})
 
1812
class ClientDBus(Client, DBusObjectWithProperties):
 
1813
    """A Client class using D-Bus
 
1814
 
 
1815
    Attributes:
 
1816
    dbus_object_path: dbus.ObjectPath
 
1817
    bus: dbus.SystemBus()
 
1818
    """
 
1819
 
 
1820
    runtime_expansions = (Client.runtime_expansions
 
1821
                          + ("dbus_object_path", ))
 
1822
 
 
1823
    _interface = "se.recompile.Mandos.Client"
 
1824
 
 
1825
    # dbus.service.Object doesn't use super(), so we can't either.
 
1826
 
 
1827
    def __init__(self, bus=None, *args, **kwargs):
 
1828
        self.bus = bus
 
1829
        Client.__init__(self, *args, **kwargs)
 
1830
        # Only now, when this client is initialized, can it show up on
 
1831
        # the D-Bus
 
1832
        client_object_name = str(self.name).translate(
 
1833
            {ord("."): ord("_"),
 
1834
             ord("-"): ord("_")})
 
1835
        self.dbus_object_path = dbus.ObjectPath(
 
1836
            "/clients/" + client_object_name)
 
1837
        DBusObjectWithProperties.__init__(self, self.bus,
 
1838
                                          self.dbus_object_path)
 
1839
 
 
1840
    def notifychangeproperty(transform_func, dbus_name,
 
1841
                             type_func=lambda x: x,
 
1842
                             variant_level=1,
 
1843
                             invalidate_only=False,
 
1844
                             _interface=_interface):
 
1845
        """ Modify a variable so that it's a property which announces
 
1846
        its changes to DBus.
 
1847
 
 
1848
        transform_fun: Function that takes a value and a variant_level
 
1849
                       and transforms it to a D-Bus type.
 
1850
        dbus_name: D-Bus name of the variable
 
1851
        type_func: Function that transform the value before sending it
 
1852
                   to the D-Bus.  Default: no transform
 
1853
        variant_level: D-Bus variant level.  Default: 1
 
1854
        """
 
1855
        attrname = "_{}".format(dbus_name)
 
1856
 
 
1857
        def setter(self, value):
 
1858
            if hasattr(self, "dbus_object_path"):
 
1859
                if (not hasattr(self, attrname) or
 
1860
                    type_func(getattr(self, attrname, None))
 
1861
                    != type_func(value)):
 
1862
                    if invalidate_only:
 
1863
                        self.PropertiesChanged(
 
1864
                            _interface, dbus.Dictionary(),
 
1865
                            dbus.Array((dbus_name, )))
 
1866
                    else:
 
1867
                        dbus_value = transform_func(
 
1868
                            type_func(value),
 
1869
                            variant_level=variant_level)
 
1870
                        self.PropertyChanged(dbus.String(dbus_name),
 
1871
                                             dbus_value)
 
1872
                        self.PropertiesChanged(
 
1873
                            _interface,
 
1874
                            dbus.Dictionary({dbus.String(dbus_name):
 
1875
                                             dbus_value}),
 
1876
                            dbus.Array())
 
1877
            setattr(self, attrname, value)
 
1878
 
 
1879
        return property(lambda self: getattr(self, attrname), setter)
 
1880
 
 
1881
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
 
1882
    approvals_pending = notifychangeproperty(dbus.Boolean,
 
1883
                                             "ApprovalPending",
 
1884
                                             type_func=bool)
 
1885
    enabled = notifychangeproperty(dbus.Boolean, "Enabled")
 
1886
    last_enabled = notifychangeproperty(datetime_to_dbus,
 
1887
                                        "LastEnabled")
 
1888
    checker = notifychangeproperty(
 
1889
        dbus.Boolean, "CheckerRunning",
 
1890
        type_func=lambda checker: checker is not None)
 
1891
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
 
1892
                                           "LastCheckedOK")
 
1893
    last_checker_status = notifychangeproperty(dbus.Int16,
 
1894
                                               "LastCheckerStatus")
 
1895
    last_approval_request = notifychangeproperty(
 
1896
        datetime_to_dbus, "LastApprovalRequest")
 
1897
    approved_by_default = notifychangeproperty(dbus.Boolean,
 
1898
                                               "ApprovedByDefault")
 
1899
    approval_delay = notifychangeproperty(
 
1900
        dbus.UInt64, "ApprovalDelay",
 
1901
        type_func=lambda td: td.total_seconds() * 1000)
 
1902
    approval_duration = notifychangeproperty(
 
1903
        dbus.UInt64, "ApprovalDuration",
 
1904
        type_func=lambda td: td.total_seconds() * 1000)
 
1905
    host = notifychangeproperty(dbus.String, "Host")
 
1906
    timeout = notifychangeproperty(
 
1907
        dbus.UInt64, "Timeout",
 
1908
        type_func=lambda td: td.total_seconds() * 1000)
 
1909
    extended_timeout = notifychangeproperty(
 
1910
        dbus.UInt64, "ExtendedTimeout",
 
1911
        type_func=lambda td: td.total_seconds() * 1000)
 
1912
    interval = notifychangeproperty(
 
1913
        dbus.UInt64, "Interval",
 
1914
        type_func=lambda td: td.total_seconds() * 1000)
 
1915
    checker_command = notifychangeproperty(dbus.String, "Checker")
 
1916
    secret = notifychangeproperty(dbus.ByteArray, "Secret",
 
1917
                                  invalidate_only=True)
 
1918
 
 
1919
    del notifychangeproperty
 
1920
 
 
1921
    def __del__(self, *args, **kwargs):
 
1922
        try:
 
1923
            self.remove_from_connection()
 
1924
        except LookupError:
 
1925
            pass
 
1926
        if hasattr(DBusObjectWithProperties, "__del__"):
 
1927
            DBusObjectWithProperties.__del__(self, *args, **kwargs)
 
1928
        Client.__del__(self, *args, **kwargs)
 
1929
 
 
1930
    def checker_callback(self, source, condition,
 
1931
                         connection, command, *args, **kwargs):
 
1932
        ret = Client.checker_callback(self, source, condition,
 
1933
                                      connection, command, *args,
 
1934
                                      **kwargs)
 
1935
        exitstatus = self.last_checker_status
 
1936
        if exitstatus >= 0:
 
1937
            # Emit D-Bus signal
 
1938
            self.CheckerCompleted(dbus.Int16(exitstatus),
 
1939
                                  # This is specific to GNU libC
 
1940
                                  dbus.Int64(exitstatus << 8),
 
1941
                                  dbus.String(command))
 
1942
        else:
 
1943
            # Emit D-Bus signal
 
1944
            self.CheckerCompleted(dbus.Int16(-1),
 
1945
                                  dbus.Int64(
 
1946
                                      # This is specific to GNU libC
 
1947
                                      (exitstatus << 8)
 
1948
                                      | self.last_checker_signal),
 
1949
                                  dbus.String(command))
 
1950
        return ret
 
1951
 
 
1952
    def start_checker(self, *args, **kwargs):
 
1953
        old_checker_pid = getattr(self.checker, "pid", None)
 
1954
        r = Client.start_checker(self, *args, **kwargs)
 
1955
        # Only if new checker process was started
 
1956
        if (self.checker is not None
 
1957
            and old_checker_pid != self.checker.pid):
 
1958
            # Emit D-Bus signal
 
1959
            self.CheckerStarted(self.current_checker_command)
 
1960
        return r
 
1961
 
 
1962
    def _reset_approved(self):
 
1963
        self.approved = None
 
1964
        return False
 
1965
 
 
1966
    def approve(self, value=True):
 
1967
        self.approved = value
 
1968
        GLib.timeout_add(int(self.approval_duration.total_seconds()
 
1969
                             * 1000), self._reset_approved)
 
1970
        self.send_changedstate()
 
1971
 
 
1972
    #  D-Bus methods, signals & properties
 
1973
 
 
1974
    #  Interfaces
 
1975
 
 
1976
    #  Signals
 
1977
 
 
1978
    # CheckerCompleted - signal
 
1979
    @dbus.service.signal(_interface, signature="nxs")
 
1980
    def CheckerCompleted(self, exitcode, waitstatus, command):
 
1981
        "D-Bus signal"
 
1982
        pass
 
1983
 
 
1984
    # CheckerStarted - signal
 
1985
    @dbus.service.signal(_interface, signature="s")
 
1986
    def CheckerStarted(self, command):
 
1987
        "D-Bus signal"
 
1988
        pass
 
1989
 
 
1990
    # PropertyChanged - signal
 
1991
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
 
1992
    @dbus.service.signal(_interface, signature="sv")
 
1993
    def PropertyChanged(self, property, value):
 
1994
        "D-Bus signal"
 
1995
        pass
 
1996
 
 
1997
    # GotSecret - signal
 
1998
    @dbus.service.signal(_interface)
 
1999
    def GotSecret(self):
 
2000
        """D-Bus signal
 
2001
        Is sent after a successful transfer of secret from the Mandos
 
2002
        server to mandos-client
 
2003
        """
 
2004
        pass
 
2005
 
 
2006
    # Rejected - signal
 
2007
    @dbus.service.signal(_interface, signature="s")
 
2008
    def Rejected(self, reason):
 
2009
        "D-Bus signal"
 
2010
        pass
 
2011
 
 
2012
    # NeedApproval - signal
 
2013
    @dbus.service.signal(_interface, signature="tb")
 
2014
    def NeedApproval(self, timeout, default):
 
2015
        "D-Bus signal"
 
2016
        return self.need_approval()
 
2017
 
 
2018
    #  Methods
 
2019
 
 
2020
    # Approve - method
 
2021
    @dbus.service.method(_interface, in_signature="b")
 
2022
    def Approve(self, value):
 
2023
        self.approve(value)
 
2024
 
 
2025
    # CheckedOK - method
 
2026
    @dbus.service.method(_interface)
 
2027
    def CheckedOK(self):
 
2028
        self.checked_ok()
 
2029
 
 
2030
    # Enable - method
 
2031
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
 
2032
    @dbus.service.method(_interface)
 
2033
    def Enable(self):
 
2034
        "D-Bus method"
 
2035
        self.enable()
 
2036
 
 
2037
    # StartChecker - method
 
2038
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
 
2039
    @dbus.service.method(_interface)
 
2040
    def StartChecker(self):
 
2041
        "D-Bus method"
 
2042
        self.start_checker()
 
2043
 
 
2044
    # Disable - method
 
2045
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
 
2046
    @dbus.service.method(_interface)
 
2047
    def Disable(self):
 
2048
        "D-Bus method"
 
2049
        self.disable()
 
2050
 
 
2051
    # StopChecker - method
 
2052
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
 
2053
    @dbus.service.method(_interface)
 
2054
    def StopChecker(self):
 
2055
        self.stop_checker()
 
2056
 
 
2057
    #  Properties
 
2058
 
 
2059
    # ApprovalPending - property
 
2060
    @dbus_service_property(_interface, signature="b", access="read")
 
2061
    def ApprovalPending_dbus_property(self):
 
2062
        return dbus.Boolean(bool(self.approvals_pending))
 
2063
 
 
2064
    # ApprovedByDefault - property
 
2065
    @dbus_service_property(_interface,
 
2066
                           signature="b",
 
2067
                           access="readwrite")
 
2068
    def ApprovedByDefault_dbus_property(self, value=None):
 
2069
        if value is None:       # get
 
2070
            return dbus.Boolean(self.approved_by_default)
 
2071
        self.approved_by_default = bool(value)
 
2072
 
 
2073
    # ApprovalDelay - property
 
2074
    @dbus_service_property(_interface,
 
2075
                           signature="t",
 
2076
                           access="readwrite")
 
2077
    def ApprovalDelay_dbus_property(self, value=None):
 
2078
        if value is None:       # get
 
2079
            return dbus.UInt64(self.approval_delay.total_seconds()
 
2080
                               * 1000)
 
2081
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
 
2082
 
 
2083
    # ApprovalDuration - property
 
2084
    @dbus_service_property(_interface,
 
2085
                           signature="t",
 
2086
                           access="readwrite")
 
2087
    def ApprovalDuration_dbus_property(self, value=None):
 
2088
        if value is None:       # get
 
2089
            return dbus.UInt64(self.approval_duration.total_seconds()
 
2090
                               * 1000)
 
2091
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
 
2092
 
 
2093
    # Name - property
 
2094
    @dbus_annotations(
 
2095
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
 
2096
    @dbus_service_property(_interface, signature="s", access="read")
 
2097
    def Name_dbus_property(self):
 
2098
        return dbus.String(self.name)
 
2099
 
 
2100
    # KeyID - property
 
2101
    @dbus_annotations(
 
2102
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
 
2103
    @dbus_service_property(_interface, signature="s", access="read")
 
2104
    def KeyID_dbus_property(self):
 
2105
        return dbus.String(self.key_id)
 
2106
 
 
2107
    # Fingerprint - property
 
2108
    @dbus_annotations(
 
2109
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
 
2110
    @dbus_service_property(_interface, signature="s", access="read")
 
2111
    def Fingerprint_dbus_property(self):
 
2112
        return dbus.String(self.fingerprint)
 
2113
 
 
2114
    # Host - property
 
2115
    @dbus_service_property(_interface,
 
2116
                           signature="s",
 
2117
                           access="readwrite")
 
2118
    def Host_dbus_property(self, value=None):
 
2119
        if value is None:       # get
 
2120
            return dbus.String(self.host)
 
2121
        self.host = str(value)
 
2122
 
 
2123
    # Created - property
 
2124
    @dbus_annotations(
 
2125
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
 
2126
    @dbus_service_property(_interface, signature="s", access="read")
 
2127
    def Created_dbus_property(self):
 
2128
        return datetime_to_dbus(self.created)
 
2129
 
 
2130
    # LastEnabled - property
 
2131
    @dbus_service_property(_interface, signature="s", access="read")
 
2132
    def LastEnabled_dbus_property(self):
 
2133
        return datetime_to_dbus(self.last_enabled)
 
2134
 
 
2135
    # Enabled - property
 
2136
    @dbus_service_property(_interface,
 
2137
                           signature="b",
 
2138
                           access="readwrite")
 
2139
    def Enabled_dbus_property(self, value=None):
 
2140
        if value is None:       # get
 
2141
            return dbus.Boolean(self.enabled)
 
2142
        if value:
 
2143
            self.enable()
 
2144
        else:
 
2145
            self.disable()
 
2146
 
 
2147
    # LastCheckedOK - property
 
2148
    @dbus_service_property(_interface,
 
2149
                           signature="s",
 
2150
                           access="readwrite")
 
2151
    def LastCheckedOK_dbus_property(self, value=None):
 
2152
        if value is not None:
 
2153
            self.checked_ok()
 
2154
            return
 
2155
        return datetime_to_dbus(self.last_checked_ok)
 
2156
 
 
2157
    # LastCheckerStatus - property
 
2158
    @dbus_service_property(_interface, signature="n", access="read")
 
2159
    def LastCheckerStatus_dbus_property(self):
 
2160
        return dbus.Int16(self.last_checker_status)
 
2161
 
 
2162
    # Expires - property
 
2163
    @dbus_service_property(_interface, signature="s", access="read")
 
2164
    def Expires_dbus_property(self):
 
2165
        return datetime_to_dbus(self.expires)
 
2166
 
 
2167
    # LastApprovalRequest - property
 
2168
    @dbus_service_property(_interface, signature="s", access="read")
 
2169
    def LastApprovalRequest_dbus_property(self):
 
2170
        return datetime_to_dbus(self.last_approval_request)
 
2171
 
 
2172
    # Timeout - property
 
2173
    @dbus_service_property(_interface,
 
2174
                           signature="t",
 
2175
                           access="readwrite")
 
2176
    def Timeout_dbus_property(self, value=None):
 
2177
        if value is None:       # get
 
2178
            return dbus.UInt64(self.timeout.total_seconds() * 1000)
 
2179
        old_timeout = self.timeout
 
2180
        self.timeout = datetime.timedelta(0, 0, 0, value)
 
2181
        # Reschedule disabling
 
2182
        if self.enabled:
 
2183
            now = datetime.datetime.utcnow()
 
2184
            self.expires += self.timeout - old_timeout
 
2185
            if self.expires <= now:
 
2186
                # The timeout has passed
 
2187
                self.disable()
 
2188
            else:
 
2189
                if (getattr(self, "disable_initiator_tag", None)
 
2190
                    is None):
 
2191
                    return
 
2192
                GLib.source_remove(self.disable_initiator_tag)
 
2193
                self.disable_initiator_tag = GLib.timeout_add(
 
2194
                    int((self.expires - now).total_seconds() * 1000),
 
2195
                    self.disable)
 
2196
 
 
2197
    # ExtendedTimeout - property
 
2198
    @dbus_service_property(_interface,
 
2199
                           signature="t",
 
2200
                           access="readwrite")
 
2201
    def ExtendedTimeout_dbus_property(self, value=None):
 
2202
        if value is None:       # get
 
2203
            return dbus.UInt64(self.extended_timeout.total_seconds()
 
2204
                               * 1000)
 
2205
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
 
2206
 
 
2207
    # Interval - property
 
2208
    @dbus_service_property(_interface,
 
2209
                           signature="t",
 
2210
                           access="readwrite")
 
2211
    def Interval_dbus_property(self, value=None):
 
2212
        if value is None:       # get
 
2213
            return dbus.UInt64(self.interval.total_seconds() * 1000)
 
2214
        self.interval = datetime.timedelta(0, 0, 0, value)
 
2215
        if getattr(self, "checker_initiator_tag", None) is None:
 
2216
            return
 
2217
        if self.enabled:
 
2218
            # Reschedule checker run
 
2219
            GLib.source_remove(self.checker_initiator_tag)
 
2220
            self.checker_initiator_tag = GLib.timeout_add(
 
2221
                value, self.start_checker)
 
2222
            self.start_checker()  # Start one now, too
 
2223
 
 
2224
    # Checker - property
 
2225
    @dbus_service_property(_interface,
 
2226
                           signature="s",
 
2227
                           access="readwrite")
 
2228
    def Checker_dbus_property(self, value=None):
 
2229
        if value is None:       # get
 
2230
            return dbus.String(self.checker_command)
 
2231
        self.checker_command = str(value)
 
2232
 
 
2233
    # CheckerRunning - property
 
2234
    @dbus_service_property(_interface,
 
2235
                           signature="b",
 
2236
                           access="readwrite")
 
2237
    def CheckerRunning_dbus_property(self, value=None):
 
2238
        if value is None:       # get
 
2239
            return dbus.Boolean(self.checker is not None)
 
2240
        if value:
 
2241
            self.start_checker()
 
2242
        else:
 
2243
            self.stop_checker()
 
2244
 
 
2245
    # ObjectPath - property
 
2246
    @dbus_annotations(
 
2247
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
 
2248
         "org.freedesktop.DBus.Deprecated": "true"})
 
2249
    @dbus_service_property(_interface, signature="o", access="read")
 
2250
    def ObjectPath_dbus_property(self):
 
2251
        return self.dbus_object_path  # is already a dbus.ObjectPath
 
2252
 
 
2253
    # Secret = property
 
2254
    @dbus_annotations(
 
2255
        {"org.freedesktop.DBus.Property.EmitsChangedSignal":
 
2256
         "invalidates"})
 
2257
    @dbus_service_property(_interface,
 
2258
                           signature="ay",
 
2259
                           access="write",
 
2260
                           byte_arrays=True)
 
2261
    def Secret_dbus_property(self, value):
 
2262
        self.secret = bytes(value)
 
2263
 
 
2264
    del _interface
 
2265
 
 
2266
 
 
2267
class ProxyClient:
 
2268
    def __init__(self, child_pipe, key_id, fpr, address):
 
2269
        self._pipe = child_pipe
 
2270
        self._pipe.send(("init", key_id, fpr, address))
 
2271
        if not self._pipe.recv():
 
2272
            raise KeyError(key_id or fpr)
 
2273
 
 
2274
    def __getattribute__(self, name):
 
2275
        if name == "_pipe":
 
2276
            return super(ProxyClient, self).__getattribute__(name)
 
2277
        self._pipe.send(("getattr", name))
 
2278
        data = self._pipe.recv()
 
2279
        if data[0] == "data":
 
2280
            return data[1]
 
2281
        if data[0] == "function":
 
2282
 
 
2283
            def func(*args, **kwargs):
 
2284
                self._pipe.send(("funcall", name, args, kwargs))
 
2285
                return self._pipe.recv()[1]
 
2286
 
 
2287
            return func
 
2288
 
 
2289
    def __setattr__(self, name, value):
 
2290
        if name == "_pipe":
 
2291
            return super(ProxyClient, self).__setattr__(name, value)
 
2292
        self._pipe.send(("setattr", name, value))
 
2293
 
 
2294
 
 
2295
class ClientHandler(socketserver.BaseRequestHandler, object):
 
2296
    """A class to handle client connections.
 
2297
 
 
2298
    Instantiated once for each connection to handle it.
441
2299
    Note: This will run in its own forked process."""
442
 
    
 
2300
 
443
2301
    def handle(self):
444
 
        logger.info(u"TCP connection from: %s",
445
 
                     unicode(self.client_address))
446
 
        session = gnutls.connection.ClientSession\
447
 
                  (self.request, gnutls.connection.X509Credentials())
448
 
        
449
 
        line = self.request.makefile().readline()
450
 
        logger.debug(u"Protocol version: %r", line)
451
 
        try:
452
 
            if int(line.strip().split()[0]) > 1:
453
 
                raise RuntimeError
454
 
        except (ValueError, IndexError, RuntimeError), error:
455
 
            logger.error(u"Unknown protocol version: %s", error)
456
 
            return
457
 
        
458
 
        # Note: gnutls.connection.X509Credentials is really a generic
459
 
        # GnuTLS certificate credentials object so long as no X.509
460
 
        # keys are added to it.  Therefore, we can use it here despite
461
 
        # using OpenPGP certificates.
462
 
        
463
 
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
464
 
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
465
 
        #                "+DHE-DSS"))
466
 
        priority = "NORMAL"             # Fallback default, since this
467
 
                                        # MUST be set.
468
 
        if self.server.settings["priority"]:
469
 
            priority = self.server.settings["priority"]
470
 
        gnutls.library.functions.gnutls_priority_set_direct\
471
 
            (session._c_object, priority, None);
472
 
        
473
 
        try:
474
 
            session.handshake()
475
 
        except gnutls.errors.GNUTLSError, error:
476
 
            logger.warning(u"Handshake failed: %s", error)
477
 
            # Do not run session.bye() here: the session is not
478
 
            # established.  Just abandon the request.
479
 
            return
480
 
        try:
481
 
            fpr = fingerprint(peer_certificate(session))
482
 
        except (TypeError, gnutls.errors.GNUTLSError), error:
483
 
            logger.warning(u"Bad certificate: %s", error)
484
 
            session.bye()
485
 
            return
486
 
        logger.debug(u"Fingerprint: %s", fpr)
487
 
        client = None
488
 
        for c in self.server.clients:
489
 
            if c.fingerprint == fpr:
490
 
                client = c
491
 
                break
492
 
        if not client:
493
 
            logger.warning(u"Client not found for fingerprint: %s",
494
 
                           fpr)
495
 
            session.bye()
496
 
            return
497
 
        # Have to check if client.still_valid(), since it is possible
498
 
        # that the client timed out while establishing the GnuTLS
499
 
        # session.
500
 
        if not client.still_valid():
501
 
            logger.warning(u"Client %(name)s is invalid",
502
 
                           vars(client))
503
 
            session.bye()
504
 
            return
505
 
        sent_size = 0
506
 
        while sent_size < len(client.secret):
507
 
            sent = session.send(client.secret[sent_size:])
508
 
            logger.debug(u"Sent: %d, remaining: %d",
509
 
                         sent, len(client.secret)
510
 
                         - (sent_size + sent))
511
 
            sent_size += sent
512
 
        session.bye()
513
 
 
514
 
 
515
 
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
516
 
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
 
2302
        with contextlib.closing(self.server.child_pipe) as child_pipe:
 
2303
            log.info("TCP connection from: %s",
 
2304
                     str(self.client_address))
 
2305
            log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
 
2306
 
 
2307
            session = gnutls.ClientSession(self.request)
 
2308
 
 
2309
            # priority = ":".join(("NONE", "+VERS-TLS1.1",
 
2310
            #                       "+AES-256-CBC", "+SHA1",
 
2311
            #                       "+COMP-NULL", "+CTYPE-OPENPGP",
 
2312
            #                       "+DHE-DSS"))
 
2313
            # Use a fallback default, since this MUST be set.
 
2314
            priority = self.server.gnutls_priority
 
2315
            if priority is None:
 
2316
                priority = "NORMAL"
 
2317
            gnutls.priority_set_direct(session,
 
2318
                                       priority.encode("utf-8"), None)
 
2319
 
 
2320
            # Start communication using the Mandos protocol
 
2321
            # Get protocol number
 
2322
            line = self.request.makefile().readline()
 
2323
            log.debug("Protocol version: %r", line)
 
2324
            try:
 
2325
                if int(line.strip().split()[0]) > 1:
 
2326
                    raise RuntimeError(line)
 
2327
            except (ValueError, IndexError, RuntimeError) as error:
 
2328
                log.error("Unknown protocol version: %s", error)
 
2329
                return
 
2330
 
 
2331
            # Start GnuTLS connection
 
2332
            try:
 
2333
                session.handshake()
 
2334
            except gnutls.Error as error:
 
2335
                log.warning("Handshake failed: %s", error)
 
2336
                # Do not run session.bye() here: the session is not
 
2337
                # established.  Just abandon the request.
 
2338
                return
 
2339
            log.debug("Handshake succeeded")
 
2340
 
 
2341
            approval_required = False
 
2342
            try:
 
2343
                if gnutls.has_rawpk:
 
2344
                    fpr = b""
 
2345
                    try:
 
2346
                        key_id = self.key_id(
 
2347
                            self.peer_certificate(session))
 
2348
                    except (TypeError, gnutls.Error) as error:
 
2349
                        log.warning("Bad certificate: %s", error)
 
2350
                        return
 
2351
                    log.debug("Key ID: %s",
 
2352
                              key_id.decode("utf-8",
 
2353
                                            errors="replace"))
 
2354
 
 
2355
                else:
 
2356
                    key_id = b""
 
2357
                    try:
 
2358
                        fpr = self.fingerprint(
 
2359
                            self.peer_certificate(session))
 
2360
                    except (TypeError, gnutls.Error) as error:
 
2361
                        log.warning("Bad certificate: %s", error)
 
2362
                        return
 
2363
                    log.debug("Fingerprint: %s", fpr)
 
2364
 
 
2365
                try:
 
2366
                    client = ProxyClient(child_pipe, key_id, fpr,
 
2367
                                         self.client_address)
 
2368
                except KeyError:
 
2369
                    return
 
2370
 
 
2371
                if client.approval_delay:
 
2372
                    delay = client.approval_delay
 
2373
                    client.approvals_pending += 1
 
2374
                    approval_required = True
 
2375
 
 
2376
                while True:
 
2377
                    if not client.enabled:
 
2378
                        log.info("Client %s is disabled", client.name)
 
2379
                        if self.server.use_dbus:
 
2380
                            # Emit D-Bus signal
 
2381
                            client.Rejected("Disabled")
 
2382
                        return
 
2383
 
 
2384
                    if client.approved or not client.approval_delay:
 
2385
                        # We are approved or approval is disabled
 
2386
                        break
 
2387
                    elif client.approved is None:
 
2388
                        log.info("Client %s needs approval",
 
2389
                                 client.name)
 
2390
                        if self.server.use_dbus:
 
2391
                            # Emit D-Bus signal
 
2392
                            client.NeedApproval(
 
2393
                                client.approval_delay.total_seconds()
 
2394
                                * 1000, client.approved_by_default)
 
2395
                    else:
 
2396
                        log.warning("Client %s was not approved",
 
2397
                                    client.name)
 
2398
                        if self.server.use_dbus:
 
2399
                            # Emit D-Bus signal
 
2400
                            client.Rejected("Denied")
 
2401
                        return
 
2402
 
 
2403
                    # wait until timeout or approved
 
2404
                    time = datetime.datetime.now()
 
2405
                    client.changedstate.acquire()
 
2406
                    client.changedstate.wait(delay.total_seconds())
 
2407
                    client.changedstate.release()
 
2408
                    time2 = datetime.datetime.now()
 
2409
                    if (time2 - time) >= delay:
 
2410
                        if not client.approved_by_default:
 
2411
                            log.warning("Client %s timed out while"
 
2412
                                        " waiting for approval",
 
2413
                                        client.name)
 
2414
                            if self.server.use_dbus:
 
2415
                                # Emit D-Bus signal
 
2416
                                client.Rejected("Approval timed out")
 
2417
                            return
 
2418
                        else:
 
2419
                            break
 
2420
                    else:
 
2421
                        delay -= time2 - time
 
2422
 
 
2423
                try:
 
2424
                    session.send(client.secret)
 
2425
                except gnutls.Error as error:
 
2426
                    log.warning("gnutls send failed", exc_info=error)
 
2427
                    return
 
2428
 
 
2429
                log.info("Sending secret to %s", client.name)
 
2430
                # bump the timeout using extended_timeout
 
2431
                client.bump_timeout(client.extended_timeout)
 
2432
                if self.server.use_dbus:
 
2433
                    # Emit D-Bus signal
 
2434
                    client.GotSecret()
 
2435
 
 
2436
            finally:
 
2437
                if approval_required:
 
2438
                    client.approvals_pending -= 1
 
2439
                try:
 
2440
                    session.bye()
 
2441
                except gnutls.Error as error:
 
2442
                    log.warning("GnuTLS bye failed", exc_info=error)
 
2443
 
 
2444
    @staticmethod
 
2445
    def peer_certificate(session):
 
2446
        "Return the peer's certificate as a bytestring"
 
2447
        try:
 
2448
            cert_type = gnutls.certificate_type_get2(
 
2449
                session, gnutls.CTYPE_PEERS)
 
2450
        except AttributeError:
 
2451
            cert_type = gnutls.certificate_type_get(session)
 
2452
        if gnutls.has_rawpk:
 
2453
            valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
 
2454
        else:
 
2455
            valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
 
2456
        # If not a valid certificate type...
 
2457
        if cert_type not in valid_cert_types:
 
2458
            log.info("Cert type %r not in %r", cert_type,
 
2459
                     valid_cert_types)
 
2460
            # ...return invalid data
 
2461
            return b""
 
2462
        list_size = ctypes.c_uint(1)
 
2463
        cert_list = (gnutls.certificate_get_peers
 
2464
                     (session, ctypes.byref(list_size)))
 
2465
        if not bool(cert_list) and list_size.value != 0:
 
2466
            raise gnutls.Error("error getting peer certificate")
 
2467
        if list_size.value == 0:
 
2468
            return None
 
2469
        cert = cert_list[0]
 
2470
        return ctypes.string_at(cert.data, cert.size)
 
2471
 
 
2472
    @staticmethod
 
2473
    def key_id(certificate):
 
2474
        "Convert a certificate bytestring to a hexdigit key ID"
 
2475
        # New GnuTLS "datum" with the public key
 
2476
        datum = gnutls.datum_t(
 
2477
            ctypes.cast(ctypes.c_char_p(certificate),
 
2478
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2479
            ctypes.c_uint(len(certificate)))
 
2480
        # XXX all these need to be created in the gnutls "module"
 
2481
        # New empty GnuTLS certificate
 
2482
        pubkey = gnutls.pubkey_t()
 
2483
        gnutls.pubkey_init(ctypes.byref(pubkey))
 
2484
        # Import the raw public key into the certificate
 
2485
        gnutls.pubkey_import(pubkey,
 
2486
                             ctypes.byref(datum),
 
2487
                             gnutls.X509_FMT_DER)
 
2488
        # New buffer for the key ID
 
2489
        buf = ctypes.create_string_buffer(32)
 
2490
        buf_len = ctypes.c_size_t(len(buf))
 
2491
        # Get the key ID from the raw public key into the buffer
 
2492
        gnutls.pubkey_get_key_id(
 
2493
            pubkey,
 
2494
            gnutls.KEYID_USE_SHA256,
 
2495
            ctypes.cast(ctypes.byref(buf),
 
2496
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2497
            ctypes.byref(buf_len))
 
2498
        # Deinit the certificate
 
2499
        gnutls.pubkey_deinit(pubkey)
 
2500
 
 
2501
        # Convert the buffer to a Python bytestring
 
2502
        key_id = ctypes.string_at(buf, buf_len.value)
 
2503
        # Convert the bytestring to hexadecimal notation
 
2504
        hex_key_id = binascii.hexlify(key_id).upper()
 
2505
        return hex_key_id
 
2506
 
 
2507
    @staticmethod
 
2508
    def fingerprint(openpgp):
 
2509
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
 
2510
        # New GnuTLS "datum" with the OpenPGP public key
 
2511
        datum = gnutls.datum_t(
 
2512
            ctypes.cast(ctypes.c_char_p(openpgp),
 
2513
                        ctypes.POINTER(ctypes.c_ubyte)),
 
2514
            ctypes.c_uint(len(openpgp)))
 
2515
        # New empty GnuTLS certificate
 
2516
        crt = gnutls.openpgp_crt_t()
 
2517
        gnutls.openpgp_crt_init(ctypes.byref(crt))
 
2518
        # Import the OpenPGP public key into the certificate
 
2519
        gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
 
2520
                                  gnutls.OPENPGP_FMT_RAW)
 
2521
        # Verify the self signature in the key
 
2522
        crtverify = ctypes.c_uint()
 
2523
        gnutls.openpgp_crt_verify_self(crt, 0,
 
2524
                                       ctypes.byref(crtverify))
 
2525
        if crtverify.value != 0:
 
2526
            gnutls.openpgp_crt_deinit(crt)
 
2527
            raise gnutls.CertificateSecurityError(code
 
2528
                                                  =crtverify.value)
 
2529
        # New buffer for the fingerprint
 
2530
        buf = ctypes.create_string_buffer(20)
 
2531
        buf_len = ctypes.c_size_t()
 
2532
        # Get the fingerprint from the certificate into the buffer
 
2533
        gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
 
2534
                                           ctypes.byref(buf_len))
 
2535
        # Deinit the certificate
 
2536
        gnutls.openpgp_crt_deinit(crt)
 
2537
        # Convert the buffer to a Python bytestring
 
2538
        fpr = ctypes.string_at(buf, buf_len.value)
 
2539
        # Convert the bytestring to hexadecimal notation
 
2540
        hex_fpr = binascii.hexlify(fpr).upper()
 
2541
        return hex_fpr
 
2542
 
 
2543
 
 
2544
class MultiprocessingMixIn:
 
2545
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
 
2546
 
 
2547
    def sub_process_main(self, request, address):
 
2548
        try:
 
2549
            self.finish_request(request, address)
 
2550
        except Exception:
 
2551
            self.handle_error(request, address)
 
2552
        self.close_request(request)
 
2553
 
 
2554
    def process_request(self, request, address):
 
2555
        """Start a new process to process the request."""
 
2556
        proc = multiprocessing.Process(target=self.sub_process_main,
 
2557
                                       args=(request, address))
 
2558
        proc.start()
 
2559
        return proc
 
2560
 
 
2561
 
 
2562
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
 
2563
    """ adds a pipe to the MixIn """
 
2564
 
 
2565
    def process_request(self, request, client_address):
 
2566
        """Overrides and wraps the original process_request().
 
2567
 
 
2568
        This function creates a new pipe in self.pipe
 
2569
        """
 
2570
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
 
2571
 
 
2572
        proc = MultiprocessingMixIn.process_request(self, request,
 
2573
                                                    client_address)
 
2574
        self.child_pipe.close()
 
2575
        self.add_pipe(parent_pipe, proc)
 
2576
 
 
2577
    def add_pipe(self, parent_pipe, proc):
 
2578
        """Dummy function; override as necessary"""
 
2579
        raise NotImplementedError()
 
2580
 
 
2581
 
 
2582
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
 
2583
                     socketserver.TCPServer):
 
2584
    """IPv6-capable TCP server.  Accepts None as address and/or port
 
2585
 
517
2586
    Attributes:
518
 
        settings:       Server settings
519
 
        clients:        Set() of Client objects
 
2587
        enabled:        Boolean; whether this server is activated yet
 
2588
        interface:      None or a network interface name (string)
 
2589
        use_ipv6:       Boolean; to use IPv6 or not
520
2590
    """
521
 
    address_family = socket.AF_INET6
522
 
    def __init__(self, *args, **kwargs):
523
 
        if "settings" in kwargs:
524
 
            self.settings = kwargs["settings"]
525
 
            del kwargs["settings"]
526
 
        if "clients" in kwargs:
527
 
            self.clients = kwargs["clients"]
528
 
            del kwargs["clients"]
529
 
        return super(type(self), self).__init__(*args, **kwargs)
 
2591
 
 
2592
    def __init__(self, server_address, RequestHandlerClass,
 
2593
                 interface=None,
 
2594
                 use_ipv6=True,
 
2595
                 socketfd=None):
 
2596
        """If socketfd is set, use that file descriptor instead of
 
2597
        creating a new one with socket.socket().
 
2598
        """
 
2599
        self.interface = interface
 
2600
        if use_ipv6:
 
2601
            self.address_family = socket.AF_INET6
 
2602
        if socketfd is not None:
 
2603
            # Save the file descriptor
 
2604
            self.socketfd = socketfd
 
2605
            # Save the original socket.socket() function
 
2606
            self.socket_socket = socket.socket
 
2607
 
 
2608
            # To implement --socket, we monkey patch socket.socket.
 
2609
            #
 
2610
            # (When socketserver.TCPServer is a new-style class, we
 
2611
            # could make self.socket into a property instead of monkey
 
2612
            # patching socket.socket.)
 
2613
            #
 
2614
            # Create a one-time-only replacement for socket.socket()
 
2615
            @functools.wraps(socket.socket)
 
2616
            def socket_wrapper(*args, **kwargs):
 
2617
                # Restore original function so subsequent calls are
 
2618
                # not affected.
 
2619
                socket.socket = self.socket_socket
 
2620
                del self.socket_socket
 
2621
                # This time only, return a new socket object from the
 
2622
                # saved file descriptor.
 
2623
                return socket.fromfd(self.socketfd, *args, **kwargs)
 
2624
            # Replace socket.socket() function with wrapper
 
2625
            socket.socket = socket_wrapper
 
2626
        # The socketserver.TCPServer.__init__ will call
 
2627
        # socket.socket(), which might be our replacement,
 
2628
        # socket_wrapper(), if socketfd was set.
 
2629
        socketserver.TCPServer.__init__(self, server_address,
 
2630
                                        RequestHandlerClass)
 
2631
 
530
2632
    def server_bind(self):
531
2633
        """This overrides the normal server_bind() function
532
2634
        to bind to an interface if one was specified, and also NOT to
533
2635
        bind to an address or port if they were not specified."""
534
 
        if self.settings["interface"]:
535
 
            # 25 is from /usr/include/asm-i486/socket.h
536
 
            SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
 
2636
        global SO_BINDTODEVICE
 
2637
        if self.interface is not None:
 
2638
            if SO_BINDTODEVICE is None:
 
2639
                # Fall back to a hard-coded value which seems to be
 
2640
                # common enough.
 
2641
                log.warning("SO_BINDTODEVICE not found, trying 25")
 
2642
                SO_BINDTODEVICE = 25
537
2643
            try:
538
 
                self.socket.setsockopt(socket.SOL_SOCKET,
539
 
                                       SO_BINDTODEVICE,
540
 
                                       self.settings["interface"])
541
 
            except socket.error, error:
542
 
                if error[0] == errno.EPERM:
543
 
                    logger.error(u"No permission to"
544
 
                                 u" bind to interface %s",
545
 
                                 self.settings["interface"])
 
2644
                self.socket.setsockopt(
 
2645
                    socket.SOL_SOCKET, SO_BINDTODEVICE,
 
2646
                    (self.interface + "\0").encode("utf-8"))
 
2647
            except socket.error as error:
 
2648
                if error.errno == errno.EPERM:
 
2649
                    log.error("No permission to bind to interface %s",
 
2650
                              self.interface)
 
2651
                elif error.errno == errno.ENOPROTOOPT:
 
2652
                    log.error("SO_BINDTODEVICE not available; cannot"
 
2653
                              " bind to interface %s", self.interface)
 
2654
                elif error.errno == errno.ENODEV:
 
2655
                    log.error("Interface %s does not exist, cannot"
 
2656
                              " bind", self.interface)
546
2657
                else:
547
 
                    raise error
 
2658
                    raise
548
2659
        # Only bind(2) the socket if we really need to.
549
2660
        if self.server_address[0] or self.server_address[1]:
 
2661
            if self.server_address[1]:
 
2662
                self.allow_reuse_address = True
550
2663
            if not self.server_address[0]:
551
 
                in6addr_any = "::"
552
 
                self.server_address = (in6addr_any,
 
2664
                if self.address_family == socket.AF_INET6:
 
2665
                    any_address = "::"  # in6addr_any
 
2666
                else:
 
2667
                    any_address = "0.0.0.0"  # INADDR_ANY
 
2668
                self.server_address = (any_address,
553
2669
                                       self.server_address[1])
554
2670
            elif not self.server_address[1]:
555
 
                self.server_address = (self.server_address[0],
556
 
                                       0)
557
 
#                 if self.settings["interface"]:
 
2671
                self.server_address = (self.server_address[0], 0)
 
2672
#                 if self.interface:
558
2673
#                     self.server_address = (self.server_address[0],
559
2674
#                                            0, # port
560
2675
#                                            0, # flowinfo
561
2676
#                                            if_nametoindex
562
 
#                                            (self.settings
563
 
#                                             ["interface"]))
564
 
            return super(type(self), self).server_bind()
 
2677
#                                            (self.interface))
 
2678
            return socketserver.TCPServer.server_bind(self)
 
2679
 
 
2680
 
 
2681
class MandosServer(IPv6_TCPServer):
 
2682
    """Mandos server.
 
2683
 
 
2684
    Attributes:
 
2685
        clients:        set of Client objects
 
2686
        gnutls_priority GnuTLS priority string
 
2687
        use_dbus:       Boolean; to emit D-Bus signals or not
 
2688
 
 
2689
    Assumes a GLib.MainLoop event loop.
 
2690
    """
 
2691
 
 
2692
    def __init__(self, server_address, RequestHandlerClass,
 
2693
                 interface=None,
 
2694
                 use_ipv6=True,
 
2695
                 clients=None,
 
2696
                 gnutls_priority=None,
 
2697
                 use_dbus=True,
 
2698
                 socketfd=None):
 
2699
        self.enabled = False
 
2700
        self.clients = clients
 
2701
        if self.clients is None:
 
2702
            self.clients = {}
 
2703
        self.use_dbus = use_dbus
 
2704
        self.gnutls_priority = gnutls_priority
 
2705
        IPv6_TCPServer.__init__(self, server_address,
 
2706
                                RequestHandlerClass,
 
2707
                                interface=interface,
 
2708
                                use_ipv6=use_ipv6,
 
2709
                                socketfd=socketfd)
 
2710
 
 
2711
    def server_activate(self):
 
2712
        if self.enabled:
 
2713
            return socketserver.TCPServer.server_activate(self)
 
2714
 
 
2715
    def enable(self):
 
2716
        self.enabled = True
 
2717
 
 
2718
    def add_pipe(self, parent_pipe, proc):
 
2719
        # Call "handle_ipc" for both data and EOF events
 
2720
        GLib.io_add_watch(
 
2721
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2722
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
 
2723
            functools.partial(self.handle_ipc,
 
2724
                              parent_pipe=parent_pipe,
 
2725
                              proc=proc))
 
2726
 
 
2727
    def handle_ipc(self, source, condition,
 
2728
                   parent_pipe=None,
 
2729
                   proc=None,
 
2730
                   client_object=None):
 
2731
        # error, or the other end of multiprocessing.Pipe has closed
 
2732
        if condition & (GLib.IO_ERR | GLib.IO_HUP):
 
2733
            # Wait for other process to exit
 
2734
            proc.join()
 
2735
            return False
 
2736
 
 
2737
        # Read a request from the child
 
2738
        request = parent_pipe.recv()
 
2739
        command = request[0]
 
2740
 
 
2741
        if command == "init":
 
2742
            key_id = request[1].decode("ascii")
 
2743
            fpr = request[2].decode("ascii")
 
2744
            address = request[3]
 
2745
 
 
2746
            for c in self.clients.values():
 
2747
                if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
 
2748
                              "27AE41E4649B934CA495991B7852B855"):
 
2749
                    continue
 
2750
                if key_id and c.key_id == key_id:
 
2751
                    client = c
 
2752
                    break
 
2753
                if fpr and c.fingerprint == fpr:
 
2754
                    client = c
 
2755
                    break
 
2756
            else:
 
2757
                log.info("Client not found for key ID: %s, address:"
 
2758
                         " %s", key_id or fpr, address)
 
2759
                if self.use_dbus:
 
2760
                    # Emit D-Bus signal
 
2761
                    mandos_dbus_service.ClientNotFound(key_id or fpr,
 
2762
                                                       address[0])
 
2763
                parent_pipe.send(False)
 
2764
                return False
 
2765
 
 
2766
            GLib.io_add_watch(
 
2767
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2768
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
 
2769
                functools.partial(self.handle_ipc,
 
2770
                                  parent_pipe=parent_pipe,
 
2771
                                  proc=proc,
 
2772
                                  client_object=client))
 
2773
            parent_pipe.send(True)
 
2774
            # remove the old hook in favor of the new above hook on
 
2775
            # same fileno
 
2776
            return False
 
2777
        if command == "funcall":
 
2778
            funcname = request[1]
 
2779
            args = request[2]
 
2780
            kwargs = request[3]
 
2781
 
 
2782
            parent_pipe.send(("data", getattr(client_object,
 
2783
                                              funcname)(*args,
 
2784
                                                        **kwargs)))
 
2785
 
 
2786
        if command == "getattr":
 
2787
            attrname = request[1]
 
2788
            if isinstance(client_object.__getattribute__(attrname),
 
2789
                          collections.abc.Callable):
 
2790
                parent_pipe.send(("function", ))
 
2791
            else:
 
2792
                parent_pipe.send((
 
2793
                    "data", client_object.__getattribute__(attrname)))
 
2794
 
 
2795
        if command == "setattr":
 
2796
            attrname = request[1]
 
2797
            value = request[2]
 
2798
            setattr(client_object, attrname, value)
 
2799
 
 
2800
        return True
 
2801
 
 
2802
 
 
2803
def rfc3339_duration_to_delta(duration):
 
2804
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2805
 
 
2806
    >>> timedelta = datetime.timedelta
 
2807
    >>> rfc3339_duration_to_delta("P7D") == timedelta(7)
 
2808
    True
 
2809
    >>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
 
2810
    True
 
2811
    >>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
 
2812
    True
 
2813
    >>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
 
2814
    True
 
2815
    >>> rfc3339_duration_to_delta("P1W") == timedelta(7)
 
2816
    True
 
2817
    >>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
 
2818
    True
 
2819
    >>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
 
2820
    True
 
2821
    >>> del timedelta
 
2822
    """
 
2823
 
 
2824
    # Parsing an RFC 3339 duration with regular expressions is not
 
2825
    # possible - there would have to be multiple places for the same
 
2826
    # values, like seconds.  The current code, while more esoteric, is
 
2827
    # cleaner without depending on a parsing library.  If Python had a
 
2828
    # built-in library for parsing we would use it, but we'd like to
 
2829
    # avoid excessive use of external libraries.
 
2830
 
 
2831
    # New type for defining tokens, syntax, and semantics all-in-one
 
2832
    Token = collections.namedtuple("Token", (
 
2833
        "regexp",  # To match token; if "value" is not None, must have
 
2834
                   # a "group" containing digits
 
2835
        "value",   # datetime.timedelta or None
 
2836
        "followers"))           # Tokens valid after this token
 
2837
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2838
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2839
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2840
    token_second = Token(re.compile(r"(\d+)S"),
 
2841
                         datetime.timedelta(seconds=1),
 
2842
                         frozenset((token_end, )))
 
2843
    token_minute = Token(re.compile(r"(\d+)M"),
 
2844
                         datetime.timedelta(minutes=1),
 
2845
                         frozenset((token_second, token_end)))
 
2846
    token_hour = Token(re.compile(r"(\d+)H"),
 
2847
                       datetime.timedelta(hours=1),
 
2848
                       frozenset((token_minute, token_end)))
 
2849
    token_time = Token(re.compile(r"T"),
 
2850
                       None,
 
2851
                       frozenset((token_hour, token_minute,
 
2852
                                  token_second)))
 
2853
    token_day = Token(re.compile(r"(\d+)D"),
 
2854
                      datetime.timedelta(days=1),
 
2855
                      frozenset((token_time, token_end)))
 
2856
    token_month = Token(re.compile(r"(\d+)M"),
 
2857
                        datetime.timedelta(weeks=4),
 
2858
                        frozenset((token_day, token_end)))
 
2859
    token_year = Token(re.compile(r"(\d+)Y"),
 
2860
                       datetime.timedelta(weeks=52),
 
2861
                       frozenset((token_month, token_end)))
 
2862
    token_week = Token(re.compile(r"(\d+)W"),
 
2863
                       datetime.timedelta(weeks=1),
 
2864
                       frozenset((token_end, )))
 
2865
    token_duration = Token(re.compile(r"P"), None,
 
2866
                           frozenset((token_year, token_month,
 
2867
                                      token_day, token_time,
 
2868
                                      token_week)))
 
2869
    # Define starting values:
 
2870
    # Value so far
 
2871
    value = datetime.timedelta()
 
2872
    found_token = None
 
2873
    # Following valid tokens
 
2874
    followers = frozenset((token_duration, ))
 
2875
    # String left to parse
 
2876
    s = duration
 
2877
    # Loop until end token is found
 
2878
    while found_token is not token_end:
 
2879
        # Search for any currently valid tokens
 
2880
        for token in followers:
 
2881
            match = token.regexp.match(s)
 
2882
            if match is not None:
 
2883
                # Token found
 
2884
                if token.value is not None:
 
2885
                    # Value found, parse digits
 
2886
                    factor = int(match.group(1), 10)
 
2887
                    # Add to value so far
 
2888
                    value += factor * token.value
 
2889
                # Strip token from string
 
2890
                s = token.regexp.sub("", s, 1)
 
2891
                # Go to found token
 
2892
                found_token = token
 
2893
                # Set valid next tokens
 
2894
                followers = found_token.followers
 
2895
                break
 
2896
        else:
 
2897
            # No currently valid tokens were found
 
2898
            raise ValueError("Invalid RFC 3339 duration: {!r}"
 
2899
                             .format(duration))
 
2900
    # End token found
 
2901
    return value
565
2902
 
566
2903
 
567
2904
def string_to_delta(interval):
568
2905
    """Parse a string and return a datetime.timedelta
569
2906
 
570
 
    >>> string_to_delta('7d')
571
 
    datetime.timedelta(7)
572
 
    >>> string_to_delta('60s')
573
 
    datetime.timedelta(0, 60)
574
 
    >>> string_to_delta('60m')
575
 
    datetime.timedelta(0, 3600)
576
 
    >>> string_to_delta('24h')
577
 
    datetime.timedelta(1)
578
 
    >>> string_to_delta(u'1w')
579
 
    datetime.timedelta(7)
580
 
    >>> string_to_delta('5m 30s')
581
 
    datetime.timedelta(0, 330)
 
2907
    >>> string_to_delta("7d") == datetime.timedelta(7)
 
2908
    True
 
2909
    >>> string_to_delta("60s") == datetime.timedelta(0, 60)
 
2910
    True
 
2911
    >>> string_to_delta("60m") == datetime.timedelta(0, 3600)
 
2912
    True
 
2913
    >>> string_to_delta("24h") == datetime.timedelta(1)
 
2914
    True
 
2915
    >>> string_to_delta("1w") == datetime.timedelta(7)
 
2916
    True
 
2917
    >>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
 
2918
    True
582
2919
    """
 
2920
 
 
2921
    try:
 
2922
        return rfc3339_duration_to_delta(interval)
 
2923
    except ValueError:
 
2924
        pass
 
2925
 
583
2926
    timevalue = datetime.timedelta(0)
584
2927
    for s in interval.split():
585
2928
        try:
586
 
            suffix=unicode(s[-1])
587
 
            value=int(s[:-1])
588
 
            if suffix == u"d":
 
2929
            suffix = s[-1]
 
2930
            value = int(s[:-1])
 
2931
            if suffix == "d":
589
2932
                delta = datetime.timedelta(value)
590
 
            elif suffix == u"s":
 
2933
            elif suffix == "s":
591
2934
                delta = datetime.timedelta(0, value)
592
 
            elif suffix == u"m":
 
2935
            elif suffix == "m":
593
2936
                delta = datetime.timedelta(0, 0, 0, 0, value)
594
 
            elif suffix == u"h":
 
2937
            elif suffix == "h":
595
2938
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
596
 
            elif suffix == u"w":
 
2939
            elif suffix == "w":
597
2940
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
598
2941
            else:
599
 
                raise ValueError
600
 
        except (ValueError, IndexError):
601
 
            raise ValueError
 
2942
                raise ValueError("Unknown suffix {!r}".format(suffix))
 
2943
        except IndexError as e:
 
2944
            raise ValueError(*(e.args))
602
2945
        timevalue += delta
603
2946
    return timevalue
604
2947
 
605
2948
 
606
 
def server_state_changed(state):
607
 
    """Derived from the Avahi example code"""
608
 
    if state == avahi.SERVER_COLLISION:
609
 
        logger.error(u"Zeroconf server name collision")
610
 
        service.remove()
611
 
    elif state == avahi.SERVER_RUNNING:
612
 
        service.add()
613
 
 
614
 
 
615
 
def entry_group_state_changed(state, error):
616
 
    """Derived from the Avahi example code"""
617
 
    logger.debug(u"Avahi state change: %i", state)
618
 
    
619
 
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
620
 
        logger.debug(u"Zeroconf service established.")
621
 
    elif state == avahi.ENTRY_GROUP_COLLISION:
622
 
        logger.warning(u"Zeroconf service name collision.")
623
 
        service.rename()
624
 
    elif state == avahi.ENTRY_GROUP_FAILURE:
625
 
        logger.critical(u"Avahi: Error in group state changed %s",
626
 
                        unicode(error))
627
 
        raise AvahiGroupError("State changed: %s", str(error))
628
 
 
629
 
def if_nametoindex(interface):
630
 
    """Call the C function if_nametoindex(), or equivalent"""
631
 
    global if_nametoindex
632
 
    try:
633
 
        if "ctypes.util" not in sys.modules:
634
 
            import ctypes.util
635
 
        if_nametoindex = ctypes.cdll.LoadLibrary\
636
 
            (ctypes.util.find_library("c")).if_nametoindex
637
 
    except (OSError, AttributeError):
638
 
        if "struct" not in sys.modules:
639
 
            import struct
640
 
        if "fcntl" not in sys.modules:
641
 
            import fcntl
642
 
        def if_nametoindex(interface):
643
 
            "Get an interface index the hard way, i.e. using fcntl()"
644
 
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
645
 
            s = socket.socket()
646
 
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
647
 
                                struct.pack("16s16x", interface))
648
 
            s.close()
649
 
            interface_index = struct.unpack("I", ifreq[16:20])[0]
650
 
            return interface_index
651
 
    return if_nametoindex(interface)
652
 
 
653
 
 
654
 
def daemon(nochdir = False, noclose = False):
 
2949
def daemon(nochdir=False, noclose=False):
655
2950
    """See daemon(3).  Standard BSD Unix function.
 
2951
 
656
2952
    This should really exist as os.daemon, but it doesn't (yet)."""
657
2953
    if os.fork():
658
2954
        sys.exit()
663
2959
        sys.exit()
664
2960
    if not noclose:
665
2961
        # Close all standard open file descriptors
666
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2962
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
667
2963
        if not stat.S_ISCHR(os.fstat(null).st_mode):
668
2964
            raise OSError(errno.ENODEV,
669
 
                          "/dev/null not a character device")
 
2965
                          "{} not a character device"
 
2966
                          .format(os.devnull))
670
2967
        os.dup2(null, sys.stdin.fileno())
671
2968
        os.dup2(null, sys.stdout.fileno())
672
2969
        os.dup2(null, sys.stderr.fileno())
675
2972
 
676
2973
 
677
2974
def main():
678
 
    global main_loop_started
679
 
    main_loop_started = False
680
 
    
681
 
    parser = OptionParser(version = "%%prog %s" % version)
682
 
    parser.add_option("-i", "--interface", type="string",
683
 
                      metavar="IF", help="Bind to interface IF")
684
 
    parser.add_option("-a", "--address", type="string",
685
 
                      help="Address to listen for requests on")
686
 
    parser.add_option("-p", "--port", type="int",
687
 
                      help="Port number to receive requests on")
688
 
    parser.add_option("--check", action="store_true", default=False,
689
 
                      help="Run self-test")
690
 
    parser.add_option("--debug", action="store_true",
691
 
                      help="Debug mode; run in foreground and log to"
692
 
                      " terminal")
693
 
    parser.add_option("--priority", type="string", help="GnuTLS"
694
 
                      " priority string (see GnuTLS documentation)")
695
 
    parser.add_option("--servicename", type="string", metavar="NAME",
696
 
                      help="Zeroconf service name")
697
 
    parser.add_option("--configdir", type="string",
698
 
                      default="/etc/mandos", metavar="DIR",
699
 
                      help="Directory to search for configuration"
700
 
                      " files")
701
 
    (options, args) = parser.parse_args()
702
 
    
703
 
    if options.check:
704
 
        import doctest
705
 
        doctest.testmod()
706
 
        sys.exit()
707
 
    
 
2975
 
 
2976
    ##################################################################
 
2977
    # Parsing of options, both command line and config file
 
2978
 
 
2979
    parser = argparse.ArgumentParser()
 
2980
    parser.add_argument("-v", "--version", action="version",
 
2981
                        version="%(prog)s {}".format(version),
 
2982
                        help="show version number and exit")
 
2983
    parser.add_argument("-i", "--interface", metavar="IF",
 
2984
                        help="Bind to interface IF")
 
2985
    parser.add_argument("-a", "--address",
 
2986
                        help="Address to listen for requests on")
 
2987
    parser.add_argument("-p", "--port", type=int,
 
2988
                        help="Port number to receive requests on")
 
2989
    parser.add_argument("--check", action="store_true",
 
2990
                        help="Run self-test")
 
2991
    parser.add_argument("--debug", action="store_true",
 
2992
                        help="Debug mode; run in foreground and log"
 
2993
                        " to terminal", default=None)
 
2994
    parser.add_argument("--debuglevel", metavar="LEVEL",
 
2995
                        help="Debug level for stdout output")
 
2996
    parser.add_argument("--priority", help="GnuTLS"
 
2997
                        " priority string (see GnuTLS documentation)")
 
2998
    parser.add_argument("--servicename",
 
2999
                        metavar="NAME", help="Zeroconf service name")
 
3000
    parser.add_argument("--configdir",
 
3001
                        default="/etc/mandos", metavar="DIR",
 
3002
                        help="Directory to search for configuration"
 
3003
                        " files")
 
3004
    parser.add_argument("--no-dbus", action="store_false",
 
3005
                        dest="use_dbus", help="Do not provide D-Bus"
 
3006
                        " system bus interface", default=None)
 
3007
    parser.add_argument("--no-ipv6", action="store_false",
 
3008
                        dest="use_ipv6", help="Do not use IPv6",
 
3009
                        default=None)
 
3010
    parser.add_argument("--no-restore", action="store_false",
 
3011
                        dest="restore", help="Do not restore stored"
 
3012
                        " state", default=None)
 
3013
    parser.add_argument("--socket", type=int,
 
3014
                        help="Specify a file descriptor to a network"
 
3015
                        " socket to use instead of creating one")
 
3016
    parser.add_argument("--statedir", metavar="DIR",
 
3017
                        help="Directory to save/restore state in")
 
3018
    parser.add_argument("--foreground", action="store_true",
 
3019
                        help="Run in foreground", default=None)
 
3020
    parser.add_argument("--no-zeroconf", action="store_false",
 
3021
                        dest="zeroconf", help="Do not use Zeroconf",
 
3022
                        default=None)
 
3023
 
 
3024
    options = parser.parse_args()
 
3025
 
708
3026
    # Default values for config file for server-global settings
709
 
    server_defaults = { "interface": "",
710
 
                        "address": "",
711
 
                        "port": "",
712
 
                        "debug": "False",
713
 
                        "priority":
714
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
715
 
                        "servicename": "Mandos",
716
 
                        }
717
 
    
 
3027
    if gnutls.has_rawpk:
 
3028
        priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
 
3029
                    ":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
 
3030
    else:
 
3031
        priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
 
3032
                    ":+SIGN-DSA-SHA256")
 
3033
    server_defaults = {"interface": "",
 
3034
                       "address": "",
 
3035
                       "port": "",
 
3036
                       "debug": "False",
 
3037
                       "priority": priority,
 
3038
                       "servicename": "Mandos",
 
3039
                       "use_dbus": "True",
 
3040
                       "use_ipv6": "True",
 
3041
                       "debuglevel": "",
 
3042
                       "restore": "True",
 
3043
                       "socket": "",
 
3044
                       "statedir": "/var/lib/mandos",
 
3045
                       "foreground": "False",
 
3046
                       "zeroconf": "True",
 
3047
                       }
 
3048
    del priority
 
3049
 
718
3050
    # Parse config file for server-global settings
719
 
    server_config = ConfigParser.SafeConfigParser(server_defaults)
 
3051
    server_config = configparser.ConfigParser(server_defaults)
720
3052
    del server_defaults
721
3053
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
722
 
    # Convert the SafeConfigParser object to a dict
 
3054
    # Convert the ConfigParser object to a dict
723
3055
    server_settings = server_config.defaults()
724
 
    # Use getboolean on the boolean config option
725
 
    server_settings["debug"] = server_config.getboolean\
726
 
                               ("DEFAULT", "debug")
 
3056
    # Use the appropriate methods on the non-string config options
 
3057
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
3058
                   "foreground", "zeroconf"):
 
3059
        server_settings[option] = server_config.getboolean("DEFAULT",
 
3060
                                                           option)
 
3061
    if server_settings["port"]:
 
3062
        server_settings["port"] = server_config.getint("DEFAULT",
 
3063
                                                       "port")
 
3064
    if server_settings["socket"]:
 
3065
        server_settings["socket"] = server_config.getint("DEFAULT",
 
3066
                                                         "socket")
 
3067
        # Later, stdin will, and stdout and stderr might, be dup'ed
 
3068
        # over with an opened os.devnull.  But we don't want this to
 
3069
        # happen with a supplied network socket.
 
3070
        if 0 <= server_settings["socket"] <= 2:
 
3071
            server_settings["socket"] = os.dup(server_settings
 
3072
                                               ["socket"])
727
3073
    del server_config
728
 
    
 
3074
 
729
3075
    # Override the settings from the config file with command line
730
3076
    # options, if set.
731
3077
    for option in ("interface", "address", "port", "debug",
732
 
                   "priority", "servicename", "configdir"):
 
3078
                   "priority", "servicename", "configdir", "use_dbus",
 
3079
                   "use_ipv6", "debuglevel", "restore", "statedir",
 
3080
                   "socket", "foreground", "zeroconf"):
733
3081
        value = getattr(options, option)
734
3082
        if value is not None:
735
3083
            server_settings[option] = value
736
3084
    del options
 
3085
    # Force all strings to be unicode
 
3086
    for option in server_settings.keys():
 
3087
        if isinstance(server_settings[option], bytes):
 
3088
            server_settings[option] = (server_settings[option]
 
3089
                                       .decode("utf-8"))
 
3090
    # Force all boolean options to be boolean
 
3091
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
3092
                   "foreground", "zeroconf"):
 
3093
        server_settings[option] = bool(server_settings[option])
 
3094
    # Debug implies foreground
 
3095
    if server_settings["debug"]:
 
3096
        server_settings["foreground"] = True
737
3097
    # Now we have our good server settings in "server_settings"
738
 
    
 
3098
 
 
3099
    ##################################################################
 
3100
 
 
3101
    if (not server_settings["zeroconf"]
 
3102
        and not (server_settings["port"]
 
3103
                 or server_settings["socket"] != "")):
 
3104
        parser.error("Needs port or socket to work without Zeroconf")
 
3105
 
 
3106
    # For convenience
739
3107
    debug = server_settings["debug"]
740
 
    
741
 
    if not debug:
742
 
        syslogger.setLevel(logging.WARNING)
743
 
        console.setLevel(logging.WARNING)
744
 
    
 
3108
    debuglevel = server_settings["debuglevel"]
 
3109
    use_dbus = server_settings["use_dbus"]
 
3110
    use_ipv6 = server_settings["use_ipv6"]
 
3111
    stored_state_path = os.path.join(server_settings["statedir"],
 
3112
                                     stored_state_file)
 
3113
    foreground = server_settings["foreground"]
 
3114
    zeroconf = server_settings["zeroconf"]
 
3115
 
 
3116
    if debug:
 
3117
        initlogger(debug, logging.DEBUG)
 
3118
    else:
 
3119
        if not debuglevel:
 
3120
            initlogger(debug)
 
3121
        else:
 
3122
            level = getattr(logging, debuglevel.upper())
 
3123
            initlogger(debug, level)
 
3124
 
745
3125
    if server_settings["servicename"] != "Mandos":
746
 
        syslogger.setFormatter(logging.Formatter\
747
 
                               ('Mandos (%s): %%(levelname)s:'
748
 
                                ' %%(message)s'
749
 
                                % server_settings["servicename"]))
750
 
    
 
3126
        syslogger.setFormatter(
 
3127
            logging.Formatter("Mandos ({}) [%(process)d]:"
 
3128
                              " %(levelname)s: %(message)s".format(
 
3129
                                  server_settings["servicename"])))
 
3130
 
751
3131
    # Parse config file with clients
752
 
    client_defaults = { "timeout": "1h",
753
 
                        "interval": "5m",
754
 
                        "checker": "fping -q -- %(host)s",
755
 
                        "host": "",
756
 
                        }
757
 
    client_config = ConfigParser.SafeConfigParser(client_defaults)
 
3132
    client_config = configparser.ConfigParser(Client.client_defaults)
758
3133
    client_config.read(os.path.join(server_settings["configdir"],
759
3134
                                    "clients.conf"))
760
 
    
761
 
    global service
762
 
    service = AvahiService(name = server_settings["servicename"],
763
 
                           type = "_mandos._tcp", );
764
 
    if server_settings["interface"]:
765
 
        service.interface = if_nametoindex\
766
 
                            (server_settings["interface"])
767
 
    
 
3135
 
 
3136
    global mandos_dbus_service
 
3137
    mandos_dbus_service = None
 
3138
 
 
3139
    socketfd = None
 
3140
    if server_settings["socket"] != "":
 
3141
        socketfd = server_settings["socket"]
 
3142
    tcp_server = MandosServer(
 
3143
        (server_settings["address"], server_settings["port"]),
 
3144
        ClientHandler,
 
3145
        interface=(server_settings["interface"] or None),
 
3146
        use_ipv6=use_ipv6,
 
3147
        gnutls_priority=server_settings["priority"],
 
3148
        use_dbus=use_dbus,
 
3149
        socketfd=socketfd)
 
3150
    if not foreground:
 
3151
        pidfilename = "/run/mandos.pid"
 
3152
        if not os.path.isdir("/run/."):
 
3153
            pidfilename = "/var/run/mandos.pid"
 
3154
        pidfile = None
 
3155
        try:
 
3156
            pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
 
3157
        except IOError as e:
 
3158
            log.error("Could not open file %r", pidfilename,
 
3159
                      exc_info=e)
 
3160
 
 
3161
    for name, group in (("_mandos", "_mandos"),
 
3162
                        ("mandos", "mandos"),
 
3163
                        ("nobody", "nogroup")):
 
3164
        try:
 
3165
            uid = pwd.getpwnam(name).pw_uid
 
3166
            gid = pwd.getpwnam(group).pw_gid
 
3167
            break
 
3168
        except KeyError:
 
3169
            continue
 
3170
    else:
 
3171
        uid = 65534
 
3172
        gid = 65534
 
3173
    try:
 
3174
        os.setgid(gid)
 
3175
        os.setuid(uid)
 
3176
        log.debug("Did setuid/setgid to %s:%s", uid, gid)
 
3177
    except OSError as error:
 
3178
        log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,
 
3179
                    os.strerror(error.errno))
 
3180
        if error.errno != errno.EPERM:
 
3181
            raise
 
3182
 
 
3183
    if debug:
 
3184
        # Enable all possible GnuTLS debugging
 
3185
 
 
3186
        # "Use a log level over 10 to enable all debugging options."
 
3187
        # - GnuTLS manual
 
3188
        gnutls.global_set_log_level(11)
 
3189
 
 
3190
        @gnutls.log_func
 
3191
        def debug_gnutls(level, string):
 
3192
            log.debug("GnuTLS: %s",
 
3193
                      string[:-1].decode("utf-8", errors="replace"))
 
3194
 
 
3195
        gnutls.global_set_log_function(debug_gnutls)
 
3196
 
 
3197
        # Redirect stdin so all checkers get /dev/null
 
3198
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
 
3199
        os.dup2(null, sys.stdin.fileno())
 
3200
        if null > 2:
 
3201
            os.close(null)
 
3202
 
 
3203
    # Need to fork before connecting to D-Bus
 
3204
    if not foreground:
 
3205
        # Close all input and output, do double fork, etc.
 
3206
        daemon()
 
3207
 
 
3208
    if gi.version_info < (3, 10, 2):
 
3209
        # multiprocessing will use threads, so before we use GLib we
 
3210
        # need to inform GLib that threads will be used.
 
3211
        GLib.threads_init()
 
3212
 
768
3213
    global main_loop
769
 
    global bus
770
 
    global server
771
3214
    # From the Avahi example code
772
 
    DBusGMainLoop(set_as_default=True )
773
 
    main_loop = gobject.MainLoop()
 
3215
    DBusGMainLoop(set_as_default=True)
 
3216
    main_loop = GLib.MainLoop()
774
3217
    bus = dbus.SystemBus()
775
 
    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
776
 
                                           avahi.DBUS_PATH_SERVER),
777
 
                            avahi.DBUS_INTERFACE_SERVER)
778
3218
    # End of Avahi example code
779
 
    
780
 
    clients = Set()
781
 
    def remove_from_clients(client):
782
 
        clients.remove(client)
783
 
        if not clients:
784
 
            logger.critical(u"No clients left, exiting")
785
 
            sys.exit()
786
 
    
787
 
    clients.update(Set(Client(name = section,
788
 
                              stop_hook = remove_from_clients,
789
 
                              config
790
 
                              = dict(client_config.items(section)))
791
 
                       for section in client_config.sections()))
792
 
    if not clients:
793
 
        logger.critical(u"No clients defined")
794
 
        sys.exit(1)
795
 
    
796
 
    if debug:
797
 
        # Redirect stdin so all checkers get /dev/null
798
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
799
 
        os.dup2(null, sys.stdin.fileno())
800
 
        if null > 2:
801
 
            os.close(null)
802
 
    else:
803
 
        # No console logging
804
 
        logger.removeHandler(console)
805
 
        # Close all input and output, do double fork, etc.
806
 
        daemon()
807
 
    
808
 
    pidfilename = "/var/run/mandos/mandos.pid"
809
 
    pid = os.getpid()
810
 
    try:
811
 
        pidfile = open(pidfilename, "w")
812
 
        pidfile.write(str(pid) + "\n")
813
 
        pidfile.close()
 
3219
    if use_dbus:
 
3220
        try:
 
3221
            bus_name = dbus.service.BusName("se.recompile.Mandos",
 
3222
                                            bus,
 
3223
                                            do_not_queue=True)
 
3224
            old_bus_name = dbus.service.BusName(
 
3225
                "se.bsnet.fukt.Mandos", bus,
 
3226
                do_not_queue=True)
 
3227
        except dbus.exceptions.DBusException as e:
 
3228
            log.error("Disabling D-Bus:", exc_info=e)
 
3229
            use_dbus = False
 
3230
            server_settings["use_dbus"] = False
 
3231
            tcp_server.use_dbus = False
 
3232
    if zeroconf:
 
3233
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
3234
        service = AvahiServiceToSyslog(
 
3235
            name=server_settings["servicename"],
 
3236
            servicetype="_mandos._tcp",
 
3237
            protocol=protocol,
 
3238
            bus=bus)
 
3239
        if server_settings["interface"]:
 
3240
            service.interface = if_nametoindex(
 
3241
                server_settings["interface"].encode("utf-8"))
 
3242
 
 
3243
    global multiprocessing_manager
 
3244
    multiprocessing_manager = multiprocessing.Manager()
 
3245
 
 
3246
    client_class = Client
 
3247
    if use_dbus:
 
3248
        client_class = functools.partial(ClientDBus, bus=bus)
 
3249
 
 
3250
    client_settings = Client.config_parser(client_config)
 
3251
    old_client_settings = {}
 
3252
    clients_data = {}
 
3253
 
 
3254
    # This is used to redirect stdout and stderr for checker processes
 
3255
    global wnull
 
3256
    wnull = open(os.devnull, "w")  # A writable /dev/null
 
3257
    # Only used if server is running in foreground but not in debug
 
3258
    # mode
 
3259
    if debug or not foreground:
 
3260
        wnull.close()
 
3261
 
 
3262
    # Get client data and settings from last running state.
 
3263
    if server_settings["restore"]:
 
3264
        try:
 
3265
            with open(stored_state_path, "rb") as stored_state:
 
3266
                if sys.version_info.major == 2:
 
3267
                    clients_data, old_client_settings = pickle.load(
 
3268
                        stored_state)
 
3269
                else:
 
3270
                    bytes_clients_data, bytes_old_client_settings = (
 
3271
                        pickle.load(stored_state, encoding="bytes"))
 
3272
                    #   Fix bytes to strings
 
3273
                    #  clients_data
 
3274
                    # .keys()
 
3275
                    clients_data = {(key.decode("utf-8")
 
3276
                                     if isinstance(key, bytes)
 
3277
                                     else key): value
 
3278
                                    for key, value in
 
3279
                                    bytes_clients_data.items()}
 
3280
                    del bytes_clients_data
 
3281
                    for key in clients_data:
 
3282
                        value = {(k.decode("utf-8")
 
3283
                                  if isinstance(k, bytes) else k): v
 
3284
                                 for k, v in
 
3285
                                 clients_data[key].items()}
 
3286
                        clients_data[key] = value
 
3287
                        # .client_structure
 
3288
                        value["client_structure"] = [
 
3289
                            (s.decode("utf-8")
 
3290
                             if isinstance(s, bytes)
 
3291
                             else s) for s in
 
3292
                            value["client_structure"]]
 
3293
                        # .name, .host, and .checker_command
 
3294
                        for k in ("name", "host", "checker_command"):
 
3295
                            if isinstance(value[k], bytes):
 
3296
                                value[k] = value[k].decode("utf-8")
 
3297
                        if "key_id" not in value:
 
3298
                            value["key_id"] = ""
 
3299
                        elif "fingerprint" not in value:
 
3300
                            value["fingerprint"] = ""
 
3301
                    #  old_client_settings
 
3302
                    # .keys()
 
3303
                    old_client_settings = {
 
3304
                        (key.decode("utf-8")
 
3305
                         if isinstance(key, bytes)
 
3306
                         else key): value
 
3307
                        for key, value in
 
3308
                        bytes_old_client_settings.items()}
 
3309
                    del bytes_old_client_settings
 
3310
                    # .host and .checker_command
 
3311
                    for value in old_client_settings.values():
 
3312
                        for attribute in ("host", "checker_command"):
 
3313
                            if isinstance(value[attribute], bytes):
 
3314
                                value[attribute] = (value[attribute]
 
3315
                                                    .decode("utf-8"))
 
3316
            os.remove(stored_state_path)
 
3317
        except IOError as e:
 
3318
            if e.errno == errno.ENOENT:
 
3319
                log.warning("Could not load persistent state:"
 
3320
                            " %s", os.strerror(e.errno))
 
3321
            else:
 
3322
                log.critical("Could not load persistent state:",
 
3323
                             exc_info=e)
 
3324
                raise
 
3325
        except EOFError as e:
 
3326
            log.warning("Could not load persistent state: EOFError:",
 
3327
                        exc_info=e)
 
3328
 
 
3329
    with PGPEngine() as pgp:
 
3330
        for client_name, client in clients_data.items():
 
3331
            # Skip removed clients
 
3332
            if client_name not in client_settings:
 
3333
                continue
 
3334
 
 
3335
            # Decide which value to use after restoring saved state.
 
3336
            # We have three different values: Old config file,
 
3337
            # new config file, and saved state.
 
3338
            # New config value takes precedence if it differs from old
 
3339
            # config value, otherwise use saved state.
 
3340
            for name, value in client_settings[client_name].items():
 
3341
                try:
 
3342
                    # For each value in new config, check if it
 
3343
                    # differs from the old config value (Except for
 
3344
                    # the "secret" attribute)
 
3345
                    if (name != "secret"
 
3346
                        and (value !=
 
3347
                             old_client_settings[client_name][name])):
 
3348
                        client[name] = value
 
3349
                except KeyError:
 
3350
                    pass
 
3351
 
 
3352
            # Clients who has passed its expire date can still be
 
3353
            # enabled if its last checker was successful.  A Client
 
3354
            # whose checker succeeded before we stored its state is
 
3355
            # assumed to have successfully run all checkers during
 
3356
            # downtime.
 
3357
            if client["enabled"]:
 
3358
                if datetime.datetime.utcnow() >= client["expires"]:
 
3359
                    if not client["last_checked_ok"]:
 
3360
                        log.warning("disabling client %s - Client"
 
3361
                                    " never performed a successful"
 
3362
                                    " checker", client_name)
 
3363
                        client["enabled"] = False
 
3364
                    elif client["last_checker_status"] != 0:
 
3365
                        log.warning("disabling client %s - Client"
 
3366
                                    " last checker failed with error"
 
3367
                                    " code %s", client_name,
 
3368
                                    client["last_checker_status"])
 
3369
                        client["enabled"] = False
 
3370
                    else:
 
3371
                        client["expires"] = (
 
3372
                            datetime.datetime.utcnow()
 
3373
                            + client["timeout"])
 
3374
                        log.debug("Last checker succeeded, keeping %s"
 
3375
                                  " enabled", client_name)
 
3376
            try:
 
3377
                client["secret"] = pgp.decrypt(
 
3378
                    client["encrypted_secret"],
 
3379
                    client_settings[client_name]["secret"])
 
3380
            except PGPError:
 
3381
                # If decryption fails, we use secret from new settings
 
3382
                log.debug("Failed to decrypt %s old secret",
 
3383
                          client_name)
 
3384
                client["secret"] = (client_settings[client_name]
 
3385
                                    ["secret"])
 
3386
 
 
3387
    # Add/remove clients based on new changes made to config
 
3388
    for client_name in (set(old_client_settings)
 
3389
                        - set(client_settings)):
 
3390
        del clients_data[client_name]
 
3391
    for client_name in (set(client_settings)
 
3392
                        - set(old_client_settings)):
 
3393
        clients_data[client_name] = client_settings[client_name]
 
3394
 
 
3395
    # Create all client objects
 
3396
    for client_name, client in clients_data.items():
 
3397
        tcp_server.clients[client_name] = client_class(
 
3398
            name=client_name,
 
3399
            settings=client,
 
3400
            server_settings=server_settings)
 
3401
 
 
3402
    if not tcp_server.clients:
 
3403
        log.warning("No clients defined")
 
3404
 
 
3405
    if not foreground:
 
3406
        if pidfile is not None:
 
3407
            pid = os.getpid()
 
3408
            try:
 
3409
                with pidfile:
 
3410
                    print(pid, file=pidfile)
 
3411
            except IOError:
 
3412
                log.error("Could not write to file %r with PID %d",
 
3413
                          pidfilename, pid)
814
3414
        del pidfile
815
 
    except IOError, err:
816
 
        logger.error(u"Could not write %s file with PID %d",
817
 
                     pidfilename, os.getpid())
818
 
    
 
3415
        del pidfilename
 
3416
 
 
3417
    for termsig in (signal.SIGHUP, signal.SIGTERM):
 
3418
        GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
 
3419
                             lambda: main_loop.quit() and False)
 
3420
 
 
3421
    if use_dbus:
 
3422
 
 
3423
        @alternate_dbus_interfaces(
 
3424
            {"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
 
3425
        class MandosDBusService(DBusObjectWithObjectManager):
 
3426
            """A D-Bus proxy object"""
 
3427
 
 
3428
            def __init__(self):
 
3429
                dbus.service.Object.__init__(self, bus, "/")
 
3430
 
 
3431
            _interface = "se.recompile.Mandos"
 
3432
 
 
3433
            @dbus.service.signal(_interface, signature="o")
 
3434
            def ClientAdded(self, objpath):
 
3435
                "D-Bus signal"
 
3436
                pass
 
3437
 
 
3438
            @dbus.service.signal(_interface, signature="ss")
 
3439
            def ClientNotFound(self, key_id, address):
 
3440
                "D-Bus signal"
 
3441
                pass
 
3442
 
 
3443
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
3444
                               "true"})
 
3445
            @dbus.service.signal(_interface, signature="os")
 
3446
            def ClientRemoved(self, objpath, name):
 
3447
                "D-Bus signal"
 
3448
                pass
 
3449
 
 
3450
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
3451
                               "true"})
 
3452
            @dbus.service.method(_interface, out_signature="ao")
 
3453
            def GetAllClients(self):
 
3454
                "D-Bus method"
 
3455
                return dbus.Array(c.dbus_object_path for c in
 
3456
                                  tcp_server.clients.values())
 
3457
 
 
3458
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
3459
                               "true"})
 
3460
            @dbus.service.method(_interface,
 
3461
                                 out_signature="a{oa{sv}}")
 
3462
            def GetAllClientsWithProperties(self):
 
3463
                "D-Bus method"
 
3464
                return dbus.Dictionary(
 
3465
                    {c.dbus_object_path: c.GetAll(
 
3466
                        "se.recompile.Mandos.Client")
 
3467
                     for c in tcp_server.clients.values()},
 
3468
                    signature="oa{sv}")
 
3469
 
 
3470
            @dbus.service.method(_interface, in_signature="o")
 
3471
            def RemoveClient(self, object_path):
 
3472
                "D-Bus method"
 
3473
                for c in tcp_server.clients.values():
 
3474
                    if c.dbus_object_path == object_path:
 
3475
                        del tcp_server.clients[c.name]
 
3476
                        c.remove_from_connection()
 
3477
                        # Don't signal the disabling
 
3478
                        c.disable(quiet=True)
 
3479
                        # Emit D-Bus signal for removal
 
3480
                        self.client_removed_signal(c)
 
3481
                        return
 
3482
                raise KeyError(object_path)
 
3483
 
 
3484
            del _interface
 
3485
 
 
3486
            @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
 
3487
                                 out_signature="a{oa{sa{sv}}}")
 
3488
            def GetManagedObjects(self):
 
3489
                """D-Bus method"""
 
3490
                return dbus.Dictionary(
 
3491
                    {client.dbus_object_path:
 
3492
                     dbus.Dictionary(
 
3493
                         {interface: client.GetAll(interface)
 
3494
                          for interface in
 
3495
                          client._get_all_interface_names()})
 
3496
                     for client in tcp_server.clients.values()})
 
3497
 
 
3498
            def client_added_signal(self, client):
 
3499
                """Send the new standard signal and the old signal"""
 
3500
                if use_dbus:
 
3501
                    # New standard signal
 
3502
                    self.InterfacesAdded(
 
3503
                        client.dbus_object_path,
 
3504
                        dbus.Dictionary(
 
3505
                            {interface: client.GetAll(interface)
 
3506
                             for interface in
 
3507
                             client._get_all_interface_names()}))
 
3508
                    # Old signal
 
3509
                    self.ClientAdded(client.dbus_object_path)
 
3510
 
 
3511
            def client_removed_signal(self, client):
 
3512
                """Send the new standard signal and the old signal"""
 
3513
                if use_dbus:
 
3514
                    # New standard signal
 
3515
                    self.InterfacesRemoved(
 
3516
                        client.dbus_object_path,
 
3517
                        client._get_all_interface_names())
 
3518
                    # Old signal
 
3519
                    self.ClientRemoved(client.dbus_object_path,
 
3520
                                       client.name)
 
3521
 
 
3522
        mandos_dbus_service = MandosDBusService()
 
3523
 
 
3524
    # Save modules to variables to exempt the modules from being
 
3525
    # unloaded before the function registered with atexit() is run.
 
3526
    mp = multiprocessing
 
3527
    wn = wnull
 
3528
 
819
3529
    def cleanup():
820
3530
        "Cleanup function; run on exit"
821
 
        global group
822
 
        # From the Avahi example code
823
 
        if not group is None:
824
 
            group.Free()
825
 
            group = None
826
 
        # End of Avahi example code
827
 
        
828
 
        while clients:
829
 
            client = clients.pop()
830
 
            client.stop_hook = None
831
 
            client.stop()
832
 
    
 
3531
        if zeroconf:
 
3532
            service.cleanup()
 
3533
 
 
3534
        mp.active_children()
 
3535
        wn.close()
 
3536
        if not (tcp_server.clients or client_settings):
 
3537
            return
 
3538
 
 
3539
        # Store client before exiting. Secrets are encrypted with key
 
3540
        # based on what config file has. If config file is
 
3541
        # removed/edited, old secret will thus be unrecovable.
 
3542
        clients = {}
 
3543
        with PGPEngine() as pgp:
 
3544
            for client in tcp_server.clients.values():
 
3545
                key = client_settings[client.name]["secret"]
 
3546
                client.encrypted_secret = pgp.encrypt(client.secret,
 
3547
                                                      key)
 
3548
                client_dict = {}
 
3549
 
 
3550
                # A list of attributes that can not be pickled
 
3551
                # + secret.
 
3552
                exclude = {"bus", "changedstate", "secret",
 
3553
                           "checker", "server_settings"}
 
3554
                for name, typ in inspect.getmembers(dbus.service
 
3555
                                                    .Object):
 
3556
                    exclude.add(name)
 
3557
 
 
3558
                client_dict["encrypted_secret"] = (client
 
3559
                                                   .encrypted_secret)
 
3560
                for attr in client.client_structure:
 
3561
                    if attr not in exclude:
 
3562
                        client_dict[attr] = getattr(client, attr)
 
3563
 
 
3564
                clients[client.name] = client_dict
 
3565
                del client_settings[client.name]["secret"]
 
3566
 
 
3567
        try:
 
3568
            with tempfile.NamedTemporaryFile(
 
3569
                    mode="wb",
 
3570
                    suffix=".pickle",
 
3571
                    prefix="clients-",
 
3572
                    dir=os.path.dirname(stored_state_path),
 
3573
                    delete=False) as stored_state:
 
3574
                pickle.dump((clients, client_settings), stored_state,
 
3575
                            protocol=2)
 
3576
                tempname = stored_state.name
 
3577
            os.rename(tempname, stored_state_path)
 
3578
        except (IOError, OSError) as e:
 
3579
            if not debug:
 
3580
                try:
 
3581
                    os.remove(tempname)
 
3582
                except NameError:
 
3583
                    pass
 
3584
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
 
3585
                log.warning("Could not save persistent state: %s",
 
3586
                            os.strerror(e.errno))
 
3587
            else:
 
3588
                log.warning("Could not save persistent state:",
 
3589
                            exc_info=e)
 
3590
                raise
 
3591
 
 
3592
        # Delete all clients, and settings from config
 
3593
        while tcp_server.clients:
 
3594
            name, client = tcp_server.clients.popitem()
 
3595
            if use_dbus:
 
3596
                client.remove_from_connection()
 
3597
            # Don't signal the disabling
 
3598
            client.disable(quiet=True)
 
3599
            # Emit D-Bus signal for removal
 
3600
            if use_dbus:
 
3601
                mandos_dbus_service.client_removed_signal(client)
 
3602
        client_settings.clear()
 
3603
 
833
3604
    atexit.register(cleanup)
834
 
    
835
 
    if not debug:
836
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
837
 
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
838
 
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
839
 
    
840
 
    for client in clients:
841
 
        client.start()
842
 
    
843
 
    tcp_server = IPv6_TCPServer((server_settings["address"],
844
 
                                 server_settings["port"]),
845
 
                                tcp_handler,
846
 
                                settings=server_settings,
847
 
                                clients=clients)
 
3605
 
 
3606
    for client in tcp_server.clients.values():
 
3607
        if use_dbus:
 
3608
            # Emit D-Bus signal for adding
 
3609
            mandos_dbus_service.client_added_signal(client)
 
3610
        # Need to initiate checking of clients
 
3611
        if client.enabled:
 
3612
            client.init_checker()
 
3613
 
 
3614
    tcp_server.enable()
 
3615
    tcp_server.server_activate()
 
3616
 
848
3617
    # Find out what port we got
849
 
    service.port = tcp_server.socket.getsockname()[1]
850
 
    logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
851
 
                u" scope_id %d" % tcp_server.socket.getsockname())
852
 
    
853
 
    #service.interface = tcp_server.socket.getsockname()[3]
854
 
    
 
3618
    if zeroconf:
 
3619
        service.port = tcp_server.socket.getsockname()[1]
 
3620
    if use_ipv6:
 
3621
        log.info("Now listening on address %r, port %d, flowinfo %d,"
 
3622
                 " scope_id %d", *tcp_server.socket.getsockname())
 
3623
    else:                       # IPv4
 
3624
        log.info("Now listening on address %r, port %d",
 
3625
                 *tcp_server.socket.getsockname())
 
3626
 
 
3627
    # service.interface = tcp_server.socket.getsockname()[3]
 
3628
 
855
3629
    try:
856
 
        # From the Avahi example code
857
 
        server.connect_to_signal("StateChanged", server_state_changed)
858
 
        try:
859
 
            server_state_changed(server.GetState())
860
 
        except dbus.exceptions.DBusException, error:
861
 
            logger.critical(u"DBusException: %s", error)
862
 
            sys.exit(1)
863
 
        # End of Avahi example code
864
 
        
865
 
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
866
 
                             lambda *args, **kwargs:
867
 
                             tcp_server.handle_request\
868
 
                             (*args[2:], **kwargs) or True)
869
 
        
870
 
        logger.debug(u"Starting main loop")
871
 
        main_loop_started = True
 
3630
        if zeroconf:
 
3631
            # From the Avahi example code
 
3632
            try:
 
3633
                service.activate()
 
3634
            except dbus.exceptions.DBusException as error:
 
3635
                log.critical("D-Bus Exception", exc_info=error)
 
3636
                cleanup()
 
3637
                sys.exit(1)
 
3638
            # End of Avahi example code
 
3639
 
 
3640
        GLib.io_add_watch(
 
3641
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3642
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3643
            lambda *args, **kwargs: (tcp_server.handle_request
 
3644
                                     (*args[2:], **kwargs) or True))
 
3645
 
 
3646
        log.debug("Starting main loop")
872
3647
        main_loop.run()
873
 
    except AvahiError, error:
874
 
        logger.critical(u"AvahiError: %s" + unicode(error))
 
3648
    except AvahiError as error:
 
3649
        log.critical("Avahi Error", exc_info=error)
 
3650
        cleanup()
875
3651
        sys.exit(1)
876
3652
    except KeyboardInterrupt:
877
3653
        if debug:
878
 
            print
879
 
 
880
 
if __name__ == '__main__':
881
 
    main()
 
3654
            print("", file=sys.stderr)
 
3655
        log.debug("Server received KeyboardInterrupt")
 
3656
    log.debug("Server exiting")
 
3657
    # Must run before the D-Bus bus name gets deregistered
 
3658
    cleanup()
 
3659
 
 
3660
 
 
3661
def parse_test_args():
 
3662
    # type: () -> argparse.Namespace
 
3663
    parser = argparse.ArgumentParser(add_help=False)
 
3664
    parser.add_argument("--check", action="store_true")
 
3665
    parser.add_argument("--prefix", )
 
3666
    args, unknown_args = parser.parse_known_args()
 
3667
    if args.check:
 
3668
        # Remove test options from sys.argv
 
3669
        sys.argv[1:] = unknown_args
 
3670
    return args
 
3671
 
 
3672
# Add all tests from doctest strings
 
3673
def load_tests(loader, tests, none):
 
3674
    import doctest
 
3675
    tests.addTests(doctest.DocTestSuite())
 
3676
    return tests
 
3677
 
 
3678
if __name__ == "__main__":
 
3679
    options = parse_test_args()
 
3680
    try:
 
3681
        if options.check:
 
3682
            extra_test_prefix = options.prefix
 
3683
            if extra_test_prefix is not None:
 
3684
                if not (unittest.main(argv=[""], exit=False)
 
3685
                        .result.wasSuccessful()):
 
3686
                    sys.exit(1)
 
3687
                class ExtraTestLoader(unittest.TestLoader):
 
3688
                    testMethodPrefix = extra_test_prefix
 
3689
                # Call using ./scriptname --test [--verbose]
 
3690
                unittest.main(argv=[""], testLoader=ExtraTestLoader())
 
3691
            else:
 
3692
                unittest.main(argv=[""])
 
3693
        else:
 
3694
            main()
 
3695
    finally:
 
3696
        logging.shutdown()
 
3697
 
 
3698
# Local Variables:
 
3699
# run-tests:
 
3700
# (lambda (&optional extra)
 
3701
#   (if (not (funcall run-tests-in-test-buffer default-directory
 
3702
#             extra))
 
3703
#       (funcall show-test-buffer-in-test-window)
 
3704
#     (funcall remove-test-window)
 
3705
#     (if extra (message "Extra tests run successfully!"))))
 
3706
# run-tests-in-test-buffer:
 
3707
# (lambda (dir &optional extra)
 
3708
#   (with-current-buffer (get-buffer-create "*Test*")
 
3709
#     (setq buffer-read-only nil
 
3710
#           default-directory dir)
 
3711
#     (erase-buffer)
 
3712
#     (compilation-mode))
 
3713
#   (let ((process-result
 
3714
#          (let ((inhibit-read-only t))
 
3715
#            (process-file-shell-command
 
3716
#             (funcall get-command-line extra) nil "*Test*"))))
 
3717
#     (and (numberp process-result)
 
3718
#          (= process-result 0))))
 
3719
# get-command-line:
 
3720
# (lambda (&optional extra)
 
3721
#   (let ((quoted-script
 
3722
#          (shell-quote-argument (funcall get-script-name))))
 
3723
#     (format
 
3724
#      (concat "%s --check" (if extra " --prefix=atest" ""))
 
3725
#      quoted-script)))
 
3726
# get-script-name:
 
3727
# (lambda ()
 
3728
#   (if (fboundp 'file-local-name)
 
3729
#       (file-local-name (buffer-file-name))
 
3730
#     (or (file-remote-p (buffer-file-name) 'localname)
 
3731
#         (buffer-file-name))))
 
3732
# remove-test-window:
 
3733
# (lambda ()
 
3734
#   (let ((test-window (get-buffer-window "*Test*")))
 
3735
#     (if test-window (delete-window test-window))))
 
3736
# show-test-buffer-in-test-window:
 
3737
# (lambda ()
 
3738
#   (when (not (get-buffer-window-list "*Test*"))
 
3739
#     (setq next-error-last-buffer (get-buffer "*Test*"))
 
3740
#     (let* ((side (if (>= (window-width) 146) 'right 'bottom))
 
3741
#            (display-buffer-overriding-action
 
3742
#             `((display-buffer-in-side-window) (side . ,side)
 
3743
#               (window-height . fit-window-to-buffer)
 
3744
#               (window-width . fit-window-to-buffer))))
 
3745
#       (display-buffer "*Test*"))))
 
3746
# eval:
 
3747
# (progn
 
3748
#   (let* ((run-extra-tests (lambda () (interactive)
 
3749
#                             (funcall run-tests t)))
 
3750
#          (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
 
3751
#          (outer-keymap `(keymap (3 . ,inner-keymap))))     ; C-c
 
3752
#     (setq minor-mode-overriding-map-alist
 
3753
#           (cons `(run-tests . ,outer-keymap)
 
3754
#                 minor-mode-overriding-map-alist)))
 
3755
#   (add-hook 'after-save-hook run-tests 90 t))
 
3756
# End: