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 463.1.2
- compare with another revision
- download diff
- download tarball
- view history from revision 463.1.2
- Committer: teddy at bsnet
- Date: 2011-02-11 19:02:24 UTC
- mto: This revision was merged to the branch mainline in revision 465.
- Revision ID: teddy@fukt.bsnet.se-20110211190224-62celso7mswtep65
* mandos-monitor: Use unicode string literals. Update __future__
import line to use all available and applicable
imports.
import line to use all available and applicable
imports.
- files added:
- DBUS-API
- debian/source
- files modified:
- .bzrignore
added
removed
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008,2009 Teddy Hogeborn
15
# Copyright © 2008,2009 Björn Påhlsson
14
# Copyright © 2008-2010 Teddy Hogeborn
15
# Copyright © 2008-2010 Björn Påhlsson
16
16
#
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
81
81
SO_BINDTODEVICE = None
82
82
83
83
84
version = "1.0.14"
84
version = "1.2.3"
85
85
86
logger = logging.getLogger(u'mandos')
86
#logger = logging.getLogger(u'mandos')
87
logger = logging.Logger(u'mandos')
87
88
syslogger = (logging.handlers.SysLogHandler
88
89
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
89
90
address = "/dev/log"))
98
99
u' %(message)s'))
99
100
logger.addHandler(console)
100
101
101
multiprocessing_manager = multiprocessing.Manager()
102
103
102
class AvahiError(Exception):
104
103
def __init__(self, value, *args, **kwargs):
105
104
self.value = value
158
157
u" after %i retries, exiting.",
159
158
self.rename_count)
160
159
raise AvahiServiceError(u"Too many renames")
161
self.name = self.server.GetAlternativeServiceName(self.name)
160
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
162
161
logger.info(u"Changing Zeroconf service name to %r ...",
163
unicode(self.name))
162
self.name)
164
163
syslogger.setFormatter(logging.Formatter
165
164
(u'Mandos (%s) [%%(process)d]:'
166
165
u' %%(levelname)s: %%(message)s'
167
166
% self.name))
168
167
self.remove()
169
self.add()
168
try:
169
self.add()
170
except dbus.exceptions.DBusException, error:
171
logger.critical(u"DBusException: %s", error)
172
self.cleanup()
173
os._exit(1)
170
174
self.rename_count += 1
171
175
def remove(self):
172
176
"""Derived from the Avahi example code"""
195
199
self.group.Commit()
196
200
def entry_group_state_changed(self, state, error):
197
201
"""Derived from the Avahi example code"""
198
logger.debug(u"Avahi state change: %i", state)
202
logger.debug(u"Avahi entry group state change: %i", state)
199
203
200
204
if state == avahi.ENTRY_GROUP_ESTABLISHED:
201
205
logger.debug(u"Zeroconf service established.")
202
206
elif state == avahi.ENTRY_GROUP_COLLISION:
203
logger.warning(u"Zeroconf service name collision.")
207
logger.info(u"Zeroconf service name collision.")
204
208
self.rename()
205
209
elif state == avahi.ENTRY_GROUP_FAILURE:
206
210
logger.critical(u"Avahi: Error in group state changed %s",
214
218
self.group = None
215
219
def server_state_changed(self, state):
216
220
"""Derived from the Avahi example code"""
221
logger.debug(u"Avahi server state change: %i", state)
217
222
if state == avahi.SERVER_COLLISION:
218
223
logger.error(u"Zeroconf server name collision")
219
224
self.remove()
235
240
"""A representation of a client host served by this server.
236
241
237
242
Attributes:
238
name: string; from the config file, used in log messages and
239
D-Bus identifiers
243
_approved: bool(); 'None' if not yet approved/disapproved
244
approval_delay: datetime.timedelta(); Time to wait for approval
245
approval_duration: datetime.timedelta(); Duration of one approval
246
checker: subprocess.Popen(); a running checker process used
247
to see if the client lives.
248
'None' if no process is running.
249
checker_callback_tag: a gobject event source tag, or None
250
checker_command: string; External command which is run to check
251
if client lives. %() expansions are done at
252
runtime with vars(self) as dict, so that for
253
instance %(name)s can be used in the command.
254
checker_initiator_tag: a gobject event source tag, or None
255
created: datetime.datetime(); (UTC) object creation
256
current_checker_command: string; current running checker_command
257
disable_hook: If set, called by disable() as disable_hook(self)
258
disable_initiator_tag: a gobject event source tag, or None
259
enabled: bool()
240
260
fingerprint: string (40 or 32 hexadecimal digits); used to
241
261
uniquely identify the client
242
secret: bytestring; sent verbatim (over TLS) to client
243
262
host: string; available for use by the checker command
244
created: datetime.datetime(); (UTC) object creation
263
interval: datetime.timedelta(); How often to start a new checker
264
last_approval_request: datetime.datetime(); (UTC) or None
265
last_checked_ok: datetime.datetime(); (UTC) or None
245
266
last_enabled: datetime.datetime(); (UTC)
246
enabled: bool()
247
last_checked_ok: datetime.datetime(); (UTC) or None
267
name: string; from the config file, used in log messages and
268
D-Bus identifiers
269
secret: bytestring; sent verbatim (over TLS) to client
248
270
timeout: datetime.timedelta(); How long from last_checked_ok
249
271
until this client is disabled
250
interval: datetime.timedelta(); How often to start a new checker
251
disable_hook: If set, called by disable() as disable_hook(self)
252
checker: subprocess.Popen(); a running checker process used
253
to see if the client lives.
254
'None' if no process is running.
255
checker_initiator_tag: a gobject event source tag, or None
256
disable_initiator_tag: - '' -
257
checker_callback_tag: - '' -
258
checker_command: string; External command which is run to check if
259
client lives. %() expansions are done at
260
runtime with vars(self) as dict, so that for
261
instance %(name)s can be used in the command.
262
current_checker_command: string; current running checker_command
263
approved_delay: datetime.timedelta(); Time to wait for approval
264
_approved: bool(); 'None' if not yet approved/disapproved
265
approved_duration: datetime.timedelta(); Duration of one approval
272
runtime_expansions: Allowed attributes for runtime expansion.
266
273
"""
267
274
275
runtime_expansions = (u"approval_delay", u"approval_duration",
276
u"created", u"enabled", u"fingerprint",
277
u"host", u"interval", u"last_checked_ok",
278
u"last_enabled", u"name", u"timeout")
279
268
280
@staticmethod
269
281
def _timedelta_to_milliseconds(td):
270
282
"Convert a datetime.timedelta() to milliseconds"
280
292
"Return the 'interval' attribute in milliseconds"
281
293
return self._timedelta_to_milliseconds(self.interval)
282
294
283
def approved_delay_milliseconds(self):
284
return self._timedelta_to_milliseconds(self.approved_delay)
295
def approval_delay_milliseconds(self):
296
return self._timedelta_to_milliseconds(self.approval_delay)
285
297
286
298
def __init__(self, name = None, disable_hook=None, config=None):
287
299
"""Note: the 'checker' key in 'config' sets the
305
317
"rb") as secfile:
306
318
self.secret = secfile.read()
307
319
else:
308
#XXX Need to allow secret on demand!
309
320
raise TypeError(u"No secret or secfile for client %s"
310
321
% self.name)
311
322
self.host = config.get(u"host", u"")
312
323
self.created = datetime.datetime.utcnow()
313
324
self.enabled = False
325
self.last_approval_request = None
314
326
self.last_enabled = None
315
327
self.last_checked_ok = None
316
328
self.timeout = string_to_delta(config[u"timeout"])
323
335
self.checker_command = config[u"checker"]
324
336
self.current_checker_command = None
325
337
self.last_connect = None
326
self.approvals_pending = 0
327
338
self._approved = None
328
339
self.approved_by_default = config.get(u"approved_by_default",
329
340
True)
330
self.approved_delay = string_to_delta(
331
config[u"approved_delay"])
332
self.approved_duration = string_to_delta(
333
config[u"approved_duration"])
341
self.approvals_pending = 0
342
self.approval_delay = string_to_delta(
343
config[u"approval_delay"])
344
self.approval_duration = string_to_delta(
345
config[u"approval_duration"])
334
346
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
335
347
336
348
def send_changedstate(self):
412
424
(self.timeout_milliseconds(),
413
425
self.disable))
414
426
427
def need_approval(self):
428
self.last_approval_request = datetime.datetime.utcnow()
429
415
430
def start_checker(self):
416
431
"""Start a new checker subprocess if one is not running.
417
432
446
461
command = self.checker_command % self.host
447
462
except TypeError:
448
463
# Escape attributes for the shell
449
escaped_attrs = dict((key,
450
re.escape(unicode(str(val),
451
errors=
452
u'replace')))
453
for key, val in
454
vars(self).iteritems())
464
escaped_attrs = dict(
465
(attr,
466
re.escape(unicode(str(getattr(self, attr, u"")),
467
errors=
468
u'replace')))
469
for attr in
470
self.runtime_expansions)
471
455
472
try:
456
473
command = self.checker_command % escaped_attrs
457
474
except TypeError, error:
699
716
dbus_object_path: dbus.ObjectPath
700
717
bus: dbus.SystemBus()
701
718
"""
719
720
runtime_expansions = (Client.runtime_expansions
721
+ (u"dbus_object_path",))
722
702
723
# dbus.service.Object doesn't use super(), so we can't either.
703
724
704
725
def __init__(self, bus = None, *args, **kwargs):
707
728
Client.__init__(self, *args, **kwargs)
708
729
# Only now, when this client is initialized, can it show up on
709
730
# the D-Bus
731
client_object_name = unicode(self.name).translate(
732
{ord(u"."): ord(u"_"),
733
ord(u"-"): ord(u"_")})
710
734
self.dbus_object_path = (dbus.ObjectPath
711
(u"/clients/"
712
+ self.name.replace(u".", u"_")))
735
(u"/clients/" + client_object_name))
713
736
DBusObjectWithProperties.__init__(self, self.bus,
714
737
self.dbus_object_path)
715
716
def _get_approvals_pending(value):
738
739
def _get_approvals_pending(self):
717
740
return self._approvals_pending
718
def _set_approvals_pending(value):
741
def _set_approvals_pending(self, value):
719
742
old_value = self._approvals_pending
720
743
self._approvals_pending = value
721
744
bval = bool(value)
722
if bval is bool(old_value):
745
if (hasattr(self, "dbus_object_path")
746
and bval is not bool(old_value)):
723
747
dbus_bool = dbus.Boolean(bval, variant_level=1)
724
self.PropertyChanged(dbus.String(u"approved_pending"),
748
self.PropertyChanged(dbus.String(u"ApprovalPending"),
725
749
dbus_bool)
726
return value
750
727
751
approvals_pending = property(_get_approvals_pending,
728
752
_set_approvals_pending)
729
753
del _get_approvals_pending, _set_approvals_pending
739
763
r = Client.enable(self)
740
764
if oldstate != self.enabled:
741
765
# Emit D-Bus signals
742
self.PropertyChanged(dbus.String(u"enabled"),
766
self.PropertyChanged(dbus.String(u"Enabled"),
743
767
dbus.Boolean(True, variant_level=1))
744
768
self.PropertyChanged(
745
dbus.String(u"last_enabled"),
769
dbus.String(u"LastEnabled"),
746
770
self._datetime_to_dbus(self.last_enabled,
747
771
variant_level=1))
748
772
return r
752
776
r = Client.disable(self, quiet=quiet)
753
777
if not quiet and oldstate != self.enabled:
754
778
# Emit D-Bus signal
755
self.PropertyChanged(dbus.String(u"enabled"),
779
self.PropertyChanged(dbus.String(u"Enabled"),
756
780
dbus.Boolean(False, variant_level=1))
757
781
return r
758
782
770
794
self.checker_callback_tag = None
771
795
self.checker = None
772
796
# Emit D-Bus signal
773
self.PropertyChanged(dbus.String(u"checker_running"),
797
self.PropertyChanged(dbus.String(u"CheckerRunning"),
774
798
dbus.Boolean(False, variant_level=1))
775
799
if os.WIFEXITED(condition):
776
800
exitstatus = os.WEXITSTATUS(condition)
791
815
r = Client.checked_ok(self, *args, **kwargs)
792
816
# Emit D-Bus signal
793
817
self.PropertyChanged(
794
dbus.String(u"last_checked_ok"),
818
dbus.String(u"LastCheckedOK"),
795
819
(self._datetime_to_dbus(self.last_checked_ok,
796
820
variant_level=1)))
797
821
return r
798
822
823
def need_approval(self, *args, **kwargs):
824
r = Client.need_approval(self, *args, **kwargs)
825
# Emit D-Bus signal
826
self.PropertyChanged(
827
dbus.String(u"LastApprovalRequest"),
828
(self._datetime_to_dbus(self.last_approval_request,
829
variant_level=1)))
830
return r
831
799
832
def start_checker(self, *args, **kwargs):
800
833
old_checker = self.checker
801
834
if self.checker is not None:
809
842
# Emit D-Bus signal
810
843
self.CheckerStarted(self.current_checker_command)
811
844
self.PropertyChanged(
812
dbus.String(u"checker_running"),
845
dbus.String(u"CheckerRunning"),
813
846
dbus.Boolean(True, variant_level=1))
814
847
return r
815
848
818
851
r = Client.stop_checker(self, *args, **kwargs)
819
852
if (old_checker is not None
820
853
and getattr(self, u"checker", None) is None):
821
self.PropertyChanged(dbus.String(u"checker_running"),
854
self.PropertyChanged(dbus.String(u"CheckerRunning"),
822
855
dbus.Boolean(False, variant_level=1))
823
856
return r
824
857
827
860
return False
828
861
829
862
def approve(self, value=True):
863
self.send_changedstate()
830
864
self._approved = value
831
gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration, self._reset_approved))
865
gobject.timeout_add(self._timedelta_to_milliseconds
866
(self.approval_duration),
867
self._reset_approved)
832
868
833
869
834
870
## D-Bus methods, signals & properties
857
893
# GotSecret - signal
858
894
@dbus.service.signal(_interface)
859
895
def GotSecret(self):
860
"D-Bus signal"
896
"""D-Bus signal
897
Is sent after a successful transfer of secret from the Mandos
898
server to mandos-client
899
"""
861
900
pass
862
901
863
902
# Rejected - signal
867
906
pass
868
907
869
908
# NeedApproval - signal
870
@dbus.service.signal(_interface, signature=u"db")
909
@dbus.service.signal(_interface, signature=u"tb")
871
910
def NeedApproval(self, timeout, default):
872
911
"D-Bus signal"
873
pass
912
return self.need_approval()
874
913
875
914
## Methods
876
915
877
916
# Approve - method
878
917
@dbus.service.method(_interface, in_signature=u"b")
879
918
def Approve(self, value):
880
919
self.approve(value)
881
920
882
921
# CheckedOK - method
883
922
@dbus.service.method(_interface)
884
923
def CheckedOK(self):
909
948
910
949
## Properties
911
950
912
# approved_pending - property
951
# ApprovalPending - property
913
952
@dbus_service_property(_interface, signature=u"b", access=u"read")
914
def approved_pending_dbus_property(self):
953
def ApprovalPending_dbus_property(self):
915
954
return dbus.Boolean(bool(self.approvals_pending))
916
955
917
# approved_by_default - property
956
# ApprovedByDefault - property
918
957
@dbus_service_property(_interface, signature=u"b",
919
958
access=u"readwrite")
920
def approved_by_default_dbus_property(self):
921
return dbus.Boolean(self.approved_by_default)
922
923
# approved_delay - property
924
@dbus_service_property(_interface, signature=u"t",
925
access=u"readwrite")
926
def approved_delay_dbus_property(self):
927
return dbus.UInt64(self.approved_delay_milliseconds())
928
929
# approved_duration - property
930
@dbus_service_property(_interface, signature=u"t",
931
access=u"readwrite")
932
def approved_duration_dbus_property(self):
933
return dbus.UInt64(self._timedelta_to_milliseconds(
934
self.approved_duration))
935
936
# name - property
959
def ApprovedByDefault_dbus_property(self, value=None):
960
if value is None: # get
961
return dbus.Boolean(self.approved_by_default)
962
self.approved_by_default = bool(value)
963
# Emit D-Bus signal
964
self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
965
dbus.Boolean(value, variant_level=1))
966
967
# ApprovalDelay - property
968
@dbus_service_property(_interface, signature=u"t",
969
access=u"readwrite")
970
def ApprovalDelay_dbus_property(self, value=None):
971
if value is None: # get
972
return dbus.UInt64(self.approval_delay_milliseconds())
973
self.approval_delay = datetime.timedelta(0, 0, 0, value)
974
# Emit D-Bus signal
975
self.PropertyChanged(dbus.String(u"ApprovalDelay"),
976
dbus.UInt64(value, variant_level=1))
977
978
# ApprovalDuration - property
979
@dbus_service_property(_interface, signature=u"t",
980
access=u"readwrite")
981
def ApprovalDuration_dbus_property(self, value=None):
982
if value is None: # get
983
return dbus.UInt64(self._timedelta_to_milliseconds(
984
self.approval_duration))
985
self.approval_duration = datetime.timedelta(0, 0, 0, value)
986
# Emit D-Bus signal
987
self.PropertyChanged(dbus.String(u"ApprovalDuration"),
988
dbus.UInt64(value, variant_level=1))
989
990
# Name - property
937
991
@dbus_service_property(_interface, signature=u"s", access=u"read")
938
def name_dbus_property(self):
992
def Name_dbus_property(self):
939
993
return dbus.String(self.name)
940
994
941
# fingerprint - property
995
# Fingerprint - property
942
996
@dbus_service_property(_interface, signature=u"s", access=u"read")
943
def fingerprint_dbus_property(self):
997
def Fingerprint_dbus_property(self):
944
998
return dbus.String(self.fingerprint)
945
999
946
# host - property
1000
# Host - property
947
1001
@dbus_service_property(_interface, signature=u"s",
948
1002
access=u"readwrite")
949
def host_dbus_property(self, value=None):
1003
def Host_dbus_property(self, value=None):
950
1004
if value is None: # get
951
1005
return dbus.String(self.host)
952
1006
self.host = value
953
1007
# Emit D-Bus signal
954
self.PropertyChanged(dbus.String(u"host"),
1008
self.PropertyChanged(dbus.String(u"Host"),
955
1009
dbus.String(value, variant_level=1))
956
1010
957
# created - property
1011
# Created - property
958
1012
@dbus_service_property(_interface, signature=u"s", access=u"read")
959
def created_dbus_property(self):
1013
def Created_dbus_property(self):
960
1014
return dbus.String(self._datetime_to_dbus(self.created))
961
1015
962
# last_enabled - property
1016
# LastEnabled - property
963
1017
@dbus_service_property(_interface, signature=u"s", access=u"read")
964
def last_enabled_dbus_property(self):
1018
def LastEnabled_dbus_property(self):
965
1019
if self.last_enabled is None:
966
1020
return dbus.String(u"")
967
1021
return dbus.String(self._datetime_to_dbus(self.last_enabled))
968
1022
969
# enabled - property
1023
# Enabled - property
970
1024
@dbus_service_property(_interface, signature=u"b",
971
1025
access=u"readwrite")
972
def enabled_dbus_property(self, value=None):
1026
def Enabled_dbus_property(self, value=None):
973
1027
if value is None: # get
974
1028
return dbus.Boolean(self.enabled)
975
1029
if value:
977
1031
else:
978
1032
self.disable()
979
1033
980
# last_checked_ok - property
1034
# LastCheckedOK - property
981
1035
@dbus_service_property(_interface, signature=u"s",
982
1036
access=u"readwrite")
983
def last_checked_ok_dbus_property(self, value=None):
1037
def LastCheckedOK_dbus_property(self, value=None):
984
1038
if value is not None:
985
1039
self.checked_ok()
986
1040
return
989
1043
return dbus.String(self._datetime_to_dbus(self
990
1044
.last_checked_ok))
991
1045
992
# timeout - property
1046
# LastApprovalRequest - property
1047
@dbus_service_property(_interface, signature=u"s", access=u"read")
1048
def LastApprovalRequest_dbus_property(self):
1049
if self.last_approval_request is None:
1050
return dbus.String(u"")
1051
return dbus.String(self.
1052
_datetime_to_dbus(self
1053
.last_approval_request))
1054
1055
# Timeout - property
993
1056
@dbus_service_property(_interface, signature=u"t",
994
1057
access=u"readwrite")
995
def timeout_dbus_property(self, value=None):
1058
def Timeout_dbus_property(self, value=None):
996
1059
if value is None: # get
997
1060
return dbus.UInt64(self.timeout_milliseconds())
998
1061
self.timeout = datetime.timedelta(0, 0, 0, value)
999
1062
# Emit D-Bus signal
1000
self.PropertyChanged(dbus.String(u"timeout"),
1063
self.PropertyChanged(dbus.String(u"Timeout"),
1001
1064
dbus.UInt64(value, variant_level=1))
1002
1065
if getattr(self, u"disable_initiator_tag", None) is None:
1003
1066
return
1017
1080
self.disable_initiator_tag = (gobject.timeout_add
1018
1081
(time_to_die, self.disable))
1019
1082
1020
# interval - property
1083
# Interval - property
1021
1084
@dbus_service_property(_interface, signature=u"t",
1022
1085
access=u"readwrite")
1023
def interval_dbus_property(self, value=None):
1086
def Interval_dbus_property(self, value=None):
1024
1087
if value is None: # get
1025
1088
return dbus.UInt64(self.interval_milliseconds())
1026
1089
self.interval = datetime.timedelta(0, 0, 0, value)
1027
1090
# Emit D-Bus signal
1028
self.PropertyChanged(dbus.String(u"interval"),
1091
self.PropertyChanged(dbus.String(u"Interval"),
1029
1092
dbus.UInt64(value, variant_level=1))
1030
1093
if getattr(self, u"checker_initiator_tag", None) is None:
1031
1094
return
1035
1098
(value, self.start_checker))
1036
1099
self.start_checker() # Start one now, too
1037
1100
1038
# checker - property
1101
# Checker - property
1039
1102
@dbus_service_property(_interface, signature=u"s",
1040
1103
access=u"readwrite")
1041
def checker_dbus_property(self, value=None):
1104
def Checker_dbus_property(self, value=None):
1042
1105
if value is None: # get
1043
1106
return dbus.String(self.checker_command)
1044
1107
self.checker_command = value
1045
1108
# Emit D-Bus signal
1046
self.PropertyChanged(dbus.String(u"checker"),
1109
self.PropertyChanged(dbus.String(u"Checker"),
1047
1110
dbus.String(self.checker_command,
1048
1111
variant_level=1))
1049
1112
1050
# checker_running - property
1113
# CheckerRunning - property
1051
1114
@dbus_service_property(_interface, signature=u"b",
1052
1115
access=u"readwrite")
1053
def checker_running_dbus_property(self, value=None):
1116
def CheckerRunning_dbus_property(self, value=None):
1054
1117
if value is None: # get
1055
1118
return dbus.Boolean(self.checker is not None)
1056
1119
if value:
1058
1121
else:
1059
1122
self.stop_checker()
1060
1123
1061
# object_path - property
1124
# ObjectPath - property
1062
1125
@dbus_service_property(_interface, signature=u"o", access=u"read")
1063
def object_path_dbus_property(self):
1126
def ObjectPath_dbus_property(self):
1064
1127
return self.dbus_object_path # is already a dbus.ObjectPath
1065
1128
1066
# secret = property
1129
# Secret = property
1067
1130
@dbus_service_property(_interface, signature=u"ay",
1068
1131
access=u"write", byte_arrays=True)
1069
def secret_dbus_property(self, value):
1132
def Secret_dbus_property(self, value):
1070
1133
self.secret = str(value)
1071
1134
1072
1135
del _interface
1170
1233
except KeyError:
1171
1234
return
1172
1235
1173
if client.approved_delay:
1174
delay = client.approved_delay
1236
if client.approval_delay:
1237
delay = client.approval_delay
1175
1238
client.approvals_pending += 1
1176
1239
approval_required = True
1177
1240
1184
1247
client.Rejected("Disabled")
1185
1248
return
1186
1249
1187
if client._approved or not client.approved_delay:
1250
if client._approved or not client.approval_delay:
1188
1251
#We are approved or approval is disabled
1189
1252
break
1190
1253
elif client._approved is None:
1191
logger.info(u"Client %s need approval",
1254
logger.info(u"Client %s needs approval",
1192
1255
client.name)
1193
1256
if self.server.use_dbus:
1194
1257
# Emit D-Bus signal
1195
1258
client.NeedApproval(
1196
client.approved_delay_milliseconds(),
1259
client.approval_delay_milliseconds(),
1197
1260
client.approved_by_default)
1198
1261
else:
1199
1262
logger.warning(u"Client %s was not approved",
1200
1263
client.name)
1201
1264
if self.server.use_dbus:
1202
1265
# Emit D-Bus signal
1203
client.Rejected("Disapproved")
1266
client.Rejected("Denied")
1204
1267
return
1205
1268
1206
1269
#wait until timeout or approved
1217
1280
client.name)
1218
1281
if self.server.use_dbus:
1219
1282
# Emit D-Bus signal
1220
client.Rejected("Time out")
1283
client.Rejected("Approval timed out")
1221
1284
return
1222
1285
else:
1223
1286
break
1226
1289
1227
1290
sent_size = 0
1228
1291
while sent_size < len(client.secret):
1229
# XXX handle session exception
1230
sent = session.send(client.secret[sent_size:])
1292
try:
1293
sent = session.send(client.secret[sent_size:])
1294
except (gnutls.errors.GNUTLSError), error:
1295
logger.warning("gnutls send failed")
1296
return
1231
1297
logger.debug(u"Sent: %d, remaining: %d",
1232
1298
sent, len(client.secret)
1233
1299
- (sent_size + sent))
1243
1309
finally:
1244
1310
if approval_required:
1245
1311
client.approvals_pending -= 1
1246
session.bye()
1312
try:
1313
session.bye()
1314
except (gnutls.errors.GNUTLSError), error:
1315
logger.warning("GnuTLS bye failed")
1247
1316
1248
1317
@staticmethod
1249
1318
def peer_certificate(session):
1334
1403
1335
1404
super(MultiprocessingMixInWithPipe,
1336
1405
self).process_request(request, client_address)
1406
self.child_pipe.close()
1337
1407
self.add_pipe(parent_pipe)
1408
1338
1409
def add_pipe(self, parent_pipe):
1339
1410
"""Dummy function; override as necessary"""
1340
1411
pass
1453
1524
for cond, name in
1454
1525
condition_names.iteritems()
1455
1526
if cond & condition)
1456
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1457
conditions_string)
1527
# error or the other end of multiprocessing.Pipe has closed
1528
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1529
return False
1458
1530
1459
1531
# Read a request from the child
1460
1532
request = parent_pipe.recv()
1473
1545
u"dress: %s", fpr, address)
1474
1546
if self.use_dbus:
1475
1547
# Emit D-Bus signal
1476
mandos_dbus_service.ClientNotFound(fpr, address)
1548
mandos_dbus_service.ClientNotFound(fpr, address[0])
1477
1549
parent_pipe.send(False)
1478
1550
return False
1479
1551
1503
1575
attrname = request[1]
1504
1576
value = request[2]
1505
1577
setattr(client_object, attrname, value)
1506
1578
1507
1579
return True
1508
1580
1509
1581
1612
1684
parser.add_option("--debug", action=u"store_true",
1613
1685
help=u"Debug mode; run in foreground and log to"
1614
1686
u" terminal")
1687
parser.add_option("--debuglevel", type=u"string", metavar="LEVEL",
1688
help=u"Debug level for stdout output")
1615
1689
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1616
1690
u" priority string (see GnuTLS documentation)")
1617
1691
parser.add_option("--servicename", type=u"string",
1642
1716
u"servicename": u"Mandos",
1643
1717
u"use_dbus": u"True",
1644
1718
u"use_ipv6": u"True",
1719
u"debuglevel": u"",
1645
1720
}
1646
1721
1647
1722
# Parse config file for server-global settings
1664
1739
# options, if set.
1665
1740
for option in (u"interface", u"address", u"port", u"debug",
1666
1741
u"priority", u"servicename", u"configdir",
1667
u"use_dbus", u"use_ipv6"):
1742
u"use_dbus", u"use_ipv6", u"debuglevel"):
1668
1743
value = getattr(options, option)
1669
1744
if value is not None:
1670
1745
server_settings[option] = value
1679
1754
1680
1755
# For convenience
1681
1756
debug = server_settings[u"debug"]
1757
debuglevel = server_settings[u"debuglevel"]
1682
1758
use_dbus = server_settings[u"use_dbus"]
1683
1759
use_ipv6 = server_settings[u"use_ipv6"]
1684
1685
if not debug:
1686
syslogger.setLevel(logging.WARNING)
1687
console.setLevel(logging.WARNING)
1688
1760
1689
1761
if server_settings[u"servicename"] != u"Mandos":
1690
1762
syslogger.setFormatter(logging.Formatter
1691
1763
(u'Mandos (%s) [%%(process)d]:'
1697
1769
u"interval": u"5m",
1698
1770
u"checker": u"fping -q -- %%(host)s",
1699
1771
u"host": u"",
1700
u"approved_delay": u"0s",
1701
u"approved_duration": u"1s",
1772
u"approval_delay": u"0s",
1773
u"approval_duration": u"1s",
1702
1774
}
1703
1775
client_config = configparser.SafeConfigParser(client_defaults)
1704
1776
client_config.read(os.path.join(server_settings[u"configdir"],
1710
1782
tcp_server = MandosServer((server_settings[u"address"],
1711
1783
server_settings[u"port"]),
1712
1784
ClientHandler,
1713
interface=server_settings[u"interface"],
1785
interface=(server_settings[u"interface"]
1786
or None),
1714
1787
use_ipv6=use_ipv6,
1715
1788
gnutls_priority=
1716
1789
server_settings[u"priority"],
1717
1790
use_dbus=use_dbus)
1718
pidfilename = u"/var/run/mandos.pid"
1719
try:
1720
pidfile = open(pidfilename, u"w")
1721
except IOError:
1722
logger.error(u"Could not open file %r", pidfilename)
1791
if not debug:
1792
pidfilename = u"/var/run/mandos.pid"
1793
try:
1794
pidfile = open(pidfilename, u"w")
1795
except IOError:
1796
logger.error(u"Could not open file %r", pidfilename)
1723
1797
1724
1798
try:
1725
1799
uid = pwd.getpwnam(u"_mandos").pw_uid
1742
1816
if error[0] != errno.EPERM:
1743
1817
raise error
1744
1818
1745
# Enable all possible GnuTLS debugging
1819
if not debug and not debuglevel:
1820
syslogger.setLevel(logging.WARNING)
1821
console.setLevel(logging.WARNING)
1822
if debuglevel:
1823
level = getattr(logging, debuglevel.upper())
1824
syslogger.setLevel(level)
1825
console.setLevel(level)
1826
1746
1827
if debug:
1828
# Enable all possible GnuTLS debugging
1829
1747
1830
# "Use a log level over 10 to enable all debugging options."
1748
1831
# - GnuTLS manual
1749
1832
gnutls.library.functions.gnutls_global_set_log_level(11)
1754
1837
1755
1838
(gnutls.library.functions
1756
1839
.gnutls_global_set_log_function(debug_gnutls))
1840
1841
# Redirect stdin so all checkers get /dev/null
1842
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1843
os.dup2(null, sys.stdin.fileno())
1844
if null > 2:
1845
os.close(null)
1846
else:
1847
# No console logging
1848
logger.removeHandler(console)
1849
1850
# Need to fork before connecting to D-Bus
1851
if not debug:
1852
# Close all input and output, do double fork, etc.
1853
daemon()
1757
1854
1758
1855
global main_loop
1759
1856
# From the Avahi example code
1778
1875
service.interface = (if_nametoindex
1779
1876
(str(server_settings[u"interface"])))
1780
1877
1878
global multiprocessing_manager
1879
multiprocessing_manager = multiprocessing.Manager()
1880
1781
1881
client_class = Client
1782
1882
if use_dbus:
1783
1883
client_class = functools.partial(ClientDBus, bus = bus)
1800
1900
for section in client_config.sections()))
1801
1901
if not tcp_server.clients:
1802
1902
logger.warning(u"No clients defined")
1803
1804
if debug:
1805
# Redirect stdin so all checkers get /dev/null
1806
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1807
os.dup2(null, sys.stdin.fileno())
1808
if null > 2:
1809
os.close(null)
1810
else:
1811
# No console logging
1812
logger.removeHandler(console)
1813
# Close all input and output, do double fork, etc.
1814
daemon()
1815
1816
try:
1817
with pidfile:
1818
pid = os.getpid()
1819
pidfile.write(str(pid) + "\n")
1820
del pidfile
1821
except IOError:
1822
logger.error(u"Could not write to file %r with PID %d",
1823
pidfilename, pid)
1824
except NameError:
1825
# "pidfile" was never created
1826
pass
1827
del pidfilename
1828
1903
1829
1904
if not debug:
1905
try:
1906
with pidfile:
1907
pid = os.getpid()
1908
pidfile.write(str(pid) + "\n")
1909
del pidfile
1910
except IOError:
1911
logger.error(u"Could not write to file %r with PID %d",
1912
pidfilename, pid)
1913
except NameError:
1914
# "pidfile" was never created
1915
pass
1916
del pidfilename
1917
1830
1918
signal.signal(signal.SIGINT, signal.SIG_IGN)
1919
1831
1920
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1832
1921
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1833
1922
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0