/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: 2012-06-24 03:45:55 UTC
  • mto: (237.7.272 trunk)
  • mto: This revision was merged to the branch mainline in revision 303.
  • Revision ID: teddy@recompile.se-20120624034555-7p0dtbpsz0dgsn4d
* mandos (Client.start_checker): Add comment.  Break long line.

Show diffs side-by-side

added added

removed removed

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