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