/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-05-23 12:07:07 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150523120707-t5fq0brh2kxkvw8g
mandos: Some more minor changes to prepare for Python 3.

Show diffs side-by-side

added added

removed removed

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