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 24.1.63
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.63
- Committer: Björn Påhlsson
- Date: 2008-08-24 10:19:59 UTC
- mfrom: (98 mandos)
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 99.
- Revision ID: belorn@braxen-20080824101959-cbs6x05jwgqrlp2s
merge + fallback bugg
- 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
11
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
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
55
54
import stat
56
55
import logging
57
56
import logging.handlers
58
import pwd
59
from contextlib import closing
60
57
61
58
import dbus
62
import dbus.service
63
59
import gobject
64
60
import avahi
65
61
from dbus.mainloop.glib import DBusGMainLoop
66
62
import ctypes
67
import ctypes.util
68
63
69
version = "1.0.5"
64
version = "1.0"
70
65
71
66
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 [%(process)d]: %(levelname)s:'
77
' %(message)s'))
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'))
78
72
logger.addHandler(syslogger)
79
73
80
74
console = logging.StreamHandler()
81
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
82
' %(levelname)s: %(message)s'))
75
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
76
' %(message)s'))
83
77
logger.addHandler(console)
84
78
85
79
class AvahiError(Exception):
86
def __init__(self, value, *args, **kwargs):
80
def __init__(self, value):
87
81
self.value = value
88
super(AvahiError, self).__init__(value, *args, **kwargs)
89
def __unicode__(self):
90
return unicode(repr(self.value))
82
def __str__(self):
83
return repr(self.value)
91
84
92
85
class AvahiServiceError(AvahiError):
93
86
pass
113
106
a sensible number of times
114
107
"""
115
108
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
116
servicetype = None, port = None, TXT = None,
117
domain = "", host = "", max_renames = 32768,
118
protocol = avahi.PROTO_UNSPEC):
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
119
111
self.interface = interface
120
112
self.name = name
121
self.type = servicetype
113
self.type = type
122
114
self.port = port
123
self.TXT = TXT if TXT is not None else []
115
if TXT is None:
116
self.TXT = []
117
else:
118
self.TXT = TXT
124
119
self.domain = domain
125
120
self.host = host
126
121
self.rename_count = 0
127
122
self.max_renames = max_renames
128
self.protocol = protocol
129
123
def rename(self):
130
124
"""Derived from the Avahi example code"""
131
125
if self.rename_count >= self.max_renames:
132
logger.critical(u"No suitable Zeroconf service name found"
133
u" after %i retries, exiting.",
134
self.rename_count)
135
raise AvahiServiceError(u"Too many renames")
126
logger.critical(u"No suitable service name found after %i"
127
u" retries, exiting.", rename_count)
128
raise AvahiServiceError("Too many renames")
136
129
self.name = server.GetAlternativeServiceName(self.name)
137
logger.info(u"Changing Zeroconf service name to %r ...",
138
str(self.name))
139
syslogger.setFormatter(logging.Formatter
130
logger.info(u"Changing name to %r ...", str(self.name))
131
syslogger.setFormatter(logging.Formatter\
140
132
('Mandos (%s): %%(levelname)s:'
141
' %%(message)s' % self.name))
133
' %%(message)s' % self.name))
142
134
self.remove()
143
135
self.add()
144
136
self.rename_count += 1
150
142
"""Derived from the Avahi example code"""
151
143
global group
152
144
if group is None:
153
group = dbus.Interface(bus.get_object
154
(avahi.DBUS_NAME,
145
group = dbus.Interface\
146
(bus.get_object(avahi.DBUS_NAME,
155
147
server.EntryGroupNew()),
156
avahi.DBUS_INTERFACE_ENTRY_GROUP)
148
avahi.DBUS_INTERFACE_ENTRY_GROUP)
157
149
group.connect_to_signal('StateChanged',
158
150
entry_group_state_changed)
159
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
151
logger.debug(u"Adding service '%s' of type '%s' ...",
160
152
service.name, service.type)
161
153
group.AddService(
162
154
self.interface, # interface
163
self.protocol, # protocol
155
avahi.PROTO_INET6, # protocol
164
156
dbus.UInt32(0), # flags
165
157
self.name, self.type,
166
158
self.domain, self.host,
173
165
# End of Avahi example code
174
166
175
167
176
def _datetime_to_dbus(dt, variant_level=0):
177
"""Convert a UTC datetime.datetime() to a D-Bus type."""
178
return dbus.String(dt.isoformat(), variant_level=variant_level)
179
180
181
class Client(dbus.service.Object):
168
class Client(object):
182
169
"""A representation of a client host served by this server.
183
170
Attributes:
184
name: string; from the config file, used in log messages and
185
D-Bus identifiers
171
name: string; from the config file, used in log messages
186
172
fingerprint: string (40 or 32 hexadecimal digits); used to
187
173
uniquely identify the client
188
secret: bytestring; sent verbatim (over TLS) to client
189
host: string; available for use by the checker command
190
created: datetime.datetime(); (UTC) object creation
191
last_enabled: datetime.datetime(); (UTC)
192
enabled: bool()
193
last_checked_ok: datetime.datetime(); (UTC) or None
194
timeout: datetime.timedelta(); How long from last_checked_ok
195
until this client is invalid
196
interval: datetime.timedelta(); How often to start a new checker
197
disable_hook: If set, called by disable() as disable_hook(self)
198
checker: subprocess.Popen(); a running checker process used
199
to see if the client lives.
200
'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.
201
185
checker_initiator_tag: a gobject event source tag, or None
202
disable_initiator_tag: - '' -
186
stop_initiator_tag: - '' -
203
187
checker_callback_tag: - '' -
204
188
checker_command: string; External command which is run to check if
205
189
client lives. %() expansions are done at
206
190
runtime with vars(self) as dict, so that for
207
191
instance %(name)s can be used in the command.
208
use_dbus: bool(); Whether to provide D-Bus interface and signals
209
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
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: - '' -
210
197
"""
211
def timeout_milliseconds(self):
212
"Return the 'timeout' attribute in milliseconds"
213
return ((self.timeout.days * 24 * 60 * 60 * 1000)
214
+ (self.timeout.seconds * 1000)
215
+ (self.timeout.microseconds // 1000))
216
217
def interval_milliseconds(self):
218
"Return the 'interval' attribute in milliseconds"
219
return ((self.interval.days * 24 * 60 * 60 * 1000)
220
+ (self.interval.seconds * 1000)
221
+ (self.interval.microseconds // 1000))
222
223
def __init__(self, name = None, disable_hook=None, config=None,
224
use_dbus=True):
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={}):
225
222
"""Note: the 'checker' key in 'config' sets the
226
223
'checker_command' attribute and *not* the 'checker'
227
224
attribute."""
228
225
self.name = name
229
if config is None:
230
config = {}
231
226
logger.debug(u"Creating client %r", self.name)
232
self.use_dbus = False # During __init__
233
227
# Uppercase and remove spaces from fingerprint for later
234
228
# comparison purposes with return value from the fingerprint()
235
229
# function
236
self.fingerprint = (config["fingerprint"].upper()
237
.replace(u" ", u""))
230
self.fingerprint = config["fingerprint"].upper()\
231
.replace(u" ", u"")
238
232
logger.debug(u" Fingerprint: %s", self.fingerprint)
239
233
if "secret" in config:
240
234
self.secret = config["secret"].decode(u"base64")
241
235
elif "secfile" in config:
242
with closing(open(os.path.expanduser
243
(os.path.expandvars
244
(config["secfile"])))) as secfile:
245
self.secret = secfile.read()
236
sf = open(config["secfile"])
237
self.secret = sf.read()
238
sf.close()
246
239
else:
247
240
raise TypeError(u"No secret or secfile for client %s"
248
241
% self.name)
249
242
self.host = config.get("host", "")
250
self.created = datetime.datetime.utcnow()
251
self.enabled = False
252
self.last_enabled = None
243
self.created = datetime.datetime.now()
253
244
self.last_checked_ok = None
254
245
self.timeout = string_to_delta(config["timeout"])
255
246
self.interval = string_to_delta(config["interval"])
256
self.disable_hook = disable_hook
247
self.stop_hook = stop_hook
257
248
self.checker = None
258
249
self.checker_initiator_tag = None
259
self.disable_initiator_tag = None
250
self.stop_initiator_tag = None
260
251
self.checker_callback_tag = None
261
self.checker_command = config["checker"]
262
self.last_connect = None
263
# Only now, when this client is initialized, can it show up on
264
# the D-Bus
265
self.use_dbus = use_dbus
266
if self.use_dbus:
267
self.dbus_object_path = (dbus.ObjectPath
268
("/clients/"
269
+ self.name.replace(".", "_")))
270
dbus.service.Object.__init__(self, bus,
271
self.dbus_object_path)
272
273
def enable(self):
252
self.check_command = config["checker"]
253
def start(self):
274
254
"""Start this client's checker and timeout hooks"""
275
self.last_enabled = datetime.datetime.utcnow()
276
255
# Schedule a new checker to be started an 'interval' from now,
277
256
# and every interval from then on.
278
self.checker_initiator_tag = (gobject.timeout_add
279
(self.interval_milliseconds(),
280
self.start_checker))
257
self.checker_initiator_tag = gobject.timeout_add\
258
(self._interval_milliseconds,
259
self.start_checker)
281
260
# Also start a new checker *right now*.
282
261
self.start_checker()
283
# Schedule a disable() when 'timeout' has passed
284
self.disable_initiator_tag = (gobject.timeout_add
285
(self.timeout_milliseconds(),
286
self.disable))
287
self.enabled = True
288
if self.use_dbus:
289
# Emit D-Bus signals
290
self.PropertyChanged(dbus.String(u"enabled"),
291
dbus.Boolean(True, variant_level=1))
292
self.PropertyChanged(dbus.String(u"last_enabled"),
293
(_datetime_to_dbus(self.last_enabled,
294
variant_level=1)))
295
296
def disable(self):
297
"""Disable this client."""
298
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:
299
275
return False
300
logger.info(u"Disabling client %s", self.name)
301
if getattr(self, "disable_initiator_tag", False):
302
gobject.source_remove(self.disable_initiator_tag)
303
self.disable_initiator_tag = None
276
if getattr(self, "stop_initiator_tag", False):
277
gobject.source_remove(self.stop_initiator_tag)
278
self.stop_initiator_tag = None
304
279
if getattr(self, "checker_initiator_tag", False):
305
280
gobject.source_remove(self.checker_initiator_tag)
306
281
self.checker_initiator_tag = None
307
282
self.stop_checker()
308
if self.disable_hook:
309
self.disable_hook(self)
310
self.enabled = False
311
if self.use_dbus:
312
# Emit D-Bus signal
313
self.PropertyChanged(dbus.String(u"enabled"),
314
dbus.Boolean(False, variant_level=1))
283
if self.stop_hook:
284
self.stop_hook(self)
315
285
# Do not run this again if called by a gobject.timeout_add
316
286
return False
317
318
287
def __del__(self):
319
self.disable_hook = None
320
self.disable()
321
322
def checker_callback(self, pid, condition, command):
288
self.stop_hook = None
289
self.stop()
290
def checker_callback(self, pid, condition):
323
291
"""The checker has completed, so take appropriate actions."""
292
now = datetime.datetime.now()
324
293
self.checker_callback_tag = None
325
294
self.checker = None
326
if self.use_dbus:
327
# Emit D-Bus signal
328
self.PropertyChanged(dbus.String(u"checker_running"),
329
dbus.Boolean(False, variant_level=1))
330
if os.WIFEXITED(condition):
331
exitstatus = os.WEXITSTATUS(condition)
332
if exitstatus == 0:
333
logger.info(u"Checker for %(name)s succeeded",
334
vars(self))
335
self.checked_ok()
336
else:
337
logger.info(u"Checker for %(name)s failed",
338
vars(self))
339
if self.use_dbus:
340
# Emit D-Bus signal
341
self.CheckerCompleted(dbus.Int16(exitstatus),
342
dbus.Int64(condition),
343
dbus.String(command))
344
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):
345
305
logger.warning(u"Checker for %(name)s crashed?",
346
306
vars(self))
347
if self.use_dbus:
348
# Emit D-Bus signal
349
self.CheckerCompleted(dbus.Int16(-1),
350
dbus.Int64(condition),
351
dbus.String(command))
352
353
def checked_ok(self):
354
"""Bump up the timeout for this client.
355
This should only be called when the client has been seen,
356
alive and well.
357
"""
358
self.last_checked_ok = datetime.datetime.utcnow()
359
gobject.source_remove(self.disable_initiator_tag)
360
self.disable_initiator_tag = (gobject.timeout_add
361
(self.timeout_milliseconds(),
362
self.disable))
363
if self.use_dbus:
364
# Emit D-Bus signal
365
self.PropertyChanged(
366
dbus.String(u"last_checked_ok"),
367
(_datetime_to_dbus(self.last_checked_ok,
368
variant_level=1)))
369
307
else:
308
logger.info(u"Checker for %(name)s failed",
309
vars(self))
370
310
def start_checker(self):
371
311
"""Start a new checker subprocess if one is not running.
372
312
If a checker already exists, leave it running and do
381
321
# is as it should be.
382
322
if self.checker is None:
383
323
try:
384
# In case checker_command has exactly one % operator
385
command = self.checker_command % self.host
324
# In case check_command has exactly one % operator
325
command = self.check_command % self.host
386
326
except TypeError:
387
327
# Escape attributes for the shell
388
328
escaped_attrs = dict((key, re.escape(str(val)))
389
329
for key, val in
390
330
vars(self).iteritems())
391
331
try:
392
command = self.checker_command % escaped_attrs
332
command = self.check_command % escaped_attrs
393
333
except TypeError, error:
394
334
logger.error(u'Could not format string "%s":'
395
u' %s', self.checker_command, error)
335
u' %s', self.check_command, error)
396
336
return True # Try again later
397
337
try:
398
338
logger.info(u"Starting checker %r for %s",
404
344
self.checker = subprocess.Popen(command,
405
345
close_fds=True,
406
346
shell=True, cwd="/")
407
if self.use_dbus:
408
# Emit D-Bus signal
409
self.CheckerStarted(command)
410
self.PropertyChanged(
411
dbus.String("checker_running"),
412
dbus.Boolean(True, variant_level=1))
413
self.checker_callback_tag = (gobject.child_watch_add
414
(self.checker.pid,
415
self.checker_callback,
416
data=command))
417
# The checker may have completed before the gobject
418
# watch was added. Check for this.
419
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
420
if pid:
421
gobject.source_remove(self.checker_callback_tag)
422
self.checker_callback(pid, status, command)
347
self.checker_callback_tag = gobject.child_watch_add\
348
(self.checker.pid,
349
self.checker_callback)
423
350
except OSError, error:
424
351
logger.error(u"Failed to start subprocess: %s",
425
352
error)
426
353
# Re-run this periodically if run by gobject.timeout_add
427
354
return True
428
429
355
def stop_checker(self):
430
356
"""Force the checker process, if any, to stop."""
431
357
if self.checker_callback_tag:
443
369
if error.errno != errno.ESRCH: # No such process
444
370
raise
445
371
self.checker = None
446
if self.use_dbus:
447
self.PropertyChanged(dbus.String(u"checker_running"),
448
dbus.Boolean(False, variant_level=1))
449
450
372
def still_valid(self):
451
373
"""Has the timeout not yet passed for this client?"""
452
if not getattr(self, "enabled", False):
453
return False
454
now = datetime.datetime.utcnow()
374
now = datetime.datetime.now()
455
375
if self.last_checked_ok is None:
456
376
return now < (self.created + self.timeout)
457
377
else:
458
378
return now < (self.last_checked_ok + self.timeout)
459
460
## D-Bus methods & signals
461
_interface = u"se.bsnet.fukt.Mandos.Client"
462
463
# CheckedOK - method
464
CheckedOK = dbus.service.method(_interface)(checked_ok)
465
CheckedOK.__name__ = "CheckedOK"
466
467
# CheckerCompleted - signal
468
@dbus.service.signal(_interface, signature="nxs")
469
def CheckerCompleted(self, exitcode, waitstatus, command):
470
"D-Bus signal"
471
pass
472
473
# CheckerStarted - signal
474
@dbus.service.signal(_interface, signature="s")
475
def CheckerStarted(self, command):
476
"D-Bus signal"
477
pass
478
479
# GetAllProperties - method
480
@dbus.service.method(_interface, out_signature="a{sv}")
481
def GetAllProperties(self):
482
"D-Bus method"
483
return dbus.Dictionary({
484
dbus.String("name"):
485
dbus.String(self.name, variant_level=1),
486
dbus.String("fingerprint"):
487
dbus.String(self.fingerprint, variant_level=1),
488
dbus.String("host"):
489
dbus.String(self.host, variant_level=1),
490
dbus.String("created"):
491
_datetime_to_dbus(self.created, variant_level=1),
492
dbus.String("last_enabled"):
493
(_datetime_to_dbus(self.last_enabled,
494
variant_level=1)
495
if self.last_enabled is not None
496
else dbus.Boolean(False, variant_level=1)),
497
dbus.String("enabled"):
498
dbus.Boolean(self.enabled, variant_level=1),
499
dbus.String("last_checked_ok"):
500
(_datetime_to_dbus(self.last_checked_ok,
501
variant_level=1)
502
if self.last_checked_ok is not None
503
else dbus.Boolean (False, variant_level=1)),
504
dbus.String("timeout"):
505
dbus.UInt64(self.timeout_milliseconds(),
506
variant_level=1),
507
dbus.String("interval"):
508
dbus.UInt64(self.interval_milliseconds(),
509
variant_level=1),
510
dbus.String("checker"):
511
dbus.String(self.checker_command,
512
variant_level=1),
513
dbus.String("checker_running"):
514
dbus.Boolean(self.checker is not None,
515
variant_level=1),
516
dbus.String("object_path"):
517
dbus.ObjectPath(self.dbus_object_path,
518
variant_level=1)
519
}, signature="sv")
520
521
# IsStillValid - method
522
IsStillValid = (dbus.service.method(_interface, out_signature="b")
523
(still_valid))
524
IsStillValid.__name__ = "IsStillValid"
525
526
# PropertyChanged - signal
527
@dbus.service.signal(_interface, signature="sv")
528
def PropertyChanged(self, property, value):
529
"D-Bus signal"
530
pass
531
532
# SetChecker - method
533
@dbus.service.method(_interface, in_signature="s")
534
def SetChecker(self, checker):
535
"D-Bus setter method"
536
self.checker_command = checker
537
# Emit D-Bus signal
538
self.PropertyChanged(dbus.String(u"checker"),
539
dbus.String(self.checker_command,
540
variant_level=1))
541
542
# SetHost - method
543
@dbus.service.method(_interface, in_signature="s")
544
def SetHost(self, host):
545
"D-Bus setter method"
546
self.host = host
547
# Emit D-Bus signal
548
self.PropertyChanged(dbus.String(u"host"),
549
dbus.String(self.host, variant_level=1))
550
551
# SetInterval - method
552
@dbus.service.method(_interface, in_signature="t")
553
def SetInterval(self, milliseconds):
554
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
555
# Emit D-Bus signal
556
self.PropertyChanged(dbus.String(u"interval"),
557
(dbus.UInt64(self.interval_milliseconds(),
558
variant_level=1)))
559
560
# SetSecret - method
561
@dbus.service.method(_interface, in_signature="ay",
562
byte_arrays=True)
563
def SetSecret(self, secret):
564
"D-Bus setter method"
565
self.secret = str(secret)
566
567
# SetTimeout - method
568
@dbus.service.method(_interface, in_signature="t")
569
def SetTimeout(self, milliseconds):
570
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
571
# Emit D-Bus signal
572
self.PropertyChanged(dbus.String(u"timeout"),
573
(dbus.UInt64(self.timeout_milliseconds(),
574
variant_level=1)))
575
576
# Enable - method
577
Enable = dbus.service.method(_interface)(enable)
578
Enable.__name__ = "Enable"
579
580
# StartChecker - method
581
@dbus.service.method(_interface)
582
def StartChecker(self):
583
"D-Bus method"
584
self.start_checker()
585
586
# Disable - method
587
@dbus.service.method(_interface)
588
def Disable(self):
589
"D-Bus method"
590
self.disable()
591
592
# StopChecker - method
593
StopChecker = dbus.service.method(_interface)(stop_checker)
594
StopChecker.__name__ = "StopChecker"
595
596
del _interface
597
379
598
380
599
381
def peer_certificate(session):
600
382
"Return the peer's OpenPGP certificate as a bytestring"
601
383
# If not an OpenPGP certificate...
602
if (gnutls.library.functions
603
.gnutls_certificate_type_get(session._c_object)
604
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
384
if gnutls.library.functions.gnutls_certificate_type_get\
385
(session._c_object) \
386
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
605
387
# ...do the normal thing
606
388
return session.peer_certificate
607
list_size = ctypes.c_uint(1)
608
cert_list = (gnutls.library.functions
609
.gnutls_certificate_get_peers
610
(session._c_object, ctypes.byref(list_size)))
611
if not bool(cert_list) and list_size.value != 0:
612
raise gnutls.errors.GNUTLSError("error getting peer"
613
" certificate")
389
list_size = ctypes.c_uint()
390
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
391
(session._c_object, ctypes.byref(list_size))
614
392
if list_size.value == 0:
615
393
return None
616
394
cert = cert_list[0]
620
398
def fingerprint(openpgp):
621
399
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
622
400
# New GnuTLS "datum" with the OpenPGP public key
623
datum = (gnutls.library.types
624
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
625
ctypes.POINTER
626
(ctypes.c_ubyte)),
627
ctypes.c_uint(len(openpgp))))
401
datum = gnutls.library.types.gnutls_datum_t\
402
(ctypes.cast(ctypes.c_char_p(openpgp),
403
ctypes.POINTER(ctypes.c_ubyte)),
404
ctypes.c_uint(len(openpgp)))
628
405
# New empty GnuTLS certificate
629
406
crt = gnutls.library.types.gnutls_openpgp_crt_t()
630
(gnutls.library.functions
631
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
407
gnutls.library.functions.gnutls_openpgp_crt_init\
408
(ctypes.byref(crt))
632
409
# Import the OpenPGP public key into the certificate
633
(gnutls.library.functions
634
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
635
gnutls.library.constants
636
.GNUTLS_OPENPGP_FMT_RAW))
410
gnutls.library.functions.gnutls_openpgp_crt_import\
411
(crt, ctypes.byref(datum),
412
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
637
413
# Verify the self signature in the key
638
crtverify = ctypes.c_uint()
639
(gnutls.library.functions
640
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
641
if crtverify.value != 0:
414
crtverify = ctypes.c_uint();
415
gnutls.library.functions.gnutls_openpgp_crt_verify_self\
416
(crt, ctypes.c_uint(0), ctypes.byref(crtverify))
417
if crtverify != 0:
642
418
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
643
419
raise gnutls.errors.CertificateSecurityError("Verify failed")
644
420
# New buffer for the fingerprint
645
buf = ctypes.create_string_buffer(20)
646
buf_len = ctypes.c_size_t()
421
buffer = ctypes.create_string_buffer(20)
422
buffer_length = ctypes.c_size_t()
647
423
# Get the fingerprint from the certificate into the buffer
648
(gnutls.library.functions
649
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
650
ctypes.byref(buf_len)))
424
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
425
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
651
426
# Deinit the certificate
652
427
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
653
428
# Convert the buffer to a Python bytestring
654
fpr = ctypes.string_at(buf, buf_len.value)
429
fpr = ctypes.string_at(buffer, buffer_length.value)
655
430
# Convert the bytestring to hexadecimal notation
656
431
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
657
432
return hex_fpr
658
433
659
434
660
class TCP_handler(SocketServer.BaseRequestHandler, object):
435
class tcp_handler(SocketServer.BaseRequestHandler, object):
661
436
"""A TCP request handler class.
662
437
Instantiated by IPv6_TCPServer for each request to handle it.
663
438
Note: This will run in its own forked process."""
664
439
665
440
def handle(self):
666
441
logger.info(u"TCP connection from: %s",
667
unicode(self.client_address))
668
session = (gnutls.connection
669
.ClientSession(self.request,
670
gnutls.connection
671
.X509Credentials()))
442
unicode(self.client_address))
443
session = gnutls.connection.ClientSession\
444
(self.request, gnutls.connection.X509Credentials())
672
445
673
446
line = self.request.makefile().readline()
674
447
logger.debug(u"Protocol version: %r", line)
685
458
# using OpenPGP certificates.
686
459
687
460
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
688
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
689
# "+DHE-DSS"))
690
# Use a fallback default, since this MUST be set.
691
priority = self.server.settings.get("priority", "NORMAL")
692
(gnutls.library.functions
693
.gnutls_priority_set_direct(session._c_object,
694
priority, None))
461
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
462
# "+DHE-DSS"))
463
priority = "NORMAL" # Fallback default, since this
464
# MUST be set.
465
if self.server.settings["priority"]:
466
priority = self.server.settings["priority"]
467
gnutls.library.functions.gnutls_priority_set_direct\
468
(session._c_object, priority, None);
695
469
696
470
try:
697
471
session.handshake()
700
474
# Do not run session.bye() here: the session is not
701
475
# established. Just abandon the request.
702
476
return
703
logger.debug(u"Handshake succeeded")
704
477
try:
705
478
fpr = fingerprint(peer_certificate(session))
706
479
except (TypeError, gnutls.errors.GNUTLSError), error:
708
481
session.bye()
709
482
return
710
483
logger.debug(u"Fingerprint: %s", fpr)
711
484
client = None
712
485
for c in self.server.clients:
713
486
if c.fingerprint == fpr:
714
487
client = c
715
488
break
716
else:
489
if not client:
717
490
logger.warning(u"Client not found for fingerprint: %s",
718
491
fpr)
719
492
session.bye()
726
499
vars(client))
727
500
session.bye()
728
501
return
729
## This won't work here, since we're in a fork.
730
# client.checked_ok()
731
502
sent_size = 0
732
503
while sent_size < len(client.secret):
733
504
sent = session.send(client.secret[sent_size:])
738
509
session.bye()
739
510
740
511
741
class IPv6_TCPServer(SocketServer.ForkingMixIn,
742
SocketServer.TCPServer, object):
743
"""IPv6-capable TCP server. Accepts 'None' as address and/or port.
512
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
513
"""IPv6 TCP server. Accepts 'None' as address and/or port.
744
514
Attributes:
745
515
settings: Server settings
746
516
clients: Set() of Client objects
747
enabled: Boolean; whether this server is activated yet
748
517
"""
749
518
address_family = socket.AF_INET6
750
519
def __init__(self, *args, **kwargs):
754
523
if "clients" in kwargs:
755
524
self.clients = kwargs["clients"]
756
525
del kwargs["clients"]
757
if "use_ipv6" in kwargs:
758
if not kwargs["use_ipv6"]:
759
self.address_family = socket.AF_INET
760
del kwargs["use_ipv6"]
761
self.enabled = False
762
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
526
return super(type(self), self).__init__(*args, **kwargs)
763
527
def server_bind(self):
764
528
"""This overrides the normal server_bind() function
765
529
to bind to an interface if one was specified, and also NOT to
777
541
u" bind to interface %s",
778
542
self.settings["interface"])
779
543
else:
780
raise
544
raise error
781
545
# Only bind(2) the socket if we really need to.
782
546
if self.server_address[0] or self.server_address[1]:
783
547
if not self.server_address[0]:
784
if self.address_family == socket.AF_INET6:
785
any_address = "::" # in6addr_any
786
else:
787
any_address = socket.INADDR_ANY
788
self.server_address = (any_address,
548
in6addr_any = "::"
549
self.server_address = (in6addr_any,
789
550
self.server_address[1])
790
551
elif not self.server_address[1]:
791
552
self.server_address = (self.server_address[0],
797
558
# if_nametoindex
798
559
# (self.settings
799
560
# ["interface"]))
800
return super(IPv6_TCPServer, self).server_bind()
801
def server_activate(self):
802
if self.enabled:
803
return super(IPv6_TCPServer, self).server_activate()
804
def enable(self):
805
self.enabled = True
561
return super(type(self), self).server_bind()
806
562
807
563
808
564
def string_to_delta(interval):
809
565
"""Parse a string and return a datetime.timedelta
810
566
811
567
>>> string_to_delta('7d')
812
568
datetime.timedelta(7)
813
569
>>> string_to_delta('60s')
824
580
timevalue = datetime.timedelta(0)
825
581
for s in interval.split():
826
582
try:
827
suffix = unicode(s[-1])
828
value = int(s[:-1])
583
suffix=unicode(s[-1])
584
value=int(s[:-1])
829
585
if suffix == u"d":
830
586
delta = datetime.timedelta(value)
831
587
elif suffix == u"s":
847
603
def server_state_changed(state):
848
604
"""Derived from the Avahi example code"""
849
605
if state == avahi.SERVER_COLLISION:
850
logger.error(u"Zeroconf server name collision")
606
logger.error(u"Server name collision")
851
607
service.remove()
852
608
elif state == avahi.SERVER_RUNNING:
853
609
service.add()
855
611
856
612
def entry_group_state_changed(state, error):
857
613
"""Derived from the Avahi example code"""
858
logger.debug(u"Avahi state change: %i", state)
614
logger.debug(u"state change: %i", state)
859
615
860
616
if state == avahi.ENTRY_GROUP_ESTABLISHED:
861
logger.debug(u"Zeroconf service established.")
617
logger.debug(u"Service established.")
862
618
elif state == avahi.ENTRY_GROUP_COLLISION:
863
logger.warning(u"Zeroconf service name collision.")
619
logger.warning(u"Service name collision.")
864
620
service.rename()
865
621
elif state == avahi.ENTRY_GROUP_FAILURE:
866
logger.critical(u"Avahi: Error in group state changed %s",
622
logger.critical(u"Error in group state changed %s",
867
623
unicode(error))
868
raise AvahiGroupError(u"State changed: %s" % unicode(error))
624
raise AvahiGroupError("State changed: %s", str(error))
869
625
870
626
def if_nametoindex(interface):
871
627
"""Call the C function if_nametoindex(), or equivalent"""
872
628
global if_nametoindex
873
629
try:
874
if_nametoindex = (ctypes.cdll.LoadLibrary
875
(ctypes.util.find_library("c"))
876
.if_nametoindex)
630
if "ctypes.util" not in sys.modules:
631
import ctypes.util
632
if_nametoindex = ctypes.cdll.LoadLibrary\
633
(ctypes.util.find_library("c")).if_nametoindex
877
634
except (OSError, AttributeError):
878
635
if "struct" not in sys.modules:
879
636
import struct
882
639
def if_nametoindex(interface):
883
640
"Get an interface index the hard way, i.e. using fcntl()"
884
641
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
885
with closing(socket.socket()) as s:
886
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
887
struct.pack("16s16x", interface))
642
s = socket.socket()
643
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
644
struct.pack("16s16x", interface))
645
s.close()
888
646
interface_index = struct.unpack("I", ifreq[16:20])[0]
889
647
return interface_index
890
648
return if_nametoindex(interface)
914
672
915
673
916
674
def main():
917
parser = optparse.OptionParser(version = "%%prog %s" % version)
675
global main_loop_started
676
main_loop_started = False
677
678
parser = OptionParser(version = "%%prog %s" % version)
918
679
parser.add_option("-i", "--interface", type="string",
919
680
metavar="IF", help="Bind to interface IF")
920
681
parser.add_option("-a", "--address", type="string",
921
682
help="Address to listen for requests on")
922
683
parser.add_option("-p", "--port", type="int",
923
684
help="Port number to receive requests on")
924
parser.add_option("--check", action="store_true",
685
parser.add_option("--check", action="store_true", default=False,
925
686
help="Run self-test")
926
687
parser.add_option("--debug", action="store_true",
927
688
help="Debug mode; run in foreground and log to"
934
695
default="/etc/mandos", metavar="DIR",
935
696
help="Directory to search for configuration"
936
697
" files")
937
parser.add_option("--no-dbus", action="store_false",
938
dest="use_dbus",
939
help="Do not provide D-Bus system bus"
940
" interface")
941
parser.add_option("--no-ipv6", action="store_false",
942
dest="use_ipv6", help="Do not use IPv6")
943
options = parser.parse_args()[0]
698
(options, args) = parser.parse_args()
944
699
945
700
if options.check:
946
701
import doctest
955
710
"priority":
956
711
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
957
712
"servicename": "Mandos",
958
"use_dbus": "True",
959
"use_ipv6": "True",
960
713
}
961
714
962
715
# Parse config file for server-global settings
965
718
server_config.read(os.path.join(options.configdir, "mandos.conf"))
966
719
# Convert the SafeConfigParser object to a dict
967
720
server_settings = server_config.defaults()
968
# Use the appropriate methods on the non-string config options
969
server_settings["debug"] = server_config.getboolean("DEFAULT",
970
"debug")
971
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
972
"use_dbus")
973
server_settings["use_ipv6"] = server_config.getboolean("DEFAULT",
974
"use_ipv6")
975
if server_settings["port"]:
976
server_settings["port"] = server_config.getint("DEFAULT",
977
"port")
721
# Use getboolean on the boolean config option
722
server_settings["debug"] = server_config.getboolean\
723
("DEFAULT", "debug")
978
724
del server_config
979
725
980
726
# Override the settings from the config file with command line
981
727
# options, if set.
982
728
for option in ("interface", "address", "port", "debug",
983
"priority", "servicename", "configdir",
984
"use_dbus", "use_ipv6"):
729
"priority", "servicename", "configdir"):
985
730
value = getattr(options, option)
986
731
if value is not None:
987
732
server_settings[option] = value
988
733
del options
989
734
# Now we have our good server settings in "server_settings"
990
735
991
# For convenience
992
736
debug = server_settings["debug"]
993
use_dbus = server_settings["use_dbus"]
994
use_ipv6 = server_settings["use_ipv6"]
995
737
996
738
if not debug:
997
739
syslogger.setLevel(logging.WARNING)
998
740
console.setLevel(logging.WARNING)
999
741
1000
742
if server_settings["servicename"] != "Mandos":
1001
syslogger.setFormatter(logging.Formatter
743
syslogger.setFormatter(logging.Formatter\
1002
744
('Mandos (%s): %%(levelname)s:'
1003
745
' %%(message)s'
1004
746
% server_settings["servicename"]))
1006
748
# Parse config file with clients
1007
749
client_defaults = { "timeout": "1h",
1008
750
"interval": "5m",
1009
"checker": "fping -q -- %%(host)s",
751
"checker": "fping -q -- %(host)s",
1010
752
"host": "",
1011
753
}
1012
754
client_config = ConfigParser.SafeConfigParser(client_defaults)
1013
755
client_config.read(os.path.join(server_settings["configdir"],
1014
756
"clients.conf"))
1015
757
1016
clients = Set()
1017
tcp_server = IPv6_TCPServer((server_settings["address"],
1018
server_settings["port"]),
1019
TCP_handler,
1020
settings=server_settings,
1021
clients=clients, use_ipv6=use_ipv6)
1022
pidfilename = "/var/run/mandos.pid"
1023
try:
1024
pidfile = open(pidfilename, "w")
1025
except IOError:
1026
logger.error("Could not open file %r", pidfilename)
1027
1028
try:
1029
uid = pwd.getpwnam("_mandos").pw_uid
1030
gid = pwd.getpwnam("_mandos").pw_gid
1031
except KeyError:
1032
try:
1033
uid = pwd.getpwnam("mandos").pw_uid
1034
gid = pwd.getpwnam("mandos").pw_gid
1035
except KeyError:
1036
try:
1037
uid = pwd.getpwnam("nobody").pw_uid
1038
gid = pwd.getpwnam("nogroup").pw_gid
1039
except KeyError:
1040
uid = 65534
1041
gid = 65534
1042
try:
1043
os.setgid(gid)
1044
os.setuid(uid)
1045
except OSError, error:
1046
if error[0] != errno.EPERM:
1047
raise error
1048
1049
# Enable all possible GnuTLS debugging
1050
if debug:
1051
# "Use a log level over 10 to enable all debugging options."
1052
# - GnuTLS manual
1053
gnutls.library.functions.gnutls_global_set_log_level(11)
1054
1055
@gnutls.library.types.gnutls_log_func
1056
def debug_gnutls(level, string):
1057
logger.debug("GnuTLS: %s", string[:-1])
1058
1059
(gnutls.library.functions
1060
.gnutls_global_set_log_function(debug_gnutls))
1061
1062
758
global service
1063
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1064
759
service = AvahiService(name = server_settings["servicename"],
1065
servicetype = "_mandos._tcp",
1066
protocol = protocol)
760
type = "_mandos._tcp", );
1067
761
if server_settings["interface"]:
1068
service.interface = (if_nametoindex
1069
(server_settings["interface"]))
762
service.interface = if_nametoindex(server_settings["interface"])
1070
763
1071
764
global main_loop
1072
765
global bus
1075
768
DBusGMainLoop(set_as_default=True )
1076
769
main_loop = gobject.MainLoop()
1077
770
bus = dbus.SystemBus()
1078
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1079
avahi.DBUS_PATH_SERVER),
1080
avahi.DBUS_INTERFACE_SERVER)
771
server = dbus.Interface(
772
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
773
avahi.DBUS_INTERFACE_SERVER )
1081
774
# End of Avahi example code
1082
if use_dbus:
1083
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
775
776
clients = Set()
777
def remove_from_clients(client):
778
clients.remove(client)
779
if not clients:
780
logger.critical(u"No clients left, exiting")
781
sys.exit()
1084
782
1085
783
clients.update(Set(Client(name = section,
784
stop_hook = remove_from_clients,
1086
785
config
1087
= dict(client_config.items(section)),
1088
use_dbus = use_dbus)
786
= dict(client_config.items(section)))
1089
787
for section in client_config.sections()))
1090
788
if not clients:
1091
logger.warning(u"No clients defined")
789
logger.critical(u"No clients defined")
790
sys.exit(1)
1092
791
1093
792
if debug:
1094
793
# Redirect stdin so all checkers get /dev/null
1102
801
# Close all input and output, do double fork, etc.
1103
802
daemon()
1104
803
804
pidfilename = "/var/run/mandos/mandos.pid"
805
pid = os.getpid()
1105
806
try:
1106
pid = os.getpid()
807
pidfile = open(pidfilename, "w")
1107
808
pidfile.write(str(pid) + "\n")
1108
809
pidfile.close()
1109
810
del pidfile
1110
except IOError:
1111
logger.error(u"Could not write to file %r with PID %d",
1112
pidfilename, pid)
1113
except NameError:
1114
# "pidfile" was never created
1115
pass
1116
del pidfilename
811
except IOError, err:
812
logger.error(u"Could not write %s file with PID %d",
813
pidfilename, os.getpid())
1117
814
1118
815
def cleanup():
1119
816
"Cleanup function; run on exit"
1126
823
1127
824
while clients:
1128
825
client = clients.pop()
1129
client.disable_hook = None
1130
client.disable()
826
client.stop_hook = None
827
client.stop()
1131
828
1132
829
atexit.register(cleanup)
1133
830
1136
833
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1137
834
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1138
835
1139
if use_dbus:
1140
class MandosServer(dbus.service.Object):
1141
"""A D-Bus proxy object"""
1142
def __init__(self):
1143
dbus.service.Object.__init__(self, bus, "/")
1144
_interface = u"se.bsnet.fukt.Mandos"
1145
1146
@dbus.service.signal(_interface, signature="oa{sv}")
1147
def ClientAdded(self, objpath, properties):
1148
"D-Bus signal"
1149
pass
1150
1151
@dbus.service.signal(_interface, signature="os")
1152
def ClientRemoved(self, objpath, name):
1153
"D-Bus signal"
1154
pass
1155
1156
@dbus.service.method(_interface, out_signature="ao")
1157
def GetAllClients(self):
1158
"D-Bus method"
1159
return dbus.Array(c.dbus_object_path for c in clients)
1160
1161
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1162
def GetAllClientsWithProperties(self):
1163
"D-Bus method"
1164
return dbus.Dictionary(
1165
((c.dbus_object_path, c.GetAllProperties())
1166
for c in clients),
1167
signature="oa{sv}")
1168
1169
@dbus.service.method(_interface, in_signature="o")
1170
def RemoveClient(self, object_path):
1171
"D-Bus method"
1172
for c in clients:
1173
if c.dbus_object_path == object_path:
1174
clients.remove(c)
1175
# Don't signal anything except ClientRemoved
1176
c.use_dbus = False
1177
c.disable()
1178
# Emit D-Bus signal
1179
self.ClientRemoved(object_path, c.name)
1180
return
1181
raise KeyError
1182
1183
del _interface
1184
1185
mandos_server = MandosServer()
1186
1187
836
for client in clients:
1188
if use_dbus:
1189
# Emit D-Bus signal
1190
mandos_server.ClientAdded(client.dbus_object_path,
1191
client.GetAllProperties())
1192
client.enable()
1193
1194
tcp_server.enable()
1195
tcp_server.server_activate()
1196
837
client.start()
838
839
tcp_server = IPv6_TCPServer((server_settings["address"],
840
server_settings["port"]),
841
tcp_handler,
842
settings=server_settings,
843
clients=clients)
1197
844
# Find out what port we got
1198
845
service.port = tcp_server.socket.getsockname()[1]
1199
if use_ipv6:
1200
logger.info(u"Now listening on address %r, port %d,"
1201
" flowinfo %d, scope_id %d"
1202
% tcp_server.socket.getsockname())
1203
else: # IPv4
1204
logger.info(u"Now listening on address %r, port %d"
1205
% tcp_server.socket.getsockname())
846
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
847
u" scope_id %d" % tcp_server.socket.getsockname())
1206
848
1207
849
#service.interface = tcp_server.socket.getsockname()[3]
1208
850
1218
860
1219
861
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1220
862
lambda *args, **kwargs:
1221
(tcp_server.handle_request
1222
(*args[2:], **kwargs) or True))
863
tcp_server.handle_request\
864
(*args[2:], **kwargs) or True)
1223
865
1224
866
logger.debug(u"Starting main loop")
867
main_loop_started = True
1225
868
main_loop.run()
1226
869
except AvahiError, error:
1227
logger.critical(u"AvahiError: %s", error)
870
logger.critical(u"AvahiError: %s" + unicode(error))
1228
871
sys.exit(1)
1229
872
except KeyboardInterrupt:
1230
873
if debug:
1231
print >> sys.stderr
1232
logger.debug("Server received KeyboardInterrupt")
1233
logger.debug("Server exiting")
874
print
1234
875
1235
876
if __name__ == '__main__':
1236
877
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0