/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2008-08-12 19:47:50 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080812194750-uebbpk9ynxt3sjnt
* initramfs-tools-hook (gpg): Added "--no-random-seed-file" and
                              "--no-default-keyring".  Bug fix: moved
                              "--import" to end.

* mandos-keygen (gpg): Added "--no-options".

Show diffs side-by-side

added added

removed removed

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