482
411
.format(self.name)))
485
# Pretend that we have a GnuTLS module
486
class GnuTLS(object):
487
"""This isn't so much a class as it is a module-like namespace.
488
It is instantiated once, and simulates having a GnuTLS module."""
490
_library = ctypes.cdll.LoadLibrary(
491
ctypes.util.find_library("gnutls"))
492
_need_version = b"3.3.0"
494
# Need to use class name "GnuTLS" here, since this method is
495
# called before the assignment to the "gnutls" global variable
497
if GnuTLS.check_version(self._need_version) is None:
498
raise GnuTLS.Error("Needs GnuTLS {} or later"
499
.format(self._need_version))
501
# Unless otherwise indicated, the constants and types below are
502
# all from the gnutls/gnutls.h C header file.
512
E_NO_CERTIFICATE_FOUND = -49
513
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
516
class session_int(ctypes.Structure):
518
session_t = ctypes.POINTER(session_int)
519
class certificate_credentials_st(ctypes.Structure):
521
certificate_credentials_t = ctypes.POINTER(
522
certificate_credentials_st)
523
certificate_type_t = ctypes.c_int
524
class datum_t(ctypes.Structure):
525
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
526
('size', ctypes.c_uint)]
527
class openpgp_crt_int(ctypes.Structure):
529
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
530
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
531
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
532
credentials_type_t = ctypes.c_int
533
transport_ptr_t = ctypes.c_void_p
534
close_request_t = ctypes.c_int
537
class Error(Exception):
538
# We need to use the class name "GnuTLS" here, since this
539
# exception might be raised from within GnuTLS.__init__,
540
# which is called before the assignment to the "gnutls"
541
# global variable has happened.
542
def __init__(self, message = None, code = None, args=()):
543
# Default usage is by a message string, but if a return
544
# code is passed, convert it to a string with
547
if message is None and code is not None:
548
message = GnuTLS.strerror(code)
549
return super(GnuTLS.Error, self).__init__(
552
class CertificateSecurityError(Error):
556
class Credentials(object):
558
self._c_object = gnutls.certificate_credentials_t()
559
gnutls.certificate_allocate_credentials(
560
ctypes.byref(self._c_object))
561
self.type = gnutls.CRD_CERTIFICATE
564
gnutls.certificate_free_credentials(self._c_object)
566
class ClientSession(object):
567
def __init__(self, socket, credentials = None):
568
self._c_object = gnutls.session_t()
569
gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
570
gnutls.set_default_priority(self._c_object)
571
gnutls.transport_set_ptr(self._c_object, socket.fileno())
572
gnutls.handshake_set_private_extensions(self._c_object,
575
if credentials is None:
576
credentials = gnutls.Credentials()
577
gnutls.credentials_set(self._c_object, credentials.type,
578
ctypes.cast(credentials._c_object,
580
self.credentials = credentials
583
gnutls.deinit(self._c_object)
586
return gnutls.handshake(self._c_object)
588
def send(self, data):
592
data_len -= gnutls.record_send(self._c_object,
597
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
599
# Error handling functions
600
def _error_code(result):
601
"""A function to raise exceptions on errors, suitable
602
for the 'restype' attribute on ctypes functions"""
605
if result == gnutls.E_NO_CERTIFICATE_FOUND:
606
raise gnutls.CertificateSecurityError(code = result)
607
raise gnutls.Error(code = result)
609
def _retry_on_error(result, func, arguments):
610
"""A function to retry on some errors, suitable
611
for the 'errcheck' attribute on ctypes functions"""
613
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
614
return _error_code(result)
615
result = func(*arguments)
618
# Unless otherwise indicated, the function declarations below are
619
# all from the gnutls/gnutls.h C header file.
622
priority_set_direct = _library.gnutls_priority_set_direct
623
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
624
ctypes.POINTER(ctypes.c_char_p)]
625
priority_set_direct.restype = _error_code
627
init = _library.gnutls_init
628
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
629
init.restype = _error_code
631
set_default_priority = _library.gnutls_set_default_priority
632
set_default_priority.argtypes = [session_t]
633
set_default_priority.restype = _error_code
635
record_send = _library.gnutls_record_send
636
record_send.argtypes = [session_t, ctypes.c_void_p,
638
record_send.restype = ctypes.c_ssize_t
639
record_send.errcheck = _retry_on_error
641
certificate_allocate_credentials = (
642
_library.gnutls_certificate_allocate_credentials)
643
certificate_allocate_credentials.argtypes = [
644
ctypes.POINTER(certificate_credentials_t)]
645
certificate_allocate_credentials.restype = _error_code
647
certificate_free_credentials = (
648
_library.gnutls_certificate_free_credentials)
649
certificate_free_credentials.argtypes = [certificate_credentials_t]
650
certificate_free_credentials.restype = None
652
handshake_set_private_extensions = (
653
_library.gnutls_handshake_set_private_extensions)
654
handshake_set_private_extensions.argtypes = [session_t,
656
handshake_set_private_extensions.restype = None
658
credentials_set = _library.gnutls_credentials_set
659
credentials_set.argtypes = [session_t, credentials_type_t,
661
credentials_set.restype = _error_code
663
strerror = _library.gnutls_strerror
664
strerror.argtypes = [ctypes.c_int]
665
strerror.restype = ctypes.c_char_p
667
certificate_type_get = _library.gnutls_certificate_type_get
668
certificate_type_get.argtypes = [session_t]
669
certificate_type_get.restype = _error_code
671
certificate_get_peers = _library.gnutls_certificate_get_peers
672
certificate_get_peers.argtypes = [session_t,
673
ctypes.POINTER(ctypes.c_uint)]
674
certificate_get_peers.restype = ctypes.POINTER(datum_t)
676
global_set_log_level = _library.gnutls_global_set_log_level
677
global_set_log_level.argtypes = [ctypes.c_int]
678
global_set_log_level.restype = None
680
global_set_log_function = _library.gnutls_global_set_log_function
681
global_set_log_function.argtypes = [log_func]
682
global_set_log_function.restype = None
684
deinit = _library.gnutls_deinit
685
deinit.argtypes = [session_t]
686
deinit.restype = None
688
handshake = _library.gnutls_handshake
689
handshake.argtypes = [session_t]
690
handshake.restype = _error_code
691
handshake.errcheck = _retry_on_error
693
transport_set_ptr = _library.gnutls_transport_set_ptr
694
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
695
transport_set_ptr.restype = None
697
bye = _library.gnutls_bye
698
bye.argtypes = [session_t, close_request_t]
699
bye.restype = _error_code
700
bye.errcheck = _retry_on_error
702
check_version = _library.gnutls_check_version
703
check_version.argtypes = [ctypes.c_char_p]
704
check_version.restype = ctypes.c_char_p
706
# All the function declarations below are from gnutls/openpgp.h
708
openpgp_crt_init = _library.gnutls_openpgp_crt_init
709
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
710
openpgp_crt_init.restype = _error_code
712
openpgp_crt_import = _library.gnutls_openpgp_crt_import
713
openpgp_crt_import.argtypes = [openpgp_crt_t,
714
ctypes.POINTER(datum_t),
716
openpgp_crt_import.restype = _error_code
718
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
719
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
720
ctypes.POINTER(ctypes.c_uint)]
721
openpgp_crt_verify_self.restype = _error_code
723
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
724
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
725
openpgp_crt_deinit.restype = None
727
openpgp_crt_get_fingerprint = (
728
_library.gnutls_openpgp_crt_get_fingerprint)
729
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
733
openpgp_crt_get_fingerprint.restype = _error_code
735
# Remove non-public functions
736
del _error_code, _retry_on_error
737
# Create the global "gnutls" object, simulating a module
740
def call_pipe(connection, # : multiprocessing.Connection
741
func, *args, **kwargs):
742
"""This function is meant to be called by multiprocessing.Process
744
This function runs func(*args, **kwargs), and writes the resulting
745
return value on the provided multiprocessing.Connection.
747
connection.send(func(*args, **kwargs))
750
415
class Client(object):
751
416
"""A representation of a client host served by this server.
1041
703
return True # Try again later
1042
704
self.current_checker_command = command
1043
logger.info("Starting checker %r for %s", command,
1045
# We don't need to redirect stdout and stderr, since
1046
# in normal mode, that is already done by daemon(),
1047
# and in debug mode we don't want to. (Stdin is
1048
# always replaced by /dev/null.)
1049
# The exception is when not debugging but nevertheless
1050
# running in the foreground; use the previously
1052
popen_args = { "close_fds": True,
1055
if (not self.server_settings["debug"]
1056
and self.server_settings["foreground"]):
1057
popen_args.update({"stdout": wnull,
1059
pipe = multiprocessing.Pipe(duplex = False)
1060
self.checker = multiprocessing.Process(
1062
args = (pipe[1], subprocess.call, command),
1063
kwargs = popen_args)
1064
self.checker.start()
1065
self.checker_callback_tag = GObject.io_add_watch(
1066
pipe[0].fileno(), GObject.IO_IN,
1067
self.checker_callback, pipe[0], command)
1068
# Re-run this periodically if run by GObject.timeout_add
706
logger.info("Starting checker %r for %s", command,
708
# We don't need to redirect stdout and stderr, since
709
# in normal mode, that is already done by daemon(),
710
# and in debug mode we don't want to. (Stdin is
711
# always replaced by /dev/null.)
712
# The exception is when not debugging but nevertheless
713
# running in the foreground; use the previously
716
if (not self.server_settings["debug"]
717
and self.server_settings["foreground"]):
718
popen_args.update({"stdout": wnull,
720
self.checker = subprocess.Popen(command,
725
except OSError as error:
726
logger.error("Failed to start subprocess",
729
self.checker_callback_tag = gobject.child_watch_add(
730
self.checker.pid, self.checker_callback, data=command)
731
# The checker may have completed before the gobject
732
# watch was added. Check for this.
734
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
735
except OSError as error:
736
if error.errno == errno.ECHILD:
737
# This should never happen
738
logger.error("Child process vanished",
743
gobject.source_remove(self.checker_callback_tag)
744
self.checker_callback(pid, status, command)
745
# Re-run this periodically if run by gobject.timeout_add
1071
748
def stop_checker(self):
1072
749
"""Force the checker process, if any, to stop."""
1073
750
if self.checker_callback_tag:
1074
GObject.source_remove(self.checker_callback_tag)
751
gobject.source_remove(self.checker_callback_tag)
1075
752
self.checker_callback_tag = None
1076
753
if getattr(self, "checker", None) is None:
1078
755
logger.debug("Stopping checker for %(name)s", vars(self))
1079
self.checker.terminate()
757
self.checker.terminate()
759
#if self.checker.poll() is None:
760
# self.checker.kill()
761
except OSError as error:
762
if error.errno != errno.ESRCH: # No such process
1080
764
self.checker = None
1201
884
for name, athing in
1202
885
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1204
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1205
out_signature = "s",
1206
path_keyword = 'object_path',
1207
connection_keyword = 'connection')
1208
def Introspect(self, object_path, connection):
1209
"""Overloading of standard D-Bus method.
1211
Inserts annotation tags on methods and signals.
1213
xmlstring = dbus.service.Object.Introspect(self, object_path,
1216
document = xml.dom.minidom.parseString(xmlstring)
1218
for if_tag in document.getElementsByTagName("interface"):
1219
# Add annotation tags
1220
for typ in ("method", "signal"):
1221
for tag in if_tag.getElementsByTagName(typ):
1223
for name, prop in (self.
1224
_get_all_dbus_things(typ)):
1225
if (name == tag.getAttribute("name")
1226
and prop._dbus_interface
1227
== if_tag.getAttribute("name")):
1228
annots.update(getattr(
1229
prop, "_dbus_annotations", {}))
1230
for name, value in annots.items():
1231
ann_tag = document.createElement(
1233
ann_tag.setAttribute("name", name)
1234
ann_tag.setAttribute("value", value)
1235
tag.appendChild(ann_tag)
1236
# Add interface annotation tags
1237
for annotation, value in dict(
1238
itertools.chain.from_iterable(
1239
annotations().items()
1240
for name, annotations
1241
in self._get_all_dbus_things("interface")
1242
if name == if_tag.getAttribute("name")
1244
ann_tag = document.createElement("annotation")
1245
ann_tag.setAttribute("name", annotation)
1246
ann_tag.setAttribute("value", value)
1247
if_tag.appendChild(ann_tag)
1248
# Fix argument name for the Introspect method itself
1249
if (if_tag.getAttribute("name")
1250
== dbus.INTROSPECTABLE_IFACE):
1251
for cn in if_tag.getElementsByTagName("method"):
1252
if cn.getAttribute("name") == "Introspect":
1253
for arg in cn.getElementsByTagName("arg"):
1254
if (arg.getAttribute("direction")
1256
arg.setAttribute("name",
1258
xmlstring = document.toxml("utf-8")
1260
except (AttributeError, xml.dom.DOMException,
1261
xml.parsers.expat.ExpatError) as error:
1262
logger.error("Failed to override Introspection method",
1267
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1268
"""A D-Bus object with properties.
1270
Classes inheriting from this can use the dbus_service_property
1271
decorator to expose methods as D-Bus properties. It exposes the
1272
standard Get(), Set(), and GetAll() methods on the D-Bus.
1275
887
def _get_dbus_property(self, interface_name, property_name):
1276
888
"""Returns a bound method if one exists which is a D-Bus
1277
889
property with the specified name and interface.
1392
994
if prop._dbus_interface
1393
995
== if_tag.getAttribute("name")):
1394
996
if_tag.appendChild(tag)
1395
# Add annotation tags for properties
1396
for tag in if_tag.getElementsByTagName("property"):
1398
for name, prop in self._get_all_dbus_things(
1400
if (name == tag.getAttribute("name")
1401
and prop._dbus_interface
1402
== if_tag.getAttribute("name")):
1403
annots.update(getattr(
1404
prop, "_dbus_annotations", {}))
1405
for name, value in annots.items():
1406
ann_tag = document.createElement(
1408
ann_tag.setAttribute("name", name)
1409
ann_tag.setAttribute("value", value)
1410
tag.appendChild(ann_tag)
997
# Add annotation tags
998
for typ in ("method", "signal", "property"):
999
for tag in if_tag.getElementsByTagName(typ):
1001
for name, prop in (self.
1002
_get_all_dbus_things(typ)):
1003
if (name == tag.getAttribute("name")
1004
and prop._dbus_interface
1005
== if_tag.getAttribute("name")):
1006
annots.update(getattr(
1007
prop, "_dbus_annotations", {}))
1008
for name, value in annots.items():
1009
ann_tag = document.createElement(
1011
ann_tag.setAttribute("name", name)
1012
ann_tag.setAttribute("value", value)
1013
tag.appendChild(ann_tag)
1014
# Add interface annotation tags
1015
for annotation, value in dict(
1016
itertools.chain.from_iterable(
1017
annotations().items()
1018
for name, annotations
1019
in self._get_all_dbus_things("interface")
1020
if name == if_tag.getAttribute("name")
1022
ann_tag = document.createElement("annotation")
1023
ann_tag.setAttribute("name", annotation)
1024
ann_tag.setAttribute("value", value)
1025
if_tag.appendChild(ann_tag)
1411
1026
# Add the names to the return values for the
1412
1027
# "org.freedesktop.DBus.Properties" methods
1413
1028
if (if_tag.getAttribute("name")
1431
1046
exc_info=error)
1432
1047
return xmlstring
1435
dbus.OBJECT_MANAGER_IFACE
1436
except AttributeError:
1437
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1439
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1440
"""A D-Bus object with an ObjectManager.
1442
Classes inheriting from this exposes the standard
1443
GetManagedObjects call and the InterfacesAdded and
1444
InterfacesRemoved signals on the standard
1445
"org.freedesktop.DBus.ObjectManager" interface.
1447
Note: No signals are sent automatically; they must be sent
1450
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1451
out_signature = "a{oa{sa{sv}}}")
1452
def GetManagedObjects(self):
1453
"""This function must be overridden"""
1454
raise NotImplementedError()
1456
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1457
signature = "oa{sa{sv}}")
1458
def InterfacesAdded(self, object_path, interfaces_and_properties):
1461
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1462
def InterfacesRemoved(self, object_path, interfaces):
1465
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1466
out_signature = "s",
1467
path_keyword = 'object_path',
1468
connection_keyword = 'connection')
1469
def Introspect(self, object_path, connection):
1470
"""Overloading of standard D-Bus method.
1472
Override return argument name of GetManagedObjects to be
1473
"objpath_interfaces_and_properties"
1475
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1479
document = xml.dom.minidom.parseString(xmlstring)
1481
for if_tag in document.getElementsByTagName("interface"):
1482
# Fix argument name for the GetManagedObjects method
1483
if (if_tag.getAttribute("name")
1484
== dbus.OBJECT_MANAGER_IFACE):
1485
for cn in if_tag.getElementsByTagName("method"):
1486
if (cn.getAttribute("name")
1487
== "GetManagedObjects"):
1488
for arg in cn.getElementsByTagName("arg"):
1489
if (arg.getAttribute("direction")
1493
"objpath_interfaces"
1495
xmlstring = document.toxml("utf-8")
1497
except (AttributeError, xml.dom.DOMException,
1498
xml.parsers.expat.ExpatError) as error:
1499
logger.error("Failed to override Introspection method",
1503
1050
def datetime_to_dbus(dt, variant_level=0):
1504
1051
"""Convert a UTC datetime.datetime() to a D-Bus type."""
2313
1859
def fingerprint(openpgp):
2314
1860
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2315
1861
# New GnuTLS "datum" with the OpenPGP public key
2316
datum = gnutls.datum_t(
1862
datum = gnutls.library.types.gnutls_datum_t(
2317
1863
ctypes.cast(ctypes.c_char_p(openpgp),
2318
1864
ctypes.POINTER(ctypes.c_ubyte)),
2319
1865
ctypes.c_uint(len(openpgp)))
2320
1866
# New empty GnuTLS certificate
2321
crt = gnutls.openpgp_crt_t()
2322
gnutls.openpgp_crt_init(ctypes.byref(crt))
1867
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1868
gnutls.library.functions.gnutls_openpgp_crt_init(
2323
1870
# Import the OpenPGP public key into the certificate
2324
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2325
gnutls.OPENPGP_FMT_RAW)
1871
gnutls.library.functions.gnutls_openpgp_crt_import(
1872
crt, ctypes.byref(datum),
1873
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
2326
1874
# Verify the self signature in the key
2327
1875
crtverify = ctypes.c_uint()
2328
gnutls.openpgp_crt_verify_self(crt, 0,
2329
ctypes.byref(crtverify))
1876
gnutls.library.functions.gnutls_openpgp_crt_verify_self(
1877
crt, 0, ctypes.byref(crtverify))
2330
1878
if crtverify.value != 0:
2331
gnutls.openpgp_crt_deinit(crt)
2332
raise gnutls.CertificateSecurityError("Verify failed")
1879
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1880
raise gnutls.errors.CertificateSecurityError(
2333
1882
# New buffer for the fingerprint
2334
1883
buf = ctypes.create_string_buffer(20)
2335
1884
buf_len = ctypes.c_size_t()
2336
1885
# Get the fingerprint from the certificate into the buffer
2337
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2338
ctypes.byref(buf_len))
1886
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(
1887
crt, ctypes.byref(buf), ctypes.byref(buf_len))
2339
1888
# Deinit the certificate
2340
gnutls.openpgp_crt_deinit(crt)
1889
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2341
1890
# Convert the buffer to a Python bytestring
2342
1891
fpr = ctypes.string_at(buf, buf_len.value)
2343
1892
# Convert the bytestring to hexadecimal notation
3231
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3233
2744
@dbus.service.signal(_interface, signature="os")
3234
2745
def ClientRemoved(self, objpath, name):
3238
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3240
2749
@dbus.service.method(_interface, out_signature="ao")
3241
2750
def GetAllClients(self):
3243
2752
return dbus.Array(c.dbus_object_path for c in
3244
tcp_server.clients.values())
2753
tcp_server.clients.itervalues())
3246
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3248
2755
@dbus.service.method(_interface,
3249
2756
out_signature="a{oa{sv}}")
3250
2757
def GetAllClientsWithProperties(self):
3252
2759
return dbus.Dictionary(
3253
{ c.dbus_object_path: c.GetAll(
3254
"se.recompile.Mandos.Client")
3255
for c in tcp_server.clients.values() },
2760
{ c.dbus_object_path: c.GetAll("")
2761
for c in tcp_server.clients.itervalues() },
3256
2762
signature="oa{sv}")
3258
2764
@dbus.service.method(_interface, in_signature="o")
3259
2765
def RemoveClient(self, object_path):
3261
for c in tcp_server.clients.values():
2767
for c in tcp_server.clients.itervalues():
3262
2768
if c.dbus_object_path == object_path:
3263
2769
del tcp_server.clients[c.name]
3264
2770
c.remove_from_connection()
3265
# Don't signal the disabling
2771
# Don't signal anything except ClientRemoved
3266
2772
c.disable(quiet=True)
3267
# Emit D-Bus signal for removal
3268
self.client_removed_signal(c)
2774
self.ClientRemoved(object_path, c.name)
3270
2776
raise KeyError(object_path)
3274
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3275
out_signature = "a{oa{sa{sv}}}")
3276
def GetManagedObjects(self):
3278
return dbus.Dictionary(
3279
{ client.dbus_object_path:
3281
{ interface: client.GetAll(interface)
3283
client._get_all_interface_names()})
3284
for client in tcp_server.clients.values()})
3286
def client_added_signal(self, client):
3287
"""Send the new standard signal and the old signal"""
3289
# New standard signal
3290
self.InterfacesAdded(
3291
client.dbus_object_path,
3293
{ interface: client.GetAll(interface)
3295
client._get_all_interface_names()}))
3297
self.ClientAdded(client.dbus_object_path)
3299
def client_removed_signal(self, client):
3300
"""Send the new standard signal and the old signal"""
3302
# New standard signal
3303
self.InterfacesRemoved(
3304
client.dbus_object_path,
3305
client._get_all_interface_names())
3307
self.ClientRemoved(client.dbus_object_path,
3310
2780
mandos_dbus_service = MandosDBusService()