/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: 2008-12-21 19:19:25 UTC
  • mfrom: (24.1.116 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20081221191925-iw4js3mr8e04p35r
Merge "mandos-list" from belorn.

* Makefile (PROGS): Added "mandos-list".
  (mandos-list): New.

* mandos-list: New; from merge.  Added unicode support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1
1
#!/usr/bin/python
 
2
# -*- mode: python; coding: utf-8 -*-
 
3
# 
 
4
# Mandos server - give out binary blobs to connecting clients.
 
5
# 
 
6
# This program is partly derived from an example program for an Avahi
 
7
# service publisher, downloaded from
 
8
# <http://avahi.org/wiki/PythonPublishExample>.  This includes the
 
9
# methods "add" and "remove" in the "AvahiService" class, the
 
10
# "server_state_changed" and "entry_group_state_changed" functions,
 
11
# and some lines in "main".
 
12
# 
 
13
# Everything else is
 
14
# Copyright © 2008 Teddy Hogeborn
 
15
# Copyright © 2008 Björn Påhlsson
 
16
# 
 
17
# This program is free software: you can redistribute it and/or modify
 
18
# it under the terms of the GNU General Public License as published by
 
19
# the Free Software Foundation, either version 3 of the License, or
 
20
# (at your option) any later version.
 
21
#
 
22
#     This program is distributed in the hope that it will be useful,
 
23
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
24
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
25
#     GNU General Public License for more details.
 
26
# 
 
27
# You should have received a copy of the GNU General Public License
 
28
# along with this program.  If not, see
 
29
# <http://www.gnu.org/licenses/>.
 
30
# 
 
31
# Contact the authors at <mandos@fukt.bsnet.se>.
 
32
# 
 
33
 
 
34
from __future__ import division, with_statement, absolute_import
2
35
 
3
36
import SocketServer
4
37
import socket
5
 
import select
6
38
from optparse import OptionParser
7
39
import datetime
8
40
import errno
9
41
import gnutls.crypto
10
42
import gnutls.connection
11
43
import gnutls.errors
 
44
import gnutls.library.functions
 
45
import gnutls.library.constants
 
46
import gnutls.library.types
12
47
import ConfigParser
13
48
import sys
14
 
 
15
 
 
16
 
class Client(object):
17
 
    def __init__(self, name=None, options=None, dn=None,
18
 
                 password=None, passfile=None, fqdn=None,
19
 
                 timeout=None, interval=-1):
20
 
        self.name = name
21
 
        self.dn = dn
22
 
        if password:
23
 
            self.password = password
24
 
        elif passfile:
25
 
            self.password = open(passfile).readall()
26
 
        else:
27
 
            print "No Password or Passfile in client config file"
28
 
            # raise RuntimeError XXX
29
 
            self.password = "gazonk"
30
 
        self.fqdn = fqdn
31
 
        self.created = datetime.datetime.now()
32
 
        self.last_seen = None
33
 
        if timeout is None:
34
 
            timeout = options.timeout
35
 
        self.timeout = timeout
36
 
        if interval == -1:
37
 
            interval = options.interval
38
 
        self.interval = interval
39
 
        self.next_check = datetime.datetime.now()
40
 
 
41
 
 
42
 
class server_metaclass(type):
43
 
    "Common behavior for the UDP and TCP server classes"
44
 
    def __new__(cls, name, bases, attrs):
45
 
        attrs["address_family"] = socket.AF_INET6
46
 
        attrs["allow_reuse_address"] = True
47
 
        def server_bind(self):
48
 
            if self.options.interface:
49
 
                if not hasattr(socket, "SO_BINDTODEVICE"):
50
 
                    # From /usr/include/asm-i486/socket.h
51
 
                    socket.SO_BINDTODEVICE = 25
 
49
import re
 
50
import os
 
51
import signal
 
52
from sets import Set
 
53
import subprocess
 
54
import atexit
 
55
import stat
 
56
import logging
 
57
import logging.handlers
 
58
import pwd
 
59
from contextlib import closing
 
60
 
 
61
import dbus
 
62
import dbus.service
 
63
import gobject
 
64
import avahi
 
65
from dbus.mainloop.glib import DBusGMainLoop
 
66
import ctypes
 
67
import ctypes.util
 
68
 
 
69
version = "1.0.2"
 
70
 
 
71
logger = logging.Logger('mandos')
 
72
syslogger = (logging.handlers.SysLogHandler
 
73
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
74
              address = "/dev/log"))
 
75
syslogger.setFormatter(logging.Formatter
 
76
                       ('Mandos: %(levelname)s: %(message)s'))
 
77
logger.addHandler(syslogger)
 
78
 
 
79
console = logging.StreamHandler()
 
80
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
 
81
                                       ' %(message)s'))
 
82
logger.addHandler(console)
 
83
 
 
84
class AvahiError(Exception):
 
85
    def __init__(self, value):
 
86
        self.value = value
 
87
        super(AvahiError, self).__init__()
 
88
    def __str__(self):
 
89
        return repr(self.value)
 
90
 
 
91
class AvahiServiceError(AvahiError):
 
92
    pass
 
93
 
 
94
class AvahiGroupError(AvahiError):
 
95
    pass
 
96
 
 
97
 
 
98
class AvahiService(object):
 
99
    """An Avahi (Zeroconf) service.
 
100
    Attributes:
 
101
    interface: integer; avahi.IF_UNSPEC or an interface index.
 
102
               Used to optionally bind to the specified interface.
 
103
    name: string; Example: 'Mandos'
 
104
    type: string; Example: '_mandos._tcp'.
 
105
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
106
    port: integer; what port to announce
 
107
    TXT: list of strings; TXT record for the service
 
108
    domain: string; Domain to publish on, default to .local if empty.
 
109
    host: string; Host to publish records for, default is localhost
 
110
    max_renames: integer; maximum number of renames
 
111
    rename_count: integer; counter so we only rename after collisions
 
112
                  a sensible number of times
 
113
    """
 
114
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
 
115
                 servicetype = None, port = None, TXT = None,
 
116
                 domain = "", host = "", max_renames = 32768):
 
117
        self.interface = interface
 
118
        self.name = name
 
119
        self.type = servicetype
 
120
        self.port = port
 
121
        self.TXT = TXT if TXT is not None else []
 
122
        self.domain = domain
 
123
        self.host = host
 
124
        self.rename_count = 0
 
125
        self.max_renames = max_renames
 
126
    def rename(self):
 
127
        """Derived from the Avahi example code"""
 
128
        if self.rename_count >= self.max_renames:
 
129
            logger.critical(u"No suitable Zeroconf service name found"
 
130
                            u" after %i retries, exiting.",
 
131
                            self.rename_count)
 
132
            raise AvahiServiceError("Too many renames")
 
133
        self.name = server.GetAlternativeServiceName(self.name)
 
134
        logger.info(u"Changing Zeroconf service name to %r ...",
 
135
                    str(self.name))
 
136
        syslogger.setFormatter(logging.Formatter
 
137
                               ('Mandos (%s): %%(levelname)s:'
 
138
                                ' %%(message)s' % self.name))
 
139
        self.remove()
 
140
        self.add()
 
141
        self.rename_count += 1
 
142
    def remove(self):
 
143
        """Derived from the Avahi example code"""
 
144
        if group is not None:
 
145
            group.Reset()
 
146
    def add(self):
 
147
        """Derived from the Avahi example code"""
 
148
        global group
 
149
        if group is None:
 
150
            group = dbus.Interface(bus.get_object
 
151
                                   (avahi.DBUS_NAME,
 
152
                                    server.EntryGroupNew()),
 
153
                                   avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
154
            group.connect_to_signal('StateChanged',
 
155
                                    entry_group_state_changed)
 
156
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
 
157
                     service.name, service.type)
 
158
        group.AddService(
 
159
                self.interface,         # interface
 
160
                avahi.PROTO_INET6,      # protocol
 
161
                dbus.UInt32(0),         # flags
 
162
                self.name, self.type,
 
163
                self.domain, self.host,
 
164
                dbus.UInt16(self.port),
 
165
                avahi.string_array_to_txt_array(self.TXT))
 
166
        group.Commit()
 
167
 
 
168
# From the Avahi example code:
 
169
group = None                            # our entry group
 
170
# End of Avahi example code
 
171
 
 
172
 
 
173
def _datetime_to_dbus(dt, variant_level=0):
 
174
    """Convert a UTC datetime.datetime() to a D-Bus type."""
 
175
    return dbus.String(dt.isoformat(), variant_level=variant_level)
 
176
 
 
177
 
 
178
class Client(dbus.service.Object):
 
179
    """A representation of a client host served by this server.
 
180
    Attributes:
 
181
    name:       string; from the config file, used in log messages
 
182
    fingerprint: string (40 or 32 hexadecimal digits); used to
 
183
                 uniquely identify the client
 
184
    secret:     bytestring; sent verbatim (over TLS) to client
 
185
    host:       string; available for use by the checker command
 
186
    created:    datetime.datetime(); (UTC) object creation
 
187
    last_enabled: datetime.datetime(); (UTC)
 
188
    enabled:    bool()
 
189
    last_checked_ok: datetime.datetime(); (UTC) or None
 
190
    timeout:    datetime.timedelta(); How long from last_checked_ok
 
191
                                      until this client is invalid
 
192
    interval:   datetime.timedelta(); How often to start a new checker
 
193
    disable_hook:  If set, called by disable() as disable_hook(self)
 
194
    checker:    subprocess.Popen(); a running checker process used
 
195
                                    to see if the client lives.
 
196
                                    'None' if no process is running.
 
197
    checker_initiator_tag: a gobject event source tag, or None
 
198
    disable_initiator_tag:    - '' -
 
199
    checker_callback_tag:  - '' -
 
200
    checker_command: string; External command which is run to check if
 
201
                     client lives.  %() expansions are done at
 
202
                     runtime with vars(self) as dict, so that for
 
203
                     instance %(name)s can be used in the command.
 
204
    dbus_object_path: dbus.ObjectPath
 
205
    Private attibutes:
 
206
    _timeout: Real variable for 'timeout'
 
207
    _interval: Real variable for 'interval'
 
208
    _timeout_milliseconds: Used when calling gobject.timeout_add()
 
209
    _interval_milliseconds: - '' -
 
210
    """
 
211
    def _set_timeout(self, timeout):
 
212
        "Setter function for the 'timeout' attribute"
 
213
        self._timeout = timeout
 
214
        self._timeout_milliseconds = ((self.timeout.days
 
215
                                       * 24 * 60 * 60 * 1000)
 
216
                                      + (self.timeout.seconds * 1000)
 
217
                                      + (self.timeout.microseconds
 
218
                                         // 1000))
 
219
        # Emit D-Bus signal
 
220
        self.PropertyChanged(dbus.String(u"timeout"),
 
221
                             (dbus.UInt64(self._timeout_milliseconds,
 
222
                                          variant_level=1)))
 
223
    timeout = property(lambda self: self._timeout, _set_timeout)
 
224
    del _set_timeout
 
225
    
 
226
    def _set_interval(self, interval):
 
227
        "Setter function for the 'interval' attribute"
 
228
        self._interval = interval
 
229
        self._interval_milliseconds = ((self.interval.days
 
230
                                        * 24 * 60 * 60 * 1000)
 
231
                                       + (self.interval.seconds
 
232
                                          * 1000)
 
233
                                       + (self.interval.microseconds
 
234
                                          // 1000))
 
235
        # Emit D-Bus signal
 
236
        self.PropertyChanged(dbus.String(u"interval"),
 
237
                             (dbus.UInt64(self._interval_milliseconds,
 
238
                                          variant_level=1)))
 
239
    interval = property(lambda self: self._interval, _set_interval)
 
240
    del _set_interval
 
241
    
 
242
    def __init__(self, name = None, disable_hook=None, config=None):
 
243
        """Note: the 'checker' key in 'config' sets the
 
244
        'checker_command' attribute and *not* the 'checker'
 
245
        attribute."""
 
246
        self.dbus_object_path = (dbus.ObjectPath
 
247
                                 ("/Mandos/clients/"
 
248
                                  + name.replace(".", "_")))
 
249
        dbus.service.Object.__init__(self, bus,
 
250
                                     self.dbus_object_path)
 
251
        if config is None:
 
252
            config = {}
 
253
        self.name = name
 
254
        logger.debug(u"Creating client %r", self.name)
 
255
        # Uppercase and remove spaces from fingerprint for later
 
256
        # comparison purposes with return value from the fingerprint()
 
257
        # function
 
258
        self.fingerprint = (config["fingerprint"].upper()
 
259
                            .replace(u" ", u""))
 
260
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
 
261
        if "secret" in config:
 
262
            self.secret = config["secret"].decode(u"base64")
 
263
        elif "secfile" in config:
 
264
            with closing(open(os.path.expanduser
 
265
                              (os.path.expandvars
 
266
                               (config["secfile"])))) as secfile:
 
267
                self.secret = secfile.read()
 
268
        else:
 
269
            raise TypeError(u"No secret or secfile for client %s"
 
270
                            % self.name)
 
271
        self.host = config.get("host", "")
 
272
        self.created = datetime.datetime.utcnow()
 
273
        self.enabled = False
 
274
        self.last_enabled = None
 
275
        self.last_checked_ok = None
 
276
        self.timeout = string_to_delta(config["timeout"])
 
277
        self.interval = string_to_delta(config["interval"])
 
278
        self.disable_hook = disable_hook
 
279
        self.checker = None
 
280
        self.checker_initiator_tag = None
 
281
        self.disable_initiator_tag = None
 
282
        self.checker_callback_tag = None
 
283
        self.checker_command = config["checker"]
 
284
    
 
285
    def enable(self):
 
286
        """Start this client's checker and timeout hooks"""
 
287
        self.last_enabled = datetime.datetime.utcnow()
 
288
        # Schedule a new checker to be started an 'interval' from now,
 
289
        # and every interval from then on.
 
290
        self.checker_initiator_tag = (gobject.timeout_add
 
291
                                      (self._interval_milliseconds,
 
292
                                       self.start_checker))
 
293
        # Also start a new checker *right now*.
 
294
        self.start_checker()
 
295
        # Schedule a disable() when 'timeout' has passed
 
296
        self.disable_initiator_tag = (gobject.timeout_add
 
297
                                   (self._timeout_milliseconds,
 
298
                                    self.disable))
 
299
        self.enabled = True
 
300
        # Emit D-Bus signal
 
301
        self.PropertyChanged(dbus.String(u"enabled"),
 
302
                             dbus.Boolean(True, variant_level=1))
 
303
        self.PropertyChanged(dbus.String(u"last_enabled"),
 
304
                             (_datetime_to_dbus(self.last_enabled,
 
305
                                                variant_level=1)))
 
306
    
 
307
    def disable(self):
 
308
        """Disable this client."""
 
309
        if not getattr(self, "enabled", False):
 
310
            return False
 
311
        logger.info(u"Disabling client %s", self.name)
 
312
        if getattr(self, "disable_initiator_tag", False):
 
313
            gobject.source_remove(self.disable_initiator_tag)
 
314
            self.disable_initiator_tag = None
 
315
        if getattr(self, "checker_initiator_tag", False):
 
316
            gobject.source_remove(self.checker_initiator_tag)
 
317
            self.checker_initiator_tag = None
 
318
        self.stop_checker()
 
319
        if self.disable_hook:
 
320
            self.disable_hook(self)
 
321
        self.enabled = False
 
322
        # Emit D-Bus signal
 
323
        self.PropertyChanged(dbus.String(u"enabled"),
 
324
                             dbus.Boolean(False, variant_level=1))
 
325
        # Do not run this again if called by a gobject.timeout_add
 
326
        return False
 
327
    
 
328
    def __del__(self):
 
329
        self.disable_hook = None
 
330
        self.disable()
 
331
    
 
332
    def checker_callback(self, pid, condition, command):
 
333
        """The checker has completed, so take appropriate actions."""
 
334
        self.checker_callback_tag = None
 
335
        self.checker = None
 
336
        # Emit D-Bus signal
 
337
        self.PropertyChanged(dbus.String(u"checker_running"),
 
338
                             dbus.Boolean(False, variant_level=1))
 
339
        if (os.WIFEXITED(condition)
 
340
            and (os.WEXITSTATUS(condition) == 0)):
 
341
            logger.info(u"Checker for %(name)s succeeded",
 
342
                        vars(self))
 
343
            # Emit D-Bus signal
 
344
            self.CheckerCompleted(dbus.Boolean(True),
 
345
                                  dbus.UInt16(condition),
 
346
                                  dbus.String(command))
 
347
            self.bump_timeout()
 
348
        elif not os.WIFEXITED(condition):
 
349
            logger.warning(u"Checker for %(name)s crashed?",
 
350
                           vars(self))
 
351
            # Emit D-Bus signal
 
352
            self.CheckerCompleted(dbus.Boolean(False),
 
353
                                  dbus.UInt16(condition),
 
354
                                  dbus.String(command))
 
355
        else:
 
356
            logger.info(u"Checker for %(name)s failed",
 
357
                        vars(self))
 
358
            # Emit D-Bus signal
 
359
            self.CheckerCompleted(dbus.Boolean(False),
 
360
                                  dbus.UInt16(condition),
 
361
                                  dbus.String(command))
 
362
    
 
363
    def bump_timeout(self):
 
364
        """Bump up the timeout for this client.
 
365
        This should only be called when the client has been seen,
 
366
        alive and well.
 
367
        """
 
368
        self.last_checked_ok = datetime.datetime.utcnow()
 
369
        gobject.source_remove(self.disable_initiator_tag)
 
370
        self.disable_initiator_tag = (gobject.timeout_add
 
371
                                      (self._timeout_milliseconds,
 
372
                                       self.disable))
 
373
        self.PropertyChanged(dbus.String(u"last_checked_ok"),
 
374
                             (_datetime_to_dbus(self.last_checked_ok,
 
375
                                                variant_level=1)))
 
376
    
 
377
    def start_checker(self):
 
378
        """Start a new checker subprocess if one is not running.
 
379
        If a checker already exists, leave it running and do
 
380
        nothing."""
 
381
        # The reason for not killing a running checker is that if we
 
382
        # did that, then if a checker (for some reason) started
 
383
        # running slowly and taking more than 'interval' time, the
 
384
        # client would inevitably timeout, since no checker would get
 
385
        # a chance to run to completion.  If we instead leave running
 
386
        # checkers alone, the checker would have to take more time
 
387
        # than 'timeout' for the client to be declared invalid, which
 
388
        # is as it should be.
 
389
        if self.checker is None:
 
390
            try:
 
391
                # In case checker_command has exactly one % operator
 
392
                command = self.checker_command % self.host
 
393
            except TypeError:
 
394
                # Escape attributes for the shell
 
395
                escaped_attrs = dict((key, re.escape(str(val)))
 
396
                                     for key, val in
 
397
                                     vars(self).iteritems())
52
398
                try:
53
 
                    self.socket.setsockopt(socket.SOL_SOCKET,
54
 
                                           socket.SO_BINDTODEVICE,
55
 
                                           self.options.interface)
56
 
                except socket.error, error:
57
 
                    if error[0] == errno.EPERM:
58
 
                        print "Warning: No permission to bind to interface", \
59
 
                              self.options.interface
60
 
                    else:
61
 
                        raise error
62
 
            return super(type(self), self).server_bind()
63
 
        attrs["server_bind"] = server_bind
64
 
        def init(self, *args, **kwargs):
65
 
            if "options" in kwargs:
66
 
                self.options = kwargs["options"]
67
 
                del kwargs["options"]
68
 
            if "clients" in kwargs:
69
 
                self.clients = kwargs["clients"]
70
 
                del kwargs["clients"]
71
 
            if "credentials" in kwargs:
72
 
                self.credentials = kwargs["credentials"]
73
 
                del kwargs["credentials"]
74
 
            return super(type(self), self).__init__(*args, **kwargs)
75
 
        attrs["__init__"] = init
76
 
        return type.__new__(cls, name, bases, attrs)
77
 
 
78
 
 
79
 
class udp_handler(SocketServer.DatagramRequestHandler, object):
80
 
    def handle(self):
81
 
        self.wfile.write("Polo")
82
 
        print "UDP request answered"
83
 
 
84
 
 
85
 
class IPv6_UDPServer(SocketServer.UDPServer, object):
86
 
    __metaclass__ = server_metaclass
87
 
    def verify_request(self, request, client_address):
88
 
        print "UDP request came"
89
 
        return request[0] == "Marco"
90
 
 
91
 
 
92
 
class tcp_handler(SocketServer.BaseRequestHandler, object):
93
 
    def handle(self):
94
 
        print "TCP request came"
95
 
        print "Request:", self.request
96
 
        print "Client Address:", self.client_address
97
 
        print "Server:", self.server
98
 
        session = gnutls.connection.ServerSession(self.request,
99
 
                                                  self.server.credentials)
100
 
        session.handshake()
101
 
        if session.peer_certificate:
102
 
            print "DN:", session.peer_certificate.subject
103
 
        try:
104
 
            session.verify_peer()
105
 
        except gnutls.errors.CertificateError, error:
106
 
            print "Verify failed", error
107
 
            session.bye()
108
 
            return
109
 
        try:
110
 
            session.send(dict((client.dn, client.password)
111
 
                              for client in self.server.clients)
112
 
                         [session.peer_certificate.subject])
113
 
        except KeyError:
114
 
            session.send("gazonk")
115
 
            # Log maybe? XXX
 
399
                    command = self.checker_command % escaped_attrs
 
400
                except TypeError, error:
 
401
                    logger.error(u'Could not format string "%s":'
 
402
                                 u' %s', self.checker_command, error)
 
403
                    return True # Try again later
 
404
            try:
 
405
                logger.info(u"Starting checker %r for %s",
 
406
                            command, self.name)
 
407
                # We don't need to redirect stdout and stderr, since
 
408
                # in normal mode, that is already done by daemon(),
 
409
                # and in debug mode we don't want to.  (Stdin is
 
410
                # always replaced by /dev/null.)
 
411
                self.checker = subprocess.Popen(command,
 
412
                                                close_fds=True,
 
413
                                                shell=True, cwd="/")
 
414
                # Emit D-Bus signal
 
415
                self.CheckerStarted(command)
 
416
                self.PropertyChanged(dbus.String("checker_running"),
 
417
                                     dbus.Boolean(True, variant_level=1))
 
418
                self.checker_callback_tag = (gobject.child_watch_add
 
419
                                             (self.checker.pid,
 
420
                                              self.checker_callback,
 
421
                                              data=command))
 
422
            except OSError, error:
 
423
                logger.error(u"Failed to start subprocess: %s",
 
424
                             error)
 
425
        # Re-run this periodically if run by gobject.timeout_add
 
426
        return True
 
427
    
 
428
    def stop_checker(self):
 
429
        """Force the checker process, if any, to stop."""
 
430
        if self.checker_callback_tag:
 
431
            gobject.source_remove(self.checker_callback_tag)
 
432
            self.checker_callback_tag = None
 
433
        if getattr(self, "checker", None) is None:
 
434
            return
 
435
        logger.debug(u"Stopping checker for %(name)s", vars(self))
 
436
        try:
 
437
            os.kill(self.checker.pid, signal.SIGTERM)
 
438
            #os.sleep(0.5)
 
439
            #if self.checker.poll() is None:
 
440
            #    os.kill(self.checker.pid, signal.SIGKILL)
 
441
        except OSError, error:
 
442
            if error.errno != errno.ESRCH: # No such process
 
443
                raise
 
444
        self.checker = None
 
445
        self.PropertyChanged(dbus.String(u"checker_running"),
 
446
                             dbus.Boolean(False, variant_level=1))
 
447
    
 
448
    def still_valid(self):
 
449
        """Has the timeout not yet passed for this client?"""
 
450
        if not getattr(self, "enabled", False):
 
451
            return False
 
452
        now = datetime.datetime.utcnow()
 
453
        if self.last_checked_ok is None:
 
454
            return now < (self.created + self.timeout)
 
455
        else:
 
456
            return now < (self.last_checked_ok + self.timeout)
 
457
    
 
458
    ## D-Bus methods & signals
 
459
    _interface = u"org.mandos_system.Mandos.Client"
 
460
    
 
461
    # BumpTimeout - method
 
462
    BumpTimeout = dbus.service.method(_interface)(bump_timeout)
 
463
    BumpTimeout.__name__ = "BumpTimeout"
 
464
    
 
465
    # CheckerCompleted - signal
 
466
    @dbus.service.signal(_interface, signature="bqs")
 
467
    def CheckerCompleted(self, success, condition, command):
 
468
        "D-Bus signal"
 
469
        pass
 
470
    
 
471
    # CheckerStarted - signal
 
472
    @dbus.service.signal(_interface, signature="s")
 
473
    def CheckerStarted(self, command):
 
474
        "D-Bus signal"
 
475
        pass
 
476
    
 
477
    # GetAllProperties - method
 
478
    @dbus.service.method(_interface, out_signature="a{sv}")
 
479
    def GetAllProperties(self):
 
480
        "D-Bus method"
 
481
        return dbus.Dictionary({
 
482
                dbus.String("name"):
 
483
                    dbus.String(self.name, variant_level=1),
 
484
                dbus.String("fingerprint"):
 
485
                    dbus.String(self.fingerprint, variant_level=1),
 
486
                dbus.String("host"):
 
487
                    dbus.String(self.host, variant_level=1),
 
488
                dbus.String("created"):
 
489
                    _datetime_to_dbus(self.created, variant_level=1),
 
490
                dbus.String("last_enabled"):
 
491
                    (_datetime_to_dbus(self.last_enabled,
 
492
                                       variant_level=1)
 
493
                     if self.last_enabled is not None
 
494
                     else dbus.Boolean(False, variant_level=1)),
 
495
                dbus.String("enabled"):
 
496
                    dbus.Boolean(self.enabled, variant_level=1),
 
497
                dbus.String("last_checked_ok"):
 
498
                    (_datetime_to_dbus(self.last_checked_ok,
 
499
                                       variant_level=1)
 
500
                     if self.last_checked_ok is not None
 
501
                     else dbus.Boolean (False, variant_level=1)),
 
502
                dbus.String("timeout"):
 
503
                    dbus.UInt64(self._timeout_milliseconds,
 
504
                                variant_level=1),
 
505
                dbus.String("interval"):
 
506
                    dbus.UInt64(self._interval_milliseconds,
 
507
                                variant_level=1),
 
508
                dbus.String("checker"):
 
509
                    dbus.String(self.checker_command,
 
510
                                variant_level=1),
 
511
                dbus.String("checker_running"):
 
512
                    dbus.Boolean(self.checker is not None,
 
513
                                 variant_level=1),
 
514
                }, signature="sv")
 
515
    
 
516
    # IsStillValid - method
 
517
    IsStillValid = (dbus.service.method(_interface, out_signature="b")
 
518
                    (still_valid))
 
519
    IsStillValid.__name__ = "IsStillValid"
 
520
    
 
521
    # PropertyChanged - signal
 
522
    @dbus.service.signal(_interface, signature="sv")
 
523
    def PropertyChanged(self, property, value):
 
524
        "D-Bus signal"
 
525
        pass
 
526
    
 
527
    # SetChecker - method
 
528
    @dbus.service.method(_interface, in_signature="s")
 
529
    def SetChecker(self, checker):
 
530
        "D-Bus setter method"
 
531
        self.checker_command = checker
 
532
    
 
533
    # SetHost - method
 
534
    @dbus.service.method(_interface, in_signature="s")
 
535
    def SetHost(self, host):
 
536
        "D-Bus setter method"
 
537
        self.host = host
 
538
    
 
539
    # SetInterval - method
 
540
    @dbus.service.method(_interface, in_signature="t")
 
541
    def SetInterval(self, milliseconds):
 
542
        self.interval = datetime.timdeelta(0, 0, 0, milliseconds)
 
543
    
 
544
    # SetSecret - method
 
545
    @dbus.service.method(_interface, in_signature="ay",
 
546
                         byte_arrays=True)
 
547
    def SetSecret(self, secret):
 
548
        "D-Bus setter method"
 
549
        self.secret = str(secret)
 
550
    
 
551
    # SetTimeout - method
 
552
    @dbus.service.method(_interface, in_signature="t")
 
553
    def SetTimeout(self, milliseconds):
 
554
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
 
555
    
 
556
    # Enable - method
 
557
    Enable = dbus.service.method(_interface)(enable)
 
558
    Enable.__name__ = "Enable"
 
559
    
 
560
    # StartChecker - method
 
561
    @dbus.service.method(_interface)
 
562
    def StartChecker(self):
 
563
        "D-Bus method"
 
564
        self.start_checker()
 
565
    
 
566
    # Disable - method
 
567
    @dbus.service.method(_interface)
 
568
    def Disable(self):
 
569
        "D-Bus method"
 
570
        self.disable()
 
571
    
 
572
    # StopChecker - method
 
573
    StopChecker = dbus.service.method(_interface)(stop_checker)
 
574
    StopChecker.__name__ = "StopChecker"
 
575
    
 
576
    del _interface
 
577
 
 
578
 
 
579
def peer_certificate(session):
 
580
    "Return the peer's OpenPGP certificate as a bytestring"
 
581
    # If not an OpenPGP certificate...
 
582
    if (gnutls.library.functions
 
583
        .gnutls_certificate_type_get(session._c_object)
 
584
        != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
 
585
        # ...do the normal thing
 
586
        return session.peer_certificate
 
587
    list_size = ctypes.c_uint()
 
588
    cert_list = (gnutls.library.functions
 
589
                 .gnutls_certificate_get_peers
 
590
                 (session._c_object, ctypes.byref(list_size)))
 
591
    if list_size.value == 0:
 
592
        return None
 
593
    cert = cert_list[0]
 
594
    return ctypes.string_at(cert.data, cert.size)
 
595
 
 
596
 
 
597
def fingerprint(openpgp):
 
598
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
 
599
    # New GnuTLS "datum" with the OpenPGP public key
 
600
    datum = (gnutls.library.types
 
601
             .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
 
602
                                         ctypes.POINTER
 
603
                                         (ctypes.c_ubyte)),
 
604
                             ctypes.c_uint(len(openpgp))))
 
605
    # New empty GnuTLS certificate
 
606
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
 
607
    (gnutls.library.functions
 
608
     .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
609
    # Import the OpenPGP public key into the certificate
 
610
    (gnutls.library.functions
 
611
     .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
 
612
                                gnutls.library.constants
 
613
                                .GNUTLS_OPENPGP_FMT_RAW))
 
614
    # Verify the self signature in the key
 
615
    crtverify = ctypes.c_uint()
 
616
    (gnutls.library.functions
 
617
     .gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
 
618
    if crtverify.value != 0:
 
619
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
620
        raise gnutls.errors.CertificateSecurityError("Verify failed")
 
621
    # New buffer for the fingerprint
 
622
    buf = ctypes.create_string_buffer(20)
 
623
    buf_len = ctypes.c_size_t()
 
624
    # Get the fingerprint from the certificate into the buffer
 
625
    (gnutls.library.functions
 
626
     .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
 
627
                                         ctypes.byref(buf_len)))
 
628
    # Deinit the certificate
 
629
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
630
    # Convert the buffer to a Python bytestring
 
631
    fpr = ctypes.string_at(buf, buf_len.value)
 
632
    # Convert the bytestring to hexadecimal notation
 
633
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
 
634
    return hex_fpr
 
635
 
 
636
 
 
637
class TCP_handler(SocketServer.BaseRequestHandler, object):
 
638
    """A TCP request handler class.
 
639
    Instantiated by IPv6_TCPServer for each request to handle it.
 
640
    Note: This will run in its own forked process."""
 
641
    
 
642
    def handle(self):
 
643
        logger.info(u"TCP connection from: %s",
 
644
                    unicode(self.client_address))
 
645
        session = (gnutls.connection
 
646
                   .ClientSession(self.request,
 
647
                                  gnutls.connection
 
648
                                  .X509Credentials()))
 
649
        
 
650
        line = self.request.makefile().readline()
 
651
        logger.debug(u"Protocol version: %r", line)
 
652
        try:
 
653
            if int(line.strip().split()[0]) > 1:
 
654
                raise RuntimeError
 
655
        except (ValueError, IndexError, RuntimeError), error:
 
656
            logger.error(u"Unknown protocol version: %s", error)
 
657
            return
 
658
        
 
659
        # Note: gnutls.connection.X509Credentials is really a generic
 
660
        # GnuTLS certificate credentials object so long as no X.509
 
661
        # keys are added to it.  Therefore, we can use it here despite
 
662
        # using OpenPGP certificates.
 
663
        
 
664
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
 
665
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
 
666
        #                "+DHE-DSS"))
 
667
        # Use a fallback default, since this MUST be set.
 
668
        priority = self.server.settings.get("priority", "NORMAL")
 
669
        (gnutls.library.functions
 
670
         .gnutls_priority_set_direct(session._c_object,
 
671
                                     priority, None))
 
672
        
 
673
        try:
 
674
            session.handshake()
 
675
        except gnutls.errors.GNUTLSError, error:
 
676
            logger.warning(u"Handshake failed: %s", error)
 
677
            # Do not run session.bye() here: the session is not
 
678
            # established.  Just abandon the request.
 
679
            return
 
680
        try:
 
681
            fpr = fingerprint(peer_certificate(session))
 
682
        except (TypeError, gnutls.errors.GNUTLSError), error:
 
683
            logger.warning(u"Bad certificate: %s", error)
 
684
            session.bye()
 
685
            return
 
686
        logger.debug(u"Fingerprint: %s", fpr)
 
687
        for c in self.server.clients:
 
688
            if c.fingerprint == fpr:
 
689
                client = c
 
690
                break
 
691
        else:
 
692
            logger.warning(u"Client not found for fingerprint: %s",
 
693
                           fpr)
 
694
            session.bye()
 
695
            return
 
696
        # Have to check if client.still_valid(), since it is possible
 
697
        # that the client timed out while establishing the GnuTLS
 
698
        # session.
 
699
        if not client.still_valid():
 
700
            logger.warning(u"Client %(name)s is invalid",
 
701
                           vars(client))
 
702
            session.bye()
 
703
            return
 
704
        ## This won't work here, since we're in a fork.
 
705
        # client.bump_timeout()
 
706
        sent_size = 0
 
707
        while sent_size < len(client.secret):
 
708
            sent = session.send(client.secret[sent_size:])
 
709
            logger.debug(u"Sent: %d, remaining: %d",
 
710
                         sent, len(client.secret)
 
711
                         - (sent_size + sent))
 
712
            sent_size += sent
116
713
        session.bye()
117
714
 
118
715
 
119
 
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
120
 
    __metaclass__ = server_metaclass
121
 
    request_queue_size = 1024
122
 
 
123
 
 
124
 
in6addr_any = "::"
125
 
 
126
 
cred = None
 
716
class IPv6_TCPServer(SocketServer.ForkingMixIn,
 
717
                     SocketServer.TCPServer, object):
 
718
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
 
719
    Attributes:
 
720
        settings:       Server settings
 
721
        clients:        Set() of Client objects
 
722
        enabled:        Boolean; whether this server is activated yet
 
723
    """
 
724
    address_family = socket.AF_INET6
 
725
    def __init__(self, *args, **kwargs):
 
726
        if "settings" in kwargs:
 
727
            self.settings = kwargs["settings"]
 
728
            del kwargs["settings"]
 
729
        if "clients" in kwargs:
 
730
            self.clients = kwargs["clients"]
 
731
            del kwargs["clients"]
 
732
        self.enabled = False
 
733
        super(IPv6_TCPServer, self).__init__(*args, **kwargs)
 
734
    def server_bind(self):
 
735
        """This overrides the normal server_bind() function
 
736
        to bind to an interface if one was specified, and also NOT to
 
737
        bind to an address or port if they were not specified."""
 
738
        if self.settings["interface"]:
 
739
            # 25 is from /usr/include/asm-i486/socket.h
 
740
            SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
 
741
            try:
 
742
                self.socket.setsockopt(socket.SOL_SOCKET,
 
743
                                       SO_BINDTODEVICE,
 
744
                                       self.settings["interface"])
 
745
            except socket.error, error:
 
746
                if error[0] == errno.EPERM:
 
747
                    logger.error(u"No permission to"
 
748
                                 u" bind to interface %s",
 
749
                                 self.settings["interface"])
 
750
                else:
 
751
                    raise error
 
752
        # Only bind(2) the socket if we really need to.
 
753
        if self.server_address[0] or self.server_address[1]:
 
754
            if not self.server_address[0]:
 
755
                in6addr_any = "::"
 
756
                self.server_address = (in6addr_any,
 
757
                                       self.server_address[1])
 
758
            elif not self.server_address[1]:
 
759
                self.server_address = (self.server_address[0],
 
760
                                       0)
 
761
#                 if self.settings["interface"]:
 
762
#                     self.server_address = (self.server_address[0],
 
763
#                                            0, # port
 
764
#                                            0, # flowinfo
 
765
#                                            if_nametoindex
 
766
#                                            (self.settings
 
767
#                                             ["interface"]))
 
768
            return super(IPv6_TCPServer, self).server_bind()
 
769
    def server_activate(self):
 
770
        if self.enabled:
 
771
            return super(IPv6_TCPServer, self).server_activate()
 
772
    def enable(self):
 
773
        self.enabled = True
 
774
 
127
775
 
128
776
def string_to_delta(interval):
129
777
    """Parse a string and return a datetime.timedelta
138
786
    datetime.timedelta(1)
139
787
    >>> string_to_delta(u'1w')
140
788
    datetime.timedelta(7)
 
789
    >>> string_to_delta('5m 30s')
 
790
    datetime.timedelta(0, 330)
141
791
    """
142
 
    try:
143
 
        suffix=unicode(interval[-1])
144
 
        value=int(interval[:-1])
145
 
        if suffix == u"d":
146
 
            delta = datetime.timedelta(value)
147
 
        elif suffix == u"s":
148
 
            delta = datetime.timedelta(0, value)
149
 
        elif suffix == u"m":
150
 
            delta = datetime.timedelta(0, 0, 0, 0, value)
151
 
        elif suffix == u"h":
152
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, value)
153
 
        elif suffix == u"w":
154
 
            delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
155
 
        else:
 
792
    timevalue = datetime.timedelta(0)
 
793
    for s in interval.split():
 
794
        try:
 
795
            suffix = unicode(s[-1])
 
796
            value = int(s[:-1])
 
797
            if suffix == u"d":
 
798
                delta = datetime.timedelta(value)
 
799
            elif suffix == u"s":
 
800
                delta = datetime.timedelta(0, value)
 
801
            elif suffix == u"m":
 
802
                delta = datetime.timedelta(0, 0, 0, 0, value)
 
803
            elif suffix == u"h":
 
804
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
 
805
            elif suffix == u"w":
 
806
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
 
807
            else:
 
808
                raise ValueError
 
809
        except (ValueError, IndexError):
156
810
            raise ValueError
157
 
    except (ValueError, IndexError):
158
 
        raise ValueError
159
 
    return delta
 
811
        timevalue += delta
 
812
    return timevalue
 
813
 
 
814
 
 
815
def server_state_changed(state):
 
816
    """Derived from the Avahi example code"""
 
817
    if state == avahi.SERVER_COLLISION:
 
818
        logger.error(u"Zeroconf server name collision")
 
819
        service.remove()
 
820
    elif state == avahi.SERVER_RUNNING:
 
821
        service.add()
 
822
 
 
823
 
 
824
def entry_group_state_changed(state, error):
 
825
    """Derived from the Avahi example code"""
 
826
    logger.debug(u"Avahi state change: %i", state)
 
827
    
 
828
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
 
829
        logger.debug(u"Zeroconf service established.")
 
830
    elif state == avahi.ENTRY_GROUP_COLLISION:
 
831
        logger.warning(u"Zeroconf service name collision.")
 
832
        service.rename()
 
833
    elif state == avahi.ENTRY_GROUP_FAILURE:
 
834
        logger.critical(u"Avahi: Error in group state changed %s",
 
835
                        unicode(error))
 
836
        raise AvahiGroupError("State changed: %s", str(error))
 
837
 
 
838
def if_nametoindex(interface):
 
839
    """Call the C function if_nametoindex(), or equivalent"""
 
840
    global if_nametoindex
 
841
    try:
 
842
        if_nametoindex = (ctypes.cdll.LoadLibrary
 
843
                          (ctypes.util.find_library("c"))
 
844
                          .if_nametoindex)
 
845
    except (OSError, AttributeError):
 
846
        if "struct" not in sys.modules:
 
847
            import struct
 
848
        if "fcntl" not in sys.modules:
 
849
            import fcntl
 
850
        def if_nametoindex(interface):
 
851
            "Get an interface index the hard way, i.e. using fcntl()"
 
852
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
 
853
            with closing(socket.socket()) as s:
 
854
                ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
855
                                    struct.pack("16s16x", interface))
 
856
            interface_index = struct.unpack("I", ifreq[16:20])[0]
 
857
            return interface_index
 
858
    return if_nametoindex(interface)
 
859
 
 
860
 
 
861
def daemon(nochdir = False, noclose = False):
 
862
    """See daemon(3).  Standard BSD Unix function.
 
863
    This should really exist as os.daemon, but it doesn't (yet)."""
 
864
    if os.fork():
 
865
        sys.exit()
 
866
    os.setsid()
 
867
    if not nochdir:
 
868
        os.chdir("/")
 
869
    if os.fork():
 
870
        sys.exit()
 
871
    if not noclose:
 
872
        # Close all standard open file descriptors
 
873
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
874
        if not stat.S_ISCHR(os.fstat(null).st_mode):
 
875
            raise OSError(errno.ENODEV,
 
876
                          "/dev/null not a character device")
 
877
        os.dup2(null, sys.stdin.fileno())
 
878
        os.dup2(null, sys.stdout.fileno())
 
879
        os.dup2(null, sys.stderr.fileno())
 
880
        if null > 2:
 
881
            os.close(null)
 
882
 
160
883
 
161
884
def main():
162
 
    parser = OptionParser()
 
885
    parser = OptionParser(version = "%%prog %s" % version)
163
886
    parser.add_option("-i", "--interface", type="string",
164
 
                      default="eth0", metavar="IF",
165
 
                      help="Interface to bind to")
166
 
    parser.add_option("--cert", type="string", default="cert.pem",
167
 
                      metavar="FILE",
168
 
                      help="Public key certificate to use")
169
 
    parser.add_option("--key", type="string", default="key.pem",
170
 
                      metavar="FILE",
171
 
                      help="Private key to use")
172
 
    parser.add_option("--ca", type="string", default="ca.pem",
173
 
                      metavar="FILE",
174
 
                      help="Certificate Authority certificate to use")
175
 
    parser.add_option("--crl", type="string", default="crl.pem",
176
 
                      metavar="FILE",
177
 
                      help="Certificate Revokation List to use")
178
 
    parser.add_option("-p", "--port", type="int", default=49001,
 
887
                      metavar="IF", help="Bind to interface IF")
 
888
    parser.add_option("-a", "--address", type="string",
 
889
                      help="Address to listen for requests on")
 
890
    parser.add_option("-p", "--port", type="int",
179
891
                      help="Port number to receive requests on")
180
 
    parser.add_option("--dh", type="int", metavar="BITS",
181
 
                      help="DH group to use")
182
 
    parser.add_option("-t", "--timeout", type="string", # Parsed later
183
 
                      default="15m",
184
 
                      help="Amount of downtime allowed for clients")
185
 
    parser.add_option("--interval", type="string", # Parsed later
186
 
                      default="5m",
187
 
                      help="How often to check that a client is up")
188
892
    parser.add_option("--check", action="store_true", default=False,
189
893
                      help="Run self-test")
190
 
    (options, args) = parser.parse_args()
191
 
 
 
894
    parser.add_option("--debug", action="store_true",
 
895
                      help="Debug mode; run in foreground and log to"
 
896
                      " terminal")
 
897
    parser.add_option("--priority", type="string", help="GnuTLS"
 
898
                      " priority string (see GnuTLS documentation)")
 
899
    parser.add_option("--servicename", type="string", metavar="NAME",
 
900
                      help="Zeroconf service name")
 
901
    parser.add_option("--configdir", type="string",
 
902
                      default="/etc/mandos", metavar="DIR",
 
903
                      help="Directory to search for configuration"
 
904
                      " files")
 
905
    options = parser.parse_args()[0]
 
906
    
192
907
    if options.check:
193
908
        import doctest
194
909
        doctest.testmod()
195
910
        sys.exit()
196
911
    
197
 
    # Parse the time arguments
198
 
    try:
199
 
        options.timeout = string_to_delta(options.timeout)
200
 
    except ValueError:
201
 
        parser.error("option --timeout: Unparseable time")
202
 
    
203
 
    try:
204
 
        options.interval = string_to_delta(options.interval)
205
 
    except ValueError:
206
 
        parser.error("option --interval: Unparseable time")
207
 
    
208
 
    cert = gnutls.crypto.X509Certificate(open(options.cert).read())
209
 
    key = gnutls.crypto.X509PrivateKey(open(options.key).read())
210
 
    ca = gnutls.crypto.X509Certificate(open(options.ca).read())
211
 
    crl = gnutls.crypto.X509CRL(open(options.crl).read())
212
 
    cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])
213
 
    
214
 
    # Parse config file
215
 
    defaults = {}
216
 
    client_config_object = ConfigParser.SafeConfigParser(defaults)
217
 
    client_config_object.read("mandos-clients.conf")
218
 
    clients = [Client(name=section, options=options,
219
 
                      **(dict(client_config_object.items(section))))
220
 
               for section in client_config_object.sections()]
221
 
    
222
 
    udp_server = IPv6_UDPServer((in6addr_any, options.port),
223
 
                                udp_handler,
224
 
                                options=options)
225
 
    
226
 
    tcp_server = IPv6_TCPServer((in6addr_any, options.port),
227
 
                                tcp_handler,
228
 
                                options=options,
229
 
                                clients=clients,
230
 
                                credentials=cred)
231
 
    
232
 
    while True:
233
 
        in_, out, err = select.select((udp_server,
234
 
                                       tcp_server), (), ())
235
 
        for server in in_:
236
 
            server.handle_request()
237
 
 
238
 
 
239
 
if __name__ == "__main__":
 
912
    # Default values for config file for server-global settings
 
913
    server_defaults = { "interface": "",
 
914
                        "address": "",
 
915
                        "port": "",
 
916
                        "debug": "False",
 
917
                        "priority":
 
918
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
919
                        "servicename": "Mandos",
 
920
                        }
 
921
    
 
922
    # Parse config file for server-global settings
 
923
    server_config = ConfigParser.SafeConfigParser(server_defaults)
 
924
    del server_defaults
 
925
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
 
926
    # Convert the SafeConfigParser object to a dict
 
927
    server_settings = server_config.defaults()
 
928
    # Use getboolean on the boolean config option
 
929
    server_settings["debug"] = (server_config.getboolean
 
930
                                ("DEFAULT", "debug"))
 
931
    del server_config
 
932
    
 
933
    # Override the settings from the config file with command line
 
934
    # options, if set.
 
935
    for option in ("interface", "address", "port", "debug",
 
936
                   "priority", "servicename", "configdir"):
 
937
        value = getattr(options, option)
 
938
        if value is not None:
 
939
            server_settings[option] = value
 
940
    del options
 
941
    # Now we have our good server settings in "server_settings"
 
942
    
 
943
    debug = server_settings["debug"]
 
944
    
 
945
    if not debug:
 
946
        syslogger.setLevel(logging.WARNING)
 
947
        console.setLevel(logging.WARNING)
 
948
    
 
949
    if server_settings["servicename"] != "Mandos":
 
950
        syslogger.setFormatter(logging.Formatter
 
951
                               ('Mandos (%s): %%(levelname)s:'
 
952
                                ' %%(message)s'
 
953
                                % server_settings["servicename"]))
 
954
    
 
955
    # Parse config file with clients
 
956
    client_defaults = { "timeout": "1h",
 
957
                        "interval": "5m",
 
958
                        "checker": "fping -q -- %(host)s",
 
959
                        "host": "",
 
960
                        }
 
961
    client_config = ConfigParser.SafeConfigParser(client_defaults)
 
962
    client_config.read(os.path.join(server_settings["configdir"],
 
963
                                    "clients.conf"))
 
964
    
 
965
    clients = Set()
 
966
    tcp_server = IPv6_TCPServer((server_settings["address"],
 
967
                                 server_settings["port"]),
 
968
                                TCP_handler,
 
969
                                settings=server_settings,
 
970
                                clients=clients)
 
971
    pidfilename = "/var/run/mandos.pid"
 
972
    try:
 
973
        pidfile = open(pidfilename, "w")
 
974
    except IOError, error:
 
975
        logger.error("Could not open file %r", pidfilename)
 
976
    
 
977
    try:
 
978
        uid = pwd.getpwnam("_mandos").pw_uid
 
979
    except KeyError:
 
980
        try:
 
981
            uid = pwd.getpwnam("mandos").pw_uid
 
982
        except KeyError:
 
983
            try:
 
984
                uid = pwd.getpwnam("nobody").pw_uid
 
985
            except KeyError:
 
986
                uid = 65534
 
987
    try:
 
988
        gid = pwd.getpwnam("_mandos").pw_gid
 
989
    except KeyError:
 
990
        try:
 
991
            gid = pwd.getpwnam("mandos").pw_gid
 
992
        except KeyError:
 
993
            try:
 
994
                gid = pwd.getpwnam("nogroup").pw_gid
 
995
            except KeyError:
 
996
                gid = 65534
 
997
    try:
 
998
        os.setuid(uid)
 
999
        os.setgid(gid)
 
1000
    except OSError, error:
 
1001
        if error[0] != errno.EPERM:
 
1002
            raise error
 
1003
    
 
1004
    global service
 
1005
    service = AvahiService(name = server_settings["servicename"],
 
1006
                           servicetype = "_mandos._tcp", )
 
1007
    if server_settings["interface"]:
 
1008
        service.interface = (if_nametoindex
 
1009
                             (server_settings["interface"]))
 
1010
    
 
1011
    global main_loop
 
1012
    global bus
 
1013
    global server
 
1014
    # From the Avahi example code
 
1015
    DBusGMainLoop(set_as_default=True )
 
1016
    main_loop = gobject.MainLoop()
 
1017
    bus = dbus.SystemBus()
 
1018
    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
 
1019
                                           avahi.DBUS_PATH_SERVER),
 
1020
                            avahi.DBUS_INTERFACE_SERVER)
 
1021
    # End of Avahi example code
 
1022
    bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)
 
1023
    
 
1024
    clients.update(Set(Client(name = section,
 
1025
                              config
 
1026
                              = dict(client_config.items(section)))
 
1027
                       for section in client_config.sections()))
 
1028
    if not clients:
 
1029
        logger.critical(u"No clients defined")
 
1030
        sys.exit(1)
 
1031
    
 
1032
    if debug:
 
1033
        # Redirect stdin so all checkers get /dev/null
 
1034
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
1035
        os.dup2(null, sys.stdin.fileno())
 
1036
        if null > 2:
 
1037
            os.close(null)
 
1038
    else:
 
1039
        # No console logging
 
1040
        logger.removeHandler(console)
 
1041
        # Close all input and output, do double fork, etc.
 
1042
        daemon()
 
1043
    
 
1044
    try:
 
1045
        pid = os.getpid()
 
1046
        pidfile.write(str(pid) + "\n")
 
1047
        pidfile.close()
 
1048
        del pidfile
 
1049
    except IOError:
 
1050
        logger.error(u"Could not write to file %r with PID %d",
 
1051
                     pidfilename, pid)
 
1052
    except NameError:
 
1053
        # "pidfile" was never created
 
1054
        pass
 
1055
    del pidfilename
 
1056
    
 
1057
    def cleanup():
 
1058
        "Cleanup function; run on exit"
 
1059
        global group
 
1060
        # From the Avahi example code
 
1061
        if not group is None:
 
1062
            group.Free()
 
1063
            group = None
 
1064
        # End of Avahi example code
 
1065
        
 
1066
        while clients:
 
1067
            client = clients.pop()
 
1068
            client.disable_hook = None
 
1069
            client.disable()
 
1070
    
 
1071
    atexit.register(cleanup)
 
1072
    
 
1073
    if not debug:
 
1074
        signal.signal(signal.SIGINT, signal.SIG_IGN)
 
1075
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
 
1076
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
 
1077
    
 
1078
    class MandosServer(dbus.service.Object):
 
1079
        """A D-Bus proxy object"""
 
1080
        def __init__(self):
 
1081
            dbus.service.Object.__init__(self, bus,
 
1082
                                         "/Mandos")
 
1083
        _interface = u"org.mandos_system.Mandos"
 
1084
        
 
1085
        @dbus.service.signal(_interface, signature="oa{sv}")
 
1086
        def ClientAdded(self, objpath, properties):
 
1087
            "D-Bus signal"
 
1088
            pass
 
1089
        
 
1090
        @dbus.service.signal(_interface, signature="o")
 
1091
        def ClientRemoved(self, objpath):
 
1092
            "D-Bus signal"
 
1093
            pass
 
1094
        
 
1095
        @dbus.service.method(_interface, out_signature="ao")
 
1096
        def GetAllClients(self):
 
1097
            return dbus.Array(c.dbus_object_path for c in clients)
 
1098
        
 
1099
        @dbus.service.method(_interface, out_signature="a{oa{sv}}")
 
1100
        def GetAllClientsWithProperties(self):
 
1101
            return dbus.Dictionary(
 
1102
                ((c.dbus_object_path, c.GetAllProperties())
 
1103
                 for c in clients),
 
1104
                signature="oa{sv}")
 
1105
        
 
1106
        @dbus.service.method(_interface, in_signature="o")
 
1107
        def RemoveClient(self, object_path):
 
1108
            for c in clients:
 
1109
                if c.dbus_object_path == object_path:
 
1110
                    c.disable()
 
1111
                    clients.remove(c)
 
1112
                    return
 
1113
            raise KeyError
 
1114
        
 
1115
        del _interface
 
1116
    
 
1117
    mandos_server = MandosServer()
 
1118
    
 
1119
    for client in clients:
 
1120
        # Emit D-Bus signal
 
1121
        mandos_server.ClientAdded(client.dbus_object_path,
 
1122
                                  client.GetAllProperties())
 
1123
        client.enable()
 
1124
    
 
1125
    tcp_server.enable()
 
1126
    tcp_server.server_activate()
 
1127
    
 
1128
    # Find out what port we got
 
1129
    service.port = tcp_server.socket.getsockname()[1]
 
1130
    logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
 
1131
                u" scope_id %d" % tcp_server.socket.getsockname())
 
1132
    
 
1133
    #service.interface = tcp_server.socket.getsockname()[3]
 
1134
    
 
1135
    try:
 
1136
        # From the Avahi example code
 
1137
        server.connect_to_signal("StateChanged", server_state_changed)
 
1138
        try:
 
1139
            server_state_changed(server.GetState())
 
1140
        except dbus.exceptions.DBusException, error:
 
1141
            logger.critical(u"DBusException: %s", error)
 
1142
            sys.exit(1)
 
1143
        # End of Avahi example code
 
1144
        
 
1145
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
 
1146
                             lambda *args, **kwargs:
 
1147
                             (tcp_server.handle_request
 
1148
                              (*args[2:], **kwargs) or True))
 
1149
        
 
1150
        logger.debug(u"Starting main loop")
 
1151
        main_loop.run()
 
1152
    except AvahiError, error:
 
1153
        logger.critical(u"AvahiError: %s" + unicode(error))
 
1154
        sys.exit(1)
 
1155
    except KeyboardInterrupt:
 
1156
        if debug:
 
1157
            print
 
1158
 
 
1159
if __name__ == '__main__':
240
1160
    main()
241