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
- browse files at revision 24.1.186
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.186
- Committer: Björn Påhlsson
- Date: 2011-10-02 19:18:24 UTC
- mto: This revision was merged to the branch mainline in revision 505.
- Revision ID: belorn@fukt.bsnet.se-20111002191824-eweh4pvneeg3qzia
transitional stuff actually working
documented change to D-Bus API
documented change to D-Bus API
added
removed
mandos
62
62
import functools
63
63
import cPickle as pickle
64
64
import multiprocessing
65
import types
65
66
66
67
import dbus
67
68
import dbus.service
264
265
self.server_state_changed(self.server.GetState())
265
266
266
267
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
267
274
class Client(object):
268
275
"""A representation of a client host served by this server.
269
276
297
304
secret: bytestring; sent verbatim (over TLS) to client
298
305
timeout: datetime.timedelta(); How long from last_checked_ok
299
306
until this client is disabled
307
extended_timeout: extra long timeout when password has been sent
300
308
runtime_expansions: Allowed attributes for runtime expansion.
309
expires: datetime.datetime(); time (UTC) when a client will be
310
disabled, or None
301
311
"""
302
312
303
313
runtime_expansions = ("approval_delay", "approval_duration",
305
315
"host", "interval", "last_checked_ok",
306
316
"last_enabled", "name", "timeout")
307
317
308
@staticmethod
309
def _timedelta_to_milliseconds(td):
310
"Convert a datetime.timedelta() to milliseconds"
311
return ((td.days * 24 * 60 * 60 * 1000)
312
+ (td.seconds * 1000)
313
+ (td.microseconds // 1000))
314
315
318
def timeout_milliseconds(self):
316
319
"Return the 'timeout' attribute in milliseconds"
317
return self._timedelta_to_milliseconds(self.timeout)
320
return _timedelta_to_milliseconds(self.timeout)
321
322
def extended_timeout_milliseconds(self):
323
"Return the 'extended_timeout' attribute in milliseconds"
324
return _timedelta_to_milliseconds(self.extended_timeout)
318
325
319
326
def interval_milliseconds(self):
320
327
"Return the 'interval' attribute in milliseconds"
321
return self._timedelta_to_milliseconds(self.interval)
322
328
return _timedelta_to_milliseconds(self.interval)
329
323
330
def approval_delay_milliseconds(self):
324
return self._timedelta_to_milliseconds(self.approval_delay)
331
return _timedelta_to_milliseconds(self.approval_delay)
325
332
326
333
def __init__(self, name = None, disable_hook=None, config=None):
327
334
"""Note: the 'checker' key in 'config' sets the
354
361
self.last_enabled = None
355
362
self.last_checked_ok = None
356
363
self.timeout = string_to_delta(config["timeout"])
364
self.extended_timeout = string_to_delta(config["extended_timeout"])
357
365
self.interval = string_to_delta(config["interval"])
358
366
self.disable_hook = disable_hook
359
367
self.checker = None
360
368
self.checker_initiator_tag = None
361
369
self.disable_initiator_tag = None
370
self.expires = None
362
371
self.checker_callback_tag = None
363
372
self.checker_command = config["checker"]
364
373
self.current_checker_command = None
384
393
# Already enabled
385
394
return
386
395
self.send_changedstate()
387
self.last_enabled = datetime.datetime.utcnow()
388
396
# Schedule a new checker to be started an 'interval' from now,
389
397
# and every interval from then on.
390
398
self.checker_initiator_tag = (gobject.timeout_add
391
399
(self.interval_milliseconds(),
392
400
self.start_checker))
393
401
# Schedule a disable() when 'timeout' has passed
402
self.expires = datetime.datetime.utcnow() + self.timeout
394
403
self.disable_initiator_tag = (gobject.timeout_add
395
404
(self.timeout_milliseconds(),
396
405
self.disable))
397
406
self.enabled = True
407
self.last_enabled = datetime.datetime.utcnow()
398
408
# Also start a new checker *right now*.
399
409
self.start_checker()
400
410
409
419
if getattr(self, "disable_initiator_tag", False):
410
420
gobject.source_remove(self.disable_initiator_tag)
411
421
self.disable_initiator_tag = None
422
self.expires = None
412
423
if getattr(self, "checker_initiator_tag", False):
413
424
gobject.source_remove(self.checker_initiator_tag)
414
425
self.checker_initiator_tag = None
440
451
logger.warning("Checker for %(name)s crashed?",
441
452
vars(self))
442
453
443
def checked_ok(self):
454
def checked_ok(self, timeout=None):
444
455
"""Bump up the timeout for this client.
445
456
446
457
This should only be called when the client has been seen,
447
458
alive and well.
448
459
"""
460
if timeout is None:
461
timeout = self.timeout
449
462
self.last_checked_ok = datetime.datetime.utcnow()
450
463
gobject.source_remove(self.disable_initiator_tag)
464
self.expires = datetime.datetime.utcnow() + timeout
451
465
self.disable_initiator_tag = (gobject.timeout_add
452
(self.timeout_milliseconds(),
466
(_timedelta_to_milliseconds(timeout),
453
467
self.disable))
454
468
455
469
def need_approval(self):
496
510
'replace')))
497
511
for attr in
498
512
self.runtime_expansions)
499
513
500
514
try:
501
515
command = self.checker_command % escaped_attrs
502
516
except TypeError as error:
548
562
raise
549
563
self.checker = None
550
564
565
551
566
def dbus_service_property(dbus_interface, signature="v",
552
567
access="readwrite", byte_arrays=False):
553
568
"""Decorators for marking methods of a DBusObjectWithProperties to
599
614
600
615
class DBusObjectWithProperties(dbus.service.Object):
601
616
"""A D-Bus object with properties.
602
617
603
618
Classes inheriting from this can use the dbus_service_property
604
619
decorator to expose methods as D-Bus properties. It exposes the
605
620
standard Get(), Set(), and GetAll() methods on the D-Bus.
612
627
def _get_all_dbus_properties(self):
613
628
"""Returns a generator of (name, attribute) pairs
614
629
"""
615
return ((prop._dbus_name, prop)
616
for name, prop in
617
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))
618
633
619
634
def _get_dbus_property(self, interface_name, property_name):
620
635
"""Returns a bound method if one exists which is a D-Bus
621
636
property with the specified name and interface.
622
637
"""
623
for name in (property_name,
624
property_name + "_dbus_property"):
625
prop = getattr(self, name, None)
626
if (prop is None
627
or not self._is_dbus_property(prop)
628
or prop._dbus_name != property_name
629
or (interface_name and prop._dbus_interface
630
and interface_name != prop._dbus_interface)):
631
continue
632
return prop
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
633
643
# No such property
634
644
raise DBusPropertyNotFound(self.dbus_object_path + ":"
635
645
+ interface_name + "."
636
646
+ property_name)
647
637
648
638
649
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
639
650
out_signature="v")
669
680
def GetAll(self, interface_name):
670
681
"""Standard D-Bus property GetAll() method, see D-Bus
671
682
standard.
672
683
673
684
Note: Will not include properties with access="write".
674
685
"""
675
686
all = {}
737
748
return xmlstring
738
749
739
750
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
740
814
class ClientDBus(Client, DBusObjectWithProperties):
741
815
"""A Client class using D-Bus
742
816
764
838
DBusObjectWithProperties.__init__(self, self.bus,
765
839
self.dbus_object_path)
766
840
767
def _get_approvals_pending(self):
768
return self._approvals_pending
769
def _set_approvals_pending(self, value):
770
old_value = self._approvals_pending
771
self._approvals_pending = value
772
bval = bool(value)
773
if (hasattr(self, "dbus_object_path")
774
and bval is not bool(old_value)):
775
dbus_bool = dbus.Boolean(bval, variant_level=1)
776
self.PropertyChanged(dbus.String("ApprovalPending"),
777
dbus_bool)
778
779
approvals_pending = property(_get_approvals_pending,
780
_set_approvals_pending)
781
del _get_approvals_pending, _set_approvals_pending
782
783
@staticmethod
784
def _datetime_to_dbus(dt, variant_level=0):
785
"""Convert a UTC datetime.datetime() to a D-Bus type."""
786
return dbus.String(dt.isoformat(),
787
variant_level=variant_level)
788
789
def enable(self):
790
oldstate = getattr(self, "enabled", False)
791
r = Client.enable(self)
792
if oldstate != self.enabled:
793
# Emit D-Bus signals
794
self.PropertyChanged(dbus.String("Enabled"),
795
dbus.Boolean(True, variant_level=1))
796
self.PropertyChanged(
797
dbus.String("LastEnabled"),
798
self._datetime_to_dbus(self.last_enabled,
799
variant_level=1))
800
return r
801
802
def disable(self, quiet = False):
803
oldstate = getattr(self, "enabled", False)
804
r = Client.disable(self, quiet=quiet)
805
if not quiet and oldstate != self.enabled:
806
# Emit D-Bus signal
807
self.PropertyChanged(dbus.String("Enabled"),
808
dbus.Boolean(False, variant_level=1))
809
return r
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
810
896
811
897
def __del__(self, *args, **kwargs):
812
898
try:
821
907
*args, **kwargs):
822
908
self.checker_callback_tag = None
823
909
self.checker = None
824
# Emit D-Bus signal
825
self.PropertyChanged(dbus.String("CheckerRunning"),
826
dbus.Boolean(False, variant_level=1))
827
910
if os.WIFEXITED(condition):
828
911
exitstatus = os.WEXITSTATUS(condition)
829
912
# Emit D-Bus signal
839
922
return Client.checker_callback(self, pid, condition, command,
840
923
*args, **kwargs)
841
924
842
def checked_ok(self, *args, **kwargs):
843
Client.checked_ok(self, *args, **kwargs)
844
# Emit D-Bus signal
845
self.PropertyChanged(
846
dbus.String("LastCheckedOK"),
847
(self._datetime_to_dbus(self.last_checked_ok,
848
variant_level=1)))
849
850
def need_approval(self, *args, **kwargs):
851
r = Client.need_approval(self, *args, **kwargs)
852
# Emit D-Bus signal
853
self.PropertyChanged(
854
dbus.String("LastApprovalRequest"),
855
(self._datetime_to_dbus(self.last_approval_request,
856
variant_level=1)))
857
return r
858
859
925
def start_checker(self, *args, **kwargs):
860
926
old_checker = self.checker
861
927
if self.checker is not None:
868
934
and old_checker_pid != self.checker.pid):
869
935
# Emit D-Bus signal
870
936
self.CheckerStarted(self.current_checker_command)
871
self.PropertyChanged(
872
dbus.String("CheckerRunning"),
873
dbus.Boolean(True, variant_level=1))
874
937
return r
875
938
876
def stop_checker(self, *args, **kwargs):
877
old_checker = getattr(self, "checker", None)
878
r = Client.stop_checker(self, *args, **kwargs)
879
if (old_checker is not None
880
and getattr(self, "checker", None) is None):
881
self.PropertyChanged(dbus.String("CheckerRunning"),
882
dbus.Boolean(False, variant_level=1))
883
return r
884
885
939
def _reset_approved(self):
886
940
self._approved = None
887
941
return False
889
943
def approve(self, value=True):
890
944
self.send_changedstate()
891
945
self._approved = value
892
gobject.timeout_add(self._timedelta_to_milliseconds
946
gobject.timeout_add(_timedelta_to_milliseconds
893
947
(self.approval_duration),
894
948
self._reset_approved)
895
949
896
950
897
951
## D-Bus methods, signals & properties
898
952
_interface = "se.bsnet.fukt.Mandos.Client"
899
953
900
954
## Signals
901
955
902
956
# CheckerCompleted - signal
987
1041
if value is None: # get
988
1042
return dbus.Boolean(self.approved_by_default)
989
1043
self.approved_by_default = bool(value)
990
# Emit D-Bus signal
991
self.PropertyChanged(dbus.String("ApprovedByDefault"),
992
dbus.Boolean(value, variant_level=1))
993
1044
994
1045
# ApprovalDelay - property
995
1046
@dbus_service_property(_interface, signature="t",
998
1049
if value is None: # get
999
1050
return dbus.UInt64(self.approval_delay_milliseconds())
1000
1051
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1001
# Emit D-Bus signal
1002
self.PropertyChanged(dbus.String("ApprovalDelay"),
1003
dbus.UInt64(value, variant_level=1))
1004
1052
1005
1053
# ApprovalDuration - property
1006
1054
@dbus_service_property(_interface, signature="t",
1007
1055
access="readwrite")
1008
1056
def ApprovalDuration_dbus_property(self, value=None):
1009
1057
if value is None: # get
1010
return dbus.UInt64(self._timedelta_to_milliseconds(
1058
return dbus.UInt64(_timedelta_to_milliseconds(
1011
1059
self.approval_duration))
1012
1060
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1013
# Emit D-Bus signal
1014
self.PropertyChanged(dbus.String("ApprovalDuration"),
1015
dbus.UInt64(value, variant_level=1))
1016
1061
1017
1062
# Name - property
1018
1063
@dbus_service_property(_interface, signature="s", access="read")
1031
1076
if value is None: # get
1032
1077
return dbus.String(self.host)
1033
1078
self.host = value
1034
# Emit D-Bus signal
1035
self.PropertyChanged(dbus.String("Host"),
1036
dbus.String(value, variant_level=1))
1037
1079
1038
1080
# Created - property
1039
1081
@dbus_service_property(_interface, signature="s", access="read")
1040
1082
def Created_dbus_property(self):
1041
return dbus.String(self._datetime_to_dbus(self.created))
1083
return dbus.String(datetime_to_dbus(self.created))
1042
1084
1043
1085
# LastEnabled - property
1044
1086
@dbus_service_property(_interface, signature="s", access="read")
1045
1087
def LastEnabled_dbus_property(self):
1046
if self.last_enabled is None:
1047
return dbus.String("")
1048
return dbus.String(self._datetime_to_dbus(self.last_enabled))
1088
return datetime_to_dbus(self.last_enabled)
1049
1089
1050
1090
# Enabled - property
1051
1091
@dbus_service_property(_interface, signature="b",
1065
1105
if value is not None:
1066
1106
self.checked_ok()
1067
1107
return
1068
if self.last_checked_ok is None:
1069
return dbus.String("")
1070
return dbus.String(self._datetime_to_dbus(self
1071
.last_checked_ok))
1108
return datetime_to_dbus(self.last_checked_ok)
1109
1110
# Expires - property
1111
@dbus_service_property(_interface, signature="s", access="read")
1112
def Expires_dbus_property(self):
1113
return datetime_to_dbus(self.expires)
1072
1114
1073
1115
# LastApprovalRequest - property
1074
1116
@dbus_service_property(_interface, signature="s", access="read")
1075
1117
def LastApprovalRequest_dbus_property(self):
1076
if self.last_approval_request is None:
1077
return dbus.String("")
1078
return dbus.String(self.
1079
_datetime_to_dbus(self
1080
.last_approval_request))
1118
return datetime_to_dbus(self.last_approval_request)
1081
1119
1082
1120
# Timeout - property
1083
1121
@dbus_service_property(_interface, signature="t",
1086
1124
if value is None: # get
1087
1125
return dbus.UInt64(self.timeout_milliseconds())
1088
1126
self.timeout = datetime.timedelta(0, 0, 0, value)
1089
# Emit D-Bus signal
1090
self.PropertyChanged(dbus.String("Timeout"),
1091
dbus.UInt64(value, variant_level=1))
1092
1127
if getattr(self, "disable_initiator_tag", None) is None:
1093
1128
return
1094
1129
# Reschedule timeout
1095
1130
gobject.source_remove(self.disable_initiator_tag)
1096
1131
self.disable_initiator_tag = None
1132
self.expires = None
1097
1133
time_to_die = (self.
1098
1134
_timedelta_to_milliseconds((self
1099
1135
.last_checked_ok
1104
1140
# The timeout has passed
1105
1141
self.disable()
1106
1142
else:
1143
self.expires = (datetime.datetime.utcnow()
1144
+ datetime.timedelta(milliseconds = time_to_die))
1107
1145
self.disable_initiator_tag = (gobject.timeout_add
1108
1146
(time_to_die, self.disable))
1109
1147
1148
# ExtendedTimeout - property
1149
@dbus_service_property(_interface, signature="t",
1150
access="readwrite")
1151
def ExtendedTimeout_dbus_property(self, value=None):
1152
if value is None: # get
1153
return dbus.UInt64(self.extended_timeout_milliseconds())
1154
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1155
1110
1156
# Interval - property
1111
1157
@dbus_service_property(_interface, signature="t",
1112
1158
access="readwrite")
1114
1160
if value is None: # get
1115
1161
return dbus.UInt64(self.interval_milliseconds())
1116
1162
self.interval = datetime.timedelta(0, 0, 0, value)
1117
# Emit D-Bus signal
1118
self.PropertyChanged(dbus.String("Interval"),
1119
dbus.UInt64(value, variant_level=1))
1120
1163
if getattr(self, "checker_initiator_tag", None) is None:
1121
1164
return
1122
1165
# Reschedule checker run
1124
1167
self.checker_initiator_tag = (gobject.timeout_add
1125
1168
(value, self.start_checker))
1126
1169
self.start_checker() # Start one now, too
1127
1170
1128
1171
# Checker - property
1129
1172
@dbus_service_property(_interface, signature="s",
1130
1173
access="readwrite")
1132
1175
if value is None: # get
1133
1176
return dbus.String(self.checker_command)
1134
1177
self.checker_command = value
1135
# Emit D-Bus signal
1136
self.PropertyChanged(dbus.String("Checker"),
1137
dbus.String(self.checker_command,
1138
variant_level=1))
1139
1178
1140
1179
# CheckerRunning - property
1141
1180
@dbus_service_property(_interface, signature="b",
1168
1207
self._pipe.send(('init', fpr, address))
1169
1208
if not self._pipe.recv():
1170
1209
raise KeyError()
1171
1210
1172
1211
def __getattribute__(self, name):
1173
1212
if(name == '_pipe'):
1174
1213
return super(ProxyClient, self).__getattribute__(name)
1181
1220
self._pipe.send(('funcall', name, args, kwargs))
1182
1221
return self._pipe.recv()[1]
1183
1222
return func
1184
1223
1185
1224
def __setattr__(self, name, value):
1186
1225
if(name == '_pipe'):
1187
1226
return super(ProxyClient, self).__setattr__(name, value)
1188
1227
self._pipe.send(('setattr', name, value))
1189
1228
1229
class ClientDBusTransitional(ClientDBus):
1230
__metaclass__ = transitional_dbus_metaclass
1190
1231
1191
1232
class ClientHandler(socketserver.BaseRequestHandler, object):
1192
1233
"""A class to handle client connections.
1200
1241
unicode(self.client_address))
1201
1242
logger.debug("Pipe FD: %d",
1202
1243
self.server.child_pipe.fileno())
1203
1244
1204
1245
session = (gnutls.connection
1205
1246
.ClientSession(self.request,
1206
1247
gnutls.connection
1207
1248
.X509Credentials()))
1208
1249
1209
1250
# Note: gnutls.connection.X509Credentials is really a
1210
1251
# generic GnuTLS certificate credentials object so long as
1211
1252
# no X.509 keys are added to it. Therefore, we can use it
1212
1253
# here despite using OpenPGP certificates.
1213
1254
1214
1255
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1215
1256
# "+AES-256-CBC", "+SHA1",
1216
1257
# "+COMP-NULL", "+CTYPE-OPENPGP",
1222
1263
(gnutls.library.functions
1223
1264
.gnutls_priority_set_direct(session._c_object,
1224
1265
priority, None))
1225
1266
1226
1267
# Start communication using the Mandos protocol
1227
1268
# Get protocol number
1228
1269
line = self.request.makefile().readline()
1233
1274
except (ValueError, IndexError, RuntimeError) as error:
1234
1275
logger.error("Unknown protocol version: %s", error)
1235
1276
return
1236
1277
1237
1278
# Start GnuTLS connection
1238
1279
try:
1239
1280
session.handshake()
1243
1284
# established. Just abandon the request.
1244
1285
return
1245
1286
logger.debug("Handshake succeeded")
1246
1287
1247
1288
approval_required = False
1248
1289
try:
1249
1290
try:
1254
1295
logger.warning("Bad certificate: %s", error)
1255
1296
return
1256
1297
logger.debug("Fingerprint: %s", fpr)
1257
1298
1258
1299
try:
1259
1300
client = ProxyClient(child_pipe, fpr,
1260
1301
self.client_address)
1326
1367
sent, len(client.secret)
1327
1368
- (sent_size + sent))
1328
1369
sent_size += sent
1329
1370
1330
1371
logger.info("Sending secret to %s", client.name)
1331
1372
# bump the timeout as if seen
1332
client.checked_ok()
1373
client.checked_ok(client.extended_timeout)
1333
1374
if self.server.use_dbus:
1334
1375
# Emit D-Bus signal
1335
1376
client.GotSecret()
1420
1461
multiprocessing.Process(target = self.sub_process_main,
1421
1462
args = (request, address)).start()
1422
1463
1464
1423
1465
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1424
1466
""" adds a pipe to the MixIn """
1425
1467
def process_request(self, request, client_address):
1428
1470
This function creates a new pipe in self.pipe
1429
1471
"""
1430
1472
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1431
1473
1432
1474
super(MultiprocessingMixInWithPipe,
1433
1475
self).process_request(request, client_address)
1434
1476
self.child_pipe.close()
1435
1477
self.add_pipe(parent_pipe)
1436
1478
1437
1479
def add_pipe(self, parent_pipe):
1438
1480
"""Dummy function; override as necessary"""
1439
1481
raise NotImplementedError
1440
1482
1483
1441
1484
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1442
1485
socketserver.TCPServer, object):
1443
1486
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1591
1634
kwargs = request[3]
1592
1635
1593
1636
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1594
1637
1595
1638
if command == 'getattr':
1596
1639
attrname = request[1]
1597
1640
if callable(client_object.__getattribute__(attrname)):
1603
1646
attrname = request[1]
1604
1647
value = request[2]
1605
1648
setattr(client_object, attrname, value)
1606
1649
1607
1650
return True
1608
1651
1609
1652
1788
1831
debuglevel = server_settings["debuglevel"]
1789
1832
use_dbus = server_settings["use_dbus"]
1790
1833
use_ipv6 = server_settings["use_ipv6"]
1791
1834
1792
1835
if server_settings["servicename"] != "Mandos":
1793
1836
syslogger.setFormatter(logging.Formatter
1794
1837
('Mandos (%s) [%%(process)d]:'
1796
1839
% server_settings["servicename"]))
1797
1840
1798
1841
# Parse config file with clients
1799
client_defaults = { "timeout": "1h",
1800
"interval": "5m",
1842
client_defaults = { "timeout": "5m",
1843
"extended_timeout": "15m",
1844
"interval": "2m",
1801
1845
"checker": "fping -q -- %%(host)s",
1802
1846
"host": "",
1803
1847
"approval_delay": "0s",
1854
1898
level = getattr(logging, debuglevel.upper())
1855
1899
syslogger.setLevel(level)
1856
1900
console.setLevel(level)
1857
1901
1858
1902
if debug:
1859
1903
# Enable all possible GnuTLS debugging
1860
1904
1893
1937
try:
1894
1938
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1895
1939
bus, do_not_queue=True)
1940
bus_name2 = dbus.service.BusName("se.recompile.Mandos",
1941
bus, do_not_queue=True)
1896
1942
except dbus.exceptions.NameExistsException as e:
1897
1943
logger.error(unicode(e) + ", disabling D-Bus")
1898
1944
use_dbus = False
1911
1957
1912
1958
client_class = Client
1913
1959
if use_dbus:
1914
client_class = functools.partial(ClientDBus, bus = bus)
1960
client_class = functools.partial(ClientDBusTransitional, bus = bus)
1915
1961
def client_config_items(config, section):
1916
1962
special_settings = {
1917
1963
"approved_by_default":
1947
1993
del pidfilename
1948
1994
1949
1995
signal.signal(signal.SIGINT, signal.SIG_IGN)
1950
1996
1951
1997
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1952
1998
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1953
1999
2004
2050
2005
2051
del _interface
2006
2052
2007
mandos_dbus_service = MandosDBusService()
2053
class MandosDBusServiceTransitional(MandosDBusService):
2054
__metaclass__ = transitional_dbus_metaclass
2055
mandos_dbus_service = MandosDBusServiceTransitional()
2008
2056
2009
2057
def cleanup():
2010
2058
"Cleanup function; run on exit"
2074
2122
# Must run before the D-Bus bus name gets deregistered
2075
2123
cleanup()
2076
2124
2125
2077
2126
if __name__ == '__main__':
2078
2127
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0