/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2009-02-13 05:38:21 UTC
  • Revision ID: teddy@fukt.bsnet.se-20090213053821-03e696gckk4nbjps
Support not using IPv6 in server:

* mandos (AvahiService.__init__): Take new "protocol" parameter.  All
                                  callers changed.
  (IPv6_TCPServer.__init__): Take new "use_ipv6" parameter.  All
                             callers changed.
  (IPv6_TCPServer.server_bind): Create IPv4 socket if not using IPv6.
  (main): New "--no-ipv6" command line option.  New "use_ipv6" config
          option.
* mandos-options.xml ([@id="address"]): Document conditional IPv4
                                        address support.
  ([@id="ipv6"]): New paragraph.
* mandos.conf (use_ipv6): New config option.
* mandos.conf.xml (OPTIONS): Document new "use_dbus" option.
  (EXAMPLE): Changed to use IPv6 link-local address.  Added "use_ipv6"
             option.
* mandos.xml (SYNOPSIS): New "--no-ipv6" option.
  (OPTIONS): Document new "--no-ipv6" option.

Show diffs side-by-side

added added

removed removed

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