/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-20 06:33:48 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080720063348-jscgy5p0itrgvlo8
* mandos-clients.conf ([foo]): Uncommented.
  ([foo]/secret): New.
  ([foo]/secfile): Commented out.
  ([foo]/checker): Changed to "fping -q -- %%(fqdn)s".
  ([foo]/timeout): New.

* server.py: New modeline for Python and Emacs.  Set a logging format.
  (Client.__init__): Bug fix: Choose either the value from the options
                     object or pass the argument through string_to_delta
                     for both "timeout" and "interval".
  (Client.checker_callback): Bug fix: Do not log spurious "Checker for
                             <foo> failed" messages.
  (Client.start_checker): Moved "Starting checker" log message down to
                          just before actually starting the subprocess.
                          Do not redirect the subprocesses' stdout to a
                          pipe.
  (peer_certificate, fingerprint): Added docstrings.
  (entry_group_state_changed): Call "killme()" instead of
                               "main_loop.quit()".
  (daemon, killme): New functions.
  (exitstatus, main_loop_started): New global variables.
  (__main__): Removed the "--cert", "--key", "--ca", and "--crl"
              options.  Removed the sleep command from the default
              checker.  Add a console logger in debug mode.  Call
              "killme()" instead of "main_loop.quit()" when there are no
              more clients.  Call "daemon()" if not in debug mode.
              Register "cleanup()" to run at exit.  Ignore some
              signals.  Catch DBusException to detect another running
              server and exit cleanly.  Exit with "exitstatus".
  (cleanup): New function.

Show diffs side-by-side

added added

removed removed

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