419
193
dbus.UInt16(self.port),
420
194
avahi.string_array_to_txt_array(self.TXT))
421
195
self.group.Commit()
423
196
def entry_group_state_changed(self, state, error):
424
197
"""Derived from the Avahi example code"""
425
logger.debug("Avahi entry group state change: %i", state)
198
logger.debug(u"Avahi state change: %i", state)
427
200
if state == avahi.ENTRY_GROUP_ESTABLISHED:
428
logger.debug("Zeroconf service established.")
201
logger.debug(u"Zeroconf service established.")
429
202
elif state == avahi.ENTRY_GROUP_COLLISION:
430
logger.info("Zeroconf service name collision.")
203
logger.warning(u"Zeroconf service name collision.")
432
205
elif state == avahi.ENTRY_GROUP_FAILURE:
433
logger.critical("Avahi: Error in group state changed %s",
435
raise AvahiGroupError("State changed: {!s}".format(error))
206
logger.critical(u"Avahi: Error in group state changed %s",
208
raise AvahiGroupError(u"State changed: %s"
437
210
def cleanup(self):
438
211
"""Derived from the Avahi example code"""
439
212
if self.group is not None:
442
except (dbus.exceptions.UnknownMethodException,
443
dbus.exceptions.DBusException):
445
214
self.group = None
448
def server_state_changed(self, state, error=None):
215
def server_state_changed(self, state):
449
216
"""Derived from the Avahi example code"""
450
logger.debug("Avahi server state change: %i", state)
452
avahi.SERVER_INVALID: "Zeroconf server invalid",
453
avahi.SERVER_REGISTERING: None,
454
avahi.SERVER_COLLISION: "Zeroconf server name collision",
455
avahi.SERVER_FAILURE: "Zeroconf server failure",
457
if state in bad_states:
458
if bad_states[state] is not None:
460
logger.error(bad_states[state])
462
logger.error(bad_states[state] + ": %r", error)
217
if state == avahi.SERVER_COLLISION:
218
logger.error(u"Zeroconf server name collision")
464
220
elif state == avahi.SERVER_RUNNING:
467
except dbus.exceptions.DBusException as error:
468
if (error.get_dbus_name()
469
== "org.freedesktop.Avahi.CollisionError"):
470
logger.info("Local Zeroconf service name"
472
return self.rename(remove=False)
474
logger.critical("D-Bus Exception", exc_info=error)
479
logger.debug("Unknown state: %r", state)
481
logger.debug("Unknown state: %r: %r", state, error)
483
222
def activate(self):
484
223
"""Derived from the Avahi example code"""
485
224
if self.server is None:
486
225
self.server = dbus.Interface(
487
226
self.bus.get_object(avahi.DBUS_NAME,
488
avahi.DBUS_PATH_SERVER,
489
follow_name_owner_changes=True),
227
avahi.DBUS_PATH_SERVER),
490
228
avahi.DBUS_INTERFACE_SERVER)
491
self.server.connect_to_signal("StateChanged",
492
self.server_state_changed)
229
self.server.connect_to_signal(u"StateChanged",
230
self.server_state_changed)
493
231
self.server_state_changed(self.server.GetState())
496
class AvahiServiceToSyslog(AvahiService):
497
def rename(self, *args, **kwargs):
498
"""Add the new name to the syslog messages"""
499
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
500
syslogger.setFormatter(logging.Formatter(
501
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
506
# Pretend that we have a GnuTLS module
507
class GnuTLS(object):
508
"""This isn't so much a class as it is a module-like namespace.
509
It is instantiated once, and simulates having a GnuTLS module."""
511
library = ctypes.util.find_library("gnutls")
513
library = ctypes.util.find_library("gnutls-deb0")
514
_library = ctypes.cdll.LoadLibrary(library)
516
_need_version = b"3.3.0"
517
_tls_rawpk_version = b"3.6.6"
520
# Need to use "self" here, since this method is called before
521
# the assignment to the "gnutls" global variable happens.
522
if self.check_version(self._need_version) is None:
523
raise self.Error("Needs GnuTLS {} or later"
524
.format(self._need_version))
526
# Unless otherwise indicated, the constants and types below are
527
# all from the gnutls/gnutls.h C header file.
538
E_NO_CERTIFICATE_FOUND = -49
543
KEYID_USE_SHA256 = 1 # gnutls/x509.h
544
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
547
class session_int(ctypes.Structure):
549
session_t = ctypes.POINTER(session_int)
551
class certificate_credentials_st(ctypes.Structure):
553
certificate_credentials_t = ctypes.POINTER(
554
certificate_credentials_st)
555
certificate_type_t = ctypes.c_int
557
class datum_t(ctypes.Structure):
558
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
559
('size', ctypes.c_uint)]
561
class openpgp_crt_int(ctypes.Structure):
563
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
564
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
565
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
566
credentials_type_t = ctypes.c_int
567
transport_ptr_t = ctypes.c_void_p
568
close_request_t = ctypes.c_int
571
class Error(Exception):
572
# We need to use the class name "GnuTLS" here, since this
573
# exception might be raised from within GnuTLS.__init__,
574
# which is called before the assignment to the "gnutls"
575
# global variable has happened.
576
def __init__(self, message=None, code=None, args=()):
577
# Default usage is by a message string, but if a return
578
# code is passed, convert it to a string with
581
if message is None and code is not None:
582
message = GnuTLS.strerror(code)
583
return super(GnuTLS.Error, self).__init__(
586
class CertificateSecurityError(Error):
590
class Credentials(object):
592
self._c_object = gnutls.certificate_credentials_t()
593
gnutls.certificate_allocate_credentials(
594
ctypes.byref(self._c_object))
595
self.type = gnutls.CRD_CERTIFICATE
598
gnutls.certificate_free_credentials(self._c_object)
600
class ClientSession(object):
601
def __init__(self, socket, credentials=None):
602
self._c_object = gnutls.session_t()
603
gnutls_flags = gnutls.CLIENT
604
if gnutls.check_version("3.5.6"):
605
gnutls_flags |= gnutls.NO_TICKETS
607
gnutls_flags |= gnutls.ENABLE_RAWPK
608
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
610
gnutls.set_default_priority(self._c_object)
611
gnutls.transport_set_ptr(self._c_object, socket.fileno())
612
gnutls.handshake_set_private_extensions(self._c_object,
615
if credentials is None:
616
credentials = gnutls.Credentials()
617
gnutls.credentials_set(self._c_object, credentials.type,
618
ctypes.cast(credentials._c_object,
620
self.credentials = credentials
623
gnutls.deinit(self._c_object)
626
return gnutls.handshake(self._c_object)
628
def send(self, data):
632
data_len -= gnutls.record_send(self._c_object,
637
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
639
# Error handling functions
640
def _error_code(result):
641
"""A function to raise exceptions on errors, suitable
642
for the 'restype' attribute on ctypes functions"""
645
if result == gnutls.E_NO_CERTIFICATE_FOUND:
646
raise gnutls.CertificateSecurityError(code=result)
647
raise gnutls.Error(code=result)
649
def _retry_on_error(result, func, arguments):
650
"""A function to retry on some errors, suitable
651
for the 'errcheck' attribute on ctypes functions"""
653
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
654
return _error_code(result)
655
result = func(*arguments)
658
# Unless otherwise indicated, the function declarations below are
659
# all from the gnutls/gnutls.h C header file.
662
priority_set_direct = _library.gnutls_priority_set_direct
663
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
664
ctypes.POINTER(ctypes.c_char_p)]
665
priority_set_direct.restype = _error_code
667
init = _library.gnutls_init
668
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
669
init.restype = _error_code
671
set_default_priority = _library.gnutls_set_default_priority
672
set_default_priority.argtypes = [session_t]
673
set_default_priority.restype = _error_code
675
record_send = _library.gnutls_record_send
676
record_send.argtypes = [session_t, ctypes.c_void_p,
678
record_send.restype = ctypes.c_ssize_t
679
record_send.errcheck = _retry_on_error
681
certificate_allocate_credentials = (
682
_library.gnutls_certificate_allocate_credentials)
683
certificate_allocate_credentials.argtypes = [
684
ctypes.POINTER(certificate_credentials_t)]
685
certificate_allocate_credentials.restype = _error_code
687
certificate_free_credentials = (
688
_library.gnutls_certificate_free_credentials)
689
certificate_free_credentials.argtypes = [
690
certificate_credentials_t]
691
certificate_free_credentials.restype = None
693
handshake_set_private_extensions = (
694
_library.gnutls_handshake_set_private_extensions)
695
handshake_set_private_extensions.argtypes = [session_t,
697
handshake_set_private_extensions.restype = None
699
credentials_set = _library.gnutls_credentials_set
700
credentials_set.argtypes = [session_t, credentials_type_t,
702
credentials_set.restype = _error_code
704
strerror = _library.gnutls_strerror
705
strerror.argtypes = [ctypes.c_int]
706
strerror.restype = ctypes.c_char_p
708
certificate_type_get = _library.gnutls_certificate_type_get
709
certificate_type_get.argtypes = [session_t]
710
certificate_type_get.restype = _error_code
712
certificate_get_peers = _library.gnutls_certificate_get_peers
713
certificate_get_peers.argtypes = [session_t,
714
ctypes.POINTER(ctypes.c_uint)]
715
certificate_get_peers.restype = ctypes.POINTER(datum_t)
717
global_set_log_level = _library.gnutls_global_set_log_level
718
global_set_log_level.argtypes = [ctypes.c_int]
719
global_set_log_level.restype = None
721
global_set_log_function = _library.gnutls_global_set_log_function
722
global_set_log_function.argtypes = [log_func]
723
global_set_log_function.restype = None
725
deinit = _library.gnutls_deinit
726
deinit.argtypes = [session_t]
727
deinit.restype = None
729
handshake = _library.gnutls_handshake
730
handshake.argtypes = [session_t]
731
handshake.restype = _error_code
732
handshake.errcheck = _retry_on_error
734
transport_set_ptr = _library.gnutls_transport_set_ptr
735
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
736
transport_set_ptr.restype = None
738
bye = _library.gnutls_bye
739
bye.argtypes = [session_t, close_request_t]
740
bye.restype = _error_code
741
bye.errcheck = _retry_on_error
743
check_version = _library.gnutls_check_version
744
check_version.argtypes = [ctypes.c_char_p]
745
check_version.restype = ctypes.c_char_p
747
has_rawpk = bool(check_version(_tls_rawpk_version))
751
class pubkey_st(ctypes.Structure):
753
pubkey_t = ctypes.POINTER(pubkey_st)
755
x509_crt_fmt_t = ctypes.c_int
757
# All the function declarations below are from gnutls/abstract.h
758
pubkey_init = _library.gnutls_pubkey_init
759
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
760
pubkey_init.restype = _error_code
762
pubkey_import = _library.gnutls_pubkey_import
763
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
765
pubkey_import.restype = _error_code
767
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
768
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
769
ctypes.POINTER(ctypes.c_ubyte),
770
ctypes.POINTER(ctypes.c_size_t)]
771
pubkey_get_key_id.restype = _error_code
773
pubkey_deinit = _library.gnutls_pubkey_deinit
774
pubkey_deinit.argtypes = [pubkey_t]
775
pubkey_deinit.restype = None
777
# All the function declarations below are from gnutls/openpgp.h
779
openpgp_crt_init = _library.gnutls_openpgp_crt_init
780
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
781
openpgp_crt_init.restype = _error_code
783
openpgp_crt_import = _library.gnutls_openpgp_crt_import
784
openpgp_crt_import.argtypes = [openpgp_crt_t,
785
ctypes.POINTER(datum_t),
787
openpgp_crt_import.restype = _error_code
789
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
790
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
791
ctypes.POINTER(ctypes.c_uint)]
792
openpgp_crt_verify_self.restype = _error_code
794
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
795
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
796
openpgp_crt_deinit.restype = None
798
openpgp_crt_get_fingerprint = (
799
_library.gnutls_openpgp_crt_get_fingerprint)
800
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
804
openpgp_crt_get_fingerprint.restype = _error_code
806
if check_version("3.6.4"):
807
certificate_type_get2 = _library.gnutls_certificate_type_get2
808
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
809
certificate_type_get2.restype = _error_code
811
# Remove non-public functions
812
del _error_code, _retry_on_error
813
# Create the global "gnutls" object, simulating a module
817
def call_pipe(connection, # : multiprocessing.Connection
818
func, *args, **kwargs):
819
"""This function is meant to be called by multiprocessing.Process
821
This function runs func(*args, **kwargs), and writes the resulting
822
return value on the provided multiprocessing.Connection.
824
connection.send(func(*args, **kwargs))
828
234
class Client(object):
829
235
"""A representation of a client host served by this server.
832
approved: bool(); 'None' if not yet approved/disapproved
833
approval_delay: datetime.timedelta(); Time to wait for approval
834
approval_duration: datetime.timedelta(); Duration of one approval
238
name: string; from the config file, used in log messages and
240
fingerprint: string (40 or 32 hexadecimal digits); used to
241
uniquely identify the client
242
secret: bytestring; sent verbatim (over TLS) to client
243
host: string; available for use by the checker command
244
created: datetime.datetime(); (UTC) object creation
245
last_enabled: datetime.datetime(); (UTC)
247
last_checked_ok: datetime.datetime(); (UTC) or None
248
timeout: datetime.timedelta(); How long from last_checked_ok
249
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)
835
252
checker: subprocess.Popen(); a running checker process used
836
253
to see if the client lives.
837
254
'None' if no process is running.
838
checker_callback_tag: a GLib event source tag, or None
839
checker_command: string; External command which is run to check
840
if client lives. %() expansions are done at
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
841
260
runtime with vars(self) as dict, so that for
842
261
instance %(name)s can be used in the command.
843
checker_initiator_tag: a GLib event source tag, or None
844
created: datetime.datetime(); (UTC) object creation
845
client_structure: Object describing what attributes a client has
846
and is used for storing the client at exit
847
262
current_checker_command: string; current running checker_command
848
disable_initiator_tag: a GLib event source tag, or None
850
fingerprint: string (40 or 32 hexadecimal digits); used to
851
uniquely identify an OpenPGP client
852
key_id: string (64 hexadecimal digits); used to uniquely identify
853
a client using raw public keys
854
host: string; available for use by the checker command
855
interval: datetime.timedelta(); How often to start a new checker
856
last_approval_request: datetime.datetime(); (UTC) or None
857
last_checked_ok: datetime.datetime(); (UTC) or None
858
last_checker_status: integer between 0 and 255 reflecting exit
859
status of last checker. -1 reflects crashed
860
checker, -2 means no checker completed yet.
861
last_checker_signal: The signal which killed the last checker, if
862
last_checker_status is -1
863
last_enabled: datetime.datetime(); (UTC) or None
864
name: string; from the config file, used in log messages and
866
secret: bytestring; sent verbatim (over TLS) to client
867
timeout: datetime.timedelta(); How long from last_checked_ok
868
until this client is disabled
869
extended_timeout: extra long timeout when secret has been sent
870
runtime_expansions: Allowed attributes for runtime expansion.
871
expires: datetime.datetime(); time (UTC) when a client will be
873
server_settings: The server_settings dict from main()
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
876
runtime_expansions = ("approval_delay", "approval_duration",
877
"created", "enabled", "expires", "key_id",
878
"fingerprint", "host", "interval",
879
"last_approval_request", "last_checked_ok",
880
"last_enabled", "name", "timeout")
883
"extended_timeout": "PT15M",
885
"checker": "fping -q -- %%(host)s",
887
"approval_delay": "PT0S",
888
"approval_duration": "PT1S",
889
"approved_by_default": "True",
894
def config_parser(config):
895
"""Construct a new dict of client settings of this form:
896
{ client_name: {setting_name: value, ...}, ...}
897
with exceptions for any special settings as defined above.
898
NOTE: Must be a pure function. Must return the same result
899
value given the same arguments.
902
for client_name in config.sections():
903
section = dict(config.items(client_name))
904
client = settings[client_name] = {}
906
client["host"] = section["host"]
907
# Reformat values from string types to Python types
908
client["approved_by_default"] = config.getboolean(
909
client_name, "approved_by_default")
910
client["enabled"] = config.getboolean(client_name,
913
# Uppercase and remove spaces from key_id and fingerprint
914
# for later comparison purposes with return value from the
915
# key_id() and fingerprint() functions
916
client["key_id"] = (section.get("key_id", "").upper()
918
client["fingerprint"] = (section["fingerprint"].upper()
920
if "secret" in section:
921
client["secret"] = codecs.decode(section["secret"]
924
elif "secfile" in section:
925
with open(os.path.expanduser(os.path.expandvars
926
(section["secfile"])),
928
client["secret"] = secfile.read()
930
raise TypeError("No secret or secfile for section {}"
932
client["timeout"] = string_to_delta(section["timeout"])
933
client["extended_timeout"] = string_to_delta(
934
section["extended_timeout"])
935
client["interval"] = string_to_delta(section["interval"])
936
client["approval_delay"] = string_to_delta(
937
section["approval_delay"])
938
client["approval_duration"] = string_to_delta(
939
section["approval_duration"])
940
client["checker_command"] = section["checker"]
941
client["last_approval_request"] = None
942
client["last_checked_ok"] = None
943
client["last_checker_status"] = -2
947
def __init__(self, settings, name=None, server_settings=None):
269
def _timedelta_to_milliseconds(td):
270
"Convert a datetime.timedelta() to milliseconds"
271
return ((td.days * 24 * 60 * 60 * 1000)
272
+ (td.seconds * 1000)
273
+ (td.microseconds // 1000))
275
def timeout_milliseconds(self):
276
"Return the 'timeout' attribute in milliseconds"
277
return self._timedelta_to_milliseconds(self.timeout)
279
def interval_milliseconds(self):
280
"Return the 'interval' attribute in milliseconds"
281
return self._timedelta_to_milliseconds(self.interval)
283
def approved_delay_milliseconds(self):
284
return self._timedelta_to_milliseconds(self.approved_delay)
286
def __init__(self, name = None, disable_hook=None, config=None):
287
"""Note: the 'checker' key in 'config' sets the
288
'checker_command' attribute and *not* the 'checker'
949
if server_settings is None:
951
self.server_settings = server_settings
952
# adding all client settings
953
for setting, value in settings.items():
954
setattr(self, setting, value)
957
if not hasattr(self, "last_enabled"):
958
self.last_enabled = datetime.datetime.utcnow()
959
if not hasattr(self, "expires"):
960
self.expires = (datetime.datetime.utcnow()
293
logger.debug(u"Creating client %r", self.name)
294
# Uppercase and remove spaces from fingerprint for later
295
# comparison purposes with return value from the fingerprint()
297
self.fingerprint = (config[u"fingerprint"].upper()
299
logger.debug(u" Fingerprint: %s", self.fingerprint)
300
if u"secret" in config:
301
self.secret = config[u"secret"].decode(u"base64")
302
elif u"secfile" in config:
303
with open(os.path.expanduser(os.path.expandvars
304
(config[u"secfile"])),
306
self.secret = secfile.read()
963
self.last_enabled = None
966
logger.debug("Creating client %r", self.name)
967
logger.debug(" Key ID: %s", self.key_id)
968
logger.debug(" Fingerprint: %s", self.fingerprint)
969
self.created = settings.get("created",
970
datetime.datetime.utcnow())
972
# attributes specific for this server instance
308
#XXX Need to allow secret on demand!
309
raise TypeError(u"No secret or secfile for client %s"
311
self.host = config.get(u"host", u"")
312
self.created = datetime.datetime.utcnow()
314
self.last_enabled = None
315
self.last_checked_ok = None
316
self.timeout = string_to_delta(config[u"timeout"])
317
self.interval = string_to_delta(config[u"interval"])
318
self.disable_hook = disable_hook
973
319
self.checker = None
974
320
self.checker_initiator_tag = None
975
321
self.disable_initiator_tag = None
976
322
self.checker_callback_tag = None
323
self.checker_command = config[u"checker"]
977
324
self.current_checker_command = None
325
self.last_connect = None
979
326
self.approvals_pending = 0
980
self.changedstate = multiprocessing_manager.Condition(
981
multiprocessing_manager.Lock())
982
self.client_structure = [attr
983
for attr in self.__dict__.keys()
984
if not attr.startswith("_")]
985
self.client_structure.append("client_structure")
987
for name, t in inspect.getmembers(
988
type(self), lambda obj: isinstance(obj, property)):
989
if not name.startswith("_"):
990
self.client_structure.append(name)
992
# Send notice to process children that client state has changed
327
self._approved = None
328
self.approved_by_default = config.get(u"approved_by_default",
330
self.approved_delay = string_to_delta(
331
config[u"approved_delay"])
332
self.approved_duration = string_to_delta(
333
config[u"approved_duration"])
334
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
993
336
def send_changedstate(self):
994
with self.changedstate:
995
self.changedstate.notify_all()
337
self.changedstate.acquire()
338
self.changedstate.notify_all()
339
self.changedstate.release()
997
341
def enable(self):
998
342
"""Start this client's checker and timeout hooks"""
999
if getattr(self, "enabled", False):
343
if getattr(self, u"enabled", False):
1000
344
# Already enabled
1002
self.expires = datetime.datetime.utcnow() + self.timeout
346
self.send_changedstate()
1004
347
self.last_enabled = datetime.datetime.utcnow()
1006
self.send_changedstate()
348
# Schedule a new checker to be started an 'interval' from now,
349
# and every interval from then on.
350
self.checker_initiator_tag = (gobject.timeout_add
351
(self.interval_milliseconds(),
353
# Schedule a disable() when 'timeout' has passed
354
self.disable_initiator_tag = (gobject.timeout_add
355
(self.timeout_milliseconds(),
358
# Also start a new checker *right now*.
1008
361
def disable(self, quiet=True):
1009
362
"""Disable this client."""
1010
363
if not getattr(self, "enabled", False):
1013
logger.info("Disabling client %s", self.name)
1014
if getattr(self, "disable_initiator_tag", None) is not None:
1015
GLib.source_remove(self.disable_initiator_tag)
366
self.send_changedstate()
368
logger.info(u"Disabling client %s", self.name)
369
if getattr(self, u"disable_initiator_tag", False):
370
gobject.source_remove(self.disable_initiator_tag)
1016
371
self.disable_initiator_tag = None
1018
if getattr(self, "checker_initiator_tag", None) is not None:
1019
GLib.source_remove(self.checker_initiator_tag)
372
if getattr(self, u"checker_initiator_tag", False):
373
gobject.source_remove(self.checker_initiator_tag)
1020
374
self.checker_initiator_tag = None
1021
375
self.stop_checker()
376
if self.disable_hook:
377
self.disable_hook(self)
1022
378
self.enabled = False
1024
self.send_changedstate()
1025
# Do not run this again if called by a GLib.timeout_add
379
# Do not run this again if called by a gobject.timeout_add
1028
382
def __del__(self):
383
self.disable_hook = None
1031
def init_checker(self):
1032
# Schedule a new checker to be started an 'interval' from now,
1033
# and every interval from then on.
1034
if self.checker_initiator_tag is not None:
1035
GLib.source_remove(self.checker_initiator_tag)
1036
self.checker_initiator_tag = GLib.timeout_add(
1037
int(self.interval.total_seconds() * 1000),
1039
# Schedule a disable() when 'timeout' has passed
1040
if self.disable_initiator_tag is not None:
1041
GLib.source_remove(self.disable_initiator_tag)
1042
self.disable_initiator_tag = GLib.timeout_add(
1043
int(self.timeout.total_seconds() * 1000), self.disable)
1044
# Also start a new checker *right now*.
1045
self.start_checker()
1047
def checker_callback(self, source, condition, connection,
386
def checker_callback(self, pid, condition, command):
1049
387
"""The checker has completed, so take appropriate actions."""
1050
388
self.checker_callback_tag = None
1051
389
self.checker = None
1052
# Read return code from connection (see call_pipe)
1053
returncode = connection.recv()
1057
self.last_checker_status = returncode
1058
self.last_checker_signal = None
1059
if self.last_checker_status == 0:
1060
logger.info("Checker for %(name)s succeeded",
390
if os.WIFEXITED(condition):
391
exitstatus = os.WEXITSTATUS(condition)
393
logger.info(u"Checker for %(name)s succeeded",
1062
395
self.checked_ok()
1064
logger.info("Checker for %(name)s failed", vars(self))
397
logger.info(u"Checker for %(name)s failed",
1066
self.last_checker_status = -1
1067
self.last_checker_signal = -returncode
1068
logger.warning("Checker for %(name)s crashed?",
400
logger.warning(u"Checker for %(name)s crashed?",
1072
403
def checked_ok(self):
1073
"""Assert that the client has been seen, alive and well."""
404
"""Bump up the timeout for this client.
406
This should only be called when the client has been seen,
1074
409
self.last_checked_ok = datetime.datetime.utcnow()
1075
self.last_checker_status = 0
1076
self.last_checker_signal = None
1079
def bump_timeout(self, timeout=None):
1080
"""Bump up the timeout for this client."""
1082
timeout = self.timeout
1083
if self.disable_initiator_tag is not None:
1084
GLib.source_remove(self.disable_initiator_tag)
1085
self.disable_initiator_tag = None
1086
if getattr(self, "enabled", False):
1087
self.disable_initiator_tag = GLib.timeout_add(
1088
int(timeout.total_seconds() * 1000), self.disable)
1089
self.expires = datetime.datetime.utcnow() + timeout
1091
def need_approval(self):
1092
self.last_approval_request = datetime.datetime.utcnow()
410
gobject.source_remove(self.disable_initiator_tag)
411
self.disable_initiator_tag = (gobject.timeout_add
412
(self.timeout_milliseconds(),
1094
415
def start_checker(self):
1095
416
"""Start a new checker subprocess if one is not running.
1097
418
If a checker already exists, leave it running and do
1099
420
# The reason for not killing a running checker is that if we
1100
# did that, and if a checker (for some reason) started running
1101
# slowly and taking more than 'interval' time, then the client
1102
# would inevitably timeout, since no checker would get a
1103
# chance to run to completion. If we instead leave running
421
# did that, then if a checker (for some reason) started
422
# running slowly and taking more than 'interval' time, the
423
# client would inevitably timeout, since no checker would get
424
# a chance to run to completion. If we instead leave running
1104
425
# checkers alone, the checker would have to take more time
1105
426
# than 'timeout' for the client to be disabled, which is as it
1108
if self.checker is not None and not self.checker.is_alive():
1109
logger.warning("Checker was not alive; joining")
429
# If a checker exists, make sure it is not a zombie
431
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
432
except (AttributeError, OSError), error:
433
if (isinstance(error, OSError)
434
and error.errno != errno.ECHILD):
438
logger.warning(u"Checker was a zombie")
439
gobject.source_remove(self.checker_callback_tag)
440
self.checker_callback(pid, status,
441
self.current_checker_command)
1112
442
# Start a new checker if needed
1113
443
if self.checker is None:
1114
# Escape attributes for the shell
1116
attr: re.escape(str(getattr(self, attr)))
1117
for attr in self.runtime_expansions}
1119
command = self.checker_command % escaped_attrs
1120
except TypeError as error:
1121
logger.error('Could not format string "%s"',
1122
self.checker_command,
1124
return True # Try again later
445
# In case checker_command has exactly one % operator
446
command = self.checker_command % self.host
448
# Escape attributes for the shell
449
escaped_attrs = dict((key,
450
re.escape(unicode(str(val),
454
vars(self).iteritems())
456
command = self.checker_command % escaped_attrs
457
except TypeError, error:
458
logger.error(u'Could not format string "%s":'
459
u' %s', self.checker_command, error)
460
return True # Try again later
1125
461
self.current_checker_command = command
1126
logger.info("Starting checker %r for %s", command,
1128
# We don't need to redirect stdout and stderr, since
1129
# in normal mode, that is already done by daemon(),
1130
# and in debug mode we don't want to. (Stdin is
1131
# always replaced by /dev/null.)
1132
# The exception is when not debugging but nevertheless
1133
# running in the foreground; use the previously
1135
popen_args = {"close_fds": True,
1138
if (not self.server_settings["debug"]
1139
and self.server_settings["foreground"]):
1140
popen_args.update({"stdout": wnull,
1142
pipe = multiprocessing.Pipe(duplex=False)
1143
self.checker = multiprocessing.Process(
1145
args=(pipe[1], subprocess.call, command),
1147
self.checker.start()
1148
self.checker_callback_tag = GLib.io_add_watch(
1149
pipe[0].fileno(), GLib.IO_IN,
1150
self.checker_callback, pipe[0], command)
1151
# Re-run this periodically if run by GLib.timeout_add
463
logger.info(u"Starting checker %r for %s",
465
# We don't need to redirect stdout and stderr, since
466
# in normal mode, that is already done by daemon(),
467
# and in debug mode we don't want to. (Stdin is
468
# always replaced by /dev/null.)
469
self.checker = subprocess.Popen(command,
471
shell=True, cwd=u"/")
472
self.checker_callback_tag = (gobject.child_watch_add
474
self.checker_callback,
476
# The checker may have completed before the gobject
477
# watch was added. Check for this.
478
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
480
gobject.source_remove(self.checker_callback_tag)
481
self.checker_callback(pid, status, command)
482
except OSError, error:
483
logger.error(u"Failed to start subprocess: %s",
485
# Re-run this periodically if run by gobject.timeout_add
1154
488
def stop_checker(self):
1155
489
"""Force the checker process, if any, to stop."""
1156
490
if self.checker_callback_tag:
1157
GLib.source_remove(self.checker_callback_tag)
491
gobject.source_remove(self.checker_callback_tag)
1158
492
self.checker_callback_tag = None
1159
if getattr(self, "checker", None) is None:
493
if getattr(self, u"checker", None) is None:
1161
logger.debug("Stopping checker for %(name)s", vars(self))
1162
self.checker.terminate()
495
logger.debug(u"Stopping checker for %(name)s", vars(self))
497
os.kill(self.checker.pid, signal.SIGTERM)
499
#if self.checker.poll() is None:
500
# os.kill(self.checker.pid, signal.SIGKILL)
501
except OSError, error:
502
if error.errno != errno.ESRCH: # No such process
1163
504
self.checker = None
1166
def dbus_service_property(dbus_interface,
506
def dbus_service_property(dbus_interface, signature=u"v",
507
access=u"readwrite", byte_arrays=False):
1170
508
"""Decorators for marking methods of a DBusObjectWithProperties to
1171
509
become properties on the D-Bus.
1173
511
The decorated method will be called with no arguments by "Get"
1174
512
and with one argument by "Set".
1176
514
The parameters, where they are supported, are the same as
1177
515
dbus.service.method, except there is only "signature", since the
1178
516
type from Get() and the type sent to Set() is the same.
1180
518
# Encoding deeply encoded byte arrays is not supported yet by the
1181
519
# "Set" method, so we fail early here:
1182
if byte_arrays and signature != "ay":
1183
raise ValueError("Byte arrays not supported for non-'ay'"
1184
" signature {!r}".format(signature))
520
if byte_arrays and signature != u"ay":
521
raise ValueError(u"Byte arrays not supported for non-'ay'"
522
u" signature %r" % signature)
1186
523
def decorator(func):
1187
524
func._dbus_is_property = True
1188
525
func._dbus_interface = dbus_interface
1189
526
func._dbus_signature = signature
1190
527
func._dbus_access = access
1191
528
func._dbus_name = func.__name__
1192
if func._dbus_name.endswith("_dbus_property"):
529
if func._dbus_name.endswith(u"_dbus_property"):
1193
530
func._dbus_name = func._dbus_name[:-14]
1194
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1200
def dbus_interface_annotations(dbus_interface):
1201
"""Decorator for marking functions returning interface annotations
1205
@dbus_interface_annotations("org.example.Interface")
1206
def _foo(self): # Function name does not matter
1207
return {"org.freedesktop.DBus.Deprecated": "true",
1208
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1212
def decorator(func):
1213
func._dbus_is_interface = True
1214
func._dbus_interface = dbus_interface
1215
func._dbus_name = dbus_interface
1221
def dbus_annotations(annotations):
1222
"""Decorator to annotate D-Bus methods, signals or properties
1225
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1226
"org.freedesktop.DBus.Property."
1227
"EmitsChangedSignal": "false"})
1228
@dbus_service_property("org.example.Interface", signature="b",
1230
def Property_dbus_property(self):
1231
return dbus.Boolean(False)
1233
See also the DBusObjectWithAnnotations class.
1236
def decorator(func):
1237
func._dbus_annotations = annotations
531
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
1240
533
return decorator
1243
536
class DBusPropertyException(dbus.exceptions.DBusException):
1244
537
"""A base class for D-Bus property-related exceptions
539
def __unicode__(self):
540
return unicode(str(self))
1249
543
class DBusPropertyAccessException(DBusPropertyException):
1261
class DBusObjectWithAnnotations(dbus.service.Object):
1262
"""A D-Bus object with annotations.
1264
Classes inheriting from this can use the dbus_annotations
1265
decorator to add annotations to methods or signals.
1269
def _is_dbus_thing(thing):
1270
"""Returns a function testing if an attribute is a D-Bus thing
1272
If called like _is_dbus_thing("method") it returns a function
1273
suitable for use as predicate to inspect.getmembers().
1275
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
1278
def _get_all_dbus_things(self, thing):
1279
"""Returns a generator of (name, attribute) pairs
1281
return ((getattr(athing.__get__(self), "_dbus_name", name),
1282
athing.__get__(self))
1283
for cls in self.__class__.__mro__
1285
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1287
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1289
path_keyword='object_path',
1290
connection_keyword='connection')
1291
def Introspect(self, object_path, connection):
1292
"""Overloading of standard D-Bus method.
1294
Inserts annotation tags on methods and signals.
1296
xmlstring = dbus.service.Object.Introspect(self, object_path,
1299
document = xml.dom.minidom.parseString(xmlstring)
1301
for if_tag in document.getElementsByTagName("interface"):
1302
# Add annotation tags
1303
for typ in ("method", "signal"):
1304
for tag in if_tag.getElementsByTagName(typ):
1306
for name, prop in (self.
1307
_get_all_dbus_things(typ)):
1308
if (name == tag.getAttribute("name")
1309
and prop._dbus_interface
1310
== if_tag.getAttribute("name")):
1311
annots.update(getattr(
1312
prop, "_dbus_annotations", {}))
1313
for name, value in annots.items():
1314
ann_tag = document.createElement(
1316
ann_tag.setAttribute("name", name)
1317
ann_tag.setAttribute("value", value)
1318
tag.appendChild(ann_tag)
1319
# Add interface annotation tags
1320
for annotation, value in dict(
1321
itertools.chain.from_iterable(
1322
annotations().items()
1323
for name, annotations
1324
in self._get_all_dbus_things("interface")
1325
if name == if_tag.getAttribute("name")
1327
ann_tag = document.createElement("annotation")
1328
ann_tag.setAttribute("name", annotation)
1329
ann_tag.setAttribute("value", value)
1330
if_tag.appendChild(ann_tag)
1331
# Fix argument name for the Introspect method itself
1332
if (if_tag.getAttribute("name")
1333
== dbus.INTROSPECTABLE_IFACE):
1334
for cn in if_tag.getElementsByTagName("method"):
1335
if cn.getAttribute("name") == "Introspect":
1336
for arg in cn.getElementsByTagName("arg"):
1337
if (arg.getAttribute("direction")
1339
arg.setAttribute("name",
1341
xmlstring = document.toxml("utf-8")
1343
except (AttributeError, xml.dom.DOMException,
1344
xml.parsers.expat.ExpatError) as error:
1345
logger.error("Failed to override Introspection method",
1350
class DBusObjectWithProperties(DBusObjectWithAnnotations):
555
class DBusObjectWithProperties(dbus.service.Object):
1351
556
"""A D-Bus object with properties.
1353
558
Classes inheriting from this can use the dbus_service_property
1354
559
decorator to expose methods as D-Bus properties. It exposes the
1355
560
standard Get(), Set(), and GetAll() methods on the D-Bus.
564
def _is_dbus_property(obj):
565
return getattr(obj, u"_dbus_is_property", False)
567
def _get_all_dbus_properties(self):
568
"""Returns a generator of (name, attribute) pairs
570
return ((prop._dbus_name, prop)
572
inspect.getmembers(self, self._is_dbus_property))
1358
574
def _get_dbus_property(self, interface_name, property_name):
1359
575
"""Returns a bound method if one exists which is a D-Bus
1360
576
property with the specified name and interface.
1362
for cls in self.__class__.__mro__:
1363
for name, value in inspect.getmembers(
1364
cls, self._is_dbus_thing("property")):
1365
if (value._dbus_name == property_name
1366
and value._dbus_interface == interface_name):
1367
return value.__get__(self)
578
for name in (property_name,
579
property_name + u"_dbus_property"):
580
prop = getattr(self, name, None)
582
or not self._is_dbus_property(prop)
583
or prop._dbus_name != property_name
584
or (interface_name and prop._dbus_interface
585
and interface_name != prop._dbus_interface)):
1369
588
# No such property
1370
raise DBusPropertyNotFound("{}:{}.{}".format(
1371
self.dbus_object_path, interface_name, property_name))
1374
def _get_all_interface_names(cls):
1375
"""Get a sequence of all interfaces supported by an object"""
1376
return (name for name in set(getattr(getattr(x, attr),
1377
"_dbus_interface", None)
1378
for x in (inspect.getmro(cls))
1380
if name is not None)
1382
@dbus.service.method(dbus.PROPERTIES_IFACE,
589
raise DBusPropertyNotFound(self.dbus_object_path + u":"
590
+ interface_name + u"."
593
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
1385
595
def Get(self, interface_name, property_name):
1386
596
"""Standard D-Bus property Get() method, see D-Bus standard.
1388
598
prop = self._get_dbus_property(interface_name, property_name)
1389
if prop._dbus_access == "write":
599
if prop._dbus_access == u"write":
1390
600
raise DBusPropertyAccessException(property_name)
1392
if not hasattr(value, "variant_level"):
602
if not hasattr(value, u"variant_level"):
1394
604
return type(value)(value, variant_level=value.variant_level+1)
1396
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
606
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
1397
607
def Set(self, interface_name, property_name, value):
1398
608
"""Standard D-Bus property Set() method, see D-Bus standard.
1400
610
prop = self._get_dbus_property(interface_name, property_name)
1401
if prop._dbus_access == "read":
611
if prop._dbus_access == u"read":
1402
612
raise DBusPropertyAccessException(property_name)
1403
if prop._dbus_get_args_options["byte_arrays"]:
613
if prop._dbus_get_args_options[u"byte_arrays"]:
1404
614
# The byte_arrays option is not supported yet on
1405
615
# signatures other than "ay".
1406
if prop._dbus_signature != "ay":
1407
raise ValueError("Byte arrays not supported for non-"
1408
"'ay' signature {!r}"
1409
.format(prop._dbus_signature))
1410
value = dbus.ByteArray(b''.join(chr(byte)
616
if prop._dbus_signature != u"ay":
618
value = dbus.ByteArray(''.join(unichr(byte)
1414
@dbus.service.method(dbus.PROPERTIES_IFACE,
1416
out_signature="a{sv}")
622
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
623
out_signature=u"a{sv}")
1417
624
def GetAll(self, interface_name):
1418
625
"""Standard D-Bus property GetAll() method, see D-Bus
1421
628
Note: Will not include properties with access="write".
1424
for name, prop in self._get_all_dbus_things("property"):
631
for name, prop in self._get_all_dbus_properties():
1425
632
if (interface_name
1426
633
and interface_name != prop._dbus_interface):
1427
634
# Interface non-empty but did not match
1429
636
# Ignore write-only properties
1430
if prop._dbus_access == "write":
637
if prop._dbus_access == u"write":
1433
if not hasattr(value, "variant_level"):
1434
properties[name] = value
640
if not hasattr(value, u"variant_level"):
1436
properties[name] = type(value)(
1437
value, variant_level=value.variant_level + 1)
1438
return dbus.Dictionary(properties, signature="sv")
1440
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1441
def PropertiesChanged(self, interface_name, changed_properties,
1442
invalidated_properties):
1443
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
643
all[name] = type(value)(value, variant_level=
644
value.variant_level+1)
645
return dbus.Dictionary(all, signature=u"sv")
1448
647
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1450
649
path_keyword='object_path',
1451
650
connection_keyword='connection')
1452
651
def Introspect(self, object_path, connection):
1453
"""Overloading of standard D-Bus method.
1455
Inserts property tags and interface annotation tags.
652
"""Standard D-Bus method, overloaded to insert property tags.
1457
xmlstring = DBusObjectWithAnnotations.Introspect(self,
654
xmlstring = dbus.service.Object.Introspect(self, object_path,
1461
657
document = xml.dom.minidom.parseString(xmlstring)
1463
658
def make_tag(document, name, prop):
1464
e = document.createElement("property")
1465
e.setAttribute("name", name)
1466
e.setAttribute("type", prop._dbus_signature)
1467
e.setAttribute("access", prop._dbus_access)
659
e = document.createElement(u"property")
660
e.setAttribute(u"name", name)
661
e.setAttribute(u"type", prop._dbus_signature)
662
e.setAttribute(u"access", prop._dbus_access)
1470
for if_tag in document.getElementsByTagName("interface"):
664
for if_tag in document.getElementsByTagName(u"interface"):
1472
665
for tag in (make_tag(document, name, prop)
1474
in self._get_all_dbus_things("property")
667
in self._get_all_dbus_properties()
1475
668
if prop._dbus_interface
1476
== if_tag.getAttribute("name")):
669
== if_tag.getAttribute(u"name")):
1477
670
if_tag.appendChild(tag)
1478
# Add annotation tags for properties
1479
for tag in if_tag.getElementsByTagName("property"):
1481
for name, prop in self._get_all_dbus_things(
1483
if (name == tag.getAttribute("name")
1484
and prop._dbus_interface
1485
== if_tag.getAttribute("name")):
1486
annots.update(getattr(
1487
prop, "_dbus_annotations", {}))
1488
for name, value in annots.items():
1489
ann_tag = document.createElement(
1491
ann_tag.setAttribute("name", name)
1492
ann_tag.setAttribute("value", value)
1493
tag.appendChild(ann_tag)
1494
671
# Add the names to the return values for the
1495
672
# "org.freedesktop.DBus.Properties" methods
1496
if (if_tag.getAttribute("name")
1497
== "org.freedesktop.DBus.Properties"):
1498
for cn in if_tag.getElementsByTagName("method"):
1499
if cn.getAttribute("name") == "Get":
1500
for arg in cn.getElementsByTagName("arg"):
1501
if (arg.getAttribute("direction")
1503
arg.setAttribute("name", "value")
1504
elif cn.getAttribute("name") == "GetAll":
1505
for arg in cn.getElementsByTagName("arg"):
1506
if (arg.getAttribute("direction")
1508
arg.setAttribute("name", "props")
1509
xmlstring = document.toxml("utf-8")
1511
except (AttributeError, xml.dom.DOMException,
1512
xml.parsers.expat.ExpatError) as error:
1513
logger.error("Failed to override Introspection method",
1519
dbus.OBJECT_MANAGER_IFACE
1520
except AttributeError:
1521
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1524
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1525
"""A D-Bus object with an ObjectManager.
1527
Classes inheriting from this exposes the standard
1528
GetManagedObjects call and the InterfacesAdded and
1529
InterfacesRemoved signals on the standard
1530
"org.freedesktop.DBus.ObjectManager" interface.
1532
Note: No signals are sent automatically; they must be sent
1535
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1536
out_signature="a{oa{sa{sv}}}")
1537
def GetManagedObjects(self):
1538
"""This function must be overridden"""
1539
raise NotImplementedError()
1541
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1542
signature="oa{sa{sv}}")
1543
def InterfacesAdded(self, object_path, interfaces_and_properties):
1546
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1547
def InterfacesRemoved(self, object_path, interfaces):
1550
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1552
path_keyword='object_path',
1553
connection_keyword='connection')
1554
def Introspect(self, object_path, connection):
1555
"""Overloading of standard D-Bus method.
1557
Override return argument name of GetManagedObjects to be
1558
"objpath_interfaces_and_properties"
1560
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1564
document = xml.dom.minidom.parseString(xmlstring)
1566
for if_tag in document.getElementsByTagName("interface"):
1567
# Fix argument name for the GetManagedObjects method
1568
if (if_tag.getAttribute("name")
1569
== dbus.OBJECT_MANAGER_IFACE):
1570
for cn in if_tag.getElementsByTagName("method"):
1571
if (cn.getAttribute("name")
1572
== "GetManagedObjects"):
1573
for arg in cn.getElementsByTagName("arg"):
1574
if (arg.getAttribute("direction")
1578
"objpath_interfaces"
1580
xmlstring = document.toxml("utf-8")
1582
except (AttributeError, xml.dom.DOMException,
1583
xml.parsers.expat.ExpatError) as error:
1584
logger.error("Failed to override Introspection method",
1589
def datetime_to_dbus(dt, variant_level=0):
1590
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1592
return dbus.String("", variant_level=variant_level)
1593
return dbus.String(dt.isoformat(), variant_level=variant_level)
1596
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1597
"""A class decorator; applied to a subclass of
1598
dbus.service.Object, it will add alternate D-Bus attributes with
1599
interface names according to the "alt_interface_names" mapping.
1602
@alternate_dbus_interfaces({"org.example.Interface":
1603
"net.example.AlternateInterface"})
1604
class SampleDBusObject(dbus.service.Object):
1605
@dbus.service.method("org.example.Interface")
1606
def SampleDBusMethod():
1609
The above "SampleDBusMethod" on "SampleDBusObject" will be
1610
reachable via two interfaces: "org.example.Interface" and
1611
"net.example.AlternateInterface", the latter of which will have
1612
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1613
"true", unless "deprecate" is passed with a False value.
1615
This works for methods and signals, and also for D-Bus properties
1616
(from DBusObjectWithProperties) and interfaces (from the
1617
dbus_interface_annotations decorator).
1621
for orig_interface_name, alt_interface_name in (
1622
alt_interface_names.items()):
1624
interface_names = set()
1625
# Go though all attributes of the class
1626
for attrname, attribute in inspect.getmembers(cls):
1627
# Ignore non-D-Bus attributes, and D-Bus attributes
1628
# with the wrong interface name
1629
if (not hasattr(attribute, "_dbus_interface")
1630
or not attribute._dbus_interface.startswith(
1631
orig_interface_name)):
1633
# Create an alternate D-Bus interface name based on
1635
alt_interface = attribute._dbus_interface.replace(
1636
orig_interface_name, alt_interface_name)
1637
interface_names.add(alt_interface)
1638
# Is this a D-Bus signal?
1639
if getattr(attribute, "_dbus_is_signal", False):
1640
# Extract the original non-method undecorated
1641
# function by black magic
1642
if sys.version_info.major == 2:
1643
nonmethod_func = (dict(
1644
zip(attribute.func_code.co_freevars,
1645
attribute.__closure__))
1646
["func"].cell_contents)
1648
nonmethod_func = (dict(
1649
zip(attribute.__code__.co_freevars,
1650
attribute.__closure__))
1651
["func"].cell_contents)
1652
# Create a new, but exactly alike, function
1653
# object, and decorate it to be a new D-Bus signal
1654
# with the alternate D-Bus interface name
1655
new_function = copy_function(nonmethod_func)
1656
new_function = (dbus.service.signal(
1658
attribute._dbus_signature)(new_function))
1659
# Copy annotations, if any
1661
new_function._dbus_annotations = dict(
1662
attribute._dbus_annotations)
1663
except AttributeError:
1666
# Define a creator of a function to call both the
1667
# original and alternate functions, so both the
1668
# original and alternate signals gets sent when
1669
# the function is called
1670
def fixscope(func1, func2):
1671
"""This function is a scope container to pass
1672
func1 and func2 to the "call_both" function
1673
outside of its arguments"""
1675
@functools.wraps(func2)
1676
def call_both(*args, **kwargs):
1677
"""This function will emit two D-Bus
1678
signals by calling func1 and func2"""
1679
func1(*args, **kwargs)
1680
func2(*args, **kwargs)
1681
# Make wrapper function look like a D-Bus
1683
for name, attr in inspect.getmembers(func2):
1684
if name.startswith("_dbus_"):
1685
setattr(call_both, name, attr)
1688
# Create the "call_both" function and add it to
1690
attr[attrname] = fixscope(attribute, new_function)
1691
# Is this a D-Bus method?
1692
elif getattr(attribute, "_dbus_is_method", False):
1693
# Create a new, but exactly alike, function
1694
# object. Decorate it to be a new D-Bus method
1695
# with the alternate D-Bus interface name. Add it
1698
dbus.service.method(
1700
attribute._dbus_in_signature,
1701
attribute._dbus_out_signature)
1702
(copy_function(attribute)))
1703
# Copy annotations, if any
1705
attr[attrname]._dbus_annotations = dict(
1706
attribute._dbus_annotations)
1707
except AttributeError:
1709
# Is this a D-Bus property?
1710
elif getattr(attribute, "_dbus_is_property", False):
1711
# Create a new, but exactly alike, function
1712
# object, and decorate it to be a new D-Bus
1713
# property with the alternate D-Bus interface
1714
# name. Add it to the class.
1715
attr[attrname] = (dbus_service_property(
1716
alt_interface, attribute._dbus_signature,
1717
attribute._dbus_access,
1718
attribute._dbus_get_args_options
1720
(copy_function(attribute)))
1721
# Copy annotations, if any
1723
attr[attrname]._dbus_annotations = dict(
1724
attribute._dbus_annotations)
1725
except AttributeError:
1727
# Is this a D-Bus interface?
1728
elif getattr(attribute, "_dbus_is_interface", False):
1729
# Create a new, but exactly alike, function
1730
# object. Decorate it to be a new D-Bus interface
1731
# with the alternate D-Bus interface name. Add it
1734
dbus_interface_annotations(alt_interface)
1735
(copy_function(attribute)))
1737
# Deprecate all alternate interfaces
1738
iname = "_AlternateDBusNames_interface_annotation{}"
1739
for interface_name in interface_names:
1741
@dbus_interface_annotations(interface_name)
1743
return {"org.freedesktop.DBus.Deprecated":
1745
# Find an unused name
1746
for aname in (iname.format(i)
1747
for i in itertools.count()):
1748
if aname not in attr:
1752
# Replace the class with a new subclass of it with
1753
# methods, signals, etc. as created above.
1754
if sys.version_info.major == 2:
1755
cls = type(b"{}Alternate".format(cls.__name__),
1758
cls = type("{}Alternate".format(cls.__name__),
1765
@alternate_dbus_interfaces({"se.recompile.Mandos":
1766
"se.bsnet.fukt.Mandos"})
673
if (if_tag.getAttribute(u"name")
674
== u"org.freedesktop.DBus.Properties"):
675
for cn in if_tag.getElementsByTagName(u"method"):
676
if cn.getAttribute(u"name") == u"Get":
677
for arg in cn.getElementsByTagName(u"arg"):
678
if (arg.getAttribute(u"direction")
680
arg.setAttribute(u"name", u"value")
681
elif cn.getAttribute(u"name") == u"GetAll":
682
for arg in cn.getElementsByTagName(u"arg"):
683
if (arg.getAttribute(u"direction")
685
arg.setAttribute(u"name", u"props")
686
xmlstring = document.toxml(u"utf-8")
688
except (AttributeError, xml.dom.DOMException,
689
xml.parsers.expat.ExpatError), error:
690
logger.error(u"Failed to override Introspection method",
1767
695
class ClientDBus(Client, DBusObjectWithProperties):
1768
696
"""A Client class using D-Bus
1771
699
dbus_object_path: dbus.ObjectPath
1772
700
bus: dbus.SystemBus()
1775
runtime_expansions = (Client.runtime_expansions
1776
+ ("dbus_object_path", ))
1778
_interface = "se.recompile.Mandos.Client"
1780
702
# dbus.service.Object doesn't use super(), so we can't either.
1782
def __init__(self, bus=None, *args, **kwargs):
704
def __init__(self, bus = None, *args, **kwargs):
1784
706
Client.__init__(self, *args, **kwargs)
1785
707
# Only now, when this client is initialized, can it show up on
1787
client_object_name = str(self.name).translate(
1788
{ord("."): ord("_"),
1789
ord("-"): ord("_")})
1790
self.dbus_object_path = dbus.ObjectPath(
1791
"/clients/" + client_object_name)
709
self.dbus_object_path = (dbus.ObjectPath
711
+ self.name.replace(u".", u"_")))
1792
712
DBusObjectWithProperties.__init__(self, self.bus,
1793
713
self.dbus_object_path)
1795
def notifychangeproperty(transform_func, dbus_name,
1796
type_func=lambda x: x,
1798
invalidate_only=False,
1799
_interface=_interface):
1800
""" Modify a variable so that it's a property which announces
1801
its changes to DBus.
1803
transform_fun: Function that takes a value and a variant_level
1804
and transforms it to a D-Bus type.
1805
dbus_name: D-Bus name of the variable
1806
type_func: Function that transform the value before sending it
1807
to the D-Bus. Default: no transform
1808
variant_level: D-Bus variant level. Default: 1
1810
attrname = "_{}".format(dbus_name)
1812
def setter(self, value):
1813
if hasattr(self, "dbus_object_path"):
1814
if (not hasattr(self, attrname) or
1815
type_func(getattr(self, attrname, None))
1816
!= type_func(value)):
1818
self.PropertiesChanged(
1819
_interface, dbus.Dictionary(),
1820
dbus.Array((dbus_name, )))
1822
dbus_value = transform_func(
1824
variant_level=variant_level)
1825
self.PropertyChanged(dbus.String(dbus_name),
1827
self.PropertiesChanged(
1829
dbus.Dictionary({dbus.String(dbus_name):
1832
setattr(self, attrname, value)
1834
return property(lambda self: getattr(self, attrname), setter)
1836
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1837
approvals_pending = notifychangeproperty(dbus.Boolean,
1840
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1841
last_enabled = notifychangeproperty(datetime_to_dbus,
1843
checker = notifychangeproperty(
1844
dbus.Boolean, "CheckerRunning",
1845
type_func=lambda checker: checker is not None)
1846
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1848
last_checker_status = notifychangeproperty(dbus.Int16,
1849
"LastCheckerStatus")
1850
last_approval_request = notifychangeproperty(
1851
datetime_to_dbus, "LastApprovalRequest")
1852
approved_by_default = notifychangeproperty(dbus.Boolean,
1853
"ApprovedByDefault")
1854
approval_delay = notifychangeproperty(
1855
dbus.UInt64, "ApprovalDelay",
1856
type_func=lambda td: td.total_seconds() * 1000)
1857
approval_duration = notifychangeproperty(
1858
dbus.UInt64, "ApprovalDuration",
1859
type_func=lambda td: td.total_seconds() * 1000)
1860
host = notifychangeproperty(dbus.String, "Host")
1861
timeout = notifychangeproperty(
1862
dbus.UInt64, "Timeout",
1863
type_func=lambda td: td.total_seconds() * 1000)
1864
extended_timeout = notifychangeproperty(
1865
dbus.UInt64, "ExtendedTimeout",
1866
type_func=lambda td: td.total_seconds() * 1000)
1867
interval = notifychangeproperty(
1868
dbus.UInt64, "Interval",
1869
type_func=lambda td: td.total_seconds() * 1000)
1870
checker_command = notifychangeproperty(dbus.String, "Checker")
1871
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1872
invalidate_only=True)
1874
del notifychangeproperty
716
def _datetime_to_dbus(dt, variant_level=0):
717
"""Convert a UTC datetime.datetime() to a D-Bus type."""
718
return dbus.String(dt.isoformat(),
719
variant_level=variant_level)
722
oldstate = getattr(self, u"enabled", False)
723
r = Client.enable(self)
724
if oldstate != self.enabled:
726
self.PropertyChanged(dbus.String(u"enabled"),
727
dbus.Boolean(True, variant_level=1))
728
self.PropertyChanged(
729
dbus.String(u"last_enabled"),
730
self._datetime_to_dbus(self.last_enabled,
734
def disable(self, quiet = False):
735
oldstate = getattr(self, u"enabled", False)
736
r = Client.disable(self, quiet=quiet)
737
if not quiet and oldstate != self.enabled:
739
self.PropertyChanged(dbus.String(u"enabled"),
740
dbus.Boolean(False, variant_level=1))
1876
743
def __del__(self, *args, **kwargs):
1878
745
self.remove_from_connection()
1879
746
except LookupError:
1881
if hasattr(DBusObjectWithProperties, "__del__"):
748
if hasattr(DBusObjectWithProperties, u"__del__"):
1882
749
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1883
750
Client.__del__(self, *args, **kwargs)
1885
def checker_callback(self, source, condition,
1886
connection, command, *args, **kwargs):
1887
ret = Client.checker_callback(self, source, condition,
1888
connection, command, *args,
1890
exitstatus = self.last_checker_status
752
def checker_callback(self, pid, condition, command,
754
self.checker_callback_tag = None
757
self.PropertyChanged(dbus.String(u"checker_running"),
758
dbus.Boolean(False, variant_level=1))
759
if os.WIFEXITED(condition):
760
exitstatus = os.WEXITSTATUS(condition)
1892
761
# Emit D-Bus signal
1893
762
self.CheckerCompleted(dbus.Int16(exitstatus),
1894
# This is specific to GNU libC
1895
dbus.Int64(exitstatus << 8),
763
dbus.Int64(condition),
1896
764
dbus.String(command))
1898
766
# Emit D-Bus signal
1899
767
self.CheckerCompleted(dbus.Int16(-1),
1901
# This is specific to GNU libC
1903
| self.last_checker_signal),
768
dbus.Int64(condition),
1904
769
dbus.String(command))
771
return Client.checker_callback(self, pid, condition, command,
774
def checked_ok(self, *args, **kwargs):
775
r = Client.checked_ok(self, *args, **kwargs)
777
self.PropertyChanged(
778
dbus.String(u"last_checked_ok"),
779
(self._datetime_to_dbus(self.last_checked_ok,
1907
783
def start_checker(self, *args, **kwargs):
1908
old_checker_pid = getattr(self.checker, "pid", None)
784
old_checker = self.checker
785
if self.checker is not None:
786
old_checker_pid = self.checker.pid
788
old_checker_pid = None
1909
789
r = Client.start_checker(self, *args, **kwargs)
1910
790
# Only if new checker process was started
1911
791
if (self.checker is not None
1912
792
and old_checker_pid != self.checker.pid):
1913
793
# Emit D-Bus signal
1914
794
self.CheckerStarted(self.current_checker_command)
795
self.PropertyChanged(
796
dbus.String(u"checker_running"),
797
dbus.Boolean(True, variant_level=1))
800
def stop_checker(self, *args, **kwargs):
801
old_checker = getattr(self, u"checker", None)
802
r = Client.stop_checker(self, *args, **kwargs)
803
if (old_checker is not None
804
and getattr(self, u"checker", None) is None):
805
self.PropertyChanged(dbus.String(u"checker_running"),
806
dbus.Boolean(False, variant_level=1))
1917
809
def _reset_approved(self):
1918
self.approved = None
810
self._approved = None
1921
813
def approve(self, value=True):
1922
self.approved = value
1923
GLib.timeout_add(int(self.approval_duration.total_seconds()
1924
* 1000), self._reset_approved)
1925
self.send_changedstate()
1927
# D-Bus methods, signals & properties
814
self._approved = value
815
gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration, self._reset_approved))
817
def approved_pending(self):
818
return self.approvals_pending > 0
821
## D-Bus methods, signals & properties
822
_interface = u"se.bsnet.fukt.Mandos.Client"
1933
826
# CheckerCompleted - signal
1934
@dbus.service.signal(_interface, signature="nxs")
827
@dbus.service.signal(_interface, signature=u"nxs")
1935
828
def CheckerCompleted(self, exitcode, waitstatus, command):
1939
832
# CheckerStarted - signal
1940
@dbus.service.signal(_interface, signature="s")
833
@dbus.service.signal(_interface, signature=u"s")
1941
834
def CheckerStarted(self, command):
1945
838
# PropertyChanged - signal
1946
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1947
@dbus.service.signal(_interface, signature="sv")
839
@dbus.service.signal(_interface, signature=u"sv")
1948
840
def PropertyChanged(self, property, value):
1952
844
# GotSecret - signal
1953
845
@dbus.service.signal(_interface)
1954
846
def GotSecret(self):
1956
Is sent after a successful transfer of secret from the Mandos
1957
server to mandos-client
1961
850
# Rejected - signal
1962
@dbus.service.signal(_interface, signature="s")
851
@dbus.service.signal(_interface, signature=u"s")
1963
852
def Rejected(self, reason):
1967
856
# NeedApproval - signal
1968
@dbus.service.signal(_interface, signature="tb")
857
@dbus.service.signal(_interface, signature=u"db")
1969
858
def NeedApproval(self, timeout, default):
1971
return self.need_approval()
1975
864
# Approve - method
1976
@dbus.service.method(_interface, in_signature="b")
865
@dbus.service.method(_interface, in_signature=u"b")
1977
866
def Approve(self, value):
1978
867
self.approve(value)
1980
869
# CheckedOK - method
1981
870
@dbus.service.method(_interface)
1982
871
def CheckedOK(self):
872
return self.checked_ok()
1985
874
# Enable - method
1986
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1987
875
@dbus.service.method(_interface)
1988
876
def Enable(self):
1992
880
# StartChecker - method
1993
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1994
881
@dbus.service.method(_interface)
1995
882
def StartChecker(self):
1997
884
self.start_checker()
1999
886
# Disable - method
2000
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2001
887
@dbus.service.method(_interface)
2002
888
def Disable(self):
2006
892
# StopChecker - method
2007
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2008
893
@dbus.service.method(_interface)
2009
894
def StopChecker(self):
2010
895
self.stop_checker()
2014
# ApprovalPending - property
2015
@dbus_service_property(_interface, signature="b", access="read")
2016
def ApprovalPending_dbus_property(self):
2017
return dbus.Boolean(bool(self.approvals_pending))
2019
# ApprovedByDefault - property
2020
@dbus_service_property(_interface,
2023
def ApprovedByDefault_dbus_property(self, value=None):
2024
if value is None: # get
2025
return dbus.Boolean(self.approved_by_default)
2026
self.approved_by_default = bool(value)
2028
# ApprovalDelay - property
2029
@dbus_service_property(_interface,
2032
def ApprovalDelay_dbus_property(self, value=None):
2033
if value is None: # get
2034
return dbus.UInt64(self.approval_delay.total_seconds()
2036
self.approval_delay = datetime.timedelta(0, 0, 0, value)
2038
# ApprovalDuration - property
2039
@dbus_service_property(_interface,
2042
def ApprovalDuration_dbus_property(self, value=None):
2043
if value is None: # get
2044
return dbus.UInt64(self.approval_duration.total_seconds()
2046
self.approval_duration = datetime.timedelta(0, 0, 0, value)
2050
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2051
@dbus_service_property(_interface, signature="s", access="read")
2052
def Name_dbus_property(self):
899
# approved_pending - property
900
@dbus_service_property(_interface, signature=u"b", access=u"read")
901
def approved_pending_dbus_property(self):
902
return dbus.Boolean(self.approved_pending())
904
# approved_by_default - property
905
@dbus_service_property(_interface, signature=u"b",
907
def approved_by_default_dbus_property(self):
908
return dbus.Boolean(self.approved_by_default)
910
# approved_delay - property
911
@dbus_service_property(_interface, signature=u"t",
913
def approved_delay_dbus_property(self):
914
return dbus.UInt64(self.approved_delay_milliseconds())
916
# approved_duration - property
917
@dbus_service_property(_interface, signature=u"t",
919
def approved_duration_dbus_property(self):
920
return dbus.UInt64(self._timedelta_to_milliseconds(
921
self.approved_duration))
924
@dbus_service_property(_interface, signature=u"s", access=u"read")
925
def name_dbus_property(self):
2053
926
return dbus.String(self.name)
2057
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2058
@dbus_service_property(_interface, signature="s", access="read")
2059
def KeyID_dbus_property(self):
2060
return dbus.String(self.key_id)
2062
# Fingerprint - property
2064
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2065
@dbus_service_property(_interface, signature="s", access="read")
2066
def Fingerprint_dbus_property(self):
928
# fingerprint - property
929
@dbus_service_property(_interface, signature=u"s", access=u"read")
930
def fingerprint_dbus_property(self):
2067
931
return dbus.String(self.fingerprint)
2070
@dbus_service_property(_interface,
2073
def Host_dbus_property(self, value=None):
934
@dbus_service_property(_interface, signature=u"s",
936
def host_dbus_property(self, value=None):
2074
937
if value is None: # get
2075
938
return dbus.String(self.host)
2076
self.host = str(value)
2078
# Created - property
2080
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2081
@dbus_service_property(_interface, signature="s", access="read")
2082
def Created_dbus_property(self):
2083
return datetime_to_dbus(self.created)
2085
# LastEnabled - property
2086
@dbus_service_property(_interface, signature="s", access="read")
2087
def LastEnabled_dbus_property(self):
2088
return datetime_to_dbus(self.last_enabled)
2090
# Enabled - property
2091
@dbus_service_property(_interface,
2094
def Enabled_dbus_property(self, value=None):
941
self.PropertyChanged(dbus.String(u"host"),
942
dbus.String(value, variant_level=1))
945
@dbus_service_property(_interface, signature=u"s", access=u"read")
946
def created_dbus_property(self):
947
return dbus.String(self._datetime_to_dbus(self.created))
949
# last_enabled - property
950
@dbus_service_property(_interface, signature=u"s", access=u"read")
951
def last_enabled_dbus_property(self):
952
if self.last_enabled is None:
953
return dbus.String(u"")
954
return dbus.String(self._datetime_to_dbus(self.last_enabled))
957
@dbus_service_property(_interface, signature=u"b",
959
def enabled_dbus_property(self, value=None):
2095
960
if value is None: # get
2096
961
return dbus.Boolean(self.enabled)
2102
# LastCheckedOK - property
2103
@dbus_service_property(_interface,
2106
def LastCheckedOK_dbus_property(self, value=None):
967
# last_checked_ok - property
968
@dbus_service_property(_interface, signature=u"s",
970
def last_checked_ok_dbus_property(self, value=None):
2107
971
if value is not None:
2108
972
self.checked_ok()
2110
return datetime_to_dbus(self.last_checked_ok)
2112
# LastCheckerStatus - property
2113
@dbus_service_property(_interface, signature="n", access="read")
2114
def LastCheckerStatus_dbus_property(self):
2115
return dbus.Int16(self.last_checker_status)
2117
# Expires - property
2118
@dbus_service_property(_interface, signature="s", access="read")
2119
def Expires_dbus_property(self):
2120
return datetime_to_dbus(self.expires)
2122
# LastApprovalRequest - property
2123
@dbus_service_property(_interface, signature="s", access="read")
2124
def LastApprovalRequest_dbus_property(self):
2125
return datetime_to_dbus(self.last_approval_request)
2127
# Timeout - property
2128
@dbus_service_property(_interface,
2131
def Timeout_dbus_property(self, value=None):
974
if self.last_checked_ok is None:
975
return dbus.String(u"")
976
return dbus.String(self._datetime_to_dbus(self
980
@dbus_service_property(_interface, signature=u"t",
982
def timeout_dbus_property(self, value=None):
2132
983
if value is None: # get
2133
return dbus.UInt64(self.timeout.total_seconds() * 1000)
2134
old_timeout = self.timeout
984
return dbus.UInt64(self.timeout_milliseconds())
2135
985
self.timeout = datetime.timedelta(0, 0, 0, value)
2136
# Reschedule disabling
2138
now = datetime.datetime.utcnow()
2139
self.expires += self.timeout - old_timeout
2140
if self.expires <= now:
2141
# The timeout has passed
2144
if (getattr(self, "disable_initiator_tag", None)
2147
GLib.source_remove(self.disable_initiator_tag)
2148
self.disable_initiator_tag = GLib.timeout_add(
2149
int((self.expires - now).total_seconds() * 1000),
2152
# ExtendedTimeout - property
2153
@dbus_service_property(_interface,
2156
def ExtendedTimeout_dbus_property(self, value=None):
2157
if value is None: # get
2158
return dbus.UInt64(self.extended_timeout.total_seconds()
2160
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2162
# Interval - property
2163
@dbus_service_property(_interface,
2166
def Interval_dbus_property(self, value=None):
2167
if value is None: # get
2168
return dbus.UInt64(self.interval.total_seconds() * 1000)
987
self.PropertyChanged(dbus.String(u"timeout"),
988
dbus.UInt64(value, variant_level=1))
989
if getattr(self, u"disable_initiator_tag", None) is None:
992
gobject.source_remove(self.disable_initiator_tag)
993
self.disable_initiator_tag = None
995
_timedelta_to_milliseconds((self
1000
if time_to_die <= 0:
1001
# The timeout has passed
1004
self.disable_initiator_tag = (gobject.timeout_add
1005
(time_to_die, self.disable))
1007
# interval - property
1008
@dbus_service_property(_interface, signature=u"t",
1009
access=u"readwrite")
1010
def interval_dbus_property(self, value=None):
1011
if value is None: # get
1012
return dbus.UInt64(self.interval_milliseconds())
2169
1013
self.interval = datetime.timedelta(0, 0, 0, value)
2170
if getattr(self, "checker_initiator_tag", None) is None:
1015
self.PropertyChanged(dbus.String(u"interval"),
1016
dbus.UInt64(value, variant_level=1))
1017
if getattr(self, u"checker_initiator_tag", None) is None:
2173
# Reschedule checker run
2174
GLib.source_remove(self.checker_initiator_tag)
2175
self.checker_initiator_tag = GLib.timeout_add(
2176
value, self.start_checker)
2177
self.start_checker() # Start one now, too
1019
# Reschedule checker run
1020
gobject.source_remove(self.checker_initiator_tag)
1021
self.checker_initiator_tag = (gobject.timeout_add
1022
(value, self.start_checker))
1023
self.start_checker() # Start one now, too
2179
# Checker - property
2180
@dbus_service_property(_interface,
2183
def Checker_dbus_property(self, value=None):
1025
# checker - property
1026
@dbus_service_property(_interface, signature=u"s",
1027
access=u"readwrite")
1028
def checker_dbus_property(self, value=None):
2184
1029
if value is None: # get
2185
1030
return dbus.String(self.checker_command)
2186
self.checker_command = str(value)
2188
# CheckerRunning - property
2189
@dbus_service_property(_interface,
2192
def CheckerRunning_dbus_property(self, value=None):
1031
self.checker_command = value
1033
self.PropertyChanged(dbus.String(u"checker"),
1034
dbus.String(self.checker_command,
1037
# checker_running - property
1038
@dbus_service_property(_interface, signature=u"b",
1039
access=u"readwrite")
1040
def checker_running_dbus_property(self, value=None):
2193
1041
if value is None: # get
2194
1042
return dbus.Boolean(self.checker is not None)
2196
1044
self.start_checker()
2198
1046
self.stop_checker()
2200
# ObjectPath - property
2202
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2203
"org.freedesktop.DBus.Deprecated": "true"})
2204
@dbus_service_property(_interface, signature="o", access="read")
2205
def ObjectPath_dbus_property(self):
2206
return self.dbus_object_path # is already a dbus.ObjectPath
2210
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
2212
@dbus_service_property(_interface,
2216
def Secret_dbus_property(self, value):
2217
self.secret = bytes(value)
1048
# object_path - property
1049
@dbus_service_property(_interface, signature=u"o", access=u"read")
1050
def object_path_dbus_property(self):
1051
return self.dbus_object_path # is already a dbus.ObjectPath
1054
@dbus_service_property(_interface, signature=u"ay",
1055
access=u"write", byte_arrays=True)
1056
def secret_dbus_property(self, value):
1057
self.secret = str(value)
2222
1062
class ProxyClient(object):
2223
def __init__(self, child_pipe, key_id, fpr, address):
1063
def __init__(self, child_pipe, fpr, address):
2224
1064
self._pipe = child_pipe
2225
self._pipe.send(('init', key_id, fpr, address))
1065
self._pipe.send(('init', fpr, address))
2226
1066
if not self._pipe.recv():
2227
raise KeyError(key_id or fpr)
2229
1069
def __getattribute__(self, name):
1070
if(name == '_pipe'):
2231
1071
return super(ProxyClient, self).__getattribute__(name)
2232
1072
self._pipe.send(('getattr', name))
2233
1073
data = self._pipe.recv()
2234
1074
if data[0] == 'data':
2236
1076
if data[0] == 'function':
2238
1077
def func(*args, **kwargs):
2239
1078
self._pipe.send(('funcall', name, args, kwargs))
2240
1079
return self._pipe.recv()[1]
2244
1082
def __setattr__(self, name, value):
1083
if(name == '_pipe'):
2246
1084
return super(ProxyClient, self).__setattr__(name, value)
2247
1085
self._pipe.send(('setattr', name, value))
2250
1088
class ClientHandler(socketserver.BaseRequestHandler, object):
2251
1089
"""A class to handle client connections.
2253
1091
Instantiated once for each connection to handle it.
2254
1092
Note: This will run in its own forked process."""
2256
1094
def handle(self):
2257
1095
with contextlib.closing(self.server.child_pipe) as child_pipe:
2258
logger.info("TCP connection from: %s",
2259
str(self.client_address))
2260
logger.debug("Pipe FD: %d",
1096
logger.info(u"TCP connection from: %s",
1097
unicode(self.client_address))
1098
logger.debug(u"Pipe FD: %d",
2261
1099
self.server.child_pipe.fileno())
2263
session = gnutls.ClientSession(self.request)
2265
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2266
# "+AES-256-CBC", "+SHA1",
2267
# "+COMP-NULL", "+CTYPE-OPENPGP",
1101
session = (gnutls.connection
1102
.ClientSession(self.request,
1104
.X509Credentials()))
1106
# Note: gnutls.connection.X509Credentials is really a
1107
# generic GnuTLS certificate credentials object so long as
1108
# no X.509 keys are added to it. Therefore, we can use it
1109
# here despite using OpenPGP certificates.
1111
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1112
# u"+AES-256-CBC", u"+SHA1",
1113
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
2269
1115
# Use a fallback default, since this MUST be set.
2270
1116
priority = self.server.gnutls_priority
2271
1117
if priority is None:
2273
gnutls.priority_set_direct(session._c_object,
2274
priority.encode("utf-8"),
1118
priority = u"NORMAL"
1119
(gnutls.library.functions
1120
.gnutls_priority_set_direct(session._c_object,
2277
1123
# Start communication using the Mandos protocol
2278
1124
# Get protocol number
2279
1125
line = self.request.makefile().readline()
2280
logger.debug("Protocol version: %r", line)
1126
logger.debug(u"Protocol version: %r", line)
2282
1128
if int(line.strip().split()[0]) > 1:
2283
raise RuntimeError(line)
2284
except (ValueError, IndexError, RuntimeError) as error:
2285
logger.error("Unknown protocol version: %s", error)
1130
except (ValueError, IndexError, RuntimeError), error:
1131
logger.error(u"Unknown protocol version: %s", error)
2288
1134
# Start GnuTLS connection
2290
1136
session.handshake()
2291
except gnutls.Error as error:
2292
logger.warning("Handshake failed: %s", error)
1137
except gnutls.errors.GNUTLSError, error:
1138
logger.warning(u"Handshake failed: %s", error)
2293
1139
# Do not run session.bye() here: the session is not
2294
1140
# established. Just abandon the request.
2296
logger.debug("Handshake succeeded")
1142
logger.debug(u"Handshake succeeded")
2298
1144
approval_required = False
2300
if gnutls.has_rawpk:
2303
key_id = self.key_id(
2304
self.peer_certificate(session))
2305
except (TypeError, gnutls.Error) as error:
2306
logger.warning("Bad certificate: %s", error)
2308
logger.debug("Key ID: %s", key_id)
2313
fpr = self.fingerprint(
2314
self.peer_certificate(session))
2315
except (TypeError, gnutls.Error) as error:
2316
logger.warning("Bad certificate: %s", error)
2318
logger.debug("Fingerprint: %s", fpr)
2321
client = ProxyClient(child_pipe, key_id, fpr,
1147
fpr = self.fingerprint(self.peer_certificate
1149
except (TypeError, gnutls.errors.GNUTLSError), error:
1150
logger.warning(u"Bad certificate: %s", error)
1152
logger.debug(u"Fingerprint: %s", fpr)
1155
client = ProxyClient(child_pipe, fpr,
2322
1156
self.client_address)
2323
1157
except KeyError:
2326
if client.approval_delay:
2327
delay = client.approval_delay
1160
if client.approved_delay:
1161
delay = client.approved_delay
2328
1162
client.approvals_pending += 1
2329
1163
approval_required = True
2332
1166
if not client.enabled:
2333
logger.info("Client %s is disabled",
1167
logger.warning(u"Client %s is disabled",
2335
1169
if self.server.use_dbus:
2336
1170
# Emit D-Bus signal
2337
client.Rejected("Disabled")
1171
client.Rejected("Disabled")
2340
if client.approved or not client.approval_delay:
2341
# We are approved or approval is disabled
1174
if client._approved or not client.approved_delay:
1175
#We are approved or approval is disabled
2343
elif client.approved is None:
2344
logger.info("Client %s needs approval",
1177
elif client._approved is None:
1178
logger.info(u"Client %s need approval",
2346
1180
if self.server.use_dbus:
2347
1181
# Emit D-Bus signal
2348
1182
client.NeedApproval(
2349
client.approval_delay.total_seconds()
2350
* 1000, client.approved_by_default)
1183
client.approved_delay_milliseconds(),
1184
client.approved_by_default)
2352
logger.warning("Client %s was not approved",
1186
logger.warning(u"Client %s was not approved",
2354
1188
if self.server.use_dbus:
2355
1189
# Emit D-Bus signal
2356
client.Rejected("Denied")
1190
client.Rejected("Disapproved")
2359
# wait until timeout or approved
1193
#wait until timeout or approved
1194
#x = float(client._timedelta_to_milliseconds(delay))
2360
1195
time = datetime.datetime.now()
2361
1196
client.changedstate.acquire()
2362
client.changedstate.wait(delay.total_seconds())
1197
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
2363
1198
client.changedstate.release()
2364
1199
time2 = datetime.datetime.now()
2365
1200
if (time2 - time) >= delay:
2370
1205
if self.server.use_dbus:
2371
1206
# Emit D-Bus signal
2372
client.Rejected("Approval timed out")
1207
client.Rejected("Time out")
2377
1212
delay -= time2 - time
2380
session.send(client.secret)
2381
except gnutls.Error as error:
2382
logger.warning("gnutls send failed",
2386
logger.info("Sending secret to %s", client.name)
2387
# bump the timeout using extended_timeout
2388
client.bump_timeout(client.extended_timeout)
1215
while sent_size < len(client.secret):
1216
# XXX handle session exception
1217
sent = session.send(client.secret[sent_size:])
1218
logger.debug(u"Sent: %d, remaining: %d",
1219
sent, len(client.secret)
1220
- (sent_size + sent))
1223
logger.info(u"Sending secret to %s", client.name)
1224
# bump the timeout as if seen
2389
1226
if self.server.use_dbus:
2390
1227
# Emit D-Bus signal
2391
1228
client.GotSecret()
2394
1231
if approval_required:
2395
1232
client.approvals_pending -= 1
2398
except gnutls.Error as error:
2399
logger.warning("GnuTLS bye failed",
2403
1236
def peer_certificate(session):
2404
"Return the peer's certificate as a bytestring"
2406
cert_type = gnutls.certificate_type_get2(session._c_object,
2408
except AttributeError:
2409
cert_type = gnutls.certificate_type_get(session._c_object)
2410
if gnutls.has_rawpk:
2411
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2413
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2414
# If not a valid certificate type...
2415
if cert_type not in valid_cert_types:
2416
logger.info("Cert type %r not in %r", cert_type,
2418
# ...return invalid data
1237
"Return the peer's OpenPGP certificate as a bytestring"
1238
# If not an OpenPGP certificate...
1239
if (gnutls.library.functions
1240
.gnutls_certificate_type_get(session._c_object)
1241
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1242
# ...do the normal thing
1243
return session.peer_certificate
2420
1244
list_size = ctypes.c_uint(1)
2421
cert_list = (gnutls.certificate_get_peers
1245
cert_list = (gnutls.library.functions
1246
.gnutls_certificate_get_peers
2422
1247
(session._c_object, ctypes.byref(list_size)))
2423
1248
if not bool(cert_list) and list_size.value != 0:
2424
raise gnutls.Error("error getting peer certificate")
1249
raise gnutls.errors.GNUTLSError(u"error getting peer"
2425
1251
if list_size.value == 0:
2427
1253
cert = cert_list[0]
2428
1254
return ctypes.string_at(cert.data, cert.size)
2431
def key_id(certificate):
2432
"Convert a certificate bytestring to a hexdigit key ID"
2433
# New GnuTLS "datum" with the public key
2434
datum = gnutls.datum_t(
2435
ctypes.cast(ctypes.c_char_p(certificate),
2436
ctypes.POINTER(ctypes.c_ubyte)),
2437
ctypes.c_uint(len(certificate)))
2438
# XXX all these need to be created in the gnutls "module"
2439
# New empty GnuTLS certificate
2440
pubkey = gnutls.pubkey_t()
2441
gnutls.pubkey_init(ctypes.byref(pubkey))
2442
# Import the raw public key into the certificate
2443
gnutls.pubkey_import(pubkey,
2444
ctypes.byref(datum),
2445
gnutls.X509_FMT_DER)
2446
# New buffer for the key ID
2447
buf = ctypes.create_string_buffer(32)
2448
buf_len = ctypes.c_size_t(len(buf))
2449
# Get the key ID from the raw public key into the buffer
2450
gnutls.pubkey_get_key_id(pubkey,
2451
gnutls.KEYID_USE_SHA256,
2452
ctypes.cast(ctypes.byref(buf),
2453
ctypes.POINTER(ctypes.c_ubyte)),
2454
ctypes.byref(buf_len))
2455
# Deinit the certificate
2456
gnutls.pubkey_deinit(pubkey)
2458
# Convert the buffer to a Python bytestring
2459
key_id = ctypes.string_at(buf, buf_len.value)
2460
# Convert the bytestring to hexadecimal notation
2461
hex_key_id = binascii.hexlify(key_id).upper()
2465
1257
def fingerprint(openpgp):
2466
1258
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2467
1259
# New GnuTLS "datum" with the OpenPGP public key
2468
datum = gnutls.datum_t(
2469
ctypes.cast(ctypes.c_char_p(openpgp),
2470
ctypes.POINTER(ctypes.c_ubyte)),
2471
ctypes.c_uint(len(openpgp)))
1260
datum = (gnutls.library.types
1261
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1264
ctypes.c_uint(len(openpgp))))
2472
1265
# New empty GnuTLS certificate
2473
crt = gnutls.openpgp_crt_t()
2474
gnutls.openpgp_crt_init(ctypes.byref(crt))
1266
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1267
(gnutls.library.functions
1268
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2475
1269
# Import the OpenPGP public key into the certificate
2476
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2477
gnutls.OPENPGP_FMT_RAW)
1270
(gnutls.library.functions
1271
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1272
gnutls.library.constants
1273
.GNUTLS_OPENPGP_FMT_RAW))
2478
1274
# Verify the self signature in the key
2479
1275
crtverify = ctypes.c_uint()
2480
gnutls.openpgp_crt_verify_self(crt, 0,
2481
ctypes.byref(crtverify))
1276
(gnutls.library.functions
1277
.gnutls_openpgp_crt_verify_self(crt, 0,
1278
ctypes.byref(crtverify)))
2482
1279
if crtverify.value != 0:
2483
gnutls.openpgp_crt_deinit(crt)
2484
raise gnutls.CertificateSecurityError(code
1280
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1281
raise (gnutls.errors.CertificateSecurityError
2486
1283
# New buffer for the fingerprint
2487
1284
buf = ctypes.create_string_buffer(20)
2488
1285
buf_len = ctypes.c_size_t()
2489
1286
# Get the fingerprint from the certificate into the buffer
2490
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2491
ctypes.byref(buf_len))
1287
(gnutls.library.functions
1288
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1289
ctypes.byref(buf_len)))
2492
1290
# Deinit the certificate
2493
gnutls.openpgp_crt_deinit(crt)
1291
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2494
1292
# Convert the buffer to a Python bytestring
2495
1293
fpr = ctypes.string_at(buf, buf_len.value)
2496
1294
# Convert the bytestring to hexadecimal notation
2497
hex_fpr = binascii.hexlify(fpr).upper()
1295
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
2501
1299
class MultiprocessingMixIn(object):
2502
1300
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2504
1301
def sub_process_main(self, request, address):
2506
1303
self.finish_request(request, address)
2508
1305
self.handle_error(request, address)
2509
1306
self.close_request(request)
2511
1308
def process_request(self, request, address):
2512
1309
"""Start a new process to process the request."""
2513
proc = multiprocessing.Process(target=self.sub_process_main,
2514
args=(request, address))
1310
multiprocessing.Process(target = self.sub_process_main,
1311
args = (request, address)).start()
2519
1313
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2520
1314
""" adds a pipe to the MixIn """
2522
1315
def process_request(self, request, client_address):
2523
1316
"""Overrides and wraps the original process_request().
2525
1318
This function creates a new pipe in self.pipe
2527
1320
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2529
proc = MultiprocessingMixIn.process_request(self, request,
2531
self.child_pipe.close()
2532
self.add_pipe(parent_pipe, proc)
2534
def add_pipe(self, parent_pipe, proc):
1322
super(MultiprocessingMixInWithPipe,
1323
self).process_request(request, client_address)
1324
self.add_pipe(parent_pipe)
1325
def add_pipe(self, parent_pipe):
2535
1326
"""Dummy function; override as necessary"""
2536
raise NotImplementedError()
2539
1329
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2540
1330
socketserver.TCPServer, object):
2541
1331
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2544
1334
enabled: Boolean; whether this server is activated yet
2545
1335
interface: None or a network interface name (string)
2546
1336
use_ipv6: Boolean; to use IPv6 or not
2549
1338
def __init__(self, server_address, RequestHandlerClass,
2553
"""If socketfd is set, use that file descriptor instead of
2554
creating a new one with socket.socket().
1339
interface=None, use_ipv6=True):
2556
1340
self.interface = interface
2558
1342
self.address_family = socket.AF_INET6
2559
if socketfd is not None:
2560
# Save the file descriptor
2561
self.socketfd = socketfd
2562
# Save the original socket.socket() function
2563
self.socket_socket = socket.socket
2565
# To implement --socket, we monkey patch socket.socket.
2567
# (When socketserver.TCPServer is a new-style class, we
2568
# could make self.socket into a property instead of monkey
2569
# patching socket.socket.)
2571
# Create a one-time-only replacement for socket.socket()
2572
@functools.wraps(socket.socket)
2573
def socket_wrapper(*args, **kwargs):
2574
# Restore original function so subsequent calls are
2576
socket.socket = self.socket_socket
2577
del self.socket_socket
2578
# This time only, return a new socket object from the
2579
# saved file descriptor.
2580
return socket.fromfd(self.socketfd, *args, **kwargs)
2581
# Replace socket.socket() function with wrapper
2582
socket.socket = socket_wrapper
2583
# The socketserver.TCPServer.__init__ will call
2584
# socket.socket(), which might be our replacement,
2585
# socket_wrapper(), if socketfd was set.
2586
1343
socketserver.TCPServer.__init__(self, server_address,
2587
1344
RequestHandlerClass)
2589
1345
def server_bind(self):
2590
1346
"""This overrides the normal server_bind() function
2591
1347
to bind to an interface if one was specified, and also NOT to
2592
1348
bind to an address or port if they were not specified."""
2593
global SO_BINDTODEVICE
2594
1349
if self.interface is not None:
2595
1350
if SO_BINDTODEVICE is None:
2596
# Fall back to a hard-coded value which seems to be
2598
logger.warning("SO_BINDTODEVICE not found, trying 25")
2599
SO_BINDTODEVICE = 25
2601
self.socket.setsockopt(
2602
socket.SOL_SOCKET, SO_BINDTODEVICE,
2603
(self.interface + "\0").encode("utf-8"))
2604
except socket.error as error:
2605
if error.errno == errno.EPERM:
2606
logger.error("No permission to bind to"
2607
" interface %s", self.interface)
2608
elif error.errno == errno.ENOPROTOOPT:
2609
logger.error("SO_BINDTODEVICE not available;"
2610
" cannot bind to interface %s",
2612
elif error.errno == errno.ENODEV:
2613
logger.error("Interface %s does not exist,"
2614
" cannot bind", self.interface)
1351
logger.error(u"SO_BINDTODEVICE does not exist;"
1352
u" cannot bind to interface %s",
1356
self.socket.setsockopt(socket.SOL_SOCKET,
1360
except socket.error, error:
1361
if error[0] == errno.EPERM:
1362
logger.error(u"No permission to"
1363
u" bind to interface %s",
1365
elif error[0] == errno.ENOPROTOOPT:
1366
logger.error(u"SO_BINDTODEVICE not available;"
1367
u" cannot bind to interface %s",
2617
1371
# Only bind(2) the socket if we really need to.
2618
1372
if self.server_address[0] or self.server_address[1]:
2619
1373
if not self.server_address[0]:
2620
1374
if self.address_family == socket.AF_INET6:
2621
any_address = "::" # in6addr_any
1375
any_address = u"::" # in6addr_any
2623
any_address = "0.0.0.0" # INADDR_ANY
1377
any_address = socket.INADDR_ANY
2624
1378
self.server_address = (any_address,
2625
1379
self.server_address[1])
2626
1380
elif not self.server_address[1]:
2627
self.server_address = (self.server_address[0], 0)
1381
self.server_address = (self.server_address[0],
2628
1383
# if self.interface:
2629
1384
# self.server_address = (self.server_address[0],
2637
1392
class MandosServer(IPv6_TCPServer):
2638
1393
"""Mandos server.
2641
1396
clients: set of Client objects
2642
1397
gnutls_priority GnuTLS priority string
2643
1398
use_dbus: Boolean; to emit D-Bus signals or not
2645
Assumes a GLib.MainLoop event loop.
1400
Assumes a gobject.MainLoop event loop.
2648
1402
def __init__(self, server_address, RequestHandlerClass,
2652
gnutls_priority=None,
1403
interface=None, use_ipv6=True, clients=None,
1404
gnutls_priority=None, use_dbus=True):
2655
1405
self.enabled = False
2656
1406
self.clients = clients
2657
1407
if self.clients is None:
1408
self.clients = set()
2659
1409
self.use_dbus = use_dbus
2660
1410
self.gnutls_priority = gnutls_priority
2661
1411
IPv6_TCPServer.__init__(self, server_address,
2662
1412
RequestHandlerClass,
2663
interface=interface,
1413
interface = interface,
1414
use_ipv6 = use_ipv6)
2667
1415
def server_activate(self):
2668
1416
if self.enabled:
2669
1417
return socketserver.TCPServer.server_activate(self)
2671
1418
def enable(self):
2672
1419
self.enabled = True
2674
def add_pipe(self, parent_pipe, proc):
1420
def add_pipe(self, parent_pipe):
2675
1421
# Call "handle_ipc" for both data and EOF events
2677
parent_pipe.fileno(),
2678
GLib.IO_IN | GLib.IO_HUP,
2679
functools.partial(self.handle_ipc,
2680
parent_pipe=parent_pipe,
2683
def handle_ipc(self, source, condition,
1422
gobject.io_add_watch(parent_pipe.fileno(),
1423
gobject.IO_IN | gobject.IO_HUP,
1424
functools.partial(self.handle_ipc,
1425
parent_pipe = parent_pipe))
1427
def handle_ipc(self, source, condition, parent_pipe=None,
2686
1428
client_object=None):
2687
# error, or the other end of multiprocessing.Pipe has closed
2688
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2689
# Wait for other process to exit
1430
gobject.IO_IN: u"IN", # There is data to read.
1431
gobject.IO_OUT: u"OUT", # Data can be written (without
1433
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1434
gobject.IO_ERR: u"ERR", # Error condition.
1435
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1436
# broken, usually for pipes and
1439
conditions_string = ' | '.join(name
1441
condition_names.iteritems()
1442
if cond & condition)
1443
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
2693
1446
# Read a request from the child
2694
1447
request = parent_pipe.recv()
2695
1448
command = request[0]
2697
1450
if command == 'init':
2698
key_id = request[1].decode("ascii")
2699
fpr = request[2].decode("ascii")
2700
address = request[3]
2702
for c in self.clients.values():
2703
if key_id and c.key_id == key_id:
2706
if fpr and c.fingerprint == fpr:
1452
address = request[2]
1454
for c in self.clients:
1455
if c.fingerprint == fpr:
2710
logger.info("Client not found for key ID: %s, address"
2711
": %s", key_id or fpr, address)
1459
logger.warning(u"Client not found for fingerprint: %s, ad"
1460
u"dress: %s", fpr, address)
2712
1461
if self.use_dbus:
2713
1462
# Emit D-Bus signal
2714
mandos_dbus_service.ClientNotFound(key_id or fpr,
1463
mandos_dbus_service.ClientNotFound(fpr, address)
2716
1464
parent_pipe.send(False)
2720
parent_pipe.fileno(),
2721
GLib.IO_IN | GLib.IO_HUP,
2722
functools.partial(self.handle_ipc,
2723
parent_pipe=parent_pipe,
2725
client_object=client))
1467
gobject.io_add_watch(parent_pipe.fileno(),
1468
gobject.IO_IN | gobject.IO_HUP,
1469
functools.partial(self.handle_ipc,
1470
parent_pipe = parent_pipe,
1471
client_object = client))
2726
1472
parent_pipe.send(True)
2727
# remove the old hook in favor of the new above hook on
1473
# remove the old hook in favor of the new above hook on same fileno
2730
1475
if command == 'funcall':
2731
1476
funcname = request[1]
2732
1477
args = request[2]
2733
1478
kwargs = request[3]
2735
parent_pipe.send(('data', getattr(client_object,
1480
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
2739
1482
if command == 'getattr':
2740
1483
attrname = request[1]
2741
if isinstance(client_object.__getattribute__(attrname),
2742
collections.Callable):
2743
parent_pipe.send(('function', ))
1484
if callable(client_object.__getattribute__(attrname)):
1485
parent_pipe.send(('function',))
2746
'data', client_object.__getattribute__(attrname)))
1487
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
2748
1489
if command == 'setattr':
2749
1490
attrname = request[1]
2750
1491
value = request[2]
2751
1492
setattr(client_object, attrname, value)
2756
def rfc3339_duration_to_delta(duration):
2757
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2759
>>> rfc3339_duration_to_delta("P7D")
2760
datetime.timedelta(7)
2761
>>> rfc3339_duration_to_delta("PT60S")
2762
datetime.timedelta(0, 60)
2763
>>> rfc3339_duration_to_delta("PT60M")
2764
datetime.timedelta(0, 3600)
2765
>>> rfc3339_duration_to_delta("PT24H")
2766
datetime.timedelta(1)
2767
>>> rfc3339_duration_to_delta("P1W")
2768
datetime.timedelta(7)
2769
>>> rfc3339_duration_to_delta("PT5M30S")
2770
datetime.timedelta(0, 330)
2771
>>> rfc3339_duration_to_delta("P1DT3M20S")
2772
datetime.timedelta(1, 200)
2775
# Parsing an RFC 3339 duration with regular expressions is not
2776
# possible - there would have to be multiple places for the same
2777
# values, like seconds. The current code, while more esoteric, is
2778
# cleaner without depending on a parsing library. If Python had a
2779
# built-in library for parsing we would use it, but we'd like to
2780
# avoid excessive use of external libraries.
2782
# New type for defining tokens, syntax, and semantics all-in-one
2783
Token = collections.namedtuple("Token", (
2784
"regexp", # To match token; if "value" is not None, must have
2785
# a "group" containing digits
2786
"value", # datetime.timedelta or None
2787
"followers")) # Tokens valid after this token
2788
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2789
# the "duration" ABNF definition in RFC 3339, Appendix A.
2790
token_end = Token(re.compile(r"$"), None, frozenset())
2791
token_second = Token(re.compile(r"(\d+)S"),
2792
datetime.timedelta(seconds=1),
2793
frozenset((token_end, )))
2794
token_minute = Token(re.compile(r"(\d+)M"),
2795
datetime.timedelta(minutes=1),
2796
frozenset((token_second, token_end)))
2797
token_hour = Token(re.compile(r"(\d+)H"),
2798
datetime.timedelta(hours=1),
2799
frozenset((token_minute, token_end)))
2800
token_time = Token(re.compile(r"T"),
2802
frozenset((token_hour, token_minute,
2804
token_day = Token(re.compile(r"(\d+)D"),
2805
datetime.timedelta(days=1),
2806
frozenset((token_time, token_end)))
2807
token_month = Token(re.compile(r"(\d+)M"),
2808
datetime.timedelta(weeks=4),
2809
frozenset((token_day, token_end)))
2810
token_year = Token(re.compile(r"(\d+)Y"),
2811
datetime.timedelta(weeks=52),
2812
frozenset((token_month, token_end)))
2813
token_week = Token(re.compile(r"(\d+)W"),
2814
datetime.timedelta(weeks=1),
2815
frozenset((token_end, )))
2816
token_duration = Token(re.compile(r"P"), None,
2817
frozenset((token_year, token_month,
2818
token_day, token_time,
2820
# Define starting values:
2822
value = datetime.timedelta()
2824
# Following valid tokens
2825
followers = frozenset((token_duration, ))
2826
# String left to parse
2828
# Loop until end token is found
2829
while found_token is not token_end:
2830
# Search for any currently valid tokens
2831
for token in followers:
2832
match = token.regexp.match(s)
2833
if match is not None:
2835
if token.value is not None:
2836
# Value found, parse digits
2837
factor = int(match.group(1), 10)
2838
# Add to value so far
2839
value += factor * token.value
2840
# Strip token from string
2841
s = token.regexp.sub("", s, 1)
2844
# Set valid next tokens
2845
followers = found_token.followers
2848
# No currently valid tokens were found
2849
raise ValueError("Invalid RFC 3339 duration: {!r}"
2855
1497
def string_to_delta(interval):
2856
1498
"""Parse a string and return a datetime.timedelta
2858
>>> string_to_delta('7d')
1500
>>> string_to_delta(u'7d')
2859
1501
datetime.timedelta(7)
2860
>>> string_to_delta('60s')
1502
>>> string_to_delta(u'60s')
2861
1503
datetime.timedelta(0, 60)
2862
>>> string_to_delta('60m')
1504
>>> string_to_delta(u'60m')
2863
1505
datetime.timedelta(0, 3600)
2864
>>> string_to_delta('24h')
1506
>>> string_to_delta(u'24h')
2865
1507
datetime.timedelta(1)
2866
>>> string_to_delta('1w')
1508
>>> string_to_delta(u'1w')
2867
1509
datetime.timedelta(7)
2868
>>> string_to_delta('5m 30s')
1510
>>> string_to_delta(u'5m 30s')
2869
1511
datetime.timedelta(0, 330)
2873
return rfc3339_duration_to_delta(interval)
2877
1513
timevalue = datetime.timedelta(0)
2878
1514
for s in interval.split():
1516
suffix = unicode(s[-1])
2881
1517
value = int(s[:-1])
2883
1519
delta = datetime.timedelta(value)
1520
elif suffix == u"s":
2885
1521
delta = datetime.timedelta(0, value)
1522
elif suffix == u"m":
2887
1523
delta = datetime.timedelta(0, 0, 0, 0, value)
1524
elif suffix == u"h":
2889
1525
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1526
elif suffix == u"w":
2891
1527
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2893
raise ValueError("Unknown suffix {!r}".format(suffix))
2894
except IndexError as e:
2895
raise ValueError(*(e.args))
1529
raise ValueError(u"Unknown suffix %r" % suffix)
1530
except (ValueError, IndexError), e:
1531
raise ValueError(e.message)
2896
1532
timevalue += delta
2897
1533
return timevalue
2900
def daemon(nochdir=False, noclose=False):
1536
def if_nametoindex(interface):
1537
"""Call the C function if_nametoindex(), or equivalent
1539
Note: This function cannot accept a unicode string."""
1540
global if_nametoindex
1542
if_nametoindex = (ctypes.cdll.LoadLibrary
1543
(ctypes.util.find_library(u"c"))
1545
except (OSError, AttributeError):
1546
logger.warning(u"Doing if_nametoindex the hard way")
1547
def if_nametoindex(interface):
1548
"Get an interface index the hard way, i.e. using fcntl()"
1549
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1550
with contextlib.closing(socket.socket()) as s:
1551
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1552
struct.pack(str(u"16s16x"),
1554
interface_index = struct.unpack(str(u"I"),
1556
return interface_index
1557
return if_nametoindex(interface)
1560
def daemon(nochdir = False, noclose = False):
2901
1561
"""See daemon(3). Standard BSD Unix function.
2903
1563
This should really exist as os.daemon, but it doesn't (yet)."""
2907
1567
if not nochdir:
2911
1571
if not noclose:
2912
1572
# Close all standard open file descriptors
2913
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1573
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2914
1574
if not stat.S_ISCHR(os.fstat(null).st_mode):
2915
1575
raise OSError(errno.ENODEV,
2916
"{} not a character device"
2917
.format(os.devnull))
1576
u"%s not a character device"
2918
1578
os.dup2(null, sys.stdin.fileno())
2919
1579
os.dup2(null, sys.stdout.fileno())
2920
1580
os.dup2(null, sys.stderr.fileno())
2927
1587
##################################################################
2928
1588
# Parsing of options, both command line and config file
2930
parser = argparse.ArgumentParser()
2931
parser.add_argument("-v", "--version", action="version",
2932
version="%(prog)s {}".format(version),
2933
help="show version number and exit")
2934
parser.add_argument("-i", "--interface", metavar="IF",
2935
help="Bind to interface IF")
2936
parser.add_argument("-a", "--address",
2937
help="Address to listen for requests on")
2938
parser.add_argument("-p", "--port", type=int,
2939
help="Port number to receive requests on")
2940
parser.add_argument("--check", action="store_true",
2941
help="Run self-test")
2942
parser.add_argument("--debug", action="store_true",
2943
help="Debug mode; run in foreground and log"
2944
" to terminal", default=None)
2945
parser.add_argument("--debuglevel", metavar="LEVEL",
2946
help="Debug level for stdout output")
2947
parser.add_argument("--priority", help="GnuTLS"
2948
" priority string (see GnuTLS documentation)")
2949
parser.add_argument("--servicename",
2950
metavar="NAME", help="Zeroconf service name")
2951
parser.add_argument("--configdir",
2952
default="/etc/mandos", metavar="DIR",
2953
help="Directory to search for configuration"
2955
parser.add_argument("--no-dbus", action="store_false",
2956
dest="use_dbus", help="Do not provide D-Bus"
2957
" system bus interface", default=None)
2958
parser.add_argument("--no-ipv6", action="store_false",
2959
dest="use_ipv6", help="Do not use IPv6",
2961
parser.add_argument("--no-restore", action="store_false",
2962
dest="restore", help="Do not restore stored"
2963
" state", default=None)
2964
parser.add_argument("--socket", type=int,
2965
help="Specify a file descriptor to a network"
2966
" socket to use instead of creating one")
2967
parser.add_argument("--statedir", metavar="DIR",
2968
help="Directory to save/restore state in")
2969
parser.add_argument("--foreground", action="store_true",
2970
help="Run in foreground", default=None)
2971
parser.add_argument("--no-zeroconf", action="store_false",
2972
dest="zeroconf", help="Do not use Zeroconf",
2975
options = parser.parse_args()
1590
parser = optparse.OptionParser(version = "%%prog %s" % version)
1591
parser.add_option("-i", u"--interface", type=u"string",
1592
metavar="IF", help=u"Bind to interface IF")
1593
parser.add_option("-a", u"--address", type=u"string",
1594
help=u"Address to listen for requests on")
1595
parser.add_option("-p", u"--port", type=u"int",
1596
help=u"Port number to receive requests on")
1597
parser.add_option("--check", action=u"store_true",
1598
help=u"Run self-test")
1599
parser.add_option("--debug", action=u"store_true",
1600
help=u"Debug mode; run in foreground and log to"
1602
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1603
u" priority string (see GnuTLS documentation)")
1604
parser.add_option("--servicename", type=u"string",
1605
metavar=u"NAME", help=u"Zeroconf service name")
1606
parser.add_option("--configdir", type=u"string",
1607
default=u"/etc/mandos", metavar=u"DIR",
1608
help=u"Directory to search for configuration"
1610
parser.add_option("--no-dbus", action=u"store_false",
1611
dest=u"use_dbus", help=u"Do not provide D-Bus"
1612
u" system bus interface")
1613
parser.add_option("--no-ipv6", action=u"store_false",
1614
dest=u"use_ipv6", help=u"Do not use IPv6")
1615
options = parser.parse_args()[0]
2977
1617
if options.check:
2979
fail_count, test_count = doctest.testmod()
2980
sys.exit(os.EX_OK if fail_count == 0 else 1)
2982
1622
# Default values for config file for server-global settings
2983
if gnutls.has_rawpk:
2984
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2985
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2987
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2988
":+SIGN-DSA-SHA256")
2989
server_defaults = {"interface": "",
2993
"priority": priority,
2994
"servicename": "Mandos",
3000
"statedir": "/var/lib/mandos",
3001
"foreground": "False",
1623
server_defaults = { u"interface": u"",
1628
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1629
u"servicename": u"Mandos",
1630
u"use_dbus": u"True",
1631
u"use_ipv6": u"True",
3006
1634
# Parse config file for server-global settings
3007
1635
server_config = configparser.SafeConfigParser(server_defaults)
3008
1636
del server_defaults
3009
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1637
server_config.read(os.path.join(options.configdir,
3010
1639
# Convert the SafeConfigParser object to a dict
3011
1640
server_settings = server_config.defaults()
3012
1641
# Use the appropriate methods on the non-string config options
3013
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3014
"foreground", "zeroconf"):
3015
server_settings[option] = server_config.getboolean("DEFAULT",
1642
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1643
server_settings[option] = server_config.getboolean(u"DEFAULT",
3017
1645
if server_settings["port"]:
3018
server_settings["port"] = server_config.getint("DEFAULT",
3020
if server_settings["socket"]:
3021
server_settings["socket"] = server_config.getint("DEFAULT",
3023
# Later, stdin will, and stdout and stderr might, be dup'ed
3024
# over with an opened os.devnull. But we don't want this to
3025
# happen with a supplied network socket.
3026
if 0 <= server_settings["socket"] <= 2:
3027
server_settings["socket"] = os.dup(server_settings
1646
server_settings["port"] = server_config.getint(u"DEFAULT",
3029
1648
del server_config
3031
1650
# Override the settings from the config file with command line
3032
1651
# options, if set.
3033
for option in ("interface", "address", "port", "debug",
3034
"priority", "servicename", "configdir", "use_dbus",
3035
"use_ipv6", "debuglevel", "restore", "statedir",
3036
"socket", "foreground", "zeroconf"):
1652
for option in (u"interface", u"address", u"port", u"debug",
1653
u"priority", u"servicename", u"configdir",
1654
u"use_dbus", u"use_ipv6"):
3037
1655
value = getattr(options, option)
3038
1656
if value is not None:
3039
1657
server_settings[option] = value
3041
1659
# Force all strings to be unicode
3042
1660
for option in server_settings.keys():
3043
if isinstance(server_settings[option], bytes):
3044
server_settings[option] = (server_settings[option]
3046
# Force all boolean options to be boolean
3047
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3048
"foreground", "zeroconf"):
3049
server_settings[option] = bool(server_settings[option])
3050
# Debug implies foreground
3051
if server_settings["debug"]:
3052
server_settings["foreground"] = True
1661
if type(server_settings[option]) is str:
1662
server_settings[option] = unicode(server_settings[option])
3053
1663
# Now we have our good server settings in "server_settings"
3055
1665
##################################################################
3057
if (not server_settings["zeroconf"]
3058
and not (server_settings["port"]
3059
or server_settings["socket"] != "")):
3060
parser.error("Needs port or socket to work without Zeroconf")
3062
1667
# For convenience
3063
debug = server_settings["debug"]
3064
debuglevel = server_settings["debuglevel"]
3065
use_dbus = server_settings["use_dbus"]
3066
use_ipv6 = server_settings["use_ipv6"]
3067
stored_state_path = os.path.join(server_settings["statedir"],
3069
foreground = server_settings["foreground"]
3070
zeroconf = server_settings["zeroconf"]
3073
initlogger(debug, logging.DEBUG)
3078
level = getattr(logging, debuglevel.upper())
3079
initlogger(debug, level)
3081
if server_settings["servicename"] != "Mandos":
3082
syslogger.setFormatter(
3083
logging.Formatter('Mandos ({}) [%(process)d]:'
3084
' %(levelname)s: %(message)s'.format(
3085
server_settings["servicename"])))
1668
debug = server_settings[u"debug"]
1669
use_dbus = server_settings[u"use_dbus"]
1670
use_ipv6 = server_settings[u"use_ipv6"]
1673
syslogger.setLevel(logging.WARNING)
1674
console.setLevel(logging.WARNING)
1676
if server_settings[u"servicename"] != u"Mandos":
1677
syslogger.setFormatter(logging.Formatter
1678
(u'Mandos (%s) [%%(process)d]:'
1679
u' %%(levelname)s: %%(message)s'
1680
% server_settings[u"servicename"]))
3087
1682
# Parse config file with clients
3088
client_config = configparser.SafeConfigParser(Client
3090
client_config.read(os.path.join(server_settings["configdir"],
1683
client_defaults = { u"timeout": u"1h",
1685
u"checker": u"fping -q -- %%(host)s",
1687
u"approved_delay": u"5m",
1688
u"approved_duration": u"1s",
1690
client_config = configparser.SafeConfigParser(client_defaults)
1691
client_config.read(os.path.join(server_settings[u"configdir"],
3093
1694
global mandos_dbus_service
3094
1695
mandos_dbus_service = None
3097
if server_settings["socket"] != "":
3098
socketfd = server_settings["socket"]
3099
tcp_server = MandosServer(
3100
(server_settings["address"], server_settings["port"]),
3102
interface=(server_settings["interface"] or None),
3104
gnutls_priority=server_settings["priority"],
3108
pidfilename = "/run/mandos.pid"
3109
if not os.path.isdir("/run/."):
3110
pidfilename = "/var/run/mandos.pid"
3113
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3114
except IOError as e:
3115
logger.error("Could not open file %r", pidfilename,
3118
for name, group in (("_mandos", "_mandos"),
3119
("mandos", "mandos"),
3120
("nobody", "nogroup")):
3122
uid = pwd.getpwnam(name).pw_uid
3123
gid = pwd.getpwnam(group).pw_gid
1697
tcp_server = MandosServer((server_settings[u"address"],
1698
server_settings[u"port"]),
1700
interface=server_settings[u"interface"],
1703
server_settings[u"priority"],
1705
pidfilename = u"/var/run/mandos.pid"
1707
pidfile = open(pidfilename, u"w")
1709
logger.error(u"Could not open file %r", pidfilename)
1712
uid = pwd.getpwnam(u"_mandos").pw_uid
1713
gid = pwd.getpwnam(u"_mandos").pw_gid
1716
uid = pwd.getpwnam(u"mandos").pw_uid
1717
gid = pwd.getpwnam(u"mandos").pw_gid
3125
1718
except KeyError:
1720
uid = pwd.getpwnam(u"nobody").pw_uid
1721
gid = pwd.getpwnam(u"nobody").pw_gid
3134
logger.debug("Did setuid/setgid to {}:{}".format(uid,
3136
except OSError as error:
3137
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3138
.format(uid, gid, os.strerror(error.errno)))
3139
if error.errno != errno.EPERM:
1728
except OSError, error:
1729
if error[0] != errno.EPERM:
1732
# Enable all possible GnuTLS debugging
3143
# Enable all possible GnuTLS debugging
3145
1734
# "Use a log level over 10 to enable all debugging options."
3146
1735
# - GnuTLS manual
3147
gnutls.global_set_log_level(11)
1736
gnutls.library.functions.gnutls_global_set_log_level(11)
1738
@gnutls.library.types.gnutls_log_func
3150
1739
def debug_gnutls(level, string):
3151
logger.debug("GnuTLS: %s", string[:-1])
3153
gnutls.global_set_log_function(debug_gnutls)
3155
# Redirect stdin so all checkers get /dev/null
3156
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3157
os.dup2(null, sys.stdin.fileno())
3161
# Need to fork before connecting to D-Bus
3163
# Close all input and output, do double fork, etc.
3166
# multiprocessing will use threads, so before we use GLib we need
3167
# to inform GLib that threads will be used.
1740
logger.debug(u"GnuTLS: %s", string[:-1])
1742
(gnutls.library.functions
1743
.gnutls_global_set_log_function(debug_gnutls))
3170
1745
global main_loop
3171
1746
# From the Avahi example code
3172
DBusGMainLoop(set_as_default=True)
3173
main_loop = GLib.MainLoop()
1747
DBusGMainLoop(set_as_default=True )
1748
main_loop = gobject.MainLoop()
3174
1749
bus = dbus.SystemBus()
3175
1750
# End of Avahi example code
3178
bus_name = dbus.service.BusName("se.recompile.Mandos",
3181
old_bus_name = dbus.service.BusName(
3182
"se.bsnet.fukt.Mandos", bus,
3184
except dbus.exceptions.DBusException as e:
3185
logger.error("Disabling D-Bus:", exc_info=e)
1753
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1754
bus, do_not_queue=True)
1755
except dbus.exceptions.NameExistsException, e:
1756
logger.error(unicode(e) + u", disabling D-Bus")
3186
1757
use_dbus = False
3187
server_settings["use_dbus"] = False
1758
server_settings[u"use_dbus"] = False
3188
1759
tcp_server.use_dbus = False
3190
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3191
service = AvahiServiceToSyslog(
3192
name=server_settings["servicename"],
3193
servicetype="_mandos._tcp",
3196
if server_settings["interface"]:
3197
service.interface = if_nametoindex(
3198
server_settings["interface"].encode("utf-8"))
3200
global multiprocessing_manager
3201
multiprocessing_manager = multiprocessing.Manager()
1760
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1761
service = AvahiService(name = server_settings[u"servicename"],
1762
servicetype = u"_mandos._tcp",
1763
protocol = protocol, bus = bus)
1764
if server_settings["interface"]:
1765
service.interface = (if_nametoindex
1766
(str(server_settings[u"interface"])))
3203
1768
client_class = Client
3205
client_class = functools.partial(ClientDBus, bus=bus)
3207
client_settings = Client.config_parser(client_config)
3208
old_client_settings = {}
3211
# This is used to redirect stdout and stderr for checker processes
3213
wnull = open(os.devnull, "w") # A writable /dev/null
3214
# Only used if server is running in foreground but not in debug
3216
if debug or not foreground:
3219
# Get client data and settings from last running state.
3220
if server_settings["restore"]:
3222
with open(stored_state_path, "rb") as stored_state:
3223
if sys.version_info.major == 2:
3224
clients_data, old_client_settings = pickle.load(
3227
bytes_clients_data, bytes_old_client_settings = (
3228
pickle.load(stored_state, encoding="bytes"))
3229
# Fix bytes to strings
3232
clients_data = {(key.decode("utf-8")
3233
if isinstance(key, bytes)
3236
bytes_clients_data.items()}
3237
del bytes_clients_data
3238
for key in clients_data:
3239
value = {(k.decode("utf-8")
3240
if isinstance(k, bytes) else k): v
3242
clients_data[key].items()}
3243
clients_data[key] = value
3245
value["client_structure"] = [
3247
if isinstance(s, bytes)
3249
value["client_structure"]]
3251
for k in ("name", "host"):
3252
if isinstance(value[k], bytes):
3253
value[k] = value[k].decode("utf-8")
3254
if not value.has_key("key_id"):
3255
value["key_id"] = ""
3256
elif not value.has_key("fingerprint"):
3257
value["fingerprint"] = ""
3258
# old_client_settings
3260
old_client_settings = {
3261
(key.decode("utf-8")
3262
if isinstance(key, bytes)
3265
bytes_old_client_settings.items()}
3266
del bytes_old_client_settings
3268
for value in old_client_settings.values():
3269
if isinstance(value["host"], bytes):
3270
value["host"] = (value["host"]
3272
os.remove(stored_state_path)
3273
except IOError as e:
3274
if e.errno == errno.ENOENT:
3275
logger.warning("Could not load persistent state:"
3276
" {}".format(os.strerror(e.errno)))
3278
logger.critical("Could not load persistent state:",
3281
except EOFError as e:
3282
logger.warning("Could not load persistent state: "
3286
with PGPEngine() as pgp:
3287
for client_name, client in clients_data.items():
3288
# Skip removed clients
3289
if client_name not in client_settings:
3292
# Decide which value to use after restoring saved state.
3293
# We have three different values: Old config file,
3294
# new config file, and saved state.
3295
# New config value takes precedence if it differs from old
3296
# config value, otherwise use saved state.
3297
for name, value in client_settings[client_name].items():
3299
# For each value in new config, check if it
3300
# differs from the old config value (Except for
3301
# the "secret" attribute)
3302
if (name != "secret"
3304
old_client_settings[client_name][name])):
3305
client[name] = value
3309
# Clients who has passed its expire date can still be
3310
# enabled if its last checker was successful. A Client
3311
# whose checker succeeded before we stored its state is
3312
# assumed to have successfully run all checkers during
3314
if client["enabled"]:
3315
if datetime.datetime.utcnow() >= client["expires"]:
3316
if not client["last_checked_ok"]:
3318
"disabling client {} - Client never "
3319
"performed a successful checker".format(
3321
client["enabled"] = False
3322
elif client["last_checker_status"] != 0:
3324
"disabling client {} - Client last"
3325
" checker failed with error code"
3328
client["last_checker_status"]))
3329
client["enabled"] = False
3331
client["expires"] = (
3332
datetime.datetime.utcnow()
3333
+ client["timeout"])
3334
logger.debug("Last checker succeeded,"
3335
" keeping {} enabled".format(
1770
client_class = functools.partial(ClientDBus, bus = bus)
1771
def client_config_items(config, section):
1772
special_settings = {
1773
"approved_by_default":
1774
lambda: config.getboolean(section,
1775
"approved_by_default"),
1777
for name, value in config.items(section):
3338
client["secret"] = pgp.decrypt(
3339
client["encrypted_secret"],
3340
client_settings[client_name]["secret"])
3342
# If decryption fails, we use secret from new settings
3343
logger.debug("Failed to decrypt {} old secret".format(
3345
client["secret"] = (client_settings[client_name]
3348
# Add/remove clients based on new changes made to config
3349
for client_name in (set(old_client_settings)
3350
- set(client_settings)):
3351
del clients_data[client_name]
3352
for client_name in (set(client_settings)
3353
- set(old_client_settings)):
3354
clients_data[client_name] = client_settings[client_name]
3356
# Create all client objects
3357
for client_name, client in clients_data.items():
3358
tcp_server.clients[client_name] = client_class(
3361
server_settings=server_settings)
1779
yield (name, special_settings[name]())
1783
tcp_server.clients.update(set(
1784
client_class(name = section,
1785
config= dict(client_config_items(
1786
client_config, section)))
1787
for section in client_config.sections()))
3363
1788
if not tcp_server.clients:
3364
logger.warning("No clients defined")
3367
if pidfile is not None:
1789
logger.warning(u"No clients defined")
1792
# Redirect stdin so all checkers get /dev/null
1793
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1794
os.dup2(null, sys.stdin.fileno())
1798
# No console logging
1799
logger.removeHandler(console)
1800
# Close all input and output, do double fork, etc.
3368
1805
pid = os.getpid()
3371
print(pid, file=pidfile)
3373
logger.error("Could not write to file %r with PID %d",
1806
pidfile.write(str(pid) + "\n")
3378
for termsig in (signal.SIGHUP, signal.SIGTERM):
3379
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3380
lambda: main_loop.quit() and False)
1809
logger.error(u"Could not write to file %r with PID %d",
1812
# "pidfile" was never created
1817
signal.signal(signal.SIGINT, signal.SIG_IGN)
1818
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1819
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3384
@alternate_dbus_interfaces(
3385
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3386
class MandosDBusService(DBusObjectWithObjectManager):
1822
class MandosDBusService(dbus.service.Object):
3387
1823
"""A D-Bus proxy object"""
3389
1824
def __init__(self):
3390
dbus.service.Object.__init__(self, bus, "/")
3392
_interface = "se.recompile.Mandos"
3394
@dbus.service.signal(_interface, signature="o")
1825
dbus.service.Object.__init__(self, bus, u"/")
1826
_interface = u"se.bsnet.fukt.Mandos"
1828
@dbus.service.signal(_interface, signature=u"o")
3395
1829
def ClientAdded(self, objpath):
3399
@dbus.service.signal(_interface, signature="ss")
3400
def ClientNotFound(self, key_id, address):
1833
@dbus.service.signal(_interface, signature=u"ss")
1834
def ClientNotFound(self, fingerprint, address):
3404
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3406
@dbus.service.signal(_interface, signature="os")
1838
@dbus.service.signal(_interface, signature=u"os")
3407
1839
def ClientRemoved(self, objpath, name):
3411
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3413
@dbus.service.method(_interface, out_signature="ao")
1843
@dbus.service.method(_interface, out_signature=u"ao")
3414
1844
def GetAllClients(self):
3416
return dbus.Array(c.dbus_object_path for c in
3417
tcp_server.clients.values())
3419
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
1846
return dbus.Array(c.dbus_object_path
1847
for c in tcp_server.clients)
3421
1849
@dbus.service.method(_interface,
3422
out_signature="a{oa{sv}}")
1850
out_signature=u"a{oa{sv}}")
3423
1851
def GetAllClientsWithProperties(self):
3425
1853
return dbus.Dictionary(
3426
{c.dbus_object_path: c.GetAll(
3427
"se.recompile.Mandos.Client")
3428
for c in tcp_server.clients.values()},
3431
@dbus.service.method(_interface, in_signature="o")
1854
((c.dbus_object_path, c.GetAll(u""))
1855
for c in tcp_server.clients),
1856
signature=u"oa{sv}")
1858
@dbus.service.method(_interface, in_signature=u"o")
3432
1859
def RemoveClient(self, object_path):
3434
for c in tcp_server.clients.values():
1861
for c in tcp_server.clients:
3435
1862
if c.dbus_object_path == object_path:
3436
del tcp_server.clients[c.name]
1863
tcp_server.clients.remove(c)
3437
1864
c.remove_from_connection()
3438
# Don't signal the disabling
1865
# Don't signal anything except ClientRemoved
3439
1866
c.disable(quiet=True)
3440
# Emit D-Bus signal for removal
3441
self.client_removed_signal(c)
1868
self.ClientRemoved(object_path, c.name)
3443
1870
raise KeyError(object_path)
3447
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3448
out_signature="a{oa{sa{sv}}}")
3449
def GetManagedObjects(self):
3451
return dbus.Dictionary(
3452
{client.dbus_object_path:
3454
{interface: client.GetAll(interface)
3456
client._get_all_interface_names()})
3457
for client in tcp_server.clients.values()})
3459
def client_added_signal(self, client):
3460
"""Send the new standard signal and the old signal"""
3462
# New standard signal
3463
self.InterfacesAdded(
3464
client.dbus_object_path,
3466
{interface: client.GetAll(interface)
3468
client._get_all_interface_names()}))
3470
self.ClientAdded(client.dbus_object_path)
3472
def client_removed_signal(self, client):
3473
"""Send the new standard signal and the old signal"""
3475
# New standard signal
3476
self.InterfacesRemoved(
3477
client.dbus_object_path,
3478
client._get_all_interface_names())
3480
self.ClientRemoved(client.dbus_object_path,
3483
1874
mandos_dbus_service = MandosDBusService()
3485
# Save modules to variables to exempt the modules from being
3486
# unloaded before the function registered with atexit() is run.
3487
mp = multiprocessing
3491
1877
"Cleanup function; run on exit"
3495
mp.active_children()
3497
if not (tcp_server.clients or client_settings):
3500
# Store client before exiting. Secrets are encrypted with key
3501
# based on what config file has. If config file is
3502
# removed/edited, old secret will thus be unrecovable.
3504
with PGPEngine() as pgp:
3505
for client in tcp_server.clients.values():
3506
key = client_settings[client.name]["secret"]
3507
client.encrypted_secret = pgp.encrypt(client.secret,
3511
# A list of attributes that can not be pickled
3513
exclude = {"bus", "changedstate", "secret",
3514
"checker", "server_settings"}
3515
for name, typ in inspect.getmembers(dbus.service
3519
client_dict["encrypted_secret"] = (client
3521
for attr in client.client_structure:
3522
if attr not in exclude:
3523
client_dict[attr] = getattr(client, attr)
3525
clients[client.name] = client_dict
3526
del client_settings[client.name]["secret"]
3529
with tempfile.NamedTemporaryFile(
3533
dir=os.path.dirname(stored_state_path),
3534
delete=False) as stored_state:
3535
pickle.dump((clients, client_settings), stored_state,
3537
tempname = stored_state.name
3538
os.rename(tempname, stored_state_path)
3539
except (IOError, OSError) as e:
3545
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3546
logger.warning("Could not save persistent state: {}"
3547
.format(os.strerror(e.errno)))
3549
logger.warning("Could not save persistent state:",
3553
# Delete all clients, and settings from config
3554
1880
while tcp_server.clients:
3555
name, client = tcp_server.clients.popitem()
1881
client = tcp_server.clients.pop()
3557
1883
client.remove_from_connection()
3558
# Don't signal the disabling
1884
client.disable_hook = None
1885
# Don't signal anything except ClientRemoved
3559
1886
client.disable(quiet=True)
3560
# Emit D-Bus signal for removal
3562
mandos_dbus_service.client_removed_signal(client)
3563
client_settings.clear()
1889
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
3565
1892
atexit.register(cleanup)
3567
for client in tcp_server.clients.values():
1894
for client in tcp_server.clients:
3569
# Emit D-Bus signal for adding
3570
mandos_dbus_service.client_added_signal(client)
3571
# Need to initiate checking of clients
3573
client.init_checker()
1897
mandos_dbus_service.ClientAdded(client.dbus_object_path)
3575
1900
tcp_server.enable()
3576
1901
tcp_server.server_activate()
3578
1903
# Find out what port we got
3580
service.port = tcp_server.socket.getsockname()[1]
1904
service.port = tcp_server.socket.getsockname()[1]
3582
logger.info("Now listening on address %r, port %d,"
3583
" flowinfo %d, scope_id %d",
3584
*tcp_server.socket.getsockname())
1906
logger.info(u"Now listening on address %r, port %d,"
1907
" flowinfo %d, scope_id %d"
1908
% tcp_server.socket.getsockname())
3586
logger.info("Now listening on address %r, port %d",
3587
*tcp_server.socket.getsockname())
3589
# service.interface = tcp_server.socket.getsockname()[3]
1910
logger.info(u"Now listening on address %r, port %d"
1911
% tcp_server.socket.getsockname())
1913
#service.interface = tcp_server.socket.getsockname()[3]
3593
# From the Avahi example code
3596
except dbus.exceptions.DBusException as error:
3597
logger.critical("D-Bus Exception", exc_info=error)
3600
# End of Avahi example code
3602
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3603
lambda *args, **kwargs:
3604
(tcp_server.handle_request
3605
(*args[2:], **kwargs) or True))
3607
logger.debug("Starting main loop")
1916
# From the Avahi example code
1919
except dbus.exceptions.DBusException, error:
1920
logger.critical(u"DBusException: %s", error)
1923
# End of Avahi example code
1925
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1926
lambda *args, **kwargs:
1927
(tcp_server.handle_request
1928
(*args[2:], **kwargs) or True))
1930
logger.debug(u"Starting main loop")
3608
1931
main_loop.run()
3609
except AvahiError as error:
3610
logger.critical("Avahi Error", exc_info=error)
1932
except AvahiError, error:
1933
logger.critical(u"AvahiError: %s", error)
3613
1936
except KeyboardInterrupt:
3615
print("", file=sys.stderr)
3616
logger.debug("Server received KeyboardInterrupt")
3617
logger.debug("Server exiting")
1939
logger.debug(u"Server received KeyboardInterrupt")
1940
logger.debug(u"Server exiting")
3618
1941
# Must run before the D-Bus bus name gets deregistered
3622
1944
if __name__ == '__main__':