224
98
class AvahiService(object):
225
"""An Avahi (Zeroconf) service.
228
100
interface: integer; avahi.IF_UNSPEC or an interface index.
229
101
Used to optionally bind to the specified interface.
230
name: string; Example: 'Mandos'
231
type: string; Example: '_mandos._tcp'.
232
See <http://www.dns-sd.org/ServiceTypes.html>
233
port: integer; what port to announce
234
TXT: list of strings; TXT record for the service
235
domain: string; Domain to publish on, default to .local if empty.
236
host: string; Host to publish records for, default is localhost
237
max_renames: integer; maximum number of renames
238
rename_count: integer; counter so we only rename after collisions
239
a sensible number of times
240
group: D-Bus Entry Group
242
bus: dbus.SystemBus()
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
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
244
114
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
245
servicetype = None, port = None, TXT = None,
246
domain = "", host = "", max_renames = 32768,
247
protocol = avahi.PROTO_UNSPEC, bus = None):
115
type = None, port = None, TXT = None, domain = "",
116
host = "", max_renames = 12):
117
"""An Avahi (Zeroconf) service. """
248
118
self.interface = interface
250
self.type = servicetype
252
self.TXT = TXT if TXT is not None else []
253
126
self.domain = domain
255
128
self.rename_count = 0
256
self.max_renames = max_renames
257
self.protocol = protocol
258
self.group = None # our entry group
261
self.entry_group_state_changed_match = None
262
129
def rename(self):
263
130
"""Derived from the Avahi example code"""
264
131
if self.rename_count >= self.max_renames:
265
logger.critical("No suitable Zeroconf service name found"
266
" after %i retries, exiting.",
132
logger.critical(u"No suitable service name found after %i"
133
u" retries, exiting.", rename_count)
268
134
raise AvahiServiceError("Too many renames")
269
self.name = unicode(self.server
270
.GetAlternativeServiceName(self.name))
271
logger.info("Changing Zeroconf service name to %r ...",
135
name = server.GetAlternativeServiceName(name)
136
logger.notice(u"Changing name to %r ...", name)
276
except dbus.exceptions.DBusException as error:
277
logger.critical("DBusException: %s", error)
280
139
self.rename_count += 1
281
140
def remove(self):
282
141
"""Derived from the Avahi example code"""
283
if self.entry_group_state_changed_match is not None:
284
self.entry_group_state_changed_match.remove()
285
self.entry_group_state_changed_match = None
286
if self.group is not None:
142
if group is not None:
289
145
"""Derived from the Avahi example code"""
291
if self.group is None:
292
self.group = dbus.Interface(
293
self.bus.get_object(avahi.DBUS_NAME,
294
self.server.EntryGroupNew()),
295
avahi.DBUS_INTERFACE_ENTRY_GROUP)
296
self.entry_group_state_changed_match = (
297
self.group.connect_to_signal(
298
'StateChanged', self.entry_group_state_changed))
299
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
300
self.name, self.type)
301
self.group.AddService(
304
dbus.UInt32(0), # flags
305
self.name, self.type,
306
self.domain, self.host,
307
dbus.UInt16(self.port),
308
avahi.string_array_to_txt_array(self.TXT))
310
def entry_group_state_changed(self, state, error):
311
"""Derived from the Avahi example code"""
312
logger.debug("Avahi entry group state change: %i", state)
314
if state == avahi.ENTRY_GROUP_ESTABLISHED:
315
logger.debug("Zeroconf service established.")
316
elif state == avahi.ENTRY_GROUP_COLLISION:
317
logger.info("Zeroconf service name collision.")
319
elif state == avahi.ENTRY_GROUP_FAILURE:
320
logger.critical("Avahi: Error in group state changed %s",
322
raise AvahiGroupError("State changed: %s"
325
"""Derived from the Avahi example code"""
326
if self.group is not None:
329
except (dbus.exceptions.UnknownMethodException,
330
dbus.exceptions.DBusException):
334
def server_state_changed(self, state, error=None):
335
"""Derived from the Avahi example code"""
336
logger.debug("Avahi server state change: %i", state)
337
bad_states = { avahi.SERVER_INVALID:
338
"Zeroconf server invalid",
339
avahi.SERVER_REGISTERING: None,
340
avahi.SERVER_COLLISION:
341
"Zeroconf server name collision",
342
avahi.SERVER_FAILURE:
343
"Zeroconf server failure" }
344
if state in bad_states:
345
if bad_states[state] is not None:
347
logger.error(bad_states[state])
349
logger.error(bad_states[state] + ": %r", error)
351
elif state == avahi.SERVER_RUNNING:
355
logger.debug("Unknown state: %r", state)
357
logger.debug("Unknown state: %r: %r", state, error)
359
"""Derived from the Avahi example code"""
360
if self.server is None:
361
self.server = dbus.Interface(
362
self.bus.get_object(avahi.DBUS_NAME,
363
avahi.DBUS_PATH_SERVER,
364
follow_name_owner_changes=True),
365
avahi.DBUS_INTERFACE_SERVER)
366
self.server.connect_to_signal("StateChanged",
367
self.server_state_changed)
368
self.server_state_changed(self.server.GetState())
370
class AvahiServiceToSyslog(AvahiService):
372
"""Add the new name to the syslog messages"""
373
ret = AvahiService.rename(self)
374
syslogger.setFormatter(logging.Formatter
375
('Mandos (%s) [%%(process)d]:'
376
' %%(levelname)s: %%(message)s'
380
def _timedelta_to_milliseconds(td):
381
"Convert a datetime.timedelta() to milliseconds"
382
return ((td.days * 24 * 60 * 60 * 1000)
383
+ (td.seconds * 1000)
384
+ (td.microseconds // 1000))
148
group = dbus.Interface\
149
(bus.get_object(avahi.DBUS_NAME,
150
server.EntryGroupNew()),
151
avahi.DBUS_INTERFACE_ENTRY_GROUP)
152
group.connect_to_signal('StateChanged',
153
entry_group_state_changed)
154
logger.debug(u"Adding service '%s' of type '%s' ...",
155
service.name, service.type)
157
self.interface, # interface
158
avahi.PROTO_INET6, # protocol
159
dbus.UInt32(0), # flags
160
self.name, self.type,
161
self.domain, self.host,
162
dbus.UInt16(self.port),
163
avahi.string_array_to_txt_array(self.TXT))
166
# From the Avahi example code:
167
group = None # our entry group
168
# End of Avahi example code
386
171
class Client(object):
387
172
"""A representation of a client host served by this server.
390
_approved: bool(); 'None' if not yet approved/disapproved
391
approval_delay: datetime.timedelta(); Time to wait for approval
392
approval_duration: datetime.timedelta(); Duration of one approval
393
checker: subprocess.Popen(); a running checker process used
394
to see if the client lives.
395
'None' if no process is running.
396
checker_callback_tag: a gobject event source tag, or None
397
checker_command: string; External command which is run to check
398
if client lives. %() expansions are done at
174
name: string; from the config file, used in log messages
175
fingerprint: string (40 or 32 hexadecimal digits); used to
176
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.
188
checker_initiator_tag: a gobject event source tag, or None
189
stop_initiator_tag: - '' -
190
checker_callback_tag: - '' -
191
checker_command: string; External command which is run to check if
192
client lives. %() expansions are done at
399
193
runtime with vars(self) as dict, so that for
400
194
instance %(name)s can be used in the command.
401
checker_initiator_tag: a gobject event source tag, or None
402
created: datetime.datetime(); (UTC) object creation
403
client_structure: Object describing what attributes a client has
404
and is used for storing the client at exit
405
current_checker_command: string; current running checker_command
406
disable_initiator_tag: a gobject event source tag, or None
408
fingerprint: string (40 or 32 hexadecimal digits); used to
409
uniquely identify the client
410
host: string; available for use by the checker command
411
interval: datetime.timedelta(); How often to start a new checker
412
last_approval_request: datetime.datetime(); (UTC) or None
413
last_checked_ok: datetime.datetime(); (UTC) or None
415
last_checker_status: integer between 0 and 255 reflecting exit
416
status of last checker. -1 reflects crashed
418
last_enabled: datetime.datetime(); (UTC)
419
name: string; from the config file, used in log messages and
421
secret: bytestring; sent verbatim (over TLS) to client
422
timeout: datetime.timedelta(); How long from last_checked_ok
423
until this client is disabled
424
extended_timeout: extra long timeout when password has been sent
425
runtime_expansions: Allowed attributes for runtime expansion.
426
expires: datetime.datetime(); time (UTC) when a client will be
196
_timeout: Real variable for 'timeout'
197
_interval: Real variable for 'interval'
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
199
_interval_milliseconds: - '' -
430
runtime_expansions = ("approval_delay", "approval_duration",
431
"created", "enabled", "fingerprint",
432
"host", "interval", "last_checked_ok",
433
"last_enabled", "name", "timeout")
435
def timeout_milliseconds(self):
436
"Return the 'timeout' attribute in milliseconds"
437
return _timedelta_to_milliseconds(self.timeout)
439
def extended_timeout_milliseconds(self):
440
"Return the 'extended_timeout' attribute in milliseconds"
441
return _timedelta_to_milliseconds(self.extended_timeout)
443
def interval_milliseconds(self):
444
"Return the 'interval' attribute in milliseconds"
445
return _timedelta_to_milliseconds(self.interval)
447
def approval_delay_milliseconds(self):
448
return _timedelta_to_milliseconds(self.approval_delay)
450
def __init__(self, name = None, config=None):
451
"""Note: the 'checker' key in 'config' sets the
452
'checker_command' attribute and *not* the 'checker'
201
def _set_timeout(self, timeout):
202
"Setter function for 'timeout' attribute"
203
self._timeout = timeout
204
self._timeout_milliseconds = ((self.timeout.days
205
* 24 * 60 * 60 * 1000)
206
+ (self.timeout.seconds * 1000)
207
+ (self.timeout.microseconds
209
timeout = property(lambda self: self._timeout,
212
def _set_interval(self, interval):
213
"Setter function for 'interval' attribute"
214
self._interval = interval
215
self._interval_milliseconds = ((self.interval.days
216
* 24 * 60 * 60 * 1000)
217
+ (self.interval.seconds
219
+ (self.interval.microseconds
221
interval = property(lambda self: self._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.."""
457
logger.debug("Creating client %r", self.name)
458
# Uppercase and remove spaces from fingerprint for later
459
# comparison purposes with return value from the fingerprint()
461
self.fingerprint = (config["fingerprint"].upper()
463
logger.debug(" Fingerprint: %s", self.fingerprint)
464
if "secret" in config:
465
self.secret = config["secret"].decode("base64")
466
elif "secfile" in config:
467
with open(os.path.expanduser(os.path.expandvars
468
(config["secfile"])),
470
self.secret = secfile.read()
230
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"")
235
logger.debug(u" Fingerprint: %s", self.fingerprint)
237
self.secret = secret.decode(u"base64")
240
self.secret = sf.read()
472
raise TypeError("No secret or secfile for client %s"
243
raise TypeError(u"No secret or secfile for client %s"
474
self.host = config.get("host", "")
475
self.created = datetime.datetime.utcnow()
477
self.last_approval_request = None
478
self.last_enabled = datetime.datetime.utcnow()
246
self.created = datetime.datetime.now()
479
247
self.last_checked_ok = None
480
self.last_checker_status = None
481
self.timeout = string_to_delta(config["timeout"])
482
self.extended_timeout = string_to_delta(config
483
["extended_timeout"])
484
self.interval = string_to_delta(config["interval"])
248
self.timeout = string_to_delta(timeout)
249
self.interval = string_to_delta(interval)
250
self.stop_hook = stop_hook
485
251
self.checker = None
486
252
self.checker_initiator_tag = None
487
self.disable_initiator_tag = None
488
self.expires = datetime.datetime.utcnow() + self.timeout
253
self.stop_initiator_tag = None
489
254
self.checker_callback_tag = None
490
self.checker_command = config["checker"]
491
self.current_checker_command = None
492
self._approved = None
493
self.approved_by_default = config.get("approved_by_default",
495
self.approvals_pending = 0
496
self.approval_delay = string_to_delta(
497
config["approval_delay"])
498
self.approval_duration = string_to_delta(
499
config["approval_duration"])
500
self.changedstate = (multiprocessing_manager
501
.Condition(multiprocessing_manager
503
self.client_structure = [attr for attr in
504
self.__dict__.iterkeys()
505
if not attr.startswith("_")]
506
self.client_structure.append("client_structure")
508
for name, t in inspect.getmembers(type(self),
512
if not name.startswith("_"):
513
self.client_structure.append(name)
515
# Send notice to process children that client state has changed
516
def send_changedstate(self):
517
with self.changedstate:
518
self.changedstate.notify_all()
255
self.check_command = checker
521
257
"""Start this client's checker and timeout hooks"""
522
if getattr(self, "enabled", False):
525
self.send_changedstate()
526
self.expires = datetime.datetime.utcnow() + self.timeout
528
self.last_enabled = datetime.datetime.utcnow()
531
def disable(self, quiet=True):
532
"""Disable this client."""
533
if not getattr(self, "enabled", False):
258
# Schedule a new checker to be started an 'interval' from now,
259
# and every interval from then on.
260
self.checker_initiator_tag = gobject.timeout_add\
261
(self._interval_milliseconds,
263
# Also start a new checker *right now*.
265
# Schedule a stop() when 'timeout' has passed
266
self.stop_initiator_tag = gobject.timeout_add\
267
(self._timeout_milliseconds,
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.
275
logger.debug(u"Stopping client %s", self.name)
536
self.send_changedstate()
538
logger.info("Disabling client %s", self.name)
539
if getattr(self, "disable_initiator_tag", False):
540
gobject.source_remove(self.disable_initiator_tag)
541
self.disable_initiator_tag = None
279
if getattr(self, "stop_initiator_tag", False):
280
gobject.source_remove(self.stop_initiator_tag)
281
self.stop_initiator_tag = None
543
282
if getattr(self, "checker_initiator_tag", False):
544
283
gobject.source_remove(self.checker_initiator_tag)
545
284
self.checker_initiator_tag = None
546
285
self.stop_checker()
548
288
# Do not run this again if called by a gobject.timeout_add
551
290
def __del__(self):
554
def init_checker(self):
555
# Schedule a new checker to be started an 'interval' from now,
556
# and every interval from then on.
557
self.checker_initiator_tag = (gobject.timeout_add
558
(self.interval_milliseconds(),
560
# Schedule a disable() when 'timeout' has passed
561
self.disable_initiator_tag = (gobject.timeout_add
562
(self.timeout_milliseconds(),
564
# Also start a new checker *right now*.
567
def checker_callback(self, pid, condition, command):
291
self.stop_hook = None
293
def checker_callback(self, pid, condition):
568
294
"""The checker has completed, so take appropriate actions."""
295
now = datetime.datetime.now()
569
296
self.checker_callback_tag = None
570
297
self.checker = None
571
if os.WIFEXITED(condition):
572
self.last_checker_status = os.WEXITSTATUS(condition)
573
if self.last_checker_status == 0:
574
logger.info("Checker for %(name)s succeeded",
578
logger.info("Checker for %(name)s failed",
581
self.last_checker_status = -1
582
logger.warning("Checker for %(name)s crashed?",
298
if os.WIFEXITED(condition) \
299
and (os.WEXITSTATUS(condition) == 0):
300
logger.debug(u"Checker for %(name)s succeeded",
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,
307
elif not os.WIFEXITED(condition):
308
logger.warning(u"Checker for %(name)s crashed?",
585
def checked_ok(self, timeout=None):
586
"""Bump up the timeout for this client.
588
This should only be called when the client has been seen,
592
timeout = self.timeout
593
self.last_checked_ok = datetime.datetime.utcnow()
594
if self.disable_initiator_tag is not None:
595
gobject.source_remove(self.disable_initiator_tag)
596
if getattr(self, "enabled", False):
597
self.disable_initiator_tag = (gobject.timeout_add
598
(_timedelta_to_milliseconds
599
(timeout), self.disable))
600
self.expires = datetime.datetime.utcnow() + timeout
602
def need_approval(self):
603
self.last_approval_request = datetime.datetime.utcnow()
311
logger.debug(u"Checker for %(name)s failed",
605
313
def start_checker(self):
606
314
"""Start a new checker subprocess if one is not running.
608
315
If a checker already exists, leave it running and do
610
317
# The reason for not killing a running checker is that if we
687
361
logger.debug("Stopping checker for %(name)s", vars(self))
689
363
os.kill(self.checker.pid, signal.SIGTERM)
691
365
#if self.checker.poll() is None:
692
366
# os.kill(self.checker.pid, signal.SIGKILL)
693
except OSError as error:
367
except OSError, error:
694
368
if error.errno != errno.ESRCH: # No such process
696
370
self.checker = None
699
def dbus_service_property(dbus_interface, signature="v",
700
access="readwrite", byte_arrays=False):
701
"""Decorators for marking methods of a DBusObjectWithProperties to
702
become properties on the D-Bus.
704
The decorated method will be called with no arguments by "Get"
705
and with one argument by "Set".
707
The parameters, where they are supported, are the same as
708
dbus.service.method, except there is only "signature", since the
709
type from Get() and the type sent to Set() is the same.
711
# Encoding deeply encoded byte arrays is not supported yet by the
712
# "Set" method, so we fail early here:
713
if byte_arrays and signature != "ay":
714
raise ValueError("Byte arrays not supported for non-'ay'"
715
" signature %r" % signature)
717
func._dbus_is_property = True
718
func._dbus_interface = dbus_interface
719
func._dbus_signature = signature
720
func._dbus_access = access
721
func._dbus_name = func.__name__
722
if func._dbus_name.endswith("_dbus_property"):
723
func._dbus_name = func._dbus_name[:-14]
724
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
729
class DBusPropertyException(dbus.exceptions.DBusException):
730
"""A base class for D-Bus property-related exceptions
732
def __unicode__(self):
733
return unicode(str(self))
736
class DBusPropertyAccessException(DBusPropertyException):
737
"""A property's access permissions disallows an operation.
742
class DBusPropertyNotFound(DBusPropertyException):
743
"""An attempt was made to access a non-existing property.
748
class DBusObjectWithProperties(dbus.service.Object):
749
"""A D-Bus object with properties.
751
Classes inheriting from this can use the dbus_service_property
752
decorator to expose methods as D-Bus properties. It exposes the
753
standard Get(), Set(), and GetAll() methods on the D-Bus.
757
def _is_dbus_property(obj):
758
return getattr(obj, "_dbus_is_property", False)
760
def _get_all_dbus_properties(self):
761
"""Returns a generator of (name, attribute) pairs
763
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
764
for cls in self.__class__.__mro__
766
inspect.getmembers(cls, self._is_dbus_property))
768
def _get_dbus_property(self, interface_name, property_name):
769
"""Returns a bound method if one exists which is a D-Bus
770
property with the specified name and interface.
772
for cls in self.__class__.__mro__:
773
for name, value in (inspect.getmembers
774
(cls, self._is_dbus_property)):
775
if (value._dbus_name == property_name
776
and value._dbus_interface == interface_name):
777
return value.__get__(self)
780
raise DBusPropertyNotFound(self.dbus_object_path + ":"
781
+ interface_name + "."
784
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
786
def Get(self, interface_name, property_name):
787
"""Standard D-Bus property Get() method, see D-Bus standard.
789
prop = self._get_dbus_property(interface_name, property_name)
790
if prop._dbus_access == "write":
791
raise DBusPropertyAccessException(property_name)
793
if not hasattr(value, "variant_level"):
795
return type(value)(value, variant_level=value.variant_level+1)
797
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
798
def Set(self, interface_name, property_name, value):
799
"""Standard D-Bus property Set() method, see D-Bus standard.
801
prop = self._get_dbus_property(interface_name, property_name)
802
if prop._dbus_access == "read":
803
raise DBusPropertyAccessException(property_name)
804
if prop._dbus_get_args_options["byte_arrays"]:
805
# The byte_arrays option is not supported yet on
806
# signatures other than "ay".
807
if prop._dbus_signature != "ay":
809
value = dbus.ByteArray(''.join(unichr(byte)
813
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
814
out_signature="a{sv}")
815
def GetAll(self, interface_name):
816
"""Standard D-Bus property GetAll() method, see D-Bus
819
Note: Will not include properties with access="write".
822
for name, prop in self._get_all_dbus_properties():
824
and interface_name != prop._dbus_interface):
825
# Interface non-empty but did not match
827
# Ignore write-only properties
828
if prop._dbus_access == "write":
831
if not hasattr(value, "variant_level"):
832
properties[name] = value
834
properties[name] = type(value)(value, variant_level=
835
value.variant_level+1)
836
return dbus.Dictionary(properties, signature="sv")
838
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
840
path_keyword='object_path',
841
connection_keyword='connection')
842
def Introspect(self, object_path, connection):
843
"""Standard D-Bus method, overloaded to insert property tags.
845
xmlstring = dbus.service.Object.Introspect(self, object_path,
848
document = xml.dom.minidom.parseString(xmlstring)
849
def make_tag(document, name, prop):
850
e = document.createElement("property")
851
e.setAttribute("name", name)
852
e.setAttribute("type", prop._dbus_signature)
853
e.setAttribute("access", prop._dbus_access)
855
for if_tag in document.getElementsByTagName("interface"):
856
for tag in (make_tag(document, name, prop)
858
in self._get_all_dbus_properties()
859
if prop._dbus_interface
860
== if_tag.getAttribute("name")):
861
if_tag.appendChild(tag)
862
# Add the names to the return values for the
863
# "org.freedesktop.DBus.Properties" methods
864
if (if_tag.getAttribute("name")
865
== "org.freedesktop.DBus.Properties"):
866
for cn in if_tag.getElementsByTagName("method"):
867
if cn.getAttribute("name") == "Get":
868
for arg in cn.getElementsByTagName("arg"):
869
if (arg.getAttribute("direction")
871
arg.setAttribute("name", "value")
872
elif cn.getAttribute("name") == "GetAll":
873
for arg in cn.getElementsByTagName("arg"):
874
if (arg.getAttribute("direction")
876
arg.setAttribute("name", "props")
877
xmlstring = document.toxml("utf-8")
879
except (AttributeError, xml.dom.DOMException,
880
xml.parsers.expat.ExpatError) as error:
881
logger.error("Failed to override Introspection method",
886
def datetime_to_dbus (dt, variant_level=0):
887
"""Convert a UTC datetime.datetime() to a D-Bus type."""
889
return dbus.String("", variant_level = variant_level)
890
return dbus.String(dt.isoformat(),
891
variant_level=variant_level)
894
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
896
"""Applied to an empty subclass of a D-Bus object, this metaclass
897
will add additional D-Bus attributes matching a certain pattern.
899
def __new__(mcs, name, bases, attr):
900
# Go through all the base classes which could have D-Bus
901
# methods, signals, or properties in them
902
for base in (b for b in bases
903
if issubclass(b, dbus.service.Object)):
904
# Go though all attributes of the base class
905
for attrname, attribute in inspect.getmembers(base):
906
# Ignore non-D-Bus attributes, and D-Bus attributes
907
# with the wrong interface name
908
if (not hasattr(attribute, "_dbus_interface")
909
or not attribute._dbus_interface
910
.startswith("se.recompile.Mandos")):
912
# Create an alternate D-Bus interface name based on
914
alt_interface = (attribute._dbus_interface
915
.replace("se.recompile.Mandos",
916
"se.bsnet.fukt.Mandos"))
917
# Is this a D-Bus signal?
918
if getattr(attribute, "_dbus_is_signal", False):
919
# Extract the original non-method function by
921
nonmethod_func = (dict(
922
zip(attribute.func_code.co_freevars,
923
attribute.__closure__))["func"]
925
# Create a new, but exactly alike, function
926
# object, and decorate it to be a new D-Bus signal
927
# with the alternate D-Bus interface name
928
new_function = (dbus.service.signal
930
attribute._dbus_signature)
932
nonmethod_func.func_code,
933
nonmethod_func.func_globals,
934
nonmethod_func.func_name,
935
nonmethod_func.func_defaults,
936
nonmethod_func.func_closure)))
937
# Define a creator of a function to call both the
938
# old and new functions, so both the old and new
939
# signals gets sent when the function is called
940
def fixscope(func1, func2):
941
"""This function is a scope container to pass
942
func1 and func2 to the "call_both" function
943
outside of its arguments"""
944
def call_both(*args, **kwargs):
945
"""This function will emit two D-Bus
946
signals by calling func1 and func2"""
947
func1(*args, **kwargs)
948
func2(*args, **kwargs)
950
# Create the "call_both" function and add it to
952
attr[attrname] = fixscope(attribute,
954
# Is this a D-Bus method?
955
elif getattr(attribute, "_dbus_is_method", False):
956
# Create a new, but exactly alike, function
957
# object. Decorate it to be a new D-Bus method
958
# with the alternate D-Bus interface name. Add it
960
attr[attrname] = (dbus.service.method
962
attribute._dbus_in_signature,
963
attribute._dbus_out_signature)
965
(attribute.func_code,
966
attribute.func_globals,
968
attribute.func_defaults,
969
attribute.func_closure)))
970
# Is this a D-Bus property?
971
elif getattr(attribute, "_dbus_is_property", False):
972
# Create a new, but exactly alike, function
973
# object, and decorate it to be a new D-Bus
974
# property with the alternate D-Bus interface
975
# name. Add it to the class.
976
attr[attrname] = (dbus_service_property
978
attribute._dbus_signature,
979
attribute._dbus_access,
981
._dbus_get_args_options
984
(attribute.func_code,
985
attribute.func_globals,
987
attribute.func_defaults,
988
attribute.func_closure)))
989
return type.__new__(mcs, name, bases, attr)
992
class ClientDBus(Client, DBusObjectWithProperties):
993
"""A Client class using D-Bus
996
dbus_object_path: dbus.ObjectPath
997
bus: dbus.SystemBus()
1000
runtime_expansions = (Client.runtime_expansions
1001
+ ("dbus_object_path",))
1003
# dbus.service.Object doesn't use super(), so we can't either.
1005
def __init__(self, bus = None, *args, **kwargs):
1007
Client.__init__(self, *args, **kwargs)
1009
self._approvals_pending = 0
1010
# Only now, when this client is initialized, can it show up on
1012
client_object_name = unicode(self.name).translate(
1013
{ord("."): ord("_"),
1014
ord("-"): ord("_")})
1015
self.dbus_object_path = (dbus.ObjectPath
1016
("/clients/" + client_object_name))
1017
DBusObjectWithProperties.__init__(self, self.bus,
1018
self.dbus_object_path)
1020
def notifychangeproperty(transform_func,
1021
dbus_name, type_func=lambda x: x,
1023
""" Modify a variable so that it's a property which announces
1024
its changes to DBus.
1026
transform_fun: Function that takes a value and a variant_level
1027
and transforms it to a D-Bus type.
1028
dbus_name: D-Bus name of the variable
1029
type_func: Function that transform the value before sending it
1030
to the D-Bus. Default: no transform
1031
variant_level: D-Bus variant level. Default: 1
1033
attrname = "_{0}".format(dbus_name)
1034
def setter(self, value):
1035
if hasattr(self, "dbus_object_path"):
1036
if (not hasattr(self, attrname) or
1037
type_func(getattr(self, attrname, None))
1038
!= type_func(value)):
1039
dbus_value = transform_func(type_func(value),
1042
self.PropertyChanged(dbus.String(dbus_name),
1044
setattr(self, attrname, value)
1046
return property(lambda self: getattr(self, attrname), setter)
1049
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1050
approvals_pending = notifychangeproperty(dbus.Boolean,
1053
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1054
last_enabled = notifychangeproperty(datetime_to_dbus,
1056
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1057
type_func = lambda checker:
1058
checker is not None)
1059
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1061
last_approval_request = notifychangeproperty(
1062
datetime_to_dbus, "LastApprovalRequest")
1063
approved_by_default = notifychangeproperty(dbus.Boolean,
1064
"ApprovedByDefault")
1065
approval_delay = notifychangeproperty(dbus.UInt16,
1068
_timedelta_to_milliseconds)
1069
approval_duration = notifychangeproperty(
1070
dbus.UInt16, "ApprovalDuration",
1071
type_func = _timedelta_to_milliseconds)
1072
host = notifychangeproperty(dbus.String, "Host")
1073
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1075
_timedelta_to_milliseconds)
1076
extended_timeout = notifychangeproperty(
1077
dbus.UInt16, "ExtendedTimeout",
1078
type_func = _timedelta_to_milliseconds)
1079
interval = notifychangeproperty(dbus.UInt16,
1082
_timedelta_to_milliseconds)
1083
checker_command = notifychangeproperty(dbus.String, "Checker")
1085
del notifychangeproperty
1087
def __del__(self, *args, **kwargs):
1089
self.remove_from_connection()
1092
if hasattr(DBusObjectWithProperties, "__del__"):
1093
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1094
Client.__del__(self, *args, **kwargs)
1096
def checker_callback(self, pid, condition, command,
1098
self.checker_callback_tag = None
1100
if os.WIFEXITED(condition):
1101
exitstatus = os.WEXITSTATUS(condition)
1103
self.CheckerCompleted(dbus.Int16(exitstatus),
1104
dbus.Int64(condition),
1105
dbus.String(command))
1108
self.CheckerCompleted(dbus.Int16(-1),
1109
dbus.Int64(condition),
1110
dbus.String(command))
1112
return Client.checker_callback(self, pid, condition, command,
1115
def start_checker(self, *args, **kwargs):
1116
old_checker = self.checker
1117
if self.checker is not None:
1118
old_checker_pid = self.checker.pid
1120
old_checker_pid = None
1121
r = Client.start_checker(self, *args, **kwargs)
1122
# Only if new checker process was started
1123
if (self.checker is not None
1124
and old_checker_pid != self.checker.pid):
1126
self.CheckerStarted(self.current_checker_command)
1129
def _reset_approved(self):
1130
self._approved = None
1133
def approve(self, value=True):
1134
self.send_changedstate()
1135
self._approved = value
1136
gobject.timeout_add(_timedelta_to_milliseconds
1137
(self.approval_duration),
1138
self._reset_approved)
1141
## D-Bus methods, signals & properties
1142
_interface = "se.recompile.Mandos.Client"
1146
# CheckerCompleted - signal
1147
@dbus.service.signal(_interface, signature="nxs")
1148
def CheckerCompleted(self, exitcode, waitstatus, command):
1152
# CheckerStarted - signal
1153
@dbus.service.signal(_interface, signature="s")
1154
def CheckerStarted(self, command):
1158
# PropertyChanged - signal
1159
@dbus.service.signal(_interface, signature="sv")
1160
def PropertyChanged(self, property, value):
1164
# GotSecret - signal
1165
@dbus.service.signal(_interface)
1166
def GotSecret(self):
1168
Is sent after a successful transfer of secret from the Mandos
1169
server to mandos-client
1174
@dbus.service.signal(_interface, signature="s")
1175
def Rejected(self, reason):
1179
# NeedApproval - signal
1180
@dbus.service.signal(_interface, signature="tb")
1181
def NeedApproval(self, timeout, default):
1183
return self.need_approval()
1185
# NeRwequest - signal
1186
@dbus.service.signal(_interface, signature="s")
1187
def NewRequest(self, ip):
1189
Is sent after a client request a password.
1196
@dbus.service.method(_interface, in_signature="b")
1197
def Approve(self, value):
1200
# CheckedOK - method
1201
@dbus.service.method(_interface)
1202
def CheckedOK(self):
1206
@dbus.service.method(_interface)
1211
# StartChecker - method
1212
@dbus.service.method(_interface)
1213
def StartChecker(self):
1215
self.start_checker()
1218
@dbus.service.method(_interface)
1223
# StopChecker - method
1224
@dbus.service.method(_interface)
1225
def StopChecker(self):
1230
# ApprovalPending - property
1231
@dbus_service_property(_interface, signature="b", access="read")
1232
def ApprovalPending_dbus_property(self):
1233
return dbus.Boolean(bool(self.approvals_pending))
1235
# ApprovedByDefault - property
1236
@dbus_service_property(_interface, signature="b",
1238
def ApprovedByDefault_dbus_property(self, value=None):
1239
if value is None: # get
1240
return dbus.Boolean(self.approved_by_default)
1241
self.approved_by_default = bool(value)
1243
# ApprovalDelay - property
1244
@dbus_service_property(_interface, signature="t",
1246
def ApprovalDelay_dbus_property(self, value=None):
1247
if value is None: # get
1248
return dbus.UInt64(self.approval_delay_milliseconds())
1249
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1251
# ApprovalDuration - property
1252
@dbus_service_property(_interface, signature="t",
1254
def ApprovalDuration_dbus_property(self, value=None):
1255
if value is None: # get
1256
return dbus.UInt64(_timedelta_to_milliseconds(
1257
self.approval_duration))
1258
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1261
@dbus_service_property(_interface, signature="s", access="read")
1262
def Name_dbus_property(self):
1263
return dbus.String(self.name)
1265
# Fingerprint - property
1266
@dbus_service_property(_interface, signature="s", access="read")
1267
def Fingerprint_dbus_property(self):
1268
return dbus.String(self.fingerprint)
1271
@dbus_service_property(_interface, signature="s",
1273
def Host_dbus_property(self, value=None):
1274
if value is None: # get
1275
return dbus.String(self.host)
1278
# Created - property
1279
@dbus_service_property(_interface, signature="s", access="read")
1280
def Created_dbus_property(self):
1281
return dbus.String(datetime_to_dbus(self.created))
1283
# LastEnabled - property
1284
@dbus_service_property(_interface, signature="s", access="read")
1285
def LastEnabled_dbus_property(self):
1286
return datetime_to_dbus(self.last_enabled)
1288
# Enabled - property
1289
@dbus_service_property(_interface, signature="b",
1291
def Enabled_dbus_property(self, value=None):
1292
if value is None: # get
1293
return dbus.Boolean(self.enabled)
1299
# LastCheckedOK - property
1300
@dbus_service_property(_interface, signature="s",
1302
def LastCheckedOK_dbus_property(self, value=None):
1303
if value is not None:
1306
return datetime_to_dbus(self.last_checked_ok)
1308
# Expires - property
1309
@dbus_service_property(_interface, signature="s", access="read")
1310
def Expires_dbus_property(self):
1311
return datetime_to_dbus(self.expires)
1313
# LastApprovalRequest - property
1314
@dbus_service_property(_interface, signature="s", access="read")
1315
def LastApprovalRequest_dbus_property(self):
1316
return datetime_to_dbus(self.last_approval_request)
1318
# Timeout - property
1319
@dbus_service_property(_interface, signature="t",
1321
def Timeout_dbus_property(self, value=None):
1322
if value is None: # get
1323
return dbus.UInt64(self.timeout_milliseconds())
1324
self.timeout = datetime.timedelta(0, 0, 0, value)
1325
if getattr(self, "disable_initiator_tag", None) is None:
1327
# Reschedule timeout
1328
gobject.source_remove(self.disable_initiator_tag)
1329
self.disable_initiator_tag = None
1331
time_to_die = _timedelta_to_milliseconds((self
1336
if time_to_die <= 0:
1337
# The timeout has passed
1340
self.expires = (datetime.datetime.utcnow()
1341
+ datetime.timedelta(milliseconds =
1343
self.disable_initiator_tag = (gobject.timeout_add
1344
(time_to_die, self.disable))
1346
# ExtendedTimeout - property
1347
@dbus_service_property(_interface, signature="t",
1349
def ExtendedTimeout_dbus_property(self, value=None):
1350
if value is None: # get
1351
return dbus.UInt64(self.extended_timeout_milliseconds())
1352
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1354
# Interval - property
1355
@dbus_service_property(_interface, signature="t",
1357
def Interval_dbus_property(self, value=None):
1358
if value is None: # get
1359
return dbus.UInt64(self.interval_milliseconds())
1360
self.interval = datetime.timedelta(0, 0, 0, value)
1361
if getattr(self, "checker_initiator_tag", None) is None:
1363
# Reschedule checker run
1364
gobject.source_remove(self.checker_initiator_tag)
1365
self.checker_initiator_tag = (gobject.timeout_add
1366
(value, self.start_checker))
1367
self.start_checker() # Start one now, too
1369
# Checker - property
1370
@dbus_service_property(_interface, signature="s",
1372
def Checker_dbus_property(self, value=None):
1373
if value is None: # get
1374
return dbus.String(self.checker_command)
1375
self.checker_command = value
1377
# CheckerRunning - property
1378
@dbus_service_property(_interface, signature="b",
1380
def CheckerRunning_dbus_property(self, value=None):
1381
if value is None: # get
1382
return dbus.Boolean(self.checker is not None)
1384
self.start_checker()
1388
# ObjectPath - property
1389
@dbus_service_property(_interface, signature="o", access="read")
1390
def ObjectPath_dbus_property(self):
1391
return self.dbus_object_path # is already a dbus.ObjectPath
1394
@dbus_service_property(_interface, signature="ay",
1395
access="write", byte_arrays=True)
1396
def Secret_dbus_property(self, value):
1397
self.secret = str(value)
1402
class ProxyClient(object):
1403
def __init__(self, child_pipe, fpr, address):
1404
self._pipe = child_pipe
1405
self._pipe.send(('init', fpr, address))
1406
if not self._pipe.recv():
1409
def __getattribute__(self, name):
1410
if(name == '_pipe'):
1411
return super(ProxyClient, self).__getattribute__(name)
1412
self._pipe.send(('getattr', name))
1413
data = self._pipe.recv()
1414
if data[0] == 'data':
1416
if data[0] == 'function':
1417
def func(*args, **kwargs):
1418
self._pipe.send(('funcall', name, args, kwargs))
1419
return self._pipe.recv()[1]
1422
def __setattr__(self, name, value):
1423
if(name == '_pipe'):
1424
return super(ProxyClient, self).__setattr__(name, value)
1425
self._pipe.send(('setattr', name, value))
1428
class ClientDBusTransitional(ClientDBus):
1429
__metaclass__ = AlternateDBusNamesMetaclass
1432
class ClientHandler(socketserver.BaseRequestHandler, object):
1433
"""A class to handle client connections.
1435
Instantiated once for each connection to handle it.
371
def still_valid(self):
372
"""Has the timeout not yet passed for this client?"""
373
now = datetime.datetime.now()
374
if self.last_checked_ok is None:
375
return now < (self.created + self.timeout)
377
return now < (self.last_checked_ok + self.timeout)
380
def peer_certificate(session):
381
"Return the peer's OpenPGP certificate as a bytestring"
382
# 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:
386
# ...do the normal thing
387
return session.peer_certificate
388
list_size = ctypes.c_uint()
389
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
390
(session._c_object, ctypes.byref(list_size))
391
if list_size.value == 0:
394
return ctypes.string_at(cert.data, cert.size)
397
def fingerprint(openpgp):
398
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
399
# New empty GnuTLS certificate
400
crt = gnutls.library.types.gnutls_openpgp_crt_t()
401
gnutls.library.functions.gnutls_openpgp_crt_init\
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)))
408
# Import the OpenPGP public key into the certificate
409
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
412
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
413
# New buffer for the fingerprint
414
buffer = ctypes.create_string_buffer(20)
415
buffer_length = ctypes.c_size_t()
416
# 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))
419
# Deinit the certificate
420
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
421
# Convert the buffer to a Python bytestring
422
fpr = ctypes.string_at(buffer, buffer_length.value)
423
# Convert the bytestring to hexadecimal notation
424
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
428
class tcp_handler(SocketServer.BaseRequestHandler, object):
429
"""A TCP request handler class.
430
Instantiated by IPv6_TCPServer for each request to handle it.
1436
431
Note: This will run in its own forked process."""
1438
433
def handle(self):
1439
with contextlib.closing(self.server.child_pipe) as child_pipe:
1440
logger.info("TCP connection from: %s",
1441
unicode(self.client_address))
1442
logger.debug("Pipe FD: %d",
1443
self.server.child_pipe.fileno())
1445
session = (gnutls.connection
1446
.ClientSession(self.request,
1448
.X509Credentials()))
1450
# Note: gnutls.connection.X509Credentials is really a
1451
# generic GnuTLS certificate credentials object so long as
1452
# no X.509 keys are added to it. Therefore, we can use it
1453
# here despite using OpenPGP certificates.
1455
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1456
# "+AES-256-CBC", "+SHA1",
1457
# "+COMP-NULL", "+CTYPE-OPENPGP",
1459
# Use a fallback default, since this MUST be set.
1460
priority = self.server.gnutls_priority
1461
if priority is None:
1463
(gnutls.library.functions
1464
.gnutls_priority_set_direct(session._c_object,
1467
# Start communication using the Mandos protocol
1468
# Get protocol number
1469
line = self.request.makefile().readline()
1470
logger.debug("Protocol version: %r", line)
1472
if int(line.strip().split()[0]) > 1:
1474
except (ValueError, IndexError, RuntimeError) as error:
1475
logger.error("Unknown protocol version: %s", error)
1478
# Start GnuTLS connection
1481
except gnutls.errors.GNUTLSError as error:
1482
logger.warning("Handshake failed: %s", error)
1483
# Do not run session.bye() here: the session is not
1484
# established. Just abandon the request.
1486
logger.debug("Handshake succeeded")
1488
approval_required = False
1491
fpr = self.fingerprint(self.peer_certificate
1494
gnutls.errors.GNUTLSError) as error:
1495
logger.warning("Bad certificate: %s", error)
1497
logger.debug("Fingerprint: %s", fpr)
1498
if self.server.use_dbus:
1500
client.NewRequest(str(self.client_address))
1503
client = ProxyClient(child_pipe, fpr,
1504
self.client_address)
1508
if client.approval_delay:
1509
delay = client.approval_delay
1510
client.approvals_pending += 1
1511
approval_required = True
1514
if not client.enabled:
1515
logger.info("Client %s is disabled",
1517
if self.server.use_dbus:
1519
client.Rejected("Disabled")
1522
if client._approved or not client.approval_delay:
1523
#We are approved or approval is disabled
1525
elif client._approved is None:
1526
logger.info("Client %s needs approval",
1528
if self.server.use_dbus:
1530
client.NeedApproval(
1531
client.approval_delay_milliseconds(),
1532
client.approved_by_default)
1534
logger.warning("Client %s was not approved",
1536
if self.server.use_dbus:
1538
client.Rejected("Denied")
1541
#wait until timeout or approved
1542
time = datetime.datetime.now()
1543
client.changedstate.acquire()
1544
(client.changedstate.wait
1545
(float(client._timedelta_to_milliseconds(delay)
1547
client.changedstate.release()
1548
time2 = datetime.datetime.now()
1549
if (time2 - time) >= delay:
1550
if not client.approved_by_default:
1551
logger.warning("Client %s timed out while"
1552
" waiting for approval",
1554
if self.server.use_dbus:
1556
client.Rejected("Approval timed out")
1561
delay -= time2 - time
1564
while sent_size < len(client.secret):
1566
sent = session.send(client.secret[sent_size:])
1567
except gnutls.errors.GNUTLSError as error:
1568
logger.warning("gnutls send failed")
1570
logger.debug("Sent: %d, remaining: %d",
1571
sent, len(client.secret)
1572
- (sent_size + sent))
1575
logger.info("Sending secret to %s", client.name)
1576
# bump the timeout using extended_timeout
1577
client.checked_ok(client.extended_timeout)
1578
if self.server.use_dbus:
1583
if approval_required:
1584
client.approvals_pending -= 1
1587
except gnutls.errors.GNUTLSError as error:
1588
logger.warning("GnuTLS bye failed")
1591
def peer_certificate(session):
1592
"Return the peer's OpenPGP certificate as a bytestring"
1593
# If not an OpenPGP certificate...
1594
if (gnutls.library.functions
1595
.gnutls_certificate_type_get(session._c_object)
1596
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1597
# ...do the normal thing
1598
return session.peer_certificate
1599
list_size = ctypes.c_uint(1)
1600
cert_list = (gnutls.library.functions
1601
.gnutls_certificate_get_peers
1602
(session._c_object, ctypes.byref(list_size)))
1603
if not bool(cert_list) and list_size.value != 0:
1604
raise gnutls.errors.GNUTLSError("error getting peer"
1606
if list_size.value == 0:
1609
return ctypes.string_at(cert.data, cert.size)
1612
def fingerprint(openpgp):
1613
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1614
# New GnuTLS "datum" with the OpenPGP public key
1615
datum = (gnutls.library.types
1616
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1619
ctypes.c_uint(len(openpgp))))
1620
# New empty GnuTLS certificate
1621
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1622
(gnutls.library.functions
1623
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1624
# Import the OpenPGP public key into the certificate
1625
(gnutls.library.functions
1626
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1627
gnutls.library.constants
1628
.GNUTLS_OPENPGP_FMT_RAW))
1629
# Verify the self signature in the key
1630
crtverify = ctypes.c_uint()
1631
(gnutls.library.functions
1632
.gnutls_openpgp_crt_verify_self(crt, 0,
1633
ctypes.byref(crtverify)))
1634
if crtverify.value != 0:
1635
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1636
raise (gnutls.errors.CertificateSecurityError
1638
# New buffer for the fingerprint
1639
buf = ctypes.create_string_buffer(20)
1640
buf_len = ctypes.c_size_t()
1641
# Get the fingerprint from the certificate into the buffer
1642
(gnutls.library.functions
1643
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1644
ctypes.byref(buf_len)))
1645
# Deinit the certificate
1646
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1647
# Convert the buffer to a Python bytestring
1648
fpr = ctypes.string_at(buf, buf_len.value)
1649
# Convert the bytestring to hexadecimal notation
1650
hex_fpr = binascii.hexlify(fpr).upper()
1654
class MultiprocessingMixIn(object):
1655
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1656
def sub_process_main(self, request, address):
1658
self.finish_request(request, address)
1660
self.handle_error(request, address)
1661
self.close_request(request)
1663
def process_request(self, request, address):
1664
"""Start a new process to process the request."""
1665
proc = multiprocessing.Process(target = self.sub_process_main,
1672
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1673
""" adds a pipe to the MixIn """
1674
def process_request(self, request, client_address):
1675
"""Overrides and wraps the original process_request().
1677
This function creates a new pipe in self.pipe
1679
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1681
proc = MultiprocessingMixIn.process_request(self, request,
1683
self.child_pipe.close()
1684
self.add_pipe(parent_pipe, proc)
1686
def add_pipe(self, parent_pipe, proc):
1687
"""Dummy function; override as necessary"""
1688
raise NotImplementedError
1691
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1692
socketserver.TCPServer, object):
1693
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
434
logger.debug(u"TCP connection from: %s",
435
unicode(self.client_address))
436
session = gnutls.connection.ClientSession\
437
(self.request, gnutls.connection.X509Credentials())
438
# Note: gnutls.connection.X509Credentials is really a generic
439
# GnuTLS certificate credentials object so long as no X.509
440
# keys are added to it. Therefore, we can use it here despite
441
# using OpenPGP certificates.
443
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
444
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
446
priority = "NORMAL" # Fallback default, since this
448
if self.server.settings["priority"]:
449
priority = self.server.settings["priority"]
450
gnutls.library.functions.gnutls_priority_set_direct\
451
(session._c_object, priority, None);
455
except gnutls.errors.GNUTLSError, error:
456
logger.debug(u"Handshake failed: %s", error)
457
# Do not run session.bye() here: the session is not
458
# established. Just abandon the request.
461
fpr = fingerprint(peer_certificate(session))
462
except (TypeError, gnutls.errors.GNUTLSError), error:
463
logger.debug(u"Bad certificate: %s", error)
466
logger.debug(u"Fingerprint: %s", fpr)
468
for c in self.server.clients:
469
if c.fingerprint == fpr:
473
logger.debug(u"Client not found for fingerprint: %s", fpr)
476
# Have to check if client.still_valid(), since it is possible
477
# that the client timed out while establishing the GnuTLS
479
if not client.still_valid():
480
logger.debug(u"Client %(name)s is invalid", vars(client))
484
while sent_size < len(client.secret):
485
sent = session.send(client.secret[sent_size:])
486
logger.debug(u"Sent: %d, remaining: %d",
487
sent, len(client.secret)
488
- (sent_size + sent))
493
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
494
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1696
enabled: Boolean; whether this server is activated yet
1697
interface: None or a network interface name (string)
1698
use_ipv6: Boolean; to use IPv6 or not
496
settings: Server settings
497
clients: Set() of Client objects
1700
def __init__(self, server_address, RequestHandlerClass,
1701
interface=None, use_ipv6=True):
1702
self.interface = interface
1704
self.address_family = socket.AF_INET6
1705
socketserver.TCPServer.__init__(self, server_address,
1706
RequestHandlerClass)
499
address_family = socket.AF_INET6
500
def __init__(self, *args, **kwargs):
501
if "settings" in kwargs:
502
self.settings = kwargs["settings"]
503
del kwargs["settings"]
504
if "clients" in kwargs:
505
self.clients = kwargs["clients"]
506
del kwargs["clients"]
507
return super(type(self), self).__init__(*args, **kwargs)
1707
508
def server_bind(self):
1708
509
"""This overrides the normal server_bind() function
1709
510
to bind to an interface if one was specified, and also NOT to
1710
511
bind to an address or port if they were not specified."""
1711
if self.interface is not None:
1712
if SO_BINDTODEVICE is None:
1713
logger.error("SO_BINDTODEVICE does not exist;"
1714
" cannot bind to interface %s",
1718
self.socket.setsockopt(socket.SOL_SOCKET,
1722
except socket.error as error:
1723
if error[0] == errno.EPERM:
1724
logger.error("No permission to"
1725
" bind to interface %s",
1727
elif error[0] == errno.ENOPROTOOPT:
1728
logger.error("SO_BINDTODEVICE not available;"
1729
" cannot bind to interface %s",
512
if self.settings["interface"]:
513
# 25 is from /usr/include/asm-i486/socket.h
514
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
516
self.socket.setsockopt(socket.SOL_SOCKET,
518
self.settings["interface"])
519
except socket.error, error:
520
if error[0] == errno.EPERM:
521
logger.warning(u"No permission to"
522
u" bind to interface %s",
523
self.settings["interface"])
1733
526
# Only bind(2) the socket if we really need to.
1734
527
if self.server_address[0] or self.server_address[1]:
1735
528
if not self.server_address[0]:
1736
if self.address_family == socket.AF_INET6:
1737
any_address = "::" # in6addr_any
1739
any_address = socket.INADDR_ANY
1740
self.server_address = (any_address,
530
self.server_address = (in6addr_any,
1741
531
self.server_address[1])
1742
elif not self.server_address[1]:
532
elif self.server_address[1] is None:
1743
533
self.server_address = (self.server_address[0],
1745
# if self.interface:
1746
# self.server_address = (self.server_address[0],
1751
return socketserver.TCPServer.server_bind(self)
1754
class MandosServer(IPv6_TCPServer):
1758
clients: set of Client objects
1759
gnutls_priority GnuTLS priority string
1760
use_dbus: Boolean; to emit D-Bus signals or not
1762
Assumes a gobject.MainLoop event loop.
1764
def __init__(self, server_address, RequestHandlerClass,
1765
interface=None, use_ipv6=True, clients=None,
1766
gnutls_priority=None, use_dbus=True):
1767
self.enabled = False
1768
self.clients = clients
1769
if self.clients is None:
1771
self.use_dbus = use_dbus
1772
self.gnutls_priority = gnutls_priority
1773
IPv6_TCPServer.__init__(self, server_address,
1774
RequestHandlerClass,
1775
interface = interface,
1776
use_ipv6 = use_ipv6)
1777
def server_activate(self):
1779
return socketserver.TCPServer.server_activate(self)
1784
def add_pipe(self, parent_pipe, proc):
1785
# Call "handle_ipc" for both data and EOF events
1786
gobject.io_add_watch(parent_pipe.fileno(),
1787
gobject.IO_IN | gobject.IO_HUP,
1788
functools.partial(self.handle_ipc,
1793
def handle_ipc(self, source, condition, parent_pipe=None,
1794
proc = None, client_object=None):
1796
gobject.IO_IN: "IN", # There is data to read.
1797
gobject.IO_OUT: "OUT", # Data can be written (without
1799
gobject.IO_PRI: "PRI", # There is urgent data to read.
1800
gobject.IO_ERR: "ERR", # Error condition.
1801
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1802
# broken, usually for pipes and
1805
conditions_string = ' | '.join(name
1807
condition_names.iteritems()
1808
if cond & condition)
1809
# error, or the other end of multiprocessing.Pipe has closed
1810
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1811
# Wait for other process to exit
1815
# Read a request from the child
1816
request = parent_pipe.recv()
1817
command = request[0]
1819
if command == 'init':
1821
address = request[2]
1823
for c in self.clients.itervalues():
1824
if c.fingerprint == fpr:
1828
logger.info("Client not found for fingerprint: %s, ad"
1829
"dress: %s", fpr, address)
1832
mandos_dbus_service.ClientNotFound(fpr,
1834
parent_pipe.send(False)
1837
gobject.io_add_watch(parent_pipe.fileno(),
1838
gobject.IO_IN | gobject.IO_HUP,
1839
functools.partial(self.handle_ipc,
1845
parent_pipe.send(True)
1846
# remove the old hook in favor of the new above hook on
1849
if command == 'funcall':
1850
funcname = request[1]
1854
parent_pipe.send(('data', getattr(client_object,
1858
if command == 'getattr':
1859
attrname = request[1]
1860
if callable(client_object.__getattribute__(attrname)):
1861
parent_pipe.send(('function',))
1863
parent_pipe.send(('data', client_object
1864
.__getattribute__(attrname)))
1866
if command == 'setattr':
1867
attrname = request[1]
1869
setattr(client_object, attrname, value)
535
return super(type(self), self).server_bind()
1874
538
def string_to_delta(interval):
1875
539
"""Parse a string and return a datetime.timedelta
1877
541
>>> string_to_delta('7d')
1878
542
datetime.timedelta(7)
1879
543
>>> string_to_delta('60s')
1990
687
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1991
688
"servicename": "Mandos",
1997
691
# Parse config file for server-global settings
1998
server_config = configparser.SafeConfigParser(server_defaults)
692
server_config = ConfigParser.SafeConfigParser(server_defaults)
1999
693
del server_defaults
2000
server_config.read(os.path.join(options.configdir,
694
server_config.read(os.path.join(options.configdir, "server.conf"))
695
server_section = "server"
2002
696
# Convert the SafeConfigParser object to a dict
2003
server_settings = server_config.defaults()
2004
# Use the appropriate methods on the non-string config options
2005
for option in ("debug", "use_dbus", "use_ipv6"):
2006
server_settings[option] = server_config.getboolean("DEFAULT",
2008
if server_settings["port"]:
2009
server_settings["port"] = server_config.getint("DEFAULT",
697
server_settings = dict(server_config.items(server_section))
698
# Use getboolean on the boolean config option
699
server_settings["debug"] = server_config.getboolean\
700
(server_section, "debug")
2011
701
del server_config
2013
703
# Override the settings from the config file with command line
2014
704
# options, if set.
2015
705
for option in ("interface", "address", "port", "debug",
2016
"priority", "servicename", "configdir",
2017
"use_dbus", "use_ipv6", "debuglevel", "restore"):
706
"priority", "servicename", "configdir"):
2018
707
value = getattr(options, option)
2019
708
if value is not None:
2020
709
server_settings[option] = value
2022
# Force all strings to be unicode
2023
for option in server_settings.keys():
2024
if type(server_settings[option]) is str:
2025
server_settings[option] = unicode(server_settings[option])
2026
711
# Now we have our good server settings in "server_settings"
2028
##################################################################
2031
debug = server_settings["debug"]
2032
debuglevel = server_settings["debuglevel"]
2033
use_dbus = server_settings["use_dbus"]
2034
use_ipv6 = server_settings["use_ipv6"]
2037
initlogger(logging.DEBUG)
2042
level = getattr(logging, debuglevel.upper())
2045
if server_settings["servicename"] != "Mandos":
2046
syslogger.setFormatter(logging.Formatter
2047
('Mandos (%s) [%%(process)d]:'
2048
' %%(levelname)s: %%(message)s'
2049
% server_settings["servicename"]))
2051
713
# Parse config file with clients
2052
client_defaults = { "timeout": "5m",
2053
"extended_timeout": "15m",
2055
"checker": "fping -q -- %%(host)s",
2057
"approval_delay": "0s",
2058
"approval_duration": "1s",
714
client_defaults = { "timeout": "1h",
716
"checker": "fping -q -- %%(fqdn)s",
2060
client_config = configparser.SafeConfigParser(client_defaults)
718
client_config = ConfigParser.SafeConfigParser(client_defaults)
2061
719
client_config.read(os.path.join(server_settings["configdir"],
2062
720
"clients.conf"))
2064
global mandos_dbus_service
2065
mandos_dbus_service = None
2067
tcp_server = MandosServer((server_settings["address"],
2068
server_settings["port"]),
2070
interface=(server_settings["interface"]
2074
server_settings["priority"],
2077
pidfilename = "/var/run/mandos.pid"
2079
pidfile = open(pidfilename, "w")
2081
logger.error("Could not open file %r", pidfilename)
2084
uid = pwd.getpwnam("_mandos").pw_uid
2085
gid = pwd.getpwnam("_mandos").pw_gid
2088
uid = pwd.getpwnam("mandos").pw_uid
2089
gid = pwd.getpwnam("mandos").pw_gid
2092
uid = pwd.getpwnam("nobody").pw_uid
2093
gid = pwd.getpwnam("nobody").pw_gid
2100
except OSError as error:
2101
if error[0] != errno.EPERM:
2105
# Enable all possible GnuTLS debugging
2107
# "Use a log level over 10 to enable all debugging options."
2109
gnutls.library.functions.gnutls_global_set_log_level(11)
2111
@gnutls.library.types.gnutls_log_func
2112
def debug_gnutls(level, string):
2113
logger.debug("GnuTLS: %s", string[:-1])
2115
(gnutls.library.functions
2116
.gnutls_global_set_log_function(debug_gnutls))
2118
# Redirect stdin so all checkers get /dev/null
2119
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2120
os.dup2(null, sys.stdin.fileno())
2124
# No console logging
2125
logger.removeHandler(console)
2127
# Need to fork before connecting to D-Bus
2129
# Close all input and output, do double fork, etc.
723
service = AvahiService(name = server_settings["servicename"],
724
type = "_mandos._tcp", );
725
if server_settings["interface"]:
726
service.interface = if_nametoindex(server_settings["interface"])
2132
728
global main_loop
2133
731
# From the Avahi example code
2134
732
DBusGMainLoop(set_as_default=True )
2135
733
main_loop = gobject.MainLoop()
2136
734
bus = dbus.SystemBus()
735
server = dbus.Interface(
736
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
737
avahi.DBUS_INTERFACE_SERVER )
2137
738
# End of Avahi example code
2140
bus_name = dbus.service.BusName("se.recompile.Mandos",
2141
bus, do_not_queue=True)
2142
old_bus_name = (dbus.service.BusName
2143
("se.bsnet.fukt.Mandos", bus,
2145
except dbus.exceptions.NameExistsException as e:
2146
logger.error(unicode(e) + ", disabling D-Bus")
2148
server_settings["use_dbus"] = False
2149
tcp_server.use_dbus = False
2150
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2151
service = AvahiServiceToSyslog(name =
2152
server_settings["servicename"],
2153
servicetype = "_mandos._tcp",
2154
protocol = protocol, bus = bus)
2155
if server_settings["interface"]:
2156
service.interface = (if_nametoindex
2157
(str(server_settings["interface"])))
2159
global multiprocessing_manager
2160
multiprocessing_manager = multiprocessing.Manager()
2162
client_class = Client
2164
client_class = functools.partial(ClientDBusTransitional,
2167
special_settings = {
2168
# Some settings need to be accessd by special methods;
2169
# booleans need .getboolean(), etc. Here is a list of them:
2170
"approved_by_default":
2172
client_config.getboolean(section, "approved_by_default"),
2174
# Construct a new dict of client settings of this form:
2175
# { client_name: {setting_name: value, ...}, ...}
2176
# with exceptions for any special settings as defined above
2177
client_settings = dict((clientname,
2180
if setting not in special_settings
2181
else special_settings[setting]
2183
for setting, value in
2184
client_config.items(clientname)))
2185
for clientname in client_config.sections())
2187
old_client_settings = {}
2190
# Get client data and settings from last running state.
2191
if server_settings["restore"]:
2193
with open(stored_state_path, "rb") as stored_state:
2194
clients_data, old_client_settings = (pickle.load
2196
os.remove(stored_state_path)
2197
except IOError as e:
2198
logger.warning("Could not load persistent state: {0}"
2200
if e.errno != errno.ENOENT:
2203
with Crypto() as crypt:
2204
for client in clients_data:
2205
client_name = client["name"]
2207
# Decide which value to use after restoring saved state.
2208
# We have three different values: Old config file,
2209
# new config file, and saved state.
2210
# New config value takes precedence if it differs from old
2211
# config value, otherwise use saved state.
2212
for name, value in client_settings[client_name].items():
2214
# For each value in new config, check if it
2215
# differs from the old config value (Except for
2216
# the "secret" attribute)
2217
if (name != "secret" and
2218
value != old_client_settings[client_name]
2220
setattr(client, name, value)
2224
# Clients who has passed its expire date can still be
2225
# enabled if its last checker was sucessful. Clients
2226
# whose checker failed before we stored its state is
2227
# assumed to have failed all checkers during downtime.
2228
if client["enabled"] and client["last_checked_ok"]:
2229
if ((datetime.datetime.utcnow()
2230
- client["last_checked_ok"])
2231
> client["interval"]):
2232
if client["last_checker_status"] != 0:
2233
client["enabled"] = False
2235
client["expires"] = (datetime.datetime
2237
+ client["timeout"])
2239
client["changedstate"] = (multiprocessing_manager
2241
(multiprocessing_manager
2244
new_client = (ClientDBusTransitional.__new__
2245
(ClientDBusTransitional))
2246
tcp_server.clients[client_name] = new_client
2247
new_client.bus = bus
2248
for name, value in client.iteritems():
2249
setattr(new_client, name, value)
2250
client_object_name = unicode(client_name).translate(
2251
{ord("."): ord("_"),
2252
ord("-"): ord("_")})
2253
new_client.dbus_object_path = (dbus.ObjectPath
2255
+ client_object_name))
2256
DBusObjectWithProperties.__init__(new_client,
2261
tcp_server.clients[client_name] = (Client.__new__
2263
for name, value in client.iteritems():
2264
setattr(tcp_server.clients[client_name],
2268
tcp_server.clients[client_name].secret = (
2269
crypt.decrypt(tcp_server.clients[client_name]
2271
client_settings[client_name]
2274
# If decryption fails, we use secret from new settings
2275
tcp_server.clients[client_name].secret = (
2276
client_settings[client_name]["secret"])
2278
# Create/remove clients based on new changes made to config
2279
for clientname in set(old_client_settings) - set(client_settings):
2280
del tcp_server.clients[clientname]
2281
for clientname in set(client_settings) - set(old_client_settings):
2282
tcp_server.clients[clientname] = (client_class(name
2288
if not tcp_server.clients:
2289
logger.warning("No clients defined")
2295
pidfile.write(str(pid) + "\n".encode("utf-8"))
2298
logger.error("Could not write to file %r with PID %d",
2301
# "pidfile" was never created
740
debug = server_settings["debug"]
743
console = logging.StreamHandler()
744
# console.setLevel(logging.DEBUG)
745
console.setFormatter(logging.Formatter\
746
('%(levelname)s: %(message)s'))
747
logger.addHandler(console)
751
def remove_from_clients(client):
752
clients.remove(client)
754
logger.debug(u"No clients left, exiting")
757
clients.update(Set(Client(name=section,
758
stop_hook = remove_from_clients,
759
**(dict(client_config\
761
for section in client_config.sections()))
767
"Cleanup function; run on exit"
769
# From the Avahi example code
770
if not group is None:
773
# End of Avahi example code
776
client = clients.pop()
777
client.stop_hook = None
780
atexit.register(cleanup)
2305
783
signal.signal(signal.SIGINT, signal.SIG_IGN)
2307
784
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2308
785
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2311
class MandosDBusService(dbus.service.Object):
2312
"""A D-Bus proxy object"""
2314
dbus.service.Object.__init__(self, bus, "/")
2315
_interface = "se.recompile.Mandos"
2317
@dbus.service.signal(_interface, signature="o")
2318
def ClientAdded(self, objpath):
2322
@dbus.service.signal(_interface, signature="ss")
2323
def ClientNotFound(self, fingerprint, address):
2327
@dbus.service.signal(_interface, signature="os")
2328
def ClientRemoved(self, objpath, name):
2332
@dbus.service.method(_interface, out_signature="ao")
2333
def GetAllClients(self):
2335
return dbus.Array(c.dbus_object_path
2337
tcp_server.clients.itervalues())
2339
@dbus.service.method(_interface,
2340
out_signature="a{oa{sv}}")
2341
def GetAllClientsWithProperties(self):
2343
return dbus.Dictionary(
2344
((c.dbus_object_path, c.GetAll(""))
2345
for c in tcp_server.clients.itervalues()),
2348
@dbus.service.method(_interface, in_signature="o")
2349
def RemoveClient(self, object_path):
2351
for c in tcp_server.clients.itervalues():
2352
if c.dbus_object_path == object_path:
2353
del tcp_server.clients[c.name]
2354
c.remove_from_connection()
2355
# Don't signal anything except ClientRemoved
2356
c.disable(quiet=True)
2358
self.ClientRemoved(object_path, c.name)
2360
raise KeyError(object_path)
2364
class MandosDBusServiceTransitional(MandosDBusService):
2365
__metaclass__ = AlternateDBusNamesMetaclass
2366
mandos_dbus_service = MandosDBusServiceTransitional()
2369
"Cleanup function; run on exit"
2372
multiprocessing.active_children()
2373
if not (tcp_server.clients or client_settings):
2376
# Store client before exiting. Secrets are encrypted with key
2377
# based on what config file has. If config file is
2378
# removed/edited, old secret will thus be unrecovable.
2380
with Crypto() as crypt:
2381
for client in tcp_server.clients.itervalues():
2382
key = client_settings[client.name]["secret"]
2383
client.encrypted_secret = crypt.encrypt(client.secret,
2387
# A list of attributes that will not be stored when
2389
exclude = set(("bus", "changedstate", "secret"))
2390
for name, typ in (inspect.getmembers
2391
(dbus.service.Object)):
2394
client_dict["encrypted_secret"] = (client
2396
for attr in client.client_structure:
2397
if attr not in exclude:
2398
client_dict[attr] = getattr(client, attr)
2400
clients.append(client_dict)
2401
del client_settings[client.name]["secret"]
2404
with os.fdopen(os.open(stored_state_path,
2405
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2406
0600), "wb") as stored_state:
2407
pickle.dump((clients, client_settings), stored_state)
2408
except (IOError, OSError) as e:
2409
logger.warning("Could not save persistent state: {0}"
2411
if e.errno not in (errno.ENOENT, errno.EACCES):
2414
# Delete all clients, and settings from config
2415
while tcp_server.clients:
2416
name, client = tcp_server.clients.popitem()
2418
client.remove_from_connection()
2419
# Don't signal anything except ClientRemoved
2420
client.disable(quiet=True)
2423
mandos_dbus_service.ClientRemoved(client
2426
client_settings.clear()
2428
atexit.register(cleanup)
2430
for client in tcp_server.clients.itervalues():
2433
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2434
# Need to initiate checking of clients
2436
client.init_checker()
2439
tcp_server.server_activate()
787
for client in clients:
790
tcp_server = IPv6_TCPServer((server_settings["address"],
791
server_settings["port"]),
793
settings=server_settings,
2441
795
# Find out what port we got
2442
796
service.port = tcp_server.socket.getsockname()[1]
2444
logger.info("Now listening on address %r, port %d,"
2445
" flowinfo %d, scope_id %d"
2446
% tcp_server.socket.getsockname())
2448
logger.info("Now listening on address %r, port %d"
2449
% tcp_server.socket.getsockname())
797
logger.debug(u"Now listening on address %r, port %d, flowinfo %d,"
798
u" scope_id %d" % tcp_server.socket.getsockname())
2451
800
#service.interface = tcp_server.socket.getsockname()[3]
2454
803
# From the Avahi example code
804
server.connect_to_signal("StateChanged", server_state_changed)
2457
except dbus.exceptions.DBusException as error:
2458
logger.critical("DBusException: %s", error)
806
server_state_changed(server.GetState())
807
except dbus.exceptions.DBusException, error:
808
logger.critical(u"DBusException: %s", error)
2461
810
# End of Avahi example code
2463
812
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2464
813
lambda *args, **kwargs:
2465
(tcp_server.handle_request
2466
(*args[2:], **kwargs) or True))
814
tcp_server.handle_request\
815
(*args[2:], **kwargs) or True)
2468
817
logger.debug("Starting main loop")
818
main_loop_started = True
2470
except AvahiError as error:
2471
logger.critical("AvahiError: %s", error)
820
except AvahiError, error:
821
logger.critical(u"AvahiError: %s" + unicode(error))
2474
823
except KeyboardInterrupt:
2476
print("", file=sys.stderr)
2477
logger.debug("Server received KeyboardInterrupt")
2478
logger.debug("Server exiting")
2479
# Must run before the D-Bus bus name gets deregistered
2483
827
if __name__ == '__main__':