/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2019-08-18 04:14:31 UTC
  • mto: This revision was merged to the branch mainline in revision 390.
  • Revision ID: teddy@recompile.se-20190818041431-jgt8pizlzjvxalj0
Debian package: Client: Install the systemd sysusers.d file

* debian/mandos-client.dirs (usr/lib/sysusers.d): New.

Show diffs side-by-side

added added

removed removed

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