/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

added documentation todo

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
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,2009 Teddy Hogeborn
 
15
# Copyright © 2008,2009 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
# along with this program.  If not, see
 
29
# <http://www.gnu.org/licenses/>.
28
30
# 
29
31
# Contact the authors at <mandos@fukt.bsnet.se>.
30
32
# 
31
33
 
32
 
from __future__ import division
 
34
from __future__ import division, with_statement, absolute_import
33
35
 
34
 
import SocketServer
 
36
import SocketServer as socketserver
35
37
import socket
36
 
import select
37
 
from optparse import OptionParser
 
38
import optparse
38
39
import datetime
39
40
import errno
40
41
import gnutls.crypto
43
44
import gnutls.library.functions
44
45
import gnutls.library.constants
45
46
import gnutls.library.types
46
 
import ConfigParser
 
47
import ConfigParser as configparser
47
48
import sys
48
49
import re
49
50
import os
50
51
import signal
51
 
from sets import Set
52
52
import subprocess
53
53
import atexit
54
54
import stat
55
55
import logging
56
56
import logging.handlers
 
57
import pwd
 
58
from contextlib import closing
 
59
import struct
 
60
import fcntl
 
61
import functools
57
62
 
58
63
import dbus
 
64
import dbus.service
59
65
import gobject
60
66
import avahi
61
67
from dbus.mainloop.glib import DBusGMainLoop
62
68
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'))
 
69
import ctypes.util
 
70
 
 
71
try:
 
72
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
 
73
except AttributeError:
 
74
    try:
 
75
        from IN import SO_BINDTODEVICE
 
76
    except ImportError:
 
77
        SO_BINDTODEVICE = None
 
78
 
 
79
 
 
80
version = "1.0.12"
 
81
 
 
82
logger = logging.Logger(u'mandos')
 
83
syslogger = (logging.handlers.SysLogHandler
 
84
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
85
              address = "/dev/log"))
 
86
syslogger.setFormatter(logging.Formatter
 
87
                       (u'Mandos [%(process)d]: %(levelname)s:'
 
88
                        u' %(message)s'))
72
89
logger.addHandler(syslogger)
73
90
 
74
91
console = logging.StreamHandler()
75
 
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
76
 
                                       ' %(message)s'))
 
92
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
 
93
                                       u' %(levelname)s:'
 
94
                                       u' %(message)s'))
77
95
logger.addHandler(console)
78
96
 
79
97
class AvahiError(Exception):
80
 
    def __init__(self, value):
 
98
    def __init__(self, value, *args, **kwargs):
81
99
        self.value = value
82
 
    def __str__(self):
83
 
        return repr(self.value)
 
100
        super(AvahiError, self).__init__(value, *args, **kwargs)
 
101
    def __unicode__(self):
 
102
        return unicode(repr(self.value))
84
103
 
85
104
class AvahiServiceError(AvahiError):
86
105
    pass
91
110
 
92
111
class AvahiService(object):
93
112
    """An Avahi (Zeroconf) service.
 
113
    
94
114
    Attributes:
95
115
    interface: integer; avahi.IF_UNSPEC or an interface index.
96
116
               Used to optionally bind to the specified interface.
97
 
    name: string; Example: 'Mandos'
98
 
    type: string; Example: '_mandos._tcp'.
 
117
    name: string; Example: u'Mandos'
 
118
    type: string; Example: u'_mandos._tcp'.
99
119
                  See <http://www.dns-sd.org/ServiceTypes.html>
100
120
    port: integer; what port to announce
101
121
    TXT: list of strings; TXT record for the service
104
124
    max_renames: integer; maximum number of renames
105
125
    rename_count: integer; counter so we only rename after collisions
106
126
                  a sensible number of times
 
127
    group: D-Bus Entry Group
 
128
    server: D-Bus Server
 
129
    bus: dbus.SystemBus()
107
130
    """
108
131
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
109
 
                 type = None, port = None, TXT = None, domain = "",
110
 
                 host = "", max_renames = 32768):
 
132
                 servicetype = None, port = None, TXT = None,
 
133
                 domain = u"", host = u"", max_renames = 32768,
 
134
                 protocol = avahi.PROTO_UNSPEC, bus = None):
111
135
        self.interface = interface
112
136
        self.name = name
113
 
        self.type = type
 
137
        self.type = servicetype
114
138
        self.port = port
115
 
        if TXT is None:
116
 
            self.TXT = []
117
 
        else:
118
 
            self.TXT = TXT
 
139
        self.TXT = TXT if TXT is not None else []
119
140
        self.domain = domain
120
141
        self.host = host
121
142
        self.rename_count = 0
122
143
        self.max_renames = max_renames
 
144
        self.protocol = protocol
 
145
        self.group = None       # our entry group
 
146
        self.server = None
 
147
        self.bus = bus
123
148
    def rename(self):
124
149
        """Derived from the Avahi example code"""
125
150
        if self.rename_count >= self.max_renames:
126
 
            logger.critical(u"No suitable service name found after %i"
127
 
                            u" retries, exiting.", rename_count)
128
 
            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))
 
151
            logger.critical(u"No suitable Zeroconf service name found"
 
152
                            u" after %i retries, exiting.",
 
153
                            self.rename_count)
 
154
            raise AvahiServiceError(u"Too many renames")
 
155
        self.name = self.server.GetAlternativeServiceName(self.name)
 
156
        logger.info(u"Changing Zeroconf service name to %r ...",
 
157
                    unicode(self.name))
 
158
        syslogger.setFormatter(logging.Formatter
 
159
                               (u'Mandos (%s) [%%(process)d]:'
 
160
                                u' %%(levelname)s: %%(message)s'
 
161
                                % self.name))
134
162
        self.remove()
135
163
        self.add()
136
164
        self.rename_count += 1
137
165
    def remove(self):
138
166
        """Derived from the Avahi example code"""
139
 
        if group is not None:
140
 
            group.Reset()
 
167
        if self.group is not None:
 
168
            self.group.Reset()
141
169
    def add(self):
142
170
        """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
 
171
        if self.group is None:
 
172
            self.group = dbus.Interface(
 
173
                self.bus.get_object(avahi.DBUS_NAME,
 
174
                                    self.server.EntryGroupNew()),
 
175
                avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
176
            self.group.connect_to_signal('StateChanged',
 
177
                                         self
 
178
                                         .entry_group_state_changed)
 
179
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
 
180
                     self.name, self.type)
 
181
        self.group.AddService(
 
182
            self.interface,
 
183
            self.protocol,
 
184
            dbus.UInt32(0),     # flags
 
185
            self.name, self.type,
 
186
            self.domain, self.host,
 
187
            dbus.UInt16(self.port),
 
188
            avahi.string_array_to_txt_array(self.TXT))
 
189
        self.group.Commit()
 
190
    def entry_group_state_changed(self, state, error):
 
191
        """Derived from the Avahi example code"""
 
192
        logger.debug(u"Avahi state change: %i", state)
 
193
        
 
194
        if state == avahi.ENTRY_GROUP_ESTABLISHED:
 
195
            logger.debug(u"Zeroconf service established.")
 
196
        elif state == avahi.ENTRY_GROUP_COLLISION:
 
197
            logger.warning(u"Zeroconf service name collision.")
 
198
            self.rename()
 
199
        elif state == avahi.ENTRY_GROUP_FAILURE:
 
200
            logger.critical(u"Avahi: Error in group state changed %s",
 
201
                            unicode(error))
 
202
            raise AvahiGroupError(u"State changed: %s"
 
203
                                  % unicode(error))
 
204
    def cleanup(self):
 
205
        """Derived from the Avahi example code"""
 
206
        if self.group is not None:
 
207
            self.group.Free()
 
208
            self.group = None
 
209
    def server_state_changed(self, state):
 
210
        """Derived from the Avahi example code"""
 
211
        if state == avahi.SERVER_COLLISION:
 
212
            logger.error(u"Zeroconf server name collision")
 
213
            self.remove()
 
214
        elif state == avahi.SERVER_RUNNING:
 
215
            self.add()
 
216
    def activate(self):
 
217
        """Derived from the Avahi example code"""
 
218
        if self.server is None:
 
219
            self.server = dbus.Interface(
 
220
                self.bus.get_object(avahi.DBUS_NAME,
 
221
                                    avahi.DBUS_PATH_SERVER),
 
222
                avahi.DBUS_INTERFACE_SERVER)
 
223
        self.server.connect_to_signal(u"StateChanged",
 
224
                                 self.server_state_changed)
 
225
        self.server_state_changed(self.server.GetState())
166
226
 
167
227
 
168
228
class Client(object):
169
229
    """A representation of a client host served by this server.
 
230
    
170
231
    Attributes:
171
 
    name:      string; from the config file, used in log messages
 
232
    name:       string; from the config file, used in log messages and
 
233
                        D-Bus identifiers
172
234
    fingerprint: string (40 or 32 hexadecimal digits); used to
173
235
                 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.
 
236
    secret:     bytestring; sent verbatim (over TLS) to client
 
237
    host:       string; available for use by the checker command
 
238
    created:    datetime.datetime(); (UTC) object creation
 
239
    last_enabled: datetime.datetime(); (UTC)
 
240
    enabled:    bool()
 
241
    last_checked_ok: datetime.datetime(); (UTC) or None
 
242
    timeout:    datetime.timedelta(); How long from last_checked_ok
 
243
                                      until this client is invalid
 
244
    interval:   datetime.timedelta(); How often to start a new checker
 
245
    disable_hook:  If set, called by disable() as disable_hook(self)
 
246
    checker:    subprocess.Popen(); a running checker process used
 
247
                                    to see if the client lives.
 
248
                                    'None' if no process is running.
185
249
    checker_initiator_tag: a gobject event source tag, or None
186
 
    stop_initiator_tag:    - '' -
 
250
    disable_initiator_tag:    - '' -
187
251
    checker_callback_tag:  - '' -
188
252
    checker_command: string; External command which is run to check if
189
253
                     client lives.  %() expansions are done at
190
254
                     runtime with vars(self) as dict, so that for
191
255
                     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: - '' -
 
256
    current_checker_command: string; current running checker_command
197
257
    """
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={}):
 
258
    
 
259
    @staticmethod
 
260
    def _datetime_to_milliseconds(dt):
 
261
        "Convert a datetime.datetime() to milliseconds"
 
262
        return ((dt.days * 24 * 60 * 60 * 1000)
 
263
                + (dt.seconds * 1000)
 
264
                + (dt.microseconds // 1000))
 
265
    
 
266
    def timeout_milliseconds(self):
 
267
        "Return the 'timeout' attribute in milliseconds"
 
268
        return self._datetime_to_milliseconds(self.timeout)
 
269
    
 
270
    def interval_milliseconds(self):
 
271
        "Return the 'interval' attribute in milliseconds"
 
272
        return self._datetime_to_milliseconds(self.interval)
 
273
    
 
274
    def __init__(self, name = None, disable_hook=None, config=None):
222
275
        """Note: the 'checker' key in 'config' sets the
223
276
        'checker_command' attribute and *not* the 'checker'
224
277
        attribute."""
225
278
        self.name = name
 
279
        if config is None:
 
280
            config = {}
226
281
        logger.debug(u"Creating client %r", self.name)
227
282
        # Uppercase and remove spaces from fingerprint for later
228
283
        # comparison purposes with return value from the fingerprint()
229
284
        # function
230
 
        self.fingerprint = config["fingerprint"].upper()\
231
 
                           .replace(u" ", u"")
 
285
        self.fingerprint = (config[u"fingerprint"].upper()
 
286
                            .replace(u" ", u""))
232
287
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
233
 
        if "secret" in config:
234
 
            self.secret = config["secret"].decode(u"base64")
235
 
        elif "secfile" in config:
236
 
            sf = open(config["secfile"])
237
 
            self.secret = sf.read()
238
 
            sf.close()
 
288
        if u"secret" in config:
 
289
            self.secret = config[u"secret"].decode(u"base64")
 
290
        elif u"secfile" in config:
 
291
            with closing(open(os.path.expanduser
 
292
                              (os.path.expandvars
 
293
                               (config[u"secfile"])))) as secfile:
 
294
                self.secret = secfile.read()
239
295
        else:
240
296
            raise TypeError(u"No secret or secfile for client %s"
241
297
                            % self.name)
242
 
        self.host = config.get("host", "")
243
 
        self.created = datetime.datetime.now()
 
298
        self.host = config.get(u"host", u"")
 
299
        self.created = datetime.datetime.utcnow()
 
300
        self.enabled = False
 
301
        self.last_enabled = None
244
302
        self.last_checked_ok = None
245
 
        self.timeout = string_to_delta(config["timeout"])
246
 
        self.interval = string_to_delta(config["interval"])
247
 
        self.stop_hook = stop_hook
 
303
        self.timeout = string_to_delta(config[u"timeout"])
 
304
        self.interval = string_to_delta(config[u"interval"])
 
305
        self.disable_hook = disable_hook
248
306
        self.checker = None
249
307
        self.checker_initiator_tag = None
250
 
        self.stop_initiator_tag = None
 
308
        self.disable_initiator_tag = None
251
309
        self.checker_callback_tag = None
252
 
        self.check_command = config["checker"]
253
 
    def start(self):
 
310
        self.checker_command = config[u"checker"]
 
311
        self.current_checker_command = None
 
312
        self.last_connect = None
 
313
    
 
314
    def enable(self):
254
315
        """Start this client's checker and timeout hooks"""
 
316
        if getattr(self, u"enabled", False):
 
317
            # Already enabled
 
318
            return
 
319
        self.last_enabled = datetime.datetime.utcnow()
255
320
        # Schedule a new checker to be started an 'interval' from now,
256
321
        # and every interval from then on.
257
 
        self.checker_initiator_tag = gobject.timeout_add\
258
 
                                     (self._interval_milliseconds,
259
 
                                      self.start_checker)
 
322
        self.checker_initiator_tag = (gobject.timeout_add
 
323
                                      (self.interval_milliseconds(),
 
324
                                       self.start_checker))
260
325
        # Also start a new checker *right now*.
261
326
        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:
 
327
        # Schedule a disable() when 'timeout' has passed
 
328
        self.disable_initiator_tag = (gobject.timeout_add
 
329
                                   (self.timeout_milliseconds(),
 
330
                                    self.disable))
 
331
        self.enabled = True
 
332
    
 
333
    def disable(self):
 
334
        """Disable this client."""
 
335
        if not getattr(self, "enabled", False):
275
336
            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):
 
337
        logger.info(u"Disabling client %s", self.name)
 
338
        if getattr(self, u"disable_initiator_tag", False):
 
339
            gobject.source_remove(self.disable_initiator_tag)
 
340
            self.disable_initiator_tag = None
 
341
        if getattr(self, u"checker_initiator_tag", False):
280
342
            gobject.source_remove(self.checker_initiator_tag)
281
343
            self.checker_initiator_tag = None
282
344
        self.stop_checker()
283
 
        if self.stop_hook:
284
 
            self.stop_hook(self)
 
345
        if self.disable_hook:
 
346
            self.disable_hook(self)
 
347
        self.enabled = False
285
348
        # Do not run this again if called by a gobject.timeout_add
286
349
        return False
 
350
    
287
351
    def __del__(self):
288
 
        self.stop_hook = None
289
 
        self.stop()
290
 
    def checker_callback(self, pid, condition):
 
352
        self.disable_hook = None
 
353
        self.disable()
 
354
    
 
355
    def checker_callback(self, pid, condition, command):
291
356
        """The checker has completed, so take appropriate actions."""
292
 
        now = datetime.datetime.now()
293
357
        self.checker_callback_tag = None
294
358
        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):
 
359
        if os.WIFEXITED(condition):
 
360
            exitstatus = os.WEXITSTATUS(condition)
 
361
            if exitstatus == 0:
 
362
                logger.info(u"Checker for %(name)s succeeded",
 
363
                            vars(self))
 
364
                self.checked_ok()
 
365
            else:
 
366
                logger.info(u"Checker for %(name)s failed",
 
367
                            vars(self))
 
368
        else:
305
369
            logger.warning(u"Checker for %(name)s crashed?",
306
370
                           vars(self))
307
 
        else:
308
 
            logger.info(u"Checker for %(name)s failed",
309
 
                        vars(self))
 
371
    
 
372
    def checked_ok(self):
 
373
        """Bump up the timeout for this client.
 
374
        
 
375
        This should only be called when the client has been seen,
 
376
        alive and well.
 
377
        """
 
378
        self.last_checked_ok = datetime.datetime.utcnow()
 
379
        gobject.source_remove(self.disable_initiator_tag)
 
380
        self.disable_initiator_tag = (gobject.timeout_add
 
381
                                      (self.timeout_milliseconds(),
 
382
                                       self.disable))
 
383
    
310
384
    def start_checker(self):
311
385
        """Start a new checker subprocess if one is not running.
 
386
        
312
387
        If a checker already exists, leave it running and do
313
388
        nothing."""
314
389
        # The reason for not killing a running checker is that if we
319
394
        # checkers alone, the checker would have to take more time
320
395
        # than 'timeout' for the client to be declared invalid, which
321
396
        # is as it should be.
 
397
        
 
398
        # If a checker exists, make sure it is not a zombie
 
399
        if self.checker is not None:
 
400
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
401
            if pid:
 
402
                logger.warning(u"Checker was a zombie")
 
403
                gobject.source_remove(self.checker_callback_tag)
 
404
                self.checker_callback(pid, status,
 
405
                                      self.current_checker_command)
 
406
        # Start a new checker if needed
322
407
        if self.checker is None:
323
408
            try:
324
 
                # In case check_command has exactly one % operator
325
 
                command = self.check_command % self.host
 
409
                # In case checker_command has exactly one % operator
 
410
                command = self.checker_command % self.host
326
411
            except TypeError:
327
412
                # Escape attributes for the shell
328
 
                escaped_attrs = dict((key, re.escape(str(val)))
 
413
                escaped_attrs = dict((key,
 
414
                                      re.escape(unicode(str(val),
 
415
                                                        errors=
 
416
                                                        u'replace')))
329
417
                                     for key, val in
330
418
                                     vars(self).iteritems())
331
419
                try:
332
 
                    command = self.check_command % escaped_attrs
 
420
                    command = self.checker_command % escaped_attrs
333
421
                except TypeError, error:
334
422
                    logger.error(u'Could not format string "%s":'
335
 
                                 u' %s', self.check_command, error)
 
423
                                 u' %s', self.checker_command, error)
336
424
                    return True # Try again later
 
425
            self.current_checker_command = command
337
426
            try:
338
427
                logger.info(u"Starting checker %r for %s",
339
428
                            command, self.name)
343
432
                # always replaced by /dev/null.)
344
433
                self.checker = subprocess.Popen(command,
345
434
                                                close_fds=True,
346
 
                                                shell=True, cwd="/")
347
 
                self.checker_callback_tag = gobject.child_watch_add\
348
 
                                            (self.checker.pid,
349
 
                                             self.checker_callback)
 
435
                                                shell=True, cwd=u"/")
 
436
                self.checker_callback_tag = (gobject.child_watch_add
 
437
                                             (self.checker.pid,
 
438
                                              self.checker_callback,
 
439
                                              data=command))
 
440
                # The checker may have completed before the gobject
 
441
                # watch was added.  Check for this.
 
442
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
443
                if pid:
 
444
                    gobject.source_remove(self.checker_callback_tag)
 
445
                    self.checker_callback(pid, status, command)
350
446
            except OSError, error:
351
447
                logger.error(u"Failed to start subprocess: %s",
352
448
                             error)
353
449
        # Re-run this periodically if run by gobject.timeout_add
354
450
        return True
 
451
    
355
452
    def stop_checker(self):
356
453
        """Force the checker process, if any, to stop."""
357
454
        if self.checker_callback_tag:
358
455
            gobject.source_remove(self.checker_callback_tag)
359
456
            self.checker_callback_tag = None
360
 
        if getattr(self, "checker", None) is None:
 
457
        if getattr(self, u"checker", None) is None:
361
458
            return
362
459
        logger.debug(u"Stopping checker for %(name)s", vars(self))
363
460
        try:
369
466
            if error.errno != errno.ESRCH: # No such process
370
467
                raise
371
468
        self.checker = None
 
469
    
372
470
    def still_valid(self):
373
471
        """Has the timeout not yet passed for this client?"""
374
 
        now = datetime.datetime.now()
 
472
        if not getattr(self, u"enabled", False):
 
473
            return False
 
474
        now = datetime.datetime.utcnow()
375
475
        if self.last_checked_ok is None:
376
476
            return now < (self.created + self.timeout)
377
477
        else:
378
478
            return now < (self.last_checked_ok + self.timeout)
379
479
 
380
480
 
381
 
def peer_certificate(session):
382
 
    "Return the peer's OpenPGP certificate as a bytestring"
383
 
    # If not an OpenPGP certificate...
384
 
    if gnutls.library.functions.gnutls_certificate_type_get\
385
 
            (session._c_object) \
386
 
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
387
 
        # ...do the normal thing
388
 
        return session.peer_certificate
389
 
    list_size = ctypes.c_uint()
390
 
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
391
 
        (session._c_object, ctypes.byref(list_size))
392
 
    if list_size.value == 0:
393
 
        return None
394
 
    cert = cert_list[0]
395
 
    return ctypes.string_at(cert.data, cert.size)
396
 
 
397
 
 
398
 
def fingerprint(openpgp):
399
 
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
400
 
    # New GnuTLS "datum" with the OpenPGP public key
401
 
    datum = gnutls.library.types.gnutls_datum_t\
402
 
        (ctypes.cast(ctypes.c_char_p(openpgp),
403
 
                     ctypes.POINTER(ctypes.c_ubyte)),
404
 
         ctypes.c_uint(len(openpgp)))
405
 
    # New empty GnuTLS certificate
406
 
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
407
 
    gnutls.library.functions.gnutls_openpgp_crt_init\
408
 
        (ctypes.byref(crt))
409
 
    # Import the OpenPGP public key into the certificate
410
 
    gnutls.library.functions.gnutls_openpgp_crt_import\
411
 
                    (crt, ctypes.byref(datum),
412
 
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
413
 
    # Verify the self signature in the key
414
 
    crtverify = ctypes.c_uint();
415
 
    gnutls.library.functions.gnutls_openpgp_crt_verify_self\
416
 
        (crt, ctypes.c_uint(0), ctypes.byref(crtverify))
417
 
    if crtverify.value != 0:
418
 
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
419
 
        raise gnutls.errors.CertificateSecurityError("Verify failed")
420
 
    # New buffer for the fingerprint
421
 
    buffer = ctypes.create_string_buffer(20)
422
 
    buffer_length = ctypes.c_size_t()
423
 
    # Get the fingerprint from the certificate into the buffer
424
 
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
425
 
        (crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
426
 
    # Deinit the certificate
427
 
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
428
 
    # Convert the buffer to a Python bytestring
429
 
    fpr = ctypes.string_at(buffer, buffer_length.value)
430
 
    # Convert the bytestring to hexadecimal notation
431
 
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
432
 
    return hex_fpr
433
 
 
434
 
 
435
 
class tcp_handler(SocketServer.BaseRequestHandler, object):
436
 
    """A TCP request handler class.
437
 
    Instantiated by IPv6_TCPServer for each request to handle it.
 
481
class ClientDBus(Client, dbus.service.Object):
 
482
    """A Client class using D-Bus
 
483
    
 
484
    Attributes:
 
485
    dbus_object_path: dbus.ObjectPath
 
486
    bus: dbus.SystemBus()
 
487
    """
 
488
    # dbus.service.Object doesn't use super(), so we can't either.
 
489
    
 
490
    def __init__(self, bus = None, *args, **kwargs):
 
491
        self.bus = bus
 
492
        Client.__init__(self, *args, **kwargs)
 
493
        # Only now, when this client is initialized, can it show up on
 
494
        # the D-Bus
 
495
        self.dbus_object_path = (dbus.ObjectPath
 
496
                                 (u"/clients/"
 
497
                                  + self.name.replace(u".", u"_")))
 
498
        dbus.service.Object.__init__(self, self.bus,
 
499
                                     self.dbus_object_path)
 
500
    
 
501
    @staticmethod
 
502
    def _datetime_to_dbus(dt, variant_level=0):
 
503
        """Convert a UTC datetime.datetime() to a D-Bus type."""
 
504
        return dbus.String(dt.isoformat(),
 
505
                           variant_level=variant_level)
 
506
    
 
507
    def enable(self):
 
508
        oldstate = getattr(self, u"enabled", False)
 
509
        r = Client.enable(self)
 
510
        if oldstate != self.enabled:
 
511
            # Emit D-Bus signals
 
512
            self.PropertyChanged(dbus.String(u"enabled"),
 
513
                                 dbus.Boolean(True, variant_level=1))
 
514
            self.PropertyChanged(
 
515
                dbus.String(u"last_enabled"),
 
516
                self._datetime_to_dbus(self.last_enabled,
 
517
                                       variant_level=1))
 
518
        return r
 
519
    
 
520
    def disable(self, signal = True):
 
521
        oldstate = getattr(self, u"enabled", False)
 
522
        r = Client.disable(self)
 
523
        if signal and oldstate != self.enabled:
 
524
            # Emit D-Bus signal
 
525
            self.PropertyChanged(dbus.String(u"enabled"),
 
526
                                 dbus.Boolean(False, variant_level=1))
 
527
        return r
 
528
    
 
529
    def __del__(self, *args, **kwargs):
 
530
        try:
 
531
            self.remove_from_connection()
 
532
        except LookupError:
 
533
            pass
 
534
        if hasattr(dbus.service.Object, u"__del__"):
 
535
            dbus.service.Object.__del__(self, *args, **kwargs)
 
536
        Client.__del__(self, *args, **kwargs)
 
537
    
 
538
    def checker_callback(self, pid, condition, command,
 
539
                         *args, **kwargs):
 
540
        self.checker_callback_tag = None
 
541
        self.checker = None
 
542
        # Emit D-Bus signal
 
543
        self.PropertyChanged(dbus.String(u"checker_running"),
 
544
                             dbus.Boolean(False, variant_level=1))
 
545
        if os.WIFEXITED(condition):
 
546
            exitstatus = os.WEXITSTATUS(condition)
 
547
            # Emit D-Bus signal
 
548
            self.CheckerCompleted(dbus.Int16(exitstatus),
 
549
                                  dbus.Int64(condition),
 
550
                                  dbus.String(command))
 
551
        else:
 
552
            # Emit D-Bus signal
 
553
            self.CheckerCompleted(dbus.Int16(-1),
 
554
                                  dbus.Int64(condition),
 
555
                                  dbus.String(command))
 
556
        
 
557
        return Client.checker_callback(self, pid, condition, command,
 
558
                                       *args, **kwargs)
 
559
    
 
560
    def checked_ok(self, *args, **kwargs):
 
561
        r = Client.checked_ok(self, *args, **kwargs)
 
562
        # Emit D-Bus signal
 
563
        self.PropertyChanged(
 
564
            dbus.String(u"last_checked_ok"),
 
565
            (self._datetime_to_dbus(self.last_checked_ok,
 
566
                                    variant_level=1)))
 
567
        return r
 
568
    
 
569
    def start_checker(self, *args, **kwargs):
 
570
        old_checker = self.checker
 
571
        if self.checker is not None:
 
572
            old_checker_pid = self.checker.pid
 
573
        else:
 
574
            old_checker_pid = None
 
575
        r = Client.start_checker(self, *args, **kwargs)
 
576
        # Only if new checker process was started
 
577
        if (self.checker is not None
 
578
            and old_checker_pid != self.checker.pid):
 
579
            # Emit D-Bus signal
 
580
            self.CheckerStarted(self.current_checker_command)
 
581
            self.PropertyChanged(
 
582
                dbus.String(u"checker_running"),
 
583
                dbus.Boolean(True, variant_level=1))
 
584
        return r
 
585
    
 
586
    def stop_checker(self, *args, **kwargs):
 
587
        old_checker = getattr(self, u"checker", None)
 
588
        r = Client.stop_checker(self, *args, **kwargs)
 
589
        if (old_checker is not None
 
590
            and getattr(self, u"checker", None) is None):
 
591
            self.PropertyChanged(dbus.String(u"checker_running"),
 
592
                                 dbus.Boolean(False, variant_level=1))
 
593
        return r
 
594
    
 
595
    ## D-Bus methods & signals
 
596
    _interface = u"se.bsnet.fukt.Mandos.Client"
 
597
    
 
598
    # CheckedOK - method
 
599
    @dbus.service.method(_interface)
 
600
    def CheckedOK(self):
 
601
        return self.checked_ok()
 
602
    
 
603
    # CheckerCompleted - signal
 
604
    @dbus.service.signal(_interface, signature=u"nxs")
 
605
    def CheckerCompleted(self, exitcode, waitstatus, command):
 
606
        "D-Bus signal"
 
607
        pass
 
608
    
 
609
    # CheckerStarted - signal
 
610
    @dbus.service.signal(_interface, signature=u"s")
 
611
    def CheckerStarted(self, command):
 
612
        "D-Bus signal"
 
613
        pass
 
614
    
 
615
    # GetAllProperties - method
 
616
    @dbus.service.method(_interface, out_signature=u"a{sv}")
 
617
    def GetAllProperties(self):
 
618
        "D-Bus method"
 
619
        return dbus.Dictionary({
 
620
                dbus.String(u"name"):
 
621
                    dbus.String(self.name, variant_level=1),
 
622
                dbus.String(u"fingerprint"):
 
623
                    dbus.String(self.fingerprint, variant_level=1),
 
624
                dbus.String(u"host"):
 
625
                    dbus.String(self.host, variant_level=1),
 
626
                dbus.String(u"created"):
 
627
                    self._datetime_to_dbus(self.created,
 
628
                                           variant_level=1),
 
629
                dbus.String(u"last_enabled"):
 
630
                    (self._datetime_to_dbus(self.last_enabled,
 
631
                                            variant_level=1)
 
632
                     if self.last_enabled is not None
 
633
                     else dbus.Boolean(False, variant_level=1)),
 
634
                dbus.String(u"enabled"):
 
635
                    dbus.Boolean(self.enabled, variant_level=1),
 
636
                dbus.String(u"last_checked_ok"):
 
637
                    (self._datetime_to_dbus(self.last_checked_ok,
 
638
                                            variant_level=1)
 
639
                     if self.last_checked_ok is not None
 
640
                     else dbus.Boolean (False, variant_level=1)),
 
641
                dbus.String(u"timeout"):
 
642
                    dbus.UInt64(self.timeout_milliseconds(),
 
643
                                variant_level=1),
 
644
                dbus.String(u"interval"):
 
645
                    dbus.UInt64(self.interval_milliseconds(),
 
646
                                variant_level=1),
 
647
                dbus.String(u"checker"):
 
648
                    dbus.String(self.checker_command,
 
649
                                variant_level=1),
 
650
                dbus.String(u"checker_running"):
 
651
                    dbus.Boolean(self.checker is not None,
 
652
                                 variant_level=1),
 
653
                dbus.String(u"object_path"):
 
654
                    dbus.ObjectPath(self.dbus_object_path,
 
655
                                    variant_level=1)
 
656
                }, signature=u"sv")
 
657
    
 
658
    # IsStillValid - method
 
659
    @dbus.service.method(_interface, out_signature=u"b")
 
660
    def IsStillValid(self):
 
661
        return self.still_valid()
 
662
    
 
663
    # PropertyChanged - signal
 
664
    @dbus.service.signal(_interface, signature=u"sv")
 
665
    def PropertyChanged(self, property, value):
 
666
        "D-Bus signal"
 
667
        pass
 
668
    
 
669
    # ReceivedSecret - signal
 
670
    @dbus.service.signal(_interface)
 
671
    def ReceivedSecret(self):
 
672
        "D-Bus signal"
 
673
        pass
 
674
    
 
675
    # Rejected - signal
 
676
    @dbus.service.signal(_interface)
 
677
    def Rejected(self):
 
678
        "D-Bus signal"
 
679
        pass
 
680
    
 
681
    # SetChecker - method
 
682
    @dbus.service.method(_interface, in_signature=u"s")
 
683
    def SetChecker(self, checker):
 
684
        "D-Bus setter method"
 
685
        self.checker_command = checker
 
686
        # Emit D-Bus signal
 
687
        self.PropertyChanged(dbus.String(u"checker"),
 
688
                             dbus.String(self.checker_command,
 
689
                                         variant_level=1))
 
690
    
 
691
    # SetHost - method
 
692
    @dbus.service.method(_interface, in_signature=u"s")
 
693
    def SetHost(self, host):
 
694
        "D-Bus setter method"
 
695
        self.host = host
 
696
        # Emit D-Bus signal
 
697
        self.PropertyChanged(dbus.String(u"host"),
 
698
                             dbus.String(self.host, variant_level=1))
 
699
    
 
700
    # SetInterval - method
 
701
    @dbus.service.method(_interface, in_signature=u"t")
 
702
    def SetInterval(self, milliseconds):
 
703
        self.interval = datetime.timedelta(0, 0, 0, milliseconds)
 
704
        # Emit D-Bus signal
 
705
        self.PropertyChanged(dbus.String(u"interval"),
 
706
                             (dbus.UInt64(self
 
707
                                          .interval_milliseconds(),
 
708
                                          variant_level=1)))
 
709
    
 
710
    # SetSecret - method
 
711
    @dbus.service.method(_interface, in_signature=u"ay",
 
712
                         byte_arrays=True)
 
713
    def SetSecret(self, secret):
 
714
        "D-Bus setter method"
 
715
        self.secret = str(secret)
 
716
    
 
717
    # SetTimeout - method
 
718
    @dbus.service.method(_interface, in_signature=u"t")
 
719
    def SetTimeout(self, milliseconds):
 
720
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
 
721
        # Emit D-Bus signal
 
722
        self.PropertyChanged(dbus.String(u"timeout"),
 
723
                             (dbus.UInt64(self.timeout_milliseconds(),
 
724
                                          variant_level=1)))
 
725
    
 
726
    # Enable - method
 
727
    @dbus.service.method(_interface)
 
728
    def Enable(self):
 
729
        "D-Bus method"
 
730
        self.enable()
 
731
    
 
732
    # StartChecker - method
 
733
    @dbus.service.method(_interface)
 
734
    def StartChecker(self):
 
735
        "D-Bus method"
 
736
        self.start_checker()
 
737
    
 
738
    # Disable - method
 
739
    @dbus.service.method(_interface)
 
740
    def Disable(self):
 
741
        "D-Bus method"
 
742
        self.disable()
 
743
    
 
744
    # StopChecker - method
 
745
    @dbus.service.method(_interface)
 
746
    def StopChecker(self):
 
747
        self.stop_checker()
 
748
    
 
749
    del _interface
 
750
 
 
751
 
 
752
class ClientHandler(socketserver.BaseRequestHandler, object):
 
753
    """A class to handle client connections.
 
754
    
 
755
    Instantiated once for each connection to handle it.
438
756
    Note: This will run in its own forked process."""
439
757
    
440
758
    def handle(self):
441
759
        logger.info(u"TCP connection from: %s",
442
 
                     unicode(self.client_address))
443
 
        session = gnutls.connection.ClientSession\
444
 
                  (self.request, gnutls.connection.X509Credentials())
445
 
        
446
 
        line = self.request.makefile().readline()
447
 
        logger.debug(u"Protocol version: %r", line)
448
 
        try:
449
 
            if int(line.strip().split()[0]) > 1:
450
 
                raise RuntimeError
451
 
        except (ValueError, IndexError, RuntimeError), error:
452
 
            logger.error(u"Unknown protocol version: %s", error)
453
 
            return
454
 
        
455
 
        # Note: gnutls.connection.X509Credentials is really a generic
456
 
        # GnuTLS certificate credentials object so long as no X.509
457
 
        # keys are added to it.  Therefore, we can use it here despite
458
 
        # using OpenPGP certificates.
459
 
        
460
 
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
461
 
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
462
 
        #                "+DHE-DSS"))
463
 
        priority = "NORMAL"             # Fallback default, since this
464
 
                                        # MUST be set.
465
 
        if self.server.settings["priority"]:
466
 
            priority = self.server.settings["priority"]
467
 
        gnutls.library.functions.gnutls_priority_set_direct\
468
 
            (session._c_object, priority, None);
469
 
        
470
 
        try:
471
 
            session.handshake()
472
 
        except gnutls.errors.GNUTLSError, error:
473
 
            logger.warning(u"Handshake failed: %s", error)
474
 
            # Do not run session.bye() here: the session is not
475
 
            # established.  Just abandon the request.
476
 
            return
477
 
        try:
478
 
            fpr = fingerprint(peer_certificate(session))
479
 
        except (TypeError, gnutls.errors.GNUTLSError), error:
480
 
            logger.warning(u"Bad certificate: %s", error)
481
 
            session.bye()
482
 
            return
483
 
        logger.debug(u"Fingerprint: %s", fpr)
484
 
        client = None
485
 
        for c in self.server.clients:
486
 
            if c.fingerprint == fpr:
487
 
                client = c
488
 
                break
489
 
        if not client:
490
 
            logger.warning(u"Client not found for fingerprint: %s",
491
 
                           fpr)
492
 
            session.bye()
493
 
            return
494
 
        # Have to check if client.still_valid(), since it is possible
495
 
        # that the client timed out while establishing the GnuTLS
496
 
        # session.
497
 
        if not client.still_valid():
498
 
            logger.warning(u"Client %(name)s is invalid",
499
 
                           vars(client))
500
 
            session.bye()
501
 
            return
502
 
        sent_size = 0
503
 
        while sent_size < len(client.secret):
504
 
            sent = session.send(client.secret[sent_size:])
505
 
            logger.debug(u"Sent: %d, remaining: %d",
506
 
                         sent, len(client.secret)
507
 
                         - (sent_size + sent))
508
 
            sent_size += sent
509
 
        session.bye()
510
 
 
511
 
 
512
 
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
513
 
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
 
760
                    unicode(self.client_address))
 
761
        logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
 
762
        # Open IPC pipe to parent process
 
763
        with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
 
764
            session = (gnutls.connection
 
765
                       .ClientSession(self.request,
 
766
                                      gnutls.connection
 
767
                                      .X509Credentials()))
 
768
            
 
769
            line = self.request.makefile().readline()
 
770
            logger.debug(u"Protocol version: %r", line)
 
771
            try:
 
772
                if int(line.strip().split()[0]) > 1:
 
773
                    raise RuntimeError
 
774
            except (ValueError, IndexError, RuntimeError), error:
 
775
                logger.error(u"Unknown protocol version: %s", error)
 
776
                return
 
777
            
 
778
            # Note: gnutls.connection.X509Credentials is really a
 
779
            # generic GnuTLS certificate credentials object so long as
 
780
            # no X.509 keys are added to it.  Therefore, we can use it
 
781
            # here despite using OpenPGP certificates.
 
782
            
 
783
            #priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
 
784
            #                      u"+AES-256-CBC", u"+SHA1",
 
785
            #                      u"+COMP-NULL", u"+CTYPE-OPENPGP",
 
786
            #                      u"+DHE-DSS"))
 
787
            # Use a fallback default, since this MUST be set.
 
788
            priority = self.server.gnutls_priority
 
789
            if priority is None:
 
790
                priority = u"NORMAL"
 
791
            (gnutls.library.functions
 
792
             .gnutls_priority_set_direct(session._c_object,
 
793
                                         priority, None))
 
794
            
 
795
            try:
 
796
                session.handshake()
 
797
            except gnutls.errors.GNUTLSError, error:
 
798
                logger.warning(u"Handshake failed: %s", error)
 
799
                # Do not run session.bye() here: the session is not
 
800
                # established.  Just abandon the request.
 
801
                return
 
802
            logger.debug(u"Handshake succeeded")
 
803
            try:
 
804
                fpr = self.fingerprint(self.peer_certificate(session))
 
805
            except (TypeError, gnutls.errors.GNUTLSError), error:
 
806
                logger.warning(u"Bad certificate: %s", error)
 
807
                session.bye()
 
808
                return
 
809
            logger.debug(u"Fingerprint: %s", fpr)
 
810
            
 
811
            for c in self.server.clients:
 
812
                if c.fingerprint == fpr:
 
813
                    client = c
 
814
                    break
 
815
            else:
 
816
                ipc.write(u"NOTFOUND %s %s\n"
 
817
                          % (fpr, unicode(self.client_address)))
 
818
                session.bye()
 
819
                return
 
820
            # Have to check if client.still_valid(), since it is
 
821
            # possible that the client timed out while establishing
 
822
            # the GnuTLS session.
 
823
            if not client.still_valid():
 
824
                ipc.write(u"INVALID %s\n" % client.name)
 
825
                session.bye()
 
826
                return
 
827
            ipc.write(u"SENDING %s\n" % client.name)
 
828
            sent_size = 0
 
829
            while sent_size < len(client.secret):
 
830
                sent = session.send(client.secret[sent_size:])
 
831
                logger.debug(u"Sent: %d, remaining: %d",
 
832
                             sent, len(client.secret)
 
833
                             - (sent_size + sent))
 
834
                sent_size += sent
 
835
            session.bye()
 
836
    
 
837
    @staticmethod
 
838
    def peer_certificate(session):
 
839
        "Return the peer's OpenPGP certificate as a bytestring"
 
840
        # If not an OpenPGP certificate...
 
841
        if (gnutls.library.functions
 
842
            .gnutls_certificate_type_get(session._c_object)
 
843
            != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
 
844
            # ...do the normal thing
 
845
            return session.peer_certificate
 
846
        list_size = ctypes.c_uint(1)
 
847
        cert_list = (gnutls.library.functions
 
848
                     .gnutls_certificate_get_peers
 
849
                     (session._c_object, ctypes.byref(list_size)))
 
850
        if not bool(cert_list) and list_size.value != 0:
 
851
            raise gnutls.errors.GNUTLSError(u"error getting peer"
 
852
                                            u" certificate")
 
853
        if list_size.value == 0:
 
854
            return None
 
855
        cert = cert_list[0]
 
856
        return ctypes.string_at(cert.data, cert.size)
 
857
    
 
858
    @staticmethod
 
859
    def fingerprint(openpgp):
 
860
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
 
861
        # New GnuTLS "datum" with the OpenPGP public key
 
862
        datum = (gnutls.library.types
 
863
                 .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
 
864
                                             ctypes.POINTER
 
865
                                             (ctypes.c_ubyte)),
 
866
                                 ctypes.c_uint(len(openpgp))))
 
867
        # New empty GnuTLS certificate
 
868
        crt = gnutls.library.types.gnutls_openpgp_crt_t()
 
869
        (gnutls.library.functions
 
870
         .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
871
        # Import the OpenPGP public key into the certificate
 
872
        (gnutls.library.functions
 
873
         .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
 
874
                                    gnutls.library.constants
 
875
                                    .GNUTLS_OPENPGP_FMT_RAW))
 
876
        # Verify the self signature in the key
 
877
        crtverify = ctypes.c_uint()
 
878
        (gnutls.library.functions
 
879
         .gnutls_openpgp_crt_verify_self(crt, 0,
 
880
                                         ctypes.byref(crtverify)))
 
881
        if crtverify.value != 0:
 
882
            gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
883
            raise (gnutls.errors.CertificateSecurityError
 
884
                   (u"Verify failed"))
 
885
        # New buffer for the fingerprint
 
886
        buf = ctypes.create_string_buffer(20)
 
887
        buf_len = ctypes.c_size_t()
 
888
        # Get the fingerprint from the certificate into the buffer
 
889
        (gnutls.library.functions
 
890
         .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
 
891
                                             ctypes.byref(buf_len)))
 
892
        # Deinit the certificate
 
893
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
894
        # Convert the buffer to a Python bytestring
 
895
        fpr = ctypes.string_at(buf, buf_len.value)
 
896
        # Convert the bytestring to hexadecimal notation
 
897
        hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
 
898
        return hex_fpr
 
899
 
 
900
 
 
901
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
 
902
    """Like socketserver.ForkingMixIn, but also pass a pipe."""
 
903
    def process_request(self, request, client_address):
 
904
        """Overrides and wraps the original process_request().
 
905
        
 
906
        This function creates a new pipe in self.pipe
 
907
        """
 
908
        self.pipe = os.pipe()
 
909
        super(ForkingMixInWithPipe,
 
910
              self).process_request(request, client_address)
 
911
        os.close(self.pipe[1])  # close write end
 
912
        self.add_pipe(self.pipe[0])
 
913
    def add_pipe(self, pipe):
 
914
        """Dummy function; override as necessary"""
 
915
        os.close(pipe)
 
916
 
 
917
 
 
918
class IPv6_TCPServer(ForkingMixInWithPipe,
 
919
                     socketserver.TCPServer, object):
 
920
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
 
921
    
514
922
    Attributes:
515
 
        settings:       Server settings
516
 
        clients:        Set() of Client objects
 
923
        enabled:        Boolean; whether this server is activated yet
 
924
        interface:      None or a network interface name (string)
 
925
        use_ipv6:       Boolean; to use IPv6 or not
517
926
    """
518
 
    address_family = socket.AF_INET6
519
 
    def __init__(self, *args, **kwargs):
520
 
        if "settings" in kwargs:
521
 
            self.settings = kwargs["settings"]
522
 
            del kwargs["settings"]
523
 
        if "clients" in kwargs:
524
 
            self.clients = kwargs["clients"]
525
 
            del kwargs["clients"]
526
 
        return super(type(self), self).__init__(*args, **kwargs)
 
927
    def __init__(self, server_address, RequestHandlerClass,
 
928
                 interface=None, use_ipv6=True):
 
929
        self.interface = interface
 
930
        if use_ipv6:
 
931
            self.address_family = socket.AF_INET6
 
932
        socketserver.TCPServer.__init__(self, server_address,
 
933
                                        RequestHandlerClass)
527
934
    def server_bind(self):
528
935
        """This overrides the normal server_bind() function
529
936
        to bind to an interface if one was specified, and also NOT to
530
937
        bind to an address or port if they were not specified."""
531
 
        if self.settings["interface"]:
532
 
            # 25 is from /usr/include/asm-i486/socket.h
533
 
            SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
534
 
            try:
535
 
                self.socket.setsockopt(socket.SOL_SOCKET,
536
 
                                       SO_BINDTODEVICE,
537
 
                                       self.settings["interface"])
538
 
            except socket.error, error:
539
 
                if error[0] == errno.EPERM:
540
 
                    logger.error(u"No permission to"
541
 
                                 u" bind to interface %s",
542
 
                                 self.settings["interface"])
543
 
                else:
544
 
                    raise error
 
938
        if self.interface is not None:
 
939
            if SO_BINDTODEVICE is None:
 
940
                logger.error(u"SO_BINDTODEVICE does not exist;"
 
941
                             u" cannot bind to interface %s",
 
942
                             self.interface)
 
943
            else:
 
944
                try:
 
945
                    self.socket.setsockopt(socket.SOL_SOCKET,
 
946
                                           SO_BINDTODEVICE,
 
947
                                           str(self.interface
 
948
                                               + u'\0'))
 
949
                except socket.error, error:
 
950
                    if error[0] == errno.EPERM:
 
951
                        logger.error(u"No permission to"
 
952
                                     u" bind to interface %s",
 
953
                                     self.interface)
 
954
                    elif error[0] == errno.ENOPROTOOPT:
 
955
                        logger.error(u"SO_BINDTODEVICE not available;"
 
956
                                     u" cannot bind to interface %s",
 
957
                                     self.interface)
 
958
                    else:
 
959
                        raise
545
960
        # Only bind(2) the socket if we really need to.
546
961
        if self.server_address[0] or self.server_address[1]:
547
962
            if not self.server_address[0]:
548
 
                in6addr_any = "::"
549
 
                self.server_address = (in6addr_any,
 
963
                if self.address_family == socket.AF_INET6:
 
964
                    any_address = u"::" # in6addr_any
 
965
                else:
 
966
                    any_address = socket.INADDR_ANY
 
967
                self.server_address = (any_address,
550
968
                                       self.server_address[1])
551
969
            elif not self.server_address[1]:
552
970
                self.server_address = (self.server_address[0],
553
971
                                       0)
554
 
#                 if self.settings["interface"]:
 
972
#                 if self.interface:
555
973
#                     self.server_address = (self.server_address[0],
556
974
#                                            0, # port
557
975
#                                            0, # flowinfo
558
976
#                                            if_nametoindex
559
 
#                                            (self.settings
560
 
#                                             ["interface"]))
561
 
            return super(type(self), self).server_bind()
 
977
#                                            (self.interface))
 
978
            return socketserver.TCPServer.server_bind(self)
 
979
 
 
980
 
 
981
class MandosServer(IPv6_TCPServer):
 
982
    """Mandos server.
 
983
    
 
984
    Attributes:
 
985
        clients:        set of Client objects
 
986
        gnutls_priority GnuTLS priority string
 
987
        use_dbus:       Boolean; to emit D-Bus signals or not
 
988
    
 
989
    Assumes a gobject.MainLoop event loop.
 
990
    """
 
991
    def __init__(self, server_address, RequestHandlerClass,
 
992
                 interface=None, use_ipv6=True, clients=None,
 
993
                 gnutls_priority=None, use_dbus=True):
 
994
        self.enabled = False
 
995
        self.clients = clients
 
996
        if self.clients is None:
 
997
            self.clients = set()
 
998
        self.use_dbus = use_dbus
 
999
        self.gnutls_priority = gnutls_priority
 
1000
        IPv6_TCPServer.__init__(self, server_address,
 
1001
                                RequestHandlerClass,
 
1002
                                interface = interface,
 
1003
                                use_ipv6 = use_ipv6)
 
1004
    def server_activate(self):
 
1005
        if self.enabled:
 
1006
            return socketserver.TCPServer.server_activate(self)
 
1007
    def enable(self):
 
1008
        self.enabled = True
 
1009
    def add_pipe(self, pipe):
 
1010
        # Call "handle_ipc" for both data and EOF events
 
1011
        gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
 
1012
                             self.handle_ipc)
 
1013
    def handle_ipc(self, source, condition, file_objects={}):
 
1014
        condition_names = {
 
1015
            gobject.IO_IN: u"IN",   # There is data to read.
 
1016
            gobject.IO_OUT: u"OUT", # Data can be written (without
 
1017
                                    # blocking).
 
1018
            gobject.IO_PRI: u"PRI", # There is urgent data to read.
 
1019
            gobject.IO_ERR: u"ERR", # Error condition.
 
1020
            gobject.IO_HUP: u"HUP"  # Hung up (the connection has been
 
1021
                                    # broken, usually for pipes and
 
1022
                                    # sockets).
 
1023
            }
 
1024
        conditions_string = ' | '.join(name
 
1025
                                       for cond, name in
 
1026
                                       condition_names.iteritems()
 
1027
                                       if cond & condition)
 
1028
        logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
 
1029
                     conditions_string)
 
1030
        
 
1031
        # Turn the pipe file descriptor into a Python file object
 
1032
        if source not in file_objects:
 
1033
            file_objects[source] = os.fdopen(source, u"r", 1)
 
1034
        
 
1035
        # Read a line from the file object
 
1036
        cmdline = file_objects[source].readline()
 
1037
        if not cmdline:             # Empty line means end of file
 
1038
            # close the IPC pipe
 
1039
            file_objects[source].close()
 
1040
            del file_objects[source]
 
1041
            
 
1042
            # Stop calling this function
 
1043
            return False
 
1044
        
 
1045
        logger.debug(u"IPC command: %r", cmdline)
 
1046
        
 
1047
        # Parse and act on command
 
1048
        cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
 
1049
        
 
1050
        if cmd == u"NOTFOUND":
 
1051
            logger.warning(u"Client not found for fingerprint: %s",
 
1052
                           args)
 
1053
            if self.use_dbus:
 
1054
                # Emit D-Bus signal
 
1055
                mandos_dbus_service.ClientNotFound(args)
 
1056
        elif cmd == u"INVALID":
 
1057
            for client in self.clients:
 
1058
                if client.name == args:
 
1059
                    logger.warning(u"Client %s is invalid", args)
 
1060
                    if self.use_dbus:
 
1061
                        # Emit D-Bus signal
 
1062
                        client.Rejected()
 
1063
                    break
 
1064
            else:
 
1065
                logger.error(u"Unknown client %s is invalid", args)
 
1066
        elif cmd == u"SENDING":
 
1067
            for client in self.clients:
 
1068
                if client.name == args:
 
1069
                    logger.info(u"Sending secret to %s", client.name)
 
1070
                    client.checked_ok()
 
1071
                    if self.use_dbus:
 
1072
                        # Emit D-Bus signal
 
1073
                        client.ReceivedSecret()
 
1074
                    break
 
1075
            else:
 
1076
                logger.error(u"Sending secret to unknown client %s",
 
1077
                             args)
 
1078
        else:
 
1079
            logger.error(u"Unknown IPC command: %r", cmdline)
 
1080
        
 
1081
        # Keep calling this function
 
1082
        return True
562
1083
 
563
1084
 
564
1085
def string_to_delta(interval):
565
1086
    """Parse a string and return a datetime.timedelta
566
 
 
567
 
    >>> string_to_delta('7d')
 
1087
    
 
1088
    >>> string_to_delta(u'7d')
568
1089
    datetime.timedelta(7)
569
 
    >>> string_to_delta('60s')
 
1090
    >>> string_to_delta(u'60s')
570
1091
    datetime.timedelta(0, 60)
571
 
    >>> string_to_delta('60m')
 
1092
    >>> string_to_delta(u'60m')
572
1093
    datetime.timedelta(0, 3600)
573
 
    >>> string_to_delta('24h')
 
1094
    >>> string_to_delta(u'24h')
574
1095
    datetime.timedelta(1)
575
1096
    >>> string_to_delta(u'1w')
576
1097
    datetime.timedelta(7)
577
 
    >>> string_to_delta('5m 30s')
 
1098
    >>> string_to_delta(u'5m 30s')
578
1099
    datetime.timedelta(0, 330)
579
1100
    """
580
1101
    timevalue = datetime.timedelta(0)
581
1102
    for s in interval.split():
582
1103
        try:
583
 
            suffix=unicode(s[-1])
584
 
            value=int(s[:-1])
 
1104
            suffix = unicode(s[-1])
 
1105
            value = int(s[:-1])
585
1106
            if suffix == u"d":
586
1107
                delta = datetime.timedelta(value)
587
1108
            elif suffix == u"s":
600
1121
    return timevalue
601
1122
 
602
1123
 
603
 
def server_state_changed(state):
604
 
    """Derived from the Avahi example code"""
605
 
    if state == avahi.SERVER_COLLISION:
606
 
        logger.error(u"Server name collision")
607
 
        service.remove()
608
 
    elif state == avahi.SERVER_RUNNING:
609
 
        service.add()
610
 
 
611
 
 
612
 
def entry_group_state_changed(state, error):
613
 
    """Derived from the Avahi example code"""
614
 
    logger.debug(u"state change: %i", state)
615
 
    
616
 
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
617
 
        logger.debug(u"Service established.")
618
 
    elif state == avahi.ENTRY_GROUP_COLLISION:
619
 
        logger.warning(u"Service name collision.")
620
 
        service.rename()
621
 
    elif state == avahi.ENTRY_GROUP_FAILURE:
622
 
        logger.critical(u"Error in group state changed %s",
623
 
                        unicode(error))
624
 
        raise AvahiGroupError("State changed: %s", str(error))
625
 
 
626
1124
def if_nametoindex(interface):
627
 
    """Call the C function if_nametoindex(), or equivalent"""
 
1125
    """Call the C function if_nametoindex(), or equivalent
 
1126
    
 
1127
    Note: This function cannot accept a unicode string."""
628
1128
    global if_nametoindex
629
1129
    try:
630
 
        if "ctypes.util" not in sys.modules:
631
 
            import ctypes.util
632
 
        if_nametoindex = ctypes.cdll.LoadLibrary\
633
 
            (ctypes.util.find_library("c")).if_nametoindex
 
1130
        if_nametoindex = (ctypes.cdll.LoadLibrary
 
1131
                          (ctypes.util.find_library(u"c"))
 
1132
                          .if_nametoindex)
634
1133
    except (OSError, AttributeError):
635
 
        if "struct" not in sys.modules:
636
 
            import struct
637
 
        if "fcntl" not in sys.modules:
638
 
            import fcntl
 
1134
        logger.warning(u"Doing if_nametoindex the hard way")
639
1135
        def if_nametoindex(interface):
640
1136
            "Get an interface index the hard way, i.e. using fcntl()"
641
1137
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
642
 
            s = socket.socket()
643
 
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
644
 
                                struct.pack("16s16x", interface))
645
 
            s.close()
646
 
            interface_index = struct.unpack("I", ifreq[16:20])[0]
 
1138
            with closing(socket.socket()) as s:
 
1139
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
1140
                                    struct.pack(str(u"16s16x"),
 
1141
                                                interface))
 
1142
            interface_index = struct.unpack(str(u"I"),
 
1143
                                            ifreq[16:20])[0]
647
1144
            return interface_index
648
1145
    return if_nametoindex(interface)
649
1146
 
650
1147
 
651
1148
def daemon(nochdir = False, noclose = False):
652
1149
    """See daemon(3).  Standard BSD Unix function.
 
1150
    
653
1151
    This should really exist as os.daemon, but it doesn't (yet)."""
654
1152
    if os.fork():
655
1153
        sys.exit()
656
1154
    os.setsid()
657
1155
    if not nochdir:
658
 
        os.chdir("/")
 
1156
        os.chdir(u"/")
659
1157
    if os.fork():
660
1158
        sys.exit()
661
1159
    if not noclose:
663
1161
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
664
1162
        if not stat.S_ISCHR(os.fstat(null).st_mode):
665
1163
            raise OSError(errno.ENODEV,
666
 
                          "/dev/null not a character device")
 
1164
                          u"/dev/null not a character device")
667
1165
        os.dup2(null, sys.stdin.fileno())
668
1166
        os.dup2(null, sys.stdout.fileno())
669
1167
        os.dup2(null, sys.stderr.fileno())
672
1170
 
673
1171
 
674
1172
def main():
675
 
    global main_loop_started
676
 
    main_loop_started = False
677
 
    
678
 
    parser = OptionParser(version = "%%prog %s" % version)
679
 
    parser.add_option("-i", "--interface", type="string",
680
 
                      metavar="IF", help="Bind to interface IF")
681
 
    parser.add_option("-a", "--address", type="string",
682
 
                      help="Address to listen for requests on")
683
 
    parser.add_option("-p", "--port", type="int",
684
 
                      help="Port number to receive requests on")
685
 
    parser.add_option("--check", action="store_true", default=False,
686
 
                      help="Run self-test")
687
 
    parser.add_option("--debug", action="store_true",
688
 
                      help="Debug mode; run in foreground and log to"
689
 
                      " terminal")
690
 
    parser.add_option("--priority", type="string", help="GnuTLS"
691
 
                      " priority string (see GnuTLS documentation)")
692
 
    parser.add_option("--servicename", type="string", metavar="NAME",
693
 
                      help="Zeroconf service name")
694
 
    parser.add_option("--configdir", type="string",
695
 
                      default="/etc/mandos", metavar="DIR",
696
 
                      help="Directory to search for configuration"
697
 
                      " files")
698
 
    (options, args) = parser.parse_args()
 
1173
    
 
1174
    ##################################################################
 
1175
    # Parsing of options, both command line and config file
 
1176
    
 
1177
    parser = optparse.OptionParser(version = "%%prog %s" % version)
 
1178
    parser.add_option("-i", u"--interface", type=u"string",
 
1179
                      metavar="IF", help=u"Bind to interface IF")
 
1180
    parser.add_option("-a", u"--address", type=u"string",
 
1181
                      help=u"Address to listen for requests on")
 
1182
    parser.add_option("-p", u"--port", type=u"int",
 
1183
                      help=u"Port number to receive requests on")
 
1184
    parser.add_option("--check", action=u"store_true",
 
1185
                      help=u"Run self-test")
 
1186
    parser.add_option("--debug", action=u"store_true",
 
1187
                      help=u"Debug mode; run in foreground and log to"
 
1188
                      u" terminal")
 
1189
    parser.add_option("--priority", type=u"string", help=u"GnuTLS"
 
1190
                      u" priority string (see GnuTLS documentation)")
 
1191
    parser.add_option("--servicename", type=u"string",
 
1192
                      metavar=u"NAME", help=u"Zeroconf service name")
 
1193
    parser.add_option("--configdir", type=u"string",
 
1194
                      default=u"/etc/mandos", metavar=u"DIR",
 
1195
                      help=u"Directory to search for configuration"
 
1196
                      u" files")
 
1197
    parser.add_option("--no-dbus", action=u"store_false",
 
1198
                      dest=u"use_dbus", help=u"Do not provide D-Bus"
 
1199
                      u" system bus interface")
 
1200
    parser.add_option("--no-ipv6", action=u"store_false",
 
1201
                      dest=u"use_ipv6", help=u"Do not use IPv6")
 
1202
    options = parser.parse_args()[0]
699
1203
    
700
1204
    if options.check:
701
1205
        import doctest
703
1207
        sys.exit()
704
1208
    
705
1209
    # Default values for config file for server-global settings
706
 
    server_defaults = { "interface": "",
707
 
                        "address": "",
708
 
                        "port": "",
709
 
                        "debug": "False",
710
 
                        "priority":
711
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
712
 
                        "servicename": "Mandos",
 
1210
    server_defaults = { u"interface": u"",
 
1211
                        u"address": u"",
 
1212
                        u"port": u"",
 
1213
                        u"debug": u"False",
 
1214
                        u"priority":
 
1215
                        u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
1216
                        u"servicename": u"Mandos",
 
1217
                        u"use_dbus": u"True",
 
1218
                        u"use_ipv6": u"True",
713
1219
                        }
714
1220
    
715
1221
    # Parse config file for server-global settings
716
 
    server_config = ConfigParser.SafeConfigParser(server_defaults)
 
1222
    server_config = configparser.SafeConfigParser(server_defaults)
717
1223
    del server_defaults
718
 
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
 
1224
    server_config.read(os.path.join(options.configdir,
 
1225
                                    u"mandos.conf"))
719
1226
    # Convert the SafeConfigParser object to a dict
720
1227
    server_settings = server_config.defaults()
721
 
    # Use getboolean on the boolean config option
722
 
    server_settings["debug"] = server_config.getboolean\
723
 
                               ("DEFAULT", "debug")
 
1228
    # Use the appropriate methods on the non-string config options
 
1229
    for option in (u"debug", u"use_dbus", u"use_ipv6"):
 
1230
        server_settings[option] = server_config.getboolean(u"DEFAULT",
 
1231
                                                           option)
 
1232
    if server_settings["port"]:
 
1233
        server_settings["port"] = server_config.getint(u"DEFAULT",
 
1234
                                                       u"port")
724
1235
    del server_config
725
1236
    
726
1237
    # Override the settings from the config file with command line
727
1238
    # options, if set.
728
 
    for option in ("interface", "address", "port", "debug",
729
 
                   "priority", "servicename", "configdir"):
 
1239
    for option in (u"interface", u"address", u"port", u"debug",
 
1240
                   u"priority", u"servicename", u"configdir",
 
1241
                   u"use_dbus", u"use_ipv6"):
730
1242
        value = getattr(options, option)
731
1243
        if value is not None:
732
1244
            server_settings[option] = value
733
1245
    del options
 
1246
    # Force all strings to be unicode
 
1247
    for option in server_settings.keys():
 
1248
        if type(server_settings[option]) is str:
 
1249
            server_settings[option] = unicode(server_settings[option])
734
1250
    # Now we have our good server settings in "server_settings"
735
1251
    
736
 
    debug = server_settings["debug"]
 
1252
    ##################################################################
 
1253
    
 
1254
    # For convenience
 
1255
    debug = server_settings[u"debug"]
 
1256
    use_dbus = server_settings[u"use_dbus"]
 
1257
    use_ipv6 = server_settings[u"use_ipv6"]
737
1258
    
738
1259
    if not debug:
739
1260
        syslogger.setLevel(logging.WARNING)
740
1261
        console.setLevel(logging.WARNING)
741
1262
    
742
 
    if server_settings["servicename"] != "Mandos":
743
 
        syslogger.setFormatter(logging.Formatter\
744
 
                               ('Mandos (%s): %%(levelname)s:'
745
 
                                ' %%(message)s'
746
 
                                % server_settings["servicename"]))
 
1263
    if server_settings[u"servicename"] != u"Mandos":
 
1264
        syslogger.setFormatter(logging.Formatter
 
1265
                               (u'Mandos (%s) [%%(process)d]:'
 
1266
                                u' %%(levelname)s: %%(message)s'
 
1267
                                % server_settings[u"servicename"]))
747
1268
    
748
1269
    # Parse config file with clients
749
 
    client_defaults = { "timeout": "1h",
750
 
                        "interval": "5m",
751
 
                        "checker": "fping -q -- %(host)s",
752
 
                        "host": "",
 
1270
    client_defaults = { u"timeout": u"1h",
 
1271
                        u"interval": u"5m",
 
1272
                        u"checker": u"fping -q -- %%(host)s",
 
1273
                        u"host": u"",
753
1274
                        }
754
 
    client_config = ConfigParser.SafeConfigParser(client_defaults)
755
 
    client_config.read(os.path.join(server_settings["configdir"],
756
 
                                    "clients.conf"))
757
 
    
758
 
    global service
759
 
    service = AvahiService(name = server_settings["servicename"],
760
 
                           type = "_mandos._tcp", );
761
 
    if server_settings["interface"]:
762
 
        service.interface = if_nametoindex(server_settings["interface"])
 
1275
    client_config = configparser.SafeConfigParser(client_defaults)
 
1276
    client_config.read(os.path.join(server_settings[u"configdir"],
 
1277
                                    u"clients.conf"))
 
1278
    
 
1279
    global mandos_dbus_service
 
1280
    mandos_dbus_service = None
 
1281
    
 
1282
    tcp_server = MandosServer((server_settings[u"address"],
 
1283
                               server_settings[u"port"]),
 
1284
                              ClientHandler,
 
1285
                              interface=server_settings[u"interface"],
 
1286
                              use_ipv6=use_ipv6,
 
1287
                              gnutls_priority=
 
1288
                              server_settings[u"priority"],
 
1289
                              use_dbus=use_dbus)
 
1290
    pidfilename = u"/var/run/mandos.pid"
 
1291
    try:
 
1292
        pidfile = open(pidfilename, u"w")
 
1293
    except IOError:
 
1294
        logger.error(u"Could not open file %r", pidfilename)
 
1295
    
 
1296
    try:
 
1297
        uid = pwd.getpwnam(u"_mandos").pw_uid
 
1298
        gid = pwd.getpwnam(u"_mandos").pw_gid
 
1299
    except KeyError:
 
1300
        try:
 
1301
            uid = pwd.getpwnam(u"mandos").pw_uid
 
1302
            gid = pwd.getpwnam(u"mandos").pw_gid
 
1303
        except KeyError:
 
1304
            try:
 
1305
                uid = pwd.getpwnam(u"nobody").pw_uid
 
1306
                gid = pwd.getpwnam(u"nobody").pw_gid
 
1307
            except KeyError:
 
1308
                uid = 65534
 
1309
                gid = 65534
 
1310
    try:
 
1311
        os.setgid(gid)
 
1312
        os.setuid(uid)
 
1313
    except OSError, error:
 
1314
        if error[0] != errno.EPERM:
 
1315
            raise error
 
1316
    
 
1317
    # Enable all possible GnuTLS debugging
 
1318
    if debug:
 
1319
        # "Use a log level over 10 to enable all debugging options."
 
1320
        # - GnuTLS manual
 
1321
        gnutls.library.functions.gnutls_global_set_log_level(11)
 
1322
        
 
1323
        @gnutls.library.types.gnutls_log_func
 
1324
        def debug_gnutls(level, string):
 
1325
            logger.debug(u"GnuTLS: %s", string[:-1])
 
1326
        
 
1327
        (gnutls.library.functions
 
1328
         .gnutls_global_set_log_function(debug_gnutls))
763
1329
    
764
1330
    global main_loop
765
 
    global bus
766
 
    global server
767
1331
    # From the Avahi example code
768
1332
    DBusGMainLoop(set_as_default=True )
769
1333
    main_loop = gobject.MainLoop()
770
1334
    bus = dbus.SystemBus()
771
 
    server = dbus.Interface(
772
 
            bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
773
 
            avahi.DBUS_INTERFACE_SERVER )
774
1335
    # End of Avahi example code
775
 
    
776
 
    clients = Set()
777
 
    def remove_from_clients(client):
778
 
        clients.remove(client)
779
 
        if not clients:
780
 
            logger.critical(u"No clients left, exiting")
781
 
            sys.exit()
782
 
    
783
 
    clients.update(Set(Client(name = section,
784
 
                              stop_hook = remove_from_clients,
785
 
                              config
786
 
                              = dict(client_config.items(section)))
787
 
                       for section in client_config.sections()))
788
 
    if not clients:
789
 
        logger.critical(u"No clients defined")
790
 
        sys.exit(1)
 
1336
    if use_dbus:
 
1337
        bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
 
1338
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
1339
    service = AvahiService(name = server_settings[u"servicename"],
 
1340
                           servicetype = u"_mandos._tcp",
 
1341
                           protocol = protocol, bus = bus)
 
1342
    if server_settings["interface"]:
 
1343
        service.interface = (if_nametoindex
 
1344
                             (str(server_settings[u"interface"])))
 
1345
    
 
1346
    client_class = Client
 
1347
    if use_dbus:
 
1348
        client_class = functools.partial(ClientDBus, bus = bus)
 
1349
    tcp_server.clients.update(set(
 
1350
            client_class(name = section,
 
1351
                         config= dict(client_config.items(section)))
 
1352
            for section in client_config.sections()))
 
1353
    if not tcp_server.clients:
 
1354
        logger.warning(u"No clients defined")
791
1355
    
792
1356
    if debug:
793
1357
        # Redirect stdin so all checkers get /dev/null
801
1365
        # Close all input and output, do double fork, etc.
802
1366
        daemon()
803
1367
    
804
 
    pidfilename = "/var/run/mandos/mandos.pid"
805
 
    pid = os.getpid()
806
1368
    try:
807
 
        pidfile = open(pidfilename, "w")
808
 
        pidfile.write(str(pid) + "\n")
809
 
        pidfile.close()
 
1369
        with closing(pidfile):
 
1370
            pid = os.getpid()
 
1371
            pidfile.write(str(pid) + "\n")
810
1372
        del pidfile
811
 
    except IOError, err:
812
 
        logger.error(u"Could not write %s file with PID %d",
813
 
                     pidfilename, os.getpid())
 
1373
    except IOError:
 
1374
        logger.error(u"Could not write to file %r with PID %d",
 
1375
                     pidfilename, pid)
 
1376
    except NameError:
 
1377
        # "pidfile" was never created
 
1378
        pass
 
1379
    del pidfilename
814
1380
    
815
1381
    def cleanup():
816
1382
        "Cleanup function; run on exit"
817
 
        global group
818
 
        # From the Avahi example code
819
 
        if not group is None:
820
 
            group.Free()
821
 
            group = None
822
 
        # End of Avahi example code
 
1383
        service.cleanup()
823
1384
        
824
 
        while clients:
825
 
            client = clients.pop()
826
 
            client.stop_hook = None
827
 
            client.stop()
 
1385
        while tcp_server.clients:
 
1386
            client = tcp_server.clients.pop()
 
1387
            client.disable_hook = None
 
1388
            client.disable()
828
1389
    
829
1390
    atexit.register(cleanup)
830
1391
    
833
1394
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
834
1395
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
835
1396
    
836
 
    for client in clients:
837
 
        client.start()
838
 
    
839
 
    tcp_server = IPv6_TCPServer((server_settings["address"],
840
 
                                 server_settings["port"]),
841
 
                                tcp_handler,
842
 
                                settings=server_settings,
843
 
                                clients=clients)
 
1397
    if use_dbus:
 
1398
        class MandosDBusService(dbus.service.Object):
 
1399
            """A D-Bus proxy object"""
 
1400
            def __init__(self):
 
1401
                dbus.service.Object.__init__(self, bus, u"/")
 
1402
            _interface = u"se.bsnet.fukt.Mandos"
 
1403
            
 
1404
            @dbus.service.signal(_interface, signature=u"oa{sv}")
 
1405
            def ClientAdded(self, objpath, properties):
 
1406
                "D-Bus signal"
 
1407
                pass
 
1408
            
 
1409
            @dbus.service.signal(_interface, signature=u"s")
 
1410
            def ClientNotFound(self, fingerprint):
 
1411
                "D-Bus signal"
 
1412
                pass
 
1413
            
 
1414
            @dbus.service.signal(_interface, signature=u"os")
 
1415
            def ClientRemoved(self, objpath, name):
 
1416
                "D-Bus signal"
 
1417
                pass
 
1418
            
 
1419
            @dbus.service.method(_interface, out_signature=u"ao")
 
1420
            def GetAllClients(self):
 
1421
                "D-Bus method"
 
1422
                return dbus.Array(c.dbus_object_path
 
1423
                                  for c in tcp_server.clients)
 
1424
            
 
1425
            @dbus.service.method(_interface,
 
1426
                                 out_signature=u"a{oa{sv}}")
 
1427
            def GetAllClientsWithProperties(self):
 
1428
                "D-Bus method"
 
1429
                return dbus.Dictionary(
 
1430
                    ((c.dbus_object_path, c.GetAllProperties())
 
1431
                     for c in tcp_server.clients),
 
1432
                    signature=u"oa{sv}")
 
1433
            
 
1434
            @dbus.service.method(_interface, in_signature=u"o")
 
1435
            def RemoveClient(self, object_path):
 
1436
                "D-Bus method"
 
1437
                for c in tcp_server.clients:
 
1438
                    if c.dbus_object_path == object_path:
 
1439
                        tcp_server.clients.remove(c)
 
1440
                        c.remove_from_connection()
 
1441
                        # Don't signal anything except ClientRemoved
 
1442
                        c.disable(signal=False)
 
1443
                        # Emit D-Bus signal
 
1444
                        self.ClientRemoved(object_path, c.name)
 
1445
                        return
 
1446
                raise KeyError
 
1447
            
 
1448
            del _interface
 
1449
        
 
1450
        mandos_dbus_service = MandosDBusService()
 
1451
    
 
1452
    for client in tcp_server.clients:
 
1453
        if use_dbus:
 
1454
            # Emit D-Bus signal
 
1455
            mandos_dbus_service.ClientAdded(client.dbus_object_path,
 
1456
                                            client.GetAllProperties())
 
1457
        client.enable()
 
1458
    
 
1459
    tcp_server.enable()
 
1460
    tcp_server.server_activate()
 
1461
    
844
1462
    # Find out what port we got
845
1463
    service.port = tcp_server.socket.getsockname()[1]
846
 
    logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
847
 
                u" scope_id %d" % tcp_server.socket.getsockname())
 
1464
    if use_ipv6:
 
1465
        logger.info(u"Now listening on address %r, port %d,"
 
1466
                    " flowinfo %d, scope_id %d"
 
1467
                    % tcp_server.socket.getsockname())
 
1468
    else:                       # IPv4
 
1469
        logger.info(u"Now listening on address %r, port %d"
 
1470
                    % tcp_server.socket.getsockname())
848
1471
    
849
1472
    #service.interface = tcp_server.socket.getsockname()[3]
850
1473
    
851
1474
    try:
852
1475
        # From the Avahi example code
853
 
        server.connect_to_signal("StateChanged", server_state_changed)
854
1476
        try:
855
 
            server_state_changed(server.GetState())
 
1477
            service.activate()
856
1478
        except dbus.exceptions.DBusException, error:
857
1479
            logger.critical(u"DBusException: %s", error)
858
1480
            sys.exit(1)
860
1482
        
861
1483
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
862
1484
                             lambda *args, **kwargs:
863
 
                             tcp_server.handle_request\
864
 
                             (*args[2:], **kwargs) or True)
 
1485
                             (tcp_server.handle_request
 
1486
                              (*args[2:], **kwargs) or True))
865
1487
        
866
1488
        logger.debug(u"Starting main loop")
867
 
        main_loop_started = True
868
1489
        main_loop.run()
869
1490
    except AvahiError, error:
870
 
        logger.critical(u"AvahiError: %s" + unicode(error))
 
1491
        logger.critical(u"AvahiError: %s", error)
871
1492
        sys.exit(1)
872
1493
    except KeyboardInterrupt:
873
1494
        if debug:
874
 
            print
 
1495
            print >> sys.stderr
 
1496
        logger.debug(u"Server received KeyboardInterrupt")
 
1497
    logger.debug(u"Server exiting")
875
1498
 
876
1499
if __name__ == '__main__':
877
1500
    main()