/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

Change "fukt.bsnet.se" to "recompile.se" throughout.

* README: - '' -
* debian/control: - '' -
* debian/copyright: - '' -
* debian/mandos-client.README.Debian: - '' - and some rewriting.
* debian/mandos.README.Debian: - '' -
* debian/watch: Change "fukt.bsnet.se" to "recompile.se".
* init.d-mandos: - '' -
* intro.xml: - '' -
* mandos: - '' -
* mandos-clients.conf.xml: - '' -
* mandos-ctl: - '' -
* mandos-ctl.xml: - '' -
* mandos-keygen: - '' -
* mandos-keygen.xml: - '' -
* mandos-monitor: - '' -
* mandos-monitor.xml: - '' -
* mandos.conf.xml: - '' -
* mandos.lsm: - '' -
* mandos.xml: - '' -
* plugin-runner.c: - '' -
* plugin-runner.xml: - '' -
* plugins.d/askpass-fifo.c: - '' -
* plugins.d/askpass-fifo.xml: - '' -
* plugins.d/mandos-client.c: - '' -
* plugins.d/mandos-client.xml: - '' -
* plugins.d/password-prompt.c: - '' -
* plugins.d/password-prompt.xml: - '' -
* plugins.d/plymouth.c: - '' -
* plugins.d/plymouth.xml: - '' -
* plugins.d/splashy.c: - '' -
* plugins.d/splashy.xml: - '' -
* plugins.d/usplash.c: - '' -
* plugins.d/usplash.xml: - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
28
28
# along with this program.  If not, see
29
29
# <http://www.gnu.org/licenses/>.
30
30
# 
31
 
# Contact the authors at <mandos@fukt.bsnet.se>.
 
31
# Contact the authors at <mandos@recompile.se>.
32
32
# 
33
33
 
34
34
from __future__ import (division, absolute_import, print_function,
627
627
    def _get_all_dbus_properties(self):
628
628
        """Returns a generator of (name, attribute) pairs
629
629
        """
630
 
        return ((prop._dbus_name, prop)
631
 
                for name, prop in
632
 
                inspect.getmembers(self, self._is_dbus_property))
 
630
        return ((prop.__get__(self)._dbus_name, prop.__get__(self))
 
631
                for cls in self.__class__.__mro__
 
632
                for name, prop in inspect.getmembers(cls, self._is_dbus_property))
633
633
    
634
 
#    def _get_dbus_property(self, interface_name, property_name):
635
 
#        """Returns a bound method if one exists which is a D-Bus
636
 
#        property with the specified name and interface.
637
 
#        """
638
 
#        print("get_property({0!r}, {1!r}".format(interface_name, property_name),file=sys.stderr)
639
 
#        print(dir(self), sys.stderr)
640
 
#        for name in (property_name,
641
 
#                     property_name + "_dbus_property"):
642
 
#            prop = getattr(self, name, None)
643
 
#            if (prop is None
644
 
#                or not self._is_dbus_property(prop)
645
 
#                or prop._dbus_name != property_name
646
 
#                or (interface_name and prop._dbus_interface
647
 
#                    and interface_name != prop._dbus_interface)):
648
 
#                continue
649
 
#            return prop
650
 
#        # No such property
651
 
#        raise DBusPropertyNotFound(self.dbus_object_path + ":"
652
 
#                                   + interface_name + "."
653
 
#                                   + property_name)
654
 
 
655
634
    def _get_dbus_property(self, interface_name, property_name):
656
635
        """Returns a bound method if one exists which is a D-Bus
657
636
        property with the specified name and interface.
658
637
        """
659
 
        for name, value in inspect.getmembers(self, self._is_dbus_property):
660
 
            if value._dbus_name == property_name and value._dbus_interface == interface_name:
661
 
                return value
 
638
        for cls in  self.__class__.__mro__:
 
639
            for name, value in inspect.getmembers(cls, self._is_dbus_property):
 
640
                if value._dbus_name == property_name and value._dbus_interface == interface_name:
 
641
                    return value.__get__(self)
662
642
        
663
643
        # No such property
664
644
        raise DBusPropertyNotFound(self.dbus_object_path + ":"
665
645
                                   + interface_name + "."
666
646
                                   + property_name)
667
 
 
668
647
    
669
648
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
670
649
                         out_signature="v")
775
754
    return dbus.String(dt.isoformat(),
776
755
                       variant_level=variant_level)
777
756
 
778
 
class transitional_clientdbus(DBusObjectWithProperties.__metaclass__):
 
757
class AlternateDBusNamesMetaclass(DBusObjectWithProperties.__metaclass__):
 
758
    """Applied to an empty subclass of a D-Bus object, this metaclass
 
759
    will add additional D-Bus attributes matching a certain pattern.
 
760
    """
779
761
    def __new__(mcs, name, bases, attr):
780
 
        for key, old_dbusobj in attr.items():
781
 
            new_interface = getattr(old_dbusobj, "_dbus_interface", "").replace("se.bsnet.fukt.", "se.recompile.")
782
 
            if getattr(old_dbusobj, "_dbus_is_signal", False):
783
 
                unwrappedfunc = dict(zip(old_dbusobj.func_code.co_freevars,
784
 
                                    old_dbusobj.__closure__))["func"].cell_contents
785
 
                newfunc = types.FunctionType(unwrappedfunc.func_code,
786
 
                                             unwrappedfunc.func_globals,
787
 
                                             unwrappedfunc.func_name,
788
 
                                             unwrappedfunc.func_defaults,
789
 
                                             unwrappedfunc.func_closure)
790
 
                new_dbusfunc = dbus.service.signal(
791
 
                    new_interface, old_dbusobj._dbus_signature)(newfunc)            
792
 
                attr["_transitional_{0}_1".format(key)] = new_dbusfunc
793
 
                attr["_transitional_{0}_0".format(key)] = old_dbusobj                
794
 
                def fixscope(func1, func2):
795
 
                    def newcall(*args, **kwargs):
796
 
                        func1(*args, **kwargs)
797
 
                        func2(*args, **kwargs)
798
 
                    return newcall
799
 
 
800
 
                attr[key] = fixscope(
801
 
                    old_dbusobj, attr["_transitional_{0}_1".format(key)])
802
 
            
803
 
            if getattr(old_dbusobj, "_dbus_is_method", False):
804
 
                new_dbusfunc = (dbus.service.method
805
 
                                (new_interface,
806
 
                                 old_dbusobj._dbus_in_signature,
807
 
                                 old_dbusobj._dbus_out_signature)
808
 
                                (types.FunctionType
809
 
                                 (old_dbusobj.func_code,
810
 
                                  old_dbusobj.func_globals,
811
 
                                  old_dbusobj.func_name,
812
 
                                  old_dbusobj.func_defaults,
813
 
                                  old_dbusobj.func_closure)))
814
 
 
815
 
                attr["_transitional_{0}".format(key)] = new_dbusfunc
816
 
            if getattr(old_dbusobj, "_dbus_is_property", False):
817
 
                new_dbusfunc = (dbus_service_property
818
 
                                (new_interface,
819
 
                                 old_dbusobj._dbus_signature,
820
 
                                 old_dbusobj._dbus_access,
821
 
                                 old_dbusobj._dbus_get_args_options["byte_arrays"])
822
 
                                (types.FunctionType
823
 
                                 (old_dbusobj.func_code,
824
 
                                  old_dbusobj.func_globals,
825
 
                                  old_dbusobj.func_name,
826
 
                                  old_dbusobj.func_defaults,
827
 
                                  old_dbusobj.func_closure)))
828
 
 
829
 
                attr["_transitional_{0}".format(key)] = new_dbusfunc
 
762
        # Go through all the base classes which could have D-Bus
 
763
        # methods, signals, or properties in them
 
764
        for base in (b for b in bases
 
765
                     if issubclass(b, dbus.service.Object)):
 
766
            # Go though all attributes of the base class
 
767
            for attrname, attribute in inspect.getmembers(base):
 
768
                # Ignore non-D-Bus attributes, and D-Bus attributes
 
769
                # with the wrong interface name
 
770
                if (not hasattr(attribute, "_dbus_interface")
 
771
                    or not attribute._dbus_interface
 
772
                    .startswith("se.recompile.Mandos")):
 
773
                    continue
 
774
                # Create an alternate D-Bus interface name based on
 
775
                # the current name
 
776
                alt_interface = (attribute._dbus_interface
 
777
                                 .replace("se.recompile.Mandos",
 
778
                                          "se.bsnet.fukt.Mandos"))
 
779
                # Is this a D-Bus signal?
 
780
                if getattr(attribute, "_dbus_is_signal", False):
 
781
                    # Extract the original non-method function by
 
782
                    # black magic
 
783
                    nonmethod_func = (dict(
 
784
                            zip(attribute.func_code.co_freevars,
 
785
                                attribute.__closure__))["func"]
 
786
                                      .cell_contents)
 
787
                    # Create a new, but exactly alike, function
 
788
                    # object, and decorate it to be a new D-Bus signal
 
789
                    # with the alternate D-Bus interface name
 
790
                    new_function = (dbus.service.signal
 
791
                                    (alt_interface,
 
792
                                     attribute._dbus_signature)
 
793
                                    (types.FunctionType(
 
794
                                nonmethod_func.func_code,
 
795
                                nonmethod_func.func_globals,
 
796
                                nonmethod_func.func_name,
 
797
                                nonmethod_func.func_defaults,
 
798
                                nonmethod_func.func_closure)))
 
799
                    # Define a creator of a function to call both the
 
800
                    # old and new functions, so both the old and new
 
801
                    # signals gets sent when the function is called
 
802
                    def fixscope(func1, func2):
 
803
                        """This function is a scope container to pass
 
804
                        func1 and func2 to the "call_both" function
 
805
                        outside of its arguments"""
 
806
                        def call_both(*args, **kwargs):
 
807
                            """This function will emit two D-Bus
 
808
                            signals by calling func1 and func2"""
 
809
                            func1(*args, **kwargs)
 
810
                            func2(*args, **kwargs)
 
811
                        return call_both
 
812
                    # Create the "call_both" function and add it to
 
813
                    # the class
 
814
                    attr[attrname] = fixscope(attribute,
 
815
                                              new_function)
 
816
                # Is this a D-Bus method?
 
817
                elif getattr(attribute, "_dbus_is_method", False):
 
818
                    # Create a new, but exactly alike, function
 
819
                    # object.  Decorate it to be a new D-Bus method
 
820
                    # with the alternate D-Bus interface name.  Add it
 
821
                    # to the class.
 
822
                    attr[attrname] = (dbus.service.method
 
823
                                      (alt_interface,
 
824
                                       attribute._dbus_in_signature,
 
825
                                       attribute._dbus_out_signature)
 
826
                                      (types.FunctionType
 
827
                                       (attribute.func_code,
 
828
                                        attribute.func_globals,
 
829
                                        attribute.func_name,
 
830
                                        attribute.func_defaults,
 
831
                                        attribute.func_closure)))
 
832
                # Is this a D-Bus property?
 
833
                elif getattr(attribute, "_dbus_is_property", False):
 
834
                    # Create a new, but exactly alike, function
 
835
                    # object, and decorate it to be a new D-Bus
 
836
                    # property with the alternate D-Bus interface
 
837
                    # name.  Add it to the class.
 
838
                    attr[attrname] = (dbus_service_property
 
839
                                      (alt_interface,
 
840
                                       attribute._dbus_signature,
 
841
                                       attribute._dbus_access,
 
842
                                       attribute
 
843
                                       ._dbus_get_args_options
 
844
                                       ["byte_arrays"])
 
845
                                      (types.FunctionType
 
846
                                       (attribute.func_code,
 
847
                                        attribute.func_globals,
 
848
                                        attribute.func_name,
 
849
                                        attribute.func_defaults,
 
850
                                        attribute.func_closure)))
830
851
        return type.__new__(mcs, name, bases, attr)
831
852
 
832
853
class ClientDBus(Client, DBusObjectWithProperties):
839
860
    
840
861
    runtime_expansions = (Client.runtime_expansions
841
862
                          + ("dbus_object_path",))
842
 
 
843
 
    __metaclass__ = transitional_clientdbus
844
863
    
845
864
    # dbus.service.Object doesn't use super(), so we can't either.
846
865
    
861
880
    def notifychangeproperty(transform_func,
862
881
                             dbus_name, type_func=lambda x: x,
863
882
                             variant_level=1):
864
 
        """ Modify a variable so that its a property that announce its
865
 
        changes to DBus.
866
 
        transform_fun: Function that takes a value and transform it to
867
 
                       DBus type.
868
 
        dbus_name: DBus name of the variable
 
883
        """ Modify a variable so that it's a property which announces
 
884
        its changes to DBus.
 
885
 
 
886
        transform_fun: Function that takes a value and transforms it
 
887
                       to a D-Bus type.
 
888
        dbus_name: D-Bus name of the variable
869
889
        type_func: Function that transform the value before sending it
870
 
                   to DBus
871
 
        variant_level: DBus variant level. default: 1
 
890
                   to the D-Bus.  Default: no transform
 
891
        variant_level: D-Bus variant level.  Default: 1
872
892
        """
873
893
        real_value = [None,]
874
894
        def setter(self, value):
969
989
    
970
990
    
971
991
    ## D-Bus methods, signals & properties
972
 
    _interface = "se.bsnet.fukt.Mandos.Client"
973
 
 
 
992
    _interface = "se.recompile.Mandos.Client"
 
993
    
974
994
    ## Signals
975
995
    
976
996
    # CheckerCompleted - signal
1246
1266
            return super(ProxyClient, self).__setattr__(name, value)
1247
1267
        self._pipe.send(('setattr', name, value))
1248
1268
 
 
1269
class ClientDBusTransitional(ClientDBus):
 
1270
    __metaclass__ = AlternateDBusNamesMetaclass
1249
1271
 
1250
1272
class ClientHandler(socketserver.BaseRequestHandler, object):
1251
1273
    """A class to handle client connections.
1953
1975
    # End of Avahi example code
1954
1976
    if use_dbus:
1955
1977
        try:
1956
 
            bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1957
 
                                            bus, do_not_queue=True)
1958
 
            bus_name2 = dbus.service.BusName("se.recompile.Mandos",
1959
 
                                            bus, do_not_queue=True)
 
1978
            bus_name = dbus.service.BusName("se.recompile.Mandos",
 
1979
                                            bus, do_not_queue=True)
 
1980
            old_bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
 
1981
                                                bus, do_not_queue=True)
1960
1982
        except dbus.exceptions.NameExistsException as e:
1961
1983
            logger.error(unicode(e) + ", disabling D-Bus")
1962
1984
            use_dbus = False
1975
1997
    
1976
1998
    client_class = Client
1977
1999
    if use_dbus:
1978
 
        client_class = functools.partial(ClientDBus, bus = bus)
 
2000
        client_class = functools.partial(ClientDBusTransitional, bus = bus)        
1979
2001
    def client_config_items(config, section):
1980
2002
        special_settings = {
1981
2003
            "approved_by_default":
2020
2042
            """A D-Bus proxy object"""
2021
2043
            def __init__(self):
2022
2044
                dbus.service.Object.__init__(self, bus, "/")
2023
 
            _interface = "se.bsnet.fukt.Mandos"
 
2045
            _interface = "se.recompile.Mandos"
2024
2046
            
2025
2047
            @dbus.service.signal(_interface, signature="o")
2026
2048
            def ClientAdded(self, objpath):
2068
2090
            
2069
2091
            del _interface
2070
2092
        
2071
 
        mandos_dbus_service = MandosDBusService()
 
2093
        class MandosDBusServiceTransitional(MandosDBusService):
 
2094
            __metaclass__ = AlternateDBusNamesMetaclass
 
2095
        mandos_dbus_service = MandosDBusServiceTransitional()
2072
2096
    
2073
2097
    def cleanup():
2074
2098
        "Cleanup function; run on exit"