269
140
self.rename_count = 0
270
141
self.max_renames = max_renames
271
142
self.protocol = protocol
272
self.group = None # our entry group
275
self.entry_group_state_changed_match = None
277
143
def rename(self):
278
144
"""Derived from the Avahi example code"""
279
145
if self.rename_count >= self.max_renames:
280
logger.critical("No suitable Zeroconf service name found"
281
" after %i retries, exiting.",
146
logger.critical(u"No suitable Zeroconf service name found"
147
u" after %i retries, exiting.",
282
148
self.rename_count)
283
raise AvahiServiceError("Too many renames")
284
self.name = unicode(self.server
285
.GetAlternativeServiceName(self.name))
286
logger.info("Changing Zeroconf service name to %r ...",
149
raise AvahiServiceError(u"Too many renames")
150
self.name = server.GetAlternativeServiceName(self.name)
151
logger.info(u"Changing Zeroconf service name to %r ...",
153
syslogger.setFormatter(logging.Formatter
154
(u'Mandos (%s) [%%(process)d]:'
155
u' %%(levelname)s: %%(message)s'
291
except dbus.exceptions.DBusException as error:
292
logger.critical("D-Bus Exception", exc_info=error)
295
159
self.rename_count += 1
297
160
def remove(self):
298
161
"""Derived from the Avahi example code"""
299
if self.entry_group_state_changed_match is not None:
300
self.entry_group_state_changed_match.remove()
301
self.entry_group_state_changed_match = None
302
if self.group is not None:
162
if group is not None:
306
165
"""Derived from the Avahi example code"""
308
if self.group is None:
309
self.group = dbus.Interface(
310
self.bus.get_object(avahi.DBUS_NAME,
311
self.server.EntryGroupNew()),
312
avahi.DBUS_INTERFACE_ENTRY_GROUP)
313
self.entry_group_state_changed_match = (
314
self.group.connect_to_signal(
315
'StateChanged', self.entry_group_state_changed))
316
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
317
self.name, self.type)
318
self.group.AddService(
321
dbus.UInt32(0), # flags
322
self.name, self.type,
323
self.domain, self.host,
324
dbus.UInt16(self.port),
325
avahi.string_array_to_txt_array(self.TXT))
328
def entry_group_state_changed(self, state, error):
329
"""Derived from the Avahi example code"""
330
logger.debug("Avahi entry group state change: %i", state)
332
if state == avahi.ENTRY_GROUP_ESTABLISHED:
333
logger.debug("Zeroconf service established.")
334
elif state == avahi.ENTRY_GROUP_COLLISION:
335
logger.info("Zeroconf service name collision.")
337
elif state == avahi.ENTRY_GROUP_FAILURE:
338
logger.critical("Avahi: Error in group state changed %s",
340
raise AvahiGroupError("State changed: {0!s}"
344
"""Derived from the Avahi example code"""
345
if self.group is not None:
348
except (dbus.exceptions.UnknownMethodException,
349
dbus.exceptions.DBusException):
354
def server_state_changed(self, state, error=None):
355
"""Derived from the Avahi example code"""
356
logger.debug("Avahi server state change: %i", state)
357
bad_states = { avahi.SERVER_INVALID:
358
"Zeroconf server invalid",
359
avahi.SERVER_REGISTERING: None,
360
avahi.SERVER_COLLISION:
361
"Zeroconf server name collision",
362
avahi.SERVER_FAILURE:
363
"Zeroconf server failure" }
364
if state in bad_states:
365
if bad_states[state] is not None:
367
logger.error(bad_states[state])
369
logger.error(bad_states[state] + ": %r", error)
371
elif state == avahi.SERVER_RUNNING:
375
logger.debug("Unknown state: %r", state)
377
logger.debug("Unknown state: %r: %r", state, error)
380
"""Derived from the Avahi example code"""
381
if self.server is None:
382
self.server = dbus.Interface(
383
self.bus.get_object(avahi.DBUS_NAME,
384
avahi.DBUS_PATH_SERVER,
385
follow_name_owner_changes=True),
386
avahi.DBUS_INTERFACE_SERVER)
387
self.server.connect_to_signal("StateChanged",
388
self.server_state_changed)
389
self.server_state_changed(self.server.GetState())
392
class AvahiServiceToSyslog(AvahiService):
394
"""Add the new name to the syslog messages"""
395
ret = AvahiService.rename(self)
396
syslogger.setFormatter(logging.Formatter
397
('Mandos ({0}) [%(process)d]:'
398
' %(levelname)s: %(message)s'
403
def timedelta_to_milliseconds(td):
404
"Convert a datetime.timedelta() to milliseconds"
405
return ((td.days * 24 * 60 * 60 * 1000)
406
+ (td.seconds * 1000)
407
+ (td.microseconds // 1000))
168
group = dbus.Interface(bus.get_object
170
server.EntryGroupNew()),
171
avahi.DBUS_INTERFACE_ENTRY_GROUP)
172
group.connect_to_signal('StateChanged',
173
entry_group_state_changed)
174
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
175
service.name, service.type)
177
self.interface, # interface
178
self.protocol, # protocol
179
dbus.UInt32(0), # flags
180
self.name, self.type,
181
self.domain, self.host,
182
dbus.UInt16(self.port),
183
avahi.string_array_to_txt_array(self.TXT))
186
# From the Avahi example code:
187
group = None # our entry group
188
# End of Avahi example code
191
def _datetime_to_dbus(dt, variant_level=0):
192
"""Convert a UTC datetime.datetime() to a D-Bus type."""
193
return dbus.String(dt.isoformat(), variant_level=variant_level)
410
196
class Client(object):
411
197
"""A representation of a client host served by this server.
414
approved: bool(); 'None' if not yet approved/disapproved
415
approval_delay: datetime.timedelta(); Time to wait for approval
416
approval_duration: datetime.timedelta(); Duration of one approval
200
name: string; from the config file, used in log messages and
202
fingerprint: string (40 or 32 hexadecimal digits); used to
203
uniquely identify the client
204
secret: bytestring; sent verbatim (over TLS) to client
205
host: string; available for use by the checker command
206
created: datetime.datetime(); (UTC) object creation
207
last_enabled: datetime.datetime(); (UTC)
209
last_checked_ok: datetime.datetime(); (UTC) or None
210
timeout: datetime.timedelta(); How long from last_checked_ok
211
until this client is invalid
212
interval: datetime.timedelta(); How often to start a new checker
213
disable_hook: If set, called by disable() as disable_hook(self)
417
214
checker: subprocess.Popen(); a running checker process used
418
215
to see if the client lives.
419
216
'None' if no process is running.
420
checker_callback_tag: a gobject event source tag, or None
421
checker_command: string; External command which is run to check
422
if client lives. %() expansions are done at
217
checker_initiator_tag: a gobject event source tag, or None
218
disable_initiator_tag: - '' -
219
checker_callback_tag: - '' -
220
checker_command: string; External command which is run to check if
221
client lives. %() expansions are done at
423
222
runtime with vars(self) as dict, so that for
424
223
instance %(name)s can be used in the command.
425
checker_initiator_tag: a gobject event source tag, or None
426
created: datetime.datetime(); (UTC) object creation
427
client_structure: Object describing what attributes a client has
428
and is used for storing the client at exit
429
224
current_checker_command: string; current running checker_command
430
disable_initiator_tag: a gobject event source tag, or None
432
fingerprint: string (40 or 32 hexadecimal digits); used to
433
uniquely identify the client
434
host: string; available for use by the checker command
435
interval: datetime.timedelta(); How often to start a new checker
436
last_approval_request: datetime.datetime(); (UTC) or None
437
last_checked_ok: datetime.datetime(); (UTC) or None
438
last_checker_status: integer between 0 and 255 reflecting exit
439
status of last checker. -1 reflects crashed
440
checker, -2 means no checker completed yet.
441
last_enabled: datetime.datetime(); (UTC) or None
442
name: string; from the config file, used in log messages and
444
secret: bytestring; sent verbatim (over TLS) to client
445
timeout: datetime.timedelta(); How long from last_checked_ok
446
until this client is disabled
447
extended_timeout: extra long timeout when secret has been sent
448
runtime_expansions: Allowed attributes for runtime expansion.
449
expires: datetime.datetime(); time (UTC) when a client will be
451
server_settings: The server_settings dict from main()
454
runtime_expansions = ("approval_delay", "approval_duration",
455
"created", "enabled", "expires",
456
"fingerprint", "host", "interval",
457
"last_approval_request", "last_checked_ok",
458
"last_enabled", "name", "timeout")
459
client_defaults = { "timeout": "PT5M",
460
"extended_timeout": "PT15M",
462
"checker": "fping -q -- %%(host)s",
464
"approval_delay": "PT0S",
465
"approval_duration": "PT1S",
466
"approved_by_default": "True",
228
def _datetime_to_milliseconds(dt):
229
"Convert a datetime.datetime() to milliseconds"
230
return ((dt.days * 24 * 60 * 60 * 1000)
231
+ (dt.seconds * 1000)
232
+ (dt.microseconds // 1000))
470
234
def timeout_milliseconds(self):
471
235
"Return the 'timeout' attribute in milliseconds"
472
return timedelta_to_milliseconds(self.timeout)
474
def extended_timeout_milliseconds(self):
475
"Return the 'extended_timeout' attribute in milliseconds"
476
return timedelta_to_milliseconds(self.extended_timeout)
236
return self._datetime_to_milliseconds(self.timeout)
478
238
def interval_milliseconds(self):
479
239
"Return the 'interval' attribute in milliseconds"
480
return timedelta_to_milliseconds(self.interval)
482
def approval_delay_milliseconds(self):
483
return timedelta_to_milliseconds(self.approval_delay)
486
def config_parser(config):
487
"""Construct a new dict of client settings of this form:
488
{ client_name: {setting_name: value, ...}, ...}
489
with exceptions for any special settings as defined above.
490
NOTE: Must be a pure function. Must return the same result
491
value given the same arguments.
494
for client_name in config.sections():
495
section = dict(config.items(client_name))
496
client = settings[client_name] = {}
498
client["host"] = section["host"]
499
# Reformat values from string types to Python types
500
client["approved_by_default"] = config.getboolean(
501
client_name, "approved_by_default")
502
client["enabled"] = config.getboolean(client_name,
505
client["fingerprint"] = (section["fingerprint"].upper()
507
if "secret" in section:
508
client["secret"] = section["secret"].decode("base64")
509
elif "secfile" in section:
510
with open(os.path.expanduser(os.path.expandvars
511
(section["secfile"])),
513
client["secret"] = secfile.read()
515
raise TypeError("No secret or secfile for section {0}"
517
client["timeout"] = string_to_delta(section["timeout"])
518
client["extended_timeout"] = string_to_delta(
519
section["extended_timeout"])
520
client["interval"] = string_to_delta(section["interval"])
521
client["approval_delay"] = string_to_delta(
522
section["approval_delay"])
523
client["approval_duration"] = string_to_delta(
524
section["approval_duration"])
525
client["checker_command"] = section["checker"]
526
client["last_approval_request"] = None
527
client["last_checked_ok"] = None
528
client["last_checker_status"] = -2
532
def __init__(self, settings, name = None, server_settings=None):
240
return self._datetime_to_milliseconds(self.interval)
242
def __init__(self, name = None, disable_hook=None, config=None):
243
"""Note: the 'checker' key in 'config' sets the
244
'checker_command' attribute and *not* the 'checker'
534
if server_settings is None:
536
self.server_settings = server_settings
537
# adding all client settings
538
for setting, value in settings.iteritems():
539
setattr(self, setting, value)
542
if not hasattr(self, "last_enabled"):
543
self.last_enabled = datetime.datetime.utcnow()
544
if not hasattr(self, "expires"):
545
self.expires = (datetime.datetime.utcnow()
548
self.last_enabled = None
551
logger.debug("Creating client %r", self.name)
249
logger.debug(u"Creating client %r", self.name)
552
250
# Uppercase and remove spaces from fingerprint for later
553
251
# comparison purposes with return value from the fingerprint()
555
logger.debug(" Fingerprint: %s", self.fingerprint)
556
self.created = settings.get("created",
557
datetime.datetime.utcnow())
559
# attributes specific for this server instance
253
self.fingerprint = (config[u"fingerprint"].upper()
255
logger.debug(u" Fingerprint: %s", self.fingerprint)
256
if u"secret" in config:
257
self.secret = config[u"secret"].decode(u"base64")
258
elif u"secfile" in config:
259
with closing(open(os.path.expanduser
261
(config[u"secfile"])))) as secfile:
262
self.secret = secfile.read()
264
raise TypeError(u"No secret or secfile for client %s"
266
self.host = config.get(u"host", u"")
267
self.created = datetime.datetime.utcnow()
269
self.last_enabled = None
270
self.last_checked_ok = None
271
self.timeout = string_to_delta(config[u"timeout"])
272
self.interval = string_to_delta(config[u"interval"])
273
self.disable_hook = disable_hook
560
274
self.checker = None
561
275
self.checker_initiator_tag = None
562
276
self.disable_initiator_tag = None
563
277
self.checker_callback_tag = None
278
self.checker_command = config[u"checker"]
564
279
self.current_checker_command = None
566
self.approvals_pending = 0
567
self.changedstate = (multiprocessing_manager
568
.Condition(multiprocessing_manager
570
self.client_structure = [attr for attr in
571
self.__dict__.iterkeys()
572
if not attr.startswith("_")]
573
self.client_structure.append("client_structure")
575
for name, t in inspect.getmembers(type(self),
579
if not name.startswith("_"):
580
self.client_structure.append(name)
582
# Send notice to process children that client state has changed
583
def send_changedstate(self):
584
with self.changedstate:
585
self.changedstate.notify_all()
280
self.last_connect = None
587
282
def enable(self):
588
283
"""Start this client's checker and timeout hooks"""
589
if getattr(self, "enabled", False):
592
self.expires = datetime.datetime.utcnow() + self.timeout
594
284
self.last_enabled = datetime.datetime.utcnow()
596
self.send_changedstate()
598
def disable(self, quiet=True):
599
"""Disable this client."""
600
if not getattr(self, "enabled", False):
603
logger.info("Disabling client %s", self.name)
604
if getattr(self, "disable_initiator_tag", None) is not None:
605
gobject.source_remove(self.disable_initiator_tag)
606
self.disable_initiator_tag = None
608
if getattr(self, "checker_initiator_tag", None) is not None:
609
gobject.source_remove(self.checker_initiator_tag)
610
self.checker_initiator_tag = None
614
self.send_changedstate()
615
# Do not run this again if called by a gobject.timeout_add
621
def init_checker(self):
622
285
# Schedule a new checker to be started an 'interval' from now,
623
286
# and every interval from then on.
624
if self.checker_initiator_tag is not None:
625
gobject.source_remove(self.checker_initiator_tag)
626
287
self.checker_initiator_tag = (gobject.timeout_add
627
288
(self.interval_milliseconds(),
628
289
self.start_checker))
290
# Also start a new checker *right now*.
629
292
# Schedule a disable() when 'timeout' has passed
630
if self.disable_initiator_tag is not None:
631
gobject.source_remove(self.disable_initiator_tag)
632
293
self.disable_initiator_tag = (gobject.timeout_add
633
294
(self.timeout_milliseconds(),
635
# Also start a new checker *right now*.
299
"""Disable this client."""
300
if not getattr(self, "enabled", False):
302
logger.info(u"Disabling client %s", self.name)
303
if getattr(self, u"disable_initiator_tag", False):
304
gobject.source_remove(self.disable_initiator_tag)
305
self.disable_initiator_tag = None
306
if getattr(self, u"checker_initiator_tag", False):
307
gobject.source_remove(self.checker_initiator_tag)
308
self.checker_initiator_tag = None
310
if self.disable_hook:
311
self.disable_hook(self)
313
# Do not run this again if called by a gobject.timeout_add
317
self.disable_hook = None
638
320
def checker_callback(self, pid, condition, command):
639
321
"""The checker has completed, so take appropriate actions."""
640
322
self.checker_callback_tag = None
641
323
self.checker = None
642
324
if os.WIFEXITED(condition):
643
self.last_checker_status = os.WEXITSTATUS(condition)
644
if self.last_checker_status == 0:
645
logger.info("Checker for %(name)s succeeded",
325
exitstatus = os.WEXITSTATUS(condition)
327
logger.info(u"Checker for %(name)s succeeded",
647
329
self.checked_ok()
649
logger.info("Checker for %(name)s failed",
331
logger.info(u"Checker for %(name)s failed",
652
self.last_checker_status = -1
653
logger.warning("Checker for %(name)s crashed?",
334
logger.warning(u"Checker for %(name)s crashed?",
656
337
def checked_ok(self):
657
"""Assert that the client has been seen, alive and well."""
338
"""Bump up the timeout for this client.
340
This should only be called when the client has been seen,
658
343
self.last_checked_ok = datetime.datetime.utcnow()
659
self.last_checker_status = 0
662
def bump_timeout(self, timeout=None):
663
"""Bump up the timeout for this client."""
665
timeout = self.timeout
666
if self.disable_initiator_tag is not None:
667
gobject.source_remove(self.disable_initiator_tag)
668
self.disable_initiator_tag = None
669
if getattr(self, "enabled", False):
670
self.disable_initiator_tag = (gobject.timeout_add
671
(timedelta_to_milliseconds
672
(timeout), self.disable))
673
self.expires = datetime.datetime.utcnow() + timeout
675
def need_approval(self):
676
self.last_approval_request = datetime.datetime.utcnow()
344
gobject.source_remove(self.disable_initiator_tag)
345
self.disable_initiator_tag = (gobject.timeout_add
346
(self.timeout_milliseconds(),
678
349
def start_checker(self):
679
350
"""Start a new checker subprocess if one is not running.
766
419
if self.checker_callback_tag:
767
420
gobject.source_remove(self.checker_callback_tag)
768
421
self.checker_callback_tag = None
769
if getattr(self, "checker", None) is None:
422
if getattr(self, u"checker", None) is None:
771
logger.debug("Stopping checker for %(name)s", vars(self))
424
logger.debug(u"Stopping checker for %(name)s", vars(self))
773
self.checker.terminate()
426
os.kill(self.checker.pid, signal.SIGTERM)
775
428
#if self.checker.poll() is None:
776
# self.checker.kill()
777
except OSError as error:
429
# os.kill(self.checker.pid, signal.SIGKILL)
430
except OSError, error:
778
431
if error.errno != errno.ESRCH: # No such process
780
433
self.checker = None
783
def dbus_service_property(dbus_interface, signature="v",
784
access="readwrite", byte_arrays=False):
785
"""Decorators for marking methods of a DBusObjectWithProperties to
786
become properties on the D-Bus.
788
The decorated method will be called with no arguments by "Get"
789
and with one argument by "Set".
791
The parameters, where they are supported, are the same as
792
dbus.service.method, except there is only "signature", since the
793
type from Get() and the type sent to Set() is the same.
795
# Encoding deeply encoded byte arrays is not supported yet by the
796
# "Set" method, so we fail early here:
797
if byte_arrays and signature != "ay":
798
raise ValueError("Byte arrays not supported for non-'ay'"
799
" signature {0!r}".format(signature))
801
func._dbus_is_property = True
802
func._dbus_interface = dbus_interface
803
func._dbus_signature = signature
804
func._dbus_access = access
805
func._dbus_name = func.__name__
806
if func._dbus_name.endswith("_dbus_property"):
807
func._dbus_name = func._dbus_name[:-14]
808
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
813
def dbus_interface_annotations(dbus_interface):
814
"""Decorator for marking functions returning interface annotations
818
@dbus_interface_annotations("org.example.Interface")
819
def _foo(self): # Function name does not matter
820
return {"org.freedesktop.DBus.Deprecated": "true",
821
"org.freedesktop.DBus.Property.EmitsChangedSignal":
825
func._dbus_is_interface = True
826
func._dbus_interface = dbus_interface
827
func._dbus_name = dbus_interface
832
def dbus_annotations(annotations):
833
"""Decorator to annotate D-Bus methods, signals or properties
836
@dbus_service_property("org.example.Interface", signature="b",
838
@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
839
"org.freedesktop.DBus.Property."
840
"EmitsChangedSignal": "false"})
841
def Property_dbus_property(self):
842
return dbus.Boolean(False)
845
func._dbus_annotations = annotations
850
class DBusPropertyException(dbus.exceptions.DBusException):
851
"""A base class for D-Bus property-related exceptions
853
def __unicode__(self):
854
return unicode(str(self))
857
class DBusPropertyAccessException(DBusPropertyException):
858
"""A property's access permissions disallows an operation.
863
class DBusPropertyNotFound(DBusPropertyException):
864
"""An attempt was made to access a non-existing property.
869
class DBusObjectWithProperties(dbus.service.Object):
870
"""A D-Bus object with properties.
872
Classes inheriting from this can use the dbus_service_property
873
decorator to expose methods as D-Bus properties. It exposes the
874
standard Get(), Set(), and GetAll() methods on the D-Bus.
878
def _is_dbus_thing(thing):
879
"""Returns a function testing if an attribute is a D-Bus thing
881
If called like _is_dbus_thing("method") it returns a function
882
suitable for use as predicate to inspect.getmembers().
884
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
887
def _get_all_dbus_things(self, thing):
888
"""Returns a generator of (name, attribute) pairs
890
return ((getattr(athing.__get__(self), "_dbus_name",
892
athing.__get__(self))
893
for cls in self.__class__.__mro__
895
inspect.getmembers(cls,
896
self._is_dbus_thing(thing)))
898
def _get_dbus_property(self, interface_name, property_name):
899
"""Returns a bound method if one exists which is a D-Bus
900
property with the specified name and interface.
902
for cls in self.__class__.__mro__:
903
for name, value in (inspect.getmembers
905
self._is_dbus_thing("property"))):
906
if (value._dbus_name == property_name
907
and value._dbus_interface == interface_name):
908
return value.__get__(self)
911
raise DBusPropertyNotFound(self.dbus_object_path + ":"
912
+ interface_name + "."
915
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
917
def Get(self, interface_name, property_name):
918
"""Standard D-Bus property Get() method, see D-Bus standard.
920
prop = self._get_dbus_property(interface_name, property_name)
921
if prop._dbus_access == "write":
922
raise DBusPropertyAccessException(property_name)
924
if not hasattr(value, "variant_level"):
926
return type(value)(value, variant_level=value.variant_level+1)
928
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
929
def Set(self, interface_name, property_name, value):
930
"""Standard D-Bus property Set() method, see D-Bus standard.
932
prop = self._get_dbus_property(interface_name, property_name)
933
if prop._dbus_access == "read":
934
raise DBusPropertyAccessException(property_name)
935
if prop._dbus_get_args_options["byte_arrays"]:
936
# The byte_arrays option is not supported yet on
937
# signatures other than "ay".
938
if prop._dbus_signature != "ay":
939
raise ValueError("Byte arrays not supported for non-"
940
"'ay' signature {0!r}"
941
.format(prop._dbus_signature))
942
value = dbus.ByteArray(b''.join(chr(byte)
946
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
947
out_signature="a{sv}")
948
def GetAll(self, interface_name):
949
"""Standard D-Bus property GetAll() method, see D-Bus
952
Note: Will not include properties with access="write".
955
for name, prop in self._get_all_dbus_things("property"):
957
and interface_name != prop._dbus_interface):
958
# Interface non-empty but did not match
960
# Ignore write-only properties
961
if prop._dbus_access == "write":
964
if not hasattr(value, "variant_level"):
965
properties[name] = value
967
properties[name] = type(value)(value, variant_level=
968
value.variant_level+1)
969
return dbus.Dictionary(properties, signature="sv")
971
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
973
path_keyword='object_path',
974
connection_keyword='connection')
975
def Introspect(self, object_path, connection):
976
"""Overloading of standard D-Bus method.
978
Inserts property tags and interface annotation tags.
980
xmlstring = dbus.service.Object.Introspect(self, object_path,
983
document = xml.dom.minidom.parseString(xmlstring)
984
def make_tag(document, name, prop):
985
e = document.createElement("property")
986
e.setAttribute("name", name)
987
e.setAttribute("type", prop._dbus_signature)
988
e.setAttribute("access", prop._dbus_access)
990
for if_tag in document.getElementsByTagName("interface"):
992
for tag in (make_tag(document, name, prop)
994
in self._get_all_dbus_things("property")
995
if prop._dbus_interface
996
== if_tag.getAttribute("name")):
997
if_tag.appendChild(tag)
998
# Add annotation tags
999
for typ in ("method", "signal", "property"):
1000
for tag in if_tag.getElementsByTagName(typ):
1002
for name, prop in (self.
1003
_get_all_dbus_things(typ)):
1004
if (name == tag.getAttribute("name")
1005
and prop._dbus_interface
1006
== if_tag.getAttribute("name")):
1007
annots.update(getattr
1009
"_dbus_annotations",
1011
for name, value in annots.iteritems():
1012
ann_tag = document.createElement(
1014
ann_tag.setAttribute("name", name)
1015
ann_tag.setAttribute("value", value)
1016
tag.appendChild(ann_tag)
1017
# Add interface annotation tags
1018
for annotation, value in dict(
1019
itertools.chain.from_iterable(
1020
annotations().iteritems()
1021
for name, annotations in
1022
self._get_all_dbus_things("interface")
1023
if name == if_tag.getAttribute("name")
1025
ann_tag = document.createElement("annotation")
1026
ann_tag.setAttribute("name", annotation)
1027
ann_tag.setAttribute("value", value)
1028
if_tag.appendChild(ann_tag)
1029
# Add the names to the return values for the
1030
# "org.freedesktop.DBus.Properties" methods
1031
if (if_tag.getAttribute("name")
1032
== "org.freedesktop.DBus.Properties"):
1033
for cn in if_tag.getElementsByTagName("method"):
1034
if cn.getAttribute("name") == "Get":
1035
for arg in cn.getElementsByTagName("arg"):
1036
if (arg.getAttribute("direction")
1038
arg.setAttribute("name", "value")
1039
elif cn.getAttribute("name") == "GetAll":
1040
for arg in cn.getElementsByTagName("arg"):
1041
if (arg.getAttribute("direction")
1043
arg.setAttribute("name", "props")
1044
xmlstring = document.toxml("utf-8")
1046
except (AttributeError, xml.dom.DOMException,
1047
xml.parsers.expat.ExpatError) as error:
1048
logger.error("Failed to override Introspection method",
1053
def datetime_to_dbus(dt, variant_level=0):
1054
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1056
return dbus.String("", variant_level = variant_level)
1057
return dbus.String(dt.isoformat(),
1058
variant_level=variant_level)
1061
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1062
"""A class decorator; applied to a subclass of
1063
dbus.service.Object, it will add alternate D-Bus attributes with
1064
interface names according to the "alt_interface_names" mapping.
1067
@alternate_dbus_interfaces({"org.example.Interface":
1068
"net.example.AlternateInterface"})
1069
class SampleDBusObject(dbus.service.Object):
1070
@dbus.service.method("org.example.Interface")
1071
def SampleDBusMethod():
1074
The above "SampleDBusMethod" on "SampleDBusObject" will be
1075
reachable via two interfaces: "org.example.Interface" and
1076
"net.example.AlternateInterface", the latter of which will have
1077
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1078
"true", unless "deprecate" is passed with a False value.
1080
This works for methods and signals, and also for D-Bus properties
1081
(from DBusObjectWithProperties) and interfaces (from the
1082
dbus_interface_annotations decorator).
1085
for orig_interface_name, alt_interface_name in (
1086
alt_interface_names.iteritems()):
1088
interface_names = set()
1089
# Go though all attributes of the class
1090
for attrname, attribute in inspect.getmembers(cls):
1091
# Ignore non-D-Bus attributes, and D-Bus attributes
1092
# with the wrong interface name
1093
if (not hasattr(attribute, "_dbus_interface")
1094
or not attribute._dbus_interface
1095
.startswith(orig_interface_name)):
1097
# Create an alternate D-Bus interface name based on
1099
alt_interface = (attribute._dbus_interface
1100
.replace(orig_interface_name,
1101
alt_interface_name))
1102
interface_names.add(alt_interface)
1103
# Is this a D-Bus signal?
1104
if getattr(attribute, "_dbus_is_signal", False):
1105
# Extract the original non-method undecorated
1106
# function by black magic
1107
nonmethod_func = (dict(
1108
zip(attribute.func_code.co_freevars,
1109
attribute.__closure__))["func"]
1111
# Create a new, but exactly alike, function
1112
# object, and decorate it to be a new D-Bus signal
1113
# with the alternate D-Bus interface name
1114
new_function = (dbus.service.signal
1116
attribute._dbus_signature)
1117
(types.FunctionType(
1118
nonmethod_func.func_code,
1119
nonmethod_func.func_globals,
1120
nonmethod_func.func_name,
1121
nonmethod_func.func_defaults,
1122
nonmethod_func.func_closure)))
1123
# Copy annotations, if any
1125
new_function._dbus_annotations = (
1126
dict(attribute._dbus_annotations))
1127
except AttributeError:
1129
# Define a creator of a function to call both the
1130
# original and alternate functions, so both the
1131
# original and alternate signals gets sent when
1132
# the function is called
1133
def fixscope(func1, func2):
1134
"""This function is a scope container to pass
1135
func1 and func2 to the "call_both" function
1136
outside of its arguments"""
1137
def call_both(*args, **kwargs):
1138
"""This function will emit two D-Bus
1139
signals by calling func1 and func2"""
1140
func1(*args, **kwargs)
1141
func2(*args, **kwargs)
1143
# Create the "call_both" function and add it to
1145
attr[attrname] = fixscope(attribute, new_function)
1146
# Is this a D-Bus method?
1147
elif getattr(attribute, "_dbus_is_method", False):
1148
# Create a new, but exactly alike, function
1149
# object. Decorate it to be a new D-Bus method
1150
# with the alternate D-Bus interface name. Add it
1152
attr[attrname] = (dbus.service.method
1154
attribute._dbus_in_signature,
1155
attribute._dbus_out_signature)
1157
(attribute.func_code,
1158
attribute.func_globals,
1159
attribute.func_name,
1160
attribute.func_defaults,
1161
attribute.func_closure)))
1162
# Copy annotations, if any
1164
attr[attrname]._dbus_annotations = (
1165
dict(attribute._dbus_annotations))
1166
except AttributeError:
1168
# Is this a D-Bus property?
1169
elif getattr(attribute, "_dbus_is_property", False):
1170
# Create a new, but exactly alike, function
1171
# object, and decorate it to be a new D-Bus
1172
# property with the alternate D-Bus interface
1173
# name. Add it to the class.
1174
attr[attrname] = (dbus_service_property
1176
attribute._dbus_signature,
1177
attribute._dbus_access,
1179
._dbus_get_args_options
1182
(attribute.func_code,
1183
attribute.func_globals,
1184
attribute.func_name,
1185
attribute.func_defaults,
1186
attribute.func_closure)))
1187
# Copy annotations, if any
1189
attr[attrname]._dbus_annotations = (
1190
dict(attribute._dbus_annotations))
1191
except AttributeError:
1193
# Is this a D-Bus interface?
1194
elif getattr(attribute, "_dbus_is_interface", False):
1195
# Create a new, but exactly alike, function
1196
# object. Decorate it to be a new D-Bus interface
1197
# with the alternate D-Bus interface name. Add it
1199
attr[attrname] = (dbus_interface_annotations
1202
(attribute.func_code,
1203
attribute.func_globals,
1204
attribute.func_name,
1205
attribute.func_defaults,
1206
attribute.func_closure)))
1208
# Deprecate all alternate interfaces
1209
iname="_AlternateDBusNames_interface_annotation{0}"
1210
for interface_name in interface_names:
1211
@dbus_interface_annotations(interface_name)
1213
return { "org.freedesktop.DBus.Deprecated":
1215
# Find an unused name
1216
for aname in (iname.format(i)
1217
for i in itertools.count()):
1218
if aname not in attr:
1222
# Replace the class with a new subclass of it with
1223
# methods, signals, etc. as created above.
1224
cls = type(b"{0}Alternate".format(cls.__name__),
1230
@alternate_dbus_interfaces({"se.recompile.Mandos":
1231
"se.bsnet.fukt.Mandos"})
1232
class ClientDBus(Client, DBusObjectWithProperties):
435
def still_valid(self):
436
"""Has the timeout not yet passed for this client?"""
437
if not getattr(self, u"enabled", False):
439
now = datetime.datetime.utcnow()
440
if self.last_checked_ok is None:
441
return now < (self.created + self.timeout)
443
return now < (self.last_checked_ok + self.timeout)
446
class ClientDBus(Client, dbus.service.Object):
1233
447
"""A Client class using D-Bus
1236
dbus_object_path: dbus.ObjectPath
1237
bus: dbus.SystemBus()
450
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
1240
runtime_expansions = (Client.runtime_expansions
1241
+ ("dbus_object_path",))
1243
452
# dbus.service.Object doesn't use super(), so we can't either.
1245
def __init__(self, bus = None, *args, **kwargs):
454
def __init__(self, *args, **kwargs):
1247
455
Client.__init__(self, *args, **kwargs)
1248
456
# Only now, when this client is initialized, can it show up on
1250
client_object_name = unicode(self.name).translate(
1251
{ord("."): ord("_"),
1252
ord("-"): ord("_")})
1253
458
self.dbus_object_path = (dbus.ObjectPath
1254
("/clients/" + client_object_name))
1255
DBusObjectWithProperties.__init__(self, self.bus,
1256
self.dbus_object_path)
1258
def notifychangeproperty(transform_func,
1259
dbus_name, type_func=lambda x: x,
1261
""" Modify a variable so that it's a property which announces
1262
its changes to DBus.
1264
transform_fun: Function that takes a value and a variant_level
1265
and transforms it to a D-Bus type.
1266
dbus_name: D-Bus name of the variable
1267
type_func: Function that transform the value before sending it
1268
to the D-Bus. Default: no transform
1269
variant_level: D-Bus variant level. Default: 1
1271
attrname = "_{0}".format(dbus_name)
1272
def setter(self, value):
1273
if hasattr(self, "dbus_object_path"):
1274
if (not hasattr(self, attrname) or
1275
type_func(getattr(self, attrname, None))
1276
!= type_func(value)):
1277
dbus_value = transform_func(type_func(value),
1280
self.PropertyChanged(dbus.String(dbus_name),
1282
setattr(self, attrname, value)
1284
return property(lambda self: getattr(self, attrname), setter)
1286
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1287
approvals_pending = notifychangeproperty(dbus.Boolean,
1290
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1291
last_enabled = notifychangeproperty(datetime_to_dbus,
1293
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1294
type_func = lambda checker:
1295
checker is not None)
1296
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1298
last_checker_status = notifychangeproperty(dbus.Int16,
1299
"LastCheckerStatus")
1300
last_approval_request = notifychangeproperty(
1301
datetime_to_dbus, "LastApprovalRequest")
1302
approved_by_default = notifychangeproperty(dbus.Boolean,
1303
"ApprovedByDefault")
1304
approval_delay = notifychangeproperty(dbus.UInt64,
1307
timedelta_to_milliseconds)
1308
approval_duration = notifychangeproperty(
1309
dbus.UInt64, "ApprovalDuration",
1310
type_func = timedelta_to_milliseconds)
1311
host = notifychangeproperty(dbus.String, "Host")
1312
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1314
timedelta_to_milliseconds)
1315
extended_timeout = notifychangeproperty(
1316
dbus.UInt64, "ExtendedTimeout",
1317
type_func = timedelta_to_milliseconds)
1318
interval = notifychangeproperty(dbus.UInt64,
1321
timedelta_to_milliseconds)
1322
checker_command = notifychangeproperty(dbus.String, "Checker")
1324
del notifychangeproperty
460
+ self.name.replace(u".", u"_")))
461
dbus.service.Object.__init__(self, bus,
462
self.dbus_object_path)
464
oldstate = getattr(self, u"enabled", False)
465
r = Client.enable(self)
466
if oldstate != self.enabled:
468
self.PropertyChanged(dbus.String(u"enabled"),
469
dbus.Boolean(True, variant_level=1))
470
self.PropertyChanged(dbus.String(u"last_enabled"),
471
(_datetime_to_dbus(self.last_enabled,
475
def disable(self, signal = True):
476
oldstate = getattr(self, u"enabled", False)
477
r = Client.disable(self)
478
if signal and oldstate != self.enabled:
480
self.PropertyChanged(dbus.String(u"enabled"),
481
dbus.Boolean(False, variant_level=1))
1326
484
def __del__(self, *args, **kwargs):
1328
486
self.remove_from_connection()
1329
487
except LookupError:
1331
if hasattr(DBusObjectWithProperties, "__del__"):
1332
DBusObjectWithProperties.__del__(self, *args, **kwargs)
489
if hasattr(dbus.service.Object, u"__del__"):
490
dbus.service.Object.__del__(self, *args, **kwargs)
1333
491
Client.__del__(self, *args, **kwargs)
1335
493
def checker_callback(self, pid, condition, command,
1336
494
*args, **kwargs):
1337
495
self.checker_callback_tag = None
1338
496
self.checker = None
498
self.PropertyChanged(dbus.String(u"checker_running"),
499
dbus.Boolean(False, variant_level=1))
1339
500
if os.WIFEXITED(condition):
1340
501
exitstatus = os.WEXITSTATUS(condition)
1341
502
# Emit D-Bus signal
1351
512
return Client.checker_callback(self, pid, condition, command,
1352
513
*args, **kwargs)
515
def checked_ok(self, *args, **kwargs):
516
r = Client.checked_ok(self, *args, **kwargs)
518
self.PropertyChanged(
519
dbus.String(u"last_checked_ok"),
520
(_datetime_to_dbus(self.last_checked_ok,
1354
524
def start_checker(self, *args, **kwargs):
1355
old_checker_pid = getattr(self.checker, "pid", None)
525
old_checker = self.checker
526
if self.checker is not None:
527
old_checker_pid = self.checker.pid
529
old_checker_pid = None
1356
530
r = Client.start_checker(self, *args, **kwargs)
1357
531
# Only if new checker process was started
1358
532
if (self.checker is not None
1359
533
and old_checker_pid != self.checker.pid):
1360
534
# Emit D-Bus signal
1361
535
self.CheckerStarted(self.current_checker_command)
1364
def _reset_approved(self):
1365
self.approved = None
1368
def approve(self, value=True):
1369
self.approved = value
1370
gobject.timeout_add(timedelta_to_milliseconds
1371
(self.approval_duration),
1372
self._reset_approved)
1373
self.send_changedstate()
1375
## D-Bus methods, signals & properties
1376
_interface = "se.recompile.Mandos.Client"
1380
@dbus_interface_annotations(_interface)
1382
return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
536
self.PropertyChanged(
537
dbus.String(u"checker_running"),
538
dbus.Boolean(True, variant_level=1))
541
def stop_checker(self, *args, **kwargs):
542
old_checker = getattr(self, u"checker", None)
543
r = Client.stop_checker(self, *args, **kwargs)
544
if (old_checker is not None
545
and getattr(self, u"checker", None) is None):
546
self.PropertyChanged(dbus.String(u"checker_running"),
547
dbus.Boolean(False, variant_level=1))
550
## D-Bus methods & signals
551
_interface = u"se.bsnet.fukt.Mandos.Client"
554
@dbus.service.method(_interface)
556
return self.checked_ok()
1387
558
# CheckerCompleted - signal
1388
@dbus.service.signal(_interface, signature="nxs")
559
@dbus.service.signal(_interface, signature=u"nxs")
1389
560
def CheckerCompleted(self, exitcode, waitstatus, command):
1393
564
# CheckerStarted - signal
1394
@dbus.service.signal(_interface, signature="s")
565
@dbus.service.signal(_interface, signature=u"s")
1395
566
def CheckerStarted(self, command):
570
# GetAllProperties - method
571
@dbus.service.method(_interface, out_signature=u"a{sv}")
572
def GetAllProperties(self):
574
return dbus.Dictionary({
575
dbus.String(u"name"):
576
dbus.String(self.name, variant_level=1),
577
dbus.String(u"fingerprint"):
578
dbus.String(self.fingerprint, variant_level=1),
579
dbus.String(u"host"):
580
dbus.String(self.host, variant_level=1),
581
dbus.String(u"created"):
582
_datetime_to_dbus(self.created, variant_level=1),
583
dbus.String(u"last_enabled"):
584
(_datetime_to_dbus(self.last_enabled,
586
if self.last_enabled is not None
587
else dbus.Boolean(False, variant_level=1)),
588
dbus.String(u"enabled"):
589
dbus.Boolean(self.enabled, variant_level=1),
590
dbus.String(u"last_checked_ok"):
591
(_datetime_to_dbus(self.last_checked_ok,
593
if self.last_checked_ok is not None
594
else dbus.Boolean (False, variant_level=1)),
595
dbus.String(u"timeout"):
596
dbus.UInt64(self.timeout_milliseconds(),
598
dbus.String(u"interval"):
599
dbus.UInt64(self.interval_milliseconds(),
601
dbus.String(u"checker"):
602
dbus.String(self.checker_command,
604
dbus.String(u"checker_running"):
605
dbus.Boolean(self.checker is not None,
607
dbus.String(u"object_path"):
608
dbus.ObjectPath(self.dbus_object_path,
612
# IsStillValid - method
613
@dbus.service.method(_interface, out_signature=u"b")
614
def IsStillValid(self):
615
return self.still_valid()
1399
617
# PropertyChanged - signal
1400
@dbus.service.signal(_interface, signature="sv")
618
@dbus.service.signal(_interface, signature=u"sv")
1401
619
def PropertyChanged(self, property, value):
1405
# GotSecret - signal
623
# ReceivedSecret - signal
1406
624
@dbus.service.signal(_interface)
1407
def GotSecret(self):
1409
Is sent after a successful transfer of secret from the Mandos
1410
server to mandos-client
625
def ReceivedSecret(self):
1414
629
# Rejected - signal
1415
@dbus.service.signal(_interface, signature="s")
1416
def Rejected(self, reason):
630
@dbus.service.signal(_interface)
1420
# NeedApproval - signal
1421
@dbus.service.signal(_interface, signature="tb")
1422
def NeedApproval(self, timeout, default):
1424
return self.need_approval()
1429
@dbus.service.method(_interface, in_signature="b")
1430
def Approve(self, value):
1433
# CheckedOK - method
1434
@dbus.service.method(_interface)
1435
def CheckedOK(self):
635
# SetChecker - method
636
@dbus.service.method(_interface, in_signature=u"s")
637
def SetChecker(self, checker):
638
"D-Bus setter method"
639
self.checker_command = checker
641
self.PropertyChanged(dbus.String(u"checker"),
642
dbus.String(self.checker_command,
646
@dbus.service.method(_interface, in_signature=u"s")
647
def SetHost(self, host):
648
"D-Bus setter method"
651
self.PropertyChanged(dbus.String(u"host"),
652
dbus.String(self.host, variant_level=1))
654
# SetInterval - method
655
@dbus.service.method(_interface, in_signature=u"t")
656
def SetInterval(self, milliseconds):
657
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
659
self.PropertyChanged(dbus.String(u"interval"),
660
(dbus.UInt64(self.interval_milliseconds(),
664
@dbus.service.method(_interface, in_signature=u"ay",
666
def SetSecret(self, secret):
667
"D-Bus setter method"
668
self.secret = str(secret)
670
# SetTimeout - method
671
@dbus.service.method(_interface, in_signature=u"t")
672
def SetTimeout(self, milliseconds):
673
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
675
self.PropertyChanged(dbus.String(u"timeout"),
676
(dbus.UInt64(self.timeout_milliseconds(),
1438
679
# Enable - method
1439
680
@dbus.service.method(_interface)
1458
699
def StopChecker(self):
1459
700
self.stop_checker()
1463
# ApprovalPending - property
1464
@dbus_service_property(_interface, signature="b", access="read")
1465
def ApprovalPending_dbus_property(self):
1466
return dbus.Boolean(bool(self.approvals_pending))
1468
# ApprovedByDefault - property
1469
@dbus_service_property(_interface, signature="b",
1471
def ApprovedByDefault_dbus_property(self, value=None):
1472
if value is None: # get
1473
return dbus.Boolean(self.approved_by_default)
1474
self.approved_by_default = bool(value)
1476
# ApprovalDelay - property
1477
@dbus_service_property(_interface, signature="t",
1479
def ApprovalDelay_dbus_property(self, value=None):
1480
if value is None: # get
1481
return dbus.UInt64(self.approval_delay_milliseconds())
1482
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1484
# ApprovalDuration - property
1485
@dbus_service_property(_interface, signature="t",
1487
def ApprovalDuration_dbus_property(self, value=None):
1488
if value is None: # get
1489
return dbus.UInt64(timedelta_to_milliseconds(
1490
self.approval_duration))
1491
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1494
@dbus_service_property(_interface, signature="s", access="read")
1495
def Name_dbus_property(self):
1496
return dbus.String(self.name)
1498
# Fingerprint - property
1499
@dbus_service_property(_interface, signature="s", access="read")
1500
def Fingerprint_dbus_property(self):
1501
return dbus.String(self.fingerprint)
1504
@dbus_service_property(_interface, signature="s",
1506
def Host_dbus_property(self, value=None):
1507
if value is None: # get
1508
return dbus.String(self.host)
1509
self.host = unicode(value)
1511
# Created - property
1512
@dbus_service_property(_interface, signature="s", access="read")
1513
def Created_dbus_property(self):
1514
return datetime_to_dbus(self.created)
1516
# LastEnabled - property
1517
@dbus_service_property(_interface, signature="s", access="read")
1518
def LastEnabled_dbus_property(self):
1519
return datetime_to_dbus(self.last_enabled)
1521
# Enabled - property
1522
@dbus_service_property(_interface, signature="b",
1524
def Enabled_dbus_property(self, value=None):
1525
if value is None: # get
1526
return dbus.Boolean(self.enabled)
1532
# LastCheckedOK - property
1533
@dbus_service_property(_interface, signature="s",
1535
def LastCheckedOK_dbus_property(self, value=None):
1536
if value is not None:
1539
return datetime_to_dbus(self.last_checked_ok)
1541
# LastCheckerStatus - property
1542
@dbus_service_property(_interface, signature="n",
1544
def LastCheckerStatus_dbus_property(self):
1545
return dbus.Int16(self.last_checker_status)
1547
# Expires - property
1548
@dbus_service_property(_interface, signature="s", access="read")
1549
def Expires_dbus_property(self):
1550
return datetime_to_dbus(self.expires)
1552
# LastApprovalRequest - property
1553
@dbus_service_property(_interface, signature="s", access="read")
1554
def LastApprovalRequest_dbus_property(self):
1555
return datetime_to_dbus(self.last_approval_request)
1557
# Timeout - property
1558
@dbus_service_property(_interface, signature="t",
1560
def Timeout_dbus_property(self, value=None):
1561
if value is None: # get
1562
return dbus.UInt64(self.timeout_milliseconds())
1563
old_timeout = self.timeout
1564
self.timeout = datetime.timedelta(0, 0, 0, value)
1565
# Reschedule disabling
1567
now = datetime.datetime.utcnow()
1568
self.expires += self.timeout - old_timeout
1569
if self.expires <= now:
1570
# The timeout has passed
1573
if (getattr(self, "disable_initiator_tag", None)
1576
gobject.source_remove(self.disable_initiator_tag)
1577
self.disable_initiator_tag = (
1578
gobject.timeout_add(
1579
timedelta_to_milliseconds(self.expires - now),
1582
# ExtendedTimeout - property
1583
@dbus_service_property(_interface, signature="t",
1585
def ExtendedTimeout_dbus_property(self, value=None):
1586
if value is None: # get
1587
return dbus.UInt64(self.extended_timeout_milliseconds())
1588
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1590
# Interval - property
1591
@dbus_service_property(_interface, signature="t",
1593
def Interval_dbus_property(self, value=None):
1594
if value is None: # get
1595
return dbus.UInt64(self.interval_milliseconds())
1596
self.interval = datetime.timedelta(0, 0, 0, value)
1597
if getattr(self, "checker_initiator_tag", None) is None:
1600
# Reschedule checker run
1601
gobject.source_remove(self.checker_initiator_tag)
1602
self.checker_initiator_tag = (gobject.timeout_add
1603
(value, self.start_checker))
1604
self.start_checker() # Start one now, too
1606
# Checker - property
1607
@dbus_service_property(_interface, signature="s",
1609
def Checker_dbus_property(self, value=None):
1610
if value is None: # get
1611
return dbus.String(self.checker_command)
1612
self.checker_command = unicode(value)
1614
# CheckerRunning - property
1615
@dbus_service_property(_interface, signature="b",
1617
def CheckerRunning_dbus_property(self, value=None):
1618
if value is None: # get
1619
return dbus.Boolean(self.checker is not None)
1621
self.start_checker()
1625
# ObjectPath - property
1626
@dbus_service_property(_interface, signature="o", access="read")
1627
def ObjectPath_dbus_property(self):
1628
return self.dbus_object_path # is already a dbus.ObjectPath
1631
@dbus_service_property(_interface, signature="ay",
1632
access="write", byte_arrays=True)
1633
def Secret_dbus_property(self, value):
1634
self.secret = str(value)
1639
class ProxyClient(object):
1640
def __init__(self, child_pipe, fpr, address):
1641
self._pipe = child_pipe
1642
self._pipe.send(('init', fpr, address))
1643
if not self._pipe.recv():
1646
def __getattribute__(self, name):
1648
return super(ProxyClient, self).__getattribute__(name)
1649
self._pipe.send(('getattr', name))
1650
data = self._pipe.recv()
1651
if data[0] == 'data':
1653
if data[0] == 'function':
1654
def func(*args, **kwargs):
1655
self._pipe.send(('funcall', name, args, kwargs))
1656
return self._pipe.recv()[1]
1659
def __setattr__(self, name, value):
1661
return super(ProxyClient, self).__setattr__(name, value)
1662
self._pipe.send(('setattr', name, value))
1665
class ClientHandler(socketserver.BaseRequestHandler, object):
705
class ClientHandler(SocketServer.BaseRequestHandler, object):
1666
706
"""A class to handle client connections.
1668
708
Instantiated once for each connection to handle it.
1669
709
Note: This will run in its own forked process."""
1671
711
def handle(self):
1672
with contextlib.closing(self.server.child_pipe) as child_pipe:
1673
logger.info("TCP connection from: %s",
1674
unicode(self.client_address))
1675
logger.debug("Pipe FD: %d",
1676
self.server.child_pipe.fileno())
712
logger.info(u"TCP connection from: %s",
713
unicode(self.client_address))
714
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
715
# Open IPC pipe to parent process
716
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1678
717
session = (gnutls.connection
1679
718
.ClientSession(self.request,
1680
719
gnutls.connection
1681
720
.X509Credentials()))
722
line = self.request.makefile().readline()
723
logger.debug(u"Protocol version: %r", line)
725
if int(line.strip().split()[0]) > 1:
727
except (ValueError, IndexError, RuntimeError), error:
728
logger.error(u"Unknown protocol version: %s", error)
1683
731
# Note: gnutls.connection.X509Credentials is really a
1684
732
# generic GnuTLS certificate credentials object so long as
1685
733
# no X.509 keys are added to it. Therefore, we can use it
1686
734
# here despite using OpenPGP certificates.
1688
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1689
# "+AES-256-CBC", "+SHA1",
1690
# "+COMP-NULL", "+CTYPE-OPENPGP",
736
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
737
# u"+AES-256-CBC", u"+SHA1",
738
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1692
740
# Use a fallback default, since this MUST be set.
1693
741
priority = self.server.gnutls_priority
1694
742
if priority is None:
1696
744
(gnutls.library.functions
1697
745
.gnutls_priority_set_direct(session._c_object,
1698
746
priority, None))
1700
# Start communication using the Mandos protocol
1701
# Get protocol number
1702
line = self.request.makefile().readline()
1703
logger.debug("Protocol version: %r", line)
1705
if int(line.strip().split()[0]) > 1:
1706
raise RuntimeError(line)
1707
except (ValueError, IndexError, RuntimeError) as error:
1708
logger.error("Unknown protocol version: %s", error)
1711
# Start GnuTLS connection
1713
749
session.handshake()
1714
except gnutls.errors.GNUTLSError as error:
1715
logger.warning("Handshake failed: %s", error)
750
except gnutls.errors.GNUTLSError, error:
751
logger.warning(u"Handshake failed: %s", error)
1716
752
# Do not run session.bye() here: the session is not
1717
753
# established. Just abandon the request.
1719
logger.debug("Handshake succeeded")
1721
approval_required = False
755
logger.debug(u"Handshake succeeded")
1724
fpr = self.fingerprint(self.peer_certificate
1727
gnutls.errors.GNUTLSError) as error:
1728
logger.warning("Bad certificate: %s", error)
1730
logger.debug("Fingerprint: %s", fpr)
1733
client = ProxyClient(child_pipe, fpr,
1734
self.client_address)
1738
if client.approval_delay:
1739
delay = client.approval_delay
1740
client.approvals_pending += 1
1741
approval_required = True
1744
if not client.enabled:
1745
logger.info("Client %s is disabled",
1747
if self.server.use_dbus:
1749
client.Rejected("Disabled")
1752
if client.approved or not client.approval_delay:
1753
#We are approved or approval is disabled
1755
elif client.approved is None:
1756
logger.info("Client %s needs approval",
1758
if self.server.use_dbus:
1760
client.NeedApproval(
1761
client.approval_delay_milliseconds(),
1762
client.approved_by_default)
1764
logger.warning("Client %s was not approved",
1766
if self.server.use_dbus:
1768
client.Rejected("Denied")
1771
#wait until timeout or approved
1772
time = datetime.datetime.now()
1773
client.changedstate.acquire()
1774
client.changedstate.wait(
1775
float(timedelta_to_milliseconds(delay)
1777
client.changedstate.release()
1778
time2 = datetime.datetime.now()
1779
if (time2 - time) >= delay:
1780
if not client.approved_by_default:
1781
logger.warning("Client %s timed out while"
1782
" waiting for approval",
1784
if self.server.use_dbus:
1786
client.Rejected("Approval timed out")
1791
delay -= time2 - time
1794
while sent_size < len(client.secret):
1796
sent = session.send(client.secret[sent_size:])
1797
except gnutls.errors.GNUTLSError as error:
1798
logger.warning("gnutls send failed",
1801
logger.debug("Sent: %d, remaining: %d",
1802
sent, len(client.secret)
1803
- (sent_size + sent))
1806
logger.info("Sending secret to %s", client.name)
1807
# bump the timeout using extended_timeout
1808
client.bump_timeout(client.extended_timeout)
1809
if self.server.use_dbus:
757
fpr = self.fingerprint(self.peer_certificate(session))
758
except (TypeError, gnutls.errors.GNUTLSError), error:
759
logger.warning(u"Bad certificate: %s", error)
762
logger.debug(u"Fingerprint: %s", fpr)
1814
if approval_required:
1815
client.approvals_pending -= 1
1818
except gnutls.errors.GNUTLSError as error:
1819
logger.warning("GnuTLS bye failed",
764
for c in self.server.clients:
765
if c.fingerprint == fpr:
769
ipc.write(u"NOTFOUND %s\n" % fpr)
772
# Have to check if client.still_valid(), since it is
773
# possible that the client timed out while establishing
774
# the GnuTLS session.
775
if not client.still_valid():
776
ipc.write(u"INVALID %s\n" % client.name)
779
ipc.write(u"SENDING %s\n" % client.name)
781
while sent_size < len(client.secret):
782
sent = session.send(client.secret[sent_size:])
783
logger.debug(u"Sent: %d, remaining: %d",
784
sent, len(client.secret)
785
- (sent_size + sent))
1823
790
def peer_certificate(session):
1879
846
# Convert the buffer to a Python bytestring
1880
847
fpr = ctypes.string_at(buf, buf_len.value)
1881
848
# Convert the bytestring to hexadecimal notation
1882
hex_fpr = binascii.hexlify(fpr).upper()
849
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1886
class MultiprocessingMixIn(object):
1887
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1888
def sub_process_main(self, request, address):
1890
self.finish_request(request, address)
1892
self.handle_error(request, address)
1893
self.close_request(request)
853
class ForkingMixInWithPipe(SocketServer.ForkingMixIn, object):
854
"""Like SocketServer.ForkingMixIn, but also pass a pipe.
1895
def process_request(self, request, address):
1896
"""Start a new process to process the request."""
1897
proc = multiprocessing.Process(target = self.sub_process_main,
1898
args = (request, address))
1903
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1904
""" adds a pipe to the MixIn """
856
Assumes a gobject.MainLoop event loop.
1905
858
def process_request(self, request, client_address):
1906
859
"""Overrides and wraps the original process_request().
1908
This function creates a new pipe in self.pipe
861
This function creates a new pipe in self.pipe
1910
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1912
proc = MultiprocessingMixIn.process_request(self, request,
1914
self.child_pipe.close()
1915
self.add_pipe(parent_pipe, proc)
1917
def add_pipe(self, parent_pipe, proc):
863
self.pipe = os.pipe()
864
super(ForkingMixInWithPipe,
865
self).process_request(request, client_address)
866
os.close(self.pipe[1]) # close write end
867
# Call "handle_ipc" for both data and EOF events
868
gobject.io_add_watch(self.pipe[0],
869
gobject.IO_IN | gobject.IO_HUP,
871
def handle_ipc(source, condition):
1918
872
"""Dummy function; override as necessary"""
1919
raise NotImplementedError()
1922
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1923
socketserver.TCPServer, object):
877
class IPv6_TCPServer(ForkingMixInWithPipe,
878
SocketServer.TCPServer, object):
1924
879
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1927
882
enabled: Boolean; whether this server is activated yet
1928
883
interface: None or a network interface name (string)
1929
884
use_ipv6: Boolean; to use IPv6 or not
886
clients: Set() of Client objects
887
gnutls_priority GnuTLS priority string
888
use_dbus: Boolean; to emit D-Bus signals or not
1931
890
def __init__(self, server_address, RequestHandlerClass,
1932
interface=None, use_ipv6=True, socketfd=None):
1933
"""If socketfd is set, use that file descriptor instead of
1934
creating a new one with socket.socket().
891
interface=None, use_ipv6=True, clients=None,
892
gnutls_priority=None, use_dbus=True):
1936
894
self.interface = interface
1938
896
self.address_family = socket.AF_INET6
1939
if socketfd is not None:
1940
# Save the file descriptor
1941
self.socketfd = socketfd
1942
# Save the original socket.socket() function
1943
self.socket_socket = socket.socket
1944
# To implement --socket, we monkey patch socket.socket.
1946
# (When socketserver.TCPServer is a new-style class, we
1947
# could make self.socket into a property instead of monkey
1948
# patching socket.socket.)
1950
# Create a one-time-only replacement for socket.socket()
1951
@functools.wraps(socket.socket)
1952
def socket_wrapper(*args, **kwargs):
1953
# Restore original function so subsequent calls are
1955
socket.socket = self.socket_socket
1956
del self.socket_socket
1957
# This time only, return a new socket object from the
1958
# saved file descriptor.
1959
return socket.fromfd(self.socketfd, *args, **kwargs)
1960
# Replace socket.socket() function with wrapper
1961
socket.socket = socket_wrapper
1962
# The socketserver.TCPServer.__init__ will call
1963
# socket.socket(), which might be our replacement,
1964
# socket_wrapper(), if socketfd was set.
1965
socketserver.TCPServer.__init__(self, server_address,
897
self.clients = clients
898
self.use_dbus = use_dbus
899
self.gnutls_priority = gnutls_priority
900
SocketServer.TCPServer.__init__(self, server_address,
1966
901
RequestHandlerClass)
1968
902
def server_bind(self):
1969
903
"""This overrides the normal server_bind() function
1970
904
to bind to an interface if one was specified, and also NOT to
1971
905
bind to an address or port if they were not specified."""
1972
906
if self.interface is not None:
1973
if SO_BINDTODEVICE is None:
1974
logger.error("SO_BINDTODEVICE does not exist;"
1975
" cannot bind to interface %s",
1979
self.socket.setsockopt(socket.SOL_SOCKET,
1981
str(self.interface + '\0'))
1982
except socket.error as error:
1983
if error.errno == errno.EPERM:
1984
logger.error("No permission to bind to"
1985
" interface %s", self.interface)
1986
elif error.errno == errno.ENOPROTOOPT:
1987
logger.error("SO_BINDTODEVICE not available;"
1988
" cannot bind to interface %s",
1990
elif error.errno == errno.ENODEV:
1991
logger.error("Interface %s does not exist,"
1992
" cannot bind", self.interface)
908
self.socket.setsockopt(socket.SOL_SOCKET,
910
str(self.interface + u'\0'))
911
except socket.error, error:
912
if error[0] == errno.EPERM:
913
logger.error(u"No permission to"
914
u" bind to interface %s",
1995
918
# Only bind(2) the socket if we really need to.
1996
919
if self.server_address[0] or self.server_address[1]:
1997
920
if not self.server_address[0]:
1998
921
if self.address_family == socket.AF_INET6:
1999
any_address = "::" # in6addr_any
922
any_address = u"::" # in6addr_any
2001
any_address = "0.0.0.0" # INADDR_ANY
924
any_address = socket.INADDR_ANY
2002
925
self.server_address = (any_address,
2003
926
self.server_address[1])
2004
927
elif not self.server_address[1]:
2011
934
# if_nametoindex
2012
935
# (self.interface))
2013
return socketserver.TCPServer.server_bind(self)
2016
class MandosServer(IPv6_TCPServer):
2020
clients: set of Client objects
2021
gnutls_priority GnuTLS priority string
2022
use_dbus: Boolean; to emit D-Bus signals or not
2024
Assumes a gobject.MainLoop event loop.
2026
def __init__(self, server_address, RequestHandlerClass,
2027
interface=None, use_ipv6=True, clients=None,
2028
gnutls_priority=None, use_dbus=True, socketfd=None):
2029
self.enabled = False
2030
self.clients = clients
2031
if self.clients is None:
2033
self.use_dbus = use_dbus
2034
self.gnutls_priority = gnutls_priority
2035
IPv6_TCPServer.__init__(self, server_address,
2036
RequestHandlerClass,
2037
interface = interface,
2038
use_ipv6 = use_ipv6,
2039
socketfd = socketfd)
936
return SocketServer.TCPServer.server_bind(self)
2040
937
def server_activate(self):
2041
938
if self.enabled:
2042
return socketserver.TCPServer.server_activate(self)
939
return SocketServer.TCPServer.server_activate(self)
2044
940
def enable(self):
2045
941
self.enabled = True
2047
def add_pipe(self, parent_pipe, proc):
2048
# Call "handle_ipc" for both data and EOF events
2049
gobject.io_add_watch(parent_pipe.fileno(),
2050
gobject.IO_IN | gobject.IO_HUP,
2051
functools.partial(self.handle_ipc,
2056
def handle_ipc(self, source, condition, parent_pipe=None,
2057
proc = None, client_object=None):
2058
# error, or the other end of multiprocessing.Pipe has closed
2059
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2060
# Wait for other process to exit
2064
# Read a request from the child
2065
request = parent_pipe.recv()
2066
command = request[0]
2068
if command == 'init':
2070
address = request[2]
2072
for c in self.clients.itervalues():
2073
if c.fingerprint == fpr:
2077
logger.info("Client not found for fingerprint: %s, ad"
2078
"dress: %s", fpr, address)
2081
mandos_dbus_service.ClientNotFound(fpr,
2083
parent_pipe.send(False)
2086
gobject.io_add_watch(parent_pipe.fileno(),
2087
gobject.IO_IN | gobject.IO_HUP,
2088
functools.partial(self.handle_ipc,
2094
parent_pipe.send(True)
2095
# remove the old hook in favor of the new above hook on
2098
if command == 'funcall':
2099
funcname = request[1]
2103
parent_pipe.send(('data', getattr(client_object,
2107
if command == 'getattr':
2108
attrname = request[1]
2109
if callable(client_object.__getattribute__(attrname)):
2110
parent_pipe.send(('function',))
2112
parent_pipe.send(('data', client_object
2113
.__getattribute__(attrname)))
2115
if command == 'setattr':
2116
attrname = request[1]
2118
setattr(client_object, attrname, value)
942
def handle_ipc(self, source, condition, file_objects={}):
944
gobject.IO_IN: u"IN", # There is data to read.
945
gobject.IO_OUT: u"OUT", # Data can be written (without
947
gobject.IO_PRI: u"PRI", # There is urgent data to read.
948
gobject.IO_ERR: u"ERR", # Error condition.
949
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
950
# broken, usually for pipes and
953
conditions_string = ' | '.join(name
955
condition_names.iteritems()
957
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
960
# Turn the pipe file descriptor into a Python file object
961
if source not in file_objects:
962
file_objects[source] = os.fdopen(source, u"r", 1)
964
# Read a line from the file object
965
cmdline = file_objects[source].readline()
966
if not cmdline: # Empty line means end of file
968
file_objects[source].close()
969
del file_objects[source]
971
# Stop calling this function
974
logger.debug(u"IPC command: %r", cmdline)
976
# Parse and act on command
977
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
979
if cmd == u"NOTFOUND":
980
logger.warning(u"Client not found for fingerprint: %s",
984
mandos_dbus_service.ClientNotFound(args)
985
elif cmd == u"INVALID":
986
for client in self.clients:
987
if client.name == args:
988
logger.warning(u"Client %s is invalid", args)
994
logger.error(u"Unknown client %s is invalid", args)
995
elif cmd == u"SENDING":
996
for client in self.clients:
997
if client.name == args:
998
logger.info(u"Sending secret to %s", client.name)
1002
client.ReceivedSecret()
1005
logger.error(u"Sending secret to unknown client %s",
1008
logger.error(u"Unknown IPC command: %r", cmdline)
1010
# Keep calling this function
2123
def rfc3339_duration_to_delta(duration):
2124
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2126
>>> rfc3339_duration_to_delta("P7D")
2127
datetime.timedelta(7)
2128
>>> rfc3339_duration_to_delta("PT60S")
2129
datetime.timedelta(0, 60)
2130
>>> rfc3339_duration_to_delta("PT60M")
2131
datetime.timedelta(0, 3600)
2132
>>> rfc3339_duration_to_delta("PT24H")
2133
datetime.timedelta(1)
2134
>>> rfc3339_duration_to_delta("P1W")
2135
datetime.timedelta(7)
2136
>>> rfc3339_duration_to_delta("PT5M30S")
2137
datetime.timedelta(0, 330)
2138
>>> rfc3339_duration_to_delta("P1DT3M20S")
2139
datetime.timedelta(1, 200)
2142
# Parsing an RFC 3339 duration with regular expressions is not
2143
# possible - there would have to be multiple places for the same
2144
# values, like seconds. The current code, while more esoteric, is
2145
# cleaner without depending on a parsing library. If Python had a
2146
# built-in library for parsing we would use it, but we'd like to
2147
# avoid excessive use of external libraries.
2149
# New type for defining tokens, syntax, and semantics all-in-one
2150
Token = collections.namedtuple("Token",
2151
("regexp", # To match token; if
2152
# "value" is not None,
2153
# must have a "group"
2155
"value", # datetime.timedelta or
2157
"followers")) # Tokens valid after
2159
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2160
# the "duration" ABNF definition in RFC 3339, Appendix A.
2161
token_end = Token(re.compile(r"$"), None, frozenset())
2162
token_second = Token(re.compile(r"(\d+)S"),
2163
datetime.timedelta(seconds=1),
2164
frozenset((token_end,)))
2165
token_minute = Token(re.compile(r"(\d+)M"),
2166
datetime.timedelta(minutes=1),
2167
frozenset((token_second, token_end)))
2168
token_hour = Token(re.compile(r"(\d+)H"),
2169
datetime.timedelta(hours=1),
2170
frozenset((token_minute, token_end)))
2171
token_time = Token(re.compile(r"T"),
2173
frozenset((token_hour, token_minute,
2175
token_day = Token(re.compile(r"(\d+)D"),
2176
datetime.timedelta(days=1),
2177
frozenset((token_time, token_end)))
2178
token_month = Token(re.compile(r"(\d+)M"),
2179
datetime.timedelta(weeks=4),
2180
frozenset((token_day, token_end)))
2181
token_year = Token(re.compile(r"(\d+)Y"),
2182
datetime.timedelta(weeks=52),
2183
frozenset((token_month, token_end)))
2184
token_week = Token(re.compile(r"(\d+)W"),
2185
datetime.timedelta(weeks=1),
2186
frozenset((token_end,)))
2187
token_duration = Token(re.compile(r"P"), None,
2188
frozenset((token_year, token_month,
2189
token_day, token_time,
2191
# Define starting values
2192
value = datetime.timedelta() # Value so far
2194
followers = frozenset(token_duration,) # Following valid tokens
2195
s = duration # String left to parse
2196
# Loop until end token is found
2197
while found_token is not token_end:
2198
# Search for any currently valid tokens
2199
for token in followers:
2200
match = token.regexp.match(s)
2201
if match is not None:
2203
if token.value is not None:
2204
# Value found, parse digits
2205
factor = int(match.group(1), 10)
2206
# Add to value so far
2207
value += factor * token.value
2208
# Strip token from string
2209
s = token.regexp.sub("", s, 1)
2212
# Set valid next tokens
2213
followers = found_token.followers
2216
# No currently valid tokens were found
2217
raise ValueError("Invalid RFC 3339 duration")
2222
1014
def string_to_delta(interval):
2223
1015
"""Parse a string and return a datetime.timedelta
2225
>>> string_to_delta('7d')
1017
>>> string_to_delta(u'7d')
2226
1018
datetime.timedelta(7)
2227
>>> string_to_delta('60s')
1019
>>> string_to_delta(u'60s')
2228
1020
datetime.timedelta(0, 60)
2229
>>> string_to_delta('60m')
1021
>>> string_to_delta(u'60m')
2230
1022
datetime.timedelta(0, 3600)
2231
>>> string_to_delta('24h')
1023
>>> string_to_delta(u'24h')
2232
1024
datetime.timedelta(1)
2233
>>> string_to_delta('1w')
1025
>>> string_to_delta(u'1w')
2234
1026
datetime.timedelta(7)
2235
>>> string_to_delta('5m 30s')
1027
>>> string_to_delta(u'5m 30s')
2236
1028
datetime.timedelta(0, 330)
2240
return rfc3339_duration_to_delta(interval)
2244
1030
timevalue = datetime.timedelta(0)
2245
1031
for s in interval.split():
2247
1033
suffix = unicode(s[-1])
2248
1034
value = int(s[:-1])
2250
1036
delta = datetime.timedelta(value)
1037
elif suffix == u"s":
2252
1038
delta = datetime.timedelta(0, value)
1039
elif suffix == u"m":
2254
1040
delta = datetime.timedelta(0, 0, 0, 0, value)
1041
elif suffix == u"h":
2256
1042
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1043
elif suffix == u"w":
2258
1044
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2260
raise ValueError("Unknown suffix {0!r}"
2262
except IndexError as e:
2263
raise ValueError(*(e.args))
1047
except (ValueError, IndexError):
2264
1049
timevalue += delta
2265
1050
return timevalue
1053
def server_state_changed(state):
1054
"""Derived from the Avahi example code"""
1055
if state == avahi.SERVER_COLLISION:
1056
logger.error(u"Zeroconf server name collision")
1058
elif state == avahi.SERVER_RUNNING:
1062
def entry_group_state_changed(state, error):
1063
"""Derived from the Avahi example code"""
1064
logger.debug(u"Avahi state change: %i", state)
1066
if state == avahi.ENTRY_GROUP_ESTABLISHED:
1067
logger.debug(u"Zeroconf service established.")
1068
elif state == avahi.ENTRY_GROUP_COLLISION:
1069
logger.warning(u"Zeroconf service name collision.")
1071
elif state == avahi.ENTRY_GROUP_FAILURE:
1072
logger.critical(u"Avahi: Error in group state changed %s",
1074
raise AvahiGroupError(u"State changed: %s" % unicode(error))
1076
def if_nametoindex(interface):
1077
"""Call the C function if_nametoindex(), or equivalent
1079
Note: This function cannot accept a unicode string."""
1080
global if_nametoindex
1082
if_nametoindex = (ctypes.cdll.LoadLibrary
1083
(ctypes.util.find_library(u"c"))
1085
except (OSError, AttributeError):
1086
logger.warning(u"Doing if_nametoindex the hard way")
1087
def if_nametoindex(interface):
1088
"Get an interface index the hard way, i.e. using fcntl()"
1089
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1090
with closing(socket.socket()) as s:
1091
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1092
struct.pack(str(u"16s16x"),
1094
interface_index = struct.unpack(str(u"I"),
1096
return interface_index
1097
return if_nametoindex(interface)
2268
1100
def daemon(nochdir = False, noclose = False):
2269
1101
"""See daemon(3). Standard BSD Unix function.
2295
##################################################################
1126
######################################################################
2296
1127
# Parsing of options, both command line and config file
2298
parser = argparse.ArgumentParser()
2299
parser.add_argument("-v", "--version", action="version",
2300
version = "%(prog)s {0}".format(version),
2301
help="show version number and exit")
2302
parser.add_argument("-i", "--interface", metavar="IF",
2303
help="Bind to interface IF")
2304
parser.add_argument("-a", "--address",
2305
help="Address to listen for requests on")
2306
parser.add_argument("-p", "--port", type=int,
2307
help="Port number to receive requests on")
2308
parser.add_argument("--check", action="store_true",
2309
help="Run self-test")
2310
parser.add_argument("--debug", action="store_true",
2311
help="Debug mode; run in foreground and log"
2312
" to terminal", default=None)
2313
parser.add_argument("--debuglevel", metavar="LEVEL",
2314
help="Debug level for stdout output")
2315
parser.add_argument("--priority", help="GnuTLS"
2316
" priority string (see GnuTLS documentation)")
2317
parser.add_argument("--servicename",
2318
metavar="NAME", help="Zeroconf service name")
2319
parser.add_argument("--configdir",
2320
default="/etc/mandos", metavar="DIR",
2321
help="Directory to search for configuration"
2323
parser.add_argument("--no-dbus", action="store_false",
2324
dest="use_dbus", help="Do not provide D-Bus"
2325
" system bus interface", default=None)
2326
parser.add_argument("--no-ipv6", action="store_false",
2327
dest="use_ipv6", help="Do not use IPv6",
2329
parser.add_argument("--no-restore", action="store_false",
2330
dest="restore", help="Do not restore stored"
2331
" state", default=None)
2332
parser.add_argument("--socket", type=int,
2333
help="Specify a file descriptor to a network"
2334
" socket to use instead of creating one")
2335
parser.add_argument("--statedir", metavar="DIR",
2336
help="Directory to save/restore state in")
2337
parser.add_argument("--foreground", action="store_true",
2338
help="Run in foreground", default=None)
2340
options = parser.parse_args()
1129
parser = optparse.OptionParser(version = "%%prog %s" % version)
1130
parser.add_option("-i", u"--interface", type=u"string",
1131
metavar="IF", help=u"Bind to interface IF")
1132
parser.add_option("-a", u"--address", type=u"string",
1133
help=u"Address to listen for requests on")
1134
parser.add_option("-p", u"--port", type=u"int",
1135
help=u"Port number to receive requests on")
1136
parser.add_option("--check", action=u"store_true",
1137
help=u"Run self-test")
1138
parser.add_option("--debug", action=u"store_true",
1139
help=u"Debug mode; run in foreground and log to"
1141
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1142
u" priority string (see GnuTLS documentation)")
1143
parser.add_option("--servicename", type=u"string",
1144
metavar=u"NAME", help=u"Zeroconf service name")
1145
parser.add_option("--configdir", type=u"string",
1146
default=u"/etc/mandos", metavar=u"DIR",
1147
help=u"Directory to search for configuration"
1149
parser.add_option("--no-dbus", action=u"store_false",
1150
dest=u"use_dbus", help=u"Do not provide D-Bus"
1151
u" system bus interface")
1152
parser.add_option("--no-ipv6", action=u"store_false",
1153
dest=u"use_ipv6", help=u"Do not use IPv6")
1154
options = parser.parse_args()[0]
2342
1156
if options.check:
2344
fail_count, test_count = doctest.testmod()
2345
sys.exit(os.EX_OK if fail_count == 0 else 1)
2347
1161
# Default values for config file for server-global settings
2348
server_defaults = { "interface": "",
2353
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2354
"servicename": "Mandos",
2360
"statedir": "/var/lib/mandos",
2361
"foreground": "False",
1162
server_defaults = { u"interface": u"",
1167
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1168
u"servicename": u"Mandos",
1169
u"use_dbus": u"True",
1170
u"use_ipv6": u"True",
2364
1173
# Parse config file for server-global settings
2365
server_config = configparser.SafeConfigParser(server_defaults)
1174
server_config = ConfigParser.SafeConfigParser(server_defaults)
2366
1175
del server_defaults
2367
1176
server_config.read(os.path.join(options.configdir,
2369
1178
# Convert the SafeConfigParser object to a dict
2370
1179
server_settings = server_config.defaults()
2371
1180
# Use the appropriate methods on the non-string config options
2372
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2373
server_settings[option] = server_config.getboolean("DEFAULT",
1181
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1182
server_settings[option] = server_config.getboolean(u"DEFAULT",
2375
1184
if server_settings["port"]:
2376
server_settings["port"] = server_config.getint("DEFAULT",
2378
if server_settings["socket"]:
2379
server_settings["socket"] = server_config.getint("DEFAULT",
2381
# Later, stdin will, and stdout and stderr might, be dup'ed
2382
# over with an opened os.devnull. But we don't want this to
2383
# happen with a supplied network socket.
2384
if 0 <= server_settings["socket"] <= 2:
2385
server_settings["socket"] = os.dup(server_settings
1185
server_settings["port"] = server_config.getint(u"DEFAULT",
2387
1187
del server_config
2389
1189
# Override the settings from the config file with command line
2390
1190
# options, if set.
2391
for option in ("interface", "address", "port", "debug",
2392
"priority", "servicename", "configdir",
2393
"use_dbus", "use_ipv6", "debuglevel", "restore",
2394
"statedir", "socket", "foreground"):
1191
for option in (u"interface", u"address", u"port", u"debug",
1192
u"priority", u"servicename", u"configdir",
1193
u"use_dbus", u"use_ipv6"):
2395
1194
value = getattr(options, option)
2396
1195
if value is not None:
2397
1196
server_settings[option] = value
2400
1199
for option in server_settings.keys():
2401
1200
if type(server_settings[option]) is str:
2402
1201
server_settings[option] = unicode(server_settings[option])
2403
# Force all boolean options to be boolean
2404
for option in ("debug", "use_dbus", "use_ipv6", "restore",
2406
server_settings[option] = bool(server_settings[option])
2407
# Debug implies foreground
2408
if server_settings["debug"]:
2409
server_settings["foreground"] = True
2410
1202
# Now we have our good server settings in "server_settings"
2412
1204
##################################################################
2414
1206
# For convenience
2415
debug = server_settings["debug"]
2416
debuglevel = server_settings["debuglevel"]
2417
use_dbus = server_settings["use_dbus"]
2418
use_ipv6 = server_settings["use_ipv6"]
2419
stored_state_path = os.path.join(server_settings["statedir"],
2421
foreground = server_settings["foreground"]
2424
initlogger(debug, logging.DEBUG)
2429
level = getattr(logging, debuglevel.upper())
2430
initlogger(debug, level)
2432
if server_settings["servicename"] != "Mandos":
1207
debug = server_settings[u"debug"]
1208
use_dbus = server_settings[u"use_dbus"]
1209
use_ipv6 = server_settings[u"use_ipv6"]
1212
syslogger.setLevel(logging.WARNING)
1213
console.setLevel(logging.WARNING)
1215
if server_settings[u"servicename"] != u"Mandos":
2433
1216
syslogger.setFormatter(logging.Formatter
2434
('Mandos ({0}) [%(process)d]:'
2435
' %(levelname)s: %(message)s'
2436
.format(server_settings
1217
(u'Mandos (%s) [%%(process)d]:'
1218
u' %%(levelname)s: %%(message)s'
1219
% server_settings[u"servicename"]))
2439
1221
# Parse config file with clients
2440
client_config = configparser.SafeConfigParser(Client
2442
client_config.read(os.path.join(server_settings["configdir"],
1222
client_defaults = { u"timeout": u"1h",
1224
u"checker": u"fping -q -- %%(host)s",
1227
client_config = ConfigParser.SafeConfigParser(client_defaults)
1228
client_config.read(os.path.join(server_settings[u"configdir"],
2445
1231
global mandos_dbus_service
2446
1232
mandos_dbus_service = None
2448
tcp_server = MandosServer((server_settings["address"],
2449
server_settings["port"]),
2451
interface=(server_settings["interface"]
2455
server_settings["priority"],
2457
socketfd=(server_settings["socket"]
2460
pidfilename = "/run/mandos.pid"
2461
if not os.path.isdir("/run/."):
2462
pidfilename = "/var/run/mandos.pid"
2465
pidfile = open(pidfilename, "w")
2466
except IOError as e:
2467
logger.error("Could not open file %r", pidfilename,
1235
tcp_server = IPv6_TCPServer((server_settings[u"address"],
1236
server_settings[u"port"]),
1239
server_settings[u"interface"],
1243
server_settings[u"priority"],
1245
pidfilename = u"/var/run/mandos.pid"
1247
pidfile = open(pidfilename, u"w")
1249
logger.error(u"Could not open file %r", pidfilename)
2470
for name in ("_mandos", "mandos", "nobody"):
1252
uid = pwd.getpwnam(u"_mandos").pw_uid
1253
gid = pwd.getpwnam(u"_mandos").pw_gid
2472
uid = pwd.getpwnam(name).pw_uid
2473
gid = pwd.getpwnam(name).pw_gid
1256
uid = pwd.getpwnam(u"mandos").pw_uid
1257
gid = pwd.getpwnam(u"mandos").pw_gid
2475
1258
except KeyError:
1260
uid = pwd.getpwnam(u"nobody").pw_uid
1261
gid = pwd.getpwnam(u"nobody").pw_gid
2483
except OSError as error:
2484
if error.errno != errno.EPERM:
1268
except OSError, error:
1269
if error[0] != errno.EPERM:
1272
# Enable all possible GnuTLS debugging
2488
# Enable all possible GnuTLS debugging
2490
1274
# "Use a log level over 10 to enable all debugging options."
2491
1275
# - GnuTLS manual
2492
1276
gnutls.library.functions.gnutls_global_set_log_level(11)
2494
1278
@gnutls.library.types.gnutls_log_func
2495
1279
def debug_gnutls(level, string):
2496
logger.debug("GnuTLS: %s", string[:-1])
1280
logger.debug(u"GnuTLS: %s", string[:-1])
2498
1282
(gnutls.library.functions
2499
1283
.gnutls_global_set_log_function(debug_gnutls))
2501
# Redirect stdin so all checkers get /dev/null
2502
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2503
os.dup2(null, sys.stdin.fileno())
2507
# Need to fork before connecting to D-Bus
2509
# Close all input and output, do double fork, etc.
2512
# multiprocessing will use threads, so before we use gobject we
2513
# need to inform gobject that threads will be used.
2514
gobject.threads_init()
1286
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1287
service = AvahiService(name = server_settings[u"servicename"],
1288
servicetype = u"_mandos._tcp",
1289
protocol = protocol)
1290
if server_settings["interface"]:
1291
service.interface = (if_nametoindex
1292
(str(server_settings[u"interface"])))
2516
1294
global main_loop
2517
1297
# From the Avahi example code
2518
DBusGMainLoop(set_as_default=True)
1298
DBusGMainLoop(set_as_default=True )
2519
1299
main_loop = gobject.MainLoop()
2520
1300
bus = dbus.SystemBus()
1301
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1302
avahi.DBUS_PATH_SERVER),
1303
avahi.DBUS_INTERFACE_SERVER)
2521
1304
# End of Avahi example code
2524
bus_name = dbus.service.BusName("se.recompile.Mandos",
2525
bus, do_not_queue=True)
2526
old_bus_name = (dbus.service.BusName
2527
("se.bsnet.fukt.Mandos", bus,
2529
except dbus.exceptions.NameExistsException as e:
2530
logger.error("Disabling D-Bus:", exc_info=e)
2532
server_settings["use_dbus"] = False
2533
tcp_server.use_dbus = False
2534
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2535
service = AvahiServiceToSyslog(name =
2536
server_settings["servicename"],
2537
servicetype = "_mandos._tcp",
2538
protocol = protocol, bus = bus)
2539
if server_settings["interface"]:
2540
service.interface = (if_nametoindex
2541
(str(server_settings["interface"])))
2543
global multiprocessing_manager
2544
multiprocessing_manager = multiprocessing.Manager()
1306
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
2546
1308
client_class = Client
2548
client_class = functools.partial(ClientDBus, bus = bus)
2550
client_settings = Client.config_parser(client_config)
2551
old_client_settings = {}
2554
# This is used to redirect stdout and stderr for checker processes
2556
wnull = open(os.devnull, "w") # A writable /dev/null
2557
# Only used if server is running in foreground but not in debug
2559
if debug or not foreground:
2562
# Get client data and settings from last running state.
2563
if server_settings["restore"]:
2565
with open(stored_state_path, "rb") as stored_state:
2566
clients_data, old_client_settings = (pickle.load
2568
os.remove(stored_state_path)
2569
except IOError as e:
2570
if e.errno == errno.ENOENT:
2571
logger.warning("Could not load persistent state: {0}"
2572
.format(os.strerror(e.errno)))
2574
logger.critical("Could not load persistent state:",
2577
except EOFError as e:
2578
logger.warning("Could not load persistent state: "
2579
"EOFError:", exc_info=e)
2581
with PGPEngine() as pgp:
2582
for client_name, client in clients_data.iteritems():
2583
# Skip removed clients
2584
if client_name not in client_settings:
2587
# Decide which value to use after restoring saved state.
2588
# We have three different values: Old config file,
2589
# new config file, and saved state.
2590
# New config value takes precedence if it differs from old
2591
# config value, otherwise use saved state.
2592
for name, value in client_settings[client_name].items():
2594
# For each value in new config, check if it
2595
# differs from the old config value (Except for
2596
# the "secret" attribute)
2597
if (name != "secret" and
2598
value != old_client_settings[client_name]
2600
client[name] = value
2604
# Clients who has passed its expire date can still be
2605
# enabled if its last checker was successful. Clients
2606
# whose checker succeeded before we stored its state is
2607
# assumed to have successfully run all checkers during
2609
if client["enabled"]:
2610
if datetime.datetime.utcnow() >= client["expires"]:
2611
if not client["last_checked_ok"]:
2613
"disabling client {0} - Client never "
2614
"performed a successful checker"
2615
.format(client_name))
2616
client["enabled"] = False
2617
elif client["last_checker_status"] != 0:
2619
"disabling client {0} - Client "
2620
"last checker failed with error code {1}"
2621
.format(client_name,
2622
client["last_checker_status"]))
2623
client["enabled"] = False
2625
client["expires"] = (datetime.datetime
2627
+ client["timeout"])
2628
logger.debug("Last checker succeeded,"
2629
" keeping {0} enabled"
2630
.format(client_name))
2632
client["secret"] = (
2633
pgp.decrypt(client["encrypted_secret"],
2634
client_settings[client_name]
2637
# If decryption fails, we use secret from new settings
2638
logger.debug("Failed to decrypt {0} old secret"
2639
.format(client_name))
2640
client["secret"] = (
2641
client_settings[client_name]["secret"])
2643
# Add/remove clients based on new changes made to config
2644
for client_name in (set(old_client_settings)
2645
- set(client_settings)):
2646
del clients_data[client_name]
2647
for client_name in (set(client_settings)
2648
- set(old_client_settings)):
2649
clients_data[client_name] = client_settings[client_name]
2651
# Create all client objects
2652
for client_name, client in clients_data.iteritems():
2653
tcp_server.clients[client_name] = client_class(
2654
name = client_name, settings = client,
2655
server_settings = server_settings)
2657
if not tcp_server.clients:
2658
logger.warning("No clients defined")
2661
if pidfile is not None:
2665
pidfile.write(str(pid) + "\n".encode("utf-8"))
2667
logger.error("Could not write to file %r with PID %d",
1310
client_class = ClientDBus
1312
client_class(name = section,
1313
config= dict(client_config.items(section)))
1314
for section in client_config.sections()))
1316
logger.warning(u"No clients defined")
1319
# Redirect stdin so all checkers get /dev/null
1320
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1321
os.dup2(null, sys.stdin.fileno())
1325
# No console logging
1326
logger.removeHandler(console)
1327
# Close all input and output, do double fork, etc.
1331
with closing(pidfile):
1333
pidfile.write(str(pid) + "\n")
1336
logger.error(u"Could not write to file %r with PID %d",
1339
# "pidfile" was never created
1344
"Cleanup function; run on exit"
1346
# From the Avahi example code
1347
if not group is None:
1350
# End of Avahi example code
1353
client = clients.pop()
1354
client.disable_hook = None
1357
atexit.register(cleanup)
1360
signal.signal(signal.SIGINT, signal.SIG_IGN)
2672
1361
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2673
1362
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2676
@alternate_dbus_interfaces({"se.recompile.Mandos":
2677
"se.bsnet.fukt.Mandos"})
2678
class MandosDBusService(DBusObjectWithProperties):
1365
class MandosDBusService(dbus.service.Object):
2679
1366
"""A D-Bus proxy object"""
2680
1367
def __init__(self):
2681
dbus.service.Object.__init__(self, bus, "/")
2682
_interface = "se.recompile.Mandos"
2684
@dbus_interface_annotations(_interface)
2686
return { "org.freedesktop.DBus.Property"
2687
".EmitsChangedSignal":
2690
@dbus.service.signal(_interface, signature="o")
2691
def ClientAdded(self, objpath):
2695
@dbus.service.signal(_interface, signature="ss")
2696
def ClientNotFound(self, fingerprint, address):
2700
@dbus.service.signal(_interface, signature="os")
1368
dbus.service.Object.__init__(self, bus, u"/")
1369
_interface = u"se.bsnet.fukt.Mandos"
1371
@dbus.service.signal(_interface, signature=u"oa{sv}")
1372
def ClientAdded(self, objpath, properties):
1376
@dbus.service.signal(_interface, signature=u"s")
1377
def ClientNotFound(self, fingerprint):
1381
@dbus.service.signal(_interface, signature=u"os")
2701
1382
def ClientRemoved(self, objpath, name):
2705
@dbus.service.method(_interface, out_signature="ao")
1386
@dbus.service.method(_interface, out_signature=u"ao")
2706
1387
def GetAllClients(self):
2708
return dbus.Array(c.dbus_object_path
2710
tcp_server.clients.itervalues())
1389
return dbus.Array(c.dbus_object_path for c in clients)
2712
1391
@dbus.service.method(_interface,
2713
out_signature="a{oa{sv}}")
1392
out_signature=u"a{oa{sv}}")
2714
1393
def GetAllClientsWithProperties(self):
2716
1395
return dbus.Dictionary(
2717
((c.dbus_object_path, c.GetAll(""))
2718
for c in tcp_server.clients.itervalues()),
1396
((c.dbus_object_path, c.GetAllProperties())
1398
signature=u"oa{sv}")
2721
@dbus.service.method(_interface, in_signature="o")
1400
@dbus.service.method(_interface, in_signature=u"o")
2722
1401
def RemoveClient(self, object_path):
2724
for c in tcp_server.clients.itervalues():
2725
1404
if c.dbus_object_path == object_path:
2726
del tcp_server.clients[c.name]
2727
1406
c.remove_from_connection()
2728
1407
# Don't signal anything except ClientRemoved
2729
c.disable(quiet=True)
1408
c.disable(signal=False)
2730
1409
# Emit D-Bus signal
2731
1410
self.ClientRemoved(object_path, c.name)
2733
raise KeyError(object_path)
2737
1416
mandos_dbus_service = MandosDBusService()
2740
"Cleanup function; run on exit"
2743
multiprocessing.active_children()
2745
if not (tcp_server.clients or client_settings):
2748
# Store client before exiting. Secrets are encrypted with key
2749
# based on what config file has. If config file is
2750
# removed/edited, old secret will thus be unrecovable.
2752
with PGPEngine() as pgp:
2753
for client in tcp_server.clients.itervalues():
2754
key = client_settings[client.name]["secret"]
2755
client.encrypted_secret = pgp.encrypt(client.secret,
2759
# A list of attributes that can not be pickled
2761
exclude = set(("bus", "changedstate", "secret",
2762
"checker", "server_settings"))
2763
for name, typ in (inspect.getmembers
2764
(dbus.service.Object)):
2767
client_dict["encrypted_secret"] = (client
2769
for attr in client.client_structure:
2770
if attr not in exclude:
2771
client_dict[attr] = getattr(client, attr)
2773
clients[client.name] = client_dict
2774
del client_settings[client.name]["secret"]
2777
with (tempfile.NamedTemporaryFile
2778
(mode='wb', suffix=".pickle", prefix='clients-',
2779
dir=os.path.dirname(stored_state_path),
2780
delete=False)) as stored_state:
2781
pickle.dump((clients, client_settings), stored_state)
2782
tempname=stored_state.name
2783
os.rename(tempname, stored_state_path)
2784
except (IOError, OSError) as e:
2790
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2791
logger.warning("Could not save persistent state: {0}"
2792
.format(os.strerror(e.errno)))
2794
logger.warning("Could not save persistent state:",
2798
# Delete all clients, and settings from config
2799
while tcp_server.clients:
2800
name, client = tcp_server.clients.popitem()
2802
client.remove_from_connection()
2803
# Don't signal anything except ClientRemoved
2804
client.disable(quiet=True)
2807
mandos_dbus_service.ClientRemoved(client
2810
client_settings.clear()
2812
atexit.register(cleanup)
2814
for client in tcp_server.clients.itervalues():
1418
for client in clients:
2816
1420
# Emit D-Bus signal
2817
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2818
# Need to initiate checking of clients
2820
client.init_checker()
1421
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1422
client.GetAllProperties())
2822
1425
tcp_server.enable()
2823
1426
tcp_server.server_activate()