/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: 2011-11-26 23:08:17 UTC
  • mto: (518.1.8 mandos-persistent)
  • mto: This revision was merged to the branch mainline in revision 524.
  • Revision ID: teddy@recompile.se-20111126230817-tv08v831s2yltbkd
Make "enabled" a client config option.

* DBUS-API: Fix wording on "Expires" option.
* clients.conf (enabled): New.
* mandos (Client): "last_enabled" can now be None.
  (Client.__init__): Get "enabled" from config.  Only set
                     "last_enabled" and "expires" if enabled.
  (ClientDBus.Created_dbus_property): Removed redundant dbus.String().
  (ClientDBus.Interval_dbus_property): If changed, only reschedule
                                       checker if enabled.
  (main/special_settings): Added "enabled".
* mandos-clients.conf (OPTIONS): Added "enabled".

Show diffs side-by-side

added added

removed removed

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