/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.11"
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 %s\n"
815
 
                          % (fpr, unicode(self.client_address)))
816
 
                session.bye()
817
 
                return
818
 
            # Have to check if client.still_valid(), since it is
819
 
            # possible that the client timed out while establishing
820
 
            # the GnuTLS session.
821
 
            if not client.still_valid():
822
 
                ipc.write(u"INVALID %s\n" % client.name)
823
 
                session.bye()
824
 
                return
825
 
            ipc.write(u"SENDING %s\n" % client.name)
826
 
            sent_size = 0
827
 
            while sent_size < len(client.secret):
828
 
                sent = session.send(client.secret[sent_size:])
829
 
                logger.debug(u"Sent: %d, remaining: %d",
830
 
                             sent, len(client.secret)
831
 
                             - (sent_size + sent))
832
 
                sent_size += sent
833
 
            session.bye()
834
 
    
835
 
    @staticmethod
836
 
    def peer_certificate(session):
837
 
        "Return the peer's OpenPGP certificate as a bytestring"
838
 
        # If not an OpenPGP certificate...
839
 
        if (gnutls.library.functions
840
 
            .gnutls_certificate_type_get(session._c_object)
841
 
            != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
842
 
            # ...do the normal thing
843
 
            return session.peer_certificate
844
 
        list_size = ctypes.c_uint(1)
845
 
        cert_list = (gnutls.library.functions
846
 
                     .gnutls_certificate_get_peers
847
 
                     (session._c_object, ctypes.byref(list_size)))
848
 
        if not bool(cert_list) and list_size.value != 0:
849
 
            raise gnutls.errors.GNUTLSError(u"error getting peer"
850
 
                                            u" certificate")
851
 
        if list_size.value == 0:
852
 
            return None
853
 
        cert = cert_list[0]
854
 
        return ctypes.string_at(cert.data, cert.size)
855
 
    
856
 
    @staticmethod
857
 
    def fingerprint(openpgp):
858
 
        "Convert an OpenPGP bytestring to a hexdigit fingerprint"
859
 
        # New GnuTLS "datum" with the OpenPGP public key
860
 
        datum = (gnutls.library.types
861
 
                 .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
862
 
                                             ctypes.POINTER
863
 
                                             (ctypes.c_ubyte)),
864
 
                                 ctypes.c_uint(len(openpgp))))
865
 
        # New empty GnuTLS certificate
866
 
        crt = gnutls.library.types.gnutls_openpgp_crt_t()
867
 
        (gnutls.library.functions
868
 
         .gnutls_openpgp_crt_init(ctypes.byref(crt)))
869
 
        # Import the OpenPGP public key into the certificate
870
 
        (gnutls.library.functions
871
 
         .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
872
 
                                    gnutls.library.constants
873
 
                                    .GNUTLS_OPENPGP_FMT_RAW))
874
 
        # Verify the self signature in the key
875
 
        crtverify = ctypes.c_uint()
876
 
        (gnutls.library.functions
877
 
         .gnutls_openpgp_crt_verify_self(crt, 0,
878
 
                                         ctypes.byref(crtverify)))
879
 
        if crtverify.value != 0:
880
 
            gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
881
 
            raise (gnutls.errors.CertificateSecurityError
882
 
                   (u"Verify failed"))
883
 
        # New buffer for the fingerprint
884
 
        buf = ctypes.create_string_buffer(20)
885
 
        buf_len = ctypes.c_size_t()
886
 
        # Get the fingerprint from the certificate into the buffer
887
 
        (gnutls.library.functions
888
 
         .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
889
 
                                             ctypes.byref(buf_len)))
890
 
        # Deinit the certificate
891
 
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
892
 
        # Convert the buffer to a Python bytestring
893
 
        fpr = ctypes.string_at(buf, buf_len.value)
894
 
        # Convert the bytestring to hexadecimal notation
895
 
        hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
896
 
        return hex_fpr
897
 
 
898
 
 
899
 
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
900
 
    """Like socketserver.ForkingMixIn, but also pass a pipe."""
901
 
    def process_request(self, request, client_address):
902
 
        """Overrides and wraps the original process_request().
903
 
        
904
 
        This function creates a new pipe in self.pipe
905
 
        """
906
 
        self.pipe = os.pipe()
907
 
        super(ForkingMixInWithPipe,
908
 
              self).process_request(request, client_address)
909
 
        os.close(self.pipe[1])  # close write end
910
 
        self.add_pipe(self.pipe[0])
911
 
    def add_pipe(self, pipe):
912
 
        """Dummy function; override as necessary"""
913
 
        os.close(pipe)
914
 
 
915
 
 
916
 
class IPv6_TCPServer(ForkingMixInWithPipe,
917
 
                     socketserver.TCPServer, object):
918
 
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
919
 
    
 
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.
920
744
    Attributes:
 
745
        settings:       Server settings
 
746
        clients:        Set() of Client objects
921
747
        enabled:        Boolean; whether this server is activated yet
922
 
        interface:      None or a network interface name (string)
923
 
        use_ipv6:       Boolean; to use IPv6 or not
924
748
    """
925
 
    def __init__(self, server_address, RequestHandlerClass,
926
 
                 interface=None, use_ipv6=True):
927
 
        self.interface = interface
928
 
        if use_ipv6:
929
 
            self.address_family = socket.AF_INET6
930
 
        socketserver.TCPServer.__init__(self, server_address,
931
 
                                        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)
932
763
    def server_bind(self):
933
764
        """This overrides the normal server_bind() function
934
765
        to bind to an interface if one was specified, and also NOT to
935
766
        bind to an address or port if they were not specified."""
936
 
        if self.interface is not None:
937
 
            if SO_BINDTODEVICE is None:
938
 
                logger.error(u"SO_BINDTODEVICE does not exist;"
939
 
                             u" cannot bind to interface %s",
940
 
                             self.interface)
941
 
            else:
942
 
                try:
943
 
                    self.socket.setsockopt(socket.SOL_SOCKET,
944
 
                                           SO_BINDTODEVICE,
945
 
                                           str(self.interface
946
 
                                               + u'\0'))
947
 
                except socket.error, error:
948
 
                    if error[0] == errno.EPERM:
949
 
                        logger.error(u"No permission to"
950
 
                                     u" bind to interface %s",
951
 
                                     self.interface)
952
 
                    elif error[0] == errno.ENOPROTOOPT:
953
 
                        logger.error(u"SO_BINDTODEVICE not available;"
954
 
                                     u" cannot bind to interface %s",
955
 
                                     self.interface)
956
 
                    else:
957
 
                        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
958
781
        # Only bind(2) the socket if we really need to.
959
782
        if self.server_address[0] or self.server_address[1]:
960
783
            if not self.server_address[0]:
961
784
                if self.address_family == socket.AF_INET6:
962
 
                    any_address = u"::" # in6addr_any
 
785
                    any_address = "::" # in6addr_any
963
786
                else:
964
787
                    any_address = socket.INADDR_ANY
965
788
                self.server_address = (any_address,
967
790
            elif not self.server_address[1]:
968
791
                self.server_address = (self.server_address[0],
969
792
                                       0)
970
 
#                 if self.interface:
 
793
#                 if self.settings["interface"]:
971
794
#                     self.server_address = (self.server_address[0],
972
795
#                                            0, # port
973
796
#                                            0, # flowinfo
974
797
#                                            if_nametoindex
975
 
#                                            (self.interface))
976
 
            return socketserver.TCPServer.server_bind(self)
977
 
 
978
 
 
979
 
class MandosServer(IPv6_TCPServer):
980
 
    """Mandos server.
981
 
    
982
 
    Attributes:
983
 
        clients:        set of Client objects
984
 
        gnutls_priority GnuTLS priority string
985
 
        use_dbus:       Boolean; to emit D-Bus signals or not
986
 
        clients:        set of Client objects
987
 
        gnutls_priority GnuTLS priority string
988
 
        use_dbus:       Boolean; to emit D-Bus signals or not
989
 
    
990
 
    Assumes a gobject.MainLoop event loop.
991
 
    """
992
 
    def __init__(self, server_address, RequestHandlerClass,
993
 
                 interface=None, use_ipv6=True, clients=None,
994
 
                 gnutls_priority=None, use_dbus=True):
995
 
        self.enabled = False
996
 
        self.clients = clients
997
 
        if self.clients is None:
998
 
            self.clients = set()
999
 
        self.use_dbus = use_dbus
1000
 
        self.gnutls_priority = gnutls_priority
1001
 
        IPv6_TCPServer.__init__(self, server_address,
1002
 
                                RequestHandlerClass,
1003
 
                                interface = interface,
1004
 
                                use_ipv6 = use_ipv6)
 
798
#                                            (self.settings
 
799
#                                             ["interface"]))
 
800
            return super(IPv6_TCPServer, self).server_bind()
1005
801
    def server_activate(self):
1006
802
        if self.enabled:
1007
 
            return socketserver.TCPServer.server_activate(self)
 
803
            return super(IPv6_TCPServer, self).server_activate()
1008
804
    def enable(self):
1009
805
        self.enabled = True
1010
 
    def add_pipe(self, pipe):
1011
 
        # Call "handle_ipc" for both data and EOF events
1012
 
        gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1013
 
                             self.handle_ipc)
1014
 
    def handle_ipc(self, source, condition, file_objects={}):
1015
 
        condition_names = {
1016
 
            gobject.IO_IN: u"IN",   # There is data to read.
1017
 
            gobject.IO_OUT: u"OUT", # Data can be written (without
1018
 
                                    # blocking).
1019
 
            gobject.IO_PRI: u"PRI", # There is urgent data to read.
1020
 
            gobject.IO_ERR: u"ERR", # Error condition.
1021
 
            gobject.IO_HUP: u"HUP"  # Hung up (the connection has been
1022
 
                                    # broken, usually for pipes and
1023
 
                                    # sockets).
1024
 
            }
1025
 
        conditions_string = ' | '.join(name
1026
 
                                       for cond, name in
1027
 
                                       condition_names.iteritems()
1028
 
                                       if cond & condition)
1029
 
        logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1030
 
                     conditions_string)
1031
 
        
1032
 
        # Turn the pipe file descriptor into a Python file object
1033
 
        if source not in file_objects:
1034
 
            file_objects[source] = os.fdopen(source, u"r", 1)
1035
 
        
1036
 
        # Read a line from the file object
1037
 
        cmdline = file_objects[source].readline()
1038
 
        if not cmdline:             # Empty line means end of file
1039
 
            # close the IPC pipe
1040
 
            file_objects[source].close()
1041
 
            del file_objects[source]
1042
 
            
1043
 
            # Stop calling this function
1044
 
            return False
1045
 
        
1046
 
        logger.debug(u"IPC command: %r", cmdline)
1047
 
        
1048
 
        # Parse and act on command
1049
 
        cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1050
 
        
1051
 
        if cmd == u"NOTFOUND":
1052
 
            logger.warning(u"Client not found for fingerprint: %s",
1053
 
                           args)
1054
 
            if self.use_dbus:
1055
 
                # Emit D-Bus signal
1056
 
                mandos_dbus_service.ClientNotFound(args)
1057
 
        elif cmd == u"INVALID":
1058
 
            for client in self.clients:
1059
 
                if client.name == args:
1060
 
                    logger.warning(u"Client %s is invalid", args)
1061
 
                    if self.use_dbus:
1062
 
                        # Emit D-Bus signal
1063
 
                        client.Rejected()
1064
 
                    break
1065
 
            else:
1066
 
                logger.error(u"Unknown client %s is invalid", args)
1067
 
        elif cmd == u"SENDING":
1068
 
            for client in self.clients:
1069
 
                if client.name == args:
1070
 
                    logger.info(u"Sending secret to %s", client.name)
1071
 
                    client.checked_ok()
1072
 
                    if self.use_dbus:
1073
 
                        # Emit D-Bus signal
1074
 
                        client.ReceivedSecret()
1075
 
                    break
1076
 
            else:
1077
 
                logger.error(u"Sending secret to unknown client %s",
1078
 
                             args)
1079
 
        else:
1080
 
            logger.error(u"Unknown IPC command: %r", cmdline)
1081
 
        
1082
 
        # Keep calling this function
1083
 
        return True
1084
806
 
1085
807
 
1086
808
def string_to_delta(interval):
1087
809
    """Parse a string and return a datetime.timedelta
1088
810
    
1089
 
    >>> string_to_delta(u'7d')
 
811
    >>> string_to_delta('7d')
1090
812
    datetime.timedelta(7)
1091
 
    >>> string_to_delta(u'60s')
 
813
    >>> string_to_delta('60s')
1092
814
    datetime.timedelta(0, 60)
1093
 
    >>> string_to_delta(u'60m')
 
815
    >>> string_to_delta('60m')
1094
816
    datetime.timedelta(0, 3600)
1095
 
    >>> string_to_delta(u'24h')
 
817
    >>> string_to_delta('24h')
1096
818
    datetime.timedelta(1)
1097
819
    >>> string_to_delta(u'1w')
1098
820
    datetime.timedelta(7)
1099
 
    >>> string_to_delta(u'5m 30s')
 
821
    >>> string_to_delta('5m 30s')
1100
822
    datetime.timedelta(0, 330)
1101
823
    """
1102
824
    timevalue = datetime.timedelta(0)
1122
844
    return timevalue
1123
845
 
1124
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
 
1125
870
def if_nametoindex(interface):
1126
 
    """Call the C function if_nametoindex(), or equivalent
1127
 
    
1128
 
    Note: This function cannot accept a unicode string."""
 
871
    """Call the C function if_nametoindex(), or equivalent"""
1129
872
    global if_nametoindex
1130
873
    try:
1131
874
        if_nametoindex = (ctypes.cdll.LoadLibrary
1132
 
                          (ctypes.util.find_library(u"c"))
 
875
                          (ctypes.util.find_library("c"))
1133
876
                          .if_nametoindex)
1134
877
    except (OSError, AttributeError):
1135
 
        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
1136
882
        def if_nametoindex(interface):
1137
883
            "Get an interface index the hard way, i.e. using fcntl()"
1138
884
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
1139
885
            with closing(socket.socket()) as s:
1140
886
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1141
 
                                    struct.pack(str(u"16s16x"),
1142
 
                                                interface))
1143
 
            interface_index = struct.unpack(str(u"I"),
1144
 
                                            ifreq[16:20])[0]
 
887
                                    struct.pack("16s16x", interface))
 
888
            interface_index = struct.unpack("I", ifreq[16:20])[0]
1145
889
            return interface_index
1146
890
    return if_nametoindex(interface)
1147
891
 
1148
892
 
1149
893
def daemon(nochdir = False, noclose = False):
1150
894
    """See daemon(3).  Standard BSD Unix function.
1151
 
    
1152
895
    This should really exist as os.daemon, but it doesn't (yet)."""
1153
896
    if os.fork():
1154
897
        sys.exit()
1155
898
    os.setsid()
1156
899
    if not nochdir:
1157
 
        os.chdir(u"/")
 
900
        os.chdir("/")
1158
901
    if os.fork():
1159
902
        sys.exit()
1160
903
    if not noclose:
1162
905
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1163
906
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1164
907
            raise OSError(errno.ENODEV,
1165
 
                          u"/dev/null not a character device")
 
908
                          "/dev/null not a character device")
1166
909
        os.dup2(null, sys.stdin.fileno())
1167
910
        os.dup2(null, sys.stdout.fileno())
1168
911
        os.dup2(null, sys.stderr.fileno())
1171
914
 
1172
915
 
1173
916
def main():
1174
 
    
1175
 
    ######################################################################
1176
 
    # Parsing of options, both command line and config file
1177
 
    
1178
917
    parser = optparse.OptionParser(version = "%%prog %s" % version)
1179
 
    parser.add_option("-i", u"--interface", type=u"string",
1180
 
                      metavar="IF", help=u"Bind to interface IF")
1181
 
    parser.add_option("-a", u"--address", type=u"string",
1182
 
                      help=u"Address to listen for requests on")
1183
 
    parser.add_option("-p", u"--port", type=u"int",
1184
 
                      help=u"Port number to receive requests on")
1185
 
    parser.add_option("--check", action=u"store_true",
1186
 
                      help=u"Run self-test")
1187
 
    parser.add_option("--debug", action=u"store_true",
1188
 
                      help=u"Debug mode; run in foreground and log to"
1189
 
                      u" terminal")
1190
 
    parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1191
 
                      u" priority string (see GnuTLS documentation)")
1192
 
    parser.add_option("--servicename", type=u"string",
1193
 
                      metavar=u"NAME", help=u"Zeroconf service name")
1194
 
    parser.add_option("--configdir", type=u"string",
1195
 
                      default=u"/etc/mandos", metavar=u"DIR",
1196
 
                      help=u"Directory to search for configuration"
1197
 
                      u" files")
1198
 
    parser.add_option("--no-dbus", action=u"store_false",
1199
 
                      dest=u"use_dbus", help=u"Do not provide D-Bus"
1200
 
                      u" system bus interface")
1201
 
    parser.add_option("--no-ipv6", action=u"store_false",
1202
 
                      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")
1203
943
    options = parser.parse_args()[0]
1204
944
    
1205
945
    if options.check:
1208
948
        sys.exit()
1209
949
    
1210
950
    # Default values for config file for server-global settings
1211
 
    server_defaults = { u"interface": u"",
1212
 
                        u"address": u"",
1213
 
                        u"port": u"",
1214
 
                        u"debug": u"False",
1215
 
                        u"priority":
1216
 
                        u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1217
 
                        u"servicename": u"Mandos",
1218
 
                        u"use_dbus": u"True",
1219
 
                        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",
1220
960
                        }
1221
961
    
1222
962
    # Parse config file for server-global settings
1223
 
    server_config = configparser.SafeConfigParser(server_defaults)
 
963
    server_config = ConfigParser.SafeConfigParser(server_defaults)
1224
964
    del server_defaults
1225
 
    server_config.read(os.path.join(options.configdir,
1226
 
                                    u"mandos.conf"))
 
965
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
1227
966
    # Convert the SafeConfigParser object to a dict
1228
967
    server_settings = server_config.defaults()
1229
968
    # Use the appropriate methods on the non-string config options
1230
 
    for option in (u"debug", u"use_dbus", u"use_ipv6"):
1231
 
        server_settings[option] = server_config.getboolean(u"DEFAULT",
1232
 
                                                           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")
1233
975
    if server_settings["port"]:
1234
 
        server_settings["port"] = server_config.getint(u"DEFAULT",
1235
 
                                                       u"port")
 
976
        server_settings["port"] = server_config.getint("DEFAULT",
 
977
                                                       "port")
1236
978
    del server_config
1237
979
    
1238
980
    # Override the settings from the config file with command line
1239
981
    # options, if set.
1240
 
    for option in (u"interface", u"address", u"port", u"debug",
1241
 
                   u"priority", u"servicename", u"configdir",
1242
 
                   u"use_dbus", u"use_ipv6"):
 
982
    for option in ("interface", "address", "port", "debug",
 
983
                   "priority", "servicename", "configdir",
 
984
                   "use_dbus", "use_ipv6"):
1243
985
        value = getattr(options, option)
1244
986
        if value is not None:
1245
987
            server_settings[option] = value
1246
988
    del options
1247
 
    # Force all strings to be unicode
1248
 
    for option in server_settings.keys():
1249
 
        if type(server_settings[option]) is str:
1250
 
            server_settings[option] = unicode(server_settings[option])
1251
989
    # Now we have our good server settings in "server_settings"
1252
990
    
1253
 
    ##################################################################
1254
 
    
1255
991
    # For convenience
1256
 
    debug = server_settings[u"debug"]
1257
 
    use_dbus = server_settings[u"use_dbus"]
1258
 
    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"]
1259
995
    
1260
996
    if not debug:
1261
997
        syslogger.setLevel(logging.WARNING)
1262
998
        console.setLevel(logging.WARNING)
1263
999
    
1264
 
    if server_settings[u"servicename"] != u"Mandos":
 
1000
    if server_settings["servicename"] != "Mandos":
1265
1001
        syslogger.setFormatter(logging.Formatter
1266
 
                               (u'Mandos (%s) [%%(process)d]:'
1267
 
                                u' %%(levelname)s: %%(message)s'
1268
 
                                % server_settings[u"servicename"]))
 
1002
                               ('Mandos (%s): %%(levelname)s:'
 
1003
                                ' %%(message)s'
 
1004
                                % server_settings["servicename"]))
1269
1005
    
1270
1006
    # Parse config file with clients
1271
 
    client_defaults = { u"timeout": u"1h",
1272
 
                        u"interval": u"5m",
1273
 
                        u"checker": u"fping -q -- %%(host)s",
1274
 
                        u"host": u"",
 
1007
    client_defaults = { "timeout": "1h",
 
1008
                        "interval": "5m",
 
1009
                        "checker": "fping -q -- %%(host)s",
 
1010
                        "host": "",
1275
1011
                        }
1276
 
    client_config = configparser.SafeConfigParser(client_defaults)
1277
 
    client_config.read(os.path.join(server_settings[u"configdir"],
1278
 
                                    u"clients.conf"))
1279
 
    
1280
 
    global mandos_dbus_service
1281
 
    mandos_dbus_service = None
1282
 
    
1283
 
    tcp_server = MandosServer((server_settings[u"address"],
1284
 
                               server_settings[u"port"]),
1285
 
                              ClientHandler,
1286
 
                              interface=server_settings[u"interface"],
1287
 
                              use_ipv6=use_ipv6,
1288
 
                              gnutls_priority=
1289
 
                              server_settings[u"priority"],
1290
 
                              use_dbus=use_dbus)
1291
 
    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"
1292
1023
    try:
1293
 
        pidfile = open(pidfilename, u"w")
 
1024
        pidfile = open(pidfilename, "w")
1294
1025
    except IOError:
1295
 
        logger.error(u"Could not open file %r", pidfilename)
 
1026
        logger.error("Could not open file %r", pidfilename)
1296
1027
    
1297
1028
    try:
1298
 
        uid = pwd.getpwnam(u"_mandos").pw_uid
1299
 
        gid = pwd.getpwnam(u"_mandos").pw_gid
 
1029
        uid = pwd.getpwnam("_mandos").pw_uid
 
1030
        gid = pwd.getpwnam("_mandos").pw_gid
1300
1031
    except KeyError:
1301
1032
        try:
1302
 
            uid = pwd.getpwnam(u"mandos").pw_uid
1303
 
            gid = pwd.getpwnam(u"mandos").pw_gid
 
1033
            uid = pwd.getpwnam("mandos").pw_uid
 
1034
            gid = pwd.getpwnam("mandos").pw_gid
1304
1035
        except KeyError:
1305
1036
            try:
1306
 
                uid = pwd.getpwnam(u"nobody").pw_uid
1307
 
                gid = pwd.getpwnam(u"nobody").pw_gid
 
1037
                uid = pwd.getpwnam("nobody").pw_uid
 
1038
                gid = pwd.getpwnam("nogroup").pw_gid
1308
1039
            except KeyError:
1309
1040
                uid = 65534
1310
1041
                gid = 65534
1323
1054
        
1324
1055
        @gnutls.library.types.gnutls_log_func
1325
1056
        def debug_gnutls(level, string):
1326
 
            logger.debug(u"GnuTLS: %s", string[:-1])
 
1057
            logger.debug("GnuTLS: %s", string[:-1])
1327
1058
        
1328
1059
        (gnutls.library.functions
1329
1060
         .gnutls_global_set_log_function(debug_gnutls))
1330
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
    
1331
1071
    global main_loop
 
1072
    global bus
 
1073
    global server
1332
1074
    # From the Avahi example code
1333
1075
    DBusGMainLoop(set_as_default=True )
1334
1076
    main_loop = gobject.MainLoop()
1335
1077
    bus = dbus.SystemBus()
 
1078
    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
 
1079
                                           avahi.DBUS_PATH_SERVER),
 
1080
                            avahi.DBUS_INTERFACE_SERVER)
1336
1081
    # End of Avahi example code
1337
1082
    if use_dbus:
1338
1083
        bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1339
 
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1340
 
    service = AvahiService(name = server_settings[u"servicename"],
1341
 
                           servicetype = u"_mandos._tcp",
1342
 
                           protocol = protocol, bus = bus)
1343
 
    if server_settings["interface"]:
1344
 
        service.interface = (if_nametoindex
1345
 
                             (str(server_settings[u"interface"])))
1346
1084
    
1347
 
    client_class = Client
1348
 
    if use_dbus:
1349
 
        client_class = functools.partial(ClientDBus, bus = bus)
1350
 
    tcp_server.clients.update(set(
1351
 
            client_class(name = section,
1352
 
                         config= dict(client_config.items(section)))
1353
 
            for section in client_config.sections()))
1354
 
    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:
1355
1091
        logger.warning(u"No clients defined")
1356
1092
    
1357
1093
    if debug:
1367
1103
        daemon()
1368
1104
    
1369
1105
    try:
1370
 
        with closing(pidfile):
1371
 
            pid = os.getpid()
1372
 
            pidfile.write(str(pid) + "\n")
 
1106
        pid = os.getpid()
 
1107
        pidfile.write(str(pid) + "\n")
 
1108
        pidfile.close()
1373
1109
        del pidfile
1374
1110
    except IOError:
1375
1111
        logger.error(u"Could not write to file %r with PID %d",
1381
1117
    
1382
1118
    def cleanup():
1383
1119
        "Cleanup function; run on exit"
1384
 
        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
1385
1126
        
1386
 
        while tcp_server.clients:
1387
 
            client = tcp_server.clients.pop()
 
1127
        while clients:
 
1128
            client = clients.pop()
1388
1129
            client.disable_hook = None
1389
1130
            client.disable()
1390
1131
    
1396
1137
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1397
1138
    
1398
1139
    if use_dbus:
1399
 
        class MandosDBusService(dbus.service.Object):
 
1140
        class MandosServer(dbus.service.Object):
1400
1141
            """A D-Bus proxy object"""
1401
1142
            def __init__(self):
1402
 
                dbus.service.Object.__init__(self, bus, u"/")
 
1143
                dbus.service.Object.__init__(self, bus, "/")
1403
1144
            _interface = u"se.bsnet.fukt.Mandos"
1404
1145
            
1405
 
            @dbus.service.signal(_interface, signature=u"oa{sv}")
 
1146
            @dbus.service.signal(_interface, signature="oa{sv}")
1406
1147
            def ClientAdded(self, objpath, properties):
1407
1148
                "D-Bus signal"
1408
1149
                pass
1409
1150
            
1410
 
            @dbus.service.signal(_interface, signature=u"s")
1411
 
            def ClientNotFound(self, fingerprint):
1412
 
                "D-Bus signal"
1413
 
                pass
1414
 
            
1415
 
            @dbus.service.signal(_interface, signature=u"os")
 
1151
            @dbus.service.signal(_interface, signature="os")
1416
1152
            def ClientRemoved(self, objpath, name):
1417
1153
                "D-Bus signal"
1418
1154
                pass
1419
1155
            
1420
 
            @dbus.service.method(_interface, out_signature=u"ao")
 
1156
            @dbus.service.method(_interface, out_signature="ao")
1421
1157
            def GetAllClients(self):
1422
1158
                "D-Bus method"
1423
 
                return dbus.Array(c.dbus_object_path
1424
 
                                  for c in tcp_server.clients)
 
1159
                return dbus.Array(c.dbus_object_path for c in clients)
1425
1160
            
1426
 
            @dbus.service.method(_interface,
1427
 
                                 out_signature=u"a{oa{sv}}")
 
1161
            @dbus.service.method(_interface, out_signature="a{oa{sv}}")
1428
1162
            def GetAllClientsWithProperties(self):
1429
1163
                "D-Bus method"
1430
1164
                return dbus.Dictionary(
1431
1165
                    ((c.dbus_object_path, c.GetAllProperties())
1432
 
                     for c in tcp_server.clients),
1433
 
                    signature=u"oa{sv}")
 
1166
                     for c in clients),
 
1167
                    signature="oa{sv}")
1434
1168
            
1435
 
            @dbus.service.method(_interface, in_signature=u"o")
 
1169
            @dbus.service.method(_interface, in_signature="o")
1436
1170
            def RemoveClient(self, object_path):
1437
1171
                "D-Bus method"
1438
 
                for c in tcp_server.clients:
 
1172
                for c in clients:
1439
1173
                    if c.dbus_object_path == object_path:
1440
 
                        tcp_server.clients.remove(c)
1441
 
                        c.remove_from_connection()
 
1174
                        clients.remove(c)
1442
1175
                        # Don't signal anything except ClientRemoved
1443
 
                        c.disable(signal=False)
 
1176
                        c.use_dbus = False
 
1177
                        c.disable()
1444
1178
                        # Emit D-Bus signal
1445
1179
                        self.ClientRemoved(object_path, c.name)
1446
1180
                        return
1448
1182
            
1449
1183
            del _interface
1450
1184
        
1451
 
        mandos_dbus_service = MandosDBusService()
 
1185
        mandos_server = MandosServer()
1452
1186
    
1453
 
    for client in tcp_server.clients:
 
1187
    for client in clients:
1454
1188
        if use_dbus:
1455
1189
            # Emit D-Bus signal
1456
 
            mandos_dbus_service.ClientAdded(client.dbus_object_path,
1457
 
                                            client.GetAllProperties())
 
1190
            mandos_server.ClientAdded(client.dbus_object_path,
 
1191
                                      client.GetAllProperties())
1458
1192
        client.enable()
1459
1193
    
1460
1194
    tcp_server.enable()
1474
1208
    
1475
1209
    try:
1476
1210
        # From the Avahi example code
 
1211
        server.connect_to_signal("StateChanged", server_state_changed)
1477
1212
        try:
1478
 
            service.activate()
 
1213
            server_state_changed(server.GetState())
1479
1214
        except dbus.exceptions.DBusException, error:
1480
1215
            logger.critical(u"DBusException: %s", error)
1481
1216
            sys.exit(1)
1494
1229
    except KeyboardInterrupt:
1495
1230
        if debug:
1496
1231
            print >> sys.stderr
1497
 
        logger.debug(u"Server received KeyboardInterrupt")
1498
 
    logger.debug(u"Server exiting")
 
1232
        logger.debug("Server received KeyboardInterrupt")
 
1233
    logger.debug("Server exiting")
1499
1234
 
1500
1235
if __name__ == '__main__':
1501
1236
    main()