/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: 2011-09-19 09:42:55 UTC
  • Revision ID: teddy@fukt.bsnet.se-20110919094255-3lji3igz75uog8lh
* mandos-clients.conf.xml (OPTIONS): Moved up "extended_timeout" to
                                     order options alphabetically.
* clients.conf: Language change in comment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
62
62
import functools
63
63
import cPickle as pickle
64
64
import multiprocessing
65
 
import types
66
65
 
67
66
import dbus
68
67
import dbus.service
265
264
        self.server_state_changed(self.server.GetState())
266
265
 
267
266
 
268
 
def _timedelta_to_milliseconds(td):
269
 
    "Convert a datetime.timedelta() to milliseconds"
270
 
    return ((td.days * 24 * 60 * 60 * 1000)
271
 
            + (td.seconds * 1000)
272
 
            + (td.microseconds // 1000))
273
 
        
274
267
class Client(object):
275
268
    """A representation of a client host served by this server.
276
269
    
315
308
                          "host", "interval", "last_checked_ok",
316
309
                          "last_enabled", "name", "timeout")
317
310
    
 
311
    @staticmethod
 
312
    def _timedelta_to_milliseconds(td):
 
313
        "Convert a datetime.timedelta() to milliseconds"
 
314
        return ((td.days * 24 * 60 * 60 * 1000)
 
315
                + (td.seconds * 1000)
 
316
                + (td.microseconds // 1000))
 
317
    
318
318
    def timeout_milliseconds(self):
319
319
        "Return the 'timeout' attribute in milliseconds"
320
 
        return _timedelta_to_milliseconds(self.timeout)
321
 
    
 
320
        return self._timedelta_to_milliseconds(self.timeout)
 
321
 
322
322
    def extended_timeout_milliseconds(self):
323
323
        "Return the 'extended_timeout' attribute in milliseconds"
324
 
        return _timedelta_to_milliseconds(self.extended_timeout)    
 
324
        return self._timedelta_to_milliseconds(self.extended_timeout)    
325
325
    
326
326
    def interval_milliseconds(self):
327
327
        "Return the 'interval' attribute in milliseconds"
328
 
        return _timedelta_to_milliseconds(self.interval)
329
 
    
 
328
        return self._timedelta_to_milliseconds(self.interval)
 
329
 
330
330
    def approval_delay_milliseconds(self):
331
 
        return _timedelta_to_milliseconds(self.approval_delay)
 
331
        return self._timedelta_to_milliseconds(self.approval_delay)
332
332
    
333
333
    def __init__(self, name = None, disable_hook=None, config=None):
334
334
        """Note: the 'checker' key in 'config' sets the
393
393
            # Already enabled
394
394
            return
395
395
        self.send_changedstate()
 
396
        self.last_enabled = datetime.datetime.utcnow()
396
397
        # Schedule a new checker to be started an 'interval' from now,
397
398
        # and every interval from then on.
398
399
        self.checker_initiator_tag = (gobject.timeout_add
404
405
                                   (self.timeout_milliseconds(),
405
406
                                    self.disable))
406
407
        self.enabled = True
407
 
        self.last_enabled = datetime.datetime.utcnow()
408
408
        # Also start a new checker *right now*.
409
409
        self.start_checker()
410
410
    
463
463
        gobject.source_remove(self.disable_initiator_tag)
464
464
        self.expires = datetime.datetime.utcnow() + timeout
465
465
        self.disable_initiator_tag = (gobject.timeout_add
466
 
                                      (_timedelta_to_milliseconds(timeout),
 
466
                                      (self._timedelta_to_milliseconds(timeout),
467
467
                                       self.disable))
468
468
    
469
469
    def need_approval(self):
510
510
                                       'replace')))
511
511
                    for attr in
512
512
                    self.runtime_expansions)
513
 
                
 
513
 
514
514
                try:
515
515
                    command = self.checker_command % escaped_attrs
516
516
                except TypeError as error:
562
562
                raise
563
563
        self.checker = None
564
564
 
565
 
 
566
565
def dbus_service_property(dbus_interface, signature="v",
567
566
                          access="readwrite", byte_arrays=False):
568
567
    """Decorators for marking methods of a DBusObjectWithProperties to
614
613
 
615
614
class DBusObjectWithProperties(dbus.service.Object):
616
615
    """A D-Bus object with properties.
617
 
    
 
616
 
618
617
    Classes inheriting from this can use the dbus_service_property
619
618
    decorator to expose methods as D-Bus properties.  It exposes the
620
619
    standard Get(), Set(), and GetAll() methods on the D-Bus.
627
626
    def _get_all_dbus_properties(self):
628
627
        """Returns a generator of (name, attribute) pairs
629
628
        """
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))
 
629
        return ((prop._dbus_name, prop)
 
630
                for name, prop in
 
631
                inspect.getmembers(self, self._is_dbus_property))
633
632
    
634
633
    def _get_dbus_property(self, interface_name, property_name):
635
634
        """Returns a bound method if one exists which is a D-Bus
636
635
        property with the specified name and interface.
637
636
        """
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)
642
 
        
 
637
        for name in (property_name,
 
638
                     property_name + "_dbus_property"):
 
639
            prop = getattr(self, name, None)
 
640
            if (prop is None
 
641
                or not self._is_dbus_property(prop)
 
642
                or prop._dbus_name != property_name
 
643
                or (interface_name and prop._dbus_interface
 
644
                    and interface_name != prop._dbus_interface)):
 
645
                continue
 
646
            return prop
643
647
        # No such property
644
648
        raise DBusPropertyNotFound(self.dbus_object_path + ":"
645
649
                                   + interface_name + "."
646
650
                                   + property_name)
647
 
 
648
651
    
649
652
    @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
650
653
                         out_signature="v")
680
683
    def GetAll(self, interface_name):
681
684
        """Standard D-Bus property GetAll() method, see D-Bus
682
685
        standard.
683
 
        
 
686
 
684
687
        Note: Will not include properties with access="write".
685
688
        """
686
689
        all = {}
748
751
        return xmlstring
749
752
 
750
753
 
751
 
def datetime_to_dbus (dt, variant_level=0):
752
 
    """Convert a UTC datetime.datetime() to a D-Bus type."""
753
 
    if dt is None:
754
 
        return dbus.String("", variant_level = variant_level)
755
 
    return dbus.String(dt.isoformat(),
756
 
                       variant_level=variant_level)
757
 
 
758
 
class transitional_dbus_metaclass(DBusObjectWithProperties.__metaclass__):
759
 
    def __new__(mcs, name, bases, attr):
760
 
        for attrname, old_dbusobj in inspect.getmembers(bases[0]):
761
 
            new_interface = getattr(old_dbusobj, "_dbus_interface", "").replace("se.bsnet.fukt.", "se.recompile.")
762
 
            if (getattr(old_dbusobj, "_dbus_is_signal", False)
763
 
                and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):
764
 
                unwrappedfunc = dict(zip(old_dbusobj.func_code.co_freevars,
765
 
                                    old_dbusobj.__closure__))["func"].cell_contents
766
 
                newfunc = types.FunctionType(unwrappedfunc.func_code,
767
 
                                             unwrappedfunc.func_globals,
768
 
                                             unwrappedfunc.func_name,
769
 
                                             unwrappedfunc.func_defaults,
770
 
                                             unwrappedfunc.func_closure)
771
 
                new_dbusfunc = dbus.service.signal(
772
 
                    new_interface, old_dbusobj._dbus_signature)(newfunc)            
773
 
                attr["_transitional_" + attrname] = new_dbusfunc
774
 
 
775
 
                def fixscope(func1, func2):
776
 
                    def newcall(*args, **kwargs):
777
 
                        func1(*args, **kwargs)
778
 
                        func2(*args, **kwargs)
779
 
                    return newcall
780
 
 
781
 
                attr[attrname] = fixscope(old_dbusobj, new_dbusfunc)
782
 
            
783
 
            elif (getattr(old_dbusobj, "_dbus_is_method", False)
784
 
                and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):
785
 
                new_dbusfunc = (dbus.service.method
786
 
                                (new_interface,
787
 
                                 old_dbusobj._dbus_in_signature,
788
 
                                 old_dbusobj._dbus_out_signature)
789
 
                                (types.FunctionType
790
 
                                 (old_dbusobj.func_code,
791
 
                                  old_dbusobj.func_globals,
792
 
                                  old_dbusobj.func_name,
793
 
                                  old_dbusobj.func_defaults,
794
 
                                  old_dbusobj.func_closure)))
795
 
 
796
 
                attr[attrname] = new_dbusfunc
797
 
            elif (getattr(old_dbusobj, "_dbus_is_property", False)
798
 
                  and old_dbusobj._dbus_interface.startswith("se.bsnet.fukt.Mandos")):
799
 
                new_dbusfunc = (dbus_service_property
800
 
                                (new_interface,
801
 
                                 old_dbusobj._dbus_signature,
802
 
                                 old_dbusobj._dbus_access,
803
 
                                 old_dbusobj._dbus_get_args_options["byte_arrays"])
804
 
                                (types.FunctionType
805
 
                                 (old_dbusobj.func_code,
806
 
                                  old_dbusobj.func_globals,
807
 
                                  old_dbusobj.func_name,
808
 
                                  old_dbusobj.func_defaults,
809
 
                                  old_dbusobj.func_closure)))
810
 
 
811
 
                attr[attrname] = new_dbusfunc
812
 
        return type.__new__(mcs, name, bases, attr)
813
 
 
814
754
class ClientDBus(Client, DBusObjectWithProperties):
815
755
    """A Client class using D-Bus
816
756
    
837
777
                                 ("/clients/" + client_object_name))
838
778
        DBusObjectWithProperties.__init__(self, self.bus,
839
779
                                          self.dbus_object_path)
840
 
        
841
 
    def notifychangeproperty(transform_func,
842
 
                             dbus_name, type_func=lambda x: x,
843
 
                             variant_level=1):
844
 
        """ Modify a variable so that its a property that announce its
845
 
        changes to DBus.
846
 
        transform_fun: Function that takes a value and transform it to
847
 
                       DBus type.
848
 
        dbus_name: DBus name of the variable
849
 
        type_func: Function that transform the value before sending it
850
 
                   to DBus
851
 
        variant_level: DBus variant level. default: 1
852
 
        """
853
 
        real_value = [None,]
854
 
        def setter(self, value):
855
 
            old_value = real_value[0]
856
 
            real_value[0] = value
857
 
            if hasattr(self, "dbus_object_path"):
858
 
                if type_func(old_value) != type_func(real_value[0]):
859
 
                    dbus_value = transform_func(type_func(real_value[0]),
860
 
                                                variant_level)
861
 
                    self.PropertyChanged(dbus.String(dbus_name),
862
 
                                         dbus_value)
863
 
        
864
 
        return property(lambda self: real_value[0], setter)
865
 
    
866
 
    
867
 
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
868
 
    approvals_pending = notifychangeproperty(dbus.Boolean,
869
 
                                             "ApprovalPending",
870
 
                                             type_func = bool)
871
 
    enabled = notifychangeproperty(dbus.Boolean, "Enabled")
872
 
    last_enabled = notifychangeproperty(datetime_to_dbus,
873
 
                                        "LastEnabled")
874
 
    checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
875
 
                                   type_func = lambda checker: checker is not None)
876
 
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
877
 
                                           "LastCheckedOK")
878
 
    last_approval_request = notifychangeproperty(datetime_to_dbus,
879
 
                                                 "LastApprovalRequest")
880
 
    approved_by_default = notifychangeproperty(dbus.Boolean,
881
 
                                               "ApprovedByDefault")
882
 
    approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",
883
 
                                          type_func = _timedelta_to_milliseconds)
884
 
    approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",
885
 
                                             type_func = _timedelta_to_milliseconds)
886
 
    host = notifychangeproperty(dbus.String, "Host")
887
 
    timeout = notifychangeproperty(dbus.UInt16, "Timeout",
888
 
                                   type_func = _timedelta_to_milliseconds)
889
 
    extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",
890
 
                                            type_func = _timedelta_to_milliseconds)
891
 
    interval = notifychangeproperty(dbus.UInt16, "Interval",
892
 
                                    type_func = _timedelta_to_milliseconds)
893
 
    checker_command = notifychangeproperty(dbus.String, "Checker")
894
 
    
895
 
    del notifychangeproperty
 
780
    def _set_expires(self, value):
 
781
        old_value = getattr(self, "_expires", None)
 
782
        self._expires = value
 
783
        if hasattr(self, "dbus_object_path") and old_value != value:
 
784
            dbus_time = (self._datetime_to_dbus(self._expires,
 
785
                                                variant_level=1))
 
786
            self.PropertyChanged(dbus.String("Expires"),
 
787
                                 dbus_time)
 
788
    expires = property(lambda self: self._expires, _set_expires)
 
789
    del _set_expires
 
790
        
 
791
    def _get_approvals_pending(self):
 
792
        return self._approvals_pending
 
793
    def _set_approvals_pending(self, value):
 
794
        old_value = self._approvals_pending
 
795
        self._approvals_pending = value
 
796
        bval = bool(value)
 
797
        if (hasattr(self, "dbus_object_path")
 
798
            and bval is not bool(old_value)):
 
799
            dbus_bool = dbus.Boolean(bval, variant_level=1)
 
800
            self.PropertyChanged(dbus.String("ApprovalPending"),
 
801
                                 dbus_bool)
 
802
 
 
803
    approvals_pending = property(_get_approvals_pending,
 
804
                                 _set_approvals_pending)
 
805
    del _get_approvals_pending, _set_approvals_pending
 
806
    
 
807
    @staticmethod
 
808
    def _datetime_to_dbus(dt, variant_level=0):
 
809
        """Convert a UTC datetime.datetime() to a D-Bus type."""
 
810
        if dt is None:
 
811
            return dbus.String("", variant_level = variant_level)
 
812
        return dbus.String(dt.isoformat(),
 
813
                           variant_level=variant_level)
 
814
    
 
815
    def enable(self):
 
816
        oldstate = getattr(self, "enabled", False)
 
817
        r = Client.enable(self)
 
818
        if oldstate != self.enabled:
 
819
            # Emit D-Bus signals
 
820
            self.PropertyChanged(dbus.String("Enabled"),
 
821
                                 dbus.Boolean(True, variant_level=1))
 
822
            self.PropertyChanged(
 
823
                dbus.String("LastEnabled"),
 
824
                self._datetime_to_dbus(self.last_enabled,
 
825
                                       variant_level=1))
 
826
        return r
 
827
    
 
828
    def disable(self, quiet = False):
 
829
        oldstate = getattr(self, "enabled", False)
 
830
        r = Client.disable(self, quiet=quiet)
 
831
        if not quiet and oldstate != self.enabled:
 
832
            # Emit D-Bus signal
 
833
            self.PropertyChanged(dbus.String("Enabled"),
 
834
                                 dbus.Boolean(False, variant_level=1))
 
835
        return r
896
836
    
897
837
    def __del__(self, *args, **kwargs):
898
838
        try:
907
847
                         *args, **kwargs):
908
848
        self.checker_callback_tag = None
909
849
        self.checker = None
 
850
        # Emit D-Bus signal
 
851
        self.PropertyChanged(dbus.String("CheckerRunning"),
 
852
                             dbus.Boolean(False, variant_level=1))
910
853
        if os.WIFEXITED(condition):
911
854
            exitstatus = os.WEXITSTATUS(condition)
912
855
            # Emit D-Bus signal
922
865
        return Client.checker_callback(self, pid, condition, command,
923
866
                                       *args, **kwargs)
924
867
    
 
868
    def checked_ok(self, *args, **kwargs):
 
869
        Client.checked_ok(self, *args, **kwargs)
 
870
        # Emit D-Bus signal
 
871
        self.PropertyChanged(
 
872
            dbus.String("LastCheckedOK"),
 
873
            (self._datetime_to_dbus(self.last_checked_ok,
 
874
                                    variant_level=1)))
 
875
    
 
876
    def need_approval(self, *args, **kwargs):
 
877
        r = Client.need_approval(self, *args, **kwargs)
 
878
        # Emit D-Bus signal
 
879
        self.PropertyChanged(
 
880
            dbus.String("LastApprovalRequest"),
 
881
            (self._datetime_to_dbus(self.last_approval_request,
 
882
                                    variant_level=1)))
 
883
        return r
 
884
    
925
885
    def start_checker(self, *args, **kwargs):
926
886
        old_checker = self.checker
927
887
        if self.checker is not None:
934
894
            and old_checker_pid != self.checker.pid):
935
895
            # Emit D-Bus signal
936
896
            self.CheckerStarted(self.current_checker_command)
 
897
            self.PropertyChanged(
 
898
                dbus.String("CheckerRunning"),
 
899
                dbus.Boolean(True, variant_level=1))
937
900
        return r
938
901
    
 
902
    def stop_checker(self, *args, **kwargs):
 
903
        old_checker = getattr(self, "checker", None)
 
904
        r = Client.stop_checker(self, *args, **kwargs)
 
905
        if (old_checker is not None
 
906
            and getattr(self, "checker", None) is None):
 
907
            self.PropertyChanged(dbus.String("CheckerRunning"),
 
908
                                 dbus.Boolean(False, variant_level=1))
 
909
        return r
 
910
 
939
911
    def _reset_approved(self):
940
912
        self._approved = None
941
913
        return False
943
915
    def approve(self, value=True):
944
916
        self.send_changedstate()
945
917
        self._approved = value
946
 
        gobject.timeout_add(_timedelta_to_milliseconds
 
918
        gobject.timeout_add(self._timedelta_to_milliseconds
947
919
                            (self.approval_duration),
948
920
                            self._reset_approved)
949
921
    
950
922
    
951
923
    ## D-Bus methods, signals & properties
952
924
    _interface = "se.bsnet.fukt.Mandos.Client"
953
 
 
 
925
    
954
926
    ## Signals
955
927
    
956
928
    # CheckerCompleted - signal
1040
1012
    def ApprovedByDefault_dbus_property(self, value=None):
1041
1013
        if value is None:       # get
1042
1014
            return dbus.Boolean(self.approved_by_default)
 
1015
        old_value = self.approved_by_default
1043
1016
        self.approved_by_default = bool(value)
 
1017
        # Emit D-Bus signal
 
1018
        if old_value != self.approved_by_default:
 
1019
            self.PropertyChanged(dbus.String("ApprovedByDefault"),
 
1020
                                 dbus.Boolean(value, variant_level=1))
1044
1021
    
1045
1022
    # ApprovalDelay - property
1046
1023
    @dbus_service_property(_interface, signature="t",
1048
1025
    def ApprovalDelay_dbus_property(self, value=None):
1049
1026
        if value is None:       # get
1050
1027
            return dbus.UInt64(self.approval_delay_milliseconds())
 
1028
        old_value = self.approval_delay
1051
1029
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
 
1030
        # Emit D-Bus signal
 
1031
        if old_value != self.approval_delay:
 
1032
            self.PropertyChanged(dbus.String("ApprovalDelay"),
 
1033
                                 dbus.UInt64(value, variant_level=1))
1052
1034
    
1053
1035
    # ApprovalDuration - property
1054
1036
    @dbus_service_property(_interface, signature="t",
1055
1037
                           access="readwrite")
1056
1038
    def ApprovalDuration_dbus_property(self, value=None):
1057
1039
        if value is None:       # get
1058
 
            return dbus.UInt64(_timedelta_to_milliseconds(
 
1040
            return dbus.UInt64(self._timedelta_to_milliseconds(
1059
1041
                    self.approval_duration))
 
1042
        old_value = self.approval_duration
1060
1043
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
 
1044
        # Emit D-Bus signal
 
1045
        if old_value != self.approval_duration:
 
1046
            self.PropertyChanged(dbus.String("ApprovalDuration"),
 
1047
                                 dbus.UInt64(value, variant_level=1))
1061
1048
    
1062
1049
    # Name - property
1063
1050
    @dbus_service_property(_interface, signature="s", access="read")
1075
1062
    def Host_dbus_property(self, value=None):
1076
1063
        if value is None:       # get
1077
1064
            return dbus.String(self.host)
 
1065
        old_value = self.host
1078
1066
        self.host = value
 
1067
        # Emit D-Bus signal
 
1068
        if old_value != self.host:
 
1069
            self.PropertyChanged(dbus.String("Host"),
 
1070
                                 dbus.String(value, variant_level=1))
1079
1071
    
1080
1072
    # Created - property
1081
1073
    @dbus_service_property(_interface, signature="s", access="read")
1082
1074
    def Created_dbus_property(self):
1083
 
        return dbus.String(datetime_to_dbus(self.created))
 
1075
        return dbus.String(self._datetime_to_dbus(self.created))
1084
1076
    
1085
1077
    # LastEnabled - property
1086
1078
    @dbus_service_property(_interface, signature="s", access="read")
1087
1079
    def LastEnabled_dbus_property(self):
1088
 
        return datetime_to_dbus(self.last_enabled)
 
1080
        return self._datetime_to_dbus(self.last_enabled)
1089
1081
    
1090
1082
    # Enabled - property
1091
1083
    @dbus_service_property(_interface, signature="b",
1105
1097
        if value is not None:
1106
1098
            self.checked_ok()
1107
1099
            return
1108
 
        return datetime_to_dbus(self.last_checked_ok)
 
1100
        return self._datetime_to_dbus(self.last_checked_ok)
1109
1101
    
1110
1102
    # Expires - property
1111
1103
    @dbus_service_property(_interface, signature="s", access="read")
1112
1104
    def Expires_dbus_property(self):
1113
 
        return datetime_to_dbus(self.expires)
 
1105
        return self._datetime_to_dbus(self.expires)
1114
1106
    
1115
1107
    # LastApprovalRequest - property
1116
1108
    @dbus_service_property(_interface, signature="s", access="read")
1117
1109
    def LastApprovalRequest_dbus_property(self):
1118
 
        return datetime_to_dbus(self.last_approval_request)
 
1110
        return self._datetime_to_dbus(self.last_approval_request)
1119
1111
    
1120
1112
    # Timeout - property
1121
1113
    @dbus_service_property(_interface, signature="t",
1123
1115
    def Timeout_dbus_property(self, value=None):
1124
1116
        if value is None:       # get
1125
1117
            return dbus.UInt64(self.timeout_milliseconds())
 
1118
        old_value = self.timeout
1126
1119
        self.timeout = datetime.timedelta(0, 0, 0, value)
 
1120
        # Emit D-Bus signal
 
1121
        if old_value != self.timeout:
 
1122
            self.PropertyChanged(dbus.String("Timeout"),
 
1123
                                 dbus.UInt64(value, variant_level=1))
1127
1124
        if getattr(self, "disable_initiator_tag", None) is None:
1128
1125
            return
1129
1126
        # Reschedule timeout
1144
1141
                            + datetime.timedelta(milliseconds = time_to_die))
1145
1142
            self.disable_initiator_tag = (gobject.timeout_add
1146
1143
                                          (time_to_die, self.disable))
1147
 
    
 
1144
 
1148
1145
    # ExtendedTimeout - property
1149
1146
    @dbus_service_property(_interface, signature="t",
1150
1147
                           access="readwrite")
1151
1148
    def ExtendedTimeout_dbus_property(self, value=None):
1152
1149
        if value is None:       # get
1153
1150
            return dbus.UInt64(self.extended_timeout_milliseconds())
 
1151
        old_value = self.extended_timeout
1154
1152
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1155
 
    
 
1153
        # Emit D-Bus signal
 
1154
        if old_value != self.extended_timeout:
 
1155
            self.PropertyChanged(dbus.String("ExtendedTimeout"),
 
1156
                                 dbus.UInt64(value, variant_level=1))
 
1157
 
1156
1158
    # Interval - property
1157
1159
    @dbus_service_property(_interface, signature="t",
1158
1160
                           access="readwrite")
1159
1161
    def Interval_dbus_property(self, value=None):
1160
1162
        if value is None:       # get
1161
1163
            return dbus.UInt64(self.interval_milliseconds())
 
1164
        old_value = self.interval
1162
1165
        self.interval = datetime.timedelta(0, 0, 0, value)
 
1166
        # Emit D-Bus signal
 
1167
        if old_value != self.interval:
 
1168
            self.PropertyChanged(dbus.String("Interval"),
 
1169
                                 dbus.UInt64(value, variant_level=1))
1163
1170
        if getattr(self, "checker_initiator_tag", None) is None:
1164
1171
            return
1165
1172
        # Reschedule checker run
1167
1174
        self.checker_initiator_tag = (gobject.timeout_add
1168
1175
                                      (value, self.start_checker))
1169
1176
        self.start_checker()    # Start one now, too
1170
 
    
 
1177
 
1171
1178
    # Checker - property
1172
1179
    @dbus_service_property(_interface, signature="s",
1173
1180
                           access="readwrite")
1174
1181
    def Checker_dbus_property(self, value=None):
1175
1182
        if value is None:       # get
1176
1183
            return dbus.String(self.checker_command)
 
1184
        old_value = self.checker_command
1177
1185
        self.checker_command = value
 
1186
        # Emit D-Bus signal
 
1187
        if old_value != self.checker_command:
 
1188
            self.PropertyChanged(dbus.String("Checker"),
 
1189
                                 dbus.String(self.checker_command,
 
1190
                                             variant_level=1))
1178
1191
    
1179
1192
    # CheckerRunning - property
1180
1193
    @dbus_service_property(_interface, signature="b",
1207
1220
        self._pipe.send(('init', fpr, address))
1208
1221
        if not self._pipe.recv():
1209
1222
            raise KeyError()
1210
 
    
 
1223
 
1211
1224
    def __getattribute__(self, name):
1212
1225
        if(name == '_pipe'):
1213
1226
            return super(ProxyClient, self).__getattribute__(name)
1220
1233
                self._pipe.send(('funcall', name, args, kwargs))
1221
1234
                return self._pipe.recv()[1]
1222
1235
            return func
1223
 
    
 
1236
 
1224
1237
    def __setattr__(self, name, value):
1225
1238
        if(name == '_pipe'):
1226
1239
            return super(ProxyClient, self).__setattr__(name, value)
1227
1240
        self._pipe.send(('setattr', name, value))
1228
1241
 
1229
 
class ClientDBusTransitional(ClientDBus):
1230
 
    __metaclass__ = transitional_dbus_metaclass
1231
1242
 
1232
1243
class ClientHandler(socketserver.BaseRequestHandler, object):
1233
1244
    """A class to handle client connections.
1241
1252
                        unicode(self.client_address))
1242
1253
            logger.debug("Pipe FD: %d",
1243
1254
                         self.server.child_pipe.fileno())
1244
 
            
 
1255
 
1245
1256
            session = (gnutls.connection
1246
1257
                       .ClientSession(self.request,
1247
1258
                                      gnutls.connection
1248
1259
                                      .X509Credentials()))
1249
 
            
 
1260
 
1250
1261
            # Note: gnutls.connection.X509Credentials is really a
1251
1262
            # generic GnuTLS certificate credentials object so long as
1252
1263
            # no X.509 keys are added to it.  Therefore, we can use it
1253
1264
            # here despite using OpenPGP certificates.
1254
 
            
 
1265
 
1255
1266
            #priority = ':'.join(("NONE", "+VERS-TLS1.1",
1256
1267
            #                      "+AES-256-CBC", "+SHA1",
1257
1268
            #                      "+COMP-NULL", "+CTYPE-OPENPGP",
1263
1274
            (gnutls.library.functions
1264
1275
             .gnutls_priority_set_direct(session._c_object,
1265
1276
                                         priority, None))
1266
 
            
 
1277
 
1267
1278
            # Start communication using the Mandos protocol
1268
1279
            # Get protocol number
1269
1280
            line = self.request.makefile().readline()
1274
1285
            except (ValueError, IndexError, RuntimeError) as error:
1275
1286
                logger.error("Unknown protocol version: %s", error)
1276
1287
                return
1277
 
            
 
1288
 
1278
1289
            # Start GnuTLS connection
1279
1290
            try:
1280
1291
                session.handshake()
1284
1295
                # established.  Just abandon the request.
1285
1296
                return
1286
1297
            logger.debug("Handshake succeeded")
1287
 
            
 
1298
 
1288
1299
            approval_required = False
1289
1300
            try:
1290
1301
                try:
1295
1306
                    logger.warning("Bad certificate: %s", error)
1296
1307
                    return
1297
1308
                logger.debug("Fingerprint: %s", fpr)
1298
 
                
 
1309
 
1299
1310
                try:
1300
1311
                    client = ProxyClient(child_pipe, fpr,
1301
1312
                                         self.client_address)
1367
1378
                                 sent, len(client.secret)
1368
1379
                                 - (sent_size + sent))
1369
1380
                    sent_size += sent
1370
 
                
 
1381
 
1371
1382
                logger.info("Sending secret to %s", client.name)
1372
1383
                # bump the timeout as if seen
1373
1384
                client.checked_ok(client.extended_timeout)
1461
1472
        multiprocessing.Process(target = self.sub_process_main,
1462
1473
                                args = (request, address)).start()
1463
1474
 
1464
 
 
1465
1475
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1466
1476
    """ adds a pipe to the MixIn """
1467
1477
    def process_request(self, request, client_address):
1470
1480
        This function creates a new pipe in self.pipe
1471
1481
        """
1472
1482
        parent_pipe, self.child_pipe = multiprocessing.Pipe()
1473
 
        
 
1483
 
1474
1484
        super(MultiprocessingMixInWithPipe,
1475
1485
              self).process_request(request, client_address)
1476
1486
        self.child_pipe.close()
1477
1487
        self.add_pipe(parent_pipe)
1478
 
    
 
1488
 
1479
1489
    def add_pipe(self, parent_pipe):
1480
1490
        """Dummy function; override as necessary"""
1481
1491
        raise NotImplementedError
1482
1492
 
1483
 
 
1484
1493
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1485
1494
                     socketserver.TCPServer, object):
1486
1495
    """IPv6-capable TCP server.  Accepts 'None' as address and/or port
1634
1643
            kwargs = request[3]
1635
1644
            
1636
1645
            parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1637
 
        
 
1646
 
1638
1647
        if command == 'getattr':
1639
1648
            attrname = request[1]
1640
1649
            if callable(client_object.__getattribute__(attrname)):
1646
1655
            attrname = request[1]
1647
1656
            value = request[2]
1648
1657
            setattr(client_object, attrname, value)
1649
 
        
 
1658
 
1650
1659
        return True
1651
1660
 
1652
1661
 
1831
1840
    debuglevel = server_settings["debuglevel"]
1832
1841
    use_dbus = server_settings["use_dbus"]
1833
1842
    use_ipv6 = server_settings["use_ipv6"]
1834
 
    
 
1843
 
1835
1844
    if server_settings["servicename"] != "Mandos":
1836
1845
        syslogger.setFormatter(logging.Formatter
1837
1846
                               ('Mandos (%s) [%%(process)d]:'
1898
1907
        level = getattr(logging, debuglevel.upper())
1899
1908
        syslogger.setLevel(level)
1900
1909
        console.setLevel(level)
1901
 
    
 
1910
 
1902
1911
    if debug:
1903
1912
        # Enable all possible GnuTLS debugging
1904
1913
        
1937
1946
        try:
1938
1947
            bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1939
1948
                                            bus, do_not_queue=True)
1940
 
            bus_name2 = dbus.service.BusName("se.recompile.Mandos",
1941
 
                                            bus, do_not_queue=True)
1942
1949
        except dbus.exceptions.NameExistsException as e:
1943
1950
            logger.error(unicode(e) + ", disabling D-Bus")
1944
1951
            use_dbus = False
1957
1964
    
1958
1965
    client_class = Client
1959
1966
    if use_dbus:
1960
 
        client_class = functools.partial(ClientDBusTransitional, bus = bus)        
 
1967
        client_class = functools.partial(ClientDBus, bus = bus)
1961
1968
    def client_config_items(config, section):
1962
1969
        special_settings = {
1963
1970
            "approved_by_default":
1993
2000
        del pidfilename
1994
2001
        
1995
2002
        signal.signal(signal.SIGINT, signal.SIG_IGN)
1996
 
    
 
2003
 
1997
2004
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1998
2005
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1999
2006
    
2050
2057
            
2051
2058
            del _interface
2052
2059
        
2053
 
        class MandosDBusServiceTransitional(MandosDBusService):
2054
 
            __metaclass__ = transitional_dbus_metaclass
2055
 
        mandos_dbus_service = MandosDBusServiceTransitional()
 
2060
        mandos_dbus_service = MandosDBusService()
2056
2061
    
2057
2062
    def cleanup():
2058
2063
        "Cleanup function; run on exit"
2122
2127
    # Must run before the D-Bus bus name gets deregistered
2123
2128
    cleanup()
2124
2129
 
2125
 
 
2126
2130
if __name__ == '__main__':
2127
2131
    main()