/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2015-08-02 09:36:40 UTC
  • Revision ID: teddy@recompile.se-20150802093640-nc0n17rbmqlbaxuf
Add D-Bus annotations on a few properties on the Client object.

The D-Bus property "Secret" on the interface
"se.recompile.Mandos.Client" should have the annotation
"org.freedesktop.DBus.Property.EmitsChangedSignal" set to
"invalidates".  Also, the properties "Created", "Fingerprint", "Name",
and "ObjectPath" should have the same annotation set to "const".

* mandos (ClientDBus.Name_dbus_property): Set annotation
                    "org.freedesktop.DBus.Property.EmitsChangedSignal"
                    to "const".
  (ClientDBus.Fingerprint_dbus_property): - '' -
  (ClientDBus.Created_dbus_property): - '' -
  (ClientDBus.ObjectPath_dbus_property): - '' -
  (ClientDBus.Secret_dbus_property): Set annotation
                    "org.freedesktop.DBus.Property.EmitsChangedSignal"
                    to "invalidates".

Show diffs side-by-side

added added

removed removed

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