/mandos/release

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

« back to all changes in this revision

Viewing changes to server.py

  • Committer: Teddy Hogeborn
  • Date: 2008-08-01 06:33:15 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080801063315-4k33q3ek28hjc3tu
* plugins.d/plugbasedclient.c: Update include file comments.
  (struct process.disable): Renamed to "disabled".  All users changed.
  (addarguments): Renamed to "addargument".  All callers changed.
  (doc, args_doc): Removed.
  (main): Changed default "plugindir" to
          "/conf/conf.d/mandos/plugins.d".  Renamed "rfds_orig" to
           "rfds_all"; all users changed.  New "debug" and
           "exitstatus" variables.  New "--debug" option.  Removed
           unnecessary ".flags = 0" from all options.  Changed so that
           "--disable-plugin" only takes one plugin.  Check for
           non-existence of ":" in argument to "--options-for".  Added
           some debugging outputs.  Set the FD_CLOEXEC flag on the
           directory FD.  More capable code for dealing with
           disallowed plugin file name prefixes and suffixes.  Bug
           fix: check for some malloc failures.  Moved allocating the
           "struct process *new_process" to after the fork.  Do
           _exit() instead of exit() in the child.

* plugins.d/mandosclient.c: Updated contact information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server.py
 
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
# following functions: "AvahiService.add", "AvahiService.remove",
 
10
# "server_state_changed", "entry_group_state_changed", and some lines
 
11
# in "main".
 
12
# 
 
13
# Everything else is
 
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
 
15
# 
 
16
# This program is free software: you can redistribute it and/or modify
 
17
# it under the terms of the GNU General Public License as published by
 
18
# the Free Software Foundation, either version 3 of the License, or
 
19
# (at your option) any later version.
 
20
#
 
21
#     This program is distributed in the hope that it will be useful,
 
22
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
23
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
24
#     GNU General Public License for more details.
 
25
# 
 
26
# You should have received a copy of the GNU General Public License
 
27
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
28
# 
 
29
# Contact the authors at <mandos@fukt.bsnet.se>.
 
30
# 
 
31
 
 
32
from __future__ import division
 
33
 
 
34
import SocketServer
 
35
import socket
 
36
import select
 
37
from optparse import OptionParser
 
38
import datetime
 
39
import errno
 
40
import gnutls.crypto
 
41
import gnutls.connection
 
42
import gnutls.errors
 
43
import gnutls.library.functions
 
44
import gnutls.library.constants
 
45
import gnutls.library.types
 
46
import ConfigParser
 
47
import sys
 
48
import re
 
49
import os
 
50
import signal
 
51
from sets import Set
 
52
import subprocess
 
53
import atexit
 
54
import stat
 
55
import logging
 
56
import logging.handlers
 
57
 
 
58
import dbus
 
59
import gobject
 
60
import avahi
 
61
from dbus.mainloop.glib import DBusGMainLoop
 
62
import ctypes
 
63
 
 
64
# Brief description of the operation of this program:
 
65
# 
 
66
# This server announces itself as a Zeroconf service.  Connecting
 
67
# clients use the TLS protocol, with the unusual quirk that this
 
68
# server program acts as a TLS "client" while a connecting client acts
 
69
# as a TLS "server".  The client (acting as a TLS "server") must
 
70
# supply an OpenPGP certificate, and the fingerprint of this
 
71
# certificate is used by this server to look up (in a list read from a
 
72
# file at start time) which binary blob to give the client.  No other
 
73
# authentication or authorization is done by this server.
 
74
 
 
75
 
 
76
logger = logging.Logger('mandos')
 
77
syslogger = logging.handlers.SysLogHandler\
 
78
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON)
 
79
syslogger.setFormatter(logging.Formatter\
 
80
                        ('%(levelname)s: %(message)s'))
 
81
logger.addHandler(syslogger)
 
82
del syslogger
 
83
 
 
84
 
 
85
class AvahiError(Exception):
 
86
    def __init__(self, value):
 
87
        self.value = value
 
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
    """
 
100
    interface: integer; avahi.IF_UNSPEC or an interface index.
 
101
               Used to optionally bind to the specified interface.
 
102
    name = string; Example: "Mandos"
 
103
    type = string; Example: "_mandos._tcp".
 
104
                   See <http://www.dns-sd.org/ServiceTypes.html>
 
105
    port = integer; what port to announce
 
106
    TXT = list of strings; TXT record for the service
 
107
    domain = string; Domain to publish on, default to .local if empty.
 
108
    host = string; Host to publish records for, default to localhost
 
109
                   if empty.
 
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
                 type = None, port = None, TXT = None, domain = "",
 
116
                 host = "", max_renames = 12):
 
117
        """An Avahi (Zeroconf) service. """
 
118
        self.interface = interface
 
119
        self.name = name
 
120
        self.type = type
 
121
        self.port = port
 
122
        if TXT is None:
 
123
            self.TXT = []
 
124
        else:
 
125
            self.TXT = TXT
 
126
        self.domain = domain
 
127
        self.host = host
 
128
        self.rename_count = 0
 
129
    def rename(self):
 
130
        """Derived from the Avahi example code"""
 
131
        if self.rename_count >= self.max_renames:
 
132
            logger.critical(u"No suitable service name found after %i"
 
133
                            u" retries, exiting.", rename_count)
 
134
            raise AvahiServiceError("Too many renames")
 
135
        name = server.GetAlternativeServiceName(name)
 
136
        logger.notice(u"Changing name to %r ...", name)
 
137
        self.remove()
 
138
        self.add()
 
139
        self.rename_count += 1
 
140
    def remove(self):
 
141
        """Derived from the Avahi example code"""
 
142
        if group is not None:
 
143
            group.Reset()
 
144
    def add(self):
 
145
        """Derived from the Avahi example code"""
 
146
        global group
 
147
        if group is None:
 
148
            group = dbus.Interface\
 
149
                    (bus.get_object(avahi.DBUS_NAME,
 
150
                                    server.EntryGroupNew()),
 
151
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
152
            group.connect_to_signal('StateChanged',
 
153
                                    entry_group_state_changed)
 
154
        logger.debug(u"Adding service '%s' of type '%s' ...",
 
155
                     service.name, service.type)
 
156
        group.AddService(
 
157
                self.interface,         # interface
 
158
                avahi.PROTO_INET6,      # protocol
 
159
                dbus.UInt32(0),         # flags
 
160
                self.name, self.type,
 
161
                self.domain, self.host,
 
162
                dbus.UInt16(self.port),
 
163
                avahi.string_array_to_txt_array(self.TXT))
 
164
        group.Commit()
 
165
 
 
166
# From the Avahi example code:
 
167
group = None                            # our entry group
 
168
# End of Avahi example code
 
169
 
 
170
 
 
171
class Client(object):
 
172
    """A representation of a client host served by this server.
 
173
    Attributes:
 
174
    name:      string; from the config file, used in log messages
 
175
    fingerprint: string (40 or 32 hexadecimal digits); used to
 
176
                 uniquely identify the client
 
177
    secret:    bytestring; sent verbatim (over TLS) to client
 
178
    fqdn:      string (FQDN); available for use by the checker command
 
179
    created:   datetime.datetime(); object creation, not client host
 
180
    last_checked_ok: datetime.datetime() or None if not yet checked OK
 
181
    timeout:   datetime.timedelta(); How long from last_checked_ok
 
182
                                     until this client is invalid
 
183
    interval:  datetime.timedelta(); How often to start a new checker
 
184
    stop_hook: If set, called by stop() as stop_hook(self)
 
185
    checker:   subprocess.Popen(); a running checker process used
 
186
                                   to see if the client lives.
 
187
                                   'None' if no process is running.
 
188
    checker_initiator_tag: a gobject event source tag, or None
 
189
    stop_initiator_tag:    - '' -
 
190
    checker_callback_tag:  - '' -
 
191
    checker_command: string; External command which is run to check if
 
192
                     client lives.  %() expansions are done at
 
193
                     runtime with vars(self) as dict, so that for
 
194
                     instance %(name)s can be used in the command.
 
195
    Private attibutes:
 
196
    _timeout: Real variable for 'timeout'
 
197
    _interval: Real variable for 'interval'
 
198
    _timeout_milliseconds: Used when calling gobject.timeout_add()
 
199
    _interval_milliseconds: - '' -
 
200
    """
 
201
    def _set_timeout(self, timeout):
 
202
        "Setter function for 'timeout' attribute"
 
203
        self._timeout = timeout
 
204
        self._timeout_milliseconds = ((self.timeout.days
 
205
                                       * 24 * 60 * 60 * 1000)
 
206
                                      + (self.timeout.seconds * 1000)
 
207
                                      + (self.timeout.microseconds
 
208
                                         // 1000))
 
209
    timeout = property(lambda self: self._timeout,
 
210
                       _set_timeout)
 
211
    del _set_timeout
 
212
    def _set_interval(self, interval):
 
213
        "Setter function for 'interval' attribute"
 
214
        self._interval = interval
 
215
        self._interval_milliseconds = ((self.interval.days
 
216
                                        * 24 * 60 * 60 * 1000)
 
217
                                       + (self.interval.seconds
 
218
                                          * 1000)
 
219
                                       + (self.interval.microseconds
 
220
                                          // 1000))
 
221
    interval = property(lambda self: self._interval,
 
222
                        _set_interval)
 
223
    del _set_interval
 
224
    def __init__(self, name=None, stop_hook=None, fingerprint=None,
 
225
                 secret=None, secfile=None, fqdn=None, timeout=None,
 
226
                 interval=-1, checker=None):
 
227
        """Note: the 'checker' argument sets the 'checker_command'
 
228
        attribute and not the 'checker' attribute.."""
 
229
        self.name = name
 
230
        logger.debug(u"Creating client %r", self.name)
 
231
        # Uppercase and remove spaces from fingerprint
 
232
        # for later comparison purposes with return value of
 
233
        # the fingerprint() function
 
234
        self.fingerprint = fingerprint.upper().replace(u" ", u"")
 
235
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
 
236
        if secret:
 
237
            self.secret = secret.decode(u"base64")
 
238
        elif secfile:
 
239
            sf = open(secfile)
 
240
            self.secret = sf.read()
 
241
            sf.close()
 
242
        else:
 
243
            raise TypeError(u"No secret or secfile for client %s"
 
244
                            % self.name)
 
245
        self.fqdn = fqdn
 
246
        self.created = datetime.datetime.now()
 
247
        self.last_checked_ok = None
 
248
        self.timeout = string_to_delta(timeout)
 
249
        self.interval = string_to_delta(interval)
 
250
        self.stop_hook = stop_hook
 
251
        self.checker = None
 
252
        self.checker_initiator_tag = None
 
253
        self.stop_initiator_tag = None
 
254
        self.checker_callback_tag = None
 
255
        self.check_command = checker
 
256
    def start(self):
 
257
        """Start this client's checker and timeout hooks"""
 
258
        # Schedule a new checker to be started an 'interval' from now,
 
259
        # and every interval from then on.
 
260
        self.checker_initiator_tag = gobject.timeout_add\
 
261
                                     (self._interval_milliseconds,
 
262
                                      self.start_checker)
 
263
        # Also start a new checker *right now*.
 
264
        self.start_checker()
 
265
        # Schedule a stop() when 'timeout' has passed
 
266
        self.stop_initiator_tag = gobject.timeout_add\
 
267
                                  (self._timeout_milliseconds,
 
268
                                   self.stop)
 
269
    def stop(self):
 
270
        """Stop this client.
 
271
        The possibility that a client might be restarted is left open,
 
272
        but not currently used."""
 
273
        # If this client doesn't have a secret, it is already stopped.
 
274
        if self.secret:
 
275
            logger.debug(u"Stopping client %s", self.name)
 
276
            self.secret = None
 
277
        else:
 
278
            return False
 
279
        if getattr(self, "stop_initiator_tag", False):
 
280
            gobject.source_remove(self.stop_initiator_tag)
 
281
            self.stop_initiator_tag = None
 
282
        if getattr(self, "checker_initiator_tag", False):
 
283
            gobject.source_remove(self.checker_initiator_tag)
 
284
            self.checker_initiator_tag = None
 
285
        self.stop_checker()
 
286
        if self.stop_hook:
 
287
            self.stop_hook(self)
 
288
        # Do not run this again if called by a gobject.timeout_add
 
289
        return False
 
290
    def __del__(self):
 
291
        self.stop_hook = None
 
292
        self.stop()
 
293
    def checker_callback(self, pid, condition):
 
294
        """The checker has completed, so take appropriate actions."""
 
295
        now = datetime.datetime.now()
 
296
        self.checker_callback_tag = None
 
297
        self.checker = None
 
298
        if os.WIFEXITED(condition) \
 
299
               and (os.WEXITSTATUS(condition) == 0):
 
300
            logger.debug(u"Checker for %(name)s succeeded",
 
301
                         vars(self))
 
302
            self.last_checked_ok = now
 
303
            gobject.source_remove(self.stop_initiator_tag)
 
304
            self.stop_initiator_tag = gobject.timeout_add\
 
305
                                      (self._timeout_milliseconds,
 
306
                                       self.stop)
 
307
        elif not os.WIFEXITED(condition):
 
308
            logger.warning(u"Checker for %(name)s crashed?",
 
309
                           vars(self))
 
310
        else:
 
311
            logger.debug(u"Checker for %(name)s failed",
 
312
                         vars(self))
 
313
    def start_checker(self):
 
314
        """Start a new checker subprocess if one is not running.
 
315
        If a checker already exists, leave it running and do
 
316
        nothing."""
 
317
        # The reason for not killing a running checker is that if we
 
318
        # did that, then if a checker (for some reason) started
 
319
        # running slowly and taking more than 'interval' time, the
 
320
        # client would inevitably timeout, since no checker would get
 
321
        # a chance to run to completion.  If we instead leave running
 
322
        # checkers alone, the checker would have to take more time
 
323
        # than 'timeout' for the client to be declared invalid, which
 
324
        # is as it should be.
 
325
        if self.checker is None:
 
326
            try:
 
327
                # In case check_command has exactly one % operator
 
328
                command = self.check_command % self.fqdn
 
329
            except TypeError:
 
330
                # Escape attributes for the shell
 
331
                escaped_attrs = dict((key, re.escape(str(val)))
 
332
                                     for key, val in
 
333
                                     vars(self).iteritems())
 
334
                try:
 
335
                    command = self.check_command % escaped_attrs
 
336
                except TypeError, error:
 
337
                    logger.error(u'Could not format string "%s":'
 
338
                                 u' %s', self.check_command, error)
 
339
                    return True # Try again later
 
340
            try:
 
341
                logger.debug(u"Starting checker %r for %s",
 
342
                             command, self.name)
 
343
                self.checker = subprocess.Popen(command,
 
344
                                                close_fds=True,
 
345
                                                shell=True, cwd="/")
 
346
                self.checker_callback_tag = gobject.child_watch_add\
 
347
                                            (self.checker.pid,
 
348
                                             self.checker_callback)
 
349
            except subprocess.OSError, error:
 
350
                logger.error(u"Failed to start subprocess: %s",
 
351
                             error)
 
352
        # Re-run this periodically if run by gobject.timeout_add
 
353
        return True
 
354
    def stop_checker(self):
 
355
        """Force the checker process, if any, to stop."""
 
356
        if self.checker_callback_tag:
 
357
            gobject.source_remove(self.checker_callback_tag)
 
358
            self.checker_callback_tag = None
 
359
        if getattr(self, "checker", None) is None:
 
360
            return
 
361
        logger.debug("Stopping checker for %(name)s", vars(self))
 
362
        try:
 
363
            os.kill(self.checker.pid, signal.SIGTERM)
 
364
            #os.sleep(0.5)
 
365
            #if self.checker.poll() is None:
 
366
            #    os.kill(self.checker.pid, signal.SIGKILL)
 
367
        except OSError, error:
 
368
            if error.errno != errno.ESRCH: # No such process
 
369
                raise
 
370
        self.checker = None
 
371
    def still_valid(self):
 
372
        """Has the timeout not yet passed for this client?"""
 
373
        now = datetime.datetime.now()
 
374
        if self.last_checked_ok is None:
 
375
            return now < (self.created + self.timeout)
 
376
        else:
 
377
            return now < (self.last_checked_ok + self.timeout)
 
378
 
 
379
 
 
380
def peer_certificate(session):
 
381
    "Return the peer's OpenPGP certificate as a bytestring"
 
382
    # If not an OpenPGP certificate...
 
383
    if gnutls.library.functions.gnutls_certificate_type_get\
 
384
            (session._c_object) \
 
385
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
 
386
        # ...do the normal thing
 
387
        return session.peer_certificate
 
388
    list_size = ctypes.c_uint()
 
389
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
 
390
        (session._c_object, ctypes.byref(list_size))
 
391
    if list_size.value == 0:
 
392
        return None
 
393
    cert = cert_list[0]
 
394
    return ctypes.string_at(cert.data, cert.size)
 
395
 
 
396
 
 
397
def fingerprint(openpgp):
 
398
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
 
399
    # New empty GnuTLS certificate
 
400
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
 
401
    gnutls.library.functions.gnutls_openpgp_crt_init\
 
402
        (ctypes.byref(crt))
 
403
    # New GnuTLS "datum" with the OpenPGP public key
 
404
    datum = gnutls.library.types.gnutls_datum_t\
 
405
        (ctypes.cast(ctypes.c_char_p(openpgp),
 
406
                     ctypes.POINTER(ctypes.c_ubyte)),
 
407
         ctypes.c_uint(len(openpgp)))
 
408
    # Import the OpenPGP public key into the certificate
 
409
    ret = gnutls.library.functions.gnutls_openpgp_crt_import\
 
410
        (crt,
 
411
         ctypes.byref(datum),
 
412
         gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
 
413
    # New buffer for the fingerprint
 
414
    buffer = ctypes.create_string_buffer(20)
 
415
    buffer_length = ctypes.c_size_t()
 
416
    # Get the fingerprint from the certificate into the buffer
 
417
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
 
418
        (crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
 
419
    # Deinit the certificate
 
420
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
 
421
    # Convert the buffer to a Python bytestring
 
422
    fpr = ctypes.string_at(buffer, buffer_length.value)
 
423
    # Convert the bytestring to hexadecimal notation
 
424
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
 
425
    return hex_fpr
 
426
 
 
427
 
 
428
class tcp_handler(SocketServer.BaseRequestHandler, object):
 
429
    """A TCP request handler class.
 
430
    Instantiated by IPv6_TCPServer for each request to handle it.
 
431
    Note: This will run in its own forked process."""
 
432
    
 
433
    def handle(self):
 
434
        logger.debug(u"TCP connection from: %s",
 
435
                     unicode(self.client_address))
 
436
        session = gnutls.connection.ClientSession\
 
437
                  (self.request, gnutls.connection.X509Credentials())
 
438
        # Note: gnutls.connection.X509Credentials is really a generic
 
439
        # GnuTLS certificate credentials object so long as no X.509
 
440
        # keys are added to it.  Therefore, we can use it here despite
 
441
        # using OpenPGP certificates.
 
442
        
 
443
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
 
444
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
 
445
        #                "+DHE-DSS"))
 
446
        priority = "NORMAL"             # Fallback default, since this
 
447
                                        # MUST be set.
 
448
        if self.server.settings["priority"]:
 
449
            priority = self.server.settings["priority"]
 
450
        gnutls.library.functions.gnutls_priority_set_direct\
 
451
            (session._c_object, priority, None);
 
452
        
 
453
        try:
 
454
            session.handshake()
 
455
        except gnutls.errors.GNUTLSError, error:
 
456
            logger.debug(u"Handshake failed: %s", error)
 
457
            # Do not run session.bye() here: the session is not
 
458
            # established.  Just abandon the request.
 
459
            return
 
460
        try:
 
461
            fpr = fingerprint(peer_certificate(session))
 
462
        except (TypeError, gnutls.errors.GNUTLSError), error:
 
463
            logger.debug(u"Bad certificate: %s", error)
 
464
            session.bye()
 
465
            return
 
466
        logger.debug(u"Fingerprint: %s", fpr)
 
467
        client = None
 
468
        for c in self.server.clients:
 
469
            if c.fingerprint == fpr:
 
470
                client = c
 
471
                break
 
472
        if not client:
 
473
            logger.debug(u"Client not found for fingerprint: %s", fpr)
 
474
            session.bye()
 
475
            return
 
476
        # Have to check if client.still_valid(), since it is possible
 
477
        # that the client timed out while establishing the GnuTLS
 
478
        # session.
 
479
        if not client.still_valid():
 
480
            logger.debug(u"Client %(name)s is invalid", vars(client))
 
481
            session.bye()
 
482
            return
 
483
        sent_size = 0
 
484
        while sent_size < len(client.secret):
 
485
            sent = session.send(client.secret[sent_size:])
 
486
            logger.debug(u"Sent: %d, remaining: %d",
 
487
                         sent, len(client.secret)
 
488
                         - (sent_size + sent))
 
489
            sent_size += sent
 
490
        session.bye()
 
491
 
 
492
 
 
493
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
 
494
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
 
495
    Attributes:
 
496
        settings:       Server settings
 
497
        clients:        Set() of Client objects
 
498
    """
 
499
    address_family = socket.AF_INET6
 
500
    def __init__(self, *args, **kwargs):
 
501
        if "settings" in kwargs:
 
502
            self.settings = kwargs["settings"]
 
503
            del kwargs["settings"]
 
504
        if "clients" in kwargs:
 
505
            self.clients = kwargs["clients"]
 
506
            del kwargs["clients"]
 
507
        return super(type(self), self).__init__(*args, **kwargs)
 
508
    def server_bind(self):
 
509
        """This overrides the normal server_bind() function
 
510
        to bind to an interface if one was specified, and also NOT to
 
511
        bind to an address or port if they were not specified."""
 
512
        if self.settings["interface"]:
 
513
            # 25 is from /usr/include/asm-i486/socket.h
 
514
            SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
 
515
            try:
 
516
                self.socket.setsockopt(socket.SOL_SOCKET,
 
517
                                       SO_BINDTODEVICE,
 
518
                                       self.settings["interface"])
 
519
            except socket.error, error:
 
520
                if error[0] == errno.EPERM:
 
521
                    logger.warning(u"No permission to"
 
522
                                   u" bind to interface %s",
 
523
                                   self.settings["interface"])
 
524
                else:
 
525
                    raise error
 
526
        # Only bind(2) the socket if we really need to.
 
527
        if self.server_address[0] or self.server_address[1]:
 
528
            if not self.server_address[0]:
 
529
                in6addr_any = "::"
 
530
                self.server_address = (in6addr_any,
 
531
                                       self.server_address[1])
 
532
            elif self.server_address[1] is None:
 
533
                self.server_address = (self.server_address[0],
 
534
                                       0)
 
535
            return super(type(self), self).server_bind()
 
536
 
 
537
 
 
538
def string_to_delta(interval):
 
539
    """Parse a string and return a datetime.timedelta
 
540
 
 
541
    >>> string_to_delta('7d')
 
542
    datetime.timedelta(7)
 
543
    >>> string_to_delta('60s')
 
544
    datetime.timedelta(0, 60)
 
545
    >>> string_to_delta('60m')
 
546
    datetime.timedelta(0, 3600)
 
547
    >>> string_to_delta('24h')
 
548
    datetime.timedelta(1)
 
549
    >>> string_to_delta(u'1w')
 
550
    datetime.timedelta(7)
 
551
    """
 
552
    try:
 
553
        suffix=unicode(interval[-1])
 
554
        value=int(interval[:-1])
 
555
        if suffix == u"d":
 
556
            delta = datetime.timedelta(value)
 
557
        elif suffix == u"s":
 
558
            delta = datetime.timedelta(0, value)
 
559
        elif suffix == u"m":
 
560
            delta = datetime.timedelta(0, 0, 0, 0, value)
 
561
        elif suffix == u"h":
 
562
            delta = datetime.timedelta(0, 0, 0, 0, 0, value)
 
563
        elif suffix == u"w":
 
564
            delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
 
565
        else:
 
566
            raise ValueError
 
567
    except (ValueError, IndexError):
 
568
        raise ValueError
 
569
    return delta
 
570
 
 
571
 
 
572
def server_state_changed(state):
 
573
    """Derived from the Avahi example code"""
 
574
    if state == avahi.SERVER_COLLISION:
 
575
        logger.warning(u"Server name collision")
 
576
        service.remove()
 
577
    elif state == avahi.SERVER_RUNNING:
 
578
        service.add()
 
579
 
 
580
 
 
581
def entry_group_state_changed(state, error):
 
582
    """Derived from the Avahi example code"""
 
583
    logger.debug(u"state change: %i", state)
 
584
    
 
585
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
 
586
        logger.debug(u"Service established.")
 
587
    elif state == avahi.ENTRY_GROUP_COLLISION:
 
588
        logger.warning(u"Service name collision.")
 
589
        service.rename()
 
590
    elif state == avahi.ENTRY_GROUP_FAILURE:
 
591
        logger.critical(u"Error in group state changed %s",
 
592
                        unicode(error))
 
593
        raise AvahiGroupError("State changed: %s", str(error))
 
594
 
 
595
def if_nametoindex(interface, _func=[None]):
 
596
    """Call the C function if_nametoindex(), or equivalent"""
 
597
    if _func[0] is not None:
 
598
        return _func[0](interface)
 
599
    try:
 
600
        if "ctypes.util" not in sys.modules:
 
601
            import ctypes.util
 
602
        while True:
 
603
            try:
 
604
                libc = ctypes.cdll.LoadLibrary\
 
605
                       (ctypes.util.find_library("c"))
 
606
                _func[0] = libc.if_nametoindex
 
607
                return _func[0](interface)
 
608
            except IOError, e:
 
609
                if e != errno.EINTR:
 
610
                    raise
 
611
    except (OSError, AttributeError):
 
612
        if "struct" not in sys.modules:
 
613
            import struct
 
614
        if "fcntl" not in sys.modules:
 
615
            import fcntl
 
616
        def the_hard_way(interface):
 
617
            "Get an interface index the hard way, i.e. using fcntl()"
 
618
            SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
 
619
            s = socket.socket()
 
620
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
621
                                struct.pack("16s16x", interface))
 
622
            s.close()
 
623
            interface_index = struct.unpack("I", ifreq[16:20])[0]
 
624
            return interface_index
 
625
        _func[0] = the_hard_way
 
626
        return _func[0](interface)
 
627
 
 
628
 
 
629
def daemon(nochdir, noclose):
 
630
    """See daemon(3).  Standard BSD Unix function.
 
631
    This should really exist as os.daemon, but it doesn't (yet)."""
 
632
    if os.fork():
 
633
        sys.exit()
 
634
    os.setsid()
 
635
    if not nochdir:
 
636
        os.chdir("/")
 
637
    if not noclose:
 
638
        # Close all standard open file descriptors
 
639
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
640
        if not stat.S_ISCHR(os.fstat(null).st_mode):
 
641
            raise OSError(errno.ENODEV,
 
642
                          "/dev/null not a character device")
 
643
        os.dup2(null, sys.stdin.fileno())
 
644
        os.dup2(null, sys.stdout.fileno())
 
645
        os.dup2(null, sys.stderr.fileno())
 
646
        if null > 2:
 
647
            os.close(null)
 
648
 
 
649
 
 
650
def main():
 
651
    global main_loop_started
 
652
    main_loop_started = False
 
653
    
 
654
    parser = OptionParser()
 
655
    parser.add_option("-i", "--interface", type="string",
 
656
                      metavar="IF", help="Bind to interface IF")
 
657
    parser.add_option("-a", "--address", type="string",
 
658
                      help="Address to listen for requests on")
 
659
    parser.add_option("-p", "--port", type="int",
 
660
                      help="Port number to receive requests on")
 
661
    parser.add_option("--check", action="store_true", default=False,
 
662
                      help="Run self-test")
 
663
    parser.add_option("--debug", action="store_true", default=False,
 
664
                      help="Debug mode; run in foreground and log to"
 
665
                      " terminal")
 
666
    parser.add_option("--priority", type="string", help="GnuTLS"
 
667
                      " priority string (see GnuTLS documentation)")
 
668
    parser.add_option("--servicename", type="string", metavar="NAME",
 
669
                      help="Zeroconf service name")
 
670
    parser.add_option("--configdir", type="string",
 
671
                      default="/etc/mandos", metavar="DIR",
 
672
                      help="Directory to search for configuration"
 
673
                      " files")
 
674
    (options, args) = parser.parse_args()
 
675
    
 
676
    if options.check:
 
677
        import doctest
 
678
        doctest.testmod()
 
679
        sys.exit()
 
680
    
 
681
    # Default values for config file for server-global settings
 
682
    server_defaults = { "interface": "",
 
683
                        "address": "",
 
684
                        "port": "",
 
685
                        "debug": "False",
 
686
                        "priority":
 
687
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
688
                        "servicename": "Mandos",
 
689
                        }
 
690
    
 
691
    # Parse config file for server-global settings
 
692
    server_config = ConfigParser.SafeConfigParser(server_defaults)
 
693
    del server_defaults
 
694
    server_config.read(os.path.join(options.configdir, "server.conf"))
 
695
    server_section = "server"
 
696
    # Convert the SafeConfigParser object to a dict
 
697
    server_settings = dict(server_config.items(server_section))
 
698
    # Use getboolean on the boolean config option
 
699
    server_settings["debug"] = server_config.getboolean\
 
700
                               (server_section, "debug")
 
701
    del server_config
 
702
    
 
703
    # Override the settings from the config file with command line
 
704
    # options, if set.
 
705
    for option in ("interface", "address", "port", "debug",
 
706
                   "priority", "servicename", "configdir"):
 
707
        value = getattr(options, option)
 
708
        if value is not None:
 
709
            server_settings[option] = value
 
710
    del options
 
711
    # Now we have our good server settings in "server_settings"
 
712
    
 
713
    # Parse config file with clients
 
714
    client_defaults = { "timeout": "1h",
 
715
                        "interval": "5m",
 
716
                        "checker": "fping -q -- %%(fqdn)s",
 
717
                        }
 
718
    client_config = ConfigParser.SafeConfigParser(client_defaults)
 
719
    client_config.read(os.path.join(server_settings["configdir"],
 
720
                                    "clients.conf"))
 
721
    
 
722
    global service
 
723
    service = AvahiService(name = server_settings["servicename"],
 
724
                           type = "_mandos._tcp", );
 
725
    if server_settings["interface"]:
 
726
        service.interface = if_nametoindex(server_settings["interface"])
 
727
    
 
728
    global main_loop
 
729
    global bus
 
730
    global server
 
731
    # From the Avahi example code
 
732
    DBusGMainLoop(set_as_default=True )
 
733
    main_loop = gobject.MainLoop()
 
734
    bus = dbus.SystemBus()
 
735
    server = dbus.Interface(
 
736
            bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
 
737
            avahi.DBUS_INTERFACE_SERVER )
 
738
    # End of Avahi example code
 
739
    
 
740
    debug = server_settings["debug"]
 
741
    
 
742
    if debug:
 
743
        console = logging.StreamHandler()
 
744
        # console.setLevel(logging.DEBUG)
 
745
        console.setFormatter(logging.Formatter\
 
746
                             ('%(levelname)s: %(message)s'))
 
747
        logger.addHandler(console)
 
748
        del console
 
749
    
 
750
    clients = Set()
 
751
    def remove_from_clients(client):
 
752
        clients.remove(client)
 
753
        if not clients:
 
754
            logger.debug(u"No clients left, exiting")
 
755
            sys.exit()
 
756
    
 
757
    clients.update(Set(Client(name=section,
 
758
                              stop_hook = remove_from_clients,
 
759
                              **(dict(client_config\
 
760
                                      .items(section))))
 
761
                       for section in client_config.sections()))
 
762
    
 
763
    if not debug:
 
764
        daemon(False, False)
 
765
    
 
766
    def cleanup():
 
767
        "Cleanup function; run on exit"
 
768
        global group
 
769
        # From the Avahi example code
 
770
        if not group is None:
 
771
            group.Free()
 
772
            group = None
 
773
        # End of Avahi example code
 
774
        
 
775
        while clients:
 
776
            client = clients.pop()
 
777
            client.stop_hook = None
 
778
            client.stop()
 
779
    
 
780
    atexit.register(cleanup)
 
781
    
 
782
    if not debug:
 
783
        signal.signal(signal.SIGINT, signal.SIG_IGN)
 
784
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
 
785
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
 
786
    
 
787
    for client in clients:
 
788
        client.start()
 
789
    
 
790
    tcp_server = IPv6_TCPServer((server_settings["address"],
 
791
                                 server_settings["port"]),
 
792
                                tcp_handler,
 
793
                                settings=server_settings,
 
794
                                clients=clients)
 
795
    # Find out what port we got
 
796
    service.port = tcp_server.socket.getsockname()[1]
 
797
    logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
 
798
                 u" scope_id %d" % tcp_server.socket.getsockname())
 
799
    
 
800
    #service.interface = tcp_server.socket.getsockname()[3]
 
801
    
 
802
    try:
 
803
        # From the Avahi example code
 
804
        server.connect_to_signal("StateChanged", server_state_changed)
 
805
        try:
 
806
            server_state_changed(server.GetState())
 
807
        except dbus.exceptions.DBusException, error:
 
808
            logger.critical(u"DBusException: %s", error)
 
809
            sys.exit(1)
 
810
        # End of Avahi example code
 
811
        
 
812
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
 
813
                             lambda *args, **kwargs:
 
814
                             tcp_server.handle_request\
 
815
                             (*args[2:], **kwargs) or True)
 
816
        
 
817
        logger.debug("Starting main loop")
 
818
        main_loop_started = True
 
819
        main_loop.run()
 
820
    except AvahiError, error:
 
821
        logger.critical(u"AvahiError: %s" + unicode(error))
 
822
        sys.exit(1)
 
823
    except KeyboardInterrupt:
 
824
        if debug:
 
825
            print
 
826
 
 
827
if __name__ == '__main__':
 
828
    main()