44
15
import gnutls.library.functions
45
16
import gnutls.library.constants
46
17
import gnutls.library.types
47
import ConfigParser as configparser
56
import logging.handlers
62
import cPickle as pickle
63
import multiprocessing
69
31
from dbus.mainloop.glib import DBusGMainLoop
72
import xml.dom.minidom
76
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
77
except AttributeError:
79
from IN import SO_BINDTODEVICE
81
SO_BINDTODEVICE = None
86
logger = logging.getLogger(u'mandos')
87
syslogger = (logging.handlers.SysLogHandler
88
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
89
address = "/dev/log"))
90
syslogger.setFormatter(logging.Formatter
91
(u'Mandos [%(process)d]: %(levelname)s:'
35
import logging.handlers
37
logger = logging.Logger('mandos')
38
syslogger = logging.handlers.SysLogHandler\
39
(facility = logging.handlers.SysLogHandler.LOG_DAEMON)
40
syslogger.setFormatter(logging.Formatter\
41
('%(levelname)s: %(message)s'))
93
42
logger.addHandler(syslogger)
95
console = logging.StreamHandler()
96
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
99
logger.addHandler(console)
101
multiprocessing_manager = multiprocessing.Manager()
103
class AvahiError(Exception):
104
def __init__(self, value, *args, **kwargs):
106
super(AvahiError, self).__init__(value, *args, **kwargs)
107
def __unicode__(self):
108
return unicode(repr(self.value))
110
class AvahiServiceError(AvahiError):
113
class AvahiGroupError(AvahiError):
117
class AvahiService(object):
118
"""An Avahi (Zeroconf) service.
121
interface: integer; avahi.IF_UNSPEC or an interface index.
122
Used to optionally bind to the specified interface.
123
name: string; Example: u'Mandos'
124
type: string; Example: u'_mandos._tcp'.
125
See <http://www.dns-sd.org/ServiceTypes.html>
126
port: integer; what port to announce
127
TXT: list of strings; TXT record for the service
128
domain: string; Domain to publish on, default to .local if empty.
129
host: string; Host to publish records for, default is localhost
130
max_renames: integer; maximum number of renames
131
rename_count: integer; counter so we only rename after collisions
132
a sensible number of times
133
group: D-Bus Entry Group
135
bus: dbus.SystemBus()
137
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
138
servicetype = None, port = None, TXT = None,
139
domain = u"", host = u"", max_renames = 32768,
140
protocol = avahi.PROTO_UNSPEC, bus = None):
141
self.interface = interface
143
self.type = servicetype
145
self.TXT = TXT if TXT is not None else []
148
self.rename_count = 0
149
self.max_renames = max_renames
150
self.protocol = protocol
151
self.group = None # our entry group
155
"""Derived from the Avahi example code"""
156
if self.rename_count >= self.max_renames:
157
logger.critical(u"No suitable Zeroconf service name found"
158
u" after %i retries, exiting.",
160
raise AvahiServiceError(u"Too many renames")
161
self.name = self.server.GetAlternativeServiceName(self.name)
162
logger.info(u"Changing Zeroconf service name to %r ...",
164
syslogger.setFormatter(logging.Formatter
165
(u'Mandos (%s) [%%(process)d]:'
166
u' %%(levelname)s: %%(message)s'
170
self.rename_count += 1
172
"""Derived from the Avahi example code"""
173
if self.group is not None:
176
"""Derived from the Avahi example code"""
177
if self.group is None:
178
self.group = dbus.Interface(
179
self.bus.get_object(avahi.DBUS_NAME,
180
self.server.EntryGroupNew()),
181
avahi.DBUS_INTERFACE_ENTRY_GROUP)
182
self.group.connect_to_signal('StateChanged',
184
.entry_group_state_changed)
185
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
186
self.name, self.type)
187
self.group.AddService(
190
dbus.UInt32(0), # flags
191
self.name, self.type,
192
self.domain, self.host,
193
dbus.UInt16(self.port),
194
avahi.string_array_to_txt_array(self.TXT))
196
def entry_group_state_changed(self, state, error):
197
"""Derived from the Avahi example code"""
198
logger.debug(u"Avahi state change: %i", state)
200
if state == avahi.ENTRY_GROUP_ESTABLISHED:
201
logger.debug(u"Zeroconf service established.")
202
elif state == avahi.ENTRY_GROUP_COLLISION:
203
logger.warning(u"Zeroconf service name collision.")
205
elif state == avahi.ENTRY_GROUP_FAILURE:
206
logger.critical(u"Avahi: Error in group state changed %s",
208
raise AvahiGroupError(u"State changed: %s"
211
"""Derived from the Avahi example code"""
212
if self.group is not None:
215
def server_state_changed(self, state):
216
"""Derived from the Avahi example code"""
217
if state == avahi.SERVER_COLLISION:
218
logger.error(u"Zeroconf server name collision")
220
elif state == avahi.SERVER_RUNNING:
223
"""Derived from the Avahi example code"""
224
if self.server is None:
225
self.server = dbus.Interface(
226
self.bus.get_object(avahi.DBUS_NAME,
227
avahi.DBUS_PATH_SERVER),
228
avahi.DBUS_INTERFACE_SERVER)
229
self.server.connect_to_signal(u"StateChanged",
230
self.server_state_changed)
231
self.server_state_changed(self.server.GetState())
45
# This variable is used to optionally bind to a specified interface.
46
# It is a global variable to fit in with the other variables from the
47
# Avahi server example code.
48
serviceInterface = avahi.IF_UNSPEC
49
# From the Avahi server example code:
50
serviceName = "Mandos"
51
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
52
servicePort = None # Not known at startup
53
serviceTXT = [] # TXT record for the service
54
domain = "" # Domain to publish on, default to .local
55
host = "" # Host to publish records for, default to localhost
56
group = None #our entry group
57
rename_count = 12 # Counter so we only rename after collisions a
58
# sensible number of times
59
# End of Avahi example code
234
62
class Client(object):
235
63
"""A representation of a client host served by this server.
238
name: string; from the config file, used in log messages and
65
name: string; from the config file, used in log messages
240
66
fingerprint: string (40 or 32 hexadecimal digits); used to
241
67
uniquely identify the client
242
secret: bytestring; sent verbatim (over TLS) to client
243
host: string; available for use by the checker command
244
created: datetime.datetime(); (UTC) object creation
245
last_enabled: datetime.datetime(); (UTC)
247
last_checked_ok: datetime.datetime(); (UTC) or None
248
timeout: datetime.timedelta(); How long from last_checked_ok
249
until this client is disabled
250
interval: datetime.timedelta(); How often to start a new checker
251
disable_hook: If set, called by disable() as disable_hook(self)
252
checker: subprocess.Popen(); a running checker process used
253
to see if the client lives.
254
'None' if no process is running.
68
secret: bytestring; sent verbatim (over TLS) to client
69
fqdn: string (FQDN); available for use by the checker command
70
created: datetime.datetime()
71
last_seen: datetime.datetime() or None if not yet seen
72
timeout: datetime.timedelta(); How long from last_seen until
73
this client is invalid
74
interval: datetime.timedelta(); How often to start a new checker
75
stop_hook: If set, called by stop() as stop_hook(self)
76
checker: subprocess.Popen(); a running checker process used
77
to see if the client lives.
78
Is None if no process is running.
255
79
checker_initiator_tag: a gobject event source tag, or None
256
disable_initiator_tag: - '' -
80
stop_initiator_tag: - '' -
257
81
checker_callback_tag: - '' -
258
82
checker_command: string; External command which is run to check if
259
client lives. %() expansions are done at
83
client lives. %()s expansions are done at
260
84
runtime with vars(self) as dict, so that for
261
85
instance %(name)s can be used in the command.
262
current_checker_command: string; current running checker_command
263
approved_delay: datetime.timedelta(); Time to wait for approval
264
_approved: bool(); 'None' if not yet approved/disapproved
265
approved_duration: datetime.timedelta(); Duration of one approval
87
_timeout: Real variable for 'timeout'
88
_interval: Real variable for 'interval'
89
_timeout_milliseconds: Used by gobject.timeout_add()
90
_interval_milliseconds: - '' -
269
def _timedelta_to_milliseconds(td):
270
"Convert a datetime.timedelta() to milliseconds"
271
return ((td.days * 24 * 60 * 60 * 1000)
272
+ (td.seconds * 1000)
273
+ (td.microseconds // 1000))
275
def timeout_milliseconds(self):
276
"Return the 'timeout' attribute in milliseconds"
277
return self._timedelta_to_milliseconds(self.timeout)
279
def interval_milliseconds(self):
280
"Return the 'interval' attribute in milliseconds"
281
return self._timedelta_to_milliseconds(self.interval)
283
def approved_delay_milliseconds(self):
284
return self._timedelta_to_milliseconds(self.approved_delay)
286
def __init__(self, name = None, disable_hook=None, config=None):
287
"""Note: the 'checker' key in 'config' sets the
288
'checker_command' attribute and *not* the 'checker'
92
def _set_timeout(self, timeout):
93
"Setter function for 'timeout' attribute"
94
self._timeout = timeout
95
self._timeout_milliseconds = ((self.timeout.days
96
* 24 * 60 * 60 * 1000)
97
+ (self.timeout.seconds * 1000)
98
+ (self.timeout.microseconds
100
timeout = property(lambda self: self._timeout,
103
def _set_interval(self, interval):
104
"Setter function for 'interval' attribute"
105
self._interval = interval
106
self._interval_milliseconds = ((self.interval.days
107
* 24 * 60 * 60 * 1000)
108
+ (self.interval.seconds
110
+ (self.interval.microseconds
112
interval = property(lambda self: self._interval,
115
def __init__(self, name=None, options=None, stop_hook=None,
116
fingerprint=None, secret=None, secfile=None,
117
fqdn=None, timeout=None, interval=-1, checker=None):
293
logger.debug(u"Creating client %r", self.name)
294
# Uppercase and remove spaces from fingerprint for later
295
# comparison purposes with return value from the fingerprint()
297
self.fingerprint = (config[u"fingerprint"].upper()
299
logger.debug(u" Fingerprint: %s", self.fingerprint)
300
if u"secret" in config:
301
self.secret = config[u"secret"].decode(u"base64")
302
elif u"secfile" in config:
303
with open(os.path.expanduser(os.path.expandvars
304
(config[u"secfile"])),
306
self.secret = secfile.read()
308
#XXX Need to allow secret on demand!
309
raise TypeError(u"No secret or secfile for client %s"
311
self.host = config.get(u"host", u"")
312
self.created = datetime.datetime.utcnow()
314
self.last_enabled = None
315
self.last_checked_ok = None
316
self.timeout = string_to_delta(config[u"timeout"])
317
self.interval = string_to_delta(config[u"interval"])
318
self.disable_hook = disable_hook
119
# Uppercase and remove spaces from fingerprint
120
# for later comparison purposes with return value of
121
# the fingerprint() function
122
self.fingerprint = fingerprint.upper().replace(u" ", u"")
124
self.secret = secret.decode(u"base64")
127
self.secret = sf.read()
130
raise RuntimeError(u"No secret or secfile for client %s"
132
self.fqdn = fqdn # string
133
self.created = datetime.datetime.now()
134
self.last_seen = None
136
self.timeout = options.timeout
138
self.timeout = string_to_delta(timeout)
140
self.interval = options.interval
142
self.interval = string_to_delta(interval)
143
self.stop_hook = stop_hook
319
144
self.checker = None
320
145
self.checker_initiator_tag = None
321
self.disable_initiator_tag = None
146
self.stop_initiator_tag = None
322
147
self.checker_callback_tag = None
323
self.checker_command = config[u"checker"]
324
self.current_checker_command = None
325
self.last_connect = None
326
self.approvals_pending = 0
327
self._approved = None
328
self.approved_by_default = config.get(u"approved_by_default",
330
self.approved_delay = string_to_delta(
331
config[u"approved_delay"])
332
self.approved_duration = string_to_delta(
333
config[u"approved_duration"])
334
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
336
def send_changedstate(self):
337
self.changedstate.acquire()
338
self.changedstate.notify_all()
339
self.changedstate.release()
342
"""Start this client's checker and timeout hooks"""
343
if getattr(self, u"enabled", False):
346
self.send_changedstate()
347
self.last_enabled = datetime.datetime.utcnow()
148
self.check_command = checker
150
"""Start this clients checker and timeout hooks"""
348
151
# Schedule a new checker to be started an 'interval' from now,
349
152
# and every interval from then on.
350
self.checker_initiator_tag = (gobject.timeout_add
351
(self.interval_milliseconds(),
353
# Schedule a disable() when 'timeout' has passed
354
self.disable_initiator_tag = (gobject.timeout_add
355
(self.timeout_milliseconds(),
153
self.checker_initiator_tag = gobject.timeout_add\
154
(self._interval_milliseconds,
358
156
# Also start a new checker *right now*.
359
157
self.start_checker()
361
def disable(self, quiet=True):
362
"""Disable this client."""
363
if not getattr(self, "enabled", False):
366
self.send_changedstate()
368
logger.info(u"Disabling client %s", self.name)
369
if getattr(self, u"disable_initiator_tag", False):
370
gobject.source_remove(self.disable_initiator_tag)
371
self.disable_initiator_tag = None
372
if getattr(self, u"checker_initiator_tag", False):
158
# Schedule a stop() when 'timeout' has passed
159
self.stop_initiator_tag = gobject.timeout_add\
160
(self._timeout_milliseconds,
164
The possibility that this client might be restarted is left
165
open, but not currently used."""
166
logger.debug(u"Stopping client %s", self.name)
168
if self.stop_initiator_tag:
169
gobject.source_remove(self.stop_initiator_tag)
170
self.stop_initiator_tag = None
171
if self.checker_initiator_tag:
373
172
gobject.source_remove(self.checker_initiator_tag)
374
173
self.checker_initiator_tag = None
375
174
self.stop_checker()
376
if self.disable_hook:
377
self.disable_hook(self)
379
177
# Do not run this again if called by a gobject.timeout_add
382
179
def __del__(self):
383
self.disable_hook = None
386
def checker_callback(self, pid, condition, command):
180
# Some code duplication here and in stop()
181
if hasattr(self, "stop_initiator_tag") \
182
and self.stop_initiator_tag:
183
gobject.source_remove(self.stop_initiator_tag)
184
self.stop_initiator_tag = None
185
if hasattr(self, "checker_initiator_tag") \
186
and self.checker_initiator_tag:
187
gobject.source_remove(self.checker_initiator_tag)
188
self.checker_initiator_tag = None
190
def checker_callback(self, pid, condition):
387
191
"""The checker has completed, so take appropriate actions."""
388
self.checker_callback_tag = None
390
if os.WIFEXITED(condition):
391
exitstatus = os.WEXITSTATUS(condition)
393
logger.info(u"Checker for %(name)s succeeded",
397
logger.info(u"Checker for %(name)s failed",
192
now = datetime.datetime.now()
193
if os.WIFEXITED(condition) \
194
and (os.WEXITSTATUS(condition) == 0):
195
logger.debug(u"Checker for %(name)s succeeded",
198
gobject.source_remove(self.stop_initiator_tag)
199
self.stop_initiator_tag = gobject.timeout_add\
200
(self._timeout_milliseconds,
202
elif not os.WIFEXITED(condition):
400
203
logger.warning(u"Checker for %(name)s crashed?",
403
def checked_ok(self):
404
"""Bump up the timeout for this client.
406
This should only be called when the client has been seen,
409
self.last_checked_ok = datetime.datetime.utcnow()
410
gobject.source_remove(self.disable_initiator_tag)
411
self.disable_initiator_tag = (gobject.timeout_add
412
(self.timeout_milliseconds(),
206
logger.debug(u"Checker for %(name)s failed",
209
self.checker_callback_tag = None
415
210
def start_checker(self):
416
211
"""Start a new checker subprocess if one is not running.
418
212
If a checker already exists, leave it running and do
420
# The reason for not killing a running checker is that if we
421
# did that, then if a checker (for some reason) started
422
# running slowly and taking more than 'interval' time, the
423
# client would inevitably timeout, since no checker would get
424
# a chance to run to completion. If we instead leave running
425
# checkers alone, the checker would have to take more time
426
# than 'timeout' for the client to be disabled, which is as it
429
# If a checker exists, make sure it is not a zombie
431
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
432
except (AttributeError, OSError), error:
433
if (isinstance(error, OSError)
434
and error.errno != errno.ECHILD):
438
logger.warning(u"Checker was a zombie")
439
gobject.source_remove(self.checker_callback_tag)
440
self.checker_callback(pid, status,
441
self.current_checker_command)
442
# Start a new checker if needed
443
214
if self.checker is None:
445
# In case checker_command has exactly one % operator
446
command = self.checker_command % self.host
216
command = self.check_command % self.fqdn
447
217
except TypeError:
448
# Escape attributes for the shell
449
escaped_attrs = dict((key,
450
re.escape(unicode(str(val),
218
escaped_attrs = dict((key, re.escape(str(val)))
454
220
vars(self).iteritems())
456
command = self.checker_command % escaped_attrs
222
command = self.check_command % escaped_attrs
457
223
except TypeError, error:
458
logger.error(u'Could not format string "%s":'
459
u' %s', self.checker_command, error)
224
logger.critical(u'Could not format string "%s":'
225
u' %s', self.check_command, error)
460
226
return True # Try again later
461
self.current_checker_command = command
463
logger.info(u"Starting checker %r for %s",
465
# We don't need to redirect stdout and stderr, since
466
# in normal mode, that is already done by daemon(),
467
# and in debug mode we don't want to. (Stdin is
468
# always replaced by /dev/null.)
469
self.checker = subprocess.Popen(command,
471
shell=True, cwd=u"/")
472
self.checker_callback_tag = (gobject.child_watch_add
474
self.checker_callback,
476
# The checker may have completed before the gobject
477
# watch was added. Check for this.
478
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
480
gobject.source_remove(self.checker_callback_tag)
481
self.checker_callback(pid, status, command)
482
except OSError, error:
228
logger.debug(u"Starting checker %r for %s",
230
self.checker = subprocess.\
232
close_fds=True, shell=True,
234
self.checker_callback_tag = gobject.child_watch_add\
236
self.checker_callback)
237
except subprocess.OSError, error:
483
238
logger.error(u"Failed to start subprocess: %s",
485
240
# Re-run this periodically if run by gobject.timeout_add
488
242
def stop_checker(self):
489
243
"""Force the checker process, if any, to stop."""
490
if self.checker_callback_tag:
491
gobject.source_remove(self.checker_callback_tag)
492
self.checker_callback_tag = None
493
if getattr(self, u"checker", None) is None:
244
if not hasattr(self, "checker") or self.checker is None:
495
logger.debug(u"Stopping checker for %(name)s", vars(self))
497
os.kill(self.checker.pid, signal.SIGTERM)
499
#if self.checker.poll() is None:
500
# os.kill(self.checker.pid, signal.SIGKILL)
501
except OSError, error:
502
if error.errno != errno.ESRCH: # No such process
506
def dbus_service_property(dbus_interface, signature=u"v",
507
access=u"readwrite", byte_arrays=False):
508
"""Decorators for marking methods of a DBusObjectWithProperties to
509
become properties on the D-Bus.
511
The decorated method will be called with no arguments by "Get"
512
and with one argument by "Set".
514
The parameters, where they are supported, are the same as
515
dbus.service.method, except there is only "signature", since the
516
type from Get() and the type sent to Set() is the same.
518
# Encoding deeply encoded byte arrays is not supported yet by the
519
# "Set" method, so we fail early here:
520
if byte_arrays and signature != u"ay":
521
raise ValueError(u"Byte arrays not supported for non-'ay'"
522
u" signature %r" % signature)
524
func._dbus_is_property = True
525
func._dbus_interface = dbus_interface
526
func._dbus_signature = signature
527
func._dbus_access = access
528
func._dbus_name = func.__name__
529
if func._dbus_name.endswith(u"_dbus_property"):
530
func._dbus_name = func._dbus_name[:-14]
531
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
536
class DBusPropertyException(dbus.exceptions.DBusException):
537
"""A base class for D-Bus property-related exceptions
539
def __unicode__(self):
540
return unicode(str(self))
543
class DBusPropertyAccessException(DBusPropertyException):
544
"""A property's access permissions disallows an operation.
549
class DBusPropertyNotFound(DBusPropertyException):
550
"""An attempt was made to access a non-existing property.
555
class DBusObjectWithProperties(dbus.service.Object):
556
"""A D-Bus object with properties.
558
Classes inheriting from this can use the dbus_service_property
559
decorator to expose methods as D-Bus properties. It exposes the
560
standard Get(), Set(), and GetAll() methods on the D-Bus.
564
def _is_dbus_property(obj):
565
return getattr(obj, u"_dbus_is_property", False)
567
def _get_all_dbus_properties(self):
568
"""Returns a generator of (name, attribute) pairs
570
return ((prop._dbus_name, prop)
572
inspect.getmembers(self, self._is_dbus_property))
574
def _get_dbus_property(self, interface_name, property_name):
575
"""Returns a bound method if one exists which is a D-Bus
576
property with the specified name and interface.
578
for name in (property_name,
579
property_name + u"_dbus_property"):
580
prop = getattr(self, name, None)
582
or not self._is_dbus_property(prop)
583
or prop._dbus_name != property_name
584
or (interface_name and prop._dbus_interface
585
and interface_name != prop._dbus_interface)):
589
raise DBusPropertyNotFound(self.dbus_object_path + u":"
590
+ interface_name + u"."
593
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
595
def Get(self, interface_name, property_name):
596
"""Standard D-Bus property Get() method, see D-Bus standard.
598
prop = self._get_dbus_property(interface_name, property_name)
599
if prop._dbus_access == u"write":
600
raise DBusPropertyAccessException(property_name)
602
if not hasattr(value, u"variant_level"):
604
return type(value)(value, variant_level=value.variant_level+1)
606
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
607
def Set(self, interface_name, property_name, value):
608
"""Standard D-Bus property Set() method, see D-Bus standard.
610
prop = self._get_dbus_property(interface_name, property_name)
611
if prop._dbus_access == u"read":
612
raise DBusPropertyAccessException(property_name)
613
if prop._dbus_get_args_options[u"byte_arrays"]:
614
# The byte_arrays option is not supported yet on
615
# signatures other than "ay".
616
if prop._dbus_signature != u"ay":
618
value = dbus.ByteArray(''.join(unichr(byte)
622
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
623
out_signature=u"a{sv}")
624
def GetAll(self, interface_name):
625
"""Standard D-Bus property GetAll() method, see D-Bus
628
Note: Will not include properties with access="write".
631
for name, prop in self._get_all_dbus_properties():
633
and interface_name != prop._dbus_interface):
634
# Interface non-empty but did not match
636
# Ignore write-only properties
637
if prop._dbus_access == u"write":
640
if not hasattr(value, u"variant_level"):
643
all[name] = type(value)(value, variant_level=
644
value.variant_level+1)
645
return dbus.Dictionary(all, signature=u"sv")
647
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
649
path_keyword='object_path',
650
connection_keyword='connection')
651
def Introspect(self, object_path, connection):
652
"""Standard D-Bus method, overloaded to insert property tags.
654
xmlstring = dbus.service.Object.Introspect(self, object_path,
657
document = xml.dom.minidom.parseString(xmlstring)
658
def make_tag(document, name, prop):
659
e = document.createElement(u"property")
660
e.setAttribute(u"name", name)
661
e.setAttribute(u"type", prop._dbus_signature)
662
e.setAttribute(u"access", prop._dbus_access)
664
for if_tag in document.getElementsByTagName(u"interface"):
665
for tag in (make_tag(document, name, prop)
667
in self._get_all_dbus_properties()
668
if prop._dbus_interface
669
== if_tag.getAttribute(u"name")):
670
if_tag.appendChild(tag)
671
# Add the names to the return values for the
672
# "org.freedesktop.DBus.Properties" methods
673
if (if_tag.getAttribute(u"name")
674
== u"org.freedesktop.DBus.Properties"):
675
for cn in if_tag.getElementsByTagName(u"method"):
676
if cn.getAttribute(u"name") == u"Get":
677
for arg in cn.getElementsByTagName(u"arg"):
678
if (arg.getAttribute(u"direction")
680
arg.setAttribute(u"name", u"value")
681
elif cn.getAttribute(u"name") == u"GetAll":
682
for arg in cn.getElementsByTagName(u"arg"):
683
if (arg.getAttribute(u"direction")
685
arg.setAttribute(u"name", u"props")
686
xmlstring = document.toxml(u"utf-8")
688
except (AttributeError, xml.dom.DOMException,
689
xml.parsers.expat.ExpatError), error:
690
logger.error(u"Failed to override Introspection method",
695
class ClientDBus(Client, DBusObjectWithProperties):
696
"""A Client class using D-Bus
699
dbus_object_path: dbus.ObjectPath
700
bus: dbus.SystemBus()
702
# dbus.service.Object doesn't use super(), so we can't either.
704
def __init__(self, bus = None, *args, **kwargs):
705
self._approvals_pending = 0
707
Client.__init__(self, *args, **kwargs)
708
# Only now, when this client is initialized, can it show up on
710
self.dbus_object_path = (dbus.ObjectPath
712
+ self.name.replace(u".", u"_")))
713
DBusObjectWithProperties.__init__(self, self.bus,
714
self.dbus_object_path)
716
def _get_approvals_pending(value):
717
return self._approvals_pending
718
def _set_approvals_pending(value):
719
old_value = self._approvals_pending
720
self._approvals_pending = value
722
if bval is bool(old_value):
723
dbus_bool = dbus.Boolean(bval, variant_level=1)
724
self.PropertyChanged(dbus.String(u"approved_pending"),
727
approvals_pending = property(_get_approvals_pending,
728
_set_approvals_pending)
729
del _get_approvals_pending, _set_approvals_pending
732
def _datetime_to_dbus(dt, variant_level=0):
733
"""Convert a UTC datetime.datetime() to a D-Bus type."""
734
return dbus.String(dt.isoformat(),
735
variant_level=variant_level)
738
oldstate = getattr(self, u"enabled", False)
739
r = Client.enable(self)
740
if oldstate != self.enabled:
742
self.PropertyChanged(dbus.String(u"enabled"),
743
dbus.Boolean(True, variant_level=1))
744
self.PropertyChanged(
745
dbus.String(u"last_enabled"),
746
self._datetime_to_dbus(self.last_enabled,
750
def disable(self, quiet = False):
751
oldstate = getattr(self, u"enabled", False)
752
r = Client.disable(self, quiet=quiet)
753
if not quiet and oldstate != self.enabled:
755
self.PropertyChanged(dbus.String(u"enabled"),
756
dbus.Boolean(False, variant_level=1))
759
def __del__(self, *args, **kwargs):
761
self.remove_from_connection()
764
if hasattr(DBusObjectWithProperties, u"__del__"):
765
DBusObjectWithProperties.__del__(self, *args, **kwargs)
766
Client.__del__(self, *args, **kwargs)
768
def checker_callback(self, pid, condition, command,
246
gobject.source_remove(self.checker_callback_tag)
770
247
self.checker_callback_tag = None
248
os.kill(self.checker.pid, signal.SIGTERM)
249
if self.checker.poll() is None:
250
os.kill(self.checker.pid, signal.SIGKILL)
771
251
self.checker = None
773
self.PropertyChanged(dbus.String(u"checker_running"),
774
dbus.Boolean(False, variant_level=1))
775
if os.WIFEXITED(condition):
776
exitstatus = os.WEXITSTATUS(condition)
778
self.CheckerCompleted(dbus.Int16(exitstatus),
779
dbus.Int64(condition),
780
dbus.String(command))
783
self.CheckerCompleted(dbus.Int16(-1),
784
dbus.Int64(condition),
785
dbus.String(command))
787
return Client.checker_callback(self, pid, condition, command,
790
def checked_ok(self, *args, **kwargs):
791
r = Client.checked_ok(self, *args, **kwargs)
793
self.PropertyChanged(
794
dbus.String(u"last_checked_ok"),
795
(self._datetime_to_dbus(self.last_checked_ok,
799
def start_checker(self, *args, **kwargs):
800
old_checker = self.checker
801
if self.checker is not None:
802
old_checker_pid = self.checker.pid
804
old_checker_pid = None
805
r = Client.start_checker(self, *args, **kwargs)
806
# Only if new checker process was started
807
if (self.checker is not None
808
and old_checker_pid != self.checker.pid):
810
self.CheckerStarted(self.current_checker_command)
811
self.PropertyChanged(
812
dbus.String(u"checker_running"),
813
dbus.Boolean(True, variant_level=1))
816
def stop_checker(self, *args, **kwargs):
817
old_checker = getattr(self, u"checker", None)
818
r = Client.stop_checker(self, *args, **kwargs)
819
if (old_checker is not None
820
and getattr(self, u"checker", None) is None):
821
self.PropertyChanged(dbus.String(u"checker_running"),
822
dbus.Boolean(False, variant_level=1))
825
def _reset_approved(self):
826
self._approved = None
829
def approve(self, value=True):
830
self._approved = value
831
gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration, self._reset_approved))
834
## D-Bus methods, signals & properties
835
_interface = u"se.bsnet.fukt.Mandos.Client"
839
# CheckerCompleted - signal
840
@dbus.service.signal(_interface, signature=u"nxs")
841
def CheckerCompleted(self, exitcode, waitstatus, command):
845
# CheckerStarted - signal
846
@dbus.service.signal(_interface, signature=u"s")
847
def CheckerStarted(self, command):
851
# PropertyChanged - signal
852
@dbus.service.signal(_interface, signature=u"sv")
853
def PropertyChanged(self, property, value):
858
@dbus.service.signal(_interface)
864
@dbus.service.signal(_interface, signature=u"s")
865
def Rejected(self, reason):
869
# NeedApproval - signal
870
@dbus.service.signal(_interface, signature=u"db")
871
def NeedApproval(self, timeout, default):
878
@dbus.service.method(_interface, in_signature=u"b")
879
def Approve(self, value):
883
@dbus.service.method(_interface)
885
return self.checked_ok()
888
@dbus.service.method(_interface)
893
# StartChecker - method
894
@dbus.service.method(_interface)
895
def StartChecker(self):
900
@dbus.service.method(_interface)
905
# StopChecker - method
906
@dbus.service.method(_interface)
907
def StopChecker(self):
912
# approved_pending - property
913
@dbus_service_property(_interface, signature=u"b", access=u"read")
914
def approved_pending_dbus_property(self):
915
return dbus.Boolean(bool(self.approvals_pending))
917
# approved_by_default - property
918
@dbus_service_property(_interface, signature=u"b",
920
def approved_by_default_dbus_property(self):
921
return dbus.Boolean(self.approved_by_default)
923
# approved_delay - property
924
@dbus_service_property(_interface, signature=u"t",
926
def approved_delay_dbus_property(self):
927
return dbus.UInt64(self.approved_delay_milliseconds())
929
# approved_duration - property
930
@dbus_service_property(_interface, signature=u"t",
932
def approved_duration_dbus_property(self):
933
return dbus.UInt64(self._timedelta_to_milliseconds(
934
self.approved_duration))
937
@dbus_service_property(_interface, signature=u"s", access=u"read")
938
def name_dbus_property(self):
939
return dbus.String(self.name)
941
# fingerprint - property
942
@dbus_service_property(_interface, signature=u"s", access=u"read")
943
def fingerprint_dbus_property(self):
944
return dbus.String(self.fingerprint)
947
@dbus_service_property(_interface, signature=u"s",
949
def host_dbus_property(self, value=None):
950
if value is None: # get
951
return dbus.String(self.host)
954
self.PropertyChanged(dbus.String(u"host"),
955
dbus.String(value, variant_level=1))
958
@dbus_service_property(_interface, signature=u"s", access=u"read")
959
def created_dbus_property(self):
960
return dbus.String(self._datetime_to_dbus(self.created))
962
# last_enabled - property
963
@dbus_service_property(_interface, signature=u"s", access=u"read")
964
def last_enabled_dbus_property(self):
965
if self.last_enabled is None:
966
return dbus.String(u"")
967
return dbus.String(self._datetime_to_dbus(self.last_enabled))
970
@dbus_service_property(_interface, signature=u"b",
972
def enabled_dbus_property(self, value=None):
973
if value is None: # get
974
return dbus.Boolean(self.enabled)
980
# last_checked_ok - property
981
@dbus_service_property(_interface, signature=u"s",
983
def last_checked_ok_dbus_property(self, value=None):
984
if value is not None:
987
if self.last_checked_ok is None:
988
return dbus.String(u"")
989
return dbus.String(self._datetime_to_dbus(self
993
@dbus_service_property(_interface, signature=u"t",
995
def timeout_dbus_property(self, value=None):
996
if value is None: # get
997
return dbus.UInt64(self.timeout_milliseconds())
998
self.timeout = datetime.timedelta(0, 0, 0, value)
1000
self.PropertyChanged(dbus.String(u"timeout"),
1001
dbus.UInt64(value, variant_level=1))
1002
if getattr(self, u"disable_initiator_tag", None) is None:
1004
# Reschedule timeout
1005
gobject.source_remove(self.disable_initiator_tag)
1006
self.disable_initiator_tag = None
1007
time_to_die = (self.
1008
_timedelta_to_milliseconds((self
1013
if time_to_die <= 0:
1014
# The timeout has passed
1017
self.disable_initiator_tag = (gobject.timeout_add
1018
(time_to_die, self.disable))
1020
# interval - property
1021
@dbus_service_property(_interface, signature=u"t",
1022
access=u"readwrite")
1023
def interval_dbus_property(self, value=None):
1024
if value is None: # get
1025
return dbus.UInt64(self.interval_milliseconds())
1026
self.interval = datetime.timedelta(0, 0, 0, value)
1028
self.PropertyChanged(dbus.String(u"interval"),
1029
dbus.UInt64(value, variant_level=1))
1030
if getattr(self, u"checker_initiator_tag", None) is None:
1032
# Reschedule checker run
1033
gobject.source_remove(self.checker_initiator_tag)
1034
self.checker_initiator_tag = (gobject.timeout_add
1035
(value, self.start_checker))
1036
self.start_checker() # Start one now, too
1038
# checker - property
1039
@dbus_service_property(_interface, signature=u"s",
1040
access=u"readwrite")
1041
def checker_dbus_property(self, value=None):
1042
if value is None: # get
1043
return dbus.String(self.checker_command)
1044
self.checker_command = value
1046
self.PropertyChanged(dbus.String(u"checker"),
1047
dbus.String(self.checker_command,
1050
# checker_running - property
1051
@dbus_service_property(_interface, signature=u"b",
1052
access=u"readwrite")
1053
def checker_running_dbus_property(self, value=None):
1054
if value is None: # get
1055
return dbus.Boolean(self.checker is not None)
1057
self.start_checker()
1061
# object_path - property
1062
@dbus_service_property(_interface, signature=u"o", access=u"read")
1063
def object_path_dbus_property(self):
1064
return self.dbus_object_path # is already a dbus.ObjectPath
1067
@dbus_service_property(_interface, signature=u"ay",
1068
access=u"write", byte_arrays=True)
1069
def secret_dbus_property(self, value):
1070
self.secret = str(value)
1075
class ProxyClient(object):
1076
def __init__(self, child_pipe, fpr, address):
1077
self._pipe = child_pipe
1078
self._pipe.send(('init', fpr, address))
1079
if not self._pipe.recv():
1082
def __getattribute__(self, name):
1083
if(name == '_pipe'):
1084
return super(ProxyClient, self).__getattribute__(name)
1085
self._pipe.send(('getattr', name))
1086
data = self._pipe.recv()
1087
if data[0] == 'data':
1089
if data[0] == 'function':
1090
def func(*args, **kwargs):
1091
self._pipe.send(('funcall', name, args, kwargs))
1092
return self._pipe.recv()[1]
1095
def __setattr__(self, name, value):
1096
if(name == '_pipe'):
1097
return super(ProxyClient, self).__setattr__(name, value)
1098
self._pipe.send(('setattr', name, value))
1101
class ClientHandler(socketserver.BaseRequestHandler, object):
1102
"""A class to handle client connections.
1104
Instantiated once for each connection to handle it.
252
def still_valid(self, now=None):
253
"""Has the timeout not yet passed for this client?"""
255
now = datetime.datetime.now()
256
if self.last_seen is None:
257
return now < (self.created + self.timeout)
259
return now < (self.last_seen + self.timeout)
262
def peer_certificate(session):
263
"Return an OpenPGP data packet string for the peer's certificate"
264
# If not an OpenPGP certificate...
265
if gnutls.library.functions.gnutls_certificate_type_get\
266
(session._c_object) \
267
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
268
# ...do the normal thing
269
return session.peer_certificate
270
list_size = ctypes.c_uint()
271
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
272
(session._c_object, ctypes.byref(list_size))
273
if list_size.value == 0:
276
return ctypes.string_at(cert.data, cert.size)
279
def fingerprint(openpgp):
280
"Convert an OpenPGP data string to a hexdigit fingerprint string"
281
# New empty GnuTLS certificate
282
crt = gnutls.library.types.gnutls_openpgp_crt_t()
283
gnutls.library.functions.gnutls_openpgp_crt_init\
285
# New GnuTLS "datum" with the OpenPGP public key
286
datum = gnutls.library.types.gnutls_datum_t\
287
(ctypes.cast(ctypes.c_char_p(openpgp),
288
ctypes.POINTER(ctypes.c_ubyte)),
289
ctypes.c_uint(len(openpgp)))
290
# Import the OpenPGP public key into the certificate
291
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
294
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
295
# New buffer for the fingerprint
296
buffer = ctypes.create_string_buffer(20)
297
buffer_length = ctypes.c_size_t()
298
# Get the fingerprint from the certificate into the buffer
299
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
300
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
301
# Deinit the certificate
302
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
303
# Convert the buffer to a Python bytestring
304
fpr = ctypes.string_at(buffer, buffer_length.value)
305
# Convert the bytestring to hexadecimal notation
306
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
310
class tcp_handler(SocketServer.BaseRequestHandler, object):
311
"""A TCP request handler class.
312
Instantiated by IPv6_TCPServer for each request to handle it.
1105
313
Note: This will run in its own forked process."""
1107
315
def handle(self):
1108
with contextlib.closing(self.server.child_pipe) as child_pipe:
1109
logger.info(u"TCP connection from: %s",
1110
unicode(self.client_address))
1111
logger.debug(u"Pipe FD: %d",
1112
self.server.child_pipe.fileno())
1114
session = (gnutls.connection
1115
.ClientSession(self.request,
1117
.X509Credentials()))
1119
# Note: gnutls.connection.X509Credentials is really a
1120
# generic GnuTLS certificate credentials object so long as
1121
# no X.509 keys are added to it. Therefore, we can use it
1122
# here despite using OpenPGP certificates.
1124
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1125
# u"+AES-256-CBC", u"+SHA1",
1126
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1128
# Use a fallback default, since this MUST be set.
1129
priority = self.server.gnutls_priority
1130
if priority is None:
1131
priority = u"NORMAL"
1132
(gnutls.library.functions
1133
.gnutls_priority_set_direct(session._c_object,
1136
# Start communication using the Mandos protocol
1137
# Get protocol number
1138
line = self.request.makefile().readline()
1139
logger.debug(u"Protocol version: %r", line)
1141
if int(line.strip().split()[0]) > 1:
1143
except (ValueError, IndexError, RuntimeError), error:
1144
logger.error(u"Unknown protocol version: %s", error)
1147
# Start GnuTLS connection
1150
except gnutls.errors.GNUTLSError, error:
1151
logger.warning(u"Handshake failed: %s", error)
1152
# Do not run session.bye() here: the session is not
1153
# established. Just abandon the request.
1155
logger.debug(u"Handshake succeeded")
1157
approval_required = False
1160
fpr = self.fingerprint(self.peer_certificate
1162
except (TypeError, gnutls.errors.GNUTLSError), error:
1163
logger.warning(u"Bad certificate: %s", error)
1165
logger.debug(u"Fingerprint: %s", fpr)
1168
client = ProxyClient(child_pipe, fpr,
1169
self.client_address)
1173
if client.approved_delay:
1174
delay = client.approved_delay
1175
client.approvals_pending += 1
1176
approval_required = True
1179
if not client.enabled:
1180
logger.warning(u"Client %s is disabled",
1182
if self.server.use_dbus:
1184
client.Rejected("Disabled")
1187
if client._approved or not client.approved_delay:
1188
#We are approved or approval is disabled
1190
elif client._approved is None:
1191
logger.info(u"Client %s need approval",
1193
if self.server.use_dbus:
1195
client.NeedApproval(
1196
client.approved_delay_milliseconds(),
1197
client.approved_by_default)
1199
logger.warning(u"Client %s was not approved",
1201
if self.server.use_dbus:
1203
client.Rejected("Disapproved")
1206
#wait until timeout or approved
1207
#x = float(client._timedelta_to_milliseconds(delay))
1208
time = datetime.datetime.now()
1209
client.changedstate.acquire()
1210
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1211
client.changedstate.release()
1212
time2 = datetime.datetime.now()
1213
if (time2 - time) >= delay:
1214
if not client.approved_by_default:
1215
logger.warning("Client %s timed out while"
1216
" waiting for approval",
1218
if self.server.use_dbus:
1220
client.Rejected("Time out")
1225
delay -= time2 - time
1228
while sent_size < len(client.secret):
1229
# XXX handle session exception
1230
sent = session.send(client.secret[sent_size:])
1231
logger.debug(u"Sent: %d, remaining: %d",
1232
sent, len(client.secret)
1233
- (sent_size + sent))
1236
logger.info(u"Sending secret to %s", client.name)
1237
# bump the timeout as if seen
1239
if self.server.use_dbus:
1244
if approval_required:
1245
client.approvals_pending -= 1
1249
def peer_certificate(session):
1250
"Return the peer's OpenPGP certificate as a bytestring"
1251
# If not an OpenPGP certificate...
1252
if (gnutls.library.functions
1253
.gnutls_certificate_type_get(session._c_object)
1254
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1255
# ...do the normal thing
1256
return session.peer_certificate
1257
list_size = ctypes.c_uint(1)
1258
cert_list = (gnutls.library.functions
1259
.gnutls_certificate_get_peers
1260
(session._c_object, ctypes.byref(list_size)))
1261
if not bool(cert_list) and list_size.value != 0:
1262
raise gnutls.errors.GNUTLSError(u"error getting peer"
1264
if list_size.value == 0:
1267
return ctypes.string_at(cert.data, cert.size)
1270
def fingerprint(openpgp):
1271
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1272
# New GnuTLS "datum" with the OpenPGP public key
1273
datum = (gnutls.library.types
1274
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1277
ctypes.c_uint(len(openpgp))))
1278
# New empty GnuTLS certificate
1279
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1280
(gnutls.library.functions
1281
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1282
# Import the OpenPGP public key into the certificate
1283
(gnutls.library.functions
1284
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1285
gnutls.library.constants
1286
.GNUTLS_OPENPGP_FMT_RAW))
1287
# Verify the self signature in the key
1288
crtverify = ctypes.c_uint()
1289
(gnutls.library.functions
1290
.gnutls_openpgp_crt_verify_self(crt, 0,
1291
ctypes.byref(crtverify)))
1292
if crtverify.value != 0:
1293
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1294
raise (gnutls.errors.CertificateSecurityError
1296
# New buffer for the fingerprint
1297
buf = ctypes.create_string_buffer(20)
1298
buf_len = ctypes.c_size_t()
1299
# Get the fingerprint from the certificate into the buffer
1300
(gnutls.library.functions
1301
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1302
ctypes.byref(buf_len)))
1303
# Deinit the certificate
1304
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1305
# Convert the buffer to a Python bytestring
1306
fpr = ctypes.string_at(buf, buf_len.value)
1307
# Convert the bytestring to hexadecimal notation
1308
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1312
class MultiprocessingMixIn(object):
1313
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1314
def sub_process_main(self, request, address):
1316
self.finish_request(request, address)
1318
self.handle_error(request, address)
1319
self.close_request(request)
1321
def process_request(self, request, address):
1322
"""Start a new process to process the request."""
1323
multiprocessing.Process(target = self.sub_process_main,
1324
args = (request, address)).start()
1326
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1327
""" adds a pipe to the MixIn """
1328
def process_request(self, request, client_address):
1329
"""Overrides and wraps the original process_request().
1331
This function creates a new pipe in self.pipe
1333
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1335
super(MultiprocessingMixInWithPipe,
1336
self).process_request(request, client_address)
1337
self.add_pipe(parent_pipe)
1338
def add_pipe(self, parent_pipe):
1339
"""Dummy function; override as necessary"""
1342
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1343
socketserver.TCPServer, object):
1344
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
316
logger.debug(u"TCP connection from: %s",
317
unicode(self.client_address))
318
session = gnutls.connection.ClientSession(self.request,
322
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
323
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
325
priority = "SECURE256"
327
gnutls.library.functions.gnutls_priority_set_direct\
328
(session._c_object, priority, None);
332
except gnutls.errors.GNUTLSError, error:
333
logger.debug(u"Handshake failed: %s", error)
334
# Do not run session.bye() here: the session is not
335
# established. Just abandon the request.
338
fpr = fingerprint(peer_certificate(session))
339
except (TypeError, gnutls.errors.GNUTLSError), error:
340
logger.debug(u"Bad certificate: %s", error)
343
logger.debug(u"Fingerprint: %s", fpr)
346
if c.fingerprint == fpr:
349
# Have to check if client.still_valid(), since it is possible
350
# that the client timed out while establishing the GnuTLS
352
if (not client) or (not client.still_valid()):
354
logger.debug(u"Client %(name)s is invalid",
357
logger.debug(u"Client not found for fingerprint: %s",
362
while sent_size < len(client.secret):
363
sent = session.send(client.secret[sent_size:])
364
logger.debug(u"Sent: %d, remaining: %d",
365
sent, len(client.secret)
366
- (sent_size + sent))
371
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
372
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1347
enabled: Boolean; whether this server is activated yet
1348
interface: None or a network interface name (string)
1349
use_ipv6: Boolean; to use IPv6 or not
374
options: Command line options
375
clients: Set() of Client objects
1351
def __init__(self, server_address, RequestHandlerClass,
1352
interface=None, use_ipv6=True):
1353
self.interface = interface
1355
self.address_family = socket.AF_INET6
1356
socketserver.TCPServer.__init__(self, server_address,
1357
RequestHandlerClass)
377
address_family = socket.AF_INET6
378
def __init__(self, *args, **kwargs):
379
if "options" in kwargs:
380
self.options = kwargs["options"]
381
del kwargs["options"]
382
if "clients" in kwargs:
383
self.clients = kwargs["clients"]
384
del kwargs["clients"]
385
return super(type(self), self).__init__(*args, **kwargs)
1358
386
def server_bind(self):
1359
387
"""This overrides the normal server_bind() function
1360
388
to bind to an interface if one was specified, and also NOT to
1361
389
bind to an address or port if they were not specified."""
1362
if self.interface is not None:
1363
if SO_BINDTODEVICE is None:
1364
logger.error(u"SO_BINDTODEVICE does not exist;"
1365
u" cannot bind to interface %s",
1369
self.socket.setsockopt(socket.SOL_SOCKET,
1373
except socket.error, error:
1374
if error[0] == errno.EPERM:
1375
logger.error(u"No permission to"
1376
u" bind to interface %s",
1378
elif error[0] == errno.ENOPROTOOPT:
1379
logger.error(u"SO_BINDTODEVICE not available;"
1380
u" cannot bind to interface %s",
390
if self.options.interface:
391
if not hasattr(socket, "SO_BINDTODEVICE"):
392
# From /usr/include/asm-i486/socket.h
393
socket.SO_BINDTODEVICE = 25
395
self.socket.setsockopt(socket.SOL_SOCKET,
396
socket.SO_BINDTODEVICE,
397
self.options.interface)
398
except socket.error, error:
399
if error[0] == errno.EPERM:
400
logger.warning(u"No permission to"
401
u" bind to interface %s",
402
self.options.interface)
1384
405
# Only bind(2) the socket if we really need to.
1385
406
if self.server_address[0] or self.server_address[1]:
1386
407
if not self.server_address[0]:
1387
if self.address_family == socket.AF_INET6:
1388
any_address = u"::" # in6addr_any
1390
any_address = socket.INADDR_ANY
1391
self.server_address = (any_address,
409
self.server_address = (in6addr_any,
1392
410
self.server_address[1])
1393
elif not self.server_address[1]:
411
elif self.server_address[1] is None:
1394
412
self.server_address = (self.server_address[0],
1396
# if self.interface:
1397
# self.server_address = (self.server_address[0],
1402
return socketserver.TCPServer.server_bind(self)
1405
class MandosServer(IPv6_TCPServer):
1409
clients: set of Client objects
1410
gnutls_priority GnuTLS priority string
1411
use_dbus: Boolean; to emit D-Bus signals or not
1413
Assumes a gobject.MainLoop event loop.
1415
def __init__(self, server_address, RequestHandlerClass,
1416
interface=None, use_ipv6=True, clients=None,
1417
gnutls_priority=None, use_dbus=True):
1418
self.enabled = False
1419
self.clients = clients
1420
if self.clients is None:
1421
self.clients = set()
1422
self.use_dbus = use_dbus
1423
self.gnutls_priority = gnutls_priority
1424
IPv6_TCPServer.__init__(self, server_address,
1425
RequestHandlerClass,
1426
interface = interface,
1427
use_ipv6 = use_ipv6)
1428
def server_activate(self):
1430
return socketserver.TCPServer.server_activate(self)
1433
def add_pipe(self, parent_pipe):
1434
# Call "handle_ipc" for both data and EOF events
1435
gobject.io_add_watch(parent_pipe.fileno(),
1436
gobject.IO_IN | gobject.IO_HUP,
1437
functools.partial(self.handle_ipc,
1438
parent_pipe = parent_pipe))
1440
def handle_ipc(self, source, condition, parent_pipe=None,
1441
client_object=None):
1443
gobject.IO_IN: u"IN", # There is data to read.
1444
gobject.IO_OUT: u"OUT", # Data can be written (without
1446
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1447
gobject.IO_ERR: u"ERR", # Error condition.
1448
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1449
# broken, usually for pipes and
1452
conditions_string = ' | '.join(name
1454
condition_names.iteritems()
1455
if cond & condition)
1456
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1459
# Read a request from the child
1460
request = parent_pipe.recv()
1461
command = request[0]
1463
if command == 'init':
1465
address = request[2]
1467
for c in self.clients:
1468
if c.fingerprint == fpr:
1472
logger.warning(u"Client not found for fingerprint: %s, ad"
1473
u"dress: %s", fpr, address)
1476
mandos_dbus_service.ClientNotFound(fpr, address)
1477
parent_pipe.send(False)
1480
gobject.io_add_watch(parent_pipe.fileno(),
1481
gobject.IO_IN | gobject.IO_HUP,
1482
functools.partial(self.handle_ipc,
1483
parent_pipe = parent_pipe,
1484
client_object = client))
1485
parent_pipe.send(True)
1486
# remove the old hook in favor of the new above hook on same fileno
1488
if command == 'funcall':
1489
funcname = request[1]
1493
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1495
if command == 'getattr':
1496
attrname = request[1]
1497
if callable(client_object.__getattribute__(attrname)):
1498
parent_pipe.send(('function',))
1500
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1502
if command == 'setattr':
1503
attrname = request[1]
1505
setattr(client_object, attrname, value)
414
return super(type(self), self).server_bind()
1510
417
def string_to_delta(interval):
1511
418
"""Parse a string and return a datetime.timedelta
1513
>>> string_to_delta(u'7d')
420
>>> string_to_delta('7d')
1514
421
datetime.timedelta(7)
1515
>>> string_to_delta(u'60s')
422
>>> string_to_delta('60s')
1516
423
datetime.timedelta(0, 60)
1517
>>> string_to_delta(u'60m')
424
>>> string_to_delta('60m')
1518
425
datetime.timedelta(0, 3600)
1519
>>> string_to_delta(u'24h')
426
>>> string_to_delta('24h')
1520
427
datetime.timedelta(1)
1521
428
>>> string_to_delta(u'1w')
1522
429
datetime.timedelta(7)
1523
>>> string_to_delta(u'5m 30s')
1524
datetime.timedelta(0, 330)
1526
timevalue = datetime.timedelta(0)
1527
for s in interval.split():
1529
suffix = unicode(s[-1])
1532
delta = datetime.timedelta(value)
1533
elif suffix == u"s":
1534
delta = datetime.timedelta(0, value)
1535
elif suffix == u"m":
1536
delta = datetime.timedelta(0, 0, 0, 0, value)
1537
elif suffix == u"h":
1538
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1539
elif suffix == u"w":
1540
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1542
raise ValueError(u"Unknown suffix %r" % suffix)
1543
except (ValueError, IndexError), e:
1544
raise ValueError(e.message)
432
suffix=unicode(interval[-1])
433
value=int(interval[:-1])
435
delta = datetime.timedelta(value)
437
delta = datetime.timedelta(0, value)
439
delta = datetime.timedelta(0, 0, 0, 0, value)
441
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
443
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
446
except (ValueError, IndexError):
452
"""From the Avahi server example code"""
453
global group, serviceName, serviceType, servicePort, serviceTXT, \
456
group = dbus.Interface(
457
bus.get_object( avahi.DBUS_NAME,
458
server.EntryGroupNew()),
459
avahi.DBUS_INTERFACE_ENTRY_GROUP)
460
group.connect_to_signal('StateChanged',
461
entry_group_state_changed)
462
logger.debug(u"Adding service '%s' of type '%s' ...",
463
serviceName, serviceType)
466
serviceInterface, # interface
467
avahi.PROTO_INET6, # protocol
468
dbus.UInt32(0), # flags
469
serviceName, serviceType,
471
dbus.UInt16(servicePort),
472
avahi.string_array_to_txt_array(serviceTXT))
476
def remove_service():
477
"""From the Avahi server example code"""
480
if not group is None:
484
def server_state_changed(state):
485
"""From the Avahi server example code"""
486
if state == avahi.SERVER_COLLISION:
487
logger.warning(u"Server name collision")
489
elif state == avahi.SERVER_RUNNING:
493
def entry_group_state_changed(state, error):
494
"""From the Avahi server example code"""
495
global serviceName, server, rename_count
497
logger.debug(u"state change: %i", state)
499
if state == avahi.ENTRY_GROUP_ESTABLISHED:
500
logger.debug(u"Service established.")
501
elif state == avahi.ENTRY_GROUP_COLLISION:
503
rename_count = rename_count - 1
505
name = server.GetAlternativeServiceName(name)
506
logger.warning(u"Service name collision, "
507
u"changing name to '%s' ...", name)
512
logger.error(u"No suitable service name found after %i"
513
u" retries, exiting.", n_rename)
515
elif state == avahi.ENTRY_GROUP_FAILURE:
516
logger.error(u"Error in group state changed %s",
1549
521
def if_nametoindex(interface):
1550
"""Call the C function if_nametoindex(), or equivalent
1552
Note: This function cannot accept a unicode string."""
1553
global if_nametoindex
522
"""Call the C function if_nametoindex()"""
1555
if_nametoindex = (ctypes.cdll.LoadLibrary
1556
(ctypes.util.find_library(u"c"))
524
libc = ctypes.cdll.LoadLibrary("libc.so.6")
525
return libc.if_nametoindex(interface)
1558
526
except (OSError, AttributeError):
1559
logger.warning(u"Doing if_nametoindex the hard way")
1560
def if_nametoindex(interface):
1561
"Get an interface index the hard way, i.e. using fcntl()"
1562
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1563
with contextlib.closing(socket.socket()) as s:
1564
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1565
struct.pack(str(u"16s16x"),
1567
interface_index = struct.unpack(str(u"I"),
1569
return interface_index
1570
return if_nametoindex(interface)
1573
def daemon(nochdir = False, noclose = False):
527
if "struct" not in sys.modules:
529
if "fcntl" not in sys.modules:
531
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
533
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
534
struct.pack("16s16x", interface))
536
interface_index = struct.unpack("I", ifreq[16:20])[0]
537
return interface_index
540
def daemon(nochdir, noclose):
1574
541
"""See daemon(3). Standard BSD Unix function.
1576
542
This should really exist as os.daemon, but it doesn't (yet)."""
1585
549
# Close all standard open file descriptors
1586
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
550
null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)
1587
551
if not stat.S_ISCHR(os.fstat(null).st_mode):
1588
552
raise OSError(errno.ENODEV,
1589
u"%s not a character device"
553
"/dev/null not a character device")
1591
554
os.dup2(null, sys.stdin.fileno())
1592
555
os.dup2(null, sys.stdout.fileno())
1593
556
os.dup2(null, sys.stderr.fileno())
1600
##################################################################
1601
# Parsing of options, both command line and config file
1603
parser = optparse.OptionParser(version = "%%prog %s" % version)
1604
parser.add_option("-i", u"--interface", type=u"string",
1605
metavar="IF", help=u"Bind to interface IF")
1606
parser.add_option("-a", u"--address", type=u"string",
1607
help=u"Address to listen for requests on")
1608
parser.add_option("-p", u"--port", type=u"int",
1609
help=u"Port number to receive requests on")
1610
parser.add_option("--check", action=u"store_true",
1611
help=u"Run self-test")
1612
parser.add_option("--debug", action=u"store_true",
1613
help=u"Debug mode; run in foreground and log to"
1615
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1616
u" priority string (see GnuTLS documentation)")
1617
parser.add_option("--servicename", type=u"string",
1618
metavar=u"NAME", help=u"Zeroconf service name")
1619
parser.add_option("--configdir", type=u"string",
1620
default=u"/etc/mandos", metavar=u"DIR",
1621
help=u"Directory to search for configuration"
1623
parser.add_option("--no-dbus", action=u"store_false",
1624
dest=u"use_dbus", help=u"Do not provide D-Bus"
1625
u" system bus interface")
1626
parser.add_option("--no-ipv6", action=u"store_false",
1627
dest=u"use_ipv6", help=u"Do not use IPv6")
1628
options = parser.parse_args()[0]
561
def killme(status = 0):
562
logger.debug("Stopping server with exit status %d", status)
564
if main_loop_started:
570
if __name__ == '__main__':
572
main_loop_started = False
573
parser = OptionParser()
574
parser.add_option("-i", "--interface", type="string",
575
default=None, metavar="IF",
576
help="Bind to interface IF")
577
parser.add_option("-p", "--port", type="int", default=None,
578
help="Port number to receive requests on")
579
parser.add_option("--timeout", type="string", # Parsed later
581
help="Amount of downtime allowed for clients")
582
parser.add_option("--interval", type="string", # Parsed later
584
help="How often to check that a client is up")
585
parser.add_option("--check", action="store_true", default=False,
586
help="Run self-test")
587
parser.add_option("--debug", action="store_true", default=False,
589
(options, args) = parser.parse_args()
1630
591
if options.check:
1632
593
doctest.testmod()
1635
# Default values for config file for server-global settings
1636
server_defaults = { u"interface": u"",
1641
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1642
u"servicename": u"Mandos",
1643
u"use_dbus": u"True",
1644
u"use_ipv6": u"True",
1647
# Parse config file for server-global settings
1648
server_config = configparser.SafeConfigParser(server_defaults)
1650
server_config.read(os.path.join(options.configdir,
1652
# Convert the SafeConfigParser object to a dict
1653
server_settings = server_config.defaults()
1654
# Use the appropriate methods on the non-string config options
1655
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1656
server_settings[option] = server_config.getboolean(u"DEFAULT",
1658
if server_settings["port"]:
1659
server_settings["port"] = server_config.getint(u"DEFAULT",
1663
# Override the settings from the config file with command line
1665
for option in (u"interface", u"address", u"port", u"debug",
1666
u"priority", u"servicename", u"configdir",
1667
u"use_dbus", u"use_ipv6"):
1668
value = getattr(options, option)
1669
if value is not None:
1670
server_settings[option] = value
1672
# Force all strings to be unicode
1673
for option in server_settings.keys():
1674
if type(server_settings[option]) is str:
1675
server_settings[option] = unicode(server_settings[option])
1676
# Now we have our good server settings in "server_settings"
1678
##################################################################
1681
debug = server_settings[u"debug"]
1682
use_dbus = server_settings[u"use_dbus"]
1683
use_ipv6 = server_settings[u"use_ipv6"]
1686
syslogger.setLevel(logging.WARNING)
1687
console.setLevel(logging.WARNING)
1689
if server_settings[u"servicename"] != u"Mandos":
1690
syslogger.setFormatter(logging.Formatter
1691
(u'Mandos (%s) [%%(process)d]:'
1692
u' %%(levelname)s: %%(message)s'
1693
% server_settings[u"servicename"]))
1695
# Parse config file with clients
1696
client_defaults = { u"timeout": u"1h",
1698
u"checker": u"fping -q -- %%(host)s",
1700
u"approved_delay": u"0s",
1701
u"approved_duration": u"1s",
1703
client_config = configparser.SafeConfigParser(client_defaults)
1704
client_config.read(os.path.join(server_settings[u"configdir"],
1707
global mandos_dbus_service
1708
mandos_dbus_service = None
1710
tcp_server = MandosServer((server_settings[u"address"],
1711
server_settings[u"port"]),
1713
interface=server_settings[u"interface"],
1716
server_settings[u"priority"],
1718
pidfilename = u"/var/run/mandos.pid"
1720
pidfile = open(pidfilename, u"w")
1722
logger.error(u"Could not open file %r", pidfilename)
1725
uid = pwd.getpwnam(u"_mandos").pw_uid
1726
gid = pwd.getpwnam(u"_mandos").pw_gid
1729
uid = pwd.getpwnam(u"mandos").pw_uid
1730
gid = pwd.getpwnam(u"mandos").pw_gid
1733
uid = pwd.getpwnam(u"nobody").pw_uid
1734
gid = pwd.getpwnam(u"nobody").pw_gid
1741
except OSError, error:
1742
if error[0] != errno.EPERM:
1745
# Enable all possible GnuTLS debugging
1747
# "Use a log level over 10 to enable all debugging options."
1749
gnutls.library.functions.gnutls_global_set_log_level(11)
1751
@gnutls.library.types.gnutls_log_func
1752
def debug_gnutls(level, string):
1753
logger.debug(u"GnuTLS: %s", string[:-1])
1755
(gnutls.library.functions
1756
.gnutls_global_set_log_function(debug_gnutls))
1759
# From the Avahi example code
596
# Parse the time arguments
598
options.timeout = string_to_delta(options.timeout)
600
parser.error("option --timeout: Unparseable time")
602
options.interval = string_to_delta(options.interval)
604
parser.error("option --interval: Unparseable time")
607
defaults = { "checker": "fping -q -- %%(fqdn)s" }
608
client_config = ConfigParser.SafeConfigParser(defaults)
609
#client_config.readfp(open("secrets.conf"), "secrets.conf")
610
client_config.read("mandos-clients.conf")
612
# From the Avahi server example code
1760
613
DBusGMainLoop(set_as_default=True )
1761
614
main_loop = gobject.MainLoop()
1762
615
bus = dbus.SystemBus()
616
server = dbus.Interface(
617
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
618
avahi.DBUS_INTERFACE_SERVER )
1763
619
# End of Avahi example code
1766
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1767
bus, do_not_queue=True)
1768
except dbus.exceptions.NameExistsException, e:
1769
logger.error(unicode(e) + u", disabling D-Bus")
1771
server_settings[u"use_dbus"] = False
1772
tcp_server.use_dbus = False
1773
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1774
service = AvahiService(name = server_settings[u"servicename"],
1775
servicetype = u"_mandos._tcp",
1776
protocol = protocol, bus = bus)
1777
if server_settings["interface"]:
1778
service.interface = (if_nametoindex
1779
(str(server_settings[u"interface"])))
1781
client_class = Client
1783
client_class = functools.partial(ClientDBus, bus = bus)
1784
def client_config_items(config, section):
1785
special_settings = {
1786
"approved_by_default":
1787
lambda: config.getboolean(section,
1788
"approved_by_default"),
1790
for name, value in config.items(section):
1792
yield (name, special_settings[name]())
1796
tcp_server.clients.update(set(
1797
client_class(name = section,
1798
config= dict(client_config_items(
1799
client_config, section)))
1800
for section in client_config.sections()))
1801
if not tcp_server.clients:
1802
logger.warning(u"No clients defined")
621
debug = options.debug
1805
# Redirect stdin so all checkers get /dev/null
1806
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1807
os.dup2(null, sys.stdin.fileno())
1811
# No console logging
1812
logger.removeHandler(console)
1813
# Close all input and output, do double fork, etc.
1819
pidfile.write(str(pid) + "\n")
1822
logger.error(u"Could not write to file %r with PID %d",
1825
# "pidfile" was never created
624
console = logging.StreamHandler()
625
# console.setLevel(logging.DEBUG)
626
console.setFormatter(logging.Formatter\
627
('%(levelname)s: %(message)s'))
628
logger.addHandler(console)
632
def remove_from_clients(client):
633
clients.remove(client)
635
logger.debug(u"No clients left, exiting")
638
clients.update(Set(Client(name=section, options=options,
639
stop_hook = remove_from_clients,
640
**(dict(client_config\
642
for section in client_config.sections()))
1830
signal.signal(signal.SIGINT, signal.SIG_IGN)
1831
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1832
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1835
class MandosDBusService(dbus.service.Object):
1836
"""A D-Bus proxy object"""
1838
dbus.service.Object.__init__(self, bus, u"/")
1839
_interface = u"se.bsnet.fukt.Mandos"
1841
@dbus.service.signal(_interface, signature=u"o")
1842
def ClientAdded(self, objpath):
1846
@dbus.service.signal(_interface, signature=u"ss")
1847
def ClientNotFound(self, fingerprint, address):
1851
@dbus.service.signal(_interface, signature=u"os")
1852
def ClientRemoved(self, objpath, name):
1856
@dbus.service.method(_interface, out_signature=u"ao")
1857
def GetAllClients(self):
1859
return dbus.Array(c.dbus_object_path
1860
for c in tcp_server.clients)
1862
@dbus.service.method(_interface,
1863
out_signature=u"a{oa{sv}}")
1864
def GetAllClientsWithProperties(self):
1866
return dbus.Dictionary(
1867
((c.dbus_object_path, c.GetAll(u""))
1868
for c in tcp_server.clients),
1869
signature=u"oa{sv}")
1871
@dbus.service.method(_interface, in_signature=u"o")
1872
def RemoveClient(self, object_path):
1874
for c in tcp_server.clients:
1875
if c.dbus_object_path == object_path:
1876
tcp_server.clients.remove(c)
1877
c.remove_from_connection()
1878
# Don't signal anything except ClientRemoved
1879
c.disable(quiet=True)
1881
self.ClientRemoved(object_path, c.name)
1883
raise KeyError(object_path)
1887
mandos_dbus_service = MandosDBusService()
1890
648
"Cleanup function; run on exit"
650
# From the Avahi server example code
651
if not group is None:
654
# End of Avahi example code
1893
while tcp_server.clients:
1894
client = tcp_server.clients.pop()
1896
client.remove_from_connection()
1897
client.disable_hook = None
1898
# Don't signal anything except ClientRemoved
1899
client.disable(quiet=True)
1902
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
656
for client in clients:
657
client.stop_hook = None
1905
660
atexit.register(cleanup)
1907
for client in tcp_server.clients:
1910
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1914
tcp_server.server_activate()
1916
# Find out what port we got
1917
service.port = tcp_server.socket.getsockname()[1]
1919
logger.info(u"Now listening on address %r, port %d,"
1920
" flowinfo %d, scope_id %d"
1921
% tcp_server.socket.getsockname())
1923
logger.info(u"Now listening on address %r, port %d"
1924
% tcp_server.socket.getsockname())
1926
#service.interface = tcp_server.socket.getsockname()[3]
1929
# From the Avahi example code
1932
except dbus.exceptions.DBusException, error:
1933
logger.critical(u"DBusException: %s", error)
1936
# End of Avahi example code
1938
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1939
lambda *args, **kwargs:
1940
(tcp_server.handle_request
1941
(*args[2:], **kwargs) or True))
1943
logger.debug(u"Starting main loop")
663
signal.signal(signal.SIGINT, signal.SIG_IGN)
664
signal.signal(signal.SIGHUP, lambda signum, frame: killme())
665
signal.signal(signal.SIGTERM, lambda signum, frame: killme())
667
for client in clients:
670
tcp_server = IPv6_TCPServer((None, options.port),
674
# Find out what random port we got
675
servicePort = tcp_server.socket.getsockname()[1]
676
logger.debug(u"Now listening on port %d", servicePort)
678
if options.interface is not None:
679
serviceInterface = if_nametoindex(options.interface)
681
# From the Avahi server example code
682
server.connect_to_signal("StateChanged", server_state_changed)
684
server_state_changed(server.GetState())
685
except dbus.exceptions.DBusException, error:
686
logger.critical(u"DBusException: %s", error)
688
# End of Avahi example code
690
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
691
lambda *args, **kwargs:
692
tcp_server.handle_request(*args[2:],
695
main_loop_started = True
1945
except AvahiError, error:
1946
logger.critical(u"AvahiError: %s", error)
1949
697
except KeyboardInterrupt:
1952
logger.debug(u"Server received KeyboardInterrupt")
1953
logger.debug(u"Server exiting")
1954
# Must run before the D-Bus bus name gets deregistered
1957
if __name__ == '__main__':