/mandos/trunk

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

« back to all changes in this revision

Viewing changes to mandos

  • Committer: Teddy Hogeborn
  • Date: 2015-08-10 10:42:52 UTC
  • Revision ID: teddy@recompile.se-20150810104252-1r6yyfwkvh5t60bz
Server Bug fix: Make D-Bus introspection work again.

* mandos (DBusObjectWithObjectManager.Introspect): Bug fix; call
                                                   method Introspect,
                                                   not class
                                                   DBusObjectWithAnnotations.
  (alternate_dbus_interfaces/wrapper/fixscope): Make wrapped D-Bus
                                                signal function look
                                                like a D-Bus signal so
                                                Introspect can see it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
395
395
                    logger.error(bad_states[state] + ": %r", error)
396
396
            self.cleanup()
397
397
        elif state == avahi.SERVER_RUNNING:
398
 
            self.add()
 
398
            try:
 
399
                self.add()
 
400
            except dbus.exceptions.DBusException as error:
 
401
                if (error.get_dbus_name()
 
402
                    == "org.freedesktop.Avahi.CollisionError"):
 
403
                    logger.info("Local Zeroconf service name"
 
404
                                " collision.")
 
405
                    return self.rename(remove=False)
 
406
                else:
 
407
                    logger.critical("D-Bus Exception", exc_info=error)
 
408
                    self.cleanup()
 
409
                    os._exit(1)
399
410
        else:
400
411
            if error is None:
401
412
                logger.debug("Unknown state: %r", state)
424
435
            .format(self.name)))
425
436
        return ret
426
437
 
 
438
def call_pipe(connection,       # : multiprocessing.Connection
 
439
              func, *args, **kwargs):
 
440
    """This function is meant to be called by multiprocessing.Process
 
441
    
 
442
    This function runs func(*args, **kwargs), and writes the resulting
 
443
    return value on the provided multiprocessing.Connection.
 
444
    """
 
445
    connection.send(func(*args, **kwargs))
 
446
    connection.close()
427
447
 
428
448
class Client(object):
429
449
    """A representation of a client host served by this server.
456
476
    last_checker_status: integer between 0 and 255 reflecting exit
457
477
                         status of last checker. -1 reflects crashed
458
478
                         checker, -2 means no checker completed yet.
 
479
    last_checker_signal: The signal which killed the last checker, if
 
480
                         last_checker_status is -1
459
481
    last_enabled: datetime.datetime(); (UTC) or None
460
482
    name:       string; from the config file, used in log messages and
461
483
                        D-Bus identifiers
635
657
        # Also start a new checker *right now*.
636
658
        self.start_checker()
637
659
    
638
 
    def checker_callback(self, pid, condition, command):
 
660
    def checker_callback(self, source, condition, connection,
 
661
                         command):
639
662
        """The checker has completed, so take appropriate actions."""
640
663
        self.checker_callback_tag = None
641
664
        self.checker = None
642
 
        if os.WIFEXITED(condition):
643
 
            self.last_checker_status = os.WEXITSTATUS(condition)
 
665
        # Read return code from connection (see call_pipe)
 
666
        returncode = connection.recv()
 
667
        connection.close()
 
668
        
 
669
        if returncode >= 0:
 
670
            self.last_checker_status = returncode
 
671
            self.last_checker_signal = None
644
672
            if self.last_checker_status == 0:
645
673
                logger.info("Checker for %(name)s succeeded",
646
674
                            vars(self))
649
677
                logger.info("Checker for %(name)s failed", vars(self))
650
678
        else:
651
679
            self.last_checker_status = -1
 
680
            self.last_checker_signal = -returncode
652
681
            logger.warning("Checker for %(name)s crashed?",
653
682
                           vars(self))
 
683
        return False
654
684
    
655
685
    def checked_ok(self):
656
686
        """Assert that the client has been seen, alive and well."""
657
687
        self.last_checked_ok = datetime.datetime.utcnow()
658
688
        self.last_checker_status = 0
 
689
        self.last_checker_signal = None
659
690
        self.bump_timeout()
660
691
    
661
692
    def bump_timeout(self, timeout=None):
687
718
        # than 'timeout' for the client to be disabled, which is as it
688
719
        # should be.
689
720
        
690
 
        # If a checker exists, make sure it is not a zombie
691
 
        try:
692
 
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
693
 
        except AttributeError:
694
 
            pass
695
 
        except OSError as error:
696
 
            if error.errno != errno.ECHILD:
697
 
                raise
698
 
        else:
699
 
            if pid:
700
 
                logger.warning("Checker was a zombie")
701
 
                gobject.source_remove(self.checker_callback_tag)
702
 
                self.checker_callback(pid, status,
703
 
                                      self.current_checker_command)
 
721
        if self.checker is not None and not self.checker.is_alive():
 
722
            logger.warning("Checker was not alive; joining")
 
723
            self.checker.join()
 
724
            self.checker = None
704
725
        # Start a new checker if needed
705
726
        if self.checker is None:
706
727
            # Escape attributes for the shell
715
736
                             exc_info=error)
716
737
                return True     # Try again later
717
738
            self.current_checker_command = command
718
 
            try:
719
 
                logger.info("Starting checker %r for %s", command,
720
 
                            self.name)
721
 
                # We don't need to redirect stdout and stderr, since
722
 
                # in normal mode, that is already done by daemon(),
723
 
                # and in debug mode we don't want to.  (Stdin is
724
 
                # always replaced by /dev/null.)
725
 
                # The exception is when not debugging but nevertheless
726
 
                # running in the foreground; use the previously
727
 
                # created wnull.
728
 
                popen_args = {}
729
 
                if (not self.server_settings["debug"]
730
 
                    and self.server_settings["foreground"]):
731
 
                    popen_args.update({"stdout": wnull,
732
 
                                       "stderr": wnull })
733
 
                self.checker = subprocess.Popen(command,
734
 
                                                close_fds=True,
735
 
                                                shell=True,
736
 
                                                cwd="/",
737
 
                                                **popen_args)
738
 
            except OSError as error:
739
 
                logger.error("Failed to start subprocess",
740
 
                             exc_info=error)
741
 
                return True
742
 
            self.checker_callback_tag = gobject.child_watch_add(
743
 
                self.checker.pid, self.checker_callback, data=command)
744
 
            # The checker may have completed before the gobject
745
 
            # watch was added.  Check for this.
746
 
            try:
747
 
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
748
 
            except OSError as error:
749
 
                if error.errno == errno.ECHILD:
750
 
                    # This should never happen
751
 
                    logger.error("Child process vanished",
752
 
                                 exc_info=error)
753
 
                    return True
754
 
                raise
755
 
            if pid:
756
 
                gobject.source_remove(self.checker_callback_tag)
757
 
                self.checker_callback(pid, status, command)
 
739
            logger.info("Starting checker %r for %s", command,
 
740
                        self.name)
 
741
            # We don't need to redirect stdout and stderr, since
 
742
            # in normal mode, that is already done by daemon(),
 
743
            # and in debug mode we don't want to.  (Stdin is
 
744
            # always replaced by /dev/null.)
 
745
            # The exception is when not debugging but nevertheless
 
746
            # running in the foreground; use the previously
 
747
            # created wnull.
 
748
            popen_args = { "close_fds": True,
 
749
                           "shell": True,
 
750
                           "cwd": "/" }
 
751
            if (not self.server_settings["debug"]
 
752
                and self.server_settings["foreground"]):
 
753
                popen_args.update({"stdout": wnull,
 
754
                                   "stderr": wnull })
 
755
            pipe = multiprocessing.Pipe(duplex = False)
 
756
            self.checker = multiprocessing.Process(
 
757
                target = call_pipe,
 
758
                args = (pipe[1], subprocess.call, command),
 
759
                kwargs = popen_args)
 
760
            self.checker.start()
 
761
            self.checker_callback_tag = gobject.io_add_watch(
 
762
                pipe[0].fileno(), gobject.IO_IN,
 
763
                self.checker_callback, pipe[0], command)
758
764
        # Re-run this periodically if run by gobject.timeout_add
759
765
        return True
760
766
    
766
772
        if getattr(self, "checker", None) is None:
767
773
            return
768
774
        logger.debug("Stopping checker for %(name)s", vars(self))
769
 
        try:
770
 
            self.checker.terminate()
771
 
            #time.sleep(0.5)
772
 
            #if self.checker.poll() is None:
773
 
            #    self.checker.kill()
774
 
        except OSError as error:
775
 
            if error.errno != errno.ESRCH: # No such process
776
 
                raise
 
775
        self.checker.terminate()
777
776
        self.checker = None
778
777
 
779
778
 
843
842
                           access="r")
844
843
    def Property_dbus_property(self):
845
844
        return dbus.Boolean(False)
 
845
    
 
846
    See also the DBusObjectWithAnnotations class.
846
847
    """
847
848
    
848
849
    def decorator(func):
870
871
    pass
871
872
 
872
873
 
873
 
class DBusObjectWithProperties(dbus.service.Object):
874
 
    """A D-Bus object with properties.
 
874
class DBusObjectWithAnnotations(dbus.service.Object):
 
875
    """A D-Bus object with annotations.
875
876
    
876
 
    Classes inheriting from this can use the dbus_service_property
877
 
    decorator to expose methods as D-Bus properties.  It exposes the
878
 
    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.
879
879
    """
880
880
    
881
881
    @staticmethod
897
897
                for name, athing in
898
898
                inspect.getmembers(cls, self._is_dbus_thing(thing)))
899
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
    
900
971
    def _get_dbus_property(self, interface_name, property_name):
901
972
        """Returns a bound method if one exists which is a D-Bus
902
973
        property with the specified name and interface.
912
983
        raise DBusPropertyNotFound("{}:{}.{}".format(
913
984
            self.dbus_object_path, interface_name, property_name))
914
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
    
915
995
    @dbus.service.method(dbus.PROPERTIES_IFACE,
916
996
                         in_signature="ss",
917
997
                         out_signature="v")
987
1067
        
988
1068
        Inserts property tags and interface annotation tags.
989
1069
        """
990
 
        xmlstring = dbus.service.Object.Introspect(self, object_path,
991
 
                                                   connection)
 
1070
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
 
1071
                                                         object_path,
 
1072
                                                         connection)
992
1073
        try:
993
1074
            document = xml.dom.minidom.parseString(xmlstring)
994
1075
            
1007
1088
                            if prop._dbus_interface
1008
1089
                            == if_tag.getAttribute("name")):
1009
1090
                    if_tag.appendChild(tag)
1010
 
                # Add annotation tags
1011
 
                for typ in ("method", "signal", "property"):
1012
 
                    for tag in if_tag.getElementsByTagName(typ):
1013
 
                        annots = dict()
1014
 
                        for name, prop in (self.
1015
 
                                           _get_all_dbus_things(typ)):
1016
 
                            if (name == tag.getAttribute("name")
1017
 
                                and prop._dbus_interface
1018
 
                                == if_tag.getAttribute("name")):
1019
 
                                annots.update(getattr(
1020
 
                                    prop, "_dbus_annotations", {}))
1021
 
                        for name, value in annots.items():
1022
 
                            ann_tag = document.createElement(
1023
 
                                "annotation")
1024
 
                            ann_tag.setAttribute("name", name)
1025
 
                            ann_tag.setAttribute("value", value)
1026
 
                            tag.appendChild(ann_tag)
1027
 
                # Add interface annotation tags
1028
 
                for annotation, value in dict(
1029
 
                    itertools.chain.from_iterable(
1030
 
                        annotations().items()
1031
 
                        for name, annotations
1032
 
                        in self._get_all_dbus_things("interface")
1033
 
                        if name == if_tag.getAttribute("name")
1034
 
                        )).items():
1035
 
                    ann_tag = document.createElement("annotation")
1036
 
                    ann_tag.setAttribute("name", annotation)
1037
 
                    ann_tag.setAttribute("value", value)
1038
 
                    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)
1039
1107
                # Add the names to the return values for the
1040
1108
                # "org.freedesktop.DBus.Properties" methods
1041
1109
                if (if_tag.getAttribute("name")
1059
1127
                         exc_info=error)
1060
1128
        return xmlstring
1061
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, signature = "oas")
 
1158
    def InterfacesRemoved(self, object_path, interfaces):
 
1159
        pass
 
1160
    
 
1161
    @dbus.service.method(dbus.INTROSPECTABLE_IFACE,
 
1162
                         out_signature = "s",
 
1163
                         path_keyword = 'object_path',
 
1164
                         connection_keyword = 'connection')
 
1165
    def Introspect(self, object_path, connection):
 
1166
        """Overloading of standard D-Bus method.
 
1167
        
 
1168
        Override return argument name of GetManagedObjects to be
 
1169
        "objpath_interfaces_and_properties"
 
1170
        """
 
1171
        xmlstring = DBusObjectWithAnnotations.Introspect(self,
 
1172
                                                         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
1062
1198
 
1063
1199
def datetime_to_dbus(dt, variant_level=0):
1064
1200
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1111
1247
                interface_names.add(alt_interface)
1112
1248
                # Is this a D-Bus signal?
1113
1249
                if getattr(attribute, "_dbus_is_signal", False):
1114
 
                    # Extract the original non-method undecorated
1115
 
                    # function by black magic
1116
 
                    nonmethod_func = (dict(
1117
 
                        zip(attribute.func_code.co_freevars,
1118
 
                            attribute.__closure__))
1119
 
                                      ["func"].cell_contents)
 
1250
                    if sys.version_info.major == 2:
 
1251
                        # Extract the original non-method undecorated
 
1252
                        # function by black magic
 
1253
                        nonmethod_func = (dict(
 
1254
                            zip(attribute.func_code.co_freevars,
 
1255
                                attribute.__closure__))
 
1256
                                          ["func"].cell_contents)
 
1257
                    else:
 
1258
                        nonmethod_func = attribute
1120
1259
                    # Create a new, but exactly alike, function
1121
1260
                    # object, and decorate it to be a new D-Bus signal
1122
1261
                    # with the alternate D-Bus interface name
 
1262
                    if sys.version_info.major == 2:
 
1263
                        new_function = types.FunctionType(
 
1264
                            nonmethod_func.func_code,
 
1265
                            nonmethod_func.func_globals,
 
1266
                            nonmethod_func.func_name,
 
1267
                            nonmethod_func.func_defaults,
 
1268
                            nonmethod_func.func_closure)
 
1269
                    else:
 
1270
                        new_function = types.FunctionType(
 
1271
                            nonmethod_func.__code__,
 
1272
                            nonmethod_func.__globals__,
 
1273
                            nonmethod_func.__name__,
 
1274
                            nonmethod_func.__defaults__,
 
1275
                            nonmethod_func.__closure__)
1123
1276
                    new_function = (dbus.service.signal(
1124
 
                        alt_interface, attribute._dbus_signature)
1125
 
                                    (types.FunctionType(
1126
 
                                        nonmethod_func.func_code,
1127
 
                                        nonmethod_func.func_globals,
1128
 
                                        nonmethod_func.func_name,
1129
 
                                        nonmethod_func.func_defaults,
1130
 
                                        nonmethod_func.func_closure)))
 
1277
                        alt_interface,
 
1278
                        attribute._dbus_signature)(new_function))
1131
1279
                    # Copy annotations, if any
1132
1280
                    try:
1133
1281
                        new_function._dbus_annotations = dict(
1143
1291
                        func1 and func2 to the "call_both" function
1144
1292
                        outside of its arguments"""
1145
1293
                        
 
1294
                        @functools.wraps(func2)
1146
1295
                        def call_both(*args, **kwargs):
1147
1296
                            """This function will emit two D-Bus
1148
1297
                            signals by calling func1 and func2"""
1149
1298
                            func1(*args, **kwargs)
1150
1299
                            func2(*args, **kwargs)
 
1300
                        # Make wrapper function look like a D-Bus signal
 
1301
                        for name, attr in inspect.getmembers(func2):
 
1302
                            if name.startswith("_dbus_"):
 
1303
                                setattr(call_both, name, attr)
1151
1304
                        
1152
1305
                        return call_both
1153
1306
                    # Create the "call_both" function and add it to
1356
1509
            DBusObjectWithProperties.__del__(self, *args, **kwargs)
1357
1510
        Client.__del__(self, *args, **kwargs)
1358
1511
    
1359
 
    def checker_callback(self, pid, condition, command,
1360
 
                         *args, **kwargs):
1361
 
        self.checker_callback_tag = None
1362
 
        self.checker = None
1363
 
        if os.WIFEXITED(condition):
1364
 
            exitstatus = os.WEXITSTATUS(condition)
 
1512
    def checker_callback(self, source, condition,
 
1513
                         connection, command, *args, **kwargs):
 
1514
        ret = Client.checker_callback(self, source, condition,
 
1515
                                      connection, command, *args,
 
1516
                                      **kwargs)
 
1517
        exitstatus = self.last_checker_status
 
1518
        if exitstatus >= 0:
1365
1519
            # Emit D-Bus signal
1366
1520
            self.CheckerCompleted(dbus.Int16(exitstatus),
1367
 
                                  dbus.Int64(condition),
 
1521
                                  # This is specific to GNU libC
 
1522
                                  dbus.Int64(exitstatus << 8),
1368
1523
                                  dbus.String(command))
1369
1524
        else:
1370
1525
            # Emit D-Bus signal
1371
1526
            self.CheckerCompleted(dbus.Int16(-1),
1372
 
                                  dbus.Int64(condition),
 
1527
                                  dbus.Int64(
 
1528
                                      # This is specific to GNU libC
 
1529
                                      (exitstatus << 8)
 
1530
                                      | self.last_checker_signal),
1373
1531
                                  dbus.String(command))
1374
 
        
1375
 
        return Client.checker_callback(self, pid, condition, command,
1376
 
                                       *args, **kwargs)
 
1532
        return ret
1377
1533
    
1378
1534
    def start_checker(self, *args, **kwargs):
1379
1535
        old_checker_pid = getattr(self.checker, "pid", None)
1454
1610
        self.checked_ok()
1455
1611
    
1456
1612
    # Enable - method
 
1613
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1457
1614
    @dbus.service.method(_interface)
1458
1615
    def Enable(self):
1459
1616
        "D-Bus method"
1460
1617
        self.enable()
1461
1618
    
1462
1619
    # StartChecker - method
 
1620
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1463
1621
    @dbus.service.method(_interface)
1464
1622
    def StartChecker(self):
1465
1623
        "D-Bus method"
1466
1624
        self.start_checker()
1467
1625
    
1468
1626
    # Disable - method
 
1627
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1469
1628
    @dbus.service.method(_interface)
1470
1629
    def Disable(self):
1471
1630
        "D-Bus method"
1472
1631
        self.disable()
1473
1632
    
1474
1633
    # StopChecker - method
 
1634
    @dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1475
1635
    @dbus.service.method(_interface)
1476
1636
    def StopChecker(self):
1477
1637
        self.stop_checker()
1513
1673
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1514
1674
    
1515
1675
    # Name - property
 
1676
    @dbus_annotations(
 
1677
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1516
1678
    @dbus_service_property(_interface, signature="s", access="read")
1517
1679
    def Name_dbus_property(self):
1518
1680
        return dbus.String(self.name)
1519
1681
    
1520
1682
    # Fingerprint - property
 
1683
    @dbus_annotations(
 
1684
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1521
1685
    @dbus_service_property(_interface, signature="s", access="read")
1522
1686
    def Fingerprint_dbus_property(self):
1523
1687
        return dbus.String(self.fingerprint)
1532
1696
        self.host = str(value)
1533
1697
    
1534
1698
    # Created - property
 
1699
    @dbus_annotations(
 
1700
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1535
1701
    @dbus_service_property(_interface, signature="s", access="read")
1536
1702
    def Created_dbus_property(self):
1537
1703
        return datetime_to_dbus(self.created)
1652
1818
            self.stop_checker()
1653
1819
    
1654
1820
    # ObjectPath - property
 
1821
    @dbus_annotations(
 
1822
        {"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
 
1823
         "org.freedesktop.DBus.Deprecated": "true"})
1655
1824
    @dbus_service_property(_interface, signature="o", access="read")
1656
1825
    def ObjectPath_dbus_property(self):
1657
1826
        return self.dbus_object_path # is already a dbus.ObjectPath
1658
1827
    
1659
1828
    # Secret = property
 
1829
    @dbus_annotations(
 
1830
        {"org.freedesktop.DBus.Property.EmitsChangedSignal":
 
1831
         "invalidates"})
1660
1832
    @dbus_service_property(_interface,
1661
1833
                           signature="ay",
1662
1834
                           access="write",
1672
1844
        self._pipe = child_pipe
1673
1845
        self._pipe.send(('init', fpr, address))
1674
1846
        if not self._pipe.recv():
1675
 
            raise KeyError()
 
1847
            raise KeyError(fpr)
1676
1848
    
1677
1849
    def __getattribute__(self, name):
1678
1850
        if name == '_pipe':
2141
2313
        
2142
2314
        if command == 'getattr':
2143
2315
            attrname = request[1]
2144
 
            if callable(client_object.__getattribute__(attrname)):
 
2316
            if isinstance(client_object.__getattribute__(attrname),
 
2317
                          collections.Callable):
2145
2318
                parent_pipe.send(('function', ))
2146
2319
            else:
2147
2320
                parent_pipe.send((
2182
2355
    # avoid excessive use of external libraries.
2183
2356
    
2184
2357
    # New type for defining tokens, syntax, and semantics all-in-one
2185
 
    Token = collections.namedtuple("Token",
2186
 
                                   ("regexp", # To match token; if
2187
 
                                              # "value" is not None,
2188
 
                                              # must have a "group"
2189
 
                                              # containing digits
2190
 
                                    "value",  # datetime.timedelta or
2191
 
                                              # None
2192
 
                                    "followers")) # Tokens valid after
2193
 
                                                  # this token
2194
2358
    Token = collections.namedtuple("Token", (
2195
2359
        "regexp",  # To match token; if "value" is not None, must have
2196
2360
                   # a "group" containing digits
2231
2395
    # Define starting values
2232
2396
    value = datetime.timedelta() # Value so far
2233
2397
    found_token = None
2234
 
    followers = frozenset((token_duration,)) # Following valid tokens
 
2398
    followers = frozenset((token_duration, )) # Following valid tokens
2235
2399
    s = duration                # String left to parse
2236
2400
    # Loop until end token is found
2237
2401
    while found_token is not token_end:
2254
2418
                break
2255
2419
        else:
2256
2420
            # No currently valid tokens were found
2257
 
            raise ValueError("Invalid RFC 3339 duration")
 
2421
            raise ValueError("Invalid RFC 3339 duration: {!r}"
 
2422
                             .format(duration))
2258
2423
    # End token found
2259
2424
    return value
2260
2425
 
2393
2558
                        "debug": "False",
2394
2559
                        "priority":
2395
2560
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2396
 
                        ":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
 
2561
                        ":+SIGN-DSA-SHA256",
2397
2562
                        "servicename": "Mandos",
2398
2563
                        "use_dbus": "True",
2399
2564
                        "use_ipv6": "True",
2655
2820
                    pass
2656
2821
            
2657
2822
            # Clients who has passed its expire date can still be
2658
 
            # enabled if its last checker was successful.  Clients
 
2823
            # enabled if its last checker was successful.  A Client
2659
2824
            # whose checker succeeded before we stored its state is
2660
2825
            # assumed to have successfully run all checkers during
2661
2826
            # downtime.
2730
2895
        
2731
2896
        @alternate_dbus_interfaces(
2732
2897
            { "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
2733
 
        class MandosDBusService(DBusObjectWithProperties):
 
2898
        class MandosDBusService(DBusObjectWithObjectManager):
2734
2899
            """A D-Bus proxy object"""
2735
2900
            
2736
2901
            def __init__(self):
2738
2903
            
2739
2904
            _interface = "se.recompile.Mandos"
2740
2905
            
2741
 
            @dbus_interface_annotations(_interface)
2742
 
            def _foo(self):
2743
 
                return {
2744
 
                    "org.freedesktop.DBus.Property.EmitsChangedSignal":
2745
 
                    "false" }
2746
 
            
2747
2906
            @dbus.service.signal(_interface, signature="o")
2748
2907
            def ClientAdded(self, objpath):
2749
2908
                "D-Bus signal"
2754
2913
                "D-Bus signal"
2755
2914
                pass
2756
2915
            
 
2916
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
2917
                               "true"})
2757
2918
            @dbus.service.signal(_interface, signature="os")
2758
2919
            def ClientRemoved(self, objpath, name):
2759
2920
                "D-Bus signal"
2760
2921
                pass
2761
2922
            
 
2923
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
2924
                               "true"})
2762
2925
            @dbus.service.method(_interface, out_signature="ao")
2763
2926
            def GetAllClients(self):
2764
2927
                "D-Bus method"
2765
2928
                return dbus.Array(c.dbus_object_path for c in
2766
2929
                                  tcp_server.clients.itervalues())
2767
2930
            
 
2931
            @dbus_annotations({"org.freedesktop.DBus.Deprecated":
 
2932
                               "true"})
2768
2933
            @dbus.service.method(_interface,
2769
2934
                                 out_signature="a{oa{sv}}")
2770
2935
            def GetAllClientsWithProperties(self):
2771
2936
                "D-Bus method"
2772
2937
                return dbus.Dictionary(
2773
 
                    { c.dbus_object_path: c.GetAll("")
 
2938
                    { c.dbus_object_path: c.GetAll(
 
2939
                        "se.recompile.Mandos.Client")
2774
2940
                      for c in tcp_server.clients.itervalues() },
2775
2941
                    signature="oa{sv}")
2776
2942
            
2781
2947
                    if c.dbus_object_path == object_path:
2782
2948
                        del tcp_server.clients[c.name]
2783
2949
                        c.remove_from_connection()
2784
 
                        # Don't signal anything except ClientRemoved
 
2950
                        # Don't signal the disabling
2785
2951
                        c.disable(quiet=True)
2786
 
                        # Emit D-Bus signal
2787
 
                        self.ClientRemoved(object_path, c.name)
 
2952
                        # Emit D-Bus signal for removal
 
2953
                        self.client_removed_signal(c)
2788
2954
                        return
2789
2955
                raise KeyError(object_path)
2790
2956
            
2791
2957
            del _interface
 
2958
            
 
2959
            @dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
 
2960
                                 out_signature = "a{oa{sa{sv}}}")
 
2961
            def GetManagedObjects(self):
 
2962
                """D-Bus method"""
 
2963
                return dbus.Dictionary(
 
2964
                    { client.dbus_object_path:
 
2965
                      dbus.Dictionary(
 
2966
                          { interface: client.GetAll(interface)
 
2967
                            for interface in
 
2968
                                 client._get_all_interface_names()})
 
2969
                      for client in tcp_server.clients.values()})
 
2970
            
 
2971
            def client_added_signal(self, client):
 
2972
                """Send the new standard signal and the old signal"""
 
2973
                if use_dbus:
 
2974
                    # New standard signal
 
2975
                    self.InterfacesAdded(
 
2976
                        client.dbus_object_path,
 
2977
                        dbus.Dictionary(
 
2978
                            { interface: client.GetAll(interface)
 
2979
                              for interface in
 
2980
                              client._get_all_interface_names()}))
 
2981
                    # Old signal
 
2982
                    self.ClientAdded(client.dbus_object_path)
 
2983
            
 
2984
            def client_removed_signal(self, client):
 
2985
                """Send the new standard signal and the old signal"""
 
2986
                if use_dbus:
 
2987
                    # New standard signal
 
2988
                    self.InterfacesRemoved(
 
2989
                        client.dbus_object_path,
 
2990
                        client._get_all_interface_names())
 
2991
                    # Old signal
 
2992
                    self.ClientRemoved(client.dbus_object_path,
 
2993
                                       client.name)
2792
2994
        
2793
2995
        mandos_dbus_service = MandosDBusService()
2794
2996
    
2859
3061
            name, client = tcp_server.clients.popitem()
2860
3062
            if use_dbus:
2861
3063
                client.remove_from_connection()
2862
 
            # Don't signal anything except ClientRemoved
 
3064
            # Don't signal the disabling
2863
3065
            client.disable(quiet=True)
2864
 
            if use_dbus:
2865
 
                # Emit D-Bus signal
2866
 
                mandos_dbus_service.ClientRemoved(
2867
 
                    client.dbus_object_path, client.name)
 
3066
            # Emit D-Bus signal for removal
 
3067
            mandos_dbus_service.client_removed_signal(client)
2868
3068
        client_settings.clear()
2869
3069
    
2870
3070
    atexit.register(cleanup)
2871
3071
    
2872
3072
    for client in tcp_server.clients.itervalues():
2873
3073
        if use_dbus:
2874
 
            # Emit D-Bus signal
2875
 
            mandos_dbus_service.ClientAdded(client.dbus_object_path)
 
3074
            # Emit D-Bus signal for adding
 
3075
            mandos_dbus_service.client_added_signal(client)
2876
3076
        # Need to initiate checking of clients
2877
3077
        if client.enabled:
2878
3078
            client.init_checker()