/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2015-07-12 01:41:14 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150712014114-qbala4mutkixxct3
Handle local Zeroconf service name collisions on startup, too.

* mandos (AvahiService.server_state_changed): Catch name collision
                                              error when adding
                                              server.

Show diffs side-by-side

added added

removed removed

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