/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-07-31 19:48:05 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080731194805-mseis21dxwrdfqhk
* plugins.d/mandosclient.c (start_mandos_communication): Changed
                                                        "if_index" to
                                                        be of type
                                                        "AvahiIfIndex".
                                                        All callers
                                                        changed.
 (main): Add default values to "interface" and "if_index".  Only
         change if_index from default if "interface" was given.

* server.py (IPv6_TCPServer.server_bind): Bug fix: test if interface
                                          is empty, not if equal to
                                          avahi.IF_UNSPEC.
  (if_nametoindex): Bug fix; typo: assign to _func[0], not func[0].
  (main): Bug fix: Do not set service.interface unless the interface
          setting has been given.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server.py
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>.  This includes the
9
 
# methods "add" and "remove" in the "AvahiService" class, the
10
 
# "server_state_changed" and "entry_group_state_changed" functions,
11
 
# and some lines in "main".
 
9
# following functions: "AvahiService.add", "AvahiService.remove",
 
10
# "server_state_changed", "entry_group_state_changed", and some lines
 
11
# in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008 Teddy Hogeborn
15
 
# Copyright © 2008 Björn Påhlsson
 
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
16
15
# 
17
16
# This program is free software: you can redistribute it and/or modify
18
17
# it under the terms of the GNU General Public License as published by
25
24
#     GNU General Public License for more details.
26
25
# 
27
26
# You should have received a copy of the GNU General Public License
28
 
# along with this program.  If not, see
29
 
# <http://www.gnu.org/licenses/>.
 
27
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
30
28
# 
31
29
# Contact the authors at <mandos@fukt.bsnet.se>.
32
30
# 
33
31
 
34
 
from __future__ import division, with_statement, absolute_import
 
32
from __future__ import division
35
33
 
36
34
import SocketServer
37
35
import socket
 
36
import select
38
37
from optparse import OptionParser
39
38
import datetime
40
39
import errno
55
54
import stat
56
55
import logging
57
56
import logging.handlers
58
 
import pwd
59
 
from contextlib import closing
60
57
 
61
58
import dbus
62
 
import dbus.service
63
59
import gobject
64
60
import avahi
65
61
from dbus.mainloop.glib import DBusGMainLoop
66
62
import ctypes
67
 
import ctypes.util
68
 
 
69
 
version = "1.0.2"
 
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
 
70
75
 
71
76
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
syslogger = logging.handlers.SysLogHandler\
 
78
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON)
 
79
syslogger.setFormatter(logging.Formatter\
 
80
                        ('%(levelname)s: %(message)s'))
77
81
logger.addHandler(syslogger)
 
82
del syslogger
78
83
 
79
 
console = logging.StreamHandler()
80
 
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
81
 
                                       ' %(message)s'))
82
 
logger.addHandler(console)
83
84
 
84
85
class AvahiError(Exception):
85
86
    def __init__(self, value):
86
87
        self.value = value
87
 
        super(AvahiError, self).__init__()
88
88
    def __str__(self):
89
89
        return repr(self.value)
90
90
 
96
96
 
97
97
 
98
98
class AvahiService(object):
99
 
    """An Avahi (Zeroconf) service.
100
 
    Attributes:
 
99
    """
101
100
    interface: integer; avahi.IF_UNSPEC or an interface index.
102
101
               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
 
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
113
    """
114
114
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
 
                 servicetype = None, port = None, TXT = None,
116
 
                 domain = "", host = "", max_renames = 32768):
 
115
                 type = None, port = None, TXT = None, domain = "",
 
116
                 host = "", max_renames = 12):
 
117
        """An Avahi (Zeroconf) service. """
117
118
        self.interface = interface
118
119
        self.name = name
119
 
        self.type = servicetype
 
120
        self.type = type
120
121
        self.port = port
121
 
        self.TXT = TXT if TXT is not None else []
 
122
        if TXT is None:
 
123
            self.TXT = []
 
124
        else:
 
125
            self.TXT = TXT
122
126
        self.domain = domain
123
127
        self.host = host
124
128
        self.rename_count = 0
125
 
        self.max_renames = max_renames
126
129
    def rename(self):
127
130
        """Derived from the Avahi example code"""
128
131
        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
            logger.critical(u"No suitable service name found after %i"
 
133
                            u" retries, exiting.", rename_count)
132
134
            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))
 
135
        name = server.GetAlternativeServiceName(name)
 
136
        logger.notice(u"Changing name to %r ...", name)
139
137
        self.remove()
140
138
        self.add()
141
139
        self.rename_count += 1
147
145
        """Derived from the Avahi example code"""
148
146
        global group
149
147
        if group is None:
150
 
            group = dbus.Interface(bus.get_object
151
 
                                   (avahi.DBUS_NAME,
 
148
            group = dbus.Interface\
 
149
                    (bus.get_object(avahi.DBUS_NAME,
152
150
                                    server.EntryGroupNew()),
153
 
                                   avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
151
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
152
            group.connect_to_signal('StateChanged',
155
153
                                    entry_group_state_changed)
156
 
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
 
154
        logger.debug(u"Adding service '%s' of type '%s' ...",
157
155
                     service.name, service.type)
158
156
        group.AddService(
159
157
                self.interface,         # interface
170
168
# End of Avahi example code
171
169
 
172
170
 
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):
 
171
class Client(object):
179
172
    """A representation of a client host served by this server.
180
173
    Attributes:
181
 
    name:       string; from the config file, used in log messages
 
174
    name:      string; from the config file, used in log messages
182
175
    fingerprint: string (40 or 32 hexadecimal digits); used to
183
176
                 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.
 
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.
197
188
    checker_initiator_tag: a gobject event source tag, or None
198
 
    disable_initiator_tag:    - '' -
 
189
    stop_initiator_tag:    - '' -
199
190
    checker_callback_tag:  - '' -
200
191
    checker_command: string; External command which is run to check if
201
192
                     client lives.  %() expansions are done at
202
193
                     runtime with vars(self) as dict, so that for
203
194
                     instance %(name)s can be used in the command.
204
 
    dbus_object_path: dbus.ObjectPath
205
195
    Private attibutes:
206
196
    _timeout: Real variable for 'timeout'
207
197
    _interval: Real variable for 'interval'
209
199
    _interval_milliseconds: - '' -
210
200
    """
211
201
    def _set_timeout(self, timeout):
212
 
        "Setter function for the 'timeout' attribute"
 
202
        "Setter function for 'timeout' attribute"
213
203
        self._timeout = timeout
214
204
        self._timeout_milliseconds = ((self.timeout.days
215
205
                                       * 24 * 60 * 60 * 1000)
216
206
                                      + (self.timeout.seconds * 1000)
217
207
                                      + (self.timeout.microseconds
218
208
                                         // 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)
 
209
    timeout = property(lambda self: self._timeout,
 
210
                       _set_timeout)
224
211
    del _set_timeout
225
 
    
226
212
    def _set_interval(self, interval):
227
 
        "Setter function for the 'interval' attribute"
 
213
        "Setter function for 'interval' attribute"
228
214
        self._interval = interval
229
215
        self._interval_milliseconds = ((self.interval.days
230
216
                                        * 24 * 60 * 60 * 1000)
232
218
                                          * 1000)
233
219
                                       + (self.interval.microseconds
234
220
                                          // 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)
 
221
    interval = property(lambda self: self._interval,
 
222
                        _set_interval)
240
223
    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 = {}
 
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.."""
253
229
        self.name = name
254
230
        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""))
 
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"")
260
235
        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()
 
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()
268
242
        else:
269
243
            raise TypeError(u"No secret or secfile for client %s"
270
244
                            % self.name)
271
 
        self.host = config.get("host", "")
272
 
        self.created = datetime.datetime.utcnow()
273
 
        self.enabled = False
274
 
        self.last_enabled = None
 
245
        self.fqdn = fqdn
 
246
        self.created = datetime.datetime.now()
275
247
        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
 
248
        self.timeout = string_to_delta(timeout)
 
249
        self.interval = string_to_delta(interval)
 
250
        self.stop_hook = stop_hook
279
251
        self.checker = None
280
252
        self.checker_initiator_tag = None
281
 
        self.disable_initiator_tag = None
 
253
        self.stop_initiator_tag = None
282
254
        self.checker_callback_tag = None
283
 
        self.checker_command = config["checker"]
284
 
    
285
 
    def enable(self):
 
255
        self.check_command = checker
 
256
    def start(self):
286
257
        """Start this client's checker and timeout hooks"""
287
 
        self.last_enabled = datetime.datetime.utcnow()
288
258
        # Schedule a new checker to be started an 'interval' from now,
289
259
        # and every interval from then on.
290
 
        self.checker_initiator_tag = (gobject.timeout_add
291
 
                                      (self._interval_milliseconds,
292
 
                                       self.start_checker))
 
260
        self.checker_initiator_tag = gobject.timeout_add\
 
261
                                     (self._interval_milliseconds,
 
262
                                      self.start_checker)
293
263
        # Also start a new checker *right now*.
294
264
        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):
 
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:
310
278
            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
 
279
        if getattr(self, "stop_initiator_tag", False):
 
280
            gobject.source_remove(self.stop_initiator_tag)
 
281
            self.stop_initiator_tag = None
315
282
        if getattr(self, "checker_initiator_tag", False):
316
283
            gobject.source_remove(self.checker_initiator_tag)
317
284
            self.checker_initiator_tag = None
318
285
        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))
 
286
        if self.stop_hook:
 
287
            self.stop_hook(self)
325
288
        # Do not run this again if called by a gobject.timeout_add
326
289
        return False
327
 
    
328
290
    def __del__(self):
329
 
        self.disable_hook = None
330
 
        self.disable()
331
 
    
332
 
    def checker_callback(self, pid, condition, command):
 
291
        self.stop_hook = None
 
292
        self.stop()
 
293
    def checker_callback(self, pid, condition):
333
294
        """The checker has completed, so take appropriate actions."""
 
295
        now = datetime.datetime.now()
334
296
        self.checker_callback_tag = None
335
297
        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()
 
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)
348
307
        elif not os.WIFEXITED(condition):
349
308
            logger.warning(u"Checker for %(name)s crashed?",
350
309
                           vars(self))
351
 
            # Emit D-Bus signal
352
 
            self.CheckerCompleted(dbus.Boolean(False),
353
 
                                  dbus.UInt16(condition),
354
 
                                  dbus.String(command))
355
310
        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
 
    
 
311
            logger.debug(u"Checker for %(name)s failed",
 
312
                         vars(self))
377
313
    def start_checker(self):
378
314
        """Start a new checker subprocess if one is not running.
379
315
        If a checker already exists, leave it running and do
388
324
        # is as it should be.
389
325
        if self.checker is None:
390
326
            try:
391
 
                # In case checker_command has exactly one % operator
392
 
                command = self.checker_command % self.host
 
327
                # In case check_command has exactly one % operator
 
328
                command = self.check_command % self.fqdn
393
329
            except TypeError:
394
330
                # Escape attributes for the shell
395
331
                escaped_attrs = dict((key, re.escape(str(val)))
396
332
                                     for key, val in
397
333
                                     vars(self).iteritems())
398
334
                try:
399
 
                    command = self.checker_command % escaped_attrs
 
335
                    command = self.check_command % escaped_attrs
400
336
                except TypeError, error:
401
337
                    logger.error(u'Could not format string "%s":'
402
 
                                 u' %s', self.checker_command, error)
 
338
                                 u' %s', self.check_command, error)
403
339
                    return True # Try again later
404
340
            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.)
 
341
                logger.debug(u"Starting checker %r for %s",
 
342
                             command, self.name)
411
343
                self.checker = subprocess.Popen(command,
412
344
                                                close_fds=True,
413
345
                                                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:
 
346
                self.checker_callback_tag = gobject.child_watch_add\
 
347
                                            (self.checker.pid,
 
348
                                             self.checker_callback)
 
349
            except subprocess.OSError, error:
423
350
                logger.error(u"Failed to start subprocess: %s",
424
351
                             error)
425
352
        # Re-run this periodically if run by gobject.timeout_add
426
353
        return True
427
 
    
428
354
    def stop_checker(self):
429
355
        """Force the checker process, if any, to stop."""
430
356
        if self.checker_callback_tag:
432
358
            self.checker_callback_tag = None
433
359
        if getattr(self, "checker", None) is None:
434
360
            return
435
 
        logger.debug(u"Stopping checker for %(name)s", vars(self))
 
361
        logger.debug("Stopping checker for %(name)s", vars(self))
436
362
        try:
437
363
            os.kill(self.checker.pid, signal.SIGTERM)
438
364
            #os.sleep(0.5)
442
368
            if error.errno != errno.ESRCH: # No such process
443
369
                raise
444
370
        self.checker = None
445
 
        self.PropertyChanged(dbus.String(u"checker_running"),
446
 
                             dbus.Boolean(False, variant_level=1))
447
 
    
448
371
    def still_valid(self):
449
372
        """Has the timeout not yet passed for this client?"""
450
 
        if not getattr(self, "enabled", False):
451
 
            return False
452
 
        now = datetime.datetime.utcnow()
 
373
        now = datetime.datetime.now()
453
374
        if self.last_checked_ok is None:
454
375
            return now < (self.created + self.timeout)
455
376
        else:
456
377
            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
378
 
578
379
 
579
380
def peer_certificate(session):
580
381
    "Return the peer's OpenPGP certificate as a bytestring"
581
382
    # 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):
 
383
    if gnutls.library.functions.gnutls_certificate_type_get\
 
384
            (session._c_object) \
 
385
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
585
386
        # ...do the normal thing
586
387
        return session.peer_certificate
587
388
    list_size = ctypes.c_uint()
588
 
    cert_list = (gnutls.library.functions
589
 
                 .gnutls_certificate_get_peers
590
 
                 (session._c_object, ctypes.byref(list_size)))
 
389
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
 
390
        (session._c_object, ctypes.byref(list_size))
591
391
    if list_size.value == 0:
592
392
        return None
593
393
    cert = cert_list[0]
596
396
 
597
397
def fingerprint(openpgp):
598
398
    "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
399
    # New empty GnuTLS certificate
606
400
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
607
 
    (gnutls.library.functions
608
 
     .gnutls_openpgp_crt_init(ctypes.byref(crt)))
 
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)))
609
408
    # 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")
 
409
    ret = gnutls.library.functions.gnutls_openpgp_crt_import\
 
410
        (crt,
 
411
         ctypes.byref(datum),
 
412
         gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
621
413
    # New buffer for the fingerprint
622
 
    buf = ctypes.create_string_buffer(20)
623
 
    buf_len = ctypes.c_size_t()
 
414
    buffer = ctypes.create_string_buffer(20)
 
415
    buffer_length = ctypes.c_size_t()
624
416
    # 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)))
 
417
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
 
418
        (crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
628
419
    # Deinit the certificate
629
420
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
630
421
    # Convert the buffer to a Python bytestring
631
 
    fpr = ctypes.string_at(buf, buf_len.value)
 
422
    fpr = ctypes.string_at(buffer, buffer_length.value)
632
423
    # Convert the bytestring to hexadecimal notation
633
424
    hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
634
425
    return hex_fpr
635
426
 
636
427
 
637
 
class TCP_handler(SocketServer.BaseRequestHandler, object):
 
428
class tcp_handler(SocketServer.BaseRequestHandler, object):
638
429
    """A TCP request handler class.
639
430
    Instantiated by IPv6_TCPServer for each request to handle it.
640
431
    Note: This will run in its own forked process."""
641
432
    
642
433
    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
 
        
 
434
        logger.debug(u"TCP connection from: %s",
 
435
                     unicode(self.client_address))
 
436
        session = gnutls.connection.ClientSession\
 
437
                  (self.request, gnutls.connection.X509Credentials())
659
438
        # Note: gnutls.connection.X509Credentials is really a generic
660
439
        # GnuTLS certificate credentials object so long as no X.509
661
440
        # keys are added to it.  Therefore, we can use it here despite
664
443
        #priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
665
444
        #                "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
666
445
        #                "+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))
 
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);
672
452
        
673
453
        try:
674
454
            session.handshake()
675
455
        except gnutls.errors.GNUTLSError, error:
676
 
            logger.warning(u"Handshake failed: %s", error)
 
456
            logger.debug(u"Handshake failed: %s", error)
677
457
            # Do not run session.bye() here: the session is not
678
458
            # established.  Just abandon the request.
679
459
            return
680
460
        try:
681
461
            fpr = fingerprint(peer_certificate(session))
682
462
        except (TypeError, gnutls.errors.GNUTLSError), error:
683
 
            logger.warning(u"Bad certificate: %s", error)
 
463
            logger.debug(u"Bad certificate: %s", error)
684
464
            session.bye()
685
465
            return
686
466
        logger.debug(u"Fingerprint: %s", fpr)
 
467
        client = None
687
468
        for c in self.server.clients:
688
469
            if c.fingerprint == fpr:
689
470
                client = c
690
471
                break
691
 
        else:
692
 
            logger.warning(u"Client not found for fingerprint: %s",
693
 
                           fpr)
 
472
        if not client:
 
473
            logger.debug(u"Client not found for fingerprint: %s", fpr)
694
474
            session.bye()
695
475
            return
696
476
        # Have to check if client.still_valid(), since it is possible
697
477
        # that the client timed out while establishing the GnuTLS
698
478
        # session.
699
479
        if not client.still_valid():
700
 
            logger.warning(u"Client %(name)s is invalid",
701
 
                           vars(client))
 
480
            logger.debug(u"Client %(name)s is invalid", vars(client))
702
481
            session.bye()
703
482
            return
704
 
        ## This won't work here, since we're in a fork.
705
 
        # client.bump_timeout()
706
483
        sent_size = 0
707
484
        while sent_size < len(client.secret):
708
485
            sent = session.send(client.secret[sent_size:])
713
490
        session.bye()
714
491
 
715
492
 
716
 
class IPv6_TCPServer(SocketServer.ForkingMixIn,
717
 
                     SocketServer.TCPServer, object):
 
493
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
718
494
    """IPv6 TCP server.  Accepts 'None' as address and/or port.
719
495
    Attributes:
720
496
        settings:       Server settings
721
497
        clients:        Set() of Client objects
722
 
        enabled:        Boolean; whether this server is activated yet
723
498
    """
724
499
    address_family = socket.AF_INET6
725
500
    def __init__(self, *args, **kwargs):
729
504
        if "clients" in kwargs:
730
505
            self.clients = kwargs["clients"]
731
506
            del kwargs["clients"]
732
 
        self.enabled = False
733
 
        super(IPv6_TCPServer, self).__init__(*args, **kwargs)
 
507
        return super(type(self), self).__init__(*args, **kwargs)
734
508
    def server_bind(self):
735
509
        """This overrides the normal server_bind() function
736
510
        to bind to an interface if one was specified, and also NOT to
744
518
                                       self.settings["interface"])
745
519
            except socket.error, error:
746
520
                if error[0] == errno.EPERM:
747
 
                    logger.error(u"No permission to"
748
 
                                 u" bind to interface %s",
749
 
                                 self.settings["interface"])
 
521
                    logger.warning(u"No permission to"
 
522
                                   u" bind to interface %s",
 
523
                                   self.settings["interface"])
750
524
                else:
751
525
                    raise error
752
526
        # Only bind(2) the socket if we really need to.
755
529
                in6addr_any = "::"
756
530
                self.server_address = (in6addr_any,
757
531
                                       self.server_address[1])
758
 
            elif not self.server_address[1]:
 
532
            elif self.server_address[1] is None:
759
533
                self.server_address = (self.server_address[0],
760
534
                                       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
 
535
            return super(type(self), self).server_bind()
774
536
 
775
537
 
776
538
def string_to_delta(interval):
786
548
    datetime.timedelta(1)
787
549
    >>> string_to_delta(u'1w')
788
550
    datetime.timedelta(7)
789
 
    >>> string_to_delta('5m 30s')
790
 
    datetime.timedelta(0, 330)
791
551
    """
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):
 
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:
810
566
            raise ValueError
811
 
        timevalue += delta
812
 
    return timevalue
 
567
    except (ValueError, IndexError):
 
568
        raise ValueError
 
569
    return delta
813
570
 
814
571
 
815
572
def server_state_changed(state):
816
573
    """Derived from the Avahi example code"""
817
574
    if state == avahi.SERVER_COLLISION:
818
 
        logger.error(u"Zeroconf server name collision")
 
575
        logger.warning(u"Server name collision")
819
576
        service.remove()
820
577
    elif state == avahi.SERVER_RUNNING:
821
578
        service.add()
823
580
 
824
581
def entry_group_state_changed(state, error):
825
582
    """Derived from the Avahi example code"""
826
 
    logger.debug(u"Avahi state change: %i", state)
 
583
    logger.debug(u"state change: %i", state)
827
584
    
828
585
    if state == avahi.ENTRY_GROUP_ESTABLISHED:
829
 
        logger.debug(u"Zeroconf service established.")
 
586
        logger.debug(u"Service established.")
830
587
    elif state == avahi.ENTRY_GROUP_COLLISION:
831
 
        logger.warning(u"Zeroconf service name collision.")
 
588
        logger.warning(u"Service name collision.")
832
589
        service.rename()
833
590
    elif state == avahi.ENTRY_GROUP_FAILURE:
834
 
        logger.critical(u"Avahi: Error in group state changed %s",
 
591
        logger.critical(u"Error in group state changed %s",
835
592
                        unicode(error))
836
593
        raise AvahiGroupError("State changed: %s", str(error))
837
594
 
838
 
def if_nametoindex(interface):
 
595
def if_nametoindex(interface, _func=[None]):
839
596
    """Call the C function if_nametoindex(), or equivalent"""
840
 
    global if_nametoindex
 
597
    if _func[0] is not None:
 
598
        return _func[0](interface)
841
599
    try:
842
 
        if_nametoindex = (ctypes.cdll.LoadLibrary
843
 
                          (ctypes.util.find_library("c"))
844
 
                          .if_nametoindex)
 
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
845
611
    except (OSError, AttributeError):
846
612
        if "struct" not in sys.modules:
847
613
            import struct
848
614
        if "fcntl" not in sys.modules:
849
615
            import fcntl
850
 
        def if_nametoindex(interface):
 
616
        def the_hard_way(interface):
851
617
            "Get an interface index the hard way, i.e. using fcntl()"
852
618
            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))
 
619
            s = socket.socket()
 
620
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
 
621
                                struct.pack("16s16x", interface))
 
622
            s.close()
856
623
            interface_index = struct.unpack("I", ifreq[16:20])[0]
857
624
            return interface_index
858
 
    return if_nametoindex(interface)
859
 
 
860
 
 
861
 
def daemon(nochdir = False, noclose = False):
 
625
        _func[0] = the_hard_way
 
626
        return _func[0](interface)
 
627
 
 
628
 
 
629
def daemon(nochdir, noclose):
862
630
    """See daemon(3).  Standard BSD Unix function.
863
631
    This should really exist as os.daemon, but it doesn't (yet)."""
864
632
    if os.fork():
866
634
    os.setsid()
867
635
    if not nochdir:
868
636
        os.chdir("/")
869
 
    if os.fork():
870
 
        sys.exit()
871
637
    if not noclose:
872
638
        # Close all standard open file descriptors
873
639
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
882
648
 
883
649
 
884
650
def main():
885
 
    parser = OptionParser(version = "%%prog %s" % version)
 
651
    global main_loop_started
 
652
    main_loop_started = False
 
653
    
 
654
    parser = OptionParser()
886
655
    parser.add_option("-i", "--interface", type="string",
887
656
                      metavar="IF", help="Bind to interface IF")
888
657
    parser.add_option("-a", "--address", type="string",
891
660
                      help="Port number to receive requests on")
892
661
    parser.add_option("--check", action="store_true", default=False,
893
662
                      help="Run self-test")
894
 
    parser.add_option("--debug", action="store_true",
 
663
    parser.add_option("--debug", action="store_true", default=False,
895
664
                      help="Debug mode; run in foreground and log to"
896
665
                      " terminal")
897
666
    parser.add_option("--priority", type="string", help="GnuTLS"
902
671
                      default="/etc/mandos", metavar="DIR",
903
672
                      help="Directory to search for configuration"
904
673
                      " files")
905
 
    options = parser.parse_args()[0]
 
674
    (options, args) = parser.parse_args()
906
675
    
907
676
    if options.check:
908
677
        import doctest
922
691
    # Parse config file for server-global settings
923
692
    server_config = ConfigParser.SafeConfigParser(server_defaults)
924
693
    del server_defaults
925
 
    server_config.read(os.path.join(options.configdir, "mandos.conf"))
 
694
    server_config.read(os.path.join(options.configdir, "server.conf"))
 
695
    server_section = "server"
926
696
    # Convert the SafeConfigParser object to a dict
927
 
    server_settings = server_config.defaults()
 
697
    server_settings = dict(server_config.items(server_section))
928
698
    # Use getboolean on the boolean config option
929
 
    server_settings["debug"] = (server_config.getboolean
930
 
                                ("DEFAULT", "debug"))
 
699
    server_settings["debug"] = server_config.getboolean\
 
700
                               (server_section, "debug")
931
701
    del server_config
932
702
    
933
703
    # Override the settings from the config file with command line
940
710
    del options
941
711
    # Now we have our good server settings in "server_settings"
942
712
    
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
713
    # Parse config file with clients
956
714
    client_defaults = { "timeout": "1h",
957
715
                        "interval": "5m",
958
 
                        "checker": "fping -q -- %(host)s",
959
 
                        "host": "",
 
716
                        "checker": "fping -q -- %%(fqdn)s",
960
717
                        }
961
718
    client_config = ConfigParser.SafeConfigParser(client_defaults)
962
719
    client_config.read(os.path.join(server_settings["configdir"],
963
720
                                    "clients.conf"))
964
721
    
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
722
    global service
1005
723
    service = AvahiService(name = server_settings["servicename"],
1006
 
                           servicetype = "_mandos._tcp", )
 
724
                           type = "_mandos._tcp", );
1007
725
    if server_settings["interface"]:
1008
 
        service.interface = (if_nametoindex
1009
 
                             (server_settings["interface"]))
 
726
        service.interface = if_nametoindex(server_settings["interface"])
1010
727
    
1011
728
    global main_loop
1012
729
    global bus
1015
732
    DBusGMainLoop(set_as_default=True )
1016
733
    main_loop = gobject.MainLoop()
1017
734
    bus = dbus.SystemBus()
1018
 
    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1019
 
                                           avahi.DBUS_PATH_SERVER),
1020
 
                            avahi.DBUS_INTERFACE_SERVER)
 
735
    server = dbus.Interface(
 
736
            bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
 
737
            avahi.DBUS_INTERFACE_SERVER )
1021
738
    # 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)))
 
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))))
1027
761
                       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
 
762
    
 
763
    if not debug:
 
764
        daemon(False, False)
1056
765
    
1057
766
    def cleanup():
1058
767
        "Cleanup function; run on exit"
1065
774
        
1066
775
        while clients:
1067
776
            client = clients.pop()
1068
 
            client.disable_hook = None
1069
 
            client.disable()
 
777
            client.stop_hook = None
 
778
            client.stop()
1070
779
    
1071
780
    atexit.register(cleanup)
1072
781
    
1075
784
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1076
785
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1077
786
    
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
787
    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
 
    
 
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)
1128
795
    # Find out what port we got
1129
796
    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())
 
797
    logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
 
798
                 u" scope_id %d" % tcp_server.socket.getsockname())
1132
799
    
1133
800
    #service.interface = tcp_server.socket.getsockname()[3]
1134
801
    
1144
811
        
1145
812
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1146
813
                             lambda *args, **kwargs:
1147
 
                             (tcp_server.handle_request
1148
 
                              (*args[2:], **kwargs) or True))
 
814
                             tcp_server.handle_request\
 
815
                             (*args[2:], **kwargs) or True)
1149
816
        
1150
 
        logger.debug(u"Starting main loop")
 
817
        logger.debug("Starting main loop")
 
818
        main_loop_started = True
1151
819
        main_loop.run()
1152
820
    except AvahiError, error:
1153
821
        logger.critical(u"AvahiError: %s" + unicode(error))