/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2015-08-10 09:00:23 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150810090023-fz6vjqr7zf33e2tf
Support the standard org.freedesktop.DBus.ObjectManager interface.

Now that the D-Bus standard has an interface to keep track of new and
removed objects, use that instead of our own methods.  This deprecates
our D-Bus methods "GetAllClients" and "GetAllClientsWithProperties"
and the signals "ClientAdded" and "ClientRemoved", all on the server
interface "se.recompile.Mandos".

* DBUS-API: Removed references to deprecated methods and signals;
  insert reference to the org.freedesktop.DBus.ObjectManager
  interface.
* mandos (DBusObjectWithProperties._get_all_interface_names): New.
  (dbus.OBJECT_MANAGER_IFACE): If not present, monkey patch.
  (DBusObjectWithObjectManager): New.
  (main/MandosDBusService): Inherit from DBusObjectWithObjectManager.
  (main/MandosDBusService.ClientRemoved): Annotate as deprecated.
  (main/MandosDBusService.GetAllClients): - '' -
  (main/MandosDBusService.GetAllClientsWithProperties): Annotate as
                                                        deprecated.
                                                        Also only
                                                        return
                                                        properties on
                                                        client
                                                        interface.
  (main/MandosDBusService.RemoveClient): Call client_removed_signal
                                         instead of ClientRemoved.
  (main/MandosDBusService.GetManagedObjects): New.
  (main/MandosDBusService.client_added_signal): New.
  (main/MandosDBusService.client_removed_signal): - '' -
  (main/cleanup): Call "client_removed_signal" instead of sending
                  "ClientRemoved" signal directly.
  (main): Call "client_added_signal" instead of sending "ClientAdded"
          signal directly.
* mandos-ctl: Use GetManagedObjects instead of
              GetAllClientsWithProperties.  Also, show better error
              message in case of failure to connect to the D-Bus

* mandos-monitor (MandosClientPropertyCache.properties_changed):
  Bug fix; only update properties on client interface.
  (UserInterface.find_and_remove_client): Change to accept arguments
                                          from InterfacesRemoved
                                          signal.  Also, bug fix:
                                          working error message when
                                          removing unknown client.
  (UserInterface.add_new_client): Change to accept arguments from
                                  InterfacesRemoved signal.  Pass
                                  properties to MandosClientWidget
                                  constructor.
  (UserInterface.run): Connect find_and_remove_client method to
                       InterfacesRemoved signal and the add_new_client
                       method to the InterfacesAdded signal.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
842
842
                           access="r")
843
843
    def Property_dbus_property(self):
844
844
        return dbus.Boolean(False)
 
845
    
 
846
    See also the DBusObjectWithAnnotations class.
845
847
    """
846
848
    
847
849
    def decorator(func):
869
871
    pass
870
872
 
871
873
 
872
 
class DBusObjectWithProperties(dbus.service.Object):
873
 
    """A D-Bus object with properties.
 
874
class DBusObjectWithAnnotations(dbus.service.Object):
 
875
    """A D-Bus object with annotations.
874
876
    
875
 
    Classes inheriting from this can use the dbus_service_property
876
 
    decorator to expose methods as D-Bus properties.  It exposes the
877
 
    standard Get(), Set(), and GetAll() methods on the D-Bus.
 
877
    Classes inheriting from this can use the dbus_annotations
 
878
    decorator to add annotations to methods or signals.
878
879
    """
879
880
    
880
881
    @staticmethod
896
897
                for name, athing in
897
898
                inspect.getmembers(cls, self._is_dbus_thing(thing)))
898
899
    
 
900
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
901
                         out_signature = "s",
 
902
                         path_keyword = 'object_path',
 
903
                         connection_keyword = 'connection')
 
904
    def Introspect(self, object_path, connection):
 
905
        """Overloading of standard D-Bus method.
 
906
        
 
907
        Inserts annotation tags on methods and signals.
 
908
        """
 
909
        xmlstring = dbus.service.Object.Introspect(self, object_path,
 
910
                                                   connection)
 
911
        try:
 
912
            document = xml.dom.minidom.parseString(xmlstring)
 
913
            
 
914
            for if_tag in document.getElementsByTagName("interface"):
 
915
                # Add annotation tags
 
916
                for typ in ("method", "signal"):
 
917
                    for tag in if_tag.getElementsByTagName(typ):
 
918
                        annots = dict()
 
919
                        for name, prop in (self.
 
920
                                           _get_all_dbus_things(typ)):
 
921
                            if (name == tag.getAttribute("name")
 
922
                                and prop._dbus_interface
 
923
                                == if_tag.getAttribute("name")):
 
924
                                annots.update(getattr(
 
925
                                    prop, "_dbus_annotations", {}))
 
926
                        for name, value in annots.items():
 
927
                            ann_tag = document.createElement(
 
928
                                "annotation")
 
929
                            ann_tag.setAttribute("name", name)
 
930
                            ann_tag.setAttribute("value", value)
 
931
                            tag.appendChild(ann_tag)
 
932
                # Add interface annotation tags
 
933
                for annotation, value in dict(
 
934
                    itertools.chain.from_iterable(
 
935
                        annotations().items()
 
936
                        for name, annotations
 
937
                        in self._get_all_dbus_things("interface")
 
938
                        if name == if_tag.getAttribute("name")
 
939
                        )).items():
 
940
                    ann_tag = document.createElement("annotation")
 
941
                    ann_tag.setAttribute("name", annotation)
 
942
                    ann_tag.setAttribute("value", value)
 
943
                    if_tag.appendChild(ann_tag)
 
944
                # Fix argument name for the Introspect method itself
 
945
                if (if_tag.getAttribute("name")
 
946
                                == dbus.INTROSPECTABLE_IFACE):
 
947
                    for cn in if_tag.getElementsByTagName("method"):
 
948
                        if cn.getAttribute("name") == "Introspect":
 
949
                            for arg in cn.getElementsByTagName("arg"):
 
950
                                if (arg.getAttribute("direction")
 
951
                                    == "out"):
 
952
                                    arg.setAttribute("name",
 
953
                                                     "xml_data")
 
954
            xmlstring = document.toxml("utf-8")
 
955
            document.unlink()
 
956
        except (AttributeError, xml.dom.DOMException,
 
957
                xml.parsers.expat.ExpatError) as error:
 
958
            logger.error("Failed to override Introspection method",
 
959
                         exc_info=error)
 
960
        return xmlstring
 
961
 
 
962
 
 
963
class DBusObjectWithProperties(DBusObjectWithAnnotations):
 
964
    """A D-Bus object with properties.
 
965
    
 
966
    Classes inheriting from this can use the dbus_service_property
 
967
    decorator to expose methods as D-Bus properties.  It exposes the
 
968
    standard Get(), Set(), and GetAll() methods on the D-Bus.
 
969
    """
 
970
    
899
971
    def _get_dbus_property(self, interface_name, property_name):
900
972
        """Returns a bound method if one exists which is a D-Bus
901
973
        property with the specified name and interface.
911
983
        raise DBusPropertyNotFound("{}:{}.{}".format(
912
984
            self.dbus_object_path, interface_name, property_name))
913
985
    
 
986
    @classmethod
 
987
    def _get_all_interface_names(cls):
 
988
        """Get a sequence of all interfaces supported by an object"""
 
989
        return (name for name in set(getattr(getattr(x, attr),
 
990
                                             "_dbus_interface", None)
 
991
                                     for x in (inspect.getmro(cls))
 
992
                                     for attr in dir(x))
 
993
                if name is not None)
 
994
    
914
995
    @dbus.service.method(dbus.PROPERTIES_IFACE,
915
996
                         in_signature="ss",
916
997
                         out_signature="v")
986
1067
        
987
1068
        Inserts property tags and interface annotation tags.
988
1069
        """
989
 
        xmlstring = dbus.service.Object.Introspect(self, object_path,
990
 
                                                   connection)
 
1070
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
 
1071
                                                         object_path,
 
1072
                                                         connection)
991
1073
        try:
992
1074
            document = xml.dom.minidom.parseString(xmlstring)
993
1075
            
1006
1088
                            if prop._dbus_interface
1007
1089
                            == if_tag.getAttribute("name")):
1008
1090
                    if_tag.appendChild(tag)
1009
 
                # Add annotation tags
1010
 
                for typ in ("method", "signal", "property"):
1011
 
                    for tag in if_tag.getElementsByTagName(typ):
1012
 
                        annots = dict()
1013
 
                        for name, prop in (self.
1014
 
                                           _get_all_dbus_things(typ)):
1015
 
                            if (name == tag.getAttribute("name")
1016
 
                                and prop._dbus_interface
1017
 
                                == if_tag.getAttribute("name")):
1018
 
                                annots.update(getattr(
1019
 
                                    prop, "_dbus_annotations", {}))
1020
 
                        for name, value in annots.items():
1021
 
                            ann_tag = document.createElement(
1022
 
                                "annotation")
1023
 
                            ann_tag.setAttribute("name", name)
1024
 
                            ann_tag.setAttribute("value", value)
1025
 
                            tag.appendChild(ann_tag)
1026
 
                # Add interface annotation tags
1027
 
                for annotation, value in dict(
1028
 
                    itertools.chain.from_iterable(
1029
 
                        annotations().items()
1030
 
                        for name, annotations
1031
 
                        in self._get_all_dbus_things("interface")
1032
 
                        if name == if_tag.getAttribute("name")
1033
 
                        )).items():
1034
 
                    ann_tag = document.createElement("annotation")
1035
 
                    ann_tag.setAttribute("name", annotation)
1036
 
                    ann_tag.setAttribute("value", value)
1037
 
                    if_tag.appendChild(ann_tag)
 
1091
                # Add annotation tags for properties
 
1092
                for tag in if_tag.getElementsByTagName("property"):
 
1093
                    annots = dict()
 
1094
                    for name, prop in self._get_all_dbus_things(
 
1095
                            "property"):
 
1096
                        if (name == tag.getAttribute("name")
 
1097
                            and prop._dbus_interface
 
1098
                            == if_tag.getAttribute("name")):
 
1099
                            annots.update(getattr(
 
1100
                                prop, "_dbus_annotations", {}))
 
1101
                    for name, value in annots.items():
 
1102
                        ann_tag = document.createElement(
 
1103
                            "annotation")
 
1104
                        ann_tag.setAttribute("name", name)
 
1105
                        ann_tag.setAttribute("value", value)
 
1106
                        tag.appendChild(ann_tag)
1038
1107
                # Add the names to the return values for the
1039
1108
                # "org.freedesktop.DBus.Properties" methods
1040
1109
                if (if_tag.getAttribute("name")
1058
1127
                         exc_info=error)
1059
1128
        return xmlstring
1060
1129
 
 
1130
try:
 
1131
    dbus.OBJECT_MANAGER_IFACE
 
1132
except AttributeError:
 
1133
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
 
1134
 
 
1135
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
 
1136
    """A D-Bus object with an ObjectManager.
 
1137
    
 
1138
    Classes inheriting from this exposes the standard
 
1139
    GetManagedObjects call and the InterfacesAdded and
 
1140
    InterfacesRemoved signals on the standard
 
1141
    "org.freedesktop.DBus.ObjectManager" interface.
 
1142
    
 
1143
    Note: No signals are sent automatically; they must be sent
 
1144
    manually.
 
1145
    """
 
1146
    @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
 
1147
                         out_signature = "a{oa{sa{sv}}}")
 
1148
    def GetManagedObjects(self):
 
1149
        """This function must be overridden"""
 
1150
        raise NotImplementedError()
 
1151
    
 
1152
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
 
1153
                         signature = "oa{sa{sv}}")
 
1154
    def InterfacesAdded(self, object_path, interfaces_and_properties):
 
1155
        pass
 
1156
    
 
1157
    @dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
 
1158
                         signature = "oas")
 
1159
    def InterfacesRemoved(self, object_path, interfaces):
 
1160
        pass
 
1161
    
 
1162
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
1163
                         out_signature = "s",
 
1164
                         path_keyword = 'object_path',
 
1165
                         connection_keyword = 'connection')
 
1166
    def Introspect(self, object_path, connection):
 
1167
        """Overloading of standard D-Bus method.
 
1168
        
 
1169
        Override return argument name of GetManagedObjects to be
 
1170
        "objpath_interfaces_and_properties"
 
1171
        """
 
1172
        xmlstring = DBusObjectWithAnnotations(self, object_path,
 
1173
                                              connection)
 
1174
        try:
 
1175
            document = xml.dom.minidom.parseString(xmlstring)
 
1176
            
 
1177
            for if_tag in document.getElementsByTagName("interface"):
 
1178
                # Fix argument name for the GetManagedObjects method
 
1179
                if (if_tag.getAttribute("name")
 
1180
                                == dbus.OBJECT_MANAGER_IFACE):
 
1181
                    for cn in if_tag.getElementsByTagName("method"):
 
1182
                        if (cn.getAttribute("name")
 
1183
                            == "GetManagedObjects"):
 
1184
                            for arg in cn.getElementsByTagName("arg"):
 
1185
                                if (arg.getAttribute("direction")
 
1186
                                    == "out"):
 
1187
                                    arg.setAttribute(
 
1188
                                        "name",
 
1189
                                        "objpath_interfaces"
 
1190
                                        "_and_properties")
 
1191
            xmlstring = document.toxml("utf-8")
 
1192
            document.unlink()
 
1193
        except (AttributeError, xml.dom.DOMException,
 
1194
                xml.parsers.expat.ExpatError) as error:
 
1195
            logger.error("Failed to override Introspection method",
 
1196
                         exc_info = error)
 
1197
        return xmlstring
1061
1198
 
1062
1199
def datetime_to_dbus(dt, variant_level=0):
1063
1200
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1376
1513
        if exitstatus >= 0:
1377
1514
            # Emit D-Bus signal
1378
1515
            self.CheckerCompleted(dbus.Int16(exitstatus),
1379
 
                                  dbus.Int64(0),
 
1516
                                  # This is specific to GNU libC
 
1517
                                  dbus.Int64(exitstatus << 8),
1380
1518
                                  dbus.String(command))
1381
1519
        else:
1382
1520
            # Emit D-Bus signal
1383
1521
            self.CheckerCompleted(dbus.Int16(-1),
1384
1522
                                  dbus.Int64(
1385
 
                                      self.last_checker_signal),
 
1523
                                      # This is specific to GNU libC
 
1524
                                      (exitstatus << 8)
 
1525
                                      | self.last_checker_signal),
1386
1526
                                  dbus.String(command))
1387
1527
        return ret
1388
1528
    
1465
1605
        self.checked_ok()
1466
1606
    
1467
1607
    # Enable - method
 
1608
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1468
1609
    @dbus.service.method(_interface)
1469
1610
    def Enable(self):
1470
1611
        "D-Bus method"
1471
1612
        self.enable()
1472
1613
    
1473
1614
    # StartChecker - method
 
1615
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1474
1616
    @dbus.service.method(_interface)
1475
1617
    def StartChecker(self):
1476
1618
        "D-Bus method"
1477
1619
        self.start_checker()
1478
1620
    
1479
1621
    # Disable - method
 
1622
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1480
1623
    @dbus.service.method(_interface)
1481
1624
    def Disable(self):
1482
1625
        "D-Bus method"
1483
1626
        self.disable()
1484
1627
    
1485
1628
    # StopChecker - method
 
1629
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1486
1630
    @dbus.service.method(_interface)
1487
1631
    def StopChecker(self):
1488
1632
        self.stop_checker()
1524
1668
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1525
1669
    
1526
1670
    # Name - property
 
1671
    @dbus_annotations(
 
1672
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1527
1673
    @dbus_service_property(_interface, signature="s", access="read")
1528
1674
    def Name_dbus_property(self):
1529
1675
        return dbus.String(self.name)
1530
1676
    
1531
1677
    # Fingerprint - property
 
1678
    @dbus_annotations(
 
1679
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1532
1680
    @dbus_service_property(_interface, signature="s", access="read")
1533
1681
    def Fingerprint_dbus_property(self):
1534
1682
        return dbus.String(self.fingerprint)
1543
1691
        self.host = str(value)
1544
1692
    
1545
1693
    # Created - property
 
1694
    @dbus_annotations(
 
1695
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1546
1696
    @dbus_service_property(_interface, signature="s", access="read")
1547
1697
    def Created_dbus_property(self):
1548
1698
        return datetime_to_dbus(self.created)
1663
1813
            self.stop_checker()
1664
1814
    
1665
1815
    # ObjectPath - property
 
1816
    @dbus_annotations(
 
1817
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
 
1818
         "org.freedesktop.DBus.Deprecated": "true"})
1666
1819
    @dbus_service_property(_interface, signature="o", access="read")
1667
1820
    def ObjectPath_dbus_property(self):
1668
1821
        return self.dbus_object_path # is already a dbus.ObjectPath
1669
1822
    
1670
1823
    # Secret = property
 
1824
    @dbus_annotations(
 
1825
        {"org.freedesktop.DBus.Property.EmitsChangedSignal":
 
1826
         "invalidates"})
1671
1827
    @dbus_service_property(_interface,
1672
1828
                           signature="ay",
1673
1829
                           access="write",
2397
2553
                        "debug": "False",
2398
2554
                        "priority":
2399
2555
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2400
 
                        ":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
 
2556
                        ":+SIGN-DSA-SHA256",
2401
2557
                        "servicename": "Mandos",
2402
2558
                        "use_dbus": "True",
2403
2559
                        "use_ipv6": "True",
2734
2890
        
2735
2891
        @alternate_dbus_interfaces(
2736
2892
            { "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
2737
 
        class MandosDBusService(DBusObjectWithProperties):
 
2893
        class MandosDBusService(DBusObjectWithObjectManager):
2738
2894
            """A D-Bus proxy object"""
2739
2895
            
2740
2896
            def __init__(self):
2742
2898
            
2743
2899
            _interface = "se.recompile.Mandos"
2744
2900
            
2745
 
            @dbus_interface_annotations(_interface)
2746
 
            def _foo(self):
2747
 
                return {
2748
 
                    "org.freedesktop.DBus.Property.EmitsChangedSignal":
2749
 
                    "false" }
2750
 
            
2751
2901
            @dbus.service.signal(_interface, signature="o")
2752
2902
            def ClientAdded(self, objpath):
2753
2903
                "D-Bus signal"
2758
2908
                "D-Bus signal"
2759
2909
                pass
2760
2910
            
 
2911
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
2912
                               "true"})
2761
2913
            @dbus.service.signal(_interface, signature="os")
2762
2914
            def ClientRemoved(self, objpath, name):
2763
2915
                "D-Bus signal"
2764
2916
                pass
2765
2917
            
 
2918
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
2919
                               "true"})
2766
2920
            @dbus.service.method(_interface, out_signature="ao")
2767
2921
            def GetAllClients(self):
2768
2922
                "D-Bus method"
2769
2923
                return dbus.Array(c.dbus_object_path for c in
2770
2924
                                  tcp_server.clients.itervalues())
2771
2925
            
 
2926
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
2927
                               "true"})
2772
2928
            @dbus.service.method(_interface,
2773
2929
                                 out_signature="a{oa{sv}}")
2774
2930
            def GetAllClientsWithProperties(self):
2775
2931
                "D-Bus method"
2776
2932
                return dbus.Dictionary(
2777
 
                    { c.dbus_object_path: c.GetAll("")
 
2933
                    { c.dbus_object_path: c.GetAll(
 
2934
                        "se.recompile.Mandos.Client")
2778
2935
                      for c in tcp_server.clients.itervalues() },
2779
2936
                    signature="oa{sv}")
2780
2937
            
2785
2942
                    if c.dbus_object_path == object_path:
2786
2943
                        del tcp_server.clients[c.name]
2787
2944
                        c.remove_from_connection()
2788
 
                        # Don't signal anything except ClientRemoved
 
2945
                        # Don't signal the disabling
2789
2946
                        c.disable(quiet=True)
2790
 
                        # Emit D-Bus signal
2791
 
                        self.ClientRemoved(object_path, c.name)
 
2947
                        # Emit D-Bus signal for removal
 
2948
                        self.client_removed_signal(c)
2792
2949
                        return
2793
2950
                raise KeyError(object_path)
2794
2951
            
2795
2952
            del _interface
 
2953
            
 
2954
            @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
 
2955
                                 out_signature = "a{oa{sa{sv}}}")
 
2956
            def GetManagedObjects(self):
 
2957
                """D-Bus method"""
 
2958
                return dbus.Dictionary(
 
2959
                    { client.dbus_object_path:
 
2960
                      dbus.Dictionary(
 
2961
                          { interface: client.GetAll(interface)
 
2962
                            for interface in
 
2963
                                 client._get_all_interface_names()})
 
2964
                      for client in tcp_server.clients.values()})
 
2965
            
 
2966
            def client_added_signal(self, client):
 
2967
                """Send the new standard signal and the old signal"""
 
2968
                if use_dbus:
 
2969
                    # New standard signal
 
2970
                    self.InterfacesAdded(
 
2971
                        client.dbus_object_path,
 
2972
                        dbus.Dictionary(
 
2973
                            { interface: client.GetAll(interface)
 
2974
                              for interface in
 
2975
                              client._get_all_interface_names()}))
 
2976
                    # Old signal
 
2977
                    self.ClientAdded(client.dbus_object_path)
 
2978
            
 
2979
            def client_removed_signal(self, client):
 
2980
                """Send the new standard signal and the old signal"""
 
2981
                if use_dbus:
 
2982
                    # New standard signal
 
2983
                    self.InterfacesRemoved(
 
2984
                        client.dbus_object_path,
 
2985
                        client._get_all_interface_names())
 
2986
                    # Old signal
 
2987
                    self.ClientRemoved(client.dbus_object_path,
 
2988
                                       client.name)
2796
2989
        
2797
2990
        mandos_dbus_service = MandosDBusService()
2798
2991
    
2863
3056
            name, client = tcp_server.clients.popitem()
2864
3057
            if use_dbus:
2865
3058
                client.remove_from_connection()
2866
 
            # Don't signal anything except ClientRemoved
 
3059
            # Don't signal the disabling
2867
3060
            client.disable(quiet=True)
2868
 
            if use_dbus:
2869
 
                # Emit D-Bus signal
2870
 
                mandos_dbus_service.ClientRemoved(
2871
 
                    client.dbus_object_path, client.name)
 
3061
            # Emit D-Bus signal for removal
 
3062
            mandos_dbus_service.client_removed_signal(client)
2872
3063
        client_settings.clear()
2873
3064
    
2874
3065
    atexit.register(cleanup)
2875
3066
    
2876
3067
    for client in tcp_server.clients.itervalues():
2877
3068
        if use_dbus:
2878
 
            # Emit D-Bus signal
2879
 
            mandos_dbus_service.ClientAdded(client.dbus_object_path)
 
3069
            # Emit D-Bus signal for adding
 
3070
            mandos_dbus_service.client_added_signal(client)
2880
3071
        # Need to initiate checking of clients
2881
3072
        if client.enabled:
2882
3073
            client.init_checker()