416
377
follow_name_owner_changes=True),
417
378
avahi.DBUS_INTERFACE_SERVER)
418
379
self.server.connect_to_signal("StateChanged",
419
self.server_state_changed)
380
self.server_state_changed)
420
381
self.server_state_changed(self.server.GetState())
423
384
class AvahiServiceToSyslog(AvahiService):
424
def rename(self, *args, **kwargs):
425
386
"""Add the new name to the syslog messages"""
426
ret = AvahiService.rename(self, *args, **kwargs)
427
syslogger.setFormatter(logging.Formatter(
428
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
387
ret = AvahiService.rename(self)
388
syslogger.setFormatter(logging.Formatter
389
('Mandos ({0}) [%(process)d]:'
390
' %(levelname)s: %(message)s'
432
# Pretend that we have a GnuTLS module
433
class GnuTLS(object):
434
"""This isn't so much a class as it is a module-like namespace.
435
It is instantiated once, and simulates having a GnuTLS module."""
437
_library = ctypes.cdll.LoadLibrary(
438
ctypes.util.find_library("gnutls"))
439
_need_version = "3.3.0"
441
# Need to use class name "GnuTLS" here, since this method is
442
# called before the assignment to the "gnutls" global variable
444
if GnuTLS.check_version(self._need_version) is None:
445
raise GnuTLS.Error("Needs GnuTLS {} or later"
446
.format(self._need_version))
448
# Unless otherwise indicated, the constants and types below are
449
# all from the gnutls/gnutls.h C header file.
459
E_NO_CERTIFICATE_FOUND = -49
460
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
463
class session_int(ctypes.Structure):
465
session_t = ctypes.POINTER(session_int)
466
class certificate_credentials_st(ctypes.Structure):
468
certificate_credentials_t = ctypes.POINTER(
469
certificate_credentials_st)
470
certificate_type_t = ctypes.c_int
471
class datum_t(ctypes.Structure):
472
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
473
('size', ctypes.c_uint)]
474
class openpgp_crt_int(ctypes.Structure):
476
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
477
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
478
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
479
credentials_type_t = ctypes.c_int #
480
transport_ptr_t = ctypes.c_void_p
481
close_request_t = ctypes.c_int
484
class Error(Exception):
485
# We need to use the class name "GnuTLS" here, since this
486
# exception might be raised from within GnuTLS.__init__,
487
# which is called before the assignment to the "gnutls"
488
# global variable has happened.
489
def __init__(self, message = None, code = None, args=()):
490
# Default usage is by a message string, but if a return
491
# code is passed, convert it to a string with
494
if message is None and code is not None:
495
message = GnuTLS.strerror(code)
496
return super(GnuTLS.Error, self).__init__(
499
class CertificateSecurityError(Error):
503
class Credentials(object):
505
self._c_object = gnutls.certificate_credentials_t()
506
gnutls.certificate_allocate_credentials(
507
ctypes.byref(self._c_object))
508
self.type = gnutls.CRD_CERTIFICATE
511
gnutls.certificate_free_credentials(self._c_object)
513
class ClientSession(object):
514
def __init__(self, socket, credentials = None):
515
self._c_object = gnutls.session_t()
516
gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
517
gnutls.set_default_priority(self._c_object)
518
gnutls.transport_set_ptr(self._c_object, socket.fileno())
519
gnutls.handshake_set_private_extensions(self._c_object,
522
if credentials is None:
523
credentials = gnutls.Credentials()
524
gnutls.credentials_set(self._c_object, credentials.type,
525
ctypes.cast(credentials._c_object,
527
self.credentials = credentials
530
gnutls.deinit(self._c_object)
533
return gnutls.handshake(self._c_object)
535
def send(self, data):
539
data_len -= gnutls.record_send(self._c_object,
544
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
546
# Error handling functions
547
def _error_code(result):
548
"""A function to raise exceptions on errors, suitable
549
for the 'restype' attribute on ctypes functions"""
552
if result == gnutls.E_NO_CERTIFICATE_FOUND:
553
raise gnutls.CertificateSecurityError(code = result)
554
raise gnutls.Error(code = result)
556
def _retry_on_error(result, func, arguments):
557
"""A function to retry on some errors, suitable
558
for the 'errcheck' attribute on ctypes functions"""
560
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
561
return _error_code(result)
562
result = func(*arguments)
565
# Unless otherwise indicated, the function declarations below are
566
# all from the gnutls/gnutls.h C header file.
569
priority_set_direct = _library.gnutls_priority_set_direct
570
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
571
ctypes.POINTER(ctypes.c_char_p)]
572
priority_set_direct.restype = _error_code
574
init = _library.gnutls_init
575
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
576
init.restype = _error_code
578
set_default_priority = _library.gnutls_set_default_priority
579
set_default_priority.argtypes = [session_t]
580
set_default_priority.restype = _error_code
582
record_send = _library.gnutls_record_send
583
record_send.argtypes = [session_t, ctypes.c_void_p,
585
record_send.restype = ctypes.c_ssize_t
586
record_send.errcheck = _retry_on_error
588
certificate_allocate_credentials = (
589
_library.gnutls_certificate_allocate_credentials)
590
certificate_allocate_credentials.argtypes = [
591
ctypes.POINTER(certificate_credentials_t)]
592
certificate_allocate_credentials.restype = _error_code
594
certificate_free_credentials = (
595
_library.gnutls_certificate_free_credentials)
596
certificate_free_credentials.argtypes = [certificate_credentials_t]
597
certificate_free_credentials.restype = None
599
handshake_set_private_extensions = (
600
_library.gnutls_handshake_set_private_extensions)
601
handshake_set_private_extensions.argtypes = [session_t,
603
handshake_set_private_extensions.restype = None
605
credentials_set = _library.gnutls_credentials_set
606
credentials_set.argtypes = [session_t, credentials_type_t,
608
credentials_set.restype = _error_code
610
strerror = _library.gnutls_strerror
611
strerror.argtypes = [ctypes.c_int]
612
strerror.restype = ctypes.c_char_p
614
certificate_type_get = _library.gnutls_certificate_type_get
615
certificate_type_get.argtypes = [session_t]
616
certificate_type_get.restype = _error_code
618
certificate_get_peers = _library.gnutls_certificate_get_peers
619
certificate_get_peers.argtypes = [session_t,
620
ctypes.POINTER(ctypes.c_uint)]
621
certificate_get_peers.restype = ctypes.POINTER(datum_t)
623
global_set_log_level = _library.gnutls_global_set_log_level
624
global_set_log_level.argtypes = [ctypes.c_int]
625
global_set_log_level.restype = None
627
global_set_log_function = _library.gnutls_global_set_log_function
628
global_set_log_function.argtypes = [log_func]
629
global_set_log_function.restype = None
631
deinit = _library.gnutls_deinit
632
deinit.argtypes = [session_t]
633
deinit.restype = None
635
handshake = _library.gnutls_handshake
636
handshake.argtypes = [session_t]
637
handshake.restype = _error_code
638
handshake.errcheck = _retry_on_error
640
transport_set_ptr = _library.gnutls_transport_set_ptr
641
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
642
transport_set_ptr.restype = None
644
bye = _library.gnutls_bye
645
bye.argtypes = [session_t, close_request_t]
646
bye.restype = _error_code
647
bye.errcheck = _retry_on_error
649
check_version = _library.gnutls_check_version
650
check_version.argtypes = [ctypes.c_char_p]
651
check_version.restype = ctypes.c_char_p
653
# All the function declarations below are from gnutls/openpgp.h
655
openpgp_crt_init = _library.gnutls_openpgp_crt_init
656
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
657
openpgp_crt_init.restype = _error_code
659
openpgp_crt_import = _library.gnutls_openpgp_crt_import
660
openpgp_crt_import.argtypes = [openpgp_crt_t,
661
ctypes.POINTER(datum_t),
663
openpgp_crt_import.restype = _error_code
665
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
666
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
667
ctypes.POINTER(ctypes.c_uint)]
668
openpgp_crt_verify_self.restype = _error_code
670
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
671
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
672
openpgp_crt_deinit.restype = None
674
openpgp_crt_get_fingerprint = (
675
_library.gnutls_openpgp_crt_get_fingerprint)
676
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
680
openpgp_crt_get_fingerprint.restype = _error_code
682
# Remove non-public functions
683
del _error_code, _retry_on_error
684
# Create the global "gnutls" object, simulating a module
687
def call_pipe(connection, # : multiprocessing.Connection
688
func, *args, **kwargs):
689
"""This function is meant to be called by multiprocessing.Process
691
This function runs func(*args, **kwargs), and writes the resulting
692
return value on the provided multiprocessing.Connection.
694
connection.send(func(*args, **kwargs))
395
def timedelta_to_milliseconds(td):
396
"Convert a datetime.timedelta() to milliseconds"
397
return ((td.days * 24 * 60 * 60 * 1000)
398
+ (td.seconds * 1000)
399
+ (td.microseconds // 1000))
697
402
class Client(object):
698
403
"""A representation of a client host served by this server.
895
615
# and every interval from then on.
896
616
if self.checker_initiator_tag is not None:
897
617
gobject.source_remove(self.checker_initiator_tag)
898
self.checker_initiator_tag = gobject.timeout_add(
899
int(self.interval.total_seconds() * 1000),
618
self.checker_initiator_tag = (gobject.timeout_add
619
(self.interval_milliseconds(),
901
621
# Schedule a disable() when 'timeout' has passed
902
622
if self.disable_initiator_tag is not None:
903
623
gobject.source_remove(self.disable_initiator_tag)
904
self.disable_initiator_tag = gobject.timeout_add(
905
int(self.timeout.total_seconds() * 1000), self.disable)
624
self.disable_initiator_tag = (gobject.timeout_add
625
(self.timeout_milliseconds(),
906
627
# Also start a new checker *right now*.
907
628
self.start_checker()
909
def checker_callback(self, source, condition, connection,
630
def checker_callback(self, pid, condition, command):
911
631
"""The checker has completed, so take appropriate actions."""
912
632
self.checker_callback_tag = None
913
633
self.checker = None
914
# Read return code from connection (see call_pipe)
915
returncode = connection.recv()
919
self.last_checker_status = returncode
920
self.last_checker_signal = None
634
if os.WIFEXITED(condition):
635
self.last_checker_status = os.WEXITSTATUS(condition)
921
636
if self.last_checker_status == 0:
922
637
logger.info("Checker for %(name)s succeeded",
924
639
self.checked_ok()
926
logger.info("Checker for %(name)s failed", vars(self))
641
logger.info("Checker for %(name)s failed",
928
644
self.last_checker_status = -1
929
self.last_checker_signal = -returncode
930
645
logger.warning("Checker for %(name)s crashed?",
934
648
def checked_ok(self):
935
649
"""Assert that the client has been seen, alive and well."""
936
650
self.last_checked_ok = datetime.datetime.utcnow()
937
651
self.last_checker_status = 0
938
self.last_checker_signal = None
939
652
self.bump_timeout()
941
654
def bump_timeout(self, timeout=None):
967
681
# than 'timeout' for the client to be disabled, which is as it
970
if self.checker is not None and not self.checker.is_alive():
971
logger.warning("Checker was not alive; joining")
684
# If a checker exists, make sure it is not a zombie
686
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
687
except (AttributeError, OSError) as error:
688
if (isinstance(error, OSError)
689
and error.errno != errno.ECHILD):
693
logger.warning("Checker was a zombie")
694
gobject.source_remove(self.checker_callback_tag)
695
self.checker_callback(pid, status,
696
self.current_checker_command)
974
697
# Start a new checker if needed
975
698
if self.checker is None:
976
699
# Escape attributes for the shell
978
attr: re.escape(str(getattr(self, attr)))
979
for attr in self.runtime_expansions }
700
escaped_attrs = dict(
701
(attr, re.escape(unicode(getattr(self, attr))))
703
self.runtime_expansions)
981
705
command = self.checker_command % escaped_attrs
982
706
except TypeError as error:
983
707
logger.error('Could not format string "%s"',
984
self.checker_command,
708
self.checker_command, exc_info=error)
709
return True # Try again later
710
self.current_checker_command = command
712
logger.info("Starting checker %r for %s",
714
# We don't need to redirect stdout and stderr, since
715
# in normal mode, that is already done by daemon(),
716
# and in debug mode we don't want to. (Stdin is
717
# always replaced by /dev/null.)
718
# The exception is when not debugging but nevertheless
719
# running in the foreground; use the previously
722
if (not self.server_settings["debug"]
723
and self.server_settings["foreground"]):
724
popen_args.update({"stdout": wnull,
726
self.checker = subprocess.Popen(command,
730
except OSError as error:
731
logger.error("Failed to start subprocess",
986
return True # Try again later
987
self.current_checker_command = command
988
logger.info("Starting checker %r for %s", command,
990
# We don't need to redirect stdout and stderr, since
991
# in normal mode, that is already done by daemon(),
992
# and in debug mode we don't want to. (Stdin is
993
# always replaced by /dev/null.)
994
# The exception is when not debugging but nevertheless
995
# running in the foreground; use the previously
997
popen_args = { "close_fds": True,
1000
if (not self.server_settings["debug"]
1001
and self.server_settings["foreground"]):
1002
popen_args.update({"stdout": wnull,
1004
pipe = multiprocessing.Pipe(duplex = False)
1005
self.checker = multiprocessing.Process(
1007
args = (pipe[1], subprocess.call, command),
1008
kwargs = popen_args)
1009
self.checker.start()
1010
self.checker_callback_tag = gobject.io_add_watch(
1011
pipe[0].fileno(), gobject.IO_IN,
1012
self.checker_callback, pipe[0], command)
734
self.checker_callback_tag = (gobject.child_watch_add
736
self.checker_callback,
738
# The checker may have completed before the gobject
739
# watch was added. Check for this.
741
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
742
except OSError as error:
743
if error.errno == errno.ECHILD:
744
# This should never happen
745
logger.error("Child process vanished",
750
gobject.source_remove(self.checker_callback_tag)
751
self.checker_callback(pid, status, command)
1013
752
# Re-run this periodically if run by gobject.timeout_add
1134
872
If called like _is_dbus_thing("method") it returns a function
1135
873
suitable for use as predicate to inspect.getmembers().
1137
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
875
return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),
1140
878
def _get_all_dbus_things(self, thing):
1141
879
"""Returns a generator of (name, attribute) pairs
1143
return ((getattr(athing.__get__(self), "_dbus_name", name),
881
return ((getattr(athing.__get__(self), "_dbus_name",
1144
883
athing.__get__(self))
1145
884
for cls in self.__class__.__mro__
1146
885
for name, athing in
1147
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1149
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1150
out_signature = "s",
1151
path_keyword = 'object_path',
1152
connection_keyword = 'connection')
1153
def Introspect(self, object_path, connection):
1154
"""Overloading of standard D-Bus method.
1156
Inserts annotation tags on methods and signals.
1158
xmlstring = dbus.service.Object.Introspect(self, object_path,
1161
document = xml.dom.minidom.parseString(xmlstring)
1163
for if_tag in document.getElementsByTagName("interface"):
1164
# Add annotation tags
1165
for typ in ("method", "signal"):
1166
for tag in if_tag.getElementsByTagName(typ):
1168
for name, prop in (self.
1169
_get_all_dbus_things(typ)):
1170
if (name == tag.getAttribute("name")
1171
and prop._dbus_interface
1172
== if_tag.getAttribute("name")):
1173
annots.update(getattr(
1174
prop, "_dbus_annotations", {}))
1175
for name, value in annots.items():
1176
ann_tag = document.createElement(
1178
ann_tag.setAttribute("name", name)
1179
ann_tag.setAttribute("value", value)
1180
tag.appendChild(ann_tag)
1181
# Add interface annotation tags
1182
for annotation, value in dict(
1183
itertools.chain.from_iterable(
1184
annotations().items()
1185
for name, annotations
1186
in self._get_all_dbus_things("interface")
1187
if name == if_tag.getAttribute("name")
1189
ann_tag = document.createElement("annotation")
1190
ann_tag.setAttribute("name", annotation)
1191
ann_tag.setAttribute("value", value)
1192
if_tag.appendChild(ann_tag)
1193
# Fix argument name for the Introspect method itself
1194
if (if_tag.getAttribute("name")
1195
== dbus.INTROSPECTABLE_IFACE):
1196
for cn in if_tag.getElementsByTagName("method"):
1197
if cn.getAttribute("name") == "Introspect":
1198
for arg in cn.getElementsByTagName("arg"):
1199
if (arg.getAttribute("direction")
1201
arg.setAttribute("name",
1203
xmlstring = document.toxml("utf-8")
1205
except (AttributeError, xml.dom.DOMException,
1206
xml.parsers.expat.ExpatError) as error:
1207
logger.error("Failed to override Introspection method",
1212
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1213
"""A D-Bus object with properties.
1215
Classes inheriting from this can use the dbus_service_property
1216
decorator to expose methods as D-Bus properties. It exposes the
1217
standard Get(), Set(), and GetAll() methods on the D-Bus.
886
inspect.getmembers(cls,
887
self._is_dbus_thing(thing)))
1220
889
def _get_dbus_property(self, interface_name, property_name):
1221
890
"""Returns a bound method if one exists which is a D-Bus
1222
891
property with the specified name and interface.
1224
for cls in self.__class__.__mro__:
1225
for name, value in inspect.getmembers(
1226
cls, self._is_dbus_thing("property")):
893
for cls in self.__class__.__mro__:
894
for name, value in (inspect.getmembers
896
self._is_dbus_thing("property"))):
1227
897
if (value._dbus_name == property_name
1228
898
and value._dbus_interface == interface_name):
1229
899
return value.__get__(self)
1231
901
# No such property
1232
raise DBusPropertyNotFound("{}:{}.{}".format(
1233
self.dbus_object_path, interface_name, property_name))
1236
def _get_all_interface_names(cls):
1237
"""Get a sequence of all interfaces supported by an object"""
1238
return (name for name in set(getattr(getattr(x, attr),
1239
"_dbus_interface", None)
1240
for x in (inspect.getmro(cls))
1242
if name is not None)
1244
@dbus.service.method(dbus.PROPERTIES_IFACE,
902
raise DBusPropertyNotFound(self.dbus_object_path + ":"
903
+ interface_name + "."
906
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
1246
907
out_signature="v")
1247
908
def Get(self, interface_name, property_name):
1248
909
"""Standard D-Bus property Get() method, see D-Bus standard.
1376
1038
exc_info=error)
1377
1039
return xmlstring
1380
dbus.OBJECT_MANAGER_IFACE
1381
except AttributeError:
1382
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1384
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1385
"""A D-Bus object with an ObjectManager.
1387
Classes inheriting from this exposes the standard
1388
GetManagedObjects call and the InterfacesAdded and
1389
InterfacesRemoved signals on the standard
1390
"org.freedesktop.DBus.ObjectManager" interface.
1392
Note: No signals are sent automatically; they must be sent
1395
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1396
out_signature = "a{oa{sa{sv}}}")
1397
def GetManagedObjects(self):
1398
"""This function must be overridden"""
1399
raise NotImplementedError()
1401
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1402
signature = "oa{sa{sv}}")
1403
def InterfacesAdded(self, object_path, interfaces_and_properties):
1406
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1407
def InterfacesRemoved(self, object_path, interfaces):
1410
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1411
out_signature = "s",
1412
path_keyword = 'object_path',
1413
connection_keyword = 'connection')
1414
def Introspect(self, object_path, connection):
1415
"""Overloading of standard D-Bus method.
1417
Override return argument name of GetManagedObjects to be
1418
"objpath_interfaces_and_properties"
1420
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1424
document = xml.dom.minidom.parseString(xmlstring)
1426
for if_tag in document.getElementsByTagName("interface"):
1427
# Fix argument name for the GetManagedObjects method
1428
if (if_tag.getAttribute("name")
1429
== dbus.OBJECT_MANAGER_IFACE):
1430
for cn in if_tag.getElementsByTagName("method"):
1431
if (cn.getAttribute("name")
1432
== "GetManagedObjects"):
1433
for arg in cn.getElementsByTagName("arg"):
1434
if (arg.getAttribute("direction")
1438
"objpath_interfaces"
1440
xmlstring = document.toxml("utf-8")
1442
except (AttributeError, xml.dom.DOMException,
1443
xml.parsers.expat.ExpatError) as error:
1444
logger.error("Failed to override Introspection method",
1448
1042
def datetime_to_dbus(dt, variant_level=0):
1449
1043
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1451
1045
return dbus.String("", variant_level = variant_level)
1452
return dbus.String(dt.isoformat(), variant_level=variant_level)
1046
return dbus.String(dt.isoformat(),
1047
variant_level=variant_level)
1455
1050
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1486
1080
# Ignore non-D-Bus attributes, and D-Bus attributes
1487
1081
# with the wrong interface name
1488
1082
if (not hasattr(attribute, "_dbus_interface")
1489
or not attribute._dbus_interface.startswith(
1490
orig_interface_name)):
1083
or not attribute._dbus_interface
1084
.startswith(orig_interface_name)):
1492
1086
# Create an alternate D-Bus interface name based on
1493
1087
# the current name
1494
alt_interface = attribute._dbus_interface.replace(
1495
orig_interface_name, alt_interface_name)
1088
alt_interface = (attribute._dbus_interface
1089
.replace(orig_interface_name,
1090
alt_interface_name))
1496
1091
interface_names.add(alt_interface)
1497
1092
# Is this a D-Bus signal?
1498
1093
if getattr(attribute, "_dbus_is_signal", False):
1499
if sys.version_info.major == 2:
1500
# Extract the original non-method undecorated
1501
# function by black magic
1502
nonmethod_func = (dict(
1094
# Extract the original non-method undecorated
1095
# function by black magic
1096
nonmethod_func = (dict(
1503
1097
zip(attribute.func_code.co_freevars,
1504
attribute.__closure__))
1505
["func"].cell_contents)
1507
nonmethod_func = attribute
1098
attribute.__closure__))["func"]
1508
1100
# Create a new, but exactly alike, function
1509
1101
# object, and decorate it to be a new D-Bus signal
1510
1102
# with the alternate D-Bus interface name
1511
if sys.version_info.major == 2:
1512
new_function = types.FunctionType(
1513
nonmethod_func.func_code,
1514
nonmethod_func.func_globals,
1515
nonmethod_func.func_name,
1516
nonmethod_func.func_defaults,
1517
nonmethod_func.func_closure)
1519
new_function = types.FunctionType(
1520
nonmethod_func.__code__,
1521
nonmethod_func.__globals__,
1522
nonmethod_func.__name__,
1523
nonmethod_func.__defaults__,
1524
nonmethod_func.__closure__)
1525
new_function = (dbus.service.signal(
1527
attribute._dbus_signature)(new_function))
1103
new_function = (dbus.service.signal
1105
attribute._dbus_signature)
1106
(types.FunctionType(
1107
nonmethod_func.func_code,
1108
nonmethod_func.func_globals,
1109
nonmethod_func.func_name,
1110
nonmethod_func.func_defaults,
1111
nonmethod_func.func_closure)))
1528
1112
# Copy annotations, if any
1530
new_function._dbus_annotations = dict(
1531
attribute._dbus_annotations)
1114
new_function._dbus_annotations = (
1115
dict(attribute._dbus_annotations))
1532
1116
except AttributeError:
1534
1118
# Define a creator of a function to call both the
1758
1321
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1759
1322
Client.__del__(self, *args, **kwargs)
1761
def checker_callback(self, source, condition,
1762
connection, command, *args, **kwargs):
1763
ret = Client.checker_callback(self, source, condition,
1764
connection, command, *args,
1766
exitstatus = self.last_checker_status
1324
def checker_callback(self, pid, condition, command,
1326
self.checker_callback_tag = None
1328
if os.WIFEXITED(condition):
1329
exitstatus = os.WEXITSTATUS(condition)
1768
1330
# Emit D-Bus signal
1769
1331
self.CheckerCompleted(dbus.Int16(exitstatus),
1770
# This is specific to GNU libC
1771
dbus.Int64(exitstatus << 8),
1332
dbus.Int64(condition),
1772
1333
dbus.String(command))
1774
1335
# Emit D-Bus signal
1775
1336
self.CheckerCompleted(dbus.Int16(-1),
1777
# This is specific to GNU libC
1779
| self.last_checker_signal),
1337
dbus.Int64(condition),
1780
1338
dbus.String(command))
1340
return Client.checker_callback(self, pid, condition, command,
1783
1343
def start_checker(self, *args, **kwargs):
1784
old_checker_pid = getattr(self.checker, "pid", None)
1344
old_checker = self.checker
1345
if self.checker is not None:
1346
old_checker_pid = self.checker.pid
1348
old_checker_pid = None
1785
1349
r = Client.start_checker(self, *args, **kwargs)
1786
1350
# Only if new checker process was started
1787
1351
if (self.checker is not None
1902
1467
self.approved_by_default = bool(value)
1904
1469
# ApprovalDelay - property
1905
@dbus_service_property(_interface,
1470
@dbus_service_property(_interface, signature="t",
1907
1471
access="readwrite")
1908
1472
def ApprovalDelay_dbus_property(self, value=None):
1909
1473
if value is None: # get
1910
return dbus.UInt64(self.approval_delay.total_seconds()
1474
return dbus.UInt64(self.approval_delay_milliseconds())
1912
1475
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1914
1477
# ApprovalDuration - property
1915
@dbus_service_property(_interface,
1478
@dbus_service_property(_interface, signature="t",
1917
1479
access="readwrite")
1918
1480
def ApprovalDuration_dbus_property(self, value=None):
1919
1481
if value is None: # get
1920
return dbus.UInt64(self.approval_duration.total_seconds()
1482
return dbus.UInt64(timedelta_to_milliseconds(
1483
self.approval_duration))
1922
1484
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1924
1486
# Name - property
1926
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1927
1487
@dbus_service_property(_interface, signature="s", access="read")
1928
1488
def Name_dbus_property(self):
1929
1489
return dbus.String(self.name)
1931
1491
# Fingerprint - property
1933
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1934
1492
@dbus_service_property(_interface, signature="s", access="read")
1935
1493
def Fingerprint_dbus_property(self):
1936
1494
return dbus.String(self.fingerprint)
1938
1496
# Host - property
1939
@dbus_service_property(_interface,
1497
@dbus_service_property(_interface, signature="s",
1941
1498
access="readwrite")
1942
1499
def Host_dbus_property(self, value=None):
1943
1500
if value is None: # get
1944
1501
return dbus.String(self.host)
1945
self.host = str(value)
1502
self.host = unicode(value)
1947
1504
# Created - property
1949
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1950
1505
@dbus_service_property(_interface, signature="s", access="read")
1951
1506
def Created_dbus_property(self):
1952
1507
return datetime_to_dbus(self.created)
2016
1569
gobject.source_remove(self.disable_initiator_tag)
2017
self.disable_initiator_tag = gobject.timeout_add(
2018
int((self.expires - now).total_seconds() * 1000),
1570
self.disable_initiator_tag = (
1571
gobject.timeout_add(
1572
timedelta_to_milliseconds(self.expires - now),
2021
1575
# ExtendedTimeout - property
2022
@dbus_service_property(_interface,
1576
@dbus_service_property(_interface, signature="t",
2024
1577
access="readwrite")
2025
1578
def ExtendedTimeout_dbus_property(self, value=None):
2026
1579
if value is None: # get
2027
return dbus.UInt64(self.extended_timeout.total_seconds()
1580
return dbus.UInt64(self.extended_timeout_milliseconds())
2029
1581
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2031
1583
# Interval - property
2032
@dbus_service_property(_interface,
1584
@dbus_service_property(_interface, signature="t",
2034
1585
access="readwrite")
2035
1586
def Interval_dbus_property(self, value=None):
2036
1587
if value is None: # get
2037
return dbus.UInt64(self.interval.total_seconds() * 1000)
1588
return dbus.UInt64(self.interval_milliseconds())
2038
1589
self.interval = datetime.timedelta(0, 0, 0, value)
2039
1590
if getattr(self, "checker_initiator_tag", None) is None:
2041
1592
if self.enabled:
2042
1593
# Reschedule checker run
2043
1594
gobject.source_remove(self.checker_initiator_tag)
2044
self.checker_initiator_tag = gobject.timeout_add(
2045
value, self.start_checker)
2046
self.start_checker() # Start one now, too
1595
self.checker_initiator_tag = (gobject.timeout_add
1596
(value, self.start_checker))
1597
self.start_checker() # Start one now, too
2048
1599
# Checker - property
2049
@dbus_service_property(_interface,
1600
@dbus_service_property(_interface, signature="s",
2051
1601
access="readwrite")
2052
1602
def Checker_dbus_property(self, value=None):
2053
1603
if value is None: # get
2054
1604
return dbus.String(self.checker_command)
2055
self.checker_command = str(value)
1605
self.checker_command = unicode(value)
2057
1607
# CheckerRunning - property
2058
@dbus_service_property(_interface,
1608
@dbus_service_property(_interface, signature="b",
2060
1609
access="readwrite")
2061
1610
def CheckerRunning_dbus_property(self, value=None):
2062
1611
if value is None: # get
2277
1837
def fingerprint(openpgp):
2278
1838
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2279
1839
# New GnuTLS "datum" with the OpenPGP public key
2280
datum = gnutls.datum_t(
2281
ctypes.cast(ctypes.c_char_p(openpgp),
2282
ctypes.POINTER(ctypes.c_ubyte)),
2283
ctypes.c_uint(len(openpgp)))
1840
datum = (gnutls.library.types
1841
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1844
ctypes.c_uint(len(openpgp))))
2284
1845
# New empty GnuTLS certificate
2285
crt = gnutls.openpgp_crt_t()
2286
gnutls.openpgp_crt_init(ctypes.byref(crt))
1846
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1847
(gnutls.library.functions
1848
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2287
1849
# Import the OpenPGP public key into the certificate
2288
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2289
gnutls.OPENPGP_FMT_RAW)
1850
(gnutls.library.functions
1851
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1852
gnutls.library.constants
1853
.GNUTLS_OPENPGP_FMT_RAW))
2290
1854
# Verify the self signature in the key
2291
1855
crtverify = ctypes.c_uint()
2292
gnutls.openpgp_crt_verify_self(crt, 0,
2293
ctypes.byref(crtverify))
1856
(gnutls.library.functions
1857
.gnutls_openpgp_crt_verify_self(crt, 0,
1858
ctypes.byref(crtverify)))
2294
1859
if crtverify.value != 0:
2295
gnutls.openpgp_crt_deinit(crt)
2296
raise gnutls.CertificateSecurityError("Verify failed")
1860
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1861
raise (gnutls.errors.CertificateSecurityError
2297
1863
# New buffer for the fingerprint
2298
1864
buf = ctypes.create_string_buffer(20)
2299
1865
buf_len = ctypes.c_size_t()
2300
1866
# Get the fingerprint from the certificate into the buffer
2301
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2302
ctypes.byref(buf_len))
1867
(gnutls.library.functions
1868
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1869
ctypes.byref(buf_len)))
2303
1870
# Deinit the certificate
2304
gnutls.openpgp_crt_deinit(crt)
1871
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2305
1872
# Convert the buffer to a Python bytestring
2306
1873
fpr = ctypes.string_at(buf, buf_len.value)
2307
1874
# Convert the bytestring to hexadecimal notation