419
191
dbus.UInt16(self.port),
420
192
avahi.string_array_to_txt_array(self.TXT))
421
193
self.group.Commit()
423
194
def entry_group_state_changed(self, state, error):
424
195
"""Derived from the Avahi example code"""
425
logger.debug("Avahi entry group state change: %i", state)
196
logger.debug(u"Avahi state change: %i", state)
427
198
if state == avahi.ENTRY_GROUP_ESTABLISHED:
428
logger.debug("Zeroconf service established.")
199
logger.debug(u"Zeroconf service established.")
429
200
elif state == avahi.ENTRY_GROUP_COLLISION:
430
logger.info("Zeroconf service name collision.")
201
logger.warning(u"Zeroconf service name collision.")
432
203
elif state == avahi.ENTRY_GROUP_FAILURE:
433
logger.critical("Avahi: Error in group state changed %s",
435
raise AvahiGroupError("State changed: {!s}".format(error))
204
logger.critical(u"Avahi: Error in group state changed %s",
206
raise AvahiGroupError(u"State changed: %s"
437
208
def cleanup(self):
438
209
"""Derived from the Avahi example code"""
439
210
if self.group is not None:
442
except (dbus.exceptions.UnknownMethodException,
443
dbus.exceptions.DBusException):
445
212
self.group = None
448
def server_state_changed(self, state, error=None):
213
def server_state_changed(self, state):
449
214
"""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)
215
if state == avahi.SERVER_COLLISION:
216
logger.error(u"Zeroconf server name collision")
464
218
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
220
def activate(self):
484
221
"""Derived from the Avahi example code"""
485
222
if self.server is None:
486
223
self.server = dbus.Interface(
487
224
self.bus.get_object(avahi.DBUS_NAME,
488
avahi.DBUS_PATH_SERVER,
489
follow_name_owner_changes=True),
225
avahi.DBUS_PATH_SERVER),
490
226
avahi.DBUS_INTERFACE_SERVER)
491
self.server.connect_to_signal("StateChanged",
492
self.server_state_changed)
227
self.server.connect_to_signal(u"StateChanged",
228
self.server_state_changed)
493
229
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
232
class Client(object):
829
233
"""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
236
name: string; from the config file, used in log messages and
238
fingerprint: string (40 or 32 hexadecimal digits); used to
239
uniquely identify the client
240
secret: bytestring; sent verbatim (over TLS) to client
241
host: string; available for use by the checker command
242
created: datetime.datetime(); (UTC) object creation
243
last_enabled: datetime.datetime(); (UTC)
245
last_checked_ok: datetime.datetime(); (UTC) or None
246
timeout: datetime.timedelta(); How long from last_checked_ok
247
until this client is disabled
248
interval: datetime.timedelta(); How often to start a new checker
249
disable_hook: If set, called by disable() as disable_hook(self)
835
250
checker: subprocess.Popen(); a running checker process used
836
251
to see if the client lives.
837
252
'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
253
checker_initiator_tag: a gobject event source tag, or None
254
disable_initiator_tag: - '' -
255
checker_callback_tag: - '' -
256
checker_command: string; External command which is run to check if
257
client lives. %() expansions are done at
841
258
runtime with vars(self) as dict, so that for
842
259
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
260
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()
261
approved_delay: datetime.timedelta(); Time to wait for approval
262
_approved: bool(); 'None' if not yet approved/disapproved
263
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):
267
def _timedelta_to_milliseconds(td):
268
"Convert a datetime.timedelta() to milliseconds"
269
return ((td.days * 24 * 60 * 60 * 1000)
270
+ (td.seconds * 1000)
271
+ (td.microseconds // 1000))
273
def timeout_milliseconds(self):
274
"Return the 'timeout' attribute in milliseconds"
275
return self._timedelta_to_milliseconds(self.timeout)
277
def interval_milliseconds(self):
278
"Return the 'interval' attribute in milliseconds"
279
return self._timedelta_to_milliseconds(self.interval)
281
def approved_delay_milliseconds(self):
282
return self._timedelta_to_milliseconds(self.approved_delay)
284
def __init__(self, name = None, disable_hook=None, config=None):
285
"""Note: the 'checker' key in 'config' sets the
286
'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()
291
logger.debug(u"Creating client %r", self.name)
292
# Uppercase and remove spaces from fingerprint for later
293
# comparison purposes with return value from the fingerprint()
295
self.fingerprint = (config[u"fingerprint"].upper()
297
logger.debug(u" Fingerprint: %s", self.fingerprint)
298
if u"secret" in config:
299
self.secret = config[u"secret"].decode(u"base64")
300
elif u"secfile" in config:
301
with open(os.path.expanduser(os.path.expandvars
302
(config[u"secfile"])),
304
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
306
#XXX Need to allow secret on demand!
307
raise TypeError(u"No secret or secfile for client %s"
309
self.host = config.get(u"host", u"")
310
self.created = datetime.datetime.utcnow()
312
self.last_enabled = None
313
self.last_checked_ok = None
314
self.timeout = string_to_delta(config[u"timeout"])
315
self.interval = string_to_delta(config[u"interval"])
316
self.disable_hook = disable_hook
973
317
self.checker = None
974
318
self.checker_initiator_tag = None
975
319
self.disable_initiator_tag = None
976
320
self.checker_callback_tag = None
321
self.checker_command = config[u"checker"]
977
322
self.current_checker_command = None
323
self.last_connect = None
979
324
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
325
self._approved = None
326
self.approved_by_default = config.get(u"approved_by_default",
328
self.approved_delay = string_to_delta(
329
config[u"approved_delay"])
330
self.approved_duration = string_to_delta(
331
config[u"approved_duration"])
332
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
993
334
def send_changedstate(self):
994
with self.changedstate:
995
self.changedstate.notify_all()
335
self.changedstate.acquire()
336
self.changedstate.notify_all()
337
self.changedstate.release()
997
339
def enable(self):
998
340
"""Start this client's checker and timeout hooks"""
999
if getattr(self, "enabled", False):
341
if getattr(self, u"enabled", False):
1000
342
# Already enabled
1002
self.expires = datetime.datetime.utcnow() + self.timeout
344
self.send_changedstate()
1004
345
self.last_enabled = datetime.datetime.utcnow()
1006
self.send_changedstate()
346
# Schedule a new checker to be started an 'interval' from now,
347
# and every interval from then on.
348
self.checker_initiator_tag = (gobject.timeout_add
349
(self.interval_milliseconds(),
351
# Schedule a disable() when 'timeout' has passed
352
self.disable_initiator_tag = (gobject.timeout_add
353
(self.timeout_milliseconds(),
356
# Also start a new checker *right now*.
1008
359
def disable(self, quiet=True):
1009
360
"""Disable this client."""
1010
361
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)
364
self.send_changedstate()
366
logger.info(u"Disabling client %s", self.name)
367
if getattr(self, u"disable_initiator_tag", False):
368
gobject.source_remove(self.disable_initiator_tag)
1016
369
self.disable_initiator_tag = None
1018
if getattr(self, "checker_initiator_tag", None) is not None:
1019
GLib.source_remove(self.checker_initiator_tag)
370
if getattr(self, u"checker_initiator_tag", False):
371
gobject.source_remove(self.checker_initiator_tag)
1020
372
self.checker_initiator_tag = None
1021
373
self.stop_checker()
374
if self.disable_hook:
375
self.disable_hook(self)
1022
376
self.enabled = False
1024
self.send_changedstate()
1025
# Do not run this again if called by a GLib.timeout_add
377
# Do not run this again if called by a gobject.timeout_add
1028
380
def __del__(self):
381
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,
384
def checker_callback(self, pid, condition, command):
1049
385
"""The checker has completed, so take appropriate actions."""
1050
386
self.checker_callback_tag = None
1051
387
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",
388
if os.WIFEXITED(condition):
389
exitstatus = os.WEXITSTATUS(condition)
391
logger.info(u"Checker for %(name)s succeeded",
1062
393
self.checked_ok()
1064
logger.info("Checker for %(name)s failed", vars(self))
395
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?",
398
logger.warning(u"Checker for %(name)s crashed?",
1072
401
def checked_ok(self):
1073
"""Assert that the client has been seen, alive and well."""
402
"""Bump up the timeout for this client.
404
This should only be called when the client has been seen,
1074
407
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()
408
gobject.source_remove(self.disable_initiator_tag)
409
self.disable_initiator_tag = (gobject.timeout_add
410
(self.timeout_milliseconds(),
1094
413
def start_checker(self):
1095
414
"""Start a new checker subprocess if one is not running.
1097
416
If a checker already exists, leave it running and do
1099
418
# 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
419
# did that, then if a checker (for some reason) started
420
# running slowly and taking more than 'interval' time, the
421
# client would inevitably timeout, since no checker would get
422
# a chance to run to completion. If we instead leave running
1104
423
# checkers alone, the checker would have to take more time
1105
424
# 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")
427
# If a checker exists, make sure it is not a zombie
429
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
430
except (AttributeError, OSError), error:
431
if (isinstance(error, OSError)
432
and error.errno != errno.ECHILD):
436
logger.warning(u"Checker was a zombie")
437
gobject.source_remove(self.checker_callback_tag)
438
self.checker_callback(pid, status,
439
self.current_checker_command)
1112
440
# Start a new checker if needed
1113
441
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
443
# In case checker_command has exactly one % operator
444
command = self.checker_command % self.host
446
# Escape attributes for the shell
447
escaped_attrs = dict((key,
448
re.escape(unicode(str(val),
452
vars(self).iteritems())
454
command = self.checker_command % escaped_attrs
455
except TypeError, error:
456
logger.error(u'Could not format string "%s":'
457
u' %s', self.checker_command, error)
458
return True # Try again later
1125
459
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
461
logger.info(u"Starting checker %r for %s",
463
# We don't need to redirect stdout and stderr, since
464
# in normal mode, that is already done by daemon(),
465
# and in debug mode we don't want to. (Stdin is
466
# always replaced by /dev/null.)
467
self.checker = subprocess.Popen(command,
469
shell=True, cwd=u"/")
470
self.checker_callback_tag = (gobject.child_watch_add
472
self.checker_callback,
474
# The checker may have completed before the gobject
475
# watch was added. Check for this.
476
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
478
gobject.source_remove(self.checker_callback_tag)
479
self.checker_callback(pid, status, command)
480
except OSError, error:
481
logger.error(u"Failed to start subprocess: %s",
483
# Re-run this periodically if run by gobject.timeout_add
1154
486
def stop_checker(self):
1155
487
"""Force the checker process, if any, to stop."""
1156
488
if self.checker_callback_tag:
1157
GLib.source_remove(self.checker_callback_tag)
489
gobject.source_remove(self.checker_callback_tag)
1158
490
self.checker_callback_tag = None
1159
if getattr(self, "checker", None) is None:
491
if getattr(self, u"checker", None) is None:
1161
logger.debug("Stopping checker for %(name)s", vars(self))
1162
self.checker.terminate()
493
logger.debug(u"Stopping checker for %(name)s", vars(self))
495
os.kill(self.checker.pid, signal.SIGTERM)
497
#if self.checker.poll() is None:
498
# os.kill(self.checker.pid, signal.SIGKILL)
499
except OSError, error:
500
if error.errno != errno.ESRCH: # No such process
1163
502
self.checker = None
1166
def dbus_service_property(dbus_interface,
504
def dbus_service_property(dbus_interface, signature=u"v",
505
access=u"readwrite", byte_arrays=False):
1170
506
"""Decorators for marking methods of a DBusObjectWithProperties to
1171
507
become properties on the D-Bus.
1173
509
The decorated method will be called with no arguments by "Get"
1174
510
and with one argument by "Set".
1176
512
The parameters, where they are supported, are the same as
1177
513
dbus.service.method, except there is only "signature", since the
1178
514
type from Get() and the type sent to Set() is the same.
1180
516
# Encoding deeply encoded byte arrays is not supported yet by the
1181
517
# "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))
518
if byte_arrays and signature != u"ay":
519
raise ValueError(u"Byte arrays not supported for non-'ay'"
520
u" signature %r" % signature)
1186
521
def decorator(func):
1187
522
func._dbus_is_property = True
1188
523
func._dbus_interface = dbus_interface
1189
524
func._dbus_signature = signature
1190
525
func._dbus_access = access
1191
526
func._dbus_name = func.__name__
1192
if func._dbus_name.endswith("_dbus_property"):
527
if func._dbus_name.endswith(u"_dbus_property"):
1193
528
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
529
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
1240
531
return decorator
1243
534
class DBusPropertyException(dbus.exceptions.DBusException):
1244
535
"""A base class for D-Bus property-related exceptions
537
def __unicode__(self):
538
return unicode(str(self))
1249
541
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):
553
class DBusObjectWithProperties(dbus.service.Object):
1351
554
"""A D-Bus object with properties.
1353
556
Classes inheriting from this can use the dbus_service_property
1354
557
decorator to expose methods as D-Bus properties. It exposes the
1355
558
standard Get(), Set(), and GetAll() methods on the D-Bus.
562
def _is_dbus_property(obj):
563
return getattr(obj, u"_dbus_is_property", False)
565
def _get_all_dbus_properties(self):
566
"""Returns a generator of (name, attribute) pairs
568
return ((prop._dbus_name, prop)
570
inspect.getmembers(self, self._is_dbus_property))
1358
572
def _get_dbus_property(self, interface_name, property_name):
1359
573
"""Returns a bound method if one exists which is a D-Bus
1360
574
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)
576
for name in (property_name,
577
property_name + u"_dbus_property"):
578
prop = getattr(self, name, None)
580
or not self._is_dbus_property(prop)
581
or prop._dbus_name != property_name
582
or (interface_name and prop._dbus_interface
583
and interface_name != prop._dbus_interface)):
1369
586
# 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,
587
raise DBusPropertyNotFound(self.dbus_object_path + u":"
588
+ interface_name + u"."
591
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
1385
593
def Get(self, interface_name, property_name):
1386
594
"""Standard D-Bus property Get() method, see D-Bus standard.
1388
596
prop = self._get_dbus_property(interface_name, property_name)
1389
if prop._dbus_access == "write":
597
if prop._dbus_access == u"write":
1390
598
raise DBusPropertyAccessException(property_name)
1392
if not hasattr(value, "variant_level"):
600
if not hasattr(value, u"variant_level"):
1394
602
return type(value)(value, variant_level=value.variant_level+1)
1396
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
604
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
1397
605
def Set(self, interface_name, property_name, value):
1398
606
"""Standard D-Bus property Set() method, see D-Bus standard.
1400
608
prop = self._get_dbus_property(interface_name, property_name)
1401
if prop._dbus_access == "read":
609
if prop._dbus_access == u"read":
1402
610
raise DBusPropertyAccessException(property_name)
1403
if prop._dbus_get_args_options["byte_arrays"]:
611
if prop._dbus_get_args_options[u"byte_arrays"]:
1404
612
# The byte_arrays option is not supported yet on
1405
613
# 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)
614
if prop._dbus_signature != u"ay":
616
value = dbus.ByteArray(''.join(unichr(byte)
1414
@dbus.service.method(dbus.PROPERTIES_IFACE,
1416
out_signature="a{sv}")
620
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
621
out_signature=u"a{sv}")
1417
622
def GetAll(self, interface_name):
1418
623
"""Standard D-Bus property GetAll() method, see D-Bus
1421
626
Note: Will not include properties with access="write".
1424
for name, prop in self._get_all_dbus_things("property"):
629
for name, prop in self._get_all_dbus_properties():
1425
630
if (interface_name
1426
631
and interface_name != prop._dbus_interface):
1427
632
# Interface non-empty but did not match
1429
634
# Ignore write-only properties
1430
if prop._dbus_access == "write":
635
if prop._dbus_access == u"write":
1433
if not hasattr(value, "variant_level"):
1434
properties[name] = value
638
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
641
all[name] = type(value)(value, variant_level=
642
value.variant_level+1)
643
return dbus.Dictionary(all, signature=u"sv")
1448
645
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1450
647
path_keyword='object_path',
1451
648
connection_keyword='connection')
1452
649
def Introspect(self, object_path, connection):
1453
"""Overloading of standard D-Bus method.
1455
Inserts property tags and interface annotation tags.
650
"""Standard D-Bus method, overloaded to insert property tags.
1457
xmlstring = DBusObjectWithAnnotations.Introspect(self,
652
xmlstring = dbus.service.Object.Introspect(self, object_path,
1461
655
document = xml.dom.minidom.parseString(xmlstring)
1463
656
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)
657
e = document.createElement(u"property")
658
e.setAttribute(u"name", name)
659
e.setAttribute(u"type", prop._dbus_signature)
660
e.setAttribute(u"access", prop._dbus_access)
1470
for if_tag in document.getElementsByTagName("interface"):
662
for if_tag in document.getElementsByTagName(u"interface"):
1472
663
for tag in (make_tag(document, name, prop)
1474
in self._get_all_dbus_things("property")
665
in self._get_all_dbus_properties()
1475
666
if prop._dbus_interface
1476
== if_tag.getAttribute("name")):
667
== if_tag.getAttribute(u"name")):
1477
668
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
669
# Add the names to the return values for the
1495
670
# "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"})
671
if (if_tag.getAttribute(u"name")
672
== u"org.freedesktop.DBus.Properties"):
673
for cn in if_tag.getElementsByTagName(u"method"):
674
if cn.getAttribute(u"name") == u"Get":
675
for arg in cn.getElementsByTagName(u"arg"):
676
if (arg.getAttribute(u"direction")
678
arg.setAttribute(u"name", u"value")
679
elif cn.getAttribute(u"name") == u"GetAll":
680
for arg in cn.getElementsByTagName(u"arg"):
681
if (arg.getAttribute(u"direction")
683
arg.setAttribute(u"name", u"props")
684
xmlstring = document.toxml(u"utf-8")
686
except (AttributeError, xml.dom.DOMException,
687
xml.parsers.expat.ExpatError), error:
688
logger.error(u"Failed to override Introspection method",
1767
693
class ClientDBus(Client, DBusObjectWithProperties):
1768
694
"""A Client class using D-Bus
1771
697
dbus_object_path: dbus.ObjectPath
1772
698
bus: dbus.SystemBus()
1775
runtime_expansions = (Client.runtime_expansions
1776
+ ("dbus_object_path", ))
1778
_interface = "se.recompile.Mandos.Client"
1780
700
# dbus.service.Object doesn't use super(), so we can't either.
1782
def __init__(self, bus=None, *args, **kwargs):
702
def __init__(self, bus = None, *args, **kwargs):
1784
704
Client.__init__(self, *args, **kwargs)
1785
705
# 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)
707
self.dbus_object_path = (dbus.ObjectPath
709
+ self.name.replace(u".", u"_")))
1792
710
DBusObjectWithProperties.__init__(self, self.bus,
1793
711
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
714
def _datetime_to_dbus(dt, variant_level=0):
715
"""Convert a UTC datetime.datetime() to a D-Bus type."""
716
return dbus.String(dt.isoformat(),
717
variant_level=variant_level)
720
oldstate = getattr(self, u"enabled", False)
721
r = Client.enable(self)
722
if oldstate != self.enabled:
724
self.PropertyChanged(dbus.String(u"enabled"),
725
dbus.Boolean(True, variant_level=1))
726
self.PropertyChanged(
727
dbus.String(u"last_enabled"),
728
self._datetime_to_dbus(self.last_enabled,
732
def disable(self, quiet = False):
733
oldstate = getattr(self, u"enabled", False)
734
r = Client.disable(self, quiet=quiet)
735
if not quiet and oldstate != self.enabled:
737
self.PropertyChanged(dbus.String(u"enabled"),
738
dbus.Boolean(False, variant_level=1))
1876
741
def __del__(self, *args, **kwargs):
1878
743
self.remove_from_connection()
1879
744
except LookupError:
1881
if hasattr(DBusObjectWithProperties, "__del__"):
746
if hasattr(DBusObjectWithProperties, u"__del__"):
1882
747
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1883
748
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
750
def checker_callback(self, pid, condition, command,
752
self.checker_callback_tag = None
755
self.PropertyChanged(dbus.String(u"checker_running"),
756
dbus.Boolean(False, variant_level=1))
757
if os.WIFEXITED(condition):
758
exitstatus = os.WEXITSTATUS(condition)
1892
759
# Emit D-Bus signal
1893
760
self.CheckerCompleted(dbus.Int16(exitstatus),
1894
# This is specific to GNU libC
1895
dbus.Int64(exitstatus << 8),
761
dbus.Int64(condition),
1896
762
dbus.String(command))
1898
764
# Emit D-Bus signal
1899
765
self.CheckerCompleted(dbus.Int16(-1),
1901
# This is specific to GNU libC
1903
| self.last_checker_signal),
766
dbus.Int64(condition),
1904
767
dbus.String(command))
769
return Client.checker_callback(self, pid, condition, command,
772
def checked_ok(self, *args, **kwargs):
773
r = Client.checked_ok(self, *args, **kwargs)
775
self.PropertyChanged(
776
dbus.String(u"last_checked_ok"),
777
(self._datetime_to_dbus(self.last_checked_ok,
1907
781
def start_checker(self, *args, **kwargs):
1908
old_checker_pid = getattr(self.checker, "pid", None)
782
old_checker = self.checker
783
if self.checker is not None:
784
old_checker_pid = self.checker.pid
786
old_checker_pid = None
1909
787
r = Client.start_checker(self, *args, **kwargs)
1910
788
# Only if new checker process was started
1911
789
if (self.checker is not None
1912
790
and old_checker_pid != self.checker.pid):
1913
791
# Emit D-Bus signal
1914
792
self.CheckerStarted(self.current_checker_command)
793
self.PropertyChanged(
794
dbus.String(u"checker_running"),
795
dbus.Boolean(True, variant_level=1))
798
def stop_checker(self, *args, **kwargs):
799
old_checker = getattr(self, u"checker", None)
800
r = Client.stop_checker(self, *args, **kwargs)
801
if (old_checker is not None
802
and getattr(self, u"checker", None) is None):
803
self.PropertyChanged(dbus.String(u"checker_running"),
804
dbus.Boolean(False, variant_level=1))
1917
807
def _reset_approved(self):
1918
self.approved = None
808
self._approved = None
1921
811
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
812
self._approved = value
813
gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration, self._reset_approved))
815
def approved_pending(self):
816
return self.approvals_pending > 0
819
## D-Bus methods, signals & properties
820
_interface = u"se.bsnet.fukt.Mandos.Client"
1933
824
# CheckerCompleted - signal
1934
@dbus.service.signal(_interface, signature="nxs")
825
@dbus.service.signal(_interface, signature=u"nxs")
1935
826
def CheckerCompleted(self, exitcode, waitstatus, command):
1939
830
# CheckerStarted - signal
1940
@dbus.service.signal(_interface, signature="s")
831
@dbus.service.signal(_interface, signature=u"s")
1941
832
def CheckerStarted(self, command):
1945
836
# PropertyChanged - signal
1946
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1947
@dbus.service.signal(_interface, signature="sv")
837
@dbus.service.signal(_interface, signature=u"sv")
1948
838
def PropertyChanged(self, property, value):
1952
842
# GotSecret - signal
1953
843
@dbus.service.signal(_interface)
1954
844
def GotSecret(self):
1956
Is sent after a successful transfer of secret from the Mandos
1957
server to mandos-client
1961
848
# Rejected - signal
1962
@dbus.service.signal(_interface, signature="s")
849
@dbus.service.signal(_interface, signature=u"s")
1963
850
def Rejected(self, reason):
1967
854
# NeedApproval - signal
1968
@dbus.service.signal(_interface, signature="tb")
855
@dbus.service.signal(_interface, signature=u"db")
1969
856
def NeedApproval(self, timeout, default):
1971
return self.need_approval()
1975
862
# Approve - method
1976
@dbus.service.method(_interface, in_signature="b")
863
@dbus.service.method(_interface, in_signature=u"b")
1977
864
def Approve(self, value):
1978
865
self.approve(value)
1980
867
# CheckedOK - method
1981
868
@dbus.service.method(_interface)
1982
869
def CheckedOK(self):
870
return self.checked_ok()
1985
872
# Enable - method
1986
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1987
873
@dbus.service.method(_interface)
1988
874
def Enable(self):
1992
878
# StartChecker - method
1993
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1994
879
@dbus.service.method(_interface)
1995
880
def StartChecker(self):
1997
882
self.start_checker()
1999
884
# Disable - method
2000
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2001
885
@dbus.service.method(_interface)
2002
886
def Disable(self):
2006
890
# StopChecker - method
2007
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2008
891
@dbus.service.method(_interface)
2009
892
def StopChecker(self):
2010
893
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):
897
# approved_pending - property
898
@dbus_service_property(_interface, signature=u"b", access=u"read")
899
def approved_pending_dbus_property(self):
900
return dbus.Boolean(self.approved_pending())
902
# approved_by_default - property
903
@dbus_service_property(_interface, signature=u"b",
905
def approved_by_default_dbus_property(self):
906
return dbus.Boolean(self.approved_by_default)
908
# approved_delay - property
909
@dbus_service_property(_interface, signature=u"t",
911
def approved_delay_dbus_property(self):
912
return dbus.UInt64(self.approved_delay_milliseconds())
914
# approved_duration - property
915
@dbus_service_property(_interface, signature=u"t",
917
def approved_duration_dbus_property(self):
918
return dbus.UInt64(self._timedelta_to_milliseconds(
919
self.approved_duration))
922
@dbus_service_property(_interface, signature=u"s", access=u"read")
923
def name_dbus_property(self):
2053
924
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):
926
# fingerprint - property
927
@dbus_service_property(_interface, signature=u"s", access=u"read")
928
def fingerprint_dbus_property(self):
2067
929
return dbus.String(self.fingerprint)
2070
@dbus_service_property(_interface,
2073
def Host_dbus_property(self, value=None):
932
@dbus_service_property(_interface, signature=u"s",
934
def host_dbus_property(self, value=None):
2074
935
if value is None: # get
2075
936
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):
939
self.PropertyChanged(dbus.String(u"host"),
940
dbus.String(value, variant_level=1))
943
@dbus_service_property(_interface, signature=u"s", access=u"read")
944
def created_dbus_property(self):
945
return dbus.String(self._datetime_to_dbus(self.created))
947
# last_enabled - property
948
@dbus_service_property(_interface, signature=u"s", access=u"read")
949
def last_enabled_dbus_property(self):
950
if self.last_enabled is None:
951
return dbus.String(u"")
952
return dbus.String(self._datetime_to_dbus(self.last_enabled))
955
@dbus_service_property(_interface, signature=u"b",
957
def enabled_dbus_property(self, value=None):
2095
958
if value is None: # get
2096
959
return dbus.Boolean(self.enabled)
2102
# LastCheckedOK - property
2103
@dbus_service_property(_interface,
2106
def LastCheckedOK_dbus_property(self, value=None):
965
# last_checked_ok - property
966
@dbus_service_property(_interface, signature=u"s",
968
def last_checked_ok_dbus_property(self, value=None):
2107
969
if value is not None:
2108
970
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):
972
if self.last_checked_ok is None:
973
return dbus.String(u"")
974
return dbus.String(self._datetime_to_dbus(self
978
@dbus_service_property(_interface, signature=u"t",
980
def timeout_dbus_property(self, value=None):
2132
981
if value is None: # get
2133
return dbus.UInt64(self.timeout.total_seconds() * 1000)
2134
old_timeout = self.timeout
982
return dbus.UInt64(self.timeout_milliseconds())
2135
983
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)
985
self.PropertyChanged(dbus.String(u"timeout"),
986
dbus.UInt64(value, variant_level=1))
987
if getattr(self, u"disable_initiator_tag", None) is None:
990
gobject.source_remove(self.disable_initiator_tag)
991
self.disable_initiator_tag = None
993
_timedelta_to_milliseconds((self
999
# The timeout has passed
1002
self.disable_initiator_tag = (gobject.timeout_add
1003
(time_to_die, self.disable))
1005
# interval - property
1006
@dbus_service_property(_interface, signature=u"t",
1007
access=u"readwrite")
1008
def interval_dbus_property(self, value=None):
1009
if value is None: # get
1010
return dbus.UInt64(self.interval_milliseconds())
2169
1011
self.interval = datetime.timedelta(0, 0, 0, value)
2170
if getattr(self, "checker_initiator_tag", None) is None:
1013
self.PropertyChanged(dbus.String(u"interval"),
1014
dbus.UInt64(value, variant_level=1))
1015
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
1017
# Reschedule checker run
1018
gobject.source_remove(self.checker_initiator_tag)
1019
self.checker_initiator_tag = (gobject.timeout_add
1020
(value, self.start_checker))
1021
self.start_checker() # Start one now, too
2179
# Checker - property
2180
@dbus_service_property(_interface,
2183
def Checker_dbus_property(self, value=None):
1023
# checker - property
1024
@dbus_service_property(_interface, signature=u"s",
1025
access=u"readwrite")
1026
def checker_dbus_property(self, value=None):
2184
1027
if value is None: # get
2185
1028
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):
1029
self.checker_command = value
1031
self.PropertyChanged(dbus.String(u"checker"),
1032
dbus.String(self.checker_command,
1035
# checker_running - property
1036
@dbus_service_property(_interface, signature=u"b",
1037
access=u"readwrite")
1038
def checker_running_dbus_property(self, value=None):
2193
1039
if value is None: # get
2194
1040
return dbus.Boolean(self.checker is not None)
2196
1042
self.start_checker()
2198
1044
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)
1046
# object_path - property
1047
@dbus_service_property(_interface, signature=u"o", access=u"read")
1048
def object_path_dbus_property(self):
1049
return self.dbus_object_path # is already a dbus.ObjectPath
1052
@dbus_service_property(_interface, signature=u"ay",
1053
access=u"write", byte_arrays=True)
1054
def secret_dbus_property(self, value):
1055
self.secret = str(value)
2222
1060
class ProxyClient(object):
2223
def __init__(self, child_pipe, key_id, fpr, address):
1061
def __init__(self, child_pipe, fpr, address):
2224
1062
self._pipe = child_pipe
2225
self._pipe.send(('init', key_id, fpr, address))
1063
self._pipe.send(('init', fpr, address))
2226
1064
if not self._pipe.recv():
2227
raise KeyError(key_id or fpr)
2229
1067
def __getattribute__(self, name):
1068
if(name == '_pipe'):
2231
1069
return super(ProxyClient, self).__getattribute__(name)
2232
1070
self._pipe.send(('getattr', name))
2233
1071
data = self._pipe.recv()
2234
1072
if data[0] == 'data':
2236
1074
if data[0] == 'function':
2238
1075
def func(*args, **kwargs):
2239
1076
self._pipe.send(('funcall', name, args, kwargs))
2240
1077
return self._pipe.recv()[1]
2244
1080
def __setattr__(self, name, value):
1081
if(name == '_pipe'):
2246
1082
return super(ProxyClient, self).__setattr__(name, value)
2247
1083
self._pipe.send(('setattr', name, value))
2250
1086
class ClientHandler(socketserver.BaseRequestHandler, object):
2251
1087
"""A class to handle client connections.
2253
1089
Instantiated once for each connection to handle it.
2254
1090
Note: This will run in its own forked process."""
2256
1092
def handle(self):
2257
1093
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",
1094
logger.info(u"TCP connection from: %s",
1095
unicode(self.client_address))
1096
logger.debug(u"Pipe FD: %d",
2261
1097
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",
1099
session = (gnutls.connection
1100
.ClientSession(self.request,
1102
.X509Credentials()))
1104
# Note: gnutls.connection.X509Credentials is really a
1105
# generic GnuTLS certificate credentials object so long as
1106
# no X.509 keys are added to it. Therefore, we can use it
1107
# here despite using OpenPGP certificates.
1109
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1110
# u"+AES-256-CBC", u"+SHA1",
1111
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
2269
1113
# Use a fallback default, since this MUST be set.
2270
1114
priority = self.server.gnutls_priority
2271
1115
if priority is None:
2273
gnutls.priority_set_direct(session._c_object,
2274
priority.encode("utf-8"),
1116
priority = u"NORMAL"
1117
(gnutls.library.functions
1118
.gnutls_priority_set_direct(session._c_object,
2277
1121
# Start communication using the Mandos protocol
2278
1122
# Get protocol number
2279
1123
line = self.request.makefile().readline()
2280
logger.debug("Protocol version: %r", line)
1124
logger.debug(u"Protocol version: %r", line)
2282
1126
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)
1128
except (ValueError, IndexError, RuntimeError), error:
1129
logger.error(u"Unknown protocol version: %s", error)
2288
1132
# Start GnuTLS connection
2290
1134
session.handshake()
2291
except gnutls.Error as error:
2292
logger.warning("Handshake failed: %s", error)
1135
except gnutls.errors.GNUTLSError, error:
1136
logger.warning(u"Handshake failed: %s", error)
2293
1137
# Do not run session.bye() here: the session is not
2294
1138
# established. Just abandon the request.
2296
logger.debug("Handshake succeeded")
1140
logger.debug(u"Handshake succeeded")
2298
1142
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,
1145
fpr = self.fingerprint(self.peer_certificate
1147
except (TypeError, gnutls.errors.GNUTLSError), error:
1148
logger.warning(u"Bad certificate: %s", error)
1150
logger.debug(u"Fingerprint: %s", fpr)
1153
client = ProxyClient(child_pipe, fpr,
2322
1154
self.client_address)
2323
1155
except KeyError:
2326
if client.approval_delay:
2327
delay = client.approval_delay
1158
if client.approved_delay:
1159
delay = client.approved_delay
2328
1160
client.approvals_pending += 1
2329
1161
approval_required = True
2332
1164
if not client.enabled:
2333
logger.info("Client %s is disabled",
1165
logger.warning(u"Client %s is disabled",
2335
1167
if self.server.use_dbus:
2336
1168
# Emit D-Bus signal
2337
client.Rejected("Disabled")
1169
client.Rejected("Disabled")
2340
if client.approved or not client.approval_delay:
2341
# We are approved or approval is disabled
1172
if client._approved or not client.approved_delay:
1173
#We are approved or approval is disabled
2343
elif client.approved is None:
2344
logger.info("Client %s needs approval",
1175
elif client._approved is None:
1176
logger.info(u"Client %s need approval",
2346
1178
if self.server.use_dbus:
2347
1179
# Emit D-Bus signal
2348
1180
client.NeedApproval(
2349
client.approval_delay.total_seconds()
2350
* 1000, client.approved_by_default)
1181
client.approved_delay_milliseconds(),
1182
client.approved_by_default)
2352
logger.warning("Client %s was not approved",
1184
logger.warning(u"Client %s was not approved",
2354
1186
if self.server.use_dbus:
2355
1187
# Emit D-Bus signal
2356
client.Rejected("Denied")
1188
client.Rejected("Disapproved")
2359
# wait until timeout or approved
1191
#wait until timeout or approved
1192
#x = float(client._timedelta_to_milliseconds(delay))
2360
1193
time = datetime.datetime.now()
2361
1194
client.changedstate.acquire()
2362
client.changedstate.wait(delay.total_seconds())
1195
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
2363
1196
client.changedstate.release()
2364
1197
time2 = datetime.datetime.now()
2365
1198
if (time2 - time) >= delay:
2370
1203
if self.server.use_dbus:
2371
1204
# Emit D-Bus signal
2372
client.Rejected("Approval timed out")
1205
client.Rejected("Time out")
2377
1210
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)
1213
while sent_size < len(client.secret):
1214
# XXX handle session exception
1215
sent = session.send(client.secret[sent_size:])
1216
logger.debug(u"Sent: %d, remaining: %d",
1217
sent, len(client.secret)
1218
- (sent_size + sent))
1221
logger.info(u"Sending secret to %s", client.name)
1222
# bump the timeout as if seen
2389
1224
if self.server.use_dbus:
2390
1225
# Emit D-Bus signal
2391
1226
client.GotSecret()
2394
1229
if approval_required:
2395
1230
client.approvals_pending -= 1
2398
except gnutls.Error as error:
2399
logger.warning("GnuTLS bye failed",
2403
1234
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
1235
"Return the peer's OpenPGP certificate as a bytestring"
1236
# If not an OpenPGP certificate...
1237
if (gnutls.library.functions
1238
.gnutls_certificate_type_get(session._c_object)
1239
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1240
# ...do the normal thing
1241
return session.peer_certificate
2420
1242
list_size = ctypes.c_uint(1)
2421
cert_list = (gnutls.certificate_get_peers
1243
cert_list = (gnutls.library.functions
1244
.gnutls_certificate_get_peers
2422
1245
(session._c_object, ctypes.byref(list_size)))
2423
1246
if not bool(cert_list) and list_size.value != 0:
2424
raise gnutls.Error("error getting peer certificate")
1247
raise gnutls.errors.GNUTLSError(u"error getting peer"
2425
1249
if list_size.value == 0:
2427
1251
cert = cert_list[0]
2428
1252
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
1255
def fingerprint(openpgp):
2466
1256
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2467
1257
# 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)))
1258
datum = (gnutls.library.types
1259
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1262
ctypes.c_uint(len(openpgp))))
2472
1263
# New empty GnuTLS certificate
2473
crt = gnutls.openpgp_crt_t()
2474
gnutls.openpgp_crt_init(ctypes.byref(crt))
1264
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1265
(gnutls.library.functions
1266
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
2475
1267
# Import the OpenPGP public key into the certificate
2476
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2477
gnutls.OPENPGP_FMT_RAW)
1268
(gnutls.library.functions
1269
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1270
gnutls.library.constants
1271
.GNUTLS_OPENPGP_FMT_RAW))
2478
1272
# Verify the self signature in the key
2479
1273
crtverify = ctypes.c_uint()
2480
gnutls.openpgp_crt_verify_self(crt, 0,
2481
ctypes.byref(crtverify))
1274
(gnutls.library.functions
1275
.gnutls_openpgp_crt_verify_self(crt, 0,
1276
ctypes.byref(crtverify)))
2482
1277
if crtverify.value != 0:
2483
gnutls.openpgp_crt_deinit(crt)
2484
raise gnutls.CertificateSecurityError(code
1278
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1279
raise (gnutls.errors.CertificateSecurityError
2486
1281
# New buffer for the fingerprint
2487
1282
buf = ctypes.create_string_buffer(20)
2488
1283
buf_len = ctypes.c_size_t()
2489
1284
# Get the fingerprint from the certificate into the buffer
2490
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2491
ctypes.byref(buf_len))
1285
(gnutls.library.functions
1286
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1287
ctypes.byref(buf_len)))
2492
1288
# Deinit the certificate
2493
gnutls.openpgp_crt_deinit(crt)
1289
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
2494
1290
# Convert the buffer to a Python bytestring
2495
1291
fpr = ctypes.string_at(buf, buf_len.value)
2496
1292
# Convert the bytestring to hexadecimal notation
2497
hex_fpr = binascii.hexlify(fpr).upper()
1293
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
2501
1297
class MultiprocessingMixIn(object):
2502
1298
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2504
1299
def sub_process_main(self, request, address):
2506
1301
self.finish_request(request, address)
2508
1303
self.handle_error(request, address)
2509
1304
self.close_request(request)
2511
1306
def process_request(self, request, address):
2512
1307
"""Start a new process to process the request."""
2513
proc = multiprocessing.Process(target=self.sub_process_main,
2514
args=(request, address))
1308
multiprocessing.Process(target = self.sub_process_main,
1309
args = (request, address)).start()
2519
1311
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2520
1312
""" adds a pipe to the MixIn """
2522
1313
def process_request(self, request, client_address):
2523
1314
"""Overrides and wraps the original process_request().
2525
1316
This function creates a new pipe in self.pipe
2527
1318
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2529
proc = MultiprocessingMixIn.process_request(self, request,
1320
super(MultiprocessingMixInWithPipe,
1321
self).process_request(request, client_address)
2531
1322
self.child_pipe.close()
2532
self.add_pipe(parent_pipe, proc)
2534
def add_pipe(self, parent_pipe, proc):
1323
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,
1446
# error or the other end of multiprocessing.Pipe has closed
1447
if condition & gobject.IO_HUP or condition & gobject.IO_ERR:
2693
1450
# Read a request from the child
2694
1451
request = parent_pipe.recv()
1452
logger.debug(u"IPC request: %s", repr(request))
2695
1453
command = request[0]
2697
1455
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 == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2705
if key_id and c.key_id == key_id:
2708
if fpr and c.fingerprint == fpr:
1457
address = request[2]
1459
for c in self.clients:
1460
if c.fingerprint == fpr:
2712
logger.info("Client not found for key ID: %s, address"
2713
": %s", key_id or fpr, address)
1464
logger.warning(u"Client not found for fingerprint: %s, ad"
1465
u"dress: %s", fpr, address)
2714
1466
if self.use_dbus:
2715
1467
# Emit D-Bus signal
2716
mandos_dbus_service.ClientNotFound(key_id or fpr,
1468
mandos_dbus_service.ClientNotFound(fpr, address)
2718
1469
parent_pipe.send(False)
2722
parent_pipe.fileno(),
2723
GLib.IO_IN | GLib.IO_HUP,
2724
functools.partial(self.handle_ipc,
2725
parent_pipe=parent_pipe,
2727
client_object=client))
1472
gobject.io_add_watch(parent_pipe.fileno(),
1473
gobject.IO_IN | gobject.IO_HUP,
1474
functools.partial(self.handle_ipc,
1475
parent_pipe = parent_pipe,
1476
client_object = client))
2728
1477
parent_pipe.send(True)
2729
# remove the old hook in favor of the new above hook on
1478
# remove the old hook in favor of the new above hook on same fileno
2732
1480
if command == 'funcall':
2733
1481
funcname = request[1]
2734
1482
args = request[2]
2735
1483
kwargs = request[3]
2737
parent_pipe.send(('data', getattr(client_object,
1485
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
2741
1487
if command == 'getattr':
2742
1488
attrname = request[1]
2743
if isinstance(client_object.__getattribute__(attrname),
2744
collections.Callable):
2745
parent_pipe.send(('function', ))
1489
if callable(client_object.__getattribute__(attrname)):
1490
parent_pipe.send(('function',))
2748
'data', client_object.__getattribute__(attrname)))
1492
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
2750
1494
if command == 'setattr':
2751
1495
attrname = request[1]
2752
1496
value = request[2]
2753
1497
setattr(client_object, attrname, value)
2758
def rfc3339_duration_to_delta(duration):
2759
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2761
>>> rfc3339_duration_to_delta("P7D")
2762
datetime.timedelta(7)
2763
>>> rfc3339_duration_to_delta("PT60S")
2764
datetime.timedelta(0, 60)
2765
>>> rfc3339_duration_to_delta("PT60M")
2766
datetime.timedelta(0, 3600)
2767
>>> rfc3339_duration_to_delta("PT24H")
2768
datetime.timedelta(1)
2769
>>> rfc3339_duration_to_delta("P1W")
2770
datetime.timedelta(7)
2771
>>> rfc3339_duration_to_delta("PT5M30S")
2772
datetime.timedelta(0, 330)
2773
>>> rfc3339_duration_to_delta("P1DT3M20S")
2774
datetime.timedelta(1, 200)
2777
# Parsing an RFC 3339 duration with regular expressions is not
2778
# possible - there would have to be multiple places for the same
2779
# values, like seconds. The current code, while more esoteric, is
2780
# cleaner without depending on a parsing library. If Python had a
2781
# built-in library for parsing we would use it, but we'd like to
2782
# avoid excessive use of external libraries.
2784
# New type for defining tokens, syntax, and semantics all-in-one
2785
Token = collections.namedtuple("Token", (
2786
"regexp", # To match token; if "value" is not None, must have
2787
# a "group" containing digits
2788
"value", # datetime.timedelta or None
2789
"followers")) # Tokens valid after this token
2790
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2791
# the "duration" ABNF definition in RFC 3339, Appendix A.
2792
token_end = Token(re.compile(r"$"), None, frozenset())
2793
token_second = Token(re.compile(r"(\d+)S"),
2794
datetime.timedelta(seconds=1),
2795
frozenset((token_end, )))
2796
token_minute = Token(re.compile(r"(\d+)M"),
2797
datetime.timedelta(minutes=1),
2798
frozenset((token_second, token_end)))
2799
token_hour = Token(re.compile(r"(\d+)H"),
2800
datetime.timedelta(hours=1),
2801
frozenset((token_minute, token_end)))
2802
token_time = Token(re.compile(r"T"),
2804
frozenset((token_hour, token_minute,
2806
token_day = Token(re.compile(r"(\d+)D"),
2807
datetime.timedelta(days=1),
2808
frozenset((token_time, token_end)))
2809
token_month = Token(re.compile(r"(\d+)M"),
2810
datetime.timedelta(weeks=4),
2811
frozenset((token_day, token_end)))
2812
token_year = Token(re.compile(r"(\d+)Y"),
2813
datetime.timedelta(weeks=52),
2814
frozenset((token_month, token_end)))
2815
token_week = Token(re.compile(r"(\d+)W"),
2816
datetime.timedelta(weeks=1),
2817
frozenset((token_end, )))
2818
token_duration = Token(re.compile(r"P"), None,
2819
frozenset((token_year, token_month,
2820
token_day, token_time,
2822
# Define starting values:
2824
value = datetime.timedelta()
2826
# Following valid tokens
2827
followers = frozenset((token_duration, ))
2828
# String left to parse
2830
# Loop until end token is found
2831
while found_token is not token_end:
2832
# Search for any currently valid tokens
2833
for token in followers:
2834
match = token.regexp.match(s)
2835
if match is not None:
2837
if token.value is not None:
2838
# Value found, parse digits
2839
factor = int(match.group(1), 10)
2840
# Add to value so far
2841
value += factor * token.value
2842
# Strip token from string
2843
s = token.regexp.sub("", s, 1)
2846
# Set valid next tokens
2847
followers = found_token.followers
2850
# No currently valid tokens were found
2851
raise ValueError("Invalid RFC 3339 duration: {!r}"
2857
1502
def string_to_delta(interval):
2858
1503
"""Parse a string and return a datetime.timedelta
2860
>>> string_to_delta('7d')
1505
>>> string_to_delta(u'7d')
2861
1506
datetime.timedelta(7)
2862
>>> string_to_delta('60s')
1507
>>> string_to_delta(u'60s')
2863
1508
datetime.timedelta(0, 60)
2864
>>> string_to_delta('60m')
1509
>>> string_to_delta(u'60m')
2865
1510
datetime.timedelta(0, 3600)
2866
>>> string_to_delta('24h')
1511
>>> string_to_delta(u'24h')
2867
1512
datetime.timedelta(1)
2868
>>> string_to_delta('1w')
1513
>>> string_to_delta(u'1w')
2869
1514
datetime.timedelta(7)
2870
>>> string_to_delta('5m 30s')
1515
>>> string_to_delta(u'5m 30s')
2871
1516
datetime.timedelta(0, 330)
2875
return rfc3339_duration_to_delta(interval)
2879
1518
timevalue = datetime.timedelta(0)
2880
1519
for s in interval.split():
1521
suffix = unicode(s[-1])
2883
1522
value = int(s[:-1])
2885
1524
delta = datetime.timedelta(value)
1525
elif suffix == u"s":
2887
1526
delta = datetime.timedelta(0, value)
1527
elif suffix == u"m":
2889
1528
delta = datetime.timedelta(0, 0, 0, 0, value)
1529
elif suffix == u"h":
2891
1530
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1531
elif suffix == u"w":
2893
1532
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
2895
raise ValueError("Unknown suffix {!r}".format(suffix))
2896
except IndexError as e:
2897
raise ValueError(*(e.args))
1534
raise ValueError(u"Unknown suffix %r" % suffix)
1535
except (ValueError, IndexError), e:
1536
raise ValueError(e.message)
2898
1537
timevalue += delta
2899
1538
return timevalue
2902
def daemon(nochdir=False, noclose=False):
1541
def if_nametoindex(interface):
1542
"""Call the C function if_nametoindex(), or equivalent
1544
Note: This function cannot accept a unicode string."""
1545
global if_nametoindex
1547
if_nametoindex = (ctypes.cdll.LoadLibrary
1548
(ctypes.util.find_library(u"c"))
1550
except (OSError, AttributeError):
1551
logger.warning(u"Doing if_nametoindex the hard way")
1552
def if_nametoindex(interface):
1553
"Get an interface index the hard way, i.e. using fcntl()"
1554
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1555
with contextlib.closing(socket.socket()) as s:
1556
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1557
struct.pack(str(u"16s16x"),
1559
interface_index = struct.unpack(str(u"I"),
1561
return interface_index
1562
return if_nametoindex(interface)
1565
def daemon(nochdir = False, noclose = False):
2903
1566
"""See daemon(3). Standard BSD Unix function.
2905
1568
This should really exist as os.daemon, but it doesn't (yet)."""
2909
1572
if not nochdir:
2913
1576
if not noclose:
2914
1577
# Close all standard open file descriptors
2915
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1578
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2916
1579
if not stat.S_ISCHR(os.fstat(null).st_mode):
2917
1580
raise OSError(errno.ENODEV,
2918
"{} not a character device"
2919
.format(os.devnull))
1581
u"%s not a character device"
2920
1583
os.dup2(null, sys.stdin.fileno())
2921
1584
os.dup2(null, sys.stdout.fileno())
2922
1585
os.dup2(null, sys.stderr.fileno())
2929
1592
##################################################################
2930
1593
# Parsing of options, both command line and config file
2932
parser = argparse.ArgumentParser()
2933
parser.add_argument("-v", "--version", action="version",
2934
version="%(prog)s {}".format(version),
2935
help="show version number and exit")
2936
parser.add_argument("-i", "--interface", metavar="IF",
2937
help="Bind to interface IF")
2938
parser.add_argument("-a", "--address",
2939
help="Address to listen for requests on")
2940
parser.add_argument("-p", "--port", type=int,
2941
help="Port number to receive requests on")
2942
parser.add_argument("--check", action="store_true",
2943
help="Run self-test")
2944
parser.add_argument("--debug", action="store_true",
2945
help="Debug mode; run in foreground and log"
2946
" to terminal", default=None)
2947
parser.add_argument("--debuglevel", metavar="LEVEL",
2948
help="Debug level for stdout output")
2949
parser.add_argument("--priority", help="GnuTLS"
2950
" priority string (see GnuTLS documentation)")
2951
parser.add_argument("--servicename",
2952
metavar="NAME", help="Zeroconf service name")
2953
parser.add_argument("--configdir",
2954
default="/etc/mandos", metavar="DIR",
2955
help="Directory to search for configuration"
2957
parser.add_argument("--no-dbus", action="store_false",
2958
dest="use_dbus", help="Do not provide D-Bus"
2959
" system bus interface", default=None)
2960
parser.add_argument("--no-ipv6", action="store_false",
2961
dest="use_ipv6", help="Do not use IPv6",
2963
parser.add_argument("--no-restore", action="store_false",
2964
dest="restore", help="Do not restore stored"
2965
" state", default=None)
2966
parser.add_argument("--socket", type=int,
2967
help="Specify a file descriptor to a network"
2968
" socket to use instead of creating one")
2969
parser.add_argument("--statedir", metavar="DIR",
2970
help="Directory to save/restore state in")
2971
parser.add_argument("--foreground", action="store_true",
2972
help="Run in foreground", default=None)
2973
parser.add_argument("--no-zeroconf", action="store_false",
2974
dest="zeroconf", help="Do not use Zeroconf",
2977
options = parser.parse_args()
1595
parser = optparse.OptionParser(version = "%%prog %s" % version)
1596
parser.add_option("-i", u"--interface", type=u"string",
1597
metavar="IF", help=u"Bind to interface IF")
1598
parser.add_option("-a", u"--address", type=u"string",
1599
help=u"Address to listen for requests on")
1600
parser.add_option("-p", u"--port", type=u"int",
1601
help=u"Port number to receive requests on")
1602
parser.add_option("--check", action=u"store_true",
1603
help=u"Run self-test")
1604
parser.add_option("--debug", action=u"store_true",
1605
help=u"Debug mode; run in foreground and log to"
1607
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1608
u" priority string (see GnuTLS documentation)")
1609
parser.add_option("--servicename", type=u"string",
1610
metavar=u"NAME", help=u"Zeroconf service name")
1611
parser.add_option("--configdir", type=u"string",
1612
default=u"/etc/mandos", metavar=u"DIR",
1613
help=u"Directory to search for configuration"
1615
parser.add_option("--no-dbus", action=u"store_false",
1616
dest=u"use_dbus", help=u"Do not provide D-Bus"
1617
u" system bus interface")
1618
parser.add_option("--no-ipv6", action=u"store_false",
1619
dest=u"use_ipv6", help=u"Do not use IPv6")
1620
options = parser.parse_args()[0]
2979
1622
if options.check:
2981
fail_count, test_count = doctest.testmod()
2982
sys.exit(os.EX_OK if fail_count == 0 else 1)
2984
1627
# Default values for config file for server-global settings
2985
if gnutls.has_rawpk:
2986
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2987
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2989
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2990
":+SIGN-DSA-SHA256")
2991
server_defaults = {"interface": "",
2995
"priority": priority,
2996
"servicename": "Mandos",
3002
"statedir": "/var/lib/mandos",
3003
"foreground": "False",
1628
server_defaults = { u"interface": u"",
1633
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1634
u"servicename": u"Mandos",
1635
u"use_dbus": u"True",
1636
u"use_ipv6": u"True",
3008
1639
# Parse config file for server-global settings
3009
1640
server_config = configparser.SafeConfigParser(server_defaults)
3010
1641
del server_defaults
3011
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1642
server_config.read(os.path.join(options.configdir,
3012
1644
# Convert the SafeConfigParser object to a dict
3013
1645
server_settings = server_config.defaults()
3014
1646
# Use the appropriate methods on the non-string config options
3015
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3016
"foreground", "zeroconf"):
3017
server_settings[option] = server_config.getboolean("DEFAULT",
1647
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1648
server_settings[option] = server_config.getboolean(u"DEFAULT",
3019
1650
if server_settings["port"]:
3020
server_settings["port"] = server_config.getint("DEFAULT",
3022
if server_settings["socket"]:
3023
server_settings["socket"] = server_config.getint("DEFAULT",
3025
# Later, stdin will, and stdout and stderr might, be dup'ed
3026
# over with an opened os.devnull. But we don't want this to
3027
# happen with a supplied network socket.
3028
if 0 <= server_settings["socket"] <= 2:
3029
server_settings["socket"] = os.dup(server_settings
1651
server_settings["port"] = server_config.getint(u"DEFAULT",
3031
1653
del server_config
3033
1655
# Override the settings from the config file with command line
3034
1656
# options, if set.
3035
for option in ("interface", "address", "port", "debug",
3036
"priority", "servicename", "configdir", "use_dbus",
3037
"use_ipv6", "debuglevel", "restore", "statedir",
3038
"socket", "foreground", "zeroconf"):
1657
for option in (u"interface", u"address", u"port", u"debug",
1658
u"priority", u"servicename", u"configdir",
1659
u"use_dbus", u"use_ipv6"):
3039
1660
value = getattr(options, option)
3040
1661
if value is not None:
3041
1662
server_settings[option] = value
3043
1664
# Force all strings to be unicode
3044
1665
for option in server_settings.keys():
3045
if isinstance(server_settings[option], bytes):
3046
server_settings[option] = (server_settings[option]
3048
# Force all boolean options to be boolean
3049
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3050
"foreground", "zeroconf"):
3051
server_settings[option] = bool(server_settings[option])
3052
# Debug implies foreground
3053
if server_settings["debug"]:
3054
server_settings["foreground"] = True
1666
if type(server_settings[option]) is str:
1667
server_settings[option] = unicode(server_settings[option])
3055
1668
# Now we have our good server settings in "server_settings"
3057
1670
##################################################################
3059
if (not server_settings["zeroconf"]
3060
and not (server_settings["port"]
3061
or server_settings["socket"] != "")):
3062
parser.error("Needs port or socket to work without Zeroconf")
3064
1672
# For convenience
3065
debug = server_settings["debug"]
3066
debuglevel = server_settings["debuglevel"]
3067
use_dbus = server_settings["use_dbus"]
3068
use_ipv6 = server_settings["use_ipv6"]
3069
stored_state_path = os.path.join(server_settings["statedir"],
3071
foreground = server_settings["foreground"]
3072
zeroconf = server_settings["zeroconf"]
3075
initlogger(debug, logging.DEBUG)
3080
level = getattr(logging, debuglevel.upper())
3081
initlogger(debug, level)
3083
if server_settings["servicename"] != "Mandos":
3084
syslogger.setFormatter(
3085
logging.Formatter('Mandos ({}) [%(process)d]:'
3086
' %(levelname)s: %(message)s'.format(
3087
server_settings["servicename"])))
1673
debug = server_settings[u"debug"]
1674
use_dbus = server_settings[u"use_dbus"]
1675
use_ipv6 = server_settings[u"use_ipv6"]
1678
syslogger.setLevel(logging.WARNING)
1679
console.setLevel(logging.WARNING)
1681
if server_settings[u"servicename"] != u"Mandos":
1682
syslogger.setFormatter(logging.Formatter
1683
(u'Mandos (%s) [%%(process)d]:'
1684
u' %%(levelname)s: %%(message)s'
1685
% server_settings[u"servicename"]))
3089
1687
# Parse config file with clients
3090
client_config = configparser.SafeConfigParser(Client
3092
client_config.read(os.path.join(server_settings["configdir"],
1688
client_defaults = { u"timeout": u"1h",
1690
u"checker": u"fping -q -- %%(host)s",
1692
u"approved_delay": u"5m",
1693
u"approved_duration": u"1s",
1695
client_config = configparser.SafeConfigParser(client_defaults)
1696
client_config.read(os.path.join(server_settings[u"configdir"],
3095
1699
global mandos_dbus_service
3096
1700
mandos_dbus_service = None
3099
if server_settings["socket"] != "":
3100
socketfd = server_settings["socket"]
3101
tcp_server = MandosServer(
3102
(server_settings["address"], server_settings["port"]),
3104
interface=(server_settings["interface"] or None),
3106
gnutls_priority=server_settings["priority"],
3110
pidfilename = "/run/mandos.pid"
3111
if not os.path.isdir("/run/."):
3112
pidfilename = "/var/run/mandos.pid"
3115
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3116
except IOError as e:
3117
logger.error("Could not open file %r", pidfilename,
3120
for name, group in (("_mandos", "_mandos"),
3121
("mandos", "mandos"),
3122
("nobody", "nogroup")):
3124
uid = pwd.getpwnam(name).pw_uid
3125
gid = pwd.getpwnam(group).pw_gid
1702
tcp_server = MandosServer((server_settings[u"address"],
1703
server_settings[u"port"]),
1705
interface=server_settings[u"interface"],
1708
server_settings[u"priority"],
1710
pidfilename = u"/var/run/mandos.pid"
1712
pidfile = open(pidfilename, u"w")
1714
logger.error(u"Could not open file %r", pidfilename)
1717
uid = pwd.getpwnam(u"_mandos").pw_uid
1718
gid = pwd.getpwnam(u"_mandos").pw_gid
1721
uid = pwd.getpwnam(u"mandos").pw_uid
1722
gid = pwd.getpwnam(u"mandos").pw_gid
3127
1723
except KeyError:
1725
uid = pwd.getpwnam(u"nobody").pw_uid
1726
gid = pwd.getpwnam(u"nobody").pw_gid
3136
logger.debug("Did setuid/setgid to {}:{}".format(uid,
3138
except OSError as error:
3139
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3140
.format(uid, gid, os.strerror(error.errno)))
3141
if error.errno != errno.EPERM:
1733
except OSError, error:
1734
if error[0] != errno.EPERM:
1737
# Enable all possible GnuTLS debugging
3145
# Enable all possible GnuTLS debugging
3147
1739
# "Use a log level over 10 to enable all debugging options."
3148
1740
# - GnuTLS manual
3149
gnutls.global_set_log_level(11)
1741
gnutls.library.functions.gnutls_global_set_log_level(11)
1743
@gnutls.library.types.gnutls_log_func
3152
1744
def debug_gnutls(level, string):
3153
logger.debug("GnuTLS: %s", string[:-1])
3155
gnutls.global_set_log_function(debug_gnutls)
3157
# Redirect stdin so all checkers get /dev/null
3158
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3159
os.dup2(null, sys.stdin.fileno())
3163
# Need to fork before connecting to D-Bus
3165
# Close all input and output, do double fork, etc.
3168
# multiprocessing will use threads, so before we use GLib we need
3169
# to inform GLib that threads will be used.
1745
logger.debug(u"GnuTLS: %s", string[:-1])
1747
(gnutls.library.functions
1748
.gnutls_global_set_log_function(debug_gnutls))
3172
1750
global main_loop
3173
1751
# From the Avahi example code
3174
DBusGMainLoop(set_as_default=True)
3175
main_loop = GLib.MainLoop()
1752
DBusGMainLoop(set_as_default=True )
1753
main_loop = gobject.MainLoop()
3176
1754
bus = dbus.SystemBus()
3177
1755
# End of Avahi example code
3180
bus_name = dbus.service.BusName("se.recompile.Mandos",
3183
old_bus_name = dbus.service.BusName(
3184
"se.bsnet.fukt.Mandos", bus,
3186
except dbus.exceptions.DBusException as e:
3187
logger.error("Disabling D-Bus:", exc_info=e)
1758
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1759
bus, do_not_queue=True)
1760
except dbus.exceptions.NameExistsException, e:
1761
logger.error(unicode(e) + u", disabling D-Bus")
3188
1762
use_dbus = False
3189
server_settings["use_dbus"] = False
1763
server_settings[u"use_dbus"] = False
3190
1764
tcp_server.use_dbus = False
3192
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3193
service = AvahiServiceToSyslog(
3194
name=server_settings["servicename"],
3195
servicetype="_mandos._tcp",
3198
if server_settings["interface"]:
3199
service.interface = if_nametoindex(
3200
server_settings["interface"].encode("utf-8"))
1765
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1766
service = AvahiService(name = server_settings[u"servicename"],
1767
servicetype = u"_mandos._tcp",
1768
protocol = protocol, bus = bus)
1769
if server_settings["interface"]:
1770
service.interface = (if_nametoindex
1771
(str(server_settings[u"interface"])))
3202
1773
global multiprocessing_manager
3203
1774
multiprocessing_manager = multiprocessing.Manager()
3205
1776
client_class = Client
3207
client_class = functools.partial(ClientDBus, bus=bus)
3209
client_settings = Client.config_parser(client_config)
3210
old_client_settings = {}
3213
# This is used to redirect stdout and stderr for checker processes
3215
wnull = open(os.devnull, "w") # A writable /dev/null
3216
# Only used if server is running in foreground but not in debug
3218
if debug or not foreground:
3221
# Get client data and settings from last running state.
3222
if server_settings["restore"]:
3224
with open(stored_state_path, "rb") as stored_state:
3225
if sys.version_info.major == 2:
3226
clients_data, old_client_settings = pickle.load(
3229
bytes_clients_data, bytes_old_client_settings = (
3230
pickle.load(stored_state, encoding="bytes"))
3231
# Fix bytes to strings
3234
clients_data = {(key.decode("utf-8")
3235
if isinstance(key, bytes)
3238
bytes_clients_data.items()}
3239
del bytes_clients_data
3240
for key in clients_data:
3241
value = {(k.decode("utf-8")
3242
if isinstance(k, bytes) else k): v
3244
clients_data[key].items()}
3245
clients_data[key] = value
3247
value["client_structure"] = [
3249
if isinstance(s, bytes)
3251
value["client_structure"]]
3253
for k in ("name", "host"):
3254
if isinstance(value[k], bytes):
3255
value[k] = value[k].decode("utf-8")
3256
if not value.has_key("key_id"):
3257
value["key_id"] = ""
3258
elif not value.has_key("fingerprint"):
3259
value["fingerprint"] = ""
3260
# old_client_settings
3262
old_client_settings = {
3263
(key.decode("utf-8")
3264
if isinstance(key, bytes)
3267
bytes_old_client_settings.items()}
3268
del bytes_old_client_settings
3270
for value in old_client_settings.values():
3271
if isinstance(value["host"], bytes):
3272
value["host"] = (value["host"]
3274
os.remove(stored_state_path)
3275
except IOError as e:
3276
if e.errno == errno.ENOENT:
3277
logger.warning("Could not load persistent state:"
3278
" {}".format(os.strerror(e.errno)))
3280
logger.critical("Could not load persistent state:",
3283
except EOFError as e:
3284
logger.warning("Could not load persistent state: "
3288
with PGPEngine() as pgp:
3289
for client_name, client in clients_data.items():
3290
# Skip removed clients
3291
if client_name not in client_settings:
3294
# Decide which value to use after restoring saved state.
3295
# We have three different values: Old config file,
3296
# new config file, and saved state.
3297
# New config value takes precedence if it differs from old
3298
# config value, otherwise use saved state.
3299
for name, value in client_settings[client_name].items():
3301
# For each value in new config, check if it
3302
# differs from the old config value (Except for
3303
# the "secret" attribute)
3304
if (name != "secret"
3306
old_client_settings[client_name][name])):
3307
client[name] = value
3311
# Clients who has passed its expire date can still be
3312
# enabled if its last checker was successful. A Client
3313
# whose checker succeeded before we stored its state is
3314
# assumed to have successfully run all checkers during
3316
if client["enabled"]:
3317
if datetime.datetime.utcnow() >= client["expires"]:
3318
if not client["last_checked_ok"]:
3320
"disabling client {} - Client never "
3321
"performed a successful checker".format(
3323
client["enabled"] = False
3324
elif client["last_checker_status"] != 0:
3326
"disabling client {} - Client last"
3327
" checker failed with error code"
3330
client["last_checker_status"]))
3331
client["enabled"] = False
3333
client["expires"] = (
3334
datetime.datetime.utcnow()
3335
+ client["timeout"])
3336
logger.debug("Last checker succeeded,"
3337
" keeping {} enabled".format(
1778
client_class = functools.partial(ClientDBus, bus = bus)
1779
def client_config_items(config, section):
1780
special_settings = {
1781
"approved_by_default":
1782
lambda: config.getboolean(section,
1783
"approved_by_default"),
1785
for name, value in config.items(section):
3340
client["secret"] = pgp.decrypt(
3341
client["encrypted_secret"],
3342
client_settings[client_name]["secret"])
3344
# If decryption fails, we use secret from new settings
3345
logger.debug("Failed to decrypt {} old secret".format(
3347
client["secret"] = (client_settings[client_name]
3350
# Add/remove clients based on new changes made to config
3351
for client_name in (set(old_client_settings)
3352
- set(client_settings)):
3353
del clients_data[client_name]
3354
for client_name in (set(client_settings)
3355
- set(old_client_settings)):
3356
clients_data[client_name] = client_settings[client_name]
3358
# Create all client objects
3359
for client_name, client in clients_data.items():
3360
tcp_server.clients[client_name] = client_class(
3363
server_settings=server_settings)
1787
yield (name, special_settings[name]())
1791
tcp_server.clients.update(set(
1792
client_class(name = section,
1793
config= dict(client_config_items(
1794
client_config, section)))
1795
for section in client_config.sections()))
3365
1796
if not tcp_server.clients:
3366
logger.warning("No clients defined")
3369
if pidfile is not None:
1797
logger.warning(u"No clients defined")
1800
# Redirect stdin so all checkers get /dev/null
1801
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1802
os.dup2(null, sys.stdin.fileno())
1806
# No console logging
1807
logger.removeHandler(console)
1808
# Close all input and output, do double fork, etc.
3370
1813
pid = os.getpid()
3373
print(pid, file=pidfile)
3375
logger.error("Could not write to file %r with PID %d",
1814
pidfile.write(str(pid) + "\n")
3380
for termsig in (signal.SIGHUP, signal.SIGTERM):
3381
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3382
lambda: main_loop.quit() and False)
1817
logger.error(u"Could not write to file %r with PID %d",
1820
# "pidfile" was never created
1825
signal.signal(signal.SIGINT, signal.SIG_IGN)
1826
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1827
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3386
@alternate_dbus_interfaces(
3387
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3388
class MandosDBusService(DBusObjectWithObjectManager):
1830
class MandosDBusService(dbus.service.Object):
3389
1831
"""A D-Bus proxy object"""
3391
1832
def __init__(self):
3392
dbus.service.Object.__init__(self, bus, "/")
3394
_interface = "se.recompile.Mandos"
3396
@dbus.service.signal(_interface, signature="o")
1833
dbus.service.Object.__init__(self, bus, u"/")
1834
_interface = u"se.bsnet.fukt.Mandos"
1836
@dbus.service.signal(_interface, signature=u"o")
3397
1837
def ClientAdded(self, objpath):
3401
@dbus.service.signal(_interface, signature="ss")
3402
def ClientNotFound(self, key_id, address):
1841
@dbus.service.signal(_interface, signature=u"ss")
1842
def ClientNotFound(self, fingerprint, address):
3406
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3408
@dbus.service.signal(_interface, signature="os")
1846
@dbus.service.signal(_interface, signature=u"os")
3409
1847
def ClientRemoved(self, objpath, name):
3413
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3415
@dbus.service.method(_interface, out_signature="ao")
1851
@dbus.service.method(_interface, out_signature=u"ao")
3416
1852
def GetAllClients(self):
3418
return dbus.Array(c.dbus_object_path for c in
3419
tcp_server.clients.values())
3421
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
1854
return dbus.Array(c.dbus_object_path
1855
for c in tcp_server.clients)
3423
1857
@dbus.service.method(_interface,
3424
out_signature="a{oa{sv}}")
1858
out_signature=u"a{oa{sv}}")
3425
1859
def GetAllClientsWithProperties(self):
3427
1861
return dbus.Dictionary(
3428
{c.dbus_object_path: c.GetAll(
3429
"se.recompile.Mandos.Client")
3430
for c in tcp_server.clients.values()},
3433
@dbus.service.method(_interface, in_signature="o")
1862
((c.dbus_object_path, c.GetAll(u""))
1863
for c in tcp_server.clients),
1864
signature=u"oa{sv}")
1866
@dbus.service.method(_interface, in_signature=u"o")
3434
1867
def RemoveClient(self, object_path):
3436
for c in tcp_server.clients.values():
1869
for c in tcp_server.clients:
3437
1870
if c.dbus_object_path == object_path:
3438
del tcp_server.clients[c.name]
1871
tcp_server.clients.remove(c)
3439
1872
c.remove_from_connection()
3440
# Don't signal the disabling
1873
# Don't signal anything except ClientRemoved
3441
1874
c.disable(quiet=True)
3442
# Emit D-Bus signal for removal
3443
self.client_removed_signal(c)
1876
self.ClientRemoved(object_path, c.name)
3445
1878
raise KeyError(object_path)
3449
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3450
out_signature="a{oa{sa{sv}}}")
3451
def GetManagedObjects(self):
3453
return dbus.Dictionary(
3454
{client.dbus_object_path:
3456
{interface: client.GetAll(interface)
3458
client._get_all_interface_names()})
3459
for client in tcp_server.clients.values()})
3461
def client_added_signal(self, client):
3462
"""Send the new standard signal and the old signal"""
3464
# New standard signal
3465
self.InterfacesAdded(
3466
client.dbus_object_path,
3468
{interface: client.GetAll(interface)
3470
client._get_all_interface_names()}))
3472
self.ClientAdded(client.dbus_object_path)
3474
def client_removed_signal(self, client):
3475
"""Send the new standard signal and the old signal"""
3477
# New standard signal
3478
self.InterfacesRemoved(
3479
client.dbus_object_path,
3480
client._get_all_interface_names())
3482
self.ClientRemoved(client.dbus_object_path,
3485
1882
mandos_dbus_service = MandosDBusService()
3487
# Save modules to variables to exempt the modules from being
3488
# unloaded before the function registered with atexit() is run.
3489
mp = multiprocessing
3493
1885
"Cleanup function; run on exit"
3497
mp.active_children()
3499
if not (tcp_server.clients or client_settings):
3502
# Store client before exiting. Secrets are encrypted with key
3503
# based on what config file has. If config file is
3504
# removed/edited, old secret will thus be unrecovable.
3506
with PGPEngine() as pgp:
3507
for client in tcp_server.clients.values():
3508
key = client_settings[client.name]["secret"]
3509
client.encrypted_secret = pgp.encrypt(client.secret,
3513
# A list of attributes that can not be pickled
3515
exclude = {"bus", "changedstate", "secret",
3516
"checker", "server_settings"}
3517
for name, typ in inspect.getmembers(dbus.service
3521
client_dict["encrypted_secret"] = (client
3523
for attr in client.client_structure:
3524
if attr not in exclude:
3525
client_dict[attr] = getattr(client, attr)
3527
clients[client.name] = client_dict
3528
del client_settings[client.name]["secret"]
3531
with tempfile.NamedTemporaryFile(
3535
dir=os.path.dirname(stored_state_path),
3536
delete=False) as stored_state:
3537
pickle.dump((clients, client_settings), stored_state,
3539
tempname = stored_state.name
3540
os.rename(tempname, stored_state_path)
3541
except (IOError, OSError) as e:
3547
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3548
logger.warning("Could not save persistent state: {}"
3549
.format(os.strerror(e.errno)))
3551
logger.warning("Could not save persistent state:",
3555
# Delete all clients, and settings from config
3556
1888
while tcp_server.clients:
3557
name, client = tcp_server.clients.popitem()
1889
client = tcp_server.clients.pop()
3559
1891
client.remove_from_connection()
3560
# Don't signal the disabling
1892
client.disable_hook = None
1893
# Don't signal anything except ClientRemoved
3561
1894
client.disable(quiet=True)
3562
# Emit D-Bus signal for removal
3564
mandos_dbus_service.client_removed_signal(client)
3565
client_settings.clear()
1897
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
3567
1900
atexit.register(cleanup)
3569
for client in tcp_server.clients.values():
1902
for client in tcp_server.clients:
3571
# Emit D-Bus signal for adding
3572
mandos_dbus_service.client_added_signal(client)
3573
# Need to initiate checking of clients
3575
client.init_checker()
1905
mandos_dbus_service.ClientAdded(client.dbus_object_path)
3577
1908
tcp_server.enable()
3578
1909
tcp_server.server_activate()
3580
1911
# Find out what port we got
3582
service.port = tcp_server.socket.getsockname()[1]
1912
service.port = tcp_server.socket.getsockname()[1]
3584
logger.info("Now listening on address %r, port %d,"
3585
" flowinfo %d, scope_id %d",
3586
*tcp_server.socket.getsockname())
1914
logger.info(u"Now listening on address %r, port %d,"
1915
" flowinfo %d, scope_id %d"
1916
% tcp_server.socket.getsockname())
3588
logger.info("Now listening on address %r, port %d",
3589
*tcp_server.socket.getsockname())
3591
# service.interface = tcp_server.socket.getsockname()[3]
1918
logger.info(u"Now listening on address %r, port %d"
1919
% tcp_server.socket.getsockname())
1921
#service.interface = tcp_server.socket.getsockname()[3]
3595
# From the Avahi example code
3598
except dbus.exceptions.DBusException as error:
3599
logger.critical("D-Bus Exception", exc_info=error)
3602
# End of Avahi example code
3604
GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3605
lambda *args, **kwargs:
3606
(tcp_server.handle_request
3607
(*args[2:], **kwargs) or True))
3609
logger.debug("Starting main loop")
1924
# From the Avahi example code
1927
except dbus.exceptions.DBusException, error:
1928
logger.critical(u"DBusException: %s", error)
1931
# End of Avahi example code
1933
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1934
lambda *args, **kwargs:
1935
(tcp_server.handle_request
1936
(*args[2:], **kwargs) or True))
1938
logger.debug(u"Starting main loop")
3610
1939
main_loop.run()
3611
except AvahiError as error:
3612
logger.critical("Avahi Error", exc_info=error)
1940
except AvahiError, error:
1941
logger.critical(u"AvahiError: %s", error)
3615
1944
except KeyboardInterrupt:
3617
print("", file=sys.stderr)
3618
logger.debug("Server received KeyboardInterrupt")
3619
logger.debug("Server exiting")
1947
logger.debug(u"Server received KeyboardInterrupt")
1948
logger.debug(u"Server exiting")
3620
1949
# Must run before the D-Bus bus name gets deregistered
3624
1952
if __name__ == '__main__':