/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2015-08-10 09:00:23 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150810090023-fz6vjqr7zf33e2tf
Support the standard org.freedesktop.DBus.ObjectManager interface.

Now that the D-Bus standard has an interface to keep track of new and
removed objects, use that instead of our own methods.  This deprecates
our D-Bus methods "GetAllClients" and "GetAllClientsWithProperties"
and the signals "ClientAdded" and "ClientRemoved", all on the server
interface "se.recompile.Mandos".

* DBUS-API: Removed references to deprecated methods and signals;
  insert reference to the org.freedesktop.DBus.ObjectManager
  interface.
* mandos (DBusObjectWithProperties._get_all_interface_names): New.
  (dbus.OBJECT_MANAGER_IFACE): If not present, monkey patch.
  (DBusObjectWithObjectManager): New.
  (main/MandosDBusService): Inherit from DBusObjectWithObjectManager.
  (main/MandosDBusService.ClientRemoved): Annotate as deprecated.
  (main/MandosDBusService.GetAllClients): - '' -
  (main/MandosDBusService.GetAllClientsWithProperties): Annotate as
                                                        deprecated.
                                                        Also only
                                                        return
                                                        properties on
                                                        client
                                                        interface.
  (main/MandosDBusService.RemoveClient): Call client_removed_signal
                                         instead of ClientRemoved.
  (main/MandosDBusService.GetManagedObjects): New.
  (main/MandosDBusService.client_added_signal): New.
  (main/MandosDBusService.client_removed_signal): - '' -
  (main/cleanup): Call "client_removed_signal" instead of sending
                  "ClientRemoved" signal directly.
  (main): Call "client_added_signal" instead of sending "ClientAdded"
          signal directly.
* mandos-ctl: Use GetManagedObjects instead of
              GetAllClientsWithProperties.  Also, show better error
              message in case of failure to connect to the D-Bus

* mandos-monitor (MandosClientPropertyCache.properties_changed):
  Bug fix; only update properties on client interface.
  (UserInterface.find_and_remove_client): Change to accept arguments
                                          from InterfacesRemoved
                                          signal.  Also, bug fix:
                                          working error message when
                                          removing unknown client.
  (UserInterface.add_new_client): Change to accept arguments from
                                  InterfacesRemoved signal.  Pass
                                  properties to MandosClientWidget
                                  constructor.
  (UserInterface.run): Connect find_and_remove_client method to
                       InterfacesRemoved signal and the add_new_client
                       method to the InterfacesAdded signal.

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