/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2011-11-27 19:37:54 UTC
  • mto: (237.12.11 mandos-persistent)
  • mto: This revision was merged to the branch mainline in revision 290.
  • Revision ID: teddy@recompile.se-20111127193754-4366e18gmi11kew0
* mandos (_timedelta_to_milliseconds): Renamed to
                                       "timedelta_to_milliseconds";
                                       all callers changed.
  (Client._approved): Bug fix; renamed to "approved" without
                      underscore.  All users changed.
  (ProxyClient): Removed superfluous parens in "if" statements.
  (ClientHandler.handle): Bug fix: Emit NewRequest signal *after*
                          client is found, not before.

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 © 2007-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
24
25
#     GNU General Public License for more details.
25
26
26
27
# You should have received a copy of the GNU General Public License
27
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
28
 
29
 
# Contact the authors at <mandos@fukt.bsnet.se>.
30
 
31
 
 
32
 
from __future__ import division
33
 
 
34
 
import SocketServer
 
28
# along with this program.  If not, see
 
29
# <http://www.gnu.org/licenses/>.
 
30
 
31
# Contact the authors at <mandos@recompile.se>.
 
32
 
33
 
 
34
from __future__ import (division, absolute_import, print_function,
 
35
                        unicode_literals)
 
36
 
 
37
import SocketServer as socketserver
35
38
import socket
36
 
import select
37
 
from optparse import OptionParser
 
39
import argparse
38
40
import datetime
39
41
import errno
40
42
import gnutls.crypto
43
45
import gnutls.library.functions
44
46
import gnutls.library.constants
45
47
import gnutls.library.types
46
 
import ConfigParser
 
48
import ConfigParser as configparser
47
49
import sys
48
50
import re
49
51
import os
50
52
import signal
51
 
from sets import Set
52
53
import subprocess
53
54
import atexit
54
55
import stat
55
56
import logging
56
57
import logging.handlers
 
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
57
68
 
58
69
import dbus
 
70
import dbus.service
59
71
import gobject
60
72
import avahi
61
73
from dbus.mainloop.glib import DBusGMainLoop
62
74
import ctypes
63
 
 
64
 
version = "1.0"
65
 
 
66
 
logger = logging.Logger('mandos')
67
 
syslogger = logging.handlers.SysLogHandler\
68
 
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
69
 
             address = "/dev/log")
70
 
syslogger.setFormatter(logging.Formatter\
71
 
                        ('Mandos: %(levelname)s: %(message)s'))
72
 
logger.addHandler(syslogger)
73
 
 
74
 
console = logging.StreamHandler()
75
 
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
76
 
                                       ' %(message)s'))
77
 
logger.addHandler(console)
 
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
 
78
209
 
79
210
class AvahiError(Exception):
80
 
    def __init__(self, value):
 
211
    def __init__(self, value, *args, **kwargs):
81
212
        self.value = value
82
 
    def __str__(self):
83
 
        return repr(self.value)
 
213
        super(AvahiError, self).__init__(value, *args, **kwargs)
 
214
    def __unicode__(self):
 
215
        return unicode(repr(self.value))
84
216
 
85
217
class AvahiServiceError(AvahiError):
86
218
    pass
91
223
 
92
224
class AvahiService(object):
93
225
    """An Avahi (Zeroconf) service.
 
226
    
94
227
    Attributes:
95
228
    interface: integer; avahi.IF_UNSPEC or an interface index.
96
229
               Used to optionally bind to the specified interface.
104
237
    max_renames: integer; maximum number of renames
105
238
    rename_count: integer; counter so we only rename after collisions
106
239
                  a sensible number of times
 
240
    group: D-Bus Entry Group
 
241
    server: D-Bus Server
 
242
    bus: dbus.SystemBus()
107
243
    """
108
244
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
109
 
                 type = None, port = None, TXT = None, domain = "",
110
 
                 host = "", max_renames = 32768):
 
245
                 servicetype = None, port = None, TXT = None,
 
246
                 domain = "", host = "", max_renames = 32768,
 
247
                 protocol = avahi.PROTO_UNSPEC, bus = None):
111
248
        self.interface = interface
112
249
        self.name = name
113
 
        self.type = type
 
250
        self.type = servicetype
114
251
        self.port = port
115
 
        if TXT is None:
116
 
            self.TXT = []
117
 
        else:
118
 
            self.TXT = TXT
 
252
        self.TXT = TXT if TXT is not None else []
119
253
        self.domain = domain
120
254
        self.host = host
121
255
        self.rename_count = 0
122
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
123
262
    def rename(self):
124
263
        """Derived from the Avahi example code"""
125
264
        if self.rename_count >= self.max_renames:
126
 
            logger.critical(u"No suitable service name found after %i"
127
 
                            u" retries, exiting.", rename_count)
 
265
            logger.critical("No suitable Zeroconf service name found"
 
266
                            " after %i retries, exiting.",
 
267
                            self.rename_count)
128
268
            raise AvahiServiceError("Too many renames")
129
 
        self.name = server.GetAlternativeServiceName(self.name)
130
 
        logger.info(u"Changing name to %r ...", str(self.name))
131
 
        syslogger.setFormatter(logging.Formatter\
132
 
                               ('Mandos (%s): %%(levelname)s:'
133
 
                               ' %%(message)s' % self.name))
 
269
        self.name = unicode(self.server
 
270
                            .GetAlternativeServiceName(self.name))
 
271
        logger.info("Changing Zeroconf service name to %r ...",
 
272
                    self.name)
134
273
        self.remove()
135
 
        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)
136
280
        self.rename_count += 1
137
281
    def remove(self):
138
282
        """Derived from the Avahi example code"""
139
 
        if group is not None:
140
 
            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()
141
288
    def add(self):
142
289
        """Derived from the Avahi example code"""
143
 
        global group
144
 
        if group is None:
145
 
            group = dbus.Interface\
146
 
                    (bus.get_object(avahi.DBUS_NAME,
147
 
                                    server.EntryGroupNew()),
148
 
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
149
 
            group.connect_to_signal('StateChanged',
150
 
                                    entry_group_state_changed)
151
 
        logger.debug(u"Adding service '%s' of type '%s' ...",
152
 
                     service.name, service.type)
153
 
        group.AddService(
154
 
                self.interface,         # interface
155
 
                avahi.PROTO_INET6,      # protocol
156
 
                dbus.UInt32(0),         # flags
157
 
                self.name, self.type,
158
 
                self.domain, self.host,
159
 
                dbus.UInt16(self.port),
160
 
                avahi.string_array_to_txt_array(self.TXT))
161
 
        group.Commit()
162
 
 
163
 
# From the Avahi example code:
164
 
group = None                            # our entry group
165
 
# End of Avahi example code
166
 
 
167
 
 
 
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
        
168
386
class Client(object):
169
387
    """A representation of a client host served by this server.
 
388
    
170
389
    Attributes:
171
 
    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()
172
408
    fingerprint: string (40 or 32 hexadecimal digits); used to
173
409
                 uniquely identify the client
174
 
    secret:    bytestring; sent verbatim (over TLS) to client
175
 
    host:      string; available for use by the checker command
176
 
    created:   datetime.datetime(); object creation, not client host
177
 
    last_checked_ok: datetime.datetime() or None if not yet checked OK
178
 
    timeout:   datetime.timedelta(); How long from last_checked_ok
179
 
                                     until this client is invalid
180
 
    interval:  datetime.timedelta(); How often to start a new checker
181
 
    stop_hook: If set, called by stop() as stop_hook(self)
182
 
    checker:   subprocess.Popen(); a running checker process used
183
 
                                   to see if the client lives.
184
 
                                   'None' if no process is running.
185
 
    checker_initiator_tag: a gobject event source tag, or None
186
 
    stop_initiator_tag:    - '' -
187
 
    checker_callback_tag:  - '' -
188
 
    checker_command: string; External command which is run to check if
189
 
                     client lives.  %() expansions are done at
190
 
                     runtime with vars(self) as dict, so that for
191
 
                     instance %(name)s can be used in the command.
192
 
    Private attibutes:
193
 
    _timeout: Real variable for 'timeout'
194
 
    _interval: Real variable for 'interval'
195
 
    _timeout_milliseconds: Used when calling gobject.timeout_add()
196
 
    _interval_milliseconds: - '' -
 
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
197
428
    """
198
 
    def _set_timeout(self, timeout):
199
 
        "Setter function for 'timeout' attribute"
200
 
        self._timeout = timeout
201
 
        self._timeout_milliseconds = ((self.timeout.days
202
 
                                       * 24 * 60 * 60 * 1000)
203
 
                                      + (self.timeout.seconds * 1000)
204
 
                                      + (self.timeout.microseconds
205
 
                                         // 1000))
206
 
    timeout = property(lambda self: self._timeout,
207
 
                       _set_timeout)
208
 
    del _set_timeout
209
 
    def _set_interval(self, interval):
210
 
        "Setter function for 'interval' attribute"
211
 
        self._interval = interval
212
 
        self._interval_milliseconds = ((self.interval.days
213
 
                                        * 24 * 60 * 60 * 1000)
214
 
                                       + (self.interval.seconds
215
 
                                          * 1000)
216
 
                                       + (self.interval.microseconds
217
 
                                          // 1000))
218
 
    interval = property(lambda self: self._interval,
219
 
                        _set_interval)
220
 
    del _set_interval
221
 
    def __init__(self, name = None, stop_hook=None, config={}):
 
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):
222
451
        """Note: the 'checker' key in 'config' sets the
223
452
        'checker_command' attribute and *not* the 'checker'
224
453
        attribute."""
225
454
        self.name = name
226
 
        logger.debug(u"Creating client %r", self.name)
 
455
        if config is None:
 
456
            config = {}
 
457
        logger.debug("Creating client %r", self.name)
227
458
        # Uppercase and remove spaces from fingerprint for later
228
459
        # comparison purposes with return value from the fingerprint()
229
460
        # function
230
 
        self.fingerprint = config["fingerprint"].upper()\
231
 
                           .replace(u" ", u"")
232
 
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
 
461
        self.fingerprint = (config["fingerprint"].upper()
 
462
                            .replace(" ", ""))
 
463
        logger.debug("  Fingerprint: %s", self.fingerprint)
233
464
        if "secret" in config:
234
 
            self.secret = config["secret"].decode(u"base64")
 
465
            self.secret = config["secret"].decode("base64")
235
466
        elif "secfile" in config:
236
 
            sf = open(config["secfile"])
237
 
            self.secret = sf.read()
238
 
            sf.close()
 
467
            with open(os.path.expanduser(os.path.expandvars
 
468
                                         (config["secfile"])),
 
469
                      "rb") as secfile:
 
470
                self.secret = secfile.read()
239
471
        else:
240
 
            raise TypeError(u"No secret or secfile for client %s"
 
472
            raise TypeError("No secret or secfile for client %s"
241
473
                            % self.name)
242
474
        self.host = config.get("host", "")
243
 
        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
244
482
        self.last_checked_ok = None
 
483
        self.last_checker_status = None
245
484
        self.timeout = string_to_delta(config["timeout"])
 
485
        self.extended_timeout = string_to_delta(config
 
486
                                                ["extended_timeout"])
246
487
        self.interval = string_to_delta(config["interval"])
247
 
        self.stop_hook = stop_hook
248
488
        self.checker = None
249
489
        self.checker_initiator_tag = None
250
 
        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
251
495
        self.checker_callback_tag = None
252
 
        self.check_command = config["checker"]
253
 
    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):
254
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):
255
561
        # Schedule a new checker to be started an 'interval' from now,
256
562
        # and every interval from then on.
257
 
        self.checker_initiator_tag = gobject.timeout_add\
258
 
                                     (self._interval_milliseconds,
259
 
                                      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))
260
570
        # Also start a new checker *right now*.
261
571
        self.start_checker()
262
 
        # Schedule a stop() when 'timeout' has passed
263
 
        self.stop_initiator_tag = gobject.timeout_add\
264
 
                                  (self._timeout_milliseconds,
265
 
                                   self.stop)
266
 
    def stop(self):
267
 
        """Stop this client.
268
 
        The possibility that a client might be restarted is left open,
269
 
        but not currently used."""
270
 
        # If this client doesn't have a secret, it is already stopped.
271
 
        if hasattr(self, "secret") and self.secret:
272
 
            logger.info(u"Stopping client %s", self.name)
273
 
            self.secret = None
274
 
        else:
275
 
            return False
276
 
        if getattr(self, "stop_initiator_tag", False):
277
 
            gobject.source_remove(self.stop_initiator_tag)
278
 
            self.stop_initiator_tag = None
279
 
        if getattr(self, "checker_initiator_tag", False):
280
 
            gobject.source_remove(self.checker_initiator_tag)
281
 
            self.checker_initiator_tag = None
282
 
        self.stop_checker()
283
 
        if self.stop_hook:
284
 
            self.stop_hook(self)
285
 
        # Do not run this again if called by a gobject.timeout_add
286
 
        return False
287
 
    def __del__(self):
288
 
        self.stop_hook = None
289
 
        self.stop()
290
 
    def checker_callback(self, pid, condition):
 
572
    
 
573
    def checker_callback(self, pid, condition, command):
291
574
        """The checker has completed, so take appropriate actions."""
292
 
        now = datetime.datetime.now()
293
575
        self.checker_callback_tag = None
294
576
        self.checker = None
295
 
        if os.WIFEXITED(condition) \
296
 
               and (os.WEXITSTATUS(condition) == 0):
297
 
            logger.info(u"Checker for %(name)s succeeded",
298
 
                        vars(self))
299
 
            self.last_checked_ok = now
300
 
            gobject.source_remove(self.stop_initiator_tag)
301
 
            self.stop_initiator_tag = gobject.timeout_add\
302
 
                                      (self._timeout_milliseconds,
303
 
                                       self.stop)
304
 
        elif not os.WIFEXITED(condition):
305
 
            logger.warning(u"Checker for %(name)s crashed?",
 
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?",
306
589
                           vars(self))
307
 
        else:
308
 
            logger.info(u"Checker for %(name)s failed",
309
 
                        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
    
310
611
    def start_checker(self):
311
612
        """Start a new checker subprocess if one is not running.
 
613
        
312
614
        If a checker already exists, leave it running and do
313
615
        nothing."""
314
616
        # The reason for not killing a running checker is that if we
317
619
        # client would inevitably timeout, since no checker would get
318
620
        # a chance to run to completion.  If we instead leave running
319
621
        # checkers alone, the checker would have to take more time
320
 
        # than 'timeout' for the client to be declared invalid, which
321
 
        # is as it should be.
 
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
322
639
        if self.checker is None:
323
640
            try:
324
 
                # In case check_command has exactly one % operator
325
 
                command = self.check_command % self.host
 
641
                # In case checker_command has exactly one % operator
 
642
                command = self.checker_command % self.host
326
643
            except TypeError:
327
644
                # Escape attributes for the shell
328
 
                escaped_attrs = dict((key, re.escape(str(val)))
329
 
                                     for key, val in
330
 
                                     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
                
331
653
                try:
332
 
                    command = self.check_command % escaped_attrs
333
 
                except TypeError, error:
334
 
                    logger.error(u'Could not format string "%s":'
335
 
                                 u' %s', self.check_command, error)
 
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)
336
658
                    return True # Try again later
 
659
            self.current_checker_command = command
337
660
            try:
338
 
                logger.info(u"Starting checker %r for %s",
 
661
                logger.info("Starting checker %r for %s",
339
662
                            command, self.name)
 
663
                # We don't need to redirect stdout and stderr, since
 
664
                # in normal mode, that is already done by daemon(),
 
665
                # and in debug mode we don't want to.  (Stdin is
 
666
                # always replaced by /dev/null.)
340
667
                self.checker = subprocess.Popen(command,
341
668
                                                close_fds=True,
342
669
                                                shell=True, cwd="/")
343
 
                self.checker_callback_tag = gobject.child_watch_add\
344
 
                                            (self.checker.pid,
345
 
                                             self.checker_callback)
346
 
            except subprocess.OSError, error:
347
 
                logger.error(u"Failed to start subprocess: %s",
 
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",
348
682
                             error)
349
683
        # Re-run this periodically if run by gobject.timeout_add
350
684
        return True
 
685
    
351
686
    def stop_checker(self):
352
687
        """Force the checker process, if any, to stop."""
353
688
        if self.checker_callback_tag:
355
690
            self.checker_callback_tag = None
356
691
        if getattr(self, "checker", None) is None:
357
692
            return
358
 
        logger.debug(u"Stopping checker for %(name)s", vars(self))
 
693
        logger.debug("Stopping checker for %(name)s", vars(self))
359
694
        try:
360
695
            os.kill(self.checker.pid, signal.SIGTERM)
361
 
            #os.sleep(0.5)
 
696
            #time.sleep(0.5)
362
697
            #if self.checker.poll() is None:
363
698
            #    os.kill(self.checker.pid, signal.SIGKILL)
364
 
        except OSError, error:
 
699
        except OSError as error:
365
700
            if error.errno != errno.ESRCH: # No such process
366
701
                raise
367
702
        self.checker = None
368
 
    def still_valid(self):
369
 
        """Has the timeout not yet passed for this client?"""
370
 
        now = datetime.datetime.now()
371
 
        if self.last_checked_ok is None:
372
 
            return now < (self.created + self.timeout)
373
 
        else:
374
 
            return now < (self.last_checked_ok + self.timeout)
375
 
 
376
 
 
377
 
def peer_certificate(session):
378
 
    "Return the peer's OpenPGP certificate as a bytestring"
379
 
    # If not an OpenPGP certificate...
380
 
    if gnutls.library.functions.gnutls_certificate_type_get\
381
 
            (session._c_object) \
382
 
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
383
 
        # ...do the normal thing
384
 
        return session.peer_certificate
385
 
    list_size = ctypes.c_uint()
386
 
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
387
 
        (session._c_object, ctypes.byref(list_size))
388
 
    if list_size.value == 0:
389
 
        return None
390
 
    cert = cert_list[0]
391
 
    return ctypes.string_at(cert.data, cert.size)
392
 
 
393
 
 
394
 
def fingerprint(openpgp):
395
 
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
396
 
    # New GnuTLS "datum" with the OpenPGP public key
397
 
    datum = gnutls.library.types.gnutls_datum_t\
398
 
        (ctypes.cast(ctypes.c_char_p(openpgp),
399
 
                     ctypes.POINTER(ctypes.c_ubyte)),
400
 
         ctypes.c_uint(len(openpgp)))
401
 
    # New empty GnuTLS certificate
402
 
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
403
 
    gnutls.library.functions.gnutls_openpgp_crt_init\
404
 
        (ctypes.byref(crt))
405
 
    # Import the OpenPGP public key into the certificate
406
 
    gnutls.library.functions.gnutls_openpgp_crt_import\
407
 
                    (crt, ctypes.byref(datum),
408
 
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
409
 
    # New buffer for the fingerprint
410
 
    buffer = ctypes.create_string_buffer(20)
411
 
    buffer_length = ctypes.c_size_t()
412
 
    # Get the fingerprint from the certificate into the buffer
413
 
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
414
 
        (crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
415
 
    # Deinit the certificate
416
 
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
417
 
    # Convert the buffer to a Python bytestring
418
 
    fpr = ctypes.string_at(buffer, buffer_length.value)
419
 
    # Convert the bytestring to hexadecimal notation
420
 
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
421
 
    return hex_fpr
422
 
 
423
 
 
424
 
class tcp_handler(SocketServer.BaseRequestHandler, object):
425
 
    """A TCP request handler class.
426
 
    Instantiated by IPv6_TCPServer for each request to handle it.
 
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.
427
1443
    Note: This will run in its own forked process."""
428
1444
    
429
1445
    def handle(self):
430
 
        logger.info(u"TCP connection from: %s",
431
 
                     unicode(self.client_address))
432
 
        session = gnutls.connection.ClientSession\
433
 
                  (self.request, gnutls.connection.X509Credentials())
434
 
        
435
 
        line = self.request.makefile().readline()
436
 
        logger.debug(u"Protocol version: %r", line)
437
 
        try:
438
 
            if int(line.strip().split()[0]) > 1:
439
 
                raise RuntimeError
440
 
        except (ValueError, IndexError, RuntimeError), error:
441
 
            logger.error(u"Unknown protocol version: %s", error)
442
 
            return
443
 
        
444
 
        # Note: gnutls.connection.X509Credentials is really a generic
445
 
        # GnuTLS certificate credentials object so long as no X.509
446
 
        # keys are added to it.  Therefore, we can use it here despite
447
 
        # using OpenPGP certificates.
448
 
        
449
 
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
450
 
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
451
 
        #                "+DHE-DSS"))
452
 
        priority = "NORMAL"             # Fallback default, since this
453
 
                                        # MUST be set.
454
 
        if self.server.settings["priority"]:
455
 
            priority = self.server.settings["priority"]
456
 
        gnutls.library.functions.gnutls_priority_set_direct\
457
 
            (session._c_object, priority, None);
458
 
        
459
 
        try:
460
 
            session.handshake()
461
 
        except gnutls.errors.GNUTLSError, error:
462
 
            logger.warning(u"Handshake failed: %s", error)
463
 
            # Do not run session.bye() here: the session is not
464
 
            # established.  Just abandon the request.
465
 
            return
466
 
        try:
467
 
            fpr = fingerprint(peer_certificate(session))
468
 
        except (TypeError, gnutls.errors.GNUTLSError), error:
469
 
            logger.warning(u"Bad certificate: %s", error)
470
 
            session.bye()
471
 
            return
472
 
        logger.debug(u"Fingerprint: %s", fpr)
473
 
        client = None
474
 
        for c in self.server.clients:
475
 
            if c.fingerprint == fpr:
476
 
                client = c
477
 
                break
478
 
        if not client:
479
 
            logger.warning(u"Client not found for fingerprint: %s",
480
 
                           fpr)
481
 
            session.bye()
482
 
            return
483
 
        # Have to check if client.still_valid(), since it is possible
484
 
        # that the client timed out while establishing the GnuTLS
485
 
        # session.
486
 
        if not client.still_valid():
487
 
            logger.warning(u"Client %(name)s is invalid",
488
 
                           vars(client))
489
 
            session.bye()
490
 
            return
491
 
        sent_size = 0
492
 
        while sent_size < len(client.secret):
493
 
            sent = session.send(client.secret[sent_size:])
494
 
            logger.debug(u"Sent: %d, remaining: %d",
495
 
                         sent, len(client.secret)
496
 
                         - (sent_size + sent))
497
 
            sent_size += sent
498
 
        session.bye()
499
 
 
500
 
 
501
 
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
502
 
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
 
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
                
 
1506
                try:
 
1507
                    client = ProxyClient(child_pipe, fpr,
 
1508
                                         self.client_address)
 
1509
                except KeyError:
 
1510
                    return
 
1511
                
 
1512
                if self.server.use_dbus:
 
1513
                    # Emit D-Bus signal
 
1514
                    client.NewRequest(str(self.client_address))
 
1515
                
 
1516
                if client.approval_delay:
 
1517
                    delay = client.approval_delay
 
1518
                    client.approvals_pending += 1
 
1519
                    approval_required = True
 
1520
                
 
1521
                while True:
 
1522
                    if not client.enabled:
 
1523
                        logger.info("Client %s is disabled",
 
1524
                                       client.name)
 
1525
                        if self.server.use_dbus:
 
1526
                            # Emit D-Bus signal
 
1527
                            client.Rejected("Disabled")
 
1528
                        return
 
1529
                    
 
1530
                    if client.approved or not client.approval_delay:
 
1531
                        #We are approved or approval is disabled
 
1532
                        break
 
1533
                    elif client.approved is None:
 
1534
                        logger.info("Client %s needs approval",
 
1535
                                    client.name)
 
1536
                        if self.server.use_dbus:
 
1537
                            # Emit D-Bus signal
 
1538
                            client.NeedApproval(
 
1539
                                client.approval_delay_milliseconds(),
 
1540
                                client.approved_by_default)
 
1541
                    else:
 
1542
                        logger.warning("Client %s was not approved",
 
1543
                                       client.name)
 
1544
                        if self.server.use_dbus:
 
1545
                            # Emit D-Bus signal
 
1546
                            client.Rejected("Denied")
 
1547
                        return
 
1548
                    
 
1549
                    #wait until timeout or approved
 
1550
                    time = datetime.datetime.now()
 
1551
                    client.changedstate.acquire()
 
1552
                    (client.changedstate.wait
 
1553
                     (float(client.timedelta_to_milliseconds(delay)
 
1554
                            / 1000)))
 
1555
                    client.changedstate.release()
 
1556
                    time2 = datetime.datetime.now()
 
1557
                    if (time2 - time) >= delay:
 
1558
                        if not client.approved_by_default:
 
1559
                            logger.warning("Client %s timed out while"
 
1560
                                           " waiting for approval",
 
1561
                                           client.name)
 
1562
                            if self.server.use_dbus:
 
1563
                                # Emit D-Bus signal
 
1564
                                client.Rejected("Approval timed out")
 
1565
                            return
 
1566
                        else:
 
1567
                            break
 
1568
                    else:
 
1569
                        delay -= time2 - time
 
1570
                
 
1571
                sent_size = 0
 
1572
                while sent_size < len(client.secret):
 
1573
                    try:
 
1574
                        sent = session.send(client.secret[sent_size:])
 
1575
                    except gnutls.errors.GNUTLSError as error:
 
1576
                        logger.warning("gnutls send failed")
 
1577
                        return
 
1578
                    logger.debug("Sent: %d, remaining: %d",
 
1579
                                 sent, len(client.secret)
 
1580
                                 - (sent_size + sent))
 
1581
                    sent_size += sent
 
1582
                
 
1583
                logger.info("Sending secret to %s", client.name)
 
1584
                # bump the timeout using extended_timeout
 
1585
                client.checked_ok(client.extended_timeout)
 
1586
                if self.server.use_dbus:
 
1587
                    # Emit D-Bus signal
 
1588
                    client.GotSecret()
 
1589
            
 
1590
            finally:
 
1591
                if approval_required:
 
1592
                    client.approvals_pending -= 1
 
1593
                try:
 
1594
                    session.bye()
 
1595
                except gnutls.errors.GNUTLSError as error:
 
1596
                    logger.warning("GnuTLS bye failed")
 
1597
    
 
1598
    @staticmethod
 
1599
    def peer_certificate(session):
 
1600
        "Return the peer's OpenPGP certificate as a bytestring"
 
1601
        # If not an OpenPGP certificate...
 
1602
        if (gnutls.library.functions
 
1603
            .gnutls_certificate_type_get(session._c_object)
 
1604
            != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
 
1605
            # ...do the normal thing
 
1606
            return session.peer_certificate
 
1607
        list_size = ctypes.c_uint(1)
 
1608
        cert_list = (gnutls.library.functions
 
1609
                     .gnutls_certificate_get_peers
 
1610
                     (session._c_object, ctypes.byref(list_size)))
 
1611
        if not bool(cert_list) and list_size.value != 0:
 
1612
            raise gnutls.errors.GNUTLSError("error getting peer"
 
1613
                                            " certificate")
 
1614
        if list_size.value == 0:
 
1615
            return None
 
1616
        cert = cert_list[0]
 
1617
        return ctypes.string_at(cert.data, cert.size)
 
1618
    
 
1619
    @staticmethod
 
1620
    def fingerprint(openpgp):
 
1621
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
 
1622
        # New GnuTLS "datum" with the OpenPGP public key
 
1623
        datum = (gnutls.library.types
 
1624
                 .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
 
1625
                                             ctypes.POINTER
 
1626
                                             (ctypes.c_ubyte)),
 
1627
                                 ctypes.c_uint(len(openpgp))))
 
1628
        # New empty GnuTLS certificate
 
1629
        crt = gnutls.library.types.gnutls_openpgp_crt_t()
 
1630
        (gnutls.library.functions
 
1631
         .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
1632
        # Import the OpenPGP public key into the certificate
 
1633
        (gnutls.library.functions
 
1634
         .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
 
1635
                                    gnutls.library.constants
 
1636
                                    .GNUTLS_OPENPGP_FMT_RAW))
 
1637
        # Verify the self signature in the key
 
1638
        crtverify = ctypes.c_uint()
 
1639
        (gnutls.library.functions
 
1640
         .gnutls_openpgp_crt_verify_self(crt, 0,
 
1641
                                         ctypes.byref(crtverify)))
 
1642
        if crtverify.value != 0:
 
1643
            gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
1644
            raise (gnutls.errors.CertificateSecurityError
 
1645
                   ("Verify failed"))
 
1646
        # New buffer for the fingerprint
 
1647
        buf = ctypes.create_string_buffer(20)
 
1648
        buf_len = ctypes.c_size_t()
 
1649
        # Get the fingerprint from the certificate into the buffer
 
1650
        (gnutls.library.functions
 
1651
         .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
 
1652
                                             ctypes.byref(buf_len)))
 
1653
        # Deinit the certificate
 
1654
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
1655
        # Convert the buffer to a Python bytestring
 
1656
        fpr = ctypes.string_at(buf, buf_len.value)
 
1657
        # Convert the bytestring to hexadecimal notation
 
1658
        hex_fpr = binascii.hexlify(fpr).upper()
 
1659
        return hex_fpr
 
1660
 
 
1661
 
 
1662
class MultiprocessingMixIn(object):
 
1663
    """Like socketserver.ThreadingMixIn, but with multiprocessing"""
 
1664
    def sub_process_main(self, request, address):
 
1665
        try:
 
1666
            self.finish_request(request, address)
 
1667
        except:
 
1668
            self.handle_error(request, address)
 
1669
        self.close_request(request)
 
1670
    
 
1671
    def process_request(self, request, address):
 
1672
        """Start a new process to process the request."""
 
1673
        proc = multiprocessing.Process(target = self.sub_process_main,
 
1674
                                       args = (request,
 
1675
                                               address))
 
1676
        proc.start()
 
1677
        return proc
 
1678
 
 
1679
 
 
1680
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
 
1681
    """ adds a pipe to the MixIn """
 
1682
    def process_request(self, request, client_address):
 
1683
        """Overrides and wraps the original process_request().
 
1684
        
 
1685
        This function creates a new pipe in self.pipe
 
1686
        """
 
1687
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
 
1688
        
 
1689
        proc = MultiprocessingMixIn.process_request(self, request,
 
1690
                                                    client_address)
 
1691
        self.child_pipe.close()
 
1692
        self.add_pipe(parent_pipe, proc)
 
1693
    
 
1694
    def add_pipe(self, parent_pipe, proc):
 
1695
        """Dummy function; override as necessary"""
 
1696
        raise NotImplementedError
 
1697
 
 
1698
 
 
1699
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
 
1700
                     socketserver.TCPServer, object):
 
1701
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
 
1702
    
503
1703
    Attributes:
504
 
        settings:       Server settings
505
 
        clients:        Set() of Client objects
 
1704
        enabled:        Boolean; whether this server is activated yet
 
1705
        interface:      None or a network interface name (string)
 
1706
        use_ipv6:       Boolean; to use IPv6 or not
506
1707
    """
507
 
    address_family = socket.AF_INET6
508
 
    def __init__(self, *args, **kwargs):
509
 
        if "settings" in kwargs:
510
 
            self.settings = kwargs["settings"]
511
 
            del kwargs["settings"]
512
 
        if "clients" in kwargs:
513
 
            self.clients = kwargs["clients"]
514
 
            del kwargs["clients"]
515
 
        return super(type(self), self).__init__(*args, **kwargs)
 
1708
    def __init__(self, server_address, RequestHandlerClass,
 
1709
                 interface=None, use_ipv6=True):
 
1710
        self.interface = interface
 
1711
        if use_ipv6:
 
1712
            self.address_family = socket.AF_INET6
 
1713
        socketserver.TCPServer.__init__(self, server_address,
 
1714
                                        RequestHandlerClass)
516
1715
    def server_bind(self):
517
1716
        """This overrides the normal server_bind() function
518
1717
        to bind to an interface if one was specified, and also NOT to
519
1718
        bind to an address or port if they were not specified."""
520
 
        if self.settings["interface"]:
521
 
            # 25 is from /usr/include/asm-i486/socket.h
522
 
            SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
523
 
            try:
524
 
                self.socket.setsockopt(socket.SOL_SOCKET,
525
 
                                       SO_BINDTODEVICE,
526
 
                                       self.settings["interface"])
527
 
            except socket.error, error:
528
 
                if error[0] == errno.EPERM:
529
 
                    logger.error(u"No permission to"
530
 
                                 u" bind to interface %s",
531
 
                                 self.settings["interface"])
532
 
                else:
533
 
                    raise error
 
1719
        if self.interface is not None:
 
1720
            if SO_BINDTODEVICE is None:
 
1721
                logger.error("SO_BINDTODEVICE does not exist;"
 
1722
                             " cannot bind to interface %s",
 
1723
                             self.interface)
 
1724
            else:
 
1725
                try:
 
1726
                    self.socket.setsockopt(socket.SOL_SOCKET,
 
1727
                                           SO_BINDTODEVICE,
 
1728
                                           str(self.interface
 
1729
                                               + '\0'))
 
1730
                except socket.error as error:
 
1731
                    if error[0] == errno.EPERM:
 
1732
                        logger.error("No permission to"
 
1733
                                     " bind to interface %s",
 
1734
                                     self.interface)
 
1735
                    elif error[0] == errno.ENOPROTOOPT:
 
1736
                        logger.error("SO_BINDTODEVICE not available;"
 
1737
                                     " cannot bind to interface %s",
 
1738
                                     self.interface)
 
1739
                    else:
 
1740
                        raise
534
1741
        # Only bind(2) the socket if we really need to.
535
1742
        if self.server_address[0] or self.server_address[1]:
536
1743
            if not self.server_address[0]:
537
 
                in6addr_any = "::"
538
 
                self.server_address = (in6addr_any,
 
1744
                if self.address_family == socket.AF_INET6:
 
1745
                    any_address = "::" # in6addr_any
 
1746
                else:
 
1747
                    any_address = socket.INADDR_ANY
 
1748
                self.server_address = (any_address,
539
1749
                                       self.server_address[1])
540
1750
            elif not self.server_address[1]:
541
1751
                self.server_address = (self.server_address[0],
542
1752
                                       0)
543
 
#                 if self.settings["interface"]:
 
1753
#                 if self.interface:
544
1754
#                     self.server_address = (self.server_address[0],
545
1755
#                                            0, # port
546
1756
#                                            0, # flowinfo
547
1757
#                                            if_nametoindex
548
 
#                                            (self.settings
549
 
#                                             ["interface"]))
550
 
            return super(type(self), self).server_bind()
 
1758
#                                            (self.interface))
 
1759
            return socketserver.TCPServer.server_bind(self)
 
1760
 
 
1761
 
 
1762
class MandosServer(IPv6_TCPServer):
 
1763
    """Mandos server.
 
1764
    
 
1765
    Attributes:
 
1766
        clients:        set of Client objects
 
1767
        gnutls_priority GnuTLS priority string
 
1768
        use_dbus:       Boolean; to emit D-Bus signals or not
 
1769
    
 
1770
    Assumes a gobject.MainLoop event loop.
 
1771
    """
 
1772
    def __init__(self, server_address, RequestHandlerClass,
 
1773
                 interface=None, use_ipv6=True, clients=None,
 
1774
                 gnutls_priority=None, use_dbus=True):
 
1775
        self.enabled = False
 
1776
        self.clients = clients
 
1777
        if self.clients is None:
 
1778
            self.clients = {}
 
1779
        self.use_dbus = use_dbus
 
1780
        self.gnutls_priority = gnutls_priority
 
1781
        IPv6_TCPServer.__init__(self, server_address,
 
1782
                                RequestHandlerClass,
 
1783
                                interface = interface,
 
1784
                                use_ipv6 = use_ipv6)
 
1785
    def server_activate(self):
 
1786
        if self.enabled:
 
1787
            return socketserver.TCPServer.server_activate(self)
 
1788
    
 
1789
    def enable(self):
 
1790
        self.enabled = True
 
1791
    
 
1792
    def add_pipe(self, parent_pipe, proc):
 
1793
        # Call "handle_ipc" for both data and EOF events
 
1794
        gobject.io_add_watch(parent_pipe.fileno(),
 
1795
                             gobject.IO_IN | gobject.IO_HUP,
 
1796
                             functools.partial(self.handle_ipc,
 
1797
                                               parent_pipe =
 
1798
                                               parent_pipe,
 
1799
                                               proc = proc))
 
1800
    
 
1801
    def handle_ipc(self, source, condition, parent_pipe=None,
 
1802
                   proc = None, client_object=None):
 
1803
        condition_names = {
 
1804
            gobject.IO_IN: "IN",   # There is data to read.
 
1805
            gobject.IO_OUT: "OUT", # Data can be written (without
 
1806
                                    # blocking).
 
1807
            gobject.IO_PRI: "PRI", # There is urgent data to read.
 
1808
            gobject.IO_ERR: "ERR", # Error condition.
 
1809
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
 
1810
                                    # broken, usually for pipes and
 
1811
                                    # sockets).
 
1812
            }
 
1813
        conditions_string = ' | '.join(name
 
1814
                                       for cond, name in
 
1815
                                       condition_names.iteritems()
 
1816
                                       if cond & condition)
 
1817
        # error, or the other end of multiprocessing.Pipe has closed
 
1818
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
1819
            # Wait for other process to exit
 
1820
            proc.join()
 
1821
            return False
 
1822
        
 
1823
        # Read a request from the child
 
1824
        request = parent_pipe.recv()
 
1825
        command = request[0]
 
1826
        
 
1827
        if command == 'init':
 
1828
            fpr = request[1]
 
1829
            address = request[2]
 
1830
            
 
1831
            for c in self.clients.itervalues():
 
1832
                if c.fingerprint == fpr:
 
1833
                    client = c
 
1834
                    break
 
1835
            else:
 
1836
                logger.info("Client not found for fingerprint: %s, ad"
 
1837
                            "dress: %s", fpr, address)
 
1838
                if self.use_dbus:
 
1839
                    # Emit D-Bus signal
 
1840
                    mandos_dbus_service.ClientNotFound(fpr,
 
1841
                                                       address[0])
 
1842
                parent_pipe.send(False)
 
1843
                return False
 
1844
            
 
1845
            gobject.io_add_watch(parent_pipe.fileno(),
 
1846
                                 gobject.IO_IN | gobject.IO_HUP,
 
1847
                                 functools.partial(self.handle_ipc,
 
1848
                                                   parent_pipe =
 
1849
                                                   parent_pipe,
 
1850
                                                   proc = proc,
 
1851
                                                   client_object =
 
1852
                                                   client))
 
1853
            parent_pipe.send(True)
 
1854
            # remove the old hook in favor of the new above hook on
 
1855
            # same fileno
 
1856
            return False
 
1857
        if command == 'funcall':
 
1858
            funcname = request[1]
 
1859
            args = request[2]
 
1860
            kwargs = request[3]
 
1861
            
 
1862
            parent_pipe.send(('data', getattr(client_object,
 
1863
                                              funcname)(*args,
 
1864
                                                         **kwargs)))
 
1865
        
 
1866
        if command == 'getattr':
 
1867
            attrname = request[1]
 
1868
            if callable(client_object.__getattribute__(attrname)):
 
1869
                parent_pipe.send(('function',))
 
1870
            else:
 
1871
                parent_pipe.send(('data', client_object
 
1872
                                  .__getattribute__(attrname)))
 
1873
        
 
1874
        if command == 'setattr':
 
1875
            attrname = request[1]
 
1876
            value = request[2]
 
1877
            setattr(client_object, attrname, value)
 
1878
        
 
1879
        return True
551
1880
 
552
1881
 
553
1882
def string_to_delta(interval):
554
1883
    """Parse a string and return a datetime.timedelta
555
 
 
 
1884
    
556
1885
    >>> string_to_delta('7d')
557
1886
    datetime.timedelta(7)
558
1887
    >>> string_to_delta('60s')
561
1890
    datetime.timedelta(0, 3600)
562
1891
    >>> string_to_delta('24h')
563
1892
    datetime.timedelta(1)
564
 
    >>> string_to_delta(u'1w')
 
1893
    >>> string_to_delta('1w')
565
1894
    datetime.timedelta(7)
 
1895
    >>> string_to_delta('5m 30s')
 
1896
    datetime.timedelta(0, 330)
566
1897
    """
567
 
    try:
568
 
        suffix=unicode(interval[-1])
569
 
        value=int(interval[:-1])
570
 
        if suffix == u"d":
571
 
            delta = datetime.timedelta(value)
572
 
        elif suffix == u"s":
573
 
            delta = datetime.timedelta(0, value)
574
 
        elif suffix == u"m":
575
 
            delta = datetime.timedelta(0, 0, 0, 0, value)
576
 
        elif suffix == u"h":
577
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, value)
578
 
        elif suffix == u"w":
579
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
580
 
        else:
581
 
            raise ValueError
582
 
    except (ValueError, IndexError):
583
 
        raise ValueError
584
 
    return delta
585
 
 
586
 
 
587
 
def server_state_changed(state):
588
 
    """Derived from the Avahi example code"""
589
 
    if state == avahi.SERVER_COLLISION:
590
 
        logger.error(u"Server name collision")
591
 
        service.remove()
592
 
    elif state == avahi.SERVER_RUNNING:
593
 
        service.add()
594
 
 
595
 
 
596
 
def entry_group_state_changed(state, error):
597
 
    """Derived from the Avahi example code"""
598
 
    logger.debug(u"state change: %i", state)
599
 
    
600
 
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
601
 
        logger.debug(u"Service established.")
602
 
    elif state == avahi.ENTRY_GROUP_COLLISION:
603
 
        logger.warning(u"Service name collision.")
604
 
        service.rename()
605
 
    elif state == avahi.ENTRY_GROUP_FAILURE:
606
 
        logger.critical(u"Error in group state changed %s",
607
 
                        unicode(error))
608
 
        raise AvahiGroupError("State changed: %s", str(error))
609
 
 
610
 
def if_nametoindex(interface):
611
 
    """Call the C function if_nametoindex(), or equivalent"""
612
 
    global if_nametoindex
613
 
    try:
614
 
        if "ctypes.util" not in sys.modules:
615
 
            import ctypes.util
616
 
        if_nametoindex = ctypes.cdll.LoadLibrary\
617
 
            (ctypes.util.find_library("c")).if_nametoindex
618
 
    except (OSError, AttributeError):
619
 
        if "struct" not in sys.modules:
620
 
            import struct
621
 
        if "fcntl" not in sys.modules:
622
 
            import fcntl
623
 
        def if_nametoindex(interface):
624
 
            "Get an interface index the hard way, i.e. using fcntl()"
625
 
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
626
 
            s = socket.socket()
627
 
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
628
 
                                struct.pack("16s16x", interface))
629
 
            s.close()
630
 
            interface_index = struct.unpack("I", ifreq[16:20])[0]
631
 
            return interface_index
632
 
    return if_nametoindex(interface)
 
1898
    timevalue = datetime.timedelta(0)
 
1899
    for s in interval.split():
 
1900
        try:
 
1901
            suffix = unicode(s[-1])
 
1902
            value = int(s[:-1])
 
1903
            if suffix == "d":
 
1904
                delta = datetime.timedelta(value)
 
1905
            elif suffix == "s":
 
1906
                delta = datetime.timedelta(0, value)
 
1907
            elif suffix == "m":
 
1908
                delta = datetime.timedelta(0, 0, 0, 0, value)
 
1909
            elif suffix == "h":
 
1910
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
 
1911
            elif suffix == "w":
 
1912
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
 
1913
            else:
 
1914
                raise ValueError("Unknown suffix %r" % suffix)
 
1915
        except (ValueError, IndexError) as e:
 
1916
            raise ValueError(*(e.args))
 
1917
        timevalue += delta
 
1918
    return timevalue
633
1919
 
634
1920
 
635
1921
def daemon(nochdir = False, noclose = False):
636
1922
    """See daemon(3).  Standard BSD Unix function.
 
1923
    
637
1924
    This should really exist as os.daemon, but it doesn't (yet)."""
638
1925
    if os.fork():
639
1926
        sys.exit()
647
1934
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
648
1935
        if not stat.S_ISCHR(os.fstat(null).st_mode):
649
1936
            raise OSError(errno.ENODEV,
650
 
                          "/dev/null not a character device")
 
1937
                          "%s not a character device"
 
1938
                          % os.path.devnull)
651
1939
        os.dup2(null, sys.stdin.fileno())
652
1940
        os.dup2(null, sys.stdout.fileno())
653
1941
        os.dup2(null, sys.stderr.fileno())
656
1944
 
657
1945
 
658
1946
def main():
659
 
    global main_loop_started
660
 
    main_loop_started = False
661
 
    
662
 
    parser = OptionParser(version = "%%prog %s" % version)
663
 
    parser.add_option("-i", "--interface", type="string",
664
 
                      metavar="IF", help="Bind to interface IF")
665
 
    parser.add_option("-a", "--address", type="string",
666
 
                      help="Address to listen for requests on")
667
 
    parser.add_option("-p", "--port", type="int",
668
 
                      help="Port number to receive requests on")
669
 
    parser.add_option("--check", action="store_true", default=False,
670
 
                      help="Run self-test")
671
 
    parser.add_option("--debug", action="store_true",
672
 
                      help="Debug mode; run in foreground and log to"
673
 
                      " terminal")
674
 
    parser.add_option("--priority", type="string", help="GnuTLS"
675
 
                      " priority string (see GnuTLS documentation)")
676
 
    parser.add_option("--servicename", type="string", metavar="NAME",
677
 
                      help="Zeroconf service name")
678
 
    parser.add_option("--configdir", type="string",
679
 
                      default="/etc/mandos", metavar="DIR",
680
 
                      help="Directory to search for configuration"
681
 
                      " files")
682
 
    (options, args) = parser.parse_args()
 
1947
    
 
1948
    ##################################################################
 
1949
    # Parsing of options, both command line and config file
 
1950
    
 
1951
    parser = argparse.ArgumentParser()
 
1952
    parser.add_argument("-v", "--version", action="version",
 
1953
                        version = "%%(prog)s %s" % version,
 
1954
                        help="show version number and exit")
 
1955
    parser.add_argument("-i", "--interface", metavar="IF",
 
1956
                        help="Bind to interface IF")
 
1957
    parser.add_argument("-a", "--address",
 
1958
                        help="Address to listen for requests on")
 
1959
    parser.add_argument("-p", "--port", type=int,
 
1960
                        help="Port number to receive requests on")
 
1961
    parser.add_argument("--check", action="store_true",
 
1962
                        help="Run self-test")
 
1963
    parser.add_argument("--debug", action="store_true",
 
1964
                        help="Debug mode; run in foreground and log"
 
1965
                        " to terminal")
 
1966
    parser.add_argument("--debuglevel", metavar="LEVEL",
 
1967
                        help="Debug level for stdout output")
 
1968
    parser.add_argument("--priority", help="GnuTLS"
 
1969
                        " priority string (see GnuTLS documentation)")
 
1970
    parser.add_argument("--servicename",
 
1971
                        metavar="NAME", help="Zeroconf service name")
 
1972
    parser.add_argument("--configdir",
 
1973
                        default="/etc/mandos", metavar="DIR",
 
1974
                        help="Directory to search for configuration"
 
1975
                        " files")
 
1976
    parser.add_argument("--no-dbus", action="store_false",
 
1977
                        dest="use_dbus", help="Do not provide D-Bus"
 
1978
                        " system bus interface")
 
1979
    parser.add_argument("--no-ipv6", action="store_false",
 
1980
                        dest="use_ipv6", help="Do not use IPv6")
 
1981
    parser.add_argument("--no-restore", action="store_false",
 
1982
                        dest="restore", help="Do not restore stored"
 
1983
                        " state")
 
1984
    parser.add_argument("--statedir", metavar="DIR",
 
1985
                        help="Directory to save/restore state in")
 
1986
    
 
1987
    options = parser.parse_args()
683
1988
    
684
1989
    if options.check:
685
1990
        import doctest
694
1999
                        "priority":
695
2000
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
696
2001
                        "servicename": "Mandos",
 
2002
                        "use_dbus": "True",
 
2003
                        "use_ipv6": "True",
 
2004
                        "debuglevel": "",
 
2005
                        "restore": "True",
 
2006
                        "statedir": "/var/lib/mandos"
697
2007
                        }
698
2008
    
699
2009
    # Parse config file for server-global settings
700
 
    server_config = ConfigParser.SafeConfigParser(server_defaults)
 
2010
    server_config = configparser.SafeConfigParser(server_defaults)
701
2011
    del server_defaults
702
 
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
703
 
    server_section = "server"
 
2012
    server_config.read(os.path.join(options.configdir,
 
2013
                                    "mandos.conf"))
704
2014
    # Convert the SafeConfigParser object to a dict
705
 
    server_settings = dict(server_config.items(server_section))
706
 
    # Use getboolean on the boolean config option
707
 
    server_settings["debug"] = server_config.getboolean\
708
 
                               (server_section, "debug")
 
2015
    server_settings = server_config.defaults()
 
2016
    # Use the appropriate methods on the non-string config options
 
2017
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2018
        server_settings[option] = server_config.getboolean("DEFAULT",
 
2019
                                                           option)
 
2020
    if server_settings["port"]:
 
2021
        server_settings["port"] = server_config.getint("DEFAULT",
 
2022
                                                       "port")
709
2023
    del server_config
710
2024
    
711
2025
    # Override the settings from the config file with command line
712
2026
    # options, if set.
713
2027
    for option in ("interface", "address", "port", "debug",
714
 
                   "priority", "servicename", "configdir"):
 
2028
                   "priority", "servicename", "configdir",
 
2029
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
 
2030
                   "statedir"):
715
2031
        value = getattr(options, option)
716
2032
        if value is not None:
717
2033
            server_settings[option] = value
718
2034
    del options
 
2035
    # Force all strings to be unicode
 
2036
    for option in server_settings.keys():
 
2037
        if type(server_settings[option]) is str:
 
2038
            server_settings[option] = unicode(server_settings[option])
719
2039
    # Now we have our good server settings in "server_settings"
720
2040
    
 
2041
    ##################################################################
 
2042
    
 
2043
    # For convenience
721
2044
    debug = server_settings["debug"]
 
2045
    debuglevel = server_settings["debuglevel"]
 
2046
    use_dbus = server_settings["use_dbus"]
 
2047
    use_ipv6 = server_settings["use_ipv6"]
 
2048
    stored_state_path = os.path.join(server_settings["statedir"],
 
2049
                                     stored_state_file)
722
2050
    
723
 
    if not debug:
724
 
        syslogger.setLevel(logging.WARNING)
725
 
        console.setLevel(logging.WARNING)
 
2051
    if debug:
 
2052
        initlogger(logging.DEBUG)
 
2053
    else:
 
2054
        if not debuglevel:
 
2055
            initlogger()
 
2056
        else:
 
2057
            level = getattr(logging, debuglevel.upper())
 
2058
            initlogger(level)
726
2059
    
727
2060
    if server_settings["servicename"] != "Mandos":
728
 
        syslogger.setFormatter(logging.Formatter\
729
 
                               ('Mandos (%s): %%(levelname)s:'
730
 
                                ' %%(message)s'
 
2061
        syslogger.setFormatter(logging.Formatter
 
2062
                               ('Mandos (%s) [%%(process)d]:'
 
2063
                                ' %%(levelname)s: %%(message)s'
731
2064
                                % server_settings["servicename"]))
732
2065
    
733
2066
    # Parse config file with clients
734
 
    client_defaults = { "timeout": "1h",
735
 
                        "interval": "5m",
 
2067
    client_defaults = { "timeout": "5m",
 
2068
                        "extended_timeout": "15m",
 
2069
                        "interval": "2m",
736
2070
                        "checker": "fping -q -- %%(host)s",
 
2071
                        "host": "",
 
2072
                        "approval_delay": "0s",
 
2073
                        "approval_duration": "1s",
737
2074
                        }
738
 
    client_config = ConfigParser.SafeConfigParser(client_defaults)
 
2075
    client_config = configparser.SafeConfigParser(client_defaults)
739
2076
    client_config.read(os.path.join(server_settings["configdir"],
740
2077
                                    "clients.conf"))
741
2078
    
742
 
    global service
743
 
    service = AvahiService(name = server_settings["servicename"],
744
 
                           type = "_mandos._tcp", );
745
 
    if server_settings["interface"]:
746
 
        service.interface = if_nametoindex(server_settings["interface"])
 
2079
    global mandos_dbus_service
 
2080
    mandos_dbus_service = None
 
2081
    
 
2082
    tcp_server = MandosServer((server_settings["address"],
 
2083
                               server_settings["port"]),
 
2084
                              ClientHandler,
 
2085
                              interface=(server_settings["interface"]
 
2086
                                         or None),
 
2087
                              use_ipv6=use_ipv6,
 
2088
                              gnutls_priority=
 
2089
                              server_settings["priority"],
 
2090
                              use_dbus=use_dbus)
 
2091
    if not debug:
 
2092
        pidfilename = "/var/run/mandos.pid"
 
2093
        try:
 
2094
            pidfile = open(pidfilename, "w")
 
2095
        except IOError:
 
2096
            logger.error("Could not open file %r", pidfilename)
 
2097
    
 
2098
    try:
 
2099
        uid = pwd.getpwnam("_mandos").pw_uid
 
2100
        gid = pwd.getpwnam("_mandos").pw_gid
 
2101
    except KeyError:
 
2102
        try:
 
2103
            uid = pwd.getpwnam("mandos").pw_uid
 
2104
            gid = pwd.getpwnam("mandos").pw_gid
 
2105
        except KeyError:
 
2106
            try:
 
2107
                uid = pwd.getpwnam("nobody").pw_uid
 
2108
                gid = pwd.getpwnam("nobody").pw_gid
 
2109
            except KeyError:
 
2110
                uid = 65534
 
2111
                gid = 65534
 
2112
    try:
 
2113
        os.setgid(gid)
 
2114
        os.setuid(uid)
 
2115
    except OSError as error:
 
2116
        if error[0] != errno.EPERM:
 
2117
            raise error
 
2118
    
 
2119
    if debug:
 
2120
        # Enable all possible GnuTLS debugging
 
2121
        
 
2122
        # "Use a log level over 10 to enable all debugging options."
 
2123
        # - GnuTLS manual
 
2124
        gnutls.library.functions.gnutls_global_set_log_level(11)
 
2125
        
 
2126
        @gnutls.library.types.gnutls_log_func
 
2127
        def debug_gnutls(level, string):
 
2128
            logger.debug("GnuTLS: %s", string[:-1])
 
2129
        
 
2130
        (gnutls.library.functions
 
2131
         .gnutls_global_set_log_function(debug_gnutls))
 
2132
        
 
2133
        # Redirect stdin so all checkers get /dev/null
 
2134
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2135
        os.dup2(null, sys.stdin.fileno())
 
2136
        if null > 2:
 
2137
            os.close(null)
 
2138
    else:
 
2139
        # No console logging
 
2140
        logger.removeHandler(console)
 
2141
    
 
2142
    # Need to fork before connecting to D-Bus
 
2143
    if not debug:
 
2144
        # Close all input and output, do double fork, etc.
 
2145
        daemon()
747
2146
    
748
2147
    global main_loop
749
 
    global bus
750
 
    global server
751
2148
    # From the Avahi example code
752
2149
    DBusGMainLoop(set_as_default=True )
753
2150
    main_loop = gobject.MainLoop()
754
2151
    bus = dbus.SystemBus()
755
 
    server = dbus.Interface(
756
 
            bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
757
 
            avahi.DBUS_INTERFACE_SERVER )
758
2152
    # End of Avahi example code
759
 
    
760
 
    clients = Set()
761
 
    def remove_from_clients(client):
762
 
        clients.remove(client)
763
 
        if not clients:
764
 
            logger.critical(u"No clients left, exiting")
765
 
            sys.exit()
766
 
    
767
 
    clients.update(Set(Client(name = section,
768
 
                              stop_hook = remove_from_clients,
769
 
                              config
770
 
                              = dict(client_config.items(section)))
771
 
                       for section in client_config.sections()))
772
 
    if not clients:
773
 
        logger.critical(u"No clients defined")
774
 
        sys.exit(1)
775
 
    
 
2153
    if use_dbus:
 
2154
        try:
 
2155
            bus_name = dbus.service.BusName("se.recompile.Mandos",
 
2156
                                            bus, do_not_queue=True)
 
2157
            old_bus_name = (dbus.service.BusName
 
2158
                            ("se.bsnet.fukt.Mandos", bus,
 
2159
                             do_not_queue=True))
 
2160
        except dbus.exceptions.NameExistsException as e:
 
2161
            logger.error(unicode(e) + ", disabling D-Bus")
 
2162
            use_dbus = False
 
2163
            server_settings["use_dbus"] = False
 
2164
            tcp_server.use_dbus = False
 
2165
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
2166
    service = AvahiServiceToSyslog(name =
 
2167
                                   server_settings["servicename"],
 
2168
                                   servicetype = "_mandos._tcp",
 
2169
                                   protocol = protocol, bus = bus)
 
2170
    if server_settings["interface"]:
 
2171
        service.interface = (if_nametoindex
 
2172
                             (str(server_settings["interface"])))
 
2173
    
 
2174
    global multiprocessing_manager
 
2175
    multiprocessing_manager = multiprocessing.Manager()
 
2176
    
 
2177
    client_class = Client
 
2178
    if use_dbus:
 
2179
        client_class = functools.partial(ClientDBusTransitional,
 
2180
                                         bus = bus)
 
2181
    
 
2182
    special_settings = {
 
2183
        # Some settings need to be accessd by special methods;
 
2184
        # booleans need .getboolean(), etc.  Here is a list of them:
 
2185
        "approved_by_default":
 
2186
            lambda section:
 
2187
            client_config.getboolean(section, "approved_by_default"),
 
2188
        "enabled":
 
2189
            lambda section:
 
2190
            client_config.getboolean(section, "enabled"),
 
2191
        }
 
2192
    # Construct a new dict of client settings of this form:
 
2193
    # { client_name: {setting_name: value, ...}, ...}
 
2194
    # with exceptions for any special settings as defined above
 
2195
    client_settings = dict((clientname,
 
2196
                           dict((setting,
 
2197
                                 (value
 
2198
                                  if setting not in special_settings
 
2199
                                  else special_settings[setting]
 
2200
                                  (clientname)))
 
2201
                                for setting, value in
 
2202
                                client_config.items(clientname)))
 
2203
                          for clientname in client_config.sections())
 
2204
    
 
2205
    old_client_settings = {}
 
2206
    clients_data = []
 
2207
    
 
2208
    # Get client data and settings from last running state.
 
2209
    if server_settings["restore"]:
 
2210
        try:
 
2211
            with open(stored_state_path, "rb") as stored_state:
 
2212
                clients_data, old_client_settings = (pickle.load
 
2213
                                                     (stored_state))
 
2214
            os.remove(stored_state_path)
 
2215
        except IOError as e:
 
2216
            logger.warning("Could not load persistent state: {0}"
 
2217
                           .format(e))
 
2218
            if e.errno != errno.ENOENT:
 
2219
                raise
 
2220
    
 
2221
    with Crypto() as crypt:
 
2222
        for client in clients_data:
 
2223
            client_name = client["name"]
 
2224
            
 
2225
            # Decide which value to use after restoring saved state.
 
2226
            # We have three different values: Old config file,
 
2227
            # new config file, and saved state.
 
2228
            # New config value takes precedence if it differs from old
 
2229
            # config value, otherwise use saved state.
 
2230
            for name, value in client_settings[client_name].items():
 
2231
                try:
 
2232
                    # For each value in new config, check if it
 
2233
                    # differs from the old config value (Except for
 
2234
                    # the "secret" attribute)
 
2235
                    if (name != "secret" and
 
2236
                        value != old_client_settings[client_name]
 
2237
                        [name]):
 
2238
                        setattr(client, name, value)
 
2239
                except KeyError:
 
2240
                    pass
 
2241
            
 
2242
            # Clients who has passed its expire date can still be
 
2243
            # enabled if its last checker was sucessful.  Clients
 
2244
            # whose checker failed before we stored its state is
 
2245
            # assumed to have failed all checkers during downtime.
 
2246
            if client["enabled"] and client["last_checked_ok"]:
 
2247
                if ((datetime.datetime.utcnow()
 
2248
                     - client["last_checked_ok"])
 
2249
                    > client["interval"]):
 
2250
                    if client["last_checker_status"] != 0:
 
2251
                        client["enabled"] = False
 
2252
                    else:
 
2253
                        client["expires"] = (datetime.datetime
 
2254
                                             .utcnow()
 
2255
                                             + client["timeout"])
 
2256
            
 
2257
            client["changedstate"] = (multiprocessing_manager
 
2258
                                      .Condition
 
2259
                                      (multiprocessing_manager
 
2260
                                       .Lock()))
 
2261
            if use_dbus:
 
2262
                new_client = (ClientDBusTransitional.__new__
 
2263
                              (ClientDBusTransitional))
 
2264
                tcp_server.clients[client_name] = new_client
 
2265
                new_client.bus = bus
 
2266
                for name, value in client.iteritems():
 
2267
                    setattr(new_client, name, value)
 
2268
                client_object_name = unicode(client_name).translate(
 
2269
                    {ord("."): ord("_"),
 
2270
                     ord("-"): ord("_")})
 
2271
                new_client.dbus_object_path = (dbus.ObjectPath
 
2272
                                               ("/clients/"
 
2273
                                                + client_object_name))
 
2274
                DBusObjectWithProperties.__init__(new_client,
 
2275
                                                  new_client.bus,
 
2276
                                                  new_client
 
2277
                                                  .dbus_object_path)
 
2278
            else:
 
2279
                tcp_server.clients[client_name] = (Client.__new__
 
2280
                                                   (Client))
 
2281
                for name, value in client.iteritems():
 
2282
                    setattr(tcp_server.clients[client_name],
 
2283
                            name, value)
 
2284
            
 
2285
            try:
 
2286
                tcp_server.clients[client_name].secret = (
 
2287
                    crypt.decrypt(tcp_server.clients[client_name]
 
2288
                                  .encrypted_secret,
 
2289
                                  client_settings[client_name]
 
2290
                                  ["secret"]))
 
2291
            except CryptoError:
 
2292
                # If decryption fails, we use secret from new settings
 
2293
                tcp_server.clients[client_name].secret = (
 
2294
                    client_settings[client_name]["secret"])
 
2295
    
 
2296
    # Create/remove clients based on new changes made to config
 
2297
    for clientname in set(old_client_settings) - set(client_settings):
 
2298
        del tcp_server.clients[clientname]
 
2299
    for clientname in set(client_settings) - set(old_client_settings):
 
2300
        tcp_server.clients[clientname] = (client_class(name
 
2301
                                                       = clientname,
 
2302
                                                       config =
 
2303
                                                       client_settings
 
2304
                                                       [clientname]))
 
2305
    
 
2306
    if not tcp_server.clients:
 
2307
        logger.warning("No clients defined")
 
2308
        
776
2309
    if not debug:
777
 
        logger.removeHandler(console)
778
 
        daemon()
779
 
    
780
 
    pidfilename = "/var/run/mandos/mandos.pid"
781
 
    pid = os.getpid()
782
 
    try:
783
 
        pidfile = open(pidfilename, "w")
784
 
        pidfile.write(str(pid) + "\n")
785
 
        pidfile.close()
786
 
        del pidfile
787
 
    except IOError, err:
788
 
        logger.error(u"Could not write %s file with PID %d",
789
 
                     pidfilename, os.getpid())
 
2310
        try:
 
2311
            with pidfile:
 
2312
                pid = os.getpid()
 
2313
                pidfile.write(str(pid) + "\n".encode("utf-8"))
 
2314
            del pidfile
 
2315
        except IOError:
 
2316
            logger.error("Could not write to file %r with PID %d",
 
2317
                         pidfilename, pid)
 
2318
        except NameError:
 
2319
            # "pidfile" was never created
 
2320
            pass
 
2321
        del pidfilename
 
2322
        
 
2323
        signal.signal(signal.SIGINT, signal.SIG_IGN)
 
2324
    
 
2325
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
 
2326
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
 
2327
    
 
2328
    if use_dbus:
 
2329
        class MandosDBusService(dbus.service.Object):
 
2330
            """A D-Bus proxy object"""
 
2331
            def __init__(self):
 
2332
                dbus.service.Object.__init__(self, bus, "/")
 
2333
            _interface = "se.recompile.Mandos"
 
2334
            
 
2335
            @dbus.service.signal(_interface, signature="o")
 
2336
            def ClientAdded(self, objpath):
 
2337
                "D-Bus signal"
 
2338
                pass
 
2339
            
 
2340
            @dbus.service.signal(_interface, signature="ss")
 
2341
            def ClientNotFound(self, fingerprint, address):
 
2342
                "D-Bus signal"
 
2343
                pass
 
2344
            
 
2345
            @dbus.service.signal(_interface, signature="os")
 
2346
            def ClientRemoved(self, objpath, name):
 
2347
                "D-Bus signal"
 
2348
                pass
 
2349
            
 
2350
            @dbus.service.method(_interface, out_signature="ao")
 
2351
            def GetAllClients(self):
 
2352
                "D-Bus method"
 
2353
                return dbus.Array(c.dbus_object_path
 
2354
                                  for c in
 
2355
                                  tcp_server.clients.itervalues())
 
2356
            
 
2357
            @dbus.service.method(_interface,
 
2358
                                 out_signature="a{oa{sv}}")
 
2359
            def GetAllClientsWithProperties(self):
 
2360
                "D-Bus method"
 
2361
                return dbus.Dictionary(
 
2362
                    ((c.dbus_object_path, c.GetAll(""))
 
2363
                     for c in tcp_server.clients.itervalues()),
 
2364
                    signature="oa{sv}")
 
2365
            
 
2366
            @dbus.service.method(_interface, in_signature="o")
 
2367
            def RemoveClient(self, object_path):
 
2368
                "D-Bus method"
 
2369
                for c in tcp_server.clients.itervalues():
 
2370
                    if c.dbus_object_path == object_path:
 
2371
                        del tcp_server.clients[c.name]
 
2372
                        c.remove_from_connection()
 
2373
                        # Don't signal anything except ClientRemoved
 
2374
                        c.disable(quiet=True)
 
2375
                        # Emit D-Bus signal
 
2376
                        self.ClientRemoved(object_path, c.name)
 
2377
                        return
 
2378
                raise KeyError(object_path)
 
2379
            
 
2380
            del _interface
 
2381
        
 
2382
        class MandosDBusServiceTransitional(MandosDBusService):
 
2383
            __metaclass__ = AlternateDBusNamesMetaclass
 
2384
        mandos_dbus_service = MandosDBusServiceTransitional()
790
2385
    
791
2386
    def cleanup():
792
2387
        "Cleanup function; run on exit"
793
 
        global group
794
 
        # From the Avahi example code
795
 
        if not group is None:
796
 
            group.Free()
797
 
            group = None
798
 
        # End of Avahi example code
799
 
        
800
 
        while clients:
801
 
            client = clients.pop()
802
 
            client.stop_hook = None
803
 
            client.stop()
 
2388
        service.cleanup()
 
2389
        
 
2390
        multiprocessing.active_children()
 
2391
        if not (tcp_server.clients or client_settings):
 
2392
            return
 
2393
        
 
2394
        # Store client before exiting. Secrets are encrypted with key
 
2395
        # based on what config file has. If config file is
 
2396
        # removed/edited, old secret will thus be unrecovable.
 
2397
        clients = []
 
2398
        with Crypto() as crypt:
 
2399
            for client in tcp_server.clients.itervalues():
 
2400
                key = client_settings[client.name]["secret"]
 
2401
                client.encrypted_secret = crypt.encrypt(client.secret,
 
2402
                                                        key)
 
2403
                client_dict = {}
 
2404
                
 
2405
                # A list of attributes that will not be stored when
 
2406
                # shutting down.
 
2407
                exclude = set(("bus", "changedstate", "secret"))
 
2408
                for name, typ in (inspect.getmembers
 
2409
                                  (dbus.service.Object)):
 
2410
                    exclude.add(name)
 
2411
                
 
2412
                client_dict["encrypted_secret"] = (client
 
2413
                                                   .encrypted_secret)
 
2414
                for attr in client.client_structure:
 
2415
                    if attr not in exclude:
 
2416
                        client_dict[attr] = getattr(client, attr)
 
2417
                
 
2418
                clients.append(client_dict)
 
2419
                del client_settings[client.name]["secret"]
 
2420
        
 
2421
        try:
 
2422
            with os.fdopen(os.open(stored_state_path,
 
2423
                                   os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
 
2424
                                   0600), "wb") as stored_state:
 
2425
                pickle.dump((clients, client_settings), stored_state)
 
2426
        except (IOError, OSError) as e:
 
2427
            logger.warning("Could not save persistent state: {0}"
 
2428
                           .format(e))
 
2429
            if e.errno not in (errno.ENOENT, errno.EACCES):
 
2430
                raise
 
2431
        
 
2432
        # Delete all clients, and settings from config
 
2433
        while tcp_server.clients:
 
2434
            name, client = tcp_server.clients.popitem()
 
2435
            if use_dbus:
 
2436
                client.remove_from_connection()
 
2437
            # Don't signal anything except ClientRemoved
 
2438
            client.disable(quiet=True)
 
2439
            if use_dbus:
 
2440
                # Emit D-Bus signal
 
2441
                mandos_dbus_service.ClientRemoved(client
 
2442
                                                  .dbus_object_path,
 
2443
                                                  client.name)
 
2444
        client_settings.clear()
804
2445
    
805
2446
    atexit.register(cleanup)
806
2447
    
807
 
    if not debug:
808
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
809
 
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
810
 
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
811
 
    
812
 
    for client in clients:
813
 
        client.start()
814
 
    
815
 
    tcp_server = IPv6_TCPServer((server_settings["address"],
816
 
                                 server_settings["port"]),
817
 
                                tcp_handler,
818
 
                                settings=server_settings,
819
 
                                clients=clients)
 
2448
    for client in tcp_server.clients.itervalues():
 
2449
        if use_dbus:
 
2450
            # Emit D-Bus signal
 
2451
            mandos_dbus_service.ClientAdded(client.dbus_object_path)
 
2452
        # Need to initiate checking of clients
 
2453
        if client.enabled:
 
2454
            client.init_checker()
 
2455
    
 
2456
    tcp_server.enable()
 
2457
    tcp_server.server_activate()
 
2458
    
820
2459
    # Find out what port we got
821
2460
    service.port = tcp_server.socket.getsockname()[1]
822
 
    logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
823
 
                u" scope_id %d" % tcp_server.socket.getsockname())
 
2461
    if use_ipv6:
 
2462
        logger.info("Now listening on address %r, port %d,"
 
2463
                    " flowinfo %d, scope_id %d"
 
2464
                    % tcp_server.socket.getsockname())
 
2465
    else:                       # IPv4
 
2466
        logger.info("Now listening on address %r, port %d"
 
2467
                    % tcp_server.socket.getsockname())
824
2468
    
825
2469
    #service.interface = tcp_server.socket.getsockname()[3]
826
2470
    
827
2471
    try:
828
2472
        # From the Avahi example code
829
 
        server.connect_to_signal("StateChanged", server_state_changed)
830
2473
        try:
831
 
            server_state_changed(server.GetState())
832
 
        except dbus.exceptions.DBusException, error:
833
 
            logger.critical(u"DBusException: %s", error)
 
2474
            service.activate()
 
2475
        except dbus.exceptions.DBusException as error:
 
2476
            logger.critical("DBusException: %s", error)
 
2477
            cleanup()
834
2478
            sys.exit(1)
835
2479
        # End of Avahi example code
836
2480
        
837
2481
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
838
2482
                             lambda *args, **kwargs:
839
 
                             tcp_server.handle_request\
840
 
                             (*args[2:], **kwargs) or True)
 
2483
                             (tcp_server.handle_request
 
2484
                              (*args[2:], **kwargs) or True))
841
2485
        
842
 
        logger.debug(u"Starting main loop")
843
 
        main_loop_started = True
 
2486
        logger.debug("Starting main loop")
844
2487
        main_loop.run()
845
 
    except AvahiError, error:
846
 
        logger.critical(u"AvahiError: %s" + unicode(error))
 
2488
    except AvahiError as error:
 
2489
        logger.critical("AvahiError: %s", error)
 
2490
        cleanup()
847
2491
        sys.exit(1)
848
2492
    except KeyboardInterrupt:
849
2493
        if debug:
850
 
            print
 
2494
            print("", file=sys.stderr)
 
2495
        logger.debug("Server received KeyboardInterrupt")
 
2496
    logger.debug("Server exiting")
 
2497
    # Must run before the D-Bus bus name gets deregistered
 
2498
    cleanup()
 
2499
 
851
2500
 
852
2501
if __name__ == '__main__':
853
2502
    main()