To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 89
- compare with another revision
- download diff
- download tarball
- view history from revision 89
- Committer: Teddy Hogeborn
- Date: 2008-08-18 23:55:28 UTC
- Revision ID: teddy@fukt.bsnet.se-20080818235528-dn628nlbrtzl7z4f
* Makefile: Bug fix: fixed creation of man pages for section 5 pages.
* mandos (main): Changed from requiring "[server]" in mandos.conf(5)
to requiring "[DEFAULT]".
* mandos.conf ([server]): Renamed to "[DEFAULT]".
* mandos.conf.xml: Removed <?xml-stylesheet>. New entity "&OVERVIEW;"
referring to "overview.xml".
(DESCRIPTION): Updated to specify the syntax more precisely. Use
<varname> around the option names.
* mandos (main): Changed from requiring "[server]" in mandos.conf(5)
to requiring "[DEFAULT]".
* mandos.conf ([server]): Renamed to "[DEFAULT]".
* mandos.conf.xml: Removed <?xml-stylesheet>. New entity "&OVERVIEW;"
referring to "overview.xml".
(DESCRIPTION): Updated to specify the syntax more precisely. Use
<varname> around the option names.
- files added:
- plugins.d/usplash
- files removed:
- .bzr-builddeb
- debian
- debian/po
- files renamed:
- plugins.d/mandos-client.c => plugins.d/password-request.c
- plugins.d/mandos-client.xml => plugins.d/password-request.xml
- files modified:
- Makefile
added
removed
mandos
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines in "main".
9
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 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
import SocketServer as socketserver
34
import SocketServer
37
35
import socket
38
import optparse
36
import select
37
from optparse import OptionParser
39
38
import datetime
40
39
import errno
41
40
import gnutls.crypto
44
43
import gnutls.library.functions
45
44
import gnutls.library.constants
46
45
import gnutls.library.types
47
import ConfigParser as configparser
46
import ConfigParser
48
47
import sys
49
48
import re
50
49
import os
51
50
import signal
51
from sets import Set
52
52
import subprocess
53
53
import atexit
54
54
import stat
55
55
import logging
56
56
import logging.handlers
57
import pwd
58
from contextlib import closing
59
import struct
60
import fcntl
61
import functools
62
57
63
58
import dbus
64
import dbus.service
65
59
import gobject
66
60
import avahi
67
61
from dbus.mainloop.glib import DBusGMainLoop
68
62
import ctypes
69
import ctypes.util
70
71
try:
72
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
73
except AttributeError:
74
try:
75
from IN import SO_BINDTODEVICE
76
except ImportError:
77
SO_BINDTODEVICE = None
78
79
80
version = "1.0.8"
81
82
logger = logging.Logger(u'mandos')
83
syslogger = (logging.handlers.SysLogHandler
84
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
85
address = "/dev/log"))
86
syslogger.setFormatter(logging.Formatter
87
(u'Mandos [%(process)d]: %(levelname)s:'
88
u' %(message)s'))
63
64
version = "1.0"
65
66
logger = logging.Logger('mandos')
67
syslogger = logging.handlers.SysLogHandler\
68
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
69
address = "/dev/log")
70
syslogger.setFormatter(logging.Formatter\
71
('Mandos: %(levelname)s: %(message)s'))
89
72
logger.addHandler(syslogger)
90
73
91
74
console = logging.StreamHandler()
92
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
93
u' %(levelname)s:'
94
u' %(message)s'))
75
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
76
' %(message)s'))
95
77
logger.addHandler(console)
96
78
97
79
class AvahiError(Exception):
98
def __init__(self, value, *args, **kwargs):
80
def __init__(self, value):
99
81
self.value = value
100
super(AvahiError, self).__init__(value, *args, **kwargs)
101
def __unicode__(self):
102
return unicode(repr(self.value))
82
def __str__(self):
83
return repr(self.value)
103
84
104
85
class AvahiServiceError(AvahiError):
105
86
pass
110
91
111
92
class AvahiService(object):
112
93
"""An Avahi (Zeroconf) service.
113
114
94
Attributes:
115
95
interface: integer; avahi.IF_UNSPEC or an interface index.
116
96
Used to optionally bind to the specified interface.
117
name: string; Example: u'Mandos'
118
type: string; Example: u'_mandos._tcp'.
97
name: string; Example: 'Mandos'
98
type: string; Example: '_mandos._tcp'.
119
99
See <http://www.dns-sd.org/ServiceTypes.html>
120
100
port: integer; what port to announce
121
101
TXT: list of strings; TXT record for the service
124
104
max_renames: integer; maximum number of renames
125
105
rename_count: integer; counter so we only rename after collisions
126
106
a sensible number of times
127
group: D-Bus Entry Group
128
server: D-Bus Server
129
bus: dbus.SystemBus()
130
107
"""
131
108
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
132
servicetype = None, port = None, TXT = None,
133
domain = u"", host = u"", max_renames = 32768,
134
protocol = avahi.PROTO_UNSPEC, bus = None):
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
135
111
self.interface = interface
136
112
self.name = name
137
self.type = servicetype
113
self.type = type
138
114
self.port = port
139
self.TXT = TXT if TXT is not None else []
115
if TXT is None:
116
self.TXT = []
117
else:
118
self.TXT = TXT
140
119
self.domain = domain
141
120
self.host = host
142
121
self.rename_count = 0
143
122
self.max_renames = max_renames
144
self.protocol = protocol
145
self.group = None # our entry group
146
self.server = None
147
self.bus = bus
148
123
def rename(self):
149
124
"""Derived from the Avahi example code"""
150
125
if self.rename_count >= self.max_renames:
151
logger.critical(u"No suitable Zeroconf service name found"
152
u" after %i retries, exiting.",
153
self.rename_count)
154
raise AvahiServiceError(u"Too many renames")
155
self.name = self.server.GetAlternativeServiceName(self.name)
156
logger.info(u"Changing Zeroconf service name to %r ...",
157
unicode(self.name))
158
syslogger.setFormatter(logging.Formatter
159
(u'Mandos (%s) [%%(process)d]:'
160
u' %%(levelname)s: %%(message)s'
161
% self.name))
126
logger.critical(u"No suitable service name found after %i"
127
u" retries, exiting.", rename_count)
128
raise AvahiServiceError("Too many renames")
129
self.name = server.GetAlternativeServiceName(self.name)
130
logger.info(u"Changing name to %r ...", str(self.name))
131
syslogger.setFormatter(logging.Formatter\
132
('Mandos (%s): %%(levelname)s:'
133
' %%(message)s' % self.name))
162
134
self.remove()
163
135
self.add()
164
136
self.rename_count += 1
165
137
def remove(self):
166
138
"""Derived from the Avahi example code"""
167
if self.group is not None:
168
self.group.Reset()
139
if group is not None:
140
group.Reset()
169
141
def add(self):
170
142
"""Derived from the Avahi example code"""
171
if self.group is None:
172
self.group = dbus.Interface(
173
self.bus.get_object(avahi.DBUS_NAME,
174
self.server.EntryGroupNew()),
175
avahi.DBUS_INTERFACE_ENTRY_GROUP)
176
self.group.connect_to_signal('StateChanged',
177
self.entry_group_state_changed)
178
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
179
self.name, self.type)
180
self.group.AddService(
181
self.interface,
182
self.protocol,
183
dbus.UInt32(0), # flags
184
self.name, self.type,
185
self.domain, self.host,
186
dbus.UInt16(self.port),
187
avahi.string_array_to_txt_array(self.TXT))
188
self.group.Commit()
189
def entry_group_state_changed(self, state, error):
190
"""Derived from the Avahi example code"""
191
logger.debug(u"Avahi state change: %i", state)
192
193
if state == avahi.ENTRY_GROUP_ESTABLISHED:
194
logger.debug(u"Zeroconf service established.")
195
elif state == avahi.ENTRY_GROUP_COLLISION:
196
logger.warning(u"Zeroconf service name collision.")
197
self.rename()
198
elif state == avahi.ENTRY_GROUP_FAILURE:
199
logger.critical(u"Avahi: Error in group state changed %s",
200
unicode(error))
201
raise AvahiGroupError(u"State changed: %s"
202
% unicode(error))
203
def cleanup(self):
204
"""Derived from the Avahi example code"""
205
if self.group is not None:
206
self.group.Free()
207
self.group = None
208
def server_state_changed(self, state):
209
"""Derived from the Avahi example code"""
210
if state == avahi.SERVER_COLLISION:
211
logger.error(u"Zeroconf server name collision")
212
self.remove()
213
elif state == avahi.SERVER_RUNNING:
214
self.add()
215
def activate(self):
216
"""Derived from the Avahi example code"""
217
if self.server is None:
218
self.server = dbus.Interface(
219
self.bus.get_object(avahi.DBUS_NAME,
220
avahi.DBUS_PATH_SERVER),
221
avahi.DBUS_INTERFACE_SERVER)
222
self.server.connect_to_signal(u"StateChanged",
223
self.server_state_changed)
224
self.server_state_changed(self.server.GetState())
143
global group
144
if group is None:
145
group = dbus.Interface\
146
(bus.get_object(avahi.DBUS_NAME,
147
server.EntryGroupNew()),
148
avahi.DBUS_INTERFACE_ENTRY_GROUP)
149
group.connect_to_signal('StateChanged',
150
entry_group_state_changed)
151
logger.debug(u"Adding service '%s' of type '%s' ...",
152
service.name, service.type)
153
group.AddService(
154
self.interface, # interface
155
avahi.PROTO_INET6, # protocol
156
dbus.UInt32(0), # flags
157
self.name, self.type,
158
self.domain, self.host,
159
dbus.UInt16(self.port),
160
avahi.string_array_to_txt_array(self.TXT))
161
group.Commit()
162
163
# From the Avahi example code:
164
group = None # our entry group
165
# End of Avahi example code
225
166
226
167
227
168
class Client(object):
228
169
"""A representation of a client host served by this server.
229
230
170
Attributes:
231
name: string; from the config file, used in log messages and
232
D-Bus identifiers
171
name: string; from the config file, used in log messages
233
172
fingerprint: string (40 or 32 hexadecimal digits); used to
234
173
uniquely identify the client
235
secret: bytestring; sent verbatim (over TLS) to client
236
host: string; available for use by the checker command
237
created: datetime.datetime(); (UTC) object creation
238
last_enabled: datetime.datetime(); (UTC)
239
enabled: bool()
240
last_checked_ok: datetime.datetime(); (UTC) or None
241
timeout: datetime.timedelta(); How long from last_checked_ok
242
until this client is invalid
243
interval: datetime.timedelta(); How often to start a new checker
244
disable_hook: If set, called by disable() as disable_hook(self)
245
checker: subprocess.Popen(); a running checker process used
246
to see if the client lives.
247
'None' if no process is running.
174
secret: bytestring; sent verbatim (over TLS) to client
175
host: string; available for use by the checker command
176
created: datetime.datetime(); object creation, not client host
177
last_checked_ok: datetime.datetime() or None if not yet checked OK
178
timeout: datetime.timedelta(); How long from last_checked_ok
179
until this client is invalid
180
interval: datetime.timedelta(); How often to start a new checker
181
stop_hook: If set, called by stop() as stop_hook(self)
182
checker: subprocess.Popen(); a running checker process used
183
to see if the client lives.
184
'None' if no process is running.
248
185
checker_initiator_tag: a gobject event source tag, or None
249
disable_initiator_tag: - '' -
186
stop_initiator_tag: - '' -
250
187
checker_callback_tag: - '' -
251
188
checker_command: string; External command which is run to check if
252
189
client lives. %() expansions are done at
253
190
runtime with vars(self) as dict, so that for
254
191
instance %(name)s can be used in the command.
255
current_checker_command: string; current running checker_command
192
Private attibutes:
193
_timeout: Real variable for 'timeout'
194
_interval: Real variable for 'interval'
195
_timeout_milliseconds: Used when calling gobject.timeout_add()
196
_interval_milliseconds: - '' -
256
197
"""
257
258
@staticmethod
259
def _datetime_to_milliseconds(dt):
260
"Convert a datetime.datetime() to milliseconds"
261
return ((dt.days * 24 * 60 * 60 * 1000)
262
+ (dt.seconds * 1000)
263
+ (dt.microseconds // 1000))
264
265
def timeout_milliseconds(self):
266
"Return the 'timeout' attribute in milliseconds"
267
return self._datetime_to_milliseconds(self.timeout)
268
269
def interval_milliseconds(self):
270
"Return the 'interval' attribute in milliseconds"
271
return self._datetime_to_milliseconds(self.interval)
272
273
def __init__(self, name = None, disable_hook=None, config=None):
198
def _set_timeout(self, timeout):
199
"Setter function for 'timeout' attribute"
200
self._timeout = timeout
201
self._timeout_milliseconds = ((self.timeout.days
202
* 24 * 60 * 60 * 1000)
203
+ (self.timeout.seconds * 1000)
204
+ (self.timeout.microseconds
205
// 1000))
206
timeout = property(lambda self: self._timeout,
207
_set_timeout)
208
del _set_timeout
209
def _set_interval(self, interval):
210
"Setter function for 'interval' attribute"
211
self._interval = interval
212
self._interval_milliseconds = ((self.interval.days
213
* 24 * 60 * 60 * 1000)
214
+ (self.interval.seconds
215
* 1000)
216
+ (self.interval.microseconds
217
// 1000))
218
interval = property(lambda self: self._interval,
219
_set_interval)
220
del _set_interval
221
def __init__(self, name = None, stop_hook=None, config={}):
274
222
"""Note: the 'checker' key in 'config' sets the
275
223
'checker_command' attribute and *not* the 'checker'
276
224
attribute."""
277
225
self.name = name
278
if config is None:
279
config = {}
280
226
logger.debug(u"Creating client %r", self.name)
281
227
# Uppercase and remove spaces from fingerprint for later
282
228
# comparison purposes with return value from the fingerprint()
283
229
# function
284
self.fingerprint = (config[u"fingerprint"].upper()
285
.replace(u" ", u""))
230
self.fingerprint = config["fingerprint"].upper()\
231
.replace(u" ", u"")
286
232
logger.debug(u" Fingerprint: %s", self.fingerprint)
287
if u"secret" in config:
288
self.secret = config[u"secret"].decode(u"base64")
289
elif u"secfile" in config:
290
with closing(open(os.path.expanduser
291
(os.path.expandvars
292
(config[u"secfile"])))) as secfile:
293
self.secret = secfile.read()
233
if "secret" in config:
234
self.secret = config["secret"].decode(u"base64")
235
elif "secfile" in config:
236
sf = open(config["secfile"])
237
self.secret = sf.read()
238
sf.close()
294
239
else:
295
240
raise TypeError(u"No secret or secfile for client %s"
296
241
% self.name)
297
self.host = config.get(u"host", u"")
298
self.created = datetime.datetime.utcnow()
299
self.enabled = False
300
self.last_enabled = None
242
self.host = config.get("host", "")
243
self.created = datetime.datetime.now()
301
244
self.last_checked_ok = None
302
self.timeout = string_to_delta(config[u"timeout"])
303
self.interval = string_to_delta(config[u"interval"])
304
self.disable_hook = disable_hook
245
self.timeout = string_to_delta(config["timeout"])
246
self.interval = string_to_delta(config["interval"])
247
self.stop_hook = stop_hook
305
248
self.checker = None
306
249
self.checker_initiator_tag = None
307
self.disable_initiator_tag = None
250
self.stop_initiator_tag = None
308
251
self.checker_callback_tag = None
309
self.checker_command = config[u"checker"]
310
self.current_checker_command = None
311
self.last_connect = None
312
313
def enable(self):
252
self.check_command = config["checker"]
253
def start(self):
314
254
"""Start this client's checker and timeout hooks"""
315
self.last_enabled = datetime.datetime.utcnow()
316
255
# Schedule a new checker to be started an 'interval' from now,
317
256
# and every interval from then on.
318
self.checker_initiator_tag = (gobject.timeout_add
319
(self.interval_milliseconds(),
320
self.start_checker))
257
self.checker_initiator_tag = gobject.timeout_add\
258
(self._interval_milliseconds,
259
self.start_checker)
321
260
# Also start a new checker *right now*.
322
261
self.start_checker()
323
# Schedule a disable() when 'timeout' has passed
324
self.disable_initiator_tag = (gobject.timeout_add
325
(self.timeout_milliseconds(),
326
self.disable))
327
self.enabled = True
328
329
def disable(self):
330
"""Disable this client."""
331
if not getattr(self, "enabled", False):
262
# Schedule a stop() when 'timeout' has passed
263
self.stop_initiator_tag = gobject.timeout_add\
264
(self._timeout_milliseconds,
265
self.stop)
266
def stop(self):
267
"""Stop this client.
268
The possibility that a client might be restarted is left open,
269
but not currently used."""
270
# If this client doesn't have a secret, it is already stopped.
271
if hasattr(self, "secret") and self.secret:
272
logger.info(u"Stopping client %s", self.name)
273
self.secret = None
274
else:
332
275
return False
333
logger.info(u"Disabling client %s", self.name)
334
if getattr(self, u"disable_initiator_tag", False):
335
gobject.source_remove(self.disable_initiator_tag)
336
self.disable_initiator_tag = None
337
if getattr(self, u"checker_initiator_tag", False):
276
if getattr(self, "stop_initiator_tag", False):
277
gobject.source_remove(self.stop_initiator_tag)
278
self.stop_initiator_tag = None
279
if getattr(self, "checker_initiator_tag", False):
338
280
gobject.source_remove(self.checker_initiator_tag)
339
281
self.checker_initiator_tag = None
340
282
self.stop_checker()
341
if self.disable_hook:
342
self.disable_hook(self)
343
self.enabled = False
283
if self.stop_hook:
284
self.stop_hook(self)
344
285
# Do not run this again if called by a gobject.timeout_add
345
286
return False
346
347
287
def __del__(self):
348
self.disable_hook = None
349
self.disable()
350
351
def checker_callback(self, pid, condition, command):
288
self.stop_hook = None
289
self.stop()
290
def checker_callback(self, pid, condition):
352
291
"""The checker has completed, so take appropriate actions."""
292
now = datetime.datetime.now()
353
293
self.checker_callback_tag = None
354
294
self.checker = None
355
if os.WIFEXITED(condition):
356
exitstatus = os.WEXITSTATUS(condition)
357
if exitstatus == 0:
358
logger.info(u"Checker for %(name)s succeeded",
359
vars(self))
360
self.checked_ok()
361
else:
362
logger.info(u"Checker for %(name)s failed",
363
vars(self))
364
else:
295
if os.WIFEXITED(condition) \
296
and (os.WEXITSTATUS(condition) == 0):
297
logger.info(u"Checker for %(name)s succeeded",
298
vars(self))
299
self.last_checked_ok = now
300
gobject.source_remove(self.stop_initiator_tag)
301
self.stop_initiator_tag = gobject.timeout_add\
302
(self._timeout_milliseconds,
303
self.stop)
304
elif not os.WIFEXITED(condition):
365
305
logger.warning(u"Checker for %(name)s crashed?",
366
306
vars(self))
367
368
def checked_ok(self):
369
"""Bump up the timeout for this client.
370
371
This should only be called when the client has been seen,
372
alive and well.
373
"""
374
self.last_checked_ok = datetime.datetime.utcnow()
375
gobject.source_remove(self.disable_initiator_tag)
376
self.disable_initiator_tag = (gobject.timeout_add
377
(self.timeout_milliseconds(),
378
self.disable))
379
307
else:
308
logger.info(u"Checker for %(name)s failed",
309
vars(self))
380
310
def start_checker(self):
381
311
"""Start a new checker subprocess if one is not running.
382
383
312
If a checker already exists, leave it running and do
384
313
nothing."""
385
314
# The reason for not killing a running checker is that if we
390
319
# checkers alone, the checker would have to take more time
391
320
# than 'timeout' for the client to be declared invalid, which
392
321
# is as it should be.
393
394
# If a checker exists, make sure it is not a zombie
395
if self.checker is not None:
396
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
397
if pid:
398
logger.warning(u"Checker was a zombie")
399
gobject.source_remove(self.checker_callback_tag)
400
self.checker_callback(pid, status,
401
self.current_checker_command)
402
# Start a new checker if needed
403
322
if self.checker is None:
404
323
try:
405
# In case checker_command has exactly one % operator
406
command = self.checker_command % self.host
324
# In case check_command has exactly one % operator
325
command = self.check_command % self.host
407
326
except TypeError:
408
327
# Escape attributes for the shell
409
escaped_attrs = dict((key,
410
re.escape(unicode(str(val),
411
errors=
412
u'replace')))
328
escaped_attrs = dict((key, re.escape(str(val)))
413
329
for key, val in
414
330
vars(self).iteritems())
415
331
try:
416
command = self.checker_command % escaped_attrs
332
command = self.check_command % escaped_attrs
417
333
except TypeError, error:
418
334
logger.error(u'Could not format string "%s":'
419
u' %s', self.checker_command, error)
335
u' %s', self.check_command, error)
420
336
return True # Try again later
421
self.current_checker_command = command
422
337
try:
423
338
logger.info(u"Starting checker %r for %s",
424
339
command, self.name)
425
# We don't need to redirect stdout and stderr, since
426
# in normal mode, that is already done by daemon(),
427
# and in debug mode we don't want to. (Stdin is
428
# always replaced by /dev/null.)
429
340
self.checker = subprocess.Popen(command,
430
341
close_fds=True,
431
shell=True, cwd=u"/")
432
self.checker_callback_tag = (gobject.child_watch_add
433
(self.checker.pid,
434
self.checker_callback,
435
data=command))
436
# The checker may have completed before the gobject
437
# watch was added. Check for this.
438
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
439
if pid:
440
gobject.source_remove(self.checker_callback_tag)
441
self.checker_callback(pid, status, command)
442
except OSError, error:
342
shell=True, cwd="/")
343
self.checker_callback_tag = gobject.child_watch_add\
344
(self.checker.pid,
345
self.checker_callback)
346
except subprocess.OSError, error:
443
347
logger.error(u"Failed to start subprocess: %s",
444
348
error)
445
349
# Re-run this periodically if run by gobject.timeout_add
446
350
return True
447
448
351
def stop_checker(self):
449
352
"""Force the checker process, if any, to stop."""
450
353
if self.checker_callback_tag:
451
354
gobject.source_remove(self.checker_callback_tag)
452
355
self.checker_callback_tag = None
453
if getattr(self, u"checker", None) is None:
356
if getattr(self, "checker", None) is None:
454
357
return
455
358
logger.debug(u"Stopping checker for %(name)s", vars(self))
456
359
try:
462
365
if error.errno != errno.ESRCH: # No such process
463
366
raise
464
367
self.checker = None
465
466
368
def still_valid(self):
467
369
"""Has the timeout not yet passed for this client?"""
468
if not getattr(self, u"enabled", False):
469
return False
470
now = datetime.datetime.utcnow()
370
now = datetime.datetime.now()
471
371
if self.last_checked_ok is None:
472
372
return now < (self.created + self.timeout)
473
373
else:
474
374
return now < (self.last_checked_ok + self.timeout)
475
375
476
376
477
class ClientDBus(Client, dbus.service.Object):
478
"""A Client class using D-Bus
479
480
Attributes:
481
dbus_object_path: dbus.ObjectPath
482
bus: dbus.SystemBus()
483
"""
484
# dbus.service.Object doesn't use super(), so we can't either.
485
486
def __init__(self, bus = None, *args, **kwargs):
487
self.bus = bus
488
Client.__init__(self, *args, **kwargs)
489
# Only now, when this client is initialized, can it show up on
490
# the D-Bus
491
self.dbus_object_path = (dbus.ObjectPath
492
(u"/clients/"
493
+ self.name.replace(u".", u"_")))
494
dbus.service.Object.__init__(self, self.bus,
495
self.dbus_object_path)
496
497
@staticmethod
498
def _datetime_to_dbus(dt, variant_level=0):
499
"""Convert a UTC datetime.datetime() to a D-Bus type."""
500
return dbus.String(dt.isoformat(),
501
variant_level=variant_level)
502
503
def enable(self):
504
oldstate = getattr(self, u"enabled", False)
505
r = Client.enable(self)
506
if oldstate != self.enabled:
507
# Emit D-Bus signals
508
self.PropertyChanged(dbus.String(u"enabled"),
509
dbus.Boolean(True, variant_level=1))
510
self.PropertyChanged(
511
dbus.String(u"last_enabled"),
512
self._datetime_to_dbus(self.last_enabled,
513
variant_level=1))
514
return r
515
516
def disable(self, signal = True):
517
oldstate = getattr(self, u"enabled", False)
518
r = Client.disable(self)
519
if signal and oldstate != self.enabled:
520
# Emit D-Bus signal
521
self.PropertyChanged(dbus.String(u"enabled"),
522
dbus.Boolean(False, variant_level=1))
523
return r
524
525
def __del__(self, *args, **kwargs):
526
try:
527
self.remove_from_connection()
528
except LookupError:
529
pass
530
if hasattr(dbus.service.Object, u"__del__"):
531
dbus.service.Object.__del__(self, *args, **kwargs)
532
Client.__del__(self, *args, **kwargs)
533
534
def checker_callback(self, pid, condition, command,
535
*args, **kwargs):
536
self.checker_callback_tag = None
537
self.checker = None
538
# Emit D-Bus signal
539
self.PropertyChanged(dbus.String(u"checker_running"),
540
dbus.Boolean(False, variant_level=1))
541
if os.WIFEXITED(condition):
542
exitstatus = os.WEXITSTATUS(condition)
543
# Emit D-Bus signal
544
self.CheckerCompleted(dbus.Int16(exitstatus),
545
dbus.Int64(condition),
546
dbus.String(command))
547
else:
548
# Emit D-Bus signal
549
self.CheckerCompleted(dbus.Int16(-1),
550
dbus.Int64(condition),
551
dbus.String(command))
552
553
return Client.checker_callback(self, pid, condition, command,
554
*args, **kwargs)
555
556
def checked_ok(self, *args, **kwargs):
557
r = Client.checked_ok(self, *args, **kwargs)
558
# Emit D-Bus signal
559
self.PropertyChanged(
560
dbus.String(u"last_checked_ok"),
561
(self._datetime_to_dbus(self.last_checked_ok,
562
variant_level=1)))
563
return r
564
565
def start_checker(self, *args, **kwargs):
566
old_checker = self.checker
567
if self.checker is not None:
568
old_checker_pid = self.checker.pid
569
else:
570
old_checker_pid = None
571
r = Client.start_checker(self, *args, **kwargs)
572
# Only if new checker process was started
573
if (self.checker is not None
574
and old_checker_pid != self.checker.pid):
575
# Emit D-Bus signal
576
self.CheckerStarted(self.current_checker_command)
577
self.PropertyChanged(
578
dbus.String(u"checker_running"),
579
dbus.Boolean(True, variant_level=1))
580
return r
581
582
def stop_checker(self, *args, **kwargs):
583
old_checker = getattr(self, u"checker", None)
584
r = Client.stop_checker(self, *args, **kwargs)
585
if (old_checker is not None
586
and getattr(self, u"checker", None) is None):
587
self.PropertyChanged(dbus.String(u"checker_running"),
588
dbus.Boolean(False, variant_level=1))
589
return r
590
591
## D-Bus methods & signals
592
_interface = u"se.bsnet.fukt.Mandos.Client"
593
594
# CheckedOK - method
595
@dbus.service.method(_interface)
596
def CheckedOK(self):
597
return self.checked_ok()
598
599
# CheckerCompleted - signal
600
@dbus.service.signal(_interface, signature=u"nxs")
601
def CheckerCompleted(self, exitcode, waitstatus, command):
602
"D-Bus signal"
603
pass
604
605
# CheckerStarted - signal
606
@dbus.service.signal(_interface, signature=u"s")
607
def CheckerStarted(self, command):
608
"D-Bus signal"
609
pass
610
611
# GetAllProperties - method
612
@dbus.service.method(_interface, out_signature=u"a{sv}")
613
def GetAllProperties(self):
614
"D-Bus method"
615
return dbus.Dictionary({
616
dbus.String(u"name"):
617
dbus.String(self.name, variant_level=1),
618
dbus.String(u"fingerprint"):
619
dbus.String(self.fingerprint, variant_level=1),
620
dbus.String(u"host"):
621
dbus.String(self.host, variant_level=1),
622
dbus.String(u"created"):
623
self._datetime_to_dbus(self.created,
624
variant_level=1),
625
dbus.String(u"last_enabled"):
626
(self._datetime_to_dbus(self.last_enabled,
627
variant_level=1)
628
if self.last_enabled is not None
629
else dbus.Boolean(False, variant_level=1)),
630
dbus.String(u"enabled"):
631
dbus.Boolean(self.enabled, variant_level=1),
632
dbus.String(u"last_checked_ok"):
633
(self._datetime_to_dbus(self.last_checked_ok,
634
variant_level=1)
635
if self.last_checked_ok is not None
636
else dbus.Boolean (False, variant_level=1)),
637
dbus.String(u"timeout"):
638
dbus.UInt64(self.timeout_milliseconds(),
639
variant_level=1),
640
dbus.String(u"interval"):
641
dbus.UInt64(self.interval_milliseconds(),
642
variant_level=1),
643
dbus.String(u"checker"):
644
dbus.String(self.checker_command,
645
variant_level=1),
646
dbus.String(u"checker_running"):
647
dbus.Boolean(self.checker is not None,
648
variant_level=1),
649
dbus.String(u"object_path"):
650
dbus.ObjectPath(self.dbus_object_path,
651
variant_level=1)
652
}, signature=u"sv")
653
654
# IsStillValid - method
655
@dbus.service.method(_interface, out_signature=u"b")
656
def IsStillValid(self):
657
return self.still_valid()
658
659
# PropertyChanged - signal
660
@dbus.service.signal(_interface, signature=u"sv")
661
def PropertyChanged(self, property, value):
662
"D-Bus signal"
663
pass
664
665
# ReceivedSecret - signal
666
@dbus.service.signal(_interface)
667
def ReceivedSecret(self):
668
"D-Bus signal"
669
pass
670
671
# Rejected - signal
672
@dbus.service.signal(_interface)
673
def Rejected(self):
674
"D-Bus signal"
675
pass
676
677
# SetChecker - method
678
@dbus.service.method(_interface, in_signature=u"s")
679
def SetChecker(self, checker):
680
"D-Bus setter method"
681
self.checker_command = checker
682
# Emit D-Bus signal
683
self.PropertyChanged(dbus.String(u"checker"),
684
dbus.String(self.checker_command,
685
variant_level=1))
686
687
# SetHost - method
688
@dbus.service.method(_interface, in_signature=u"s")
689
def SetHost(self, host):
690
"D-Bus setter method"
691
self.host = host
692
# Emit D-Bus signal
693
self.PropertyChanged(dbus.String(u"host"),
694
dbus.String(self.host, variant_level=1))
695
696
# SetInterval - method
697
@dbus.service.method(_interface, in_signature=u"t")
698
def SetInterval(self, milliseconds):
699
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
700
# Emit D-Bus signal
701
self.PropertyChanged(dbus.String(u"interval"),
702
(dbus.UInt64(self.interval_milliseconds(),
703
variant_level=1)))
704
705
# SetSecret - method
706
@dbus.service.method(_interface, in_signature=u"ay",
707
byte_arrays=True)
708
def SetSecret(self, secret):
709
"D-Bus setter method"
710
self.secret = str(secret)
711
712
# SetTimeout - method
713
@dbus.service.method(_interface, in_signature=u"t")
714
def SetTimeout(self, milliseconds):
715
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
716
# Emit D-Bus signal
717
self.PropertyChanged(dbus.String(u"timeout"),
718
(dbus.UInt64(self.timeout_milliseconds(),
719
variant_level=1)))
720
721
# Enable - method
722
@dbus.service.method(_interface)
723
def Enable(self):
724
"D-Bus method"
725
self.enable()
726
727
# StartChecker - method
728
@dbus.service.method(_interface)
729
def StartChecker(self):
730
"D-Bus method"
731
self.start_checker()
732
733
# Disable - method
734
@dbus.service.method(_interface)
735
def Disable(self):
736
"D-Bus method"
737
self.disable()
738
739
# StopChecker - method
740
@dbus.service.method(_interface)
741
def StopChecker(self):
742
self.stop_checker()
743
744
del _interface
745
746
747
class ClientHandler(socketserver.BaseRequestHandler, object):
748
"""A class to handle client connections.
749
750
Instantiated once for each connection to handle it.
377
def peer_certificate(session):
378
"Return the peer's OpenPGP certificate as a bytestring"
379
# If not an OpenPGP certificate...
380
if gnutls.library.functions.gnutls_certificate_type_get\
381
(session._c_object) \
382
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
383
# ...do the normal thing
384
return session.peer_certificate
385
list_size = ctypes.c_uint()
386
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
387
(session._c_object, ctypes.byref(list_size))
388
if list_size.value == 0:
389
return None
390
cert = cert_list[0]
391
return ctypes.string_at(cert.data, cert.size)
392
393
394
def fingerprint(openpgp):
395
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
396
# New GnuTLS "datum" with the OpenPGP public key
397
datum = gnutls.library.types.gnutls_datum_t\
398
(ctypes.cast(ctypes.c_char_p(openpgp),
399
ctypes.POINTER(ctypes.c_ubyte)),
400
ctypes.c_uint(len(openpgp)))
401
# New empty GnuTLS certificate
402
crt = gnutls.library.types.gnutls_openpgp_crt_t()
403
gnutls.library.functions.gnutls_openpgp_crt_init\
404
(ctypes.byref(crt))
405
# Import the OpenPGP public key into the certificate
406
gnutls.library.functions.gnutls_openpgp_crt_import\
407
(crt, ctypes.byref(datum),
408
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
409
# New buffer for the fingerprint
410
buffer = ctypes.create_string_buffer(20)
411
buffer_length = ctypes.c_size_t()
412
# Get the fingerprint from the certificate into the buffer
413
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
414
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
415
# Deinit the certificate
416
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
417
# Convert the buffer to a Python bytestring
418
fpr = ctypes.string_at(buffer, buffer_length.value)
419
# Convert the bytestring to hexadecimal notation
420
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
421
return hex_fpr
422
423
424
class tcp_handler(SocketServer.BaseRequestHandler, object):
425
"""A TCP request handler class.
426
Instantiated by IPv6_TCPServer for each request to handle it.
751
427
Note: This will run in its own forked process."""
752
428
753
429
def handle(self):
754
430
logger.info(u"TCP connection from: %s",
755
unicode(self.client_address))
756
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
757
# Open IPC pipe to parent process
758
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
759
session = (gnutls.connection
760
.ClientSession(self.request,
761
gnutls.connection
762
.X509Credentials()))
763
764
line = self.request.makefile().readline()
765
logger.debug(u"Protocol version: %r", line)
766
try:
767
if int(line.strip().split()[0]) > 1:
768
raise RuntimeError
769
except (ValueError, IndexError, RuntimeError), error:
770
logger.error(u"Unknown protocol version: %s", error)
771
return
772
773
# Note: gnutls.connection.X509Credentials is really a
774
# generic GnuTLS certificate credentials object so long as
775
# no X.509 keys are added to it. Therefore, we can use it
776
# here despite using OpenPGP certificates.
777
778
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
779
# u"+AES-256-CBC", u"+SHA1",
780
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
781
# u"+DHE-DSS"))
782
# Use a fallback default, since this MUST be set.
783
priority = self.server.gnutls_priority
784
if priority is None:
785
priority = u"NORMAL"
786
(gnutls.library.functions
787
.gnutls_priority_set_direct(session._c_object,
788
priority, None))
789
790
try:
791
session.handshake()
792
except gnutls.errors.GNUTLSError, error:
793
logger.warning(u"Handshake failed: %s", error)
794
# Do not run session.bye() here: the session is not
795
# established. Just abandon the request.
796
return
797
logger.debug(u"Handshake succeeded")
798
try:
799
fpr = self.fingerprint(self.peer_certificate(session))
800
except (TypeError, gnutls.errors.GNUTLSError), error:
801
logger.warning(u"Bad certificate: %s", error)
802
session.bye()
803
return
804
logger.debug(u"Fingerprint: %s", fpr)
805
806
for c in self.server.clients:
807
if c.fingerprint == fpr:
808
client = c
809
break
810
else:
811
ipc.write(u"NOTFOUND %s\n" % fpr)
812
session.bye()
813
return
814
# Have to check if client.still_valid(), since it is
815
# possible that the client timed out while establishing
816
# the GnuTLS session.
817
if not client.still_valid():
818
ipc.write(u"INVALID %s\n" % client.name)
819
session.bye()
820
return
821
ipc.write(u"SENDING %s\n" % client.name)
822
sent_size = 0
823
while sent_size < len(client.secret):
824
sent = session.send(client.secret[sent_size:])
825
logger.debug(u"Sent: %d, remaining: %d",
826
sent, len(client.secret)
827
- (sent_size + sent))
828
sent_size += sent
829
session.bye()
830
831
@staticmethod
832
def peer_certificate(session):
833
"Return the peer's OpenPGP certificate as a bytestring"
834
# If not an OpenPGP certificate...
835
if (gnutls.library.functions
836
.gnutls_certificate_type_get(session._c_object)
837
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
838
# ...do the normal thing
839
return session.peer_certificate
840
list_size = ctypes.c_uint(1)
841
cert_list = (gnutls.library.functions
842
.gnutls_certificate_get_peers
843
(session._c_object, ctypes.byref(list_size)))
844
if not bool(cert_list) and list_size.value != 0:
845
raise gnutls.errors.GNUTLSError(u"error getting peer"
846
u" certificate")
847
if list_size.value == 0:
848
return None
849
cert = cert_list[0]
850
return ctypes.string_at(cert.data, cert.size)
851
852
@staticmethod
853
def fingerprint(openpgp):
854
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
855
# New GnuTLS "datum" with the OpenPGP public key
856
datum = (gnutls.library.types
857
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
858
ctypes.POINTER
859
(ctypes.c_ubyte)),
860
ctypes.c_uint(len(openpgp))))
861
# New empty GnuTLS certificate
862
crt = gnutls.library.types.gnutls_openpgp_crt_t()
863
(gnutls.library.functions
864
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
865
# Import the OpenPGP public key into the certificate
866
(gnutls.library.functions
867
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
868
gnutls.library.constants
869
.GNUTLS_OPENPGP_FMT_RAW))
870
# Verify the self signature in the key
871
crtverify = ctypes.c_uint()
872
(gnutls.library.functions
873
.gnutls_openpgp_crt_verify_self(crt, 0,
874
ctypes.byref(crtverify)))
875
if crtverify.value != 0:
876
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
877
raise (gnutls.errors.CertificateSecurityError
878
(u"Verify failed"))
879
# New buffer for the fingerprint
880
buf = ctypes.create_string_buffer(20)
881
buf_len = ctypes.c_size_t()
882
# Get the fingerprint from the certificate into the buffer
883
(gnutls.library.functions
884
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
885
ctypes.byref(buf_len)))
886
# Deinit the certificate
887
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
888
# Convert the buffer to a Python bytestring
889
fpr = ctypes.string_at(buf, buf_len.value)
890
# Convert the bytestring to hexadecimal notation
891
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
892
return hex_fpr
893
894
895
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
896
"""Like socketserver.ForkingMixIn, but also pass a pipe."""
897
def process_request(self, request, client_address):
898
"""Overrides and wraps the original process_request().
899
900
This function creates a new pipe in self.pipe
901
"""
902
self.pipe = os.pipe()
903
super(ForkingMixInWithPipe,
904
self).process_request(request, client_address)
905
os.close(self.pipe[1]) # close write end
906
self.add_pipe(self.pipe[0])
907
def add_pipe(self, pipe):
908
"""Dummy function; override as necessary"""
909
os.close(pipe)
910
911
912
class IPv6_TCPServer(ForkingMixInWithPipe,
913
socketserver.TCPServer, object):
914
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
915
431
unicode(self.client_address))
432
session = gnutls.connection.ClientSession\
433
(self.request, gnutls.connection.X509Credentials())
434
435
line = self.request.makefile().readline()
436
logger.debug(u"Protocol version: %r", line)
437
try:
438
if int(line.strip().split()[0]) > 1:
439
raise RuntimeError
440
except (ValueError, IndexError, RuntimeError), error:
441
logger.error(u"Unknown protocol version: %s", error)
442
return
443
444
# Note: gnutls.connection.X509Credentials is really a generic
445
# GnuTLS certificate credentials object so long as no X.509
446
# keys are added to it. Therefore, we can use it here despite
447
# using OpenPGP certificates.
448
449
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
450
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
451
# "+DHE-DSS"))
452
priority = "NORMAL" # Fallback default, since this
453
# MUST be set.
454
if self.server.settings["priority"]:
455
priority = self.server.settings["priority"]
456
gnutls.library.functions.gnutls_priority_set_direct\
457
(session._c_object, priority, None);
458
459
try:
460
session.handshake()
461
except gnutls.errors.GNUTLSError, error:
462
logger.warning(u"Handshake failed: %s", error)
463
# Do not run session.bye() here: the session is not
464
# established. Just abandon the request.
465
return
466
try:
467
fpr = fingerprint(peer_certificate(session))
468
except (TypeError, gnutls.errors.GNUTLSError), error:
469
logger.warning(u"Bad certificate: %s", error)
470
session.bye()
471
return
472
logger.debug(u"Fingerprint: %s", fpr)
473
client = None
474
for c in self.server.clients:
475
if c.fingerprint == fpr:
476
client = c
477
break
478
if not client:
479
logger.warning(u"Client not found for fingerprint: %s",
480
fpr)
481
session.bye()
482
return
483
# Have to check if client.still_valid(), since it is possible
484
# that the client timed out while establishing the GnuTLS
485
# session.
486
if not client.still_valid():
487
logger.warning(u"Client %(name)s is invalid",
488
vars(client))
489
session.bye()
490
return
491
sent_size = 0
492
while sent_size < len(client.secret):
493
sent = session.send(client.secret[sent_size:])
494
logger.debug(u"Sent: %d, remaining: %d",
495
sent, len(client.secret)
496
- (sent_size + sent))
497
sent_size += sent
498
session.bye()
499
500
501
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
502
"""IPv6 TCP server. Accepts 'None' as address and/or port.
916
503
Attributes:
917
enabled: Boolean; whether this server is activated yet
918
interface: None or a network interface name (string)
919
use_ipv6: Boolean; to use IPv6 or not
504
settings: Server settings
505
clients: Set() of Client objects
920
506
"""
921
def __init__(self, server_address, RequestHandlerClass,
922
interface=None, use_ipv6=True):
923
self.interface = interface
924
if use_ipv6:
925
self.address_family = socket.AF_INET6
926
socketserver.TCPServer.__init__(self, server_address,
927
RequestHandlerClass)
507
address_family = socket.AF_INET6
508
def __init__(self, *args, **kwargs):
509
if "settings" in kwargs:
510
self.settings = kwargs["settings"]
511
del kwargs["settings"]
512
if "clients" in kwargs:
513
self.clients = kwargs["clients"]
514
del kwargs["clients"]
515
return super(type(self), self).__init__(*args, **kwargs)
928
516
def server_bind(self):
929
517
"""This overrides the normal server_bind() function
930
518
to bind to an interface if one was specified, and also NOT to
931
519
bind to an address or port if they were not specified."""
932
if self.interface is not None:
933
if SO_BINDTODEVICE is None:
934
logger.error(u"SO_BINDTODEVICE does not exist;"
935
u" cannot bind to interface %s",
936
self.interface)
937
else:
938
try:
939
self.socket.setsockopt(socket.SOL_SOCKET,
940
SO_BINDTODEVICE,
941
str(self.interface
942
+ u'\0'))
943
except socket.error, error:
944
if error[0] == errno.EPERM:
945
logger.error(u"No permission to"
946
u" bind to interface %s",
947
self.interface)
948
elif error[0] == errno.ENOPROTOOPT:
949
logger.error(u"SO_BINDTODEVICE not available;"
950
u" cannot bind to interface %s",
951
self.interface)
952
else:
953
raise
520
if self.settings["interface"]:
521
# 25 is from /usr/include/asm-i486/socket.h
522
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
523
try:
524
self.socket.setsockopt(socket.SOL_SOCKET,
525
SO_BINDTODEVICE,
526
self.settings["interface"])
527
except socket.error, error:
528
if error[0] == errno.EPERM:
529
logger.error(u"No permission to"
530
u" bind to interface %s",
531
self.settings["interface"])
532
else:
533
raise error
954
534
# Only bind(2) the socket if we really need to.
955
535
if self.server_address[0] or self.server_address[1]:
956
536
if not self.server_address[0]:
957
if self.address_family == socket.AF_INET6:
958
any_address = u"::" # in6addr_any
959
else:
960
any_address = socket.INADDR_ANY
961
self.server_address = (any_address,
537
in6addr_any = "::"
538
self.server_address = (in6addr_any,
962
539
self.server_address[1])
963
540
elif not self.server_address[1]:
964
541
self.server_address = (self.server_address[0],
965
542
0)
966
# if self.interface:
543
# if self.settings["interface"]:
967
544
# self.server_address = (self.server_address[0],
968
545
# 0, # port
969
546
# 0, # flowinfo
970
547
# if_nametoindex
971
# (self.interface))
972
return socketserver.TCPServer.server_bind(self)
973
974
975
class MandosServer(IPv6_TCPServer):
976
"""Mandos server.
977
978
Attributes:
979
clients: set of Client objects
980
gnutls_priority GnuTLS priority string
981
use_dbus: Boolean; to emit D-Bus signals or not
982
clients: set of Client objects
983
gnutls_priority GnuTLS priority string
984
use_dbus: Boolean; to emit D-Bus signals or not
985
986
Assumes a gobject.MainLoop event loop.
987
"""
988
def __init__(self, server_address, RequestHandlerClass,
989
interface=None, use_ipv6=True, clients=None,
990
gnutls_priority=None, use_dbus=True):
991
self.enabled = False
992
self.clients = clients
993
self.use_dbus = use_dbus
994
self.gnutls_priority = gnutls_priority
995
IPv6_TCPServer.__init__(self, server_address,
996
RequestHandlerClass,
997
interface = interface,
998
use_ipv6 = use_ipv6)
999
def server_activate(self):
1000
if self.enabled:
1001
return socketserver.TCPServer.server_activate(self)
1002
def enable(self):
1003
self.enabled = True
1004
def add_pipe(self, pipe):
1005
# Call "handle_ipc" for both data and EOF events
1006
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1007
self.handle_ipc)
1008
def handle_ipc(self, source, condition, file_objects={}):
1009
condition_names = {
1010
gobject.IO_IN: u"IN", # There is data to read.
1011
gobject.IO_OUT: u"OUT", # Data can be written (without
1012
# blocking).
1013
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1014
gobject.IO_ERR: u"ERR", # Error condition.
1015
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1016
# broken, usually for pipes and
1017
# sockets).
1018
}
1019
conditions_string = ' | '.join(name
1020
for cond, name in
1021
condition_names.iteritems()
1022
if cond & condition)
1023
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1024
conditions_string)
1025
1026
# Turn the pipe file descriptor into a Python file object
1027
if source not in file_objects:
1028
file_objects[source] = os.fdopen(source, u"r", 1)
1029
1030
# Read a line from the file object
1031
cmdline = file_objects[source].readline()
1032
if not cmdline: # Empty line means end of file
1033
# close the IPC pipe
1034
file_objects[source].close()
1035
del file_objects[source]
1036
1037
# Stop calling this function
1038
return False
1039
1040
logger.debug(u"IPC command: %r", cmdline)
1041
1042
# Parse and act on command
1043
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1044
1045
if cmd == u"NOTFOUND":
1046
logger.warning(u"Client not found for fingerprint: %s",
1047
args)
1048
if self.use_dbus:
1049
# Emit D-Bus signal
1050
mandos_dbus_service.ClientNotFound(args)
1051
elif cmd == u"INVALID":
1052
for client in self.clients:
1053
if client.name == args:
1054
logger.warning(u"Client %s is invalid", args)
1055
if self.use_dbus:
1056
# Emit D-Bus signal
1057
client.Rejected()
1058
break
1059
else:
1060
logger.error(u"Unknown client %s is invalid", args)
1061
elif cmd == u"SENDING":
1062
for client in self.clients:
1063
if client.name == args:
1064
logger.info(u"Sending secret to %s", client.name)
1065
client.checked_ok()
1066
if self.use_dbus:
1067
# Emit D-Bus signal
1068
client.ReceivedSecret()
1069
break
1070
else:
1071
logger.error(u"Sending secret to unknown client %s",
1072
args)
1073
else:
1074
logger.error(u"Unknown IPC command: %r", cmdline)
1075
1076
# Keep calling this function
1077
return True
548
# (self.settings
549
# ["interface"]))
550
return super(type(self), self).server_bind()
1078
551
1079
552
1080
553
def string_to_delta(interval):
1081
554
"""Parse a string and return a datetime.timedelta
1082
1083
>>> string_to_delta(u'7d')
555
556
>>> string_to_delta('7d')
1084
557
datetime.timedelta(7)
1085
>>> string_to_delta(u'60s')
558
>>> string_to_delta('60s')
1086
559
datetime.timedelta(0, 60)
1087
>>> string_to_delta(u'60m')
560
>>> string_to_delta('60m')
1088
561
datetime.timedelta(0, 3600)
1089
>>> string_to_delta(u'24h')
562
>>> string_to_delta('24h')
1090
563
datetime.timedelta(1)
1091
564
>>> string_to_delta(u'1w')
1092
565
datetime.timedelta(7)
1093
>>> string_to_delta(u'5m 30s')
1094
datetime.timedelta(0, 330)
1095
566
"""
1096
timevalue = datetime.timedelta(0)
1097
for s in interval.split():
1098
try:
1099
suffix = unicode(s[-1])
1100
value = int(s[:-1])
1101
if suffix == u"d":
1102
delta = datetime.timedelta(value)
1103
elif suffix == u"s":
1104
delta = datetime.timedelta(0, value)
1105
elif suffix == u"m":
1106
delta = datetime.timedelta(0, 0, 0, 0, value)
1107
elif suffix == u"h":
1108
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1109
elif suffix == u"w":
1110
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1111
else:
1112
raise ValueError
1113
except (ValueError, IndexError):
567
try:
568
suffix=unicode(interval[-1])
569
value=int(interval[:-1])
570
if suffix == u"d":
571
delta = datetime.timedelta(value)
572
elif suffix == u"s":
573
delta = datetime.timedelta(0, value)
574
elif suffix == u"m":
575
delta = datetime.timedelta(0, 0, 0, 0, value)
576
elif suffix == u"h":
577
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
578
elif suffix == u"w":
579
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
580
else:
1114
581
raise ValueError
1115
timevalue += delta
1116
return timevalue
1117
582
except (ValueError, IndexError):
583
raise ValueError
584
return delta
585
586
587
def server_state_changed(state):
588
"""Derived from the Avahi example code"""
589
if state == avahi.SERVER_COLLISION:
590
logger.error(u"Server name collision")
591
service.remove()
592
elif state == avahi.SERVER_RUNNING:
593
service.add()
594
595
596
def entry_group_state_changed(state, error):
597
"""Derived from the Avahi example code"""
598
logger.debug(u"state change: %i", state)
599
600
if state == avahi.ENTRY_GROUP_ESTABLISHED:
601
logger.debug(u"Service established.")
602
elif state == avahi.ENTRY_GROUP_COLLISION:
603
logger.warning(u"Service name collision.")
604
service.rename()
605
elif state == avahi.ENTRY_GROUP_FAILURE:
606
logger.critical(u"Error in group state changed %s",
607
unicode(error))
608
raise AvahiGroupError("State changed: %s", str(error))
1118
609
1119
610
def if_nametoindex(interface):
1120
"""Call the C function if_nametoindex(), or equivalent
1121
1122
Note: This function cannot accept a unicode string."""
611
"""Call the C function if_nametoindex(), or equivalent"""
1123
612
global if_nametoindex
1124
613
try:
1125
if_nametoindex = (ctypes.cdll.LoadLibrary
1126
(ctypes.util.find_library(u"c"))
1127
.if_nametoindex)
614
if "ctypes.util" not in sys.modules:
615
import ctypes.util
616
if_nametoindex = ctypes.cdll.LoadLibrary\
617
(ctypes.util.find_library("c")).if_nametoindex
1128
618
except (OSError, AttributeError):
1129
logger.warning(u"Doing if_nametoindex the hard way")
619
if "struct" not in sys.modules:
620
import struct
621
if "fcntl" not in sys.modules:
622
import fcntl
1130
623
def if_nametoindex(interface):
1131
624
"Get an interface index the hard way, i.e. using fcntl()"
1132
625
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1133
with closing(socket.socket()) as s:
1134
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1135
struct.pack(str(u"16s16x"),
1136
interface))
1137
interface_index = struct.unpack(str(u"I"),
1138
ifreq[16:20])[0]
626
s = socket.socket()
627
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
628
struct.pack("16s16x", interface))
629
s.close()
630
interface_index = struct.unpack("I", ifreq[16:20])[0]
1139
631
return interface_index
1140
632
return if_nametoindex(interface)
1141
633
1142
634
1143
635
def daemon(nochdir = False, noclose = False):
1144
636
"""See daemon(3). Standard BSD Unix function.
1145
1146
637
This should really exist as os.daemon, but it doesn't (yet)."""
1147
638
if os.fork():
1148
639
sys.exit()
1149
640
os.setsid()
1150
641
if not nochdir:
1151
os.chdir(u"/")
642
os.chdir("/")
1152
643
if os.fork():
1153
644
sys.exit()
1154
645
if not noclose:
1156
647
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1157
648
if not stat.S_ISCHR(os.fstat(null).st_mode):
1158
649
raise OSError(errno.ENODEV,
1159
u"/dev/null not a character device")
650
"/dev/null not a character device")
1160
651
os.dup2(null, sys.stdin.fileno())
1161
652
os.dup2(null, sys.stdout.fileno())
1162
653
os.dup2(null, sys.stderr.fileno())
1165
656
1166
657
1167
658
def main():
1168
1169
######################################################################
1170
# Parsing of options, both command line and config file
1171
1172
parser = optparse.OptionParser(version = "%%prog %s" % version)
1173
parser.add_option("-i", u"--interface", type=u"string",
1174
metavar="IF", help=u"Bind to interface IF")
1175
parser.add_option("-a", u"--address", type=u"string",
1176
help=u"Address to listen for requests on")
1177
parser.add_option("-p", u"--port", type=u"int",
1178
help=u"Port number to receive requests on")
1179
parser.add_option("--check", action=u"store_true",
1180
help=u"Run self-test")
1181
parser.add_option("--debug", action=u"store_true",
1182
help=u"Debug mode; run in foreground and log to"
1183
u" terminal")
1184
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1185
u" priority string (see GnuTLS documentation)")
1186
parser.add_option("--servicename", type=u"string",
1187
metavar=u"NAME", help=u"Zeroconf service name")
1188
parser.add_option("--configdir", type=u"string",
1189
default=u"/etc/mandos", metavar=u"DIR",
1190
help=u"Directory to search for configuration"
1191
u" files")
1192
parser.add_option("--no-dbus", action=u"store_false",
1193
dest=u"use_dbus", help=u"Do not provide D-Bus"
1194
u" system bus interface")
1195
parser.add_option("--no-ipv6", action=u"store_false",
1196
dest=u"use_ipv6", help=u"Do not use IPv6")
1197
options = parser.parse_args()[0]
659
global main_loop_started
660
main_loop_started = False
661
662
parser = OptionParser(version = "%%prog %s" % version)
663
parser.add_option("-i", "--interface", type="string",
664
metavar="IF", help="Bind to interface IF")
665
parser.add_option("-a", "--address", type="string",
666
help="Address to listen for requests on")
667
parser.add_option("-p", "--port", type="int",
668
help="Port number to receive requests on")
669
parser.add_option("--check", action="store_true", default=False,
670
help="Run self-test")
671
parser.add_option("--debug", action="store_true",
672
help="Debug mode; run in foreground and log to"
673
" terminal")
674
parser.add_option("--priority", type="string", help="GnuTLS"
675
" priority string (see GnuTLS documentation)")
676
parser.add_option("--servicename", type="string", metavar="NAME",
677
help="Zeroconf service name")
678
parser.add_option("--configdir", type="string",
679
default="/etc/mandos", metavar="DIR",
680
help="Directory to search for configuration"
681
" files")
682
(options, args) = parser.parse_args()
1198
683
1199
684
if options.check:
1200
685
import doctest
1202
687
sys.exit()
1203
688
1204
689
# Default values for config file for server-global settings
1205
server_defaults = { u"interface": u"",
1206
u"address": u"",
1207
u"port": u"",
1208
u"debug": u"False",
1209
u"priority":
1210
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1211
u"servicename": u"Mandos",
1212
u"use_dbus": u"True",
1213
u"use_ipv6": u"True",
690
server_defaults = { "interface": "",
691
"address": "",
692
"port": "",
693
"debug": "False",
694
"priority":
695
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
696
"servicename": "Mandos",
1214
697
}
1215
698
1216
699
# Parse config file for server-global settings
1217
server_config = configparser.SafeConfigParser(server_defaults)
700
server_config = ConfigParser.SafeConfigParser(server_defaults)
1218
701
del server_defaults
1219
server_config.read(os.path.join(options.configdir,
1220
u"mandos.conf"))
702
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1221
703
# Convert the SafeConfigParser object to a dict
1222
704
server_settings = server_config.defaults()
1223
# Use the appropriate methods on the non-string config options
1224
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1225
server_settings[option] = server_config.getboolean(u"DEFAULT",
1226
option)
1227
if server_settings["port"]:
1228
server_settings["port"] = server_config.getint(u"DEFAULT",
1229
u"port")
705
# Use getboolean on the boolean config option
706
server_settings["debug"] = server_config.getboolean\
707
("DEFAULT", "debug")
1230
708
del server_config
1231
709
1232
710
# Override the settings from the config file with command line
1233
711
# options, if set.
1234
for option in (u"interface", u"address", u"port", u"debug",
1235
u"priority", u"servicename", u"configdir",
1236
u"use_dbus", u"use_ipv6"):
712
for option in ("interface", "address", "port", "debug",
713
"priority", "servicename", "configdir"):
1237
714
value = getattr(options, option)
1238
715
if value is not None:
1239
716
server_settings[option] = value
1240
717
del options
1241
# Force all strings to be unicode
1242
for option in server_settings.keys():
1243
if type(server_settings[option]) is str:
1244
server_settings[option] = unicode(server_settings[option])
1245
718
# Now we have our good server settings in "server_settings"
1246
719
1247
##################################################################
1248
1249
# For convenience
1250
debug = server_settings[u"debug"]
1251
use_dbus = server_settings[u"use_dbus"]
1252
use_ipv6 = server_settings[u"use_ipv6"]
720
debug = server_settings["debug"]
1253
721
1254
722
if not debug:
1255
723
syslogger.setLevel(logging.WARNING)
1256
724
console.setLevel(logging.WARNING)
1257
725
1258
if server_settings[u"servicename"] != u"Mandos":
1259
syslogger.setFormatter(logging.Formatter
1260
(u'Mandos (%s) [%%(process)d]:'
1261
u' %%(levelname)s: %%(message)s'
1262
% server_settings[u"servicename"]))
726
if server_settings["servicename"] != "Mandos":
727
syslogger.setFormatter(logging.Formatter\
728
('Mandos (%s): %%(levelname)s:'
729
' %%(message)s'
730
% server_settings["servicename"]))
1263
731
1264
732
# Parse config file with clients
1265
client_defaults = { u"timeout": u"1h",
1266
u"interval": u"5m",
1267
u"checker": u"fping -q -- %%(host)s",
1268
u"host": u"",
733
client_defaults = { "timeout": "1h",
734
"interval": "5m",
735
"checker": "fping -q -- %%(host)s",
1269
736
}
1270
client_config = configparser.SafeConfigParser(client_defaults)
1271
client_config.read(os.path.join(server_settings[u"configdir"],
1272
u"clients.conf"))
1273
1274
global mandos_dbus_service
1275
mandos_dbus_service = None
1276
1277
clients = set()
1278
tcp_server = MandosServer((server_settings[u"address"],
1279
server_settings[u"port"]),
1280
ClientHandler,
1281
interface=server_settings[u"interface"],
1282
use_ipv6=use_ipv6,
1283
clients=clients,
1284
gnutls_priority=
1285
server_settings[u"priority"],
1286
use_dbus=use_dbus)
1287
pidfilename = u"/var/run/mandos.pid"
1288
try:
1289
pidfile = open(pidfilename, u"w")
1290
except IOError:
1291
logger.error(u"Could not open file %r", pidfilename)
1292
1293
try:
1294
uid = pwd.getpwnam(u"_mandos").pw_uid
1295
gid = pwd.getpwnam(u"_mandos").pw_gid
1296
except KeyError:
1297
try:
1298
uid = pwd.getpwnam(u"mandos").pw_uid
1299
gid = pwd.getpwnam(u"mandos").pw_gid
1300
except KeyError:
1301
try:
1302
uid = pwd.getpwnam(u"nobody").pw_uid
1303
gid = pwd.getpwnam(u"nobody").pw_gid
1304
except KeyError:
1305
uid = 65534
1306
gid = 65534
1307
try:
1308
os.setgid(gid)
1309
os.setuid(uid)
1310
except OSError, error:
1311
if error[0] != errno.EPERM:
1312
raise error
1313
1314
# Enable all possible GnuTLS debugging
1315
if debug:
1316
# "Use a log level over 10 to enable all debugging options."
1317
# - GnuTLS manual
1318
gnutls.library.functions.gnutls_global_set_log_level(11)
1319
1320
@gnutls.library.types.gnutls_log_func
1321
def debug_gnutls(level, string):
1322
logger.debug(u"GnuTLS: %s", string[:-1])
1323
1324
(gnutls.library.functions
1325
.gnutls_global_set_log_function(debug_gnutls))
737
client_config = ConfigParser.SafeConfigParser(client_defaults)
738
client_config.read(os.path.join(server_settings["configdir"],
739
"clients.conf"))
740
741
global service
742
service = AvahiService(name = server_settings["servicename"],
743
type = "_mandos._tcp", );
744
if server_settings["interface"]:
745
service.interface = if_nametoindex(server_settings["interface"])
1326
746
1327
747
global main_loop
748
global bus
749
global server
1328
750
# From the Avahi example code
1329
751
DBusGMainLoop(set_as_default=True )
1330
752
main_loop = gobject.MainLoop()
1331
753
bus = dbus.SystemBus()
754
server = dbus.Interface(
755
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
756
avahi.DBUS_INTERFACE_SERVER )
1332
757
# End of Avahi example code
1333
if use_dbus:
1334
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1335
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1336
service = AvahiService(name = server_settings[u"servicename"],
1337
servicetype = u"_mandos._tcp",
1338
protocol = protocol, bus = bus)
1339
if server_settings["interface"]:
1340
service.interface = (if_nametoindex
1341
(str(server_settings[u"interface"])))
1342
1343
client_class = Client
1344
if use_dbus:
1345
client_class = functools.partial(ClientDBus, bus = bus)
1346
clients.update(set(
1347
client_class(name = section,
1348
config= dict(client_config.items(section)))
1349
for section in client_config.sections()))
758
759
clients = Set()
760
def remove_from_clients(client):
761
clients.remove(client)
762
if not clients:
763
logger.critical(u"No clients left, exiting")
764
sys.exit()
765
766
clients.update(Set(Client(name = section,
767
stop_hook = remove_from_clients,
768
config
769
= dict(client_config.items(section)))
770
for section in client_config.sections()))
1350
771
if not clients:
1351
logger.warning(u"No clients defined")
772
logger.critical(u"No clients defined")
773
sys.exit(1)
1352
774
1353
if debug:
1354
# Redirect stdin so all checkers get /dev/null
1355
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1356
os.dup2(null, sys.stdin.fileno())
1357
if null > 2:
1358
os.close(null)
1359
else:
1360
# No console logging
775
if not debug:
1361
776
logger.removeHandler(console)
1362
# Close all input and output, do double fork, etc.
1363
777
daemon()
1364
778
779
pidfilename = "/var/run/mandos/mandos.pid"
780
pid = os.getpid()
1365
781
try:
1366
with closing(pidfile):
1367
pid = os.getpid()
1368
pidfile.write(str(pid) + "\n")
782
pidfile = open(pidfilename, "w")
783
pidfile.write(str(pid) + "\n")
784
pidfile.close()
1369
785
del pidfile
1370
except IOError:
1371
logger.error(u"Could not write to file %r with PID %d",
1372
pidfilename, pid)
1373
except NameError:
1374
# "pidfile" was never created
1375
pass
1376
del pidfilename
786
except IOError, err:
787
logger.error(u"Could not write %s file with PID %d",
788
pidfilename, os.getpid())
1377
789
1378
790
def cleanup():
1379
791
"Cleanup function; run on exit"
1380
service.cleanup()
792
global group
793
# From the Avahi example code
794
if not group is None:
795
group.Free()
796
group = None
797
# End of Avahi example code
1381
798
1382
799
while clients:
1383
800
client = clients.pop()
1384
client.disable_hook = None
1385
client.disable()
801
client.stop_hook = None
802
client.stop()
1386
803
1387
804
atexit.register(cleanup)
1388
805
1391
808
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1392
809
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1393
810
1394
if use_dbus:
1395
class MandosDBusService(dbus.service.Object):
1396
"""A D-Bus proxy object"""
1397
def __init__(self):
1398
dbus.service.Object.__init__(self, bus, u"/")
1399
_interface = u"se.bsnet.fukt.Mandos"
1400
1401
@dbus.service.signal(_interface, signature=u"oa{sv}")
1402
def ClientAdded(self, objpath, properties):
1403
"D-Bus signal"
1404
pass
1405
1406
@dbus.service.signal(_interface, signature=u"s")
1407
def ClientNotFound(self, fingerprint):
1408
"D-Bus signal"
1409
pass
1410
1411
@dbus.service.signal(_interface, signature=u"os")
1412
def ClientRemoved(self, objpath, name):
1413
"D-Bus signal"
1414
pass
1415
1416
@dbus.service.method(_interface, out_signature=u"ao")
1417
def GetAllClients(self):
1418
"D-Bus method"
1419
return dbus.Array(c.dbus_object_path for c in clients)
1420
1421
@dbus.service.method(_interface,
1422
out_signature=u"a{oa{sv}}")
1423
def GetAllClientsWithProperties(self):
1424
"D-Bus method"
1425
return dbus.Dictionary(
1426
((c.dbus_object_path, c.GetAllProperties())
1427
for c in clients),
1428
signature=u"oa{sv}")
1429
1430
@dbus.service.method(_interface, in_signature=u"o")
1431
def RemoveClient(self, object_path):
1432
"D-Bus method"
1433
for c in clients:
1434
if c.dbus_object_path == object_path:
1435
clients.remove(c)
1436
c.remove_from_connection()
1437
# Don't signal anything except ClientRemoved
1438
c.disable(signal=False)
1439
# Emit D-Bus signal
1440
self.ClientRemoved(object_path, c.name)
1441
return
1442
raise KeyError
1443
1444
del _interface
1445
1446
mandos_dbus_service = MandosDBusService()
1447
1448
811
for client in clients:
1449
if use_dbus:
1450
# Emit D-Bus signal
1451
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1452
client.GetAllProperties())
1453
client.enable()
1454
1455
tcp_server.enable()
1456
tcp_server.server_activate()
1457
812
client.start()
813
814
tcp_server = IPv6_TCPServer((server_settings["address"],
815
server_settings["port"]),
816
tcp_handler,
817
settings=server_settings,
818
clients=clients)
1458
819
# Find out what port we got
1459
820
service.port = tcp_server.socket.getsockname()[1]
1460
if use_ipv6:
1461
logger.info(u"Now listening on address %r, port %d,"
1462
" flowinfo %d, scope_id %d"
1463
% tcp_server.socket.getsockname())
1464
else: # IPv4
1465
logger.info(u"Now listening on address %r, port %d"
1466
% tcp_server.socket.getsockname())
821
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
822
u" scope_id %d" % tcp_server.socket.getsockname())
1467
823
1468
824
#service.interface = tcp_server.socket.getsockname()[3]
1469
825
1470
826
try:
1471
827
# From the Avahi example code
828
server.connect_to_signal("StateChanged", server_state_changed)
1472
829
try:
1473
service.activate()
830
server_state_changed(server.GetState())
1474
831
except dbus.exceptions.DBusException, error:
1475
832
logger.critical(u"DBusException: %s", error)
1476
833
sys.exit(1)
1478
835
1479
836
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1480
837
lambda *args, **kwargs:
1481
(tcp_server.handle_request
1482
(*args[2:], **kwargs) or True))
838
tcp_server.handle_request\
839
(*args[2:], **kwargs) or True)
1483
840
1484
841
logger.debug(u"Starting main loop")
842
main_loop_started = True
1485
843
main_loop.run()
1486
844
except AvahiError, error:
1487
logger.critical(u"AvahiError: %s", error)
845
logger.critical(u"AvahiError: %s" + unicode(error))
1488
846
sys.exit(1)
1489
847
except KeyboardInterrupt:
1490
848
if debug:
1491
print >> sys.stderr
1492
logger.debug(u"Server received KeyboardInterrupt")
1493
logger.debug(u"Server exiting")
849
print
1494
850
1495
851
if __name__ == '__main__':
1496
852
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0