/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2015-07-01 20:01:26 UTC
  • mto: This revision was merged to the branch mainline in revision 759.
  • Revision ID: teddy@recompile.se-20150701200126-qb3f6c3jcas2f4og
mandos-client: Try to start a plugin to add and remove a local route.

* debian/mandos-client.README.Debian: Add setting of environment
                                      variable MANDOSPLUGINHELPERDIR
                                      to command line testing
                                      mandos-client.
* mandos-client.c (raise_privileges): Moved to top of file.
                  (raise_privileges_permanently): - '' -
                  (lower_privileges): - '' -
                  (lower_privileges_permanently): - '' -
  (add_remove_local_route, add_local_route, remove_local_route): New.
  (start_mandos_communication): Set SOCK_CLOEXEC flag on socket.  Run
                                the above functions to add (and
                                remove) local route, if the conditions
                                indicates it could help.
  (run_network_hooks): Use O_DIRECTORY, O_PATH, and O_CLOEXEC flags
                       when opening network hook directory. Do
                       TEMP_FAILURE_RETRY around opening of /dev/null
                       and network hook executables.  Move redirecting
                       of stdout and stderr to as late as possible
                       before fexecve().
  (main): Use O_DIRECTORY and O_PATH when opening temporary directory.
* plugins.d/mandos-client.xml (ENVIRONMENT): Document usage of the
                                             MANDOSPLUGINHELPERDIR
                                             environment variable.

Show diffs side-by-side

added added

removed removed

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