124
386
self.rename_count = 0
125
387
self.max_renames = max_renames
388
self.protocol = protocol
389
self.group = None # our entry group
392
self.entry_group_state_changed_match = None
394
def rename(self, remove=True):
127
395
"""Derived from the Avahi example code"""
128
396
if self.rename_count >= self.max_renames:
129
logger.critical(u"No suitable Zeroconf service name found"
130
u" after %i retries, exiting.",
132
raise AvahiServiceError(u"Too many renames")
133
self.name = server.GetAlternativeServiceName(self.name)
134
logger.info(u"Changing Zeroconf service name to %r ...",
136
syslogger.setFormatter(logging.Formatter
137
('Mandos (%s): %%(levelname)s:'
138
' %%(message)s' % self.name))
397
log.critical("No suitable Zeroconf service name found"
398
" after %i retries, exiting.",
400
raise AvahiServiceError("Too many renames")
402
self.server.GetAlternativeServiceName(self.name))
141
403
self.rename_count += 1
404
log.info("Changing Zeroconf service name to %r ...",
410
except dbus.exceptions.DBusException as error:
411
if (error.get_dbus_name()
412
== "org.freedesktop.Avahi.CollisionError"):
413
log.info("Local Zeroconf service name collision.")
414
return self.rename(remove=False)
416
log.critical("D-Bus Exception", exc_info=error)
142
420
def remove(self):
143
421
"""Derived from the Avahi example code"""
144
if group is not None:
422
if self.entry_group_state_changed_match is not None:
423
self.entry_group_state_changed_match.remove()
424
self.entry_group_state_changed_match = None
425
if self.group is not None:
147
429
"""Derived from the Avahi example code"""
150
group = dbus.Interface(bus.get_object
152
server.EntryGroupNew()),
153
avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
group.connect_to_signal('StateChanged',
155
entry_group_state_changed)
156
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
157
service.name, service.type)
159
self.interface, # interface
160
avahi.PROTO_INET6, # protocol
161
dbus.UInt32(0), # flags
162
self.name, self.type,
163
self.domain, self.host,
164
dbus.UInt16(self.port),
165
avahi.string_array_to_txt_array(self.TXT))
168
# From the Avahi example code:
169
group = None # our entry group
170
# End of Avahi example code
173
def _datetime_to_dbus(dt, variant_level=0):
174
"""Convert a UTC datetime.datetime() to a D-Bus type."""
175
return dbus.String(dt.isoformat(), variant_level=variant_level)
178
class Client(dbus.service.Object):
431
if self.group is None:
432
self.group = dbus.Interface(
433
self.bus.get_object(avahi.DBUS_NAME,
434
self.server.EntryGroupNew()),
435
avahi.DBUS_INTERFACE_ENTRY_GROUP)
436
self.entry_group_state_changed_match = (
437
self.group.connect_to_signal(
438
"StateChanged", self.entry_group_state_changed))
439
log.debug("Adding Zeroconf service '%s' of type '%s' ...",
440
self.name, self.type)
441
self.group.AddService(
444
dbus.UInt32(0), # flags
445
self.name, self.type,
446
self.domain, self.host,
447
dbus.UInt16(self.port),
448
avahi.string_array_to_txt_array(self.TXT))
451
def entry_group_state_changed(self, state, error):
452
"""Derived from the Avahi example code"""
453
log.debug("Avahi entry group state change: %i", state)
455
if state == avahi.ENTRY_GROUP_ESTABLISHED:
456
log.debug("Zeroconf service established.")
457
elif state == avahi.ENTRY_GROUP_COLLISION:
458
log.info("Zeroconf service name collision.")
460
elif state == avahi.ENTRY_GROUP_FAILURE:
461
log.critical("Avahi: Error in group state changed %s",
463
raise AvahiGroupError("State changed: {!s}".format(error))
466
"""Derived from the Avahi example code"""
467
if self.group is not None:
470
except (dbus.exceptions.UnknownMethodException,
471
dbus.exceptions.DBusException):
476
def server_state_changed(self, state, error=None):
477
"""Derived from the Avahi example code"""
478
log.debug("Avahi server state change: %i", state)
480
avahi.SERVER_INVALID: "Zeroconf server invalid",
481
avahi.SERVER_REGISTERING: None,
482
avahi.SERVER_COLLISION: "Zeroconf server name collision",
483
avahi.SERVER_FAILURE: "Zeroconf server failure",
485
if state in bad_states:
486
if bad_states[state] is not None:
488
log.error(bad_states[state])
490
log.error(bad_states[state] + ": %r", error)
492
elif state == avahi.SERVER_RUNNING:
495
except dbus.exceptions.DBusException as error:
496
if (error.get_dbus_name()
497
== "org.freedesktop.Avahi.CollisionError"):
498
log.info("Local Zeroconf service name collision.")
499
return self.rename(remove=False)
501
log.critical("D-Bus Exception", exc_info=error)
506
log.debug("Unknown state: %r", state)
508
log.debug("Unknown state: %r: %r", state, error)
511
"""Derived from the Avahi example code"""
512
if self.server is None:
513
self.server = dbus.Interface(
514
self.bus.get_object(avahi.DBUS_NAME,
515
avahi.DBUS_PATH_SERVER,
516
follow_name_owner_changes=True),
517
avahi.DBUS_INTERFACE_SERVER)
518
self.server.connect_to_signal("StateChanged",
519
self.server_state_changed)
520
self.server_state_changed(self.server.GetState())
523
class AvahiServiceToSyslog(AvahiService):
524
def rename(self, *args, **kwargs):
525
"""Add the new name to the syslog messages"""
526
ret = super(AvahiServiceToSyslog, self).rename(*args,
528
syslogger.setFormatter(logging.Formatter(
529
"Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"
534
# Pretend that we have a GnuTLS module
536
"""This isn't so much a class as it is a module-like namespace."""
538
library = ctypes.util.find_library("gnutls")
540
library = ctypes.util.find_library("gnutls-deb0")
541
_library = ctypes.cdll.LoadLibrary(library)
544
# Unless otherwise indicated, the constants and types below are
545
# all from the gnutls/gnutls.h C header file.
556
E_NO_CERTIFICATE_FOUND = -49
561
KEYID_USE_SHA256 = 1 # gnutls/x509.h
562
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
565
class _session_int(ctypes.Structure):
567
session_t = ctypes.POINTER(_session_int)
569
class certificate_credentials_st(ctypes.Structure):
571
certificate_credentials_t = ctypes.POINTER(
572
certificate_credentials_st)
573
certificate_type_t = ctypes.c_int
575
class datum_t(ctypes.Structure):
576
_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),
577
("size", ctypes.c_uint)]
579
class _openpgp_crt_int(ctypes.Structure):
581
openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)
582
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
583
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
584
credentials_type_t = ctypes.c_int
585
transport_ptr_t = ctypes.c_void_p
586
close_request_t = ctypes.c_int
589
class Error(Exception):
590
def __init__(self, message=None, code=None, args=()):
591
# Default usage is by a message string, but if a return
592
# code is passed, convert it to a string with
595
if message is None and code is not None:
596
message = gnutls.strerror(code).decode(
597
"utf-8", errors="replace")
598
return super(gnutls.Error, self).__init__(
601
class CertificateSecurityError(Error):
605
def __init__(self, cls):
608
def from_param(self, obj):
609
if not isinstance(obj, self.cls):
610
raise TypeError("Not of type {}: {!r}"
611
.format(self.cls.__name__, obj))
612
return ctypes.byref(obj.from_param(obj))
614
class CastToVoidPointer:
615
def __init__(self, cls):
618
def from_param(self, obj):
619
if not isinstance(obj, self.cls):
620
raise TypeError("Not of type {}: {!r}"
621
.format(self.cls.__name__, obj))
622
return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)
624
class With_from_param:
626
def from_param(cls, obj):
627
return obj._as_parameter_
630
class Credentials(With_from_param):
632
self._as_parameter_ = gnutls.certificate_credentials_t()
633
gnutls.certificate_allocate_credentials(self)
634
self.type = gnutls.CRD_CERTIFICATE
637
gnutls.certificate_free_credentials(self)
639
class ClientSession(With_from_param):
640
def __init__(self, socket, credentials=None):
641
self._as_parameter_ = gnutls.session_t()
642
gnutls_flags = gnutls.CLIENT
643
if gnutls.check_version(b"3.5.6"):
644
gnutls_flags |= gnutls.NO_TICKETS
646
gnutls_flags |= gnutls.ENABLE_RAWPK
647
gnutls.init(self, gnutls_flags)
649
gnutls.set_default_priority(self)
650
gnutls.transport_set_ptr(self, socket.fileno())
651
gnutls.handshake_set_private_extensions(self, True)
653
if credentials is None:
654
credentials = gnutls.Credentials()
655
gnutls.credentials_set(self, credentials.type,
657
self.credentials = credentials
663
return gnutls.handshake(self)
665
def send(self, data):
669
data_len -= gnutls.record_send(self, data[-data_len:],
673
return gnutls.bye(self, gnutls.SHUT_RDWR)
675
# Error handling functions
676
def _error_code(result):
677
"""A function to raise exceptions on errors, suitable
678
for the "restype" attribute on ctypes functions"""
679
if result >= gnutls.E_SUCCESS:
681
if result == gnutls.E_NO_CERTIFICATE_FOUND:
682
raise gnutls.CertificateSecurityError(code=result)
683
raise gnutls.Error(code=result)
685
def _retry_on_error(result, func, arguments,
686
_error_code=_error_code):
687
"""A function to retry on some errors, suitable
688
for the "errcheck" attribute on ctypes functions"""
689
while result < gnutls.E_SUCCESS:
690
if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):
691
return _error_code(result)
692
result = func(*arguments)
695
# Unless otherwise indicated, the function declarations below are
696
# all from the gnutls/gnutls.h C header file.
699
priority_set_direct = _library.gnutls_priority_set_direct
700
priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,
701
ctypes.POINTER(ctypes.c_char_p)]
702
priority_set_direct.restype = _error_code
704
init = _library.gnutls_init
705
init.argtypes = [PointerTo(ClientSession), ctypes.c_int]
706
init.restype = _error_code
708
set_default_priority = _library.gnutls_set_default_priority
709
set_default_priority.argtypes = [ClientSession]
710
set_default_priority.restype = _error_code
712
record_send = _library.gnutls_record_send
713
record_send.argtypes = [ClientSession, ctypes.c_void_p,
715
record_send.restype = ctypes.c_ssize_t
716
record_send.errcheck = _retry_on_error
718
certificate_allocate_credentials = (
719
_library.gnutls_certificate_allocate_credentials)
720
certificate_allocate_credentials.argtypes = [
721
PointerTo(Credentials)]
722
certificate_allocate_credentials.restype = _error_code
724
certificate_free_credentials = (
725
_library.gnutls_certificate_free_credentials)
726
certificate_free_credentials.argtypes = [Credentials]
727
certificate_free_credentials.restype = None
729
handshake_set_private_extensions = (
730
_library.gnutls_handshake_set_private_extensions)
731
handshake_set_private_extensions.argtypes = [ClientSession,
733
handshake_set_private_extensions.restype = None
735
credentials_set = _library.gnutls_credentials_set
736
credentials_set.argtypes = [ClientSession, credentials_type_t,
737
CastToVoidPointer(Credentials)]
738
credentials_set.restype = _error_code
740
strerror = _library.gnutls_strerror
741
strerror.argtypes = [ctypes.c_int]
742
strerror.restype = ctypes.c_char_p
744
certificate_type_get = _library.gnutls_certificate_type_get
745
certificate_type_get.argtypes = [ClientSession]
746
certificate_type_get.restype = _error_code
748
certificate_get_peers = _library.gnutls_certificate_get_peers
749
certificate_get_peers.argtypes = [ClientSession,
750
ctypes.POINTER(ctypes.c_uint)]
751
certificate_get_peers.restype = ctypes.POINTER(datum_t)
753
global_set_log_level = _library.gnutls_global_set_log_level
754
global_set_log_level.argtypes = [ctypes.c_int]
755
global_set_log_level.restype = None
757
global_set_log_function = _library.gnutls_global_set_log_function
758
global_set_log_function.argtypes = [log_func]
759
global_set_log_function.restype = None
761
deinit = _library.gnutls_deinit
762
deinit.argtypes = [ClientSession]
763
deinit.restype = None
765
handshake = _library.gnutls_handshake
766
handshake.argtypes = [ClientSession]
767
handshake.restype = ctypes.c_int
768
handshake.errcheck = _retry_on_error
770
transport_set_ptr = _library.gnutls_transport_set_ptr
771
transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]
772
transport_set_ptr.restype = None
774
bye = _library.gnutls_bye
775
bye.argtypes = [ClientSession, close_request_t]
776
bye.restype = ctypes.c_int
777
bye.errcheck = _retry_on_error
779
check_version = _library.gnutls_check_version
780
check_version.argtypes = [ctypes.c_char_p]
781
check_version.restype = ctypes.c_char_p
783
_need_version = b"3.3.0"
784
if check_version(_need_version) is None:
785
raise self.Error("Needs GnuTLS {} or later"
786
.format(_need_version))
788
_tls_rawpk_version = b"3.6.6"
789
has_rawpk = bool(check_version(_tls_rawpk_version))
793
class pubkey_st(ctypes.Structure):
795
pubkey_t = ctypes.POINTER(pubkey_st)
797
x509_crt_fmt_t = ctypes.c_int
799
# All the function declarations below are from
801
pubkey_init = _library.gnutls_pubkey_init
802
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
803
pubkey_init.restype = _error_code
805
pubkey_import = _library.gnutls_pubkey_import
806
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
808
pubkey_import.restype = _error_code
810
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
811
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
812
ctypes.POINTER(ctypes.c_ubyte),
813
ctypes.POINTER(ctypes.c_size_t)]
814
pubkey_get_key_id.restype = _error_code
816
pubkey_deinit = _library.gnutls_pubkey_deinit
817
pubkey_deinit.argtypes = [pubkey_t]
818
pubkey_deinit.restype = None
820
# All the function declarations below are from
823
openpgp_crt_init = _library.gnutls_openpgp_crt_init
824
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
825
openpgp_crt_init.restype = _error_code
827
openpgp_crt_import = _library.gnutls_openpgp_crt_import
828
openpgp_crt_import.argtypes = [openpgp_crt_t,
829
ctypes.POINTER(datum_t),
831
openpgp_crt_import.restype = _error_code
833
openpgp_crt_verify_self = \
834
_library.gnutls_openpgp_crt_verify_self
835
openpgp_crt_verify_self.argtypes = [
838
ctypes.POINTER(ctypes.c_uint),
840
openpgp_crt_verify_self.restype = _error_code
842
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
843
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
844
openpgp_crt_deinit.restype = None
846
openpgp_crt_get_fingerprint = (
847
_library.gnutls_openpgp_crt_get_fingerprint)
848
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
852
openpgp_crt_get_fingerprint.restype = _error_code
854
if check_version(b"3.6.4"):
855
certificate_type_get2 = _library.gnutls_certificate_type_get2
856
certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]
857
certificate_type_get2.restype = _error_code
859
# Remove non-public functions
860
del _error_code, _retry_on_error
863
def call_pipe(connection, # : multiprocessing.Connection
864
func, *args, **kwargs):
865
"""This function is meant to be called by multiprocessing.Process
867
This function runs func(*args, **kwargs), and writes the resulting
868
return value on the provided multiprocessing.Connection.
870
connection.send(func(*args, **kwargs))
179
875
"""A representation of a client host served by this server.
181
name: string; from the config file, used in log messages
878
approved: bool(); None if not yet approved/disapproved
879
approval_delay: datetime.timedelta(); Time to wait for approval
880
approval_duration: datetime.timedelta(); Duration of one approval
881
checker: multiprocessing.Process(); a running checker process used
882
to see if the client lives. None if no process is
884
checker_callback_tag: a GLib event source tag, or None
885
checker_command: string; External command which is run to check
886
if client lives. %() expansions are done at
887
runtime with vars(self) as dict, so that for
888
instance %(name)s can be used in the command.
889
checker_initiator_tag: a GLib event source tag, or None
890
created: datetime.datetime(); (UTC) object creation
891
client_structure: Object describing what attributes a client has
892
and is used for storing the client at exit
893
current_checker_command: string; current running checker_command
894
disable_initiator_tag: a GLib event source tag, or None
182
896
fingerprint: string (40 or 32 hexadecimal digits); used to
183
uniquely identify the client
184
secret: bytestring; sent verbatim (over TLS) to client
897
uniquely identify an OpenPGP client
898
key_id: string (64 hexadecimal digits); used to uniquely identify
899
a client using raw public keys
185
900
host: string; available for use by the checker command
186
created: datetime.datetime(); (UTC) object creation
187
last_enabled: datetime.datetime(); (UTC)
901
interval: datetime.timedelta(); How often to start a new checker
902
last_approval_request: datetime.datetime(); (UTC) or None
189
903
last_checked_ok: datetime.datetime(); (UTC) or None
904
last_checker_status: integer between 0 and 255 reflecting exit
905
status of last checker. -1 reflects crashed
906
checker, -2 means no checker completed yet.
907
last_checker_signal: The signal which killed the last checker, if
908
last_checker_status is -1
909
last_enabled: datetime.datetime(); (UTC) or None
910
name: string; from the config file, used in log messages and
912
secret: bytestring; sent verbatim (over TLS) to client
190
913
timeout: datetime.timedelta(); How long from last_checked_ok
191
until this client is invalid
192
interval: datetime.timedelta(); How often to start a new checker
193
disable_hook: If set, called by disable() as disable_hook(self)
194
checker: subprocess.Popen(); a running checker process used
195
to see if the client lives.
196
'None' if no process is running.
197
checker_initiator_tag: a gobject event source tag, or None
198
disable_initiator_tag: - '' -
199
checker_callback_tag: - '' -
200
checker_command: string; External command which is run to check if
201
client lives. %() expansions are done at
202
runtime with vars(self) as dict, so that for
203
instance %(name)s can be used in the command.
204
use_dbus: bool(); Whether to provide D-Bus interface and signals
205
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
914
until this client is disabled
915
extended_timeout: extra long timeout when secret has been sent
916
runtime_expansions: Allowed attributes for runtime expansion.
917
expires: datetime.datetime(); time (UTC) when a client will be
919
server_settings: The server_settings dict from main()
207
def timeout_milliseconds(self):
208
"Return the 'timeout' attribute in milliseconds"
209
return ((self.timeout.days * 24 * 60 * 60 * 1000)
210
+ (self.timeout.seconds * 1000)
211
+ (self.timeout.microseconds // 1000))
213
def interval_milliseconds(self):
214
"Return the 'interval' attribute in milliseconds"
215
return ((self.interval.days * 24 * 60 * 60 * 1000)
216
+ (self.interval.seconds * 1000)
217
+ (self.interval.microseconds // 1000))
219
def __init__(self, name = None, disable_hook=None, config=None,
221
"""Note: the 'checker' key in 'config' sets the
222
'checker_command' attribute and *not* the 'checker'
922
runtime_expansions = ("approval_delay", "approval_duration",
923
"created", "enabled", "expires", "key_id",
924
"fingerprint", "host", "interval",
925
"last_approval_request", "last_checked_ok",
926
"last_enabled", "name", "timeout")
929
"extended_timeout": "PT15M",
931
"checker": "fping -q -- %%(host)s",
933
"approval_delay": "PT0S",
934
"approval_duration": "PT1S",
935
"approved_by_default": "True",
940
def config_parser(config):
941
"""Construct a new dict of client settings of this form:
942
{ client_name: {setting_name: value, ...}, ...}
943
with exceptions for any special settings as defined above.
944
NOTE: Must be a pure function. Must return the same result
945
value given the same arguments.
948
for client_name in config.sections():
949
section = dict(config.items(client_name))
950
client = settings[client_name] = {}
952
client["host"] = section["host"]
953
# Reformat values from string types to Python types
954
client["approved_by_default"] = config.getboolean(
955
client_name, "approved_by_default")
956
client["enabled"] = config.getboolean(client_name,
959
# Uppercase and remove spaces from key_id and fingerprint
960
# for later comparison purposes with return value from the
961
# key_id() and fingerprint() functions
962
client["key_id"] = (section.get("key_id", "").upper()
964
client["fingerprint"] = (section["fingerprint"].upper()
966
if "secret" in section:
967
client["secret"] = codecs.decode(section["secret"]
970
elif "secfile" in section:
971
with open(os.path.expanduser(os.path.expandvars
972
(section["secfile"])),
974
client["secret"] = secfile.read()
976
raise TypeError("No secret or secfile for section {}"
978
client["timeout"] = string_to_delta(section["timeout"])
979
client["extended_timeout"] = string_to_delta(
980
section["extended_timeout"])
981
client["interval"] = string_to_delta(section["interval"])
982
client["approval_delay"] = string_to_delta(
983
section["approval_delay"])
984
client["approval_duration"] = string_to_delta(
985
section["approval_duration"])
986
client["checker_command"] = section["checker"]
987
client["last_approval_request"] = None
988
client["last_checked_ok"] = None
989
client["last_checker_status"] = -2
993
def __init__(self, settings, name=None, server_settings=None):
227
logger.debug(u"Creating client %r", self.name)
228
self.use_dbus = use_dbus
230
self.dbus_object_path = (dbus.ObjectPath
232
+ self.name.replace(".", "_")))
233
dbus.service.Object.__init__(self, bus,
234
self.dbus_object_path)
235
# Uppercase and remove spaces from fingerprint for later
236
# comparison purposes with return value from the fingerprint()
238
self.fingerprint = (config["fingerprint"].upper()
240
logger.debug(u" Fingerprint: %s", self.fingerprint)
241
if "secret" in config:
242
self.secret = config["secret"].decode(u"base64")
243
elif "secfile" in config:
244
with closing(open(os.path.expanduser
246
(config["secfile"])))) as secfile:
247
self.secret = secfile.read()
995
if server_settings is None:
997
self.server_settings = server_settings
998
# adding all client settings
999
for setting, value in settings.items():
1000
setattr(self, setting, value)
1003
if not hasattr(self, "last_enabled"):
1004
self.last_enabled = datetime.datetime.utcnow()
1005
if not hasattr(self, "expires"):
1006
self.expires = (datetime.datetime.utcnow()
249
raise TypeError(u"No secret or secfile for client %s"
251
self.host = config.get("host", "")
252
self.created = datetime.datetime.utcnow()
254
self.last_enabled = None
255
self.last_checked_ok = None
256
self.timeout = string_to_delta(config["timeout"])
257
self.interval = string_to_delta(config["interval"])
258
self.disable_hook = disable_hook
1009
self.last_enabled = None
1012
log.debug("Creating client %r", self.name)
1013
log.debug(" Key ID: %s", self.key_id)
1014
log.debug(" Fingerprint: %s", self.fingerprint)
1015
self.created = settings.get("created",
1016
datetime.datetime.utcnow())
1018
# attributes specific for this server instance
259
1019
self.checker = None
260
1020
self.checker_initiator_tag = None
261
1021
self.disable_initiator_tag = None
262
1022
self.checker_callback_tag = None
263
self.checker_command = config["checker"]
1023
self.current_checker_command = None
1024
self.approved = None
1025
self.approvals_pending = 0
1026
self.changedstate = multiprocessing_manager.Condition(
1027
multiprocessing_manager.Lock())
1028
self.client_structure = [attr
1029
for attr in self.__dict__.keys()
1030
if not attr.startswith("_")]
1031
self.client_structure.append("client_structure")
1033
for name, t in inspect.getmembers(
1034
type(self), lambda obj: isinstance(obj, property)):
1035
if not name.startswith("_"):
1036
self.client_structure.append(name)
1038
# Send notice to process children that client state has changed
1039
def send_changedstate(self):
1040
with self.changedstate:
1041
self.changedstate.notify_all()
265
1043
def enable(self):
266
1044
"""Start this client's checker and timeout hooks"""
1045
if getattr(self, "enabled", False):
267
1049
self.last_enabled = datetime.datetime.utcnow()
268
# Schedule a new checker to be started an 'interval' from now,
269
# and every interval from then on.
270
self.checker_initiator_tag = (gobject.timeout_add
271
(self.interval_milliseconds(),
273
# Also start a new checker *right now*.
275
# Schedule a disable() when 'timeout' has passed
276
self.disable_initiator_tag = (gobject.timeout_add
277
(self.timeout_milliseconds(),
282
self.PropertyChanged(dbus.String(u"enabled"),
283
dbus.Boolean(True, variant_level=1))
284
self.PropertyChanged(dbus.String(u"last_enabled"),
285
(_datetime_to_dbus(self.last_enabled,
1051
self.send_changedstate()
1053
def disable(self, quiet=True):
289
1054
"""Disable this client."""
290
1055
if not getattr(self, "enabled", False):
292
logger.info(u"Disabling client %s", self.name)
293
if getattr(self, "disable_initiator_tag", False):
294
gobject.source_remove(self.disable_initiator_tag)
1058
log.info("Disabling client %s", self.name)
1059
if getattr(self, "disable_initiator_tag", None) is not None:
1060
GLib.source_remove(self.disable_initiator_tag)
295
1061
self.disable_initiator_tag = None
296
if getattr(self, "checker_initiator_tag", False):
297
gobject.source_remove(self.checker_initiator_tag)
1063
if getattr(self, "checker_initiator_tag", None) is not None:
1064
GLib.source_remove(self.checker_initiator_tag)
298
1065
self.checker_initiator_tag = None
299
1066
self.stop_checker()
300
if self.disable_hook:
301
self.disable_hook(self)
302
1067
self.enabled = False
305
self.PropertyChanged(dbus.String(u"enabled"),
306
dbus.Boolean(False, variant_level=1))
307
# Do not run this again if called by a gobject.timeout_add
1069
self.send_changedstate()
1070
# Do not run this again if called by a GLib.timeout_add
310
1073
def __del__(self):
311
self.disable_hook = None
314
def checker_callback(self, pid, condition, command):
1076
def init_checker(self, randomize_start=False):
1077
# Schedule a new checker to be started a randomly selected
1078
# time (a fraction of 'interval') from now. This spreads out
1079
# the startup of checkers over time when the server is
1081
if self.checker_initiator_tag is not None:
1082
GLib.source_remove(self.checker_initiator_tag)
1083
interval_milliseconds = int(self.interval.total_seconds()
1086
delay_milliseconds = random.randrange(
1087
interval_milliseconds + 1)
1089
delay_milliseconds = interval_milliseconds
1090
self.checker_initiator_tag = GLib.timeout_add(
1091
delay_milliseconds, self.start_checker, randomize_start)
1092
delay = datetime.timedelta(0, 0, 0, delay_milliseconds)
1093
# A checker might take up to an 'interval' of time, so we can
1094
# expire at the soonest one interval after a checker was
1095
# started. Since the initial checker is delayed, the expire
1096
# time might have to be extended.
1097
now = datetime.datetime.utcnow()
1098
self.expires = now + delay + self.interval
1099
# Schedule a disable() at expire time
1100
if self.disable_initiator_tag is not None:
1101
GLib.source_remove(self.disable_initiator_tag)
1102
self.disable_initiator_tag = GLib.timeout_add(
1103
int((self.expires - now).total_seconds() * 1000),
1106
def checker_callback(self, source, condition, connection,
315
1108
"""The checker has completed, so take appropriate actions."""
1109
# Read return code from connection (see call_pipe)
1110
returncode = connection.recv()
1112
if self.checker is not None:
316
1114
self.checker_callback_tag = None
317
1115
self.checker = None
320
self.PropertyChanged(dbus.String(u"checker_running"),
321
dbus.Boolean(False, variant_level=1))
322
if (os.WIFEXITED(condition)
323
and (os.WEXITSTATUS(condition) == 0)):
324
logger.info(u"Checker for %(name)s succeeded",
328
self.CheckerCompleted(dbus.Boolean(True),
329
dbus.UInt16(condition),
330
dbus.String(command))
332
elif not os.WIFEXITED(condition):
333
logger.warning(u"Checker for %(name)s crashed?",
337
self.CheckerCompleted(dbus.Boolean(False),
338
dbus.UInt16(condition),
339
dbus.String(command))
1118
self.last_checker_status = returncode
1119
self.last_checker_signal = None
1120
if self.last_checker_status == 0:
1121
log.info("Checker for %(name)s succeeded", vars(self))
1124
log.info("Checker for %(name)s failed", vars(self))
341
logger.info(u"Checker for %(name)s failed",
345
self.CheckerCompleted(dbus.Boolean(False),
346
dbus.UInt16(condition),
347
dbus.String(command))
349
def bump_timeout(self):
350
"""Bump up the timeout for this client.
351
This should only be called when the client has been seen,
1126
self.last_checker_status = -1
1127
self.last_checker_signal = -returncode
1128
log.warning("Checker for %(name)s crashed?", vars(self))
1131
def checked_ok(self):
1132
"""Assert that the client has been seen, alive and well."""
354
1133
self.last_checked_ok = datetime.datetime.utcnow()
355
gobject.source_remove(self.disable_initiator_tag)
356
self.disable_initiator_tag = (gobject.timeout_add
357
(self.timeout_milliseconds(),
361
self.PropertyChanged(
362
dbus.String(u"last_checked_ok"),
363
(_datetime_to_dbus(self.last_checked_ok,
366
def start_checker(self):
1134
self.last_checker_status = 0
1135
self.last_checker_signal = None
1138
def bump_timeout(self, timeout=None):
1139
"""Bump up the timeout for this client."""
1141
timeout = self.timeout
1142
if self.disable_initiator_tag is not None:
1143
GLib.source_remove(self.disable_initiator_tag)
1144
self.disable_initiator_tag = None
1145
if getattr(self, "enabled", False):
1146
self.disable_initiator_tag = GLib.timeout_add(
1147
int(timeout.total_seconds() * 1000), self.disable)
1148
self.expires = datetime.datetime.utcnow() + timeout
1150
def need_approval(self):
1151
self.last_approval_request = datetime.datetime.utcnow()
1153
def start_checker(self, start_was_randomized=False):
367
1154
"""Start a new checker subprocess if one is not running.
368
1156
If a checker already exists, leave it running and do
370
1158
# The reason for not killing a running checker is that if we
371
# did that, then if a checker (for some reason) started
372
# running slowly and taking more than 'interval' time, the
373
# client would inevitably timeout, since no checker would get
374
# a chance to run to completion. If we instead leave running
1159
# did that, and if a checker (for some reason) started running
1160
# slowly and taking more than 'interval' time, then the client
1161
# would inevitably timeout, since no checker would get a
1162
# chance to run to completion. If we instead leave running
375
1163
# checkers alone, the checker would have to take more time
376
# than 'timeout' for the client to be declared invalid, which
377
# is as it should be.
1164
# than 'timeout' for the client to be disabled, which is as it
1167
if self.checker is not None and not self.checker.is_alive():
1168
log.warning("Checker was not alive; joining")
1171
# Start a new checker if needed
378
1172
if self.checker is None:
380
# In case checker_command has exactly one % operator
381
command = self.checker_command % self.host
383
# Escape attributes for the shell
384
escaped_attrs = dict((key, re.escape(str(val)))
386
vars(self).iteritems())
388
command = self.checker_command % escaped_attrs
389
except TypeError, error:
390
logger.error(u'Could not format string "%s":'
391
u' %s', self.checker_command, error)
392
return True # Try again later
394
logger.info(u"Starting checker %r for %s",
396
# We don't need to redirect stdout and stderr, since
397
# in normal mode, that is already done by daemon(),
398
# and in debug mode we don't want to. (Stdin is
399
# always replaced by /dev/null.)
400
self.checker = subprocess.Popen(command,
405
self.CheckerStarted(command)
406
self.PropertyChanged(
407
dbus.String("checker_running"),
408
dbus.Boolean(True, variant_level=1))
409
self.checker_callback_tag = (gobject.child_watch_add
411
self.checker_callback,
413
except OSError, error:
414
logger.error(u"Failed to start subprocess: %s",
416
# Re-run this periodically if run by gobject.timeout_add
1173
# Escape attributes for the shell
1175
attr: shlex.quote(str(getattr(self, attr)))
1176
for attr in self.runtime_expansions}
1178
command = self.checker_command % escaped_attrs
1179
except TypeError as error:
1180
log.error('Could not format string "%s"',
1181
self.checker_command, exc_info=error)
1182
return True # Try again later
1183
self.current_checker_command = command
1184
log.info("Starting checker %r for %s", command, self.name)
1185
# We don't need to redirect stdout and stderr, since
1186
# in normal mode, that is already done by daemon(),
1187
# and in debug mode we don't want to. (Stdin is
1188
# always replaced by /dev/null.)
1189
# The exception is when not debugging but nevertheless
1190
# running in the foreground; use the previously
1192
popen_args = {"close_fds": True,
1195
if (not self.server_settings["debug"]
1196
and self.server_settings["foreground"]):
1197
popen_args.update({"stdout": wnull,
1199
pipe = multiprocessing.Pipe(duplex=False)
1200
self.checker = multiprocessing.Process(
1202
args=(pipe[1], subprocess.call, command),
1204
self.checker.start()
1205
self.checker_callback_tag = GLib.io_add_watch(
1206
GLib.IOChannel.unix_new(pipe[0].fileno()),
1207
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1208
self.checker_callback, pipe[0], command)
1209
if start_was_randomized:
1210
# We were started after a random delay; Schedule a new
1211
# checker to be started an 'interval' from now, and every
1212
# interval from then on.
1213
now = datetime.datetime.utcnow()
1214
self.checker_initiator_tag = GLib.timeout_add(
1215
int(self.interval.total_seconds() * 1000),
1217
self.expires = max(self.expires, now + self.interval)
1218
# Don't start a new checker again after same random delay
1220
# Re-run this periodically if run by GLib.timeout_add
419
1223
def stop_checker(self):
420
1224
"""Force the checker process, if any, to stop."""
421
1225
if self.checker_callback_tag:
422
gobject.source_remove(self.checker_callback_tag)
1226
GLib.source_remove(self.checker_callback_tag)
423
1227
self.checker_callback_tag = None
424
1228
if getattr(self, "checker", None) is None:
426
logger.debug(u"Stopping checker for %(name)s", vars(self))
428
os.kill(self.checker.pid, signal.SIGTERM)
430
#if self.checker.poll() is None:
431
# os.kill(self.checker.pid, signal.SIGKILL)
432
except OSError, error:
433
if error.errno != errno.ESRCH: # No such process
1230
log.debug("Stopping checker for %(name)s", vars(self))
1231
self.checker.terminate()
435
1232
self.checker = None
437
self.PropertyChanged(dbus.String(u"checker_running"),
438
dbus.Boolean(False, variant_level=1))
440
def still_valid(self):
441
"""Has the timeout not yet passed for this client?"""
442
if not getattr(self, "enabled", False):
444
now = datetime.datetime.utcnow()
445
if self.last_checked_ok is None:
446
return now < (self.created + self.timeout)
1235
def dbus_service_property(dbus_interface,
1239
"""Decorators for marking methods of a DBusObjectWithProperties to
1240
become properties on the D-Bus.
1242
The decorated method will be called with no arguments by "Get"
1243
and with one argument by "Set".
1245
The parameters, where they are supported, are the same as
1246
dbus.service.method, except there is only "signature", since the
1247
type from Get() and the type sent to Set() is the same.
1249
# Encoding deeply encoded byte arrays is not supported yet by the
1250
# "Set" method, so we fail early here:
1251
if byte_arrays and signature != "ay":
1252
raise ValueError("Byte arrays not supported for non-'ay'"
1253
" signature {!r}".format(signature))
1255
def decorator(func):
1256
func._dbus_is_property = True
1257
func._dbus_interface = dbus_interface
1258
func._dbus_signature = signature
1259
func._dbus_access = access
1260
func._dbus_name = func.__name__
1261
if func._dbus_name.endswith("_dbus_property"):
1262
func._dbus_name = func._dbus_name[:-14]
1263
func._dbus_get_args_options = {"byte_arrays": byte_arrays}
1269
def dbus_interface_annotations(dbus_interface):
1270
"""Decorator for marking functions returning interface annotations
1274
@dbus_interface_annotations("org.example.Interface")
1275
def _foo(self): # Function name does not matter
1276
return {"org.freedesktop.DBus.Deprecated": "true",
1277
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1281
def decorator(func):
1282
func._dbus_is_interface = True
1283
func._dbus_interface = dbus_interface
1284
func._dbus_name = dbus_interface
1290
def dbus_annotations(annotations):
1291
"""Decorator to annotate D-Bus methods, signals or properties
1294
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1295
"org.freedesktop.DBus.Property."
1296
"EmitsChangedSignal": "false"})
1297
@dbus_service_property("org.example.Interface", signature="b",
1299
def Property_dbus_property(self):
1300
return dbus.Boolean(False)
1302
See also the DBusObjectWithAnnotations class.
1305
def decorator(func):
1306
func._dbus_annotations = annotations
1312
class DBusPropertyException(dbus.exceptions.DBusException):
1313
"""A base class for D-Bus property-related exceptions
1318
class DBusPropertyAccessException(DBusPropertyException):
1319
"""A property's access permissions disallows an operation.
1324
class DBusPropertyNotFound(DBusPropertyException):
1325
"""An attempt was made to access a non-existing property.
1330
class DBusObjectWithAnnotations(dbus.service.Object):
1331
"""A D-Bus object with annotations.
1333
Classes inheriting from this can use the dbus_annotations
1334
decorator to add annotations to methods or signals.
1338
def _is_dbus_thing(thing):
1339
"""Returns a function testing if an attribute is a D-Bus thing
1341
If called like _is_dbus_thing("method") it returns a function
1342
suitable for use as predicate to inspect.getmembers().
1344
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
1347
def _get_all_dbus_things(self, thing):
1348
"""Returns a generator of (name, attribute) pairs
1350
return ((getattr(athing.__get__(self), "_dbus_name", name),
1351
athing.__get__(self))
1352
for cls in self.__class__.__mro__
1354
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1356
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1358
path_keyword="object_path",
1359
connection_keyword="connection")
1360
def Introspect(self, object_path, connection):
1361
"""Overloading of standard D-Bus method.
1363
Inserts annotation tags on methods and signals.
1365
xmlstring = dbus.service.Object.Introspect(self, object_path,
1368
document = xml.dom.minidom.parseString(xmlstring)
1370
for if_tag in document.getElementsByTagName("interface"):
1371
# Add annotation tags
1372
for typ in ("method", "signal"):
1373
for tag in if_tag.getElementsByTagName(typ):
1375
for name, prop in (self.
1376
_get_all_dbus_things(typ)):
1377
if (name == tag.getAttribute("name")
1378
and prop._dbus_interface
1379
== if_tag.getAttribute("name")):
1380
annots.update(getattr(
1381
prop, "_dbus_annotations", {}))
1382
for name, value in annots.items():
1383
ann_tag = document.createElement(
1385
ann_tag.setAttribute("name", name)
1386
ann_tag.setAttribute("value", value)
1387
tag.appendChild(ann_tag)
1388
# Add interface annotation tags
1389
for annotation, value in dict(
1390
itertools.chain.from_iterable(
1391
annotations().items()
1392
for name, annotations
1393
in self._get_all_dbus_things("interface")
1394
if name == if_tag.getAttribute("name")
1396
ann_tag = document.createElement("annotation")
1397
ann_tag.setAttribute("name", annotation)
1398
ann_tag.setAttribute("value", value)
1399
if_tag.appendChild(ann_tag)
1400
# Fix argument name for the Introspect method itself
1401
if (if_tag.getAttribute("name")
1402
== dbus.INTROSPECTABLE_IFACE):
1403
for cn in if_tag.getElementsByTagName("method"):
1404
if cn.getAttribute("name") == "Introspect":
1405
for arg in cn.getElementsByTagName("arg"):
1406
if (arg.getAttribute("direction")
1408
arg.setAttribute("name",
1410
xmlstring = document.toxml("utf-8")
1412
except (AttributeError, xml.dom.DOMException,
1413
xml.parsers.expat.ExpatError) as error:
1414
log.error("Failed to override Introspection method",
1419
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1420
"""A D-Bus object with properties.
1422
Classes inheriting from this can use the dbus_service_property
1423
decorator to expose methods as D-Bus properties. It exposes the
1424
standard Get(), Set(), and GetAll() methods on the D-Bus.
1427
def _get_dbus_property(self, interface_name, property_name):
1428
"""Returns a bound method if one exists which is a D-Bus
1429
property with the specified name and interface.
1431
for cls in self.__class__.__mro__:
1432
for name, value in inspect.getmembers(
1433
cls, self._is_dbus_thing("property")):
1434
if (value._dbus_name == property_name
1435
and value._dbus_interface == interface_name):
1436
return value.__get__(self)
1439
raise DBusPropertyNotFound("{}:{}.{}".format(
1440
self.dbus_object_path, interface_name, property_name))
1443
def _get_all_interface_names(cls):
1444
"""Get a sequence of all interfaces supported by an object"""
1445
return (name for name in set(getattr(getattr(x, attr),
1446
"_dbus_interface", None)
1447
for x in (inspect.getmro(cls))
1449
if name is not None)
1451
@dbus.service.method(dbus.PROPERTIES_IFACE,
1454
def Get(self, interface_name, property_name):
1455
"""Standard D-Bus property Get() method, see D-Bus standard.
1457
prop = self._get_dbus_property(interface_name, property_name)
1458
if prop._dbus_access == "write":
1459
raise DBusPropertyAccessException(property_name)
1461
if not hasattr(value, "variant_level"):
1463
return type(value)(value, variant_level=value.variant_level+1)
1465
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
1466
def Set(self, interface_name, property_name, value):
1467
"""Standard D-Bus property Set() method, see D-Bus standard.
1469
prop = self._get_dbus_property(interface_name, property_name)
1470
if prop._dbus_access == "read":
1471
raise DBusPropertyAccessException(property_name)
1472
if prop._dbus_get_args_options["byte_arrays"]:
1473
# The byte_arrays option is not supported yet on
1474
# signatures other than "ay".
1475
if prop._dbus_signature != "ay":
1476
raise ValueError("Byte arrays not supported for non-"
1477
"'ay' signature {!r}"
1478
.format(prop._dbus_signature))
1479
value = dbus.ByteArray(bytes(value))
1482
@dbus.service.method(dbus.PROPERTIES_IFACE,
1484
out_signature="a{sv}")
1485
def GetAll(self, interface_name):
1486
"""Standard D-Bus property GetAll() method, see D-Bus
1489
Note: Will not include properties with access="write".
1492
for name, prop in self._get_all_dbus_things("property"):
1494
and interface_name != prop._dbus_interface):
1495
# Interface non-empty but did not match
1497
# Ignore write-only properties
1498
if prop._dbus_access == "write":
1501
if not hasattr(value, "variant_level"):
1502
properties[name] = value
1504
properties[name] = type(value)(
1505
value, variant_level=value.variant_level + 1)
1506
return dbus.Dictionary(properties, signature="sv")
1508
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1509
def PropertiesChanged(self, interface_name, changed_properties,
1510
invalidated_properties):
1511
"""Standard D-Bus PropertiesChanged() signal, see D-Bus
1516
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1518
path_keyword="object_path",
1519
connection_keyword="connection")
1520
def Introspect(self, object_path, connection):
1521
"""Overloading of standard D-Bus method.
1523
Inserts property tags and interface annotation tags.
1525
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1529
document = xml.dom.minidom.parseString(xmlstring)
1531
def make_tag(document, name, prop):
1532
e = document.createElement("property")
1533
e.setAttribute("name", name)
1534
e.setAttribute("type", prop._dbus_signature)
1535
e.setAttribute("access", prop._dbus_access)
1538
for if_tag in document.getElementsByTagName("interface"):
1540
for tag in (make_tag(document, name, prop)
1542
in self._get_all_dbus_things("property")
1543
if prop._dbus_interface
1544
== if_tag.getAttribute("name")):
1545
if_tag.appendChild(tag)
1546
# Add annotation tags for properties
1547
for tag in if_tag.getElementsByTagName("property"):
1549
for name, prop in self._get_all_dbus_things(
1551
if (name == tag.getAttribute("name")
1552
and prop._dbus_interface
1553
== if_tag.getAttribute("name")):
1554
annots.update(getattr(
1555
prop, "_dbus_annotations", {}))
1556
for name, value in annots.items():
1557
ann_tag = document.createElement(
1559
ann_tag.setAttribute("name", name)
1560
ann_tag.setAttribute("value", value)
1561
tag.appendChild(ann_tag)
1562
# Add the names to the return values for the
1563
# "org.freedesktop.DBus.Properties" methods
1564
if (if_tag.getAttribute("name")
1565
== "org.freedesktop.DBus.Properties"):
1566
for cn in if_tag.getElementsByTagName("method"):
1567
if cn.getAttribute("name") == "Get":
1568
for arg in cn.getElementsByTagName("arg"):
1569
if (arg.getAttribute("direction")
1571
arg.setAttribute("name", "value")
1572
elif cn.getAttribute("name") == "GetAll":
1573
for arg in cn.getElementsByTagName("arg"):
1574
if (arg.getAttribute("direction")
1576
arg.setAttribute("name", "props")
1577
xmlstring = document.toxml("utf-8")
1579
except (AttributeError, xml.dom.DOMException,
1580
xml.parsers.expat.ExpatError) as error:
1581
log.error("Failed to override Introspection method",
1587
dbus.OBJECT_MANAGER_IFACE
1588
except AttributeError:
1589
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1592
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1593
"""A D-Bus object with an ObjectManager.
1595
Classes inheriting from this exposes the standard
1596
GetManagedObjects call and the InterfacesAdded and
1597
InterfacesRemoved signals on the standard
1598
"org.freedesktop.DBus.ObjectManager" interface.
1600
Note: No signals are sent automatically; they must be sent
1603
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1604
out_signature="a{oa{sa{sv}}}")
1605
def GetManagedObjects(self):
1606
"""This function must be overridden"""
1607
raise NotImplementedError()
1609
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1610
signature="oa{sa{sv}}")
1611
def InterfacesAdded(self, object_path, interfaces_and_properties):
1614
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1615
def InterfacesRemoved(self, object_path, interfaces):
1618
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1620
path_keyword="object_path",
1621
connection_keyword="connection")
1622
def Introspect(self, object_path, connection):
1623
"""Overloading of standard D-Bus method.
1625
Override return argument name of GetManagedObjects to be
1626
"objpath_interfaces_and_properties"
1628
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1632
document = xml.dom.minidom.parseString(xmlstring)
1634
for if_tag in document.getElementsByTagName("interface"):
1635
# Fix argument name for the GetManagedObjects method
1636
if (if_tag.getAttribute("name")
1637
== dbus.OBJECT_MANAGER_IFACE):
1638
for cn in if_tag.getElementsByTagName("method"):
1639
if (cn.getAttribute("name")
1640
== "GetManagedObjects"):
1641
for arg in cn.getElementsByTagName("arg"):
1642
if (arg.getAttribute("direction")
1646
"objpath_interfaces"
1648
xmlstring = document.toxml("utf-8")
1650
except (AttributeError, xml.dom.DOMException,
1651
xml.parsers.expat.ExpatError) as error:
1652
log.error("Failed to override Introspection method",
1657
def datetime_to_dbus(dt, variant_level=0):
1658
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1660
return dbus.String("", variant_level=variant_level)
1661
return dbus.String(dt.isoformat(), variant_level=variant_level)
1664
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1665
"""A class decorator; applied to a subclass of
1666
dbus.service.Object, it will add alternate D-Bus attributes with
1667
interface names according to the "alt_interface_names" mapping.
1670
@alternate_dbus_interfaces({"org.example.Interface":
1671
"net.example.AlternateInterface"})
1672
class SampleDBusObject(dbus.service.Object):
1673
@dbus.service.method("org.example.Interface")
1674
def SampleDBusMethod():
1677
The above "SampleDBusMethod" on "SampleDBusObject" will be
1678
reachable via two interfaces: "org.example.Interface" and
1679
"net.example.AlternateInterface", the latter of which will have
1680
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1681
"true", unless "deprecate" is passed with a False value.
1683
This works for methods and signals, and also for D-Bus properties
1684
(from DBusObjectWithProperties) and interfaces (from the
1685
dbus_interface_annotations decorator).
1689
for orig_interface_name, alt_interface_name in (
1690
alt_interface_names.items()):
1692
interface_names = set()
1693
# Go though all attributes of the class
1694
for attrname, attribute in inspect.getmembers(cls):
1695
# Ignore non-D-Bus attributes, and D-Bus attributes
1696
# with the wrong interface name
1697
if (not hasattr(attribute, "_dbus_interface")
1698
or not attribute._dbus_interface.startswith(
1699
orig_interface_name)):
1701
# Create an alternate D-Bus interface name based on
1703
alt_interface = attribute._dbus_interface.replace(
1704
orig_interface_name, alt_interface_name)
1705
interface_names.add(alt_interface)
1706
# Is this a D-Bus signal?
1707
if getattr(attribute, "_dbus_is_signal", False):
1708
# Extract the original non-method undecorated
1709
# function by black magic
1710
if sys.version_info.major == 2:
1711
nonmethod_func = (dict(
1712
zip(attribute.func_code.co_freevars,
1713
attribute.__closure__))
1714
["func"].cell_contents)
1716
nonmethod_func = (dict(
1717
zip(attribute.__code__.co_freevars,
1718
attribute.__closure__))
1719
["func"].cell_contents)
1720
# Create a new, but exactly alike, function
1721
# object, and decorate it to be a new D-Bus signal
1722
# with the alternate D-Bus interface name
1723
new_function = copy_function(nonmethod_func)
1724
new_function = (dbus.service.signal(
1726
attribute._dbus_signature)(new_function))
1727
# Copy annotations, if any
1729
new_function._dbus_annotations = dict(
1730
attribute._dbus_annotations)
1731
except AttributeError:
1734
# Define a creator of a function to call both the
1735
# original and alternate functions, so both the
1736
# original and alternate signals gets sent when
1737
# the function is called
1738
def fixscope(func1, func2):
1739
"""This function is a scope container to pass
1740
func1 and func2 to the "call_both" function
1741
outside of its arguments"""
1743
@functools.wraps(func2)
1744
def call_both(*args, **kwargs):
1745
"""This function will emit two D-Bus
1746
signals by calling func1 and func2"""
1747
func1(*args, **kwargs)
1748
func2(*args, **kwargs)
1749
# Make wrapper function look like a D-Bus
1751
for name, attr in inspect.getmembers(func2):
1752
if name.startswith("_dbus_"):
1753
setattr(call_both, name, attr)
1756
# Create the "call_both" function and add it to
1758
attr[attrname] = fixscope(attribute, new_function)
1759
# Is this a D-Bus method?
1760
elif getattr(attribute, "_dbus_is_method", False):
1761
# Create a new, but exactly alike, function
1762
# object. Decorate it to be a new D-Bus method
1763
# with the alternate D-Bus interface name. Add it
1766
dbus.service.method(
1768
attribute._dbus_in_signature,
1769
attribute._dbus_out_signature)
1770
(copy_function(attribute)))
1771
# Copy annotations, if any
1773
attr[attrname]._dbus_annotations = dict(
1774
attribute._dbus_annotations)
1775
except AttributeError:
1777
# Is this a D-Bus property?
1778
elif getattr(attribute, "_dbus_is_property", False):
1779
# Create a new, but exactly alike, function
1780
# object, and decorate it to be a new D-Bus
1781
# property with the alternate D-Bus interface
1782
# name. Add it to the class.
1783
attr[attrname] = (dbus_service_property(
1784
alt_interface, attribute._dbus_signature,
1785
attribute._dbus_access,
1786
attribute._dbus_get_args_options
1788
(copy_function(attribute)))
1789
# Copy annotations, if any
1791
attr[attrname]._dbus_annotations = dict(
1792
attribute._dbus_annotations)
1793
except AttributeError:
1795
# Is this a D-Bus interface?
1796
elif getattr(attribute, "_dbus_is_interface", False):
1797
# Create a new, but exactly alike, function
1798
# object. Decorate it to be a new D-Bus interface
1799
# with the alternate D-Bus interface name. Add it
1802
dbus_interface_annotations(alt_interface)
1803
(copy_function(attribute)))
1805
# Deprecate all alternate interfaces
1806
iname = "_AlternateDBusNames_interface_annotation{}"
1807
for interface_name in interface_names:
1809
@dbus_interface_annotations(interface_name)
1811
return {"org.freedesktop.DBus.Deprecated":
1813
# Find an unused name
1814
for aname in (iname.format(i)
1815
for i in itertools.count()):
1816
if aname not in attr:
1820
# Replace the class with a new subclass of it with
1821
# methods, signals, etc. as created above.
1822
if sys.version_info.major == 2:
1823
cls = type(b"{}Alternate".format(cls.__name__),
1826
cls = type("{}Alternate".format(cls.__name__),
1833
@alternate_dbus_interfaces({"se.recompile.Mandos":
1834
"se.bsnet.fukt.Mandos"})
1835
class ClientDBus(Client, DBusObjectWithProperties):
1836
"""A Client class using D-Bus
1839
dbus_object_path: dbus.ObjectPath
1840
bus: dbus.SystemBus()
1843
runtime_expansions = (Client.runtime_expansions
1844
+ ("dbus_object_path", ))
1846
_interface = "se.recompile.Mandos.Client"
1848
# dbus.service.Object doesn't use super(), so we can't either.
1850
def __init__(self, bus=None, *args, **kwargs):
1852
Client.__init__(self, *args, **kwargs)
1853
# Only now, when this client is initialized, can it show up on
1855
client_object_name = str(self.name).translate(
1856
{ord("."): ord("_"),
1857
ord("-"): ord("_")})
1858
self.dbus_object_path = dbus.ObjectPath(
1859
"/clients/" + client_object_name)
1860
DBusObjectWithProperties.__init__(self, self.bus,
1861
self.dbus_object_path)
1863
def notifychangeproperty(transform_func, dbus_name,
1864
type_func=lambda x: x,
1866
invalidate_only=False,
1867
_interface=_interface):
1868
""" Modify a variable so that it's a property which announces
1869
its changes to DBus.
1871
transform_fun: Function that takes a value and a variant_level
1872
and transforms it to a D-Bus type.
1873
dbus_name: D-Bus name of the variable
1874
type_func: Function that transform the value before sending it
1875
to the D-Bus. Default: no transform
1876
variant_level: D-Bus variant level. Default: 1
1878
attrname = "_{}".format(dbus_name)
1880
def setter(self, value):
1881
if hasattr(self, "dbus_object_path"):
1882
if (not hasattr(self, attrname) or
1883
type_func(getattr(self, attrname, None))
1884
!= type_func(value)):
1886
self.PropertiesChanged(
1887
_interface, dbus.Dictionary(),
1888
dbus.Array((dbus_name, )))
1890
dbus_value = transform_func(
1892
variant_level=variant_level)
1893
self.PropertyChanged(dbus.String(dbus_name),
1895
self.PropertiesChanged(
1897
dbus.Dictionary({dbus.String(dbus_name):
1900
setattr(self, attrname, value)
1902
return property(lambda self: getattr(self, attrname), setter)
1904
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1905
approvals_pending = notifychangeproperty(dbus.Boolean,
1908
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1909
last_enabled = notifychangeproperty(datetime_to_dbus,
1911
checker = notifychangeproperty(
1912
dbus.Boolean, "CheckerRunning",
1913
type_func=lambda checker: checker is not None)
1914
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1916
last_checker_status = notifychangeproperty(dbus.Int16,
1917
"LastCheckerStatus")
1918
last_approval_request = notifychangeproperty(
1919
datetime_to_dbus, "LastApprovalRequest")
1920
approved_by_default = notifychangeproperty(dbus.Boolean,
1921
"ApprovedByDefault")
1922
approval_delay = notifychangeproperty(
1923
dbus.UInt64, "ApprovalDelay",
1924
type_func=lambda td: td.total_seconds() * 1000)
1925
approval_duration = notifychangeproperty(
1926
dbus.UInt64, "ApprovalDuration",
1927
type_func=lambda td: td.total_seconds() * 1000)
1928
host = notifychangeproperty(dbus.String, "Host")
1929
timeout = notifychangeproperty(
1930
dbus.UInt64, "Timeout",
1931
type_func=lambda td: td.total_seconds() * 1000)
1932
extended_timeout = notifychangeproperty(
1933
dbus.UInt64, "ExtendedTimeout",
1934
type_func=lambda td: td.total_seconds() * 1000)
1935
interval = notifychangeproperty(
1936
dbus.UInt64, "Interval",
1937
type_func=lambda td: td.total_seconds() * 1000)
1938
checker_command = notifychangeproperty(dbus.String, "Checker")
1939
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1940
invalidate_only=True)
1942
del notifychangeproperty
1944
def __del__(self, *args, **kwargs):
1946
self.remove_from_connection()
1949
if hasattr(DBusObjectWithProperties, "__del__"):
1950
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1951
Client.__del__(self, *args, **kwargs)
1953
def checker_callback(self, source, condition,
1954
connection, command, *args, **kwargs):
1955
ret = Client.checker_callback(self, source, condition,
1956
connection, command, *args,
1958
exitstatus = self.last_checker_status
1961
self.CheckerCompleted(dbus.Int16(exitstatus),
1962
# This is specific to GNU libC
1963
dbus.Int64(exitstatus << 8),
1964
dbus.String(command))
448
return now < (self.last_checked_ok + self.timeout)
450
## D-Bus methods & signals
451
_interface = u"org.mandos_system.Mandos.Client"
453
# BumpTimeout - method
454
BumpTimeout = dbus.service.method(_interface)(bump_timeout)
455
BumpTimeout.__name__ = "BumpTimeout"
1967
self.CheckerCompleted(dbus.Int16(-1),
1969
# This is specific to GNU libC
1971
| self.last_checker_signal),
1972
dbus.String(command))
1975
def start_checker(self, *args, **kwargs):
1976
old_checker_pid = getattr(self.checker, "pid", None)
1977
r = Client.start_checker(self, *args, **kwargs)
1978
# Only if new checker process was started
1979
if (self.checker is not None
1980
and old_checker_pid != self.checker.pid):
1982
self.CheckerStarted(self.current_checker_command)
1985
def _reset_approved(self):
1986
self.approved = None
1989
def approve(self, value=True):
1990
self.approved = value
1991
GLib.timeout_add(int(self.approval_duration.total_seconds()
1992
* 1000), self._reset_approved)
1993
self.send_changedstate()
1995
# D-Bus methods, signals & properties
457
2001
# CheckerCompleted - signal
458
@dbus.service.signal(_interface, signature="bqs")
459
def CheckerCompleted(self, success, condition, command):
2002
@dbus.service.signal(_interface, signature="nxs")
2003
def CheckerCompleted(self, exitcode, waitstatus, command):
463
2007
# CheckerStarted - signal
464
2008
@dbus.service.signal(_interface, signature="s")
465
2009
def CheckerStarted(self, command):
469
# GetAllProperties - method
470
@dbus.service.method(_interface, out_signature="a{sv}")
471
def GetAllProperties(self):
473
return dbus.Dictionary({
475
dbus.String(self.name, variant_level=1),
476
dbus.String("fingerprint"):
477
dbus.String(self.fingerprint, variant_level=1),
479
dbus.String(self.host, variant_level=1),
480
dbus.String("created"):
481
_datetime_to_dbus(self.created, variant_level=1),
482
dbus.String("last_enabled"):
483
(_datetime_to_dbus(self.last_enabled,
485
if self.last_enabled is not None
486
else dbus.Boolean(False, variant_level=1)),
487
dbus.String("enabled"):
488
dbus.Boolean(self.enabled, variant_level=1),
489
dbus.String("last_checked_ok"):
490
(_datetime_to_dbus(self.last_checked_ok,
492
if self.last_checked_ok is not None
493
else dbus.Boolean (False, variant_level=1)),
494
dbus.String("timeout"):
495
dbus.UInt64(self.timeout_milliseconds(),
497
dbus.String("interval"):
498
dbus.UInt64(self.interval_milliseconds(),
500
dbus.String("checker"):
501
dbus.String(self.checker_command,
503
dbus.String("checker_running"):
504
dbus.Boolean(self.checker is not None,
508
# IsStillValid - method
509
IsStillValid = (dbus.service.method(_interface, out_signature="b")
511
IsStillValid.__name__ = "IsStillValid"
513
2013
# PropertyChanged - signal
2014
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
514
2015
@dbus.service.signal(_interface, signature="sv")
515
2016
def PropertyChanged(self, property, value):
519
# SetChecker - method
520
@dbus.service.method(_interface, in_signature="s")
521
def SetChecker(self, checker):
522
"D-Bus setter method"
523
self.checker_command = checker
525
self.PropertyChanged(dbus.String(u"checker"),
526
dbus.String(self.checker_command,
530
@dbus.service.method(_interface, in_signature="s")
531
def SetHost(self, host):
532
"D-Bus setter method"
535
self.PropertyChanged(dbus.String(u"host"),
536
dbus.String(self.host, variant_level=1))
538
# SetInterval - method
539
@dbus.service.method(_interface, in_signature="t")
540
def SetInterval(self, milliseconds):
541
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
543
self.PropertyChanged(dbus.String(u"interval"),
544
(dbus.UInt64(self.interval_milliseconds(),
548
@dbus.service.method(_interface, in_signature="ay",
550
def SetSecret(self, secret):
551
"D-Bus setter method"
552
self.secret = str(secret)
554
# SetTimeout - method
555
@dbus.service.method(_interface, in_signature="t")
556
def SetTimeout(self, milliseconds):
557
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
559
self.PropertyChanged(dbus.String(u"timeout"),
560
(dbus.UInt64(self.timeout_milliseconds(),
2020
# GotSecret - signal
2021
@dbus.service.signal(_interface)
2022
def GotSecret(self):
2024
Is sent after a successful transfer of secret from the Mandos
2025
server to mandos-client
2030
@dbus.service.signal(_interface, signature="s")
2031
def Rejected(self, reason):
2035
# NeedApproval - signal
2036
@dbus.service.signal(_interface, signature="tb")
2037
def NeedApproval(self, timeout, default):
2039
return self.need_approval()
2044
@dbus.service.method(_interface, in_signature="b")
2045
def Approve(self, value):
2048
# CheckedOK - method
2049
@dbus.service.method(_interface)
2050
def CheckedOK(self):
563
2053
# Enable - method
564
Enable = dbus.service.method(_interface)(enable)
565
Enable.__name__ = "Enable"
2054
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2055
@dbus.service.method(_interface)
567
2060
# StartChecker - method
2061
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
568
2062
@dbus.service.method(_interface)
569
2063
def StartChecker(self):
571
2065
self.start_checker()
573
2067
# Disable - method
2068
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
574
2069
@dbus.service.method(_interface)
575
2070
def Disable(self):
579
2074
# StopChecker - method
580
StopChecker = dbus.service.method(_interface)(stop_checker)
581
StopChecker.__name__ = "StopChecker"
2075
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2076
@dbus.service.method(_interface)
2077
def StopChecker(self):
2082
# ApprovalPending - property
2083
@dbus_service_property(_interface, signature="b", access="read")
2084
def ApprovalPending_dbus_property(self):
2085
return dbus.Boolean(bool(self.approvals_pending))
2087
# ApprovedByDefault - property
2088
@dbus_service_property(_interface,
2091
def ApprovedByDefault_dbus_property(self, value=None):
2092
if value is None: # get
2093
return dbus.Boolean(self.approved_by_default)
2094
self.approved_by_default = bool(value)
2096
# ApprovalDelay - property
2097
@dbus_service_property(_interface,
2100
def ApprovalDelay_dbus_property(self, value=None):
2101
if value is None: # get
2102
return dbus.UInt64(self.approval_delay.total_seconds()
2104
self.approval_delay = datetime.timedelta(0, 0, 0, value)
2106
# ApprovalDuration - property
2107
@dbus_service_property(_interface,
2110
def ApprovalDuration_dbus_property(self, value=None):
2111
if value is None: # get
2112
return dbus.UInt64(self.approval_duration.total_seconds()
2114
self.approval_duration = datetime.timedelta(0, 0, 0, value)
2118
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2119
@dbus_service_property(_interface, signature="s", access="read")
2120
def Name_dbus_property(self):
2121
return dbus.String(self.name)
2125
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2126
@dbus_service_property(_interface, signature="s", access="read")
2127
def KeyID_dbus_property(self):
2128
return dbus.String(self.key_id)
2130
# Fingerprint - property
2132
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2133
@dbus_service_property(_interface, signature="s", access="read")
2134
def Fingerprint_dbus_property(self):
2135
return dbus.String(self.fingerprint)
2138
@dbus_service_property(_interface,
2141
def Host_dbus_property(self, value=None):
2142
if value is None: # get
2143
return dbus.String(self.host)
2144
self.host = str(value)
2146
# Created - property
2148
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2149
@dbus_service_property(_interface, signature="s", access="read")
2150
def Created_dbus_property(self):
2151
return datetime_to_dbus(self.created)
2153
# LastEnabled - property
2154
@dbus_service_property(_interface, signature="s", access="read")
2155
def LastEnabled_dbus_property(self):
2156
return datetime_to_dbus(self.last_enabled)
2158
# Enabled - property
2159
@dbus_service_property(_interface,
2162
def Enabled_dbus_property(self, value=None):
2163
if value is None: # get
2164
return dbus.Boolean(self.enabled)
2170
# LastCheckedOK - property
2171
@dbus_service_property(_interface,
2174
def LastCheckedOK_dbus_property(self, value=None):
2175
if value is not None:
2178
return datetime_to_dbus(self.last_checked_ok)
2180
# LastCheckerStatus - property
2181
@dbus_service_property(_interface, signature="n", access="read")
2182
def LastCheckerStatus_dbus_property(self):
2183
return dbus.Int16(self.last_checker_status)
2185
# Expires - property
2186
@dbus_service_property(_interface, signature="s", access="read")
2187
def Expires_dbus_property(self):
2188
return datetime_to_dbus(self.expires)
2190
# LastApprovalRequest - property
2191
@dbus_service_property(_interface, signature="s", access="read")
2192
def LastApprovalRequest_dbus_property(self):
2193
return datetime_to_dbus(self.last_approval_request)
2195
# Timeout - property
2196
@dbus_service_property(_interface,
2199
def Timeout_dbus_property(self, value=None):
2200
if value is None: # get
2201
return dbus.UInt64(self.timeout.total_seconds() * 1000)
2202
old_timeout = self.timeout
2203
self.timeout = datetime.timedelta(0, 0, 0, value)
2204
# Reschedule disabling
2206
now = datetime.datetime.utcnow()
2207
self.expires += self.timeout - old_timeout
2208
if self.expires <= now:
2209
# The timeout has passed
2212
if (getattr(self, "disable_initiator_tag", None)
2215
GLib.source_remove(self.disable_initiator_tag)
2216
self.disable_initiator_tag = GLib.timeout_add(
2217
int((self.expires - now).total_seconds() * 1000),
2220
# ExtendedTimeout - property
2221
@dbus_service_property(_interface,
2224
def ExtendedTimeout_dbus_property(self, value=None):
2225
if value is None: # get
2226
return dbus.UInt64(self.extended_timeout.total_seconds()
2228
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2230
# Interval - property
2231
@dbus_service_property(_interface,
2234
def Interval_dbus_property(self, value=None):
2235
if value is None: # get
2236
return dbus.UInt64(self.interval.total_seconds() * 1000)
2237
self.interval = datetime.timedelta(0, 0, 0, value)
2238
if getattr(self, "checker_initiator_tag", None) is None:
2241
# Reschedule checker run
2242
GLib.source_remove(self.checker_initiator_tag)
2243
self.checker_initiator_tag = GLib.timeout_add(
2244
value, self.start_checker)
2245
self.start_checker() # Start one now, too
2247
# Checker - property
2248
@dbus_service_property(_interface,
2251
def Checker_dbus_property(self, value=None):
2252
if value is None: # get
2253
return dbus.String(self.checker_command)
2254
self.checker_command = str(value)
2256
# CheckerRunning - property
2257
@dbus_service_property(_interface,
2260
def CheckerRunning_dbus_property(self, value=None):
2261
if value is None: # get
2262
return dbus.Boolean(self.checker is not None)
2264
self.start_checker()
2268
# ObjectPath - property
2270
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2271
"org.freedesktop.DBus.Deprecated": "true"})
2272
@dbus_service_property(_interface, signature="o", access="read")
2273
def ObjectPath_dbus_property(self):
2274
return self.dbus_object_path # is already a dbus.ObjectPath
2278
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
2280
@dbus_service_property(_interface,
2284
def Secret_dbus_property(self, value):
2285
self.secret = bytes(value)
586
def peer_certificate(session):
587
"Return the peer's OpenPGP certificate as a bytestring"
588
# If not an OpenPGP certificate...
589
if (gnutls.library.functions
590
.gnutls_certificate_type_get(session._c_object)
591
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
592
# ...do the normal thing
593
return session.peer_certificate
594
list_size = ctypes.c_uint()
595
cert_list = (gnutls.library.functions
596
.gnutls_certificate_get_peers
597
(session._c_object, ctypes.byref(list_size)))
598
if list_size.value == 0:
601
return ctypes.string_at(cert.data, cert.size)
604
def fingerprint(openpgp):
605
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
606
# New GnuTLS "datum" with the OpenPGP public key
607
datum = (gnutls.library.types
608
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
611
ctypes.c_uint(len(openpgp))))
612
# New empty GnuTLS certificate
613
crt = gnutls.library.types.gnutls_openpgp_crt_t()
614
(gnutls.library.functions
615
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
616
# Import the OpenPGP public key into the certificate
617
(gnutls.library.functions
618
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
619
gnutls.library.constants
620
.GNUTLS_OPENPGP_FMT_RAW))
621
# Verify the self signature in the key
622
crtverify = ctypes.c_uint()
623
(gnutls.library.functions
624
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
625
if crtverify.value != 0:
626
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
627
raise gnutls.errors.CertificateSecurityError("Verify failed")
628
# New buffer for the fingerprint
629
buf = ctypes.create_string_buffer(20)
630
buf_len = ctypes.c_size_t()
631
# Get the fingerprint from the certificate into the buffer
632
(gnutls.library.functions
633
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
634
ctypes.byref(buf_len)))
635
# Deinit the certificate
636
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
637
# Convert the buffer to a Python bytestring
638
fpr = ctypes.string_at(buf, buf_len.value)
639
# Convert the bytestring to hexadecimal notation
640
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
644
class TCP_handler(SocketServer.BaseRequestHandler, object):
645
"""A TCP request handler class.
646
Instantiated by IPv6_TCPServer for each request to handle it.
2291
def __init__(self, child_pipe, key_id, fpr, address):
2292
self._pipe = child_pipe
2293
self._pipe.send(("init", key_id, fpr, address))
2294
if not self._pipe.recv():
2295
raise KeyError(key_id or fpr)
2297
def __getattribute__(self, name):
2299
return super(ProxyClient, self).__getattribute__(name)
2300
self._pipe.send(("getattr", name))
2301
data = self._pipe.recv()
2302
if data[0] == "data":
2304
if data[0] == "function":
2306
def func(*args, **kwargs):
2307
self._pipe.send(("funcall", name, args, kwargs))
2308
return self._pipe.recv()[1]
2312
def __setattr__(self, name, value):
2314
return super(ProxyClient, self).__setattr__(name, value)
2315
self._pipe.send(("setattr", name, value))
2318
class ClientHandler(socketserver.BaseRequestHandler, object):
2319
"""A class to handle client connections.
2321
Instantiated once for each connection to handle it.
647
2322
Note: This will run in its own forked process."""
649
2324
def handle(self):
650
logger.info(u"TCP connection from: %s",
651
unicode(self.client_address))
652
session = (gnutls.connection
653
.ClientSession(self.request,
657
line = self.request.makefile().readline()
658
logger.debug(u"Protocol version: %r", line)
660
if int(line.strip().split()[0]) > 1:
662
except (ValueError, IndexError, RuntimeError), error:
663
logger.error(u"Unknown protocol version: %s", error)
666
# Note: gnutls.connection.X509Credentials is really a generic
667
# GnuTLS certificate credentials object so long as no X.509
668
# keys are added to it. Therefore, we can use it here despite
669
# using OpenPGP certificates.
671
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
672
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
674
# Use a fallback default, since this MUST be set.
675
priority = self.server.settings.get("priority", "NORMAL")
676
(gnutls.library.functions
677
.gnutls_priority_set_direct(session._c_object,
682
except gnutls.errors.GNUTLSError, error:
683
logger.warning(u"Handshake failed: %s", error)
684
# Do not run session.bye() here: the session is not
685
# established. Just abandon the request.
688
fpr = fingerprint(peer_certificate(session))
689
except (TypeError, gnutls.errors.GNUTLSError), error:
690
logger.warning(u"Bad certificate: %s", error)
693
logger.debug(u"Fingerprint: %s", fpr)
694
for c in self.server.clients:
695
if c.fingerprint == fpr:
2325
with contextlib.closing(self.server.child_pipe) as child_pipe:
2326
log.info("TCP connection from: %s",
2327
str(self.client_address))
2328
log.debug("Pipe FD: %d", self.server.child_pipe.fileno())
2330
session = gnutls.ClientSession(self.request)
2332
# priority = ":".join(("NONE", "+VERS-TLS1.1",
2333
# "+AES-256-CBC", "+SHA1",
2334
# "+COMP-NULL", "+CTYPE-OPENPGP",
2336
# Use a fallback default, since this MUST be set.
2337
priority = self.server.gnutls_priority
2338
if priority is None:
2340
gnutls.priority_set_direct(session,
2341
priority.encode("utf-8"), None)
2343
# Start communication using the Mandos protocol
2344
# Get protocol number
2345
line = self.request.makefile().readline()
2346
log.debug("Protocol version: %r", line)
2348
if int(line.strip().split()[0]) > 1:
2349
raise RuntimeError(line)
2350
except (ValueError, IndexError, RuntimeError) as error:
2351
log.error("Unknown protocol version: %s", error)
2354
# Start GnuTLS connection
2357
except gnutls.Error as error:
2358
log.warning("Handshake failed: %s", error)
2359
# Do not run session.bye() here: the session is not
2360
# established. Just abandon the request.
2362
log.debug("Handshake succeeded")
2364
approval_required = False
2366
if gnutls.has_rawpk:
2369
key_id = self.key_id(
2370
self.peer_certificate(session))
2371
except (TypeError, gnutls.Error) as error:
2372
log.warning("Bad certificate: %s", error)
2374
log.debug("Key ID: %s",
2375
key_id.decode("utf-8",
2381
fpr = self.fingerprint(
2382
self.peer_certificate(session))
2383
except (TypeError, gnutls.Error) as error:
2384
log.warning("Bad certificate: %s", error)
2386
log.debug("Fingerprint: %s", fpr)
2389
client = ProxyClient(child_pipe, key_id, fpr,
2390
self.client_address)
2394
if client.approval_delay:
2395
delay = client.approval_delay
2396
client.approvals_pending += 1
2397
approval_required = True
2400
if not client.enabled:
2401
log.info("Client %s is disabled", client.name)
2402
if self.server.use_dbus:
2404
client.Rejected("Disabled")
2407
if client.approved or not client.approval_delay:
2408
# We are approved or approval is disabled
2410
elif client.approved is None:
2411
log.info("Client %s needs approval",
2413
if self.server.use_dbus:
2415
client.NeedApproval(
2416
client.approval_delay.total_seconds()
2417
* 1000, client.approved_by_default)
2419
log.warning("Client %s was not approved",
2421
if self.server.use_dbus:
2423
client.Rejected("Denied")
2426
# wait until timeout or approved
2427
time = datetime.datetime.now()
2428
client.changedstate.acquire()
2429
client.changedstate.wait(delay.total_seconds())
2430
client.changedstate.release()
2431
time2 = datetime.datetime.now()
2432
if (time2 - time) >= delay:
2433
if not client.approved_by_default:
2434
log.warning("Client %s timed out while"
2435
" waiting for approval",
2437
if self.server.use_dbus:
2439
client.Rejected("Approval timed out")
2444
delay -= time2 - time
2447
session.send(client.secret)
2448
except gnutls.Error as error:
2449
log.warning("gnutls send failed", exc_info=error)
2452
log.info("Sending secret to %s", client.name)
2453
# bump the timeout using extended_timeout
2454
client.bump_timeout(client.extended_timeout)
2455
if self.server.use_dbus:
2460
if approval_required:
2461
client.approvals_pending -= 1
2464
except gnutls.Error as error:
2465
log.warning("GnuTLS bye failed", exc_info=error)
2468
def peer_certificate(session):
2469
"Return the peer's certificate as a bytestring"
2471
cert_type = gnutls.certificate_type_get2(
2472
session, gnutls.CTYPE_PEERS)
2473
except AttributeError:
2474
cert_type = gnutls.certificate_type_get(session)
2475
if gnutls.has_rawpk:
2476
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
699
logger.warning(u"Client not found for fingerprint: %s",
703
# Have to check if client.still_valid(), since it is possible
704
# that the client timed out while establishing the GnuTLS
706
if not client.still_valid():
707
logger.warning(u"Client %(name)s is invalid",
711
## This won't work here, since we're in a fork.
712
# client.bump_timeout()
714
while sent_size < len(client.secret):
715
sent = session.send(client.secret[sent_size:])
716
logger.debug(u"Sent: %d, remaining: %d",
717
sent, len(client.secret)
718
- (sent_size + sent))
723
class IPv6_TCPServer(SocketServer.ForkingMixIn,
724
SocketServer.TCPServer, object):
725
"""IPv6 TCP server. Accepts 'None' as address and/or port.
2478
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2479
# If not a valid certificate type...
2480
if cert_type not in valid_cert_types:
2481
log.info("Cert type %r not in %r", cert_type,
2483
# ...return invalid data
2485
list_size = ctypes.c_uint(1)
2486
cert_list = (gnutls.certificate_get_peers
2487
(session, ctypes.byref(list_size)))
2488
if not bool(cert_list) and list_size.value != 0:
2489
raise gnutls.Error("error getting peer certificate")
2490
if list_size.value == 0:
2493
return ctypes.string_at(cert.data, cert.size)
2496
def key_id(certificate):
2497
"Convert a certificate bytestring to a hexdigit key ID"
2498
# New GnuTLS "datum" with the public key
2499
datum = gnutls.datum_t(
2500
ctypes.cast(ctypes.c_char_p(certificate),
2501
ctypes.POINTER(ctypes.c_ubyte)),
2502
ctypes.c_uint(len(certificate)))
2503
# XXX all these need to be created in the gnutls "module"
2504
# New empty GnuTLS certificate
2505
pubkey = gnutls.pubkey_t()
2506
gnutls.pubkey_init(ctypes.byref(pubkey))
2507
# Import the raw public key into the certificate
2508
gnutls.pubkey_import(pubkey,
2509
ctypes.byref(datum),
2510
gnutls.X509_FMT_DER)
2511
# New buffer for the key ID
2512
buf = ctypes.create_string_buffer(32)
2513
buf_len = ctypes.c_size_t(len(buf))
2514
# Get the key ID from the raw public key into the buffer
2515
gnutls.pubkey_get_key_id(
2517
gnutls.KEYID_USE_SHA256,
2518
ctypes.cast(ctypes.byref(buf),
2519
ctypes.POINTER(ctypes.c_ubyte)),
2520
ctypes.byref(buf_len))
2521
# Deinit the certificate
2522
gnutls.pubkey_deinit(pubkey)
2524
# Convert the buffer to a Python bytestring
2525
key_id = ctypes.string_at(buf, buf_len.value)
2526
# Convert the bytestring to hexadecimal notation
2527
hex_key_id = binascii.hexlify(key_id).upper()
2531
def fingerprint(openpgp):
2532
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2533
# New GnuTLS "datum" with the OpenPGP public key
2534
datum = gnutls.datum_t(
2535
ctypes.cast(ctypes.c_char_p(openpgp),
2536
ctypes.POINTER(ctypes.c_ubyte)),
2537
ctypes.c_uint(len(openpgp)))
2538
# New empty GnuTLS certificate
2539
crt = gnutls.openpgp_crt_t()
2540
gnutls.openpgp_crt_init(ctypes.byref(crt))
2541
# Import the OpenPGP public key into the certificate
2542
gnutls.openpgp_crt_import(crt, ctypes.byref(datum),
2543
gnutls.OPENPGP_FMT_RAW)
2544
# Verify the self signature in the key
2545
crtverify = ctypes.c_uint()
2546
gnutls.openpgp_crt_verify_self(crt, 0,
2547
ctypes.byref(crtverify))
2548
if crtverify.value != 0:
2549
gnutls.openpgp_crt_deinit(crt)
2550
raise gnutls.CertificateSecurityError(code
2552
# New buffer for the fingerprint
2553
buf = ctypes.create_string_buffer(20)
2554
buf_len = ctypes.c_size_t()
2555
# Get the fingerprint from the certificate into the buffer
2556
gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
2557
ctypes.byref(buf_len))
2558
# Deinit the certificate
2559
gnutls.openpgp_crt_deinit(crt)
2560
# Convert the buffer to a Python bytestring
2561
fpr = ctypes.string_at(buf, buf_len.value)
2562
# Convert the bytestring to hexadecimal notation
2563
hex_fpr = binascii.hexlify(fpr).upper()
2567
class MultiprocessingMixIn:
2568
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2570
def sub_process_main(self, request, address):
2572
self.finish_request(request, address)
2574
self.handle_error(request, address)
2575
self.close_request(request)
2577
def process_request(self, request, address):
2578
"""Start a new process to process the request."""
2579
proc = multiprocessing.Process(target=self.sub_process_main,
2580
args=(request, address))
2585
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2586
""" adds a pipe to the MixIn """
2588
def process_request(self, request, client_address):
2589
"""Overrides and wraps the original process_request().
2591
This function creates a new pipe in self.pipe
2593
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2595
proc = MultiprocessingMixIn.process_request(self, request,
2597
self.child_pipe.close()
2598
self.add_pipe(parent_pipe, proc)
2600
def add_pipe(self, parent_pipe, proc):
2601
"""Dummy function; override as necessary"""
2602
raise NotImplementedError()
2605
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2606
socketserver.TCPServer):
2607
"""IPv6-capable TCP server. Accepts None as address and/or port
727
settings: Server settings
728
clients: Set() of Client objects
729
2610
enabled: Boolean; whether this server is activated yet
2611
interface: None or a network interface name (string)
2612
use_ipv6: Boolean; to use IPv6 or not
731
address_family = socket.AF_INET6
732
def __init__(self, *args, **kwargs):
733
if "settings" in kwargs:
734
self.settings = kwargs["settings"]
735
del kwargs["settings"]
736
if "clients" in kwargs:
737
self.clients = kwargs["clients"]
738
del kwargs["clients"]
740
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
2615
def __init__(self, server_address, RequestHandlerClass,
2619
"""If socketfd is set, use that file descriptor instead of
2620
creating a new one with socket.socket().
2622
self.interface = interface
2624
self.address_family = socket.AF_INET6
2625
if socketfd is not None:
2626
# Save the file descriptor
2627
self.socketfd = socketfd
2628
# Save the original socket.socket() function
2629
self.socket_socket = socket.socket
2631
# To implement --socket, we monkey patch socket.socket.
2633
# (When socketserver.TCPServer is a new-style class, we
2634
# could make self.socket into a property instead of monkey
2635
# patching socket.socket.)
2637
# Create a one-time-only replacement for socket.socket()
2638
@functools.wraps(socket.socket)
2639
def socket_wrapper(*args, **kwargs):
2640
# Restore original function so subsequent calls are
2642
socket.socket = self.socket_socket
2643
del self.socket_socket
2644
# This time only, return a new socket object from the
2645
# saved file descriptor.
2646
return socket.fromfd(self.socketfd, *args, **kwargs)
2647
# Replace socket.socket() function with wrapper
2648
socket.socket = socket_wrapper
2649
# The socketserver.TCPServer.__init__ will call
2650
# socket.socket(), which might be our replacement,
2651
# socket_wrapper(), if socketfd was set.
2652
socketserver.TCPServer.__init__(self, server_address,
2653
RequestHandlerClass)
741
2655
def server_bind(self):
742
2656
"""This overrides the normal server_bind() function
743
2657
to bind to an interface if one was specified, and also NOT to
744
2658
bind to an address or port if they were not specified."""
745
if self.settings["interface"]:
746
# 25 is from /usr/include/asm-i486/socket.h
747
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
2659
global SO_BINDTODEVICE
2660
if self.interface is not None:
2661
if SO_BINDTODEVICE is None:
2662
# Fall back to a hard-coded value which seems to be
2664
log.warning("SO_BINDTODEVICE not found, trying 25")
2665
SO_BINDTODEVICE = 25
749
self.socket.setsockopt(socket.SOL_SOCKET,
751
self.settings["interface"])
752
except socket.error, error:
753
if error[0] == errno.EPERM:
754
logger.error(u"No permission to"
755
u" bind to interface %s",
756
self.settings["interface"])
2667
self.socket.setsockopt(
2668
socket.SOL_SOCKET, SO_BINDTODEVICE,
2669
(self.interface + "\0").encode("utf-8"))
2670
except socket.error as error:
2671
if error.errno == errno.EPERM:
2672
log.error("No permission to bind to interface %s",
2674
elif error.errno == errno.ENOPROTOOPT:
2675
log.error("SO_BINDTODEVICE not available; cannot"
2676
" bind to interface %s", self.interface)
2677
elif error.errno == errno.ENODEV:
2678
log.error("Interface %s does not exist, cannot"
2679
" bind", self.interface)
759
2682
# Only bind(2) the socket if we really need to.
760
2683
if self.server_address[0] or self.server_address[1]:
2684
if self.server_address[1]:
2685
self.allow_reuse_address = True
761
2686
if not self.server_address[0]:
763
self.server_address = (in6addr_any,
2687
if self.address_family == socket.AF_INET6:
2688
any_address = "::" # in6addr_any
2690
any_address = "0.0.0.0" # INADDR_ANY
2691
self.server_address = (any_address,
764
2692
self.server_address[1])
765
2693
elif not self.server_address[1]:
766
self.server_address = (self.server_address[0],
768
# if self.settings["interface"]:
2694
self.server_address = (self.server_address[0], 0)
2695
# if self.interface:
769
2696
# self.server_address = (self.server_address[0],
772
2699
# if_nametoindex
775
return super(IPv6_TCPServer, self).server_bind()
2701
return socketserver.TCPServer.server_bind(self)
2704
class MandosServer(IPv6_TCPServer):
2708
clients: set of Client objects
2709
gnutls_priority GnuTLS priority string
2710
use_dbus: Boolean; to emit D-Bus signals or not
2712
Assumes a GLib.MainLoop event loop.
2715
def __init__(self, server_address, RequestHandlerClass,
2719
gnutls_priority=None,
2722
self.enabled = False
2723
self.clients = clients
2724
if self.clients is None:
2726
self.use_dbus = use_dbus
2727
self.gnutls_priority = gnutls_priority
2728
IPv6_TCPServer.__init__(self, server_address,
2729
RequestHandlerClass,
2730
interface=interface,
776
2734
def server_activate(self):
777
2735
if self.enabled:
778
return super(IPv6_TCPServer, self).server_activate()
2736
return socketserver.TCPServer.server_activate(self)
779
2738
def enable(self):
780
2739
self.enabled = True
2741
def add_pipe(self, parent_pipe, proc):
2742
# Call "handle_ipc" for both data and EOF events
2744
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2745
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2746
functools.partial(self.handle_ipc,
2747
parent_pipe=parent_pipe,
2750
def handle_ipc(self, source, condition,
2753
client_object=None):
2754
# error, or the other end of multiprocessing.Pipe has closed
2755
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2756
# Wait for other process to exit
2760
# Read a request from the child
2761
request = parent_pipe.recv()
2762
command = request[0]
2764
if command == "init":
2765
key_id = request[1].decode("ascii")
2766
fpr = request[2].decode("ascii")
2767
address = request[3]
2769
for c in self.clients.values():
2770
if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"
2771
"27AE41E4649B934CA495991B7852B855"):
2773
if key_id and c.key_id == key_id:
2776
if fpr and c.fingerprint == fpr:
2780
log.info("Client not found for key ID: %s, address:"
2781
" %s", key_id or fpr, address)
2784
mandos_dbus_service.ClientNotFound(key_id or fpr,
2786
parent_pipe.send(False)
2790
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2791
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2792
functools.partial(self.handle_ipc,
2793
parent_pipe=parent_pipe,
2795
client_object=client))
2796
parent_pipe.send(True)
2797
# remove the old hook in favor of the new above hook on
2800
if command == "funcall":
2801
funcname = request[1]
2805
parent_pipe.send(("data", getattr(client_object,
2809
if command == "getattr":
2810
attrname = request[1]
2811
if isinstance(client_object.__getattribute__(attrname),
2812
collections.abc.Callable):
2813
parent_pipe.send(("function", ))
2816
"data", client_object.__getattribute__(attrname)))
2818
if command == "setattr":
2819
attrname = request[1]
2821
setattr(client_object, attrname, value)
2826
def rfc3339_duration_to_delta(duration):
2827
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2829
>>> timedelta = datetime.timedelta
2830
>>> rfc3339_duration_to_delta("P7D") == timedelta(7)
2832
>>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)
2834
>>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)
2836
>>> rfc3339_duration_to_delta("PT24H") == timedelta(1)
2838
>>> rfc3339_duration_to_delta("P1W") == timedelta(7)
2840
>>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)
2842
>>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)
2847
# Parsing an RFC 3339 duration with regular expressions is not
2848
# possible - there would have to be multiple places for the same
2849
# values, like seconds. The current code, while more esoteric, is
2850
# cleaner without depending on a parsing library. If Python had a
2851
# built-in library for parsing we would use it, but we'd like to
2852
# avoid excessive use of external libraries.
2854
# New type for defining tokens, syntax, and semantics all-in-one
2855
Token = collections.namedtuple("Token", (
2856
"regexp", # To match token; if "value" is not None, must have
2857
# a "group" containing digits
2858
"value", # datetime.timedelta or None
2859
"followers")) # Tokens valid after this token
2860
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2861
# the "duration" ABNF definition in RFC 3339, Appendix A.
2862
token_end = Token(re.compile(r"$"), None, frozenset())
2863
token_second = Token(re.compile(r"(\d+)S"),
2864
datetime.timedelta(seconds=1),
2865
frozenset((token_end, )))
2866
token_minute = Token(re.compile(r"(\d+)M"),
2867
datetime.timedelta(minutes=1),
2868
frozenset((token_second, token_end)))
2869
token_hour = Token(re.compile(r"(\d+)H"),
2870
datetime.timedelta(hours=1),
2871
frozenset((token_minute, token_end)))
2872
token_time = Token(re.compile(r"T"),
2874
frozenset((token_hour, token_minute,
2876
token_day = Token(re.compile(r"(\d+)D"),
2877
datetime.timedelta(days=1),
2878
frozenset((token_time, token_end)))
2879
token_month = Token(re.compile(r"(\d+)M"),
2880
datetime.timedelta(weeks=4),
2881
frozenset((token_day, token_end)))
2882
token_year = Token(re.compile(r"(\d+)Y"),
2883
datetime.timedelta(weeks=52),
2884
frozenset((token_month, token_end)))
2885
token_week = Token(re.compile(r"(\d+)W"),
2886
datetime.timedelta(weeks=1),
2887
frozenset((token_end, )))
2888
token_duration = Token(re.compile(r"P"), None,
2889
frozenset((token_year, token_month,
2890
token_day, token_time,
2892
# Define starting values:
2894
value = datetime.timedelta()
2896
# Following valid tokens
2897
followers = frozenset((token_duration, ))
2898
# String left to parse
2900
# Loop until end token is found
2901
while found_token is not token_end:
2902
# Search for any currently valid tokens
2903
for token in followers:
2904
match = token.regexp.match(s)
2905
if match is not None:
2907
if token.value is not None:
2908
# Value found, parse digits
2909
factor = int(match.group(1), 10)
2910
# Add to value so far
2911
value += factor * token.value
2912
# Strip token from string
2913
s = token.regexp.sub("", s, 1)
2916
# Set valid next tokens
2917
followers = found_token.followers
2920
# No currently valid tokens were found
2921
raise ValueError("Invalid RFC 3339 duration: {!r}"
783
2927
def string_to_delta(interval):
784
2928
"""Parse a string and return a datetime.timedelta
786
>>> string_to_delta('7d')
787
datetime.timedelta(7)
788
>>> string_to_delta('60s')
789
datetime.timedelta(0, 60)
790
>>> string_to_delta('60m')
791
datetime.timedelta(0, 3600)
792
>>> string_to_delta('24h')
793
datetime.timedelta(1)
794
>>> string_to_delta(u'1w')
795
datetime.timedelta(7)
796
>>> string_to_delta('5m 30s')
797
datetime.timedelta(0, 330)
2930
>>> string_to_delta("7d") == datetime.timedelta(7)
2932
>>> string_to_delta("60s") == datetime.timedelta(0, 60)
2934
>>> string_to_delta("60m") == datetime.timedelta(0, 3600)
2936
>>> string_to_delta("24h") == datetime.timedelta(1)
2938
>>> string_to_delta("1w") == datetime.timedelta(7)
2940
>>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)
2945
return rfc3339_duration_to_delta(interval)
799
2949
timevalue = datetime.timedelta(0)
800
2950
for s in interval.split():
802
suffix = unicode(s[-1])
803
2953
value = int(s[:-1])
805
2955
delta = datetime.timedelta(value)
807
2957
delta = datetime.timedelta(0, value)
809
2959
delta = datetime.timedelta(0, 0, 0, 0, value)
811
2961
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
813
2963
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
816
except (ValueError, IndexError):
2965
raise ValueError("Unknown suffix {!r}".format(suffix))
2966
except IndexError as e:
2967
raise ValueError(*(e.args))
818
2968
timevalue += delta
819
2969
return timevalue
822
def server_state_changed(state):
823
"""Derived from the Avahi example code"""
824
if state == avahi.SERVER_COLLISION:
825
logger.error(u"Zeroconf server name collision")
827
elif state == avahi.SERVER_RUNNING:
831
def entry_group_state_changed(state, error):
832
"""Derived from the Avahi example code"""
833
logger.debug(u"Avahi state change: %i", state)
835
if state == avahi.ENTRY_GROUP_ESTABLISHED:
836
logger.debug(u"Zeroconf service established.")
837
elif state == avahi.ENTRY_GROUP_COLLISION:
838
logger.warning(u"Zeroconf service name collision.")
840
elif state == avahi.ENTRY_GROUP_FAILURE:
841
logger.critical(u"Avahi: Error in group state changed %s",
843
raise AvahiGroupError(u"State changed: %s" % unicode(error))
845
def if_nametoindex(interface):
846
"""Call the C function if_nametoindex(), or equivalent"""
847
global if_nametoindex
849
if_nametoindex = (ctypes.cdll.LoadLibrary
850
(ctypes.util.find_library("c"))
852
except (OSError, AttributeError):
853
if "struct" not in sys.modules:
855
if "fcntl" not in sys.modules:
857
def if_nametoindex(interface):
858
"Get an interface index the hard way, i.e. using fcntl()"
859
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
860
with closing(socket.socket()) as s:
861
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
862
struct.pack("16s16x", interface))
863
interface_index = struct.unpack("I", ifreq[16:20])[0]
864
return interface_index
865
return if_nametoindex(interface)
868
def daemon(nochdir = False, noclose = False):
2972
def daemon(nochdir=False, noclose=False):
869
2973
"""See daemon(3). Standard BSD Unix function.
870
2975
This should really exist as os.daemon, but it doesn't (yet)."""
892
parser = OptionParser(version = "%%prog %s" % version)
893
parser.add_option("-i", "--interface", type="string",
894
metavar="IF", help="Bind to interface IF")
895
parser.add_option("-a", "--address", type="string",
896
help="Address to listen for requests on")
897
parser.add_option("-p", "--port", type="int",
898
help="Port number to receive requests on")
899
parser.add_option("--check", action="store_true",
900
help="Run self-test")
901
parser.add_option("--debug", action="store_true",
902
help="Debug mode; run in foreground and log to"
904
parser.add_option("--priority", type="string", help="GnuTLS"
905
" priority string (see GnuTLS documentation)")
906
parser.add_option("--servicename", type="string", metavar="NAME",
907
help="Zeroconf service name")
908
parser.add_option("--configdir", type="string",
909
default="/etc/mandos", metavar="DIR",
910
help="Directory to search for configuration"
912
parser.add_option("--no-dbus", action="store_false",
914
help="Do not provide D-Bus system bus"
916
options = parser.parse_args()[0]
2999
##################################################################
3000
# Parsing of options, both command line and config file
3002
parser = argparse.ArgumentParser()
3003
parser.add_argument("-v", "--version", action="version",
3004
version="%(prog)s {}".format(version),
3005
help="show version number and exit")
3006
parser.add_argument("-i", "--interface", metavar="IF",
3007
help="Bind to interface IF")
3008
parser.add_argument("-a", "--address",
3009
help="Address to listen for requests on")
3010
parser.add_argument("-p", "--port", type=int,
3011
help="Port number to receive requests on")
3012
parser.add_argument("--check", action="store_true",
3013
help="Run self-test")
3014
parser.add_argument("--debug", action="store_true",
3015
help="Debug mode; run in foreground and log"
3016
" to terminal", default=None)
3017
parser.add_argument("--debuglevel", metavar="LEVEL",
3018
help="Debug level for stdout output")
3019
parser.add_argument("--priority", help="GnuTLS"
3020
" priority string (see GnuTLS documentation)")
3021
parser.add_argument("--servicename",
3022
metavar="NAME", help="Zeroconf service name")
3023
parser.add_argument("--configdir",
3024
default="/etc/mandos", metavar="DIR",
3025
help="Directory to search for configuration"
3027
parser.add_argument("--no-dbus", action="store_false",
3028
dest="use_dbus", help="Do not provide D-Bus"
3029
" system bus interface", default=None)
3030
parser.add_argument("--no-ipv6", action="store_false",
3031
dest="use_ipv6", help="Do not use IPv6",
3033
parser.add_argument("--no-restore", action="store_false",
3034
dest="restore", help="Do not restore stored"
3035
" state", default=None)
3036
parser.add_argument("--socket", type=int,
3037
help="Specify a file descriptor to a network"
3038
" socket to use instead of creating one")
3039
parser.add_argument("--statedir", metavar="DIR",
3040
help="Directory to save/restore state in")
3041
parser.add_argument("--foreground", action="store_true",
3042
help="Run in foreground", default=None)
3043
parser.add_argument("--no-zeroconf", action="store_false",
3044
dest="zeroconf", help="Do not use Zeroconf",
3047
options = parser.parse_args()
923
3049
# Default values for config file for server-global settings
924
server_defaults = { "interface": "",
929
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
930
"servicename": "Mandos",
3050
if gnutls.has_rawpk:
3051
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
3052
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
3054
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
3055
":+SIGN-DSA-SHA256")
3056
server_defaults = {"interface": "",
3060
"priority": priority,
3061
"servicename": "Mandos",
3067
"statedir": "/var/lib/mandos",
3068
"foreground": "False",
934
3073
# Parse config file for server-global settings
935
server_config = ConfigParser.SafeConfigParser(server_defaults)
3074
server_config = configparser.ConfigParser(server_defaults)
936
3075
del server_defaults
937
3076
server_config.read(os.path.join(options.configdir, "mandos.conf"))
938
# Convert the SafeConfigParser object to a dict
3077
# Convert the ConfigParser object to a dict
939
3078
server_settings = server_config.defaults()
940
# Use getboolean on the boolean config options
941
server_settings["debug"] = (server_config.getboolean
942
("DEFAULT", "debug"))
943
server_settings["use_dbus"] = (server_config.getboolean
944
("DEFAULT", "use_dbus"))
3079
# Use the appropriate methods on the non-string config options
3080
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3081
"foreground", "zeroconf"):
3082
server_settings[option] = server_config.getboolean("DEFAULT",
3084
if server_settings["port"]:
3085
server_settings["port"] = server_config.getint("DEFAULT",
3087
if server_settings["socket"]:
3088
server_settings["socket"] = server_config.getint("DEFAULT",
3090
# Later, stdin will, and stdout and stderr might, be dup'ed
3091
# over with an opened os.devnull. But we don't want this to
3092
# happen with a supplied network socket.
3093
if 0 <= server_settings["socket"] <= 2:
3094
server_settings["socket"] = os.dup(server_settings
945
3096
del server_config
947
3098
# Override the settings from the config file with command line
948
3099
# options, if set.
949
3100
for option in ("interface", "address", "port", "debug",
950
"priority", "servicename", "configdir",
3101
"priority", "servicename", "configdir", "use_dbus",
3102
"use_ipv6", "debuglevel", "restore", "statedir",
3103
"socket", "foreground", "zeroconf"):
952
3104
value = getattr(options, option)
953
3105
if value is not None:
954
3106
server_settings[option] = value
3108
# Force all strings to be unicode
3109
for option in server_settings.keys():
3110
if isinstance(server_settings[option], bytes):
3111
server_settings[option] = (server_settings[option]
3113
# Force all boolean options to be boolean
3114
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3115
"foreground", "zeroconf"):
3116
server_settings[option] = bool(server_settings[option])
3117
# Debug implies foreground
3118
if server_settings["debug"]:
3119
server_settings["foreground"] = True
956
3120
# Now we have our good server settings in "server_settings"
3122
##################################################################
3124
if (not server_settings["zeroconf"]
3125
and not (server_settings["port"]
3126
or server_settings["socket"] != "")):
3127
parser.error("Needs port or socket to work without Zeroconf")
958
3129
# For convenience
959
3130
debug = server_settings["debug"]
3131
debuglevel = server_settings["debuglevel"]
960
3132
use_dbus = server_settings["use_dbus"]
963
syslogger.setLevel(logging.WARNING)
964
console.setLevel(logging.WARNING)
3133
use_ipv6 = server_settings["use_ipv6"]
3134
stored_state_path = os.path.join(server_settings["statedir"],
3136
foreground = server_settings["foreground"]
3137
zeroconf = server_settings["zeroconf"]
3140
initlogger(debug, logging.DEBUG)
3145
level = getattr(logging, debuglevel.upper())
3146
initlogger(debug, level)
966
3148
if server_settings["servicename"] != "Mandos":
967
syslogger.setFormatter(logging.Formatter
968
('Mandos (%s): %%(levelname)s:'
970
% server_settings["servicename"]))
3149
syslogger.setFormatter(
3150
logging.Formatter("Mandos ({}) [%(process)d]:"
3151
" %(levelname)s: %(message)s".format(
3152
server_settings["servicename"])))
972
3154
# Parse config file with clients
973
client_defaults = { "timeout": "1h",
975
"checker": "fping -q -- %(host)s",
978
client_config = ConfigParser.SafeConfigParser(client_defaults)
3155
client_config = configparser.ConfigParser(Client.client_defaults)
979
3156
client_config.read(os.path.join(server_settings["configdir"],
980
3157
"clients.conf"))
983
tcp_server = IPv6_TCPServer((server_settings["address"],
984
server_settings["port"]),
986
settings=server_settings,
988
pidfilename = "/var/run/mandos.pid"
990
pidfile = open(pidfilename, "w")
991
except IOError, error:
992
logger.error("Could not open file %r", pidfilename)
995
uid = pwd.getpwnam("_mandos").pw_uid
998
uid = pwd.getpwnam("mandos").pw_uid
1001
uid = pwd.getpwnam("nobody").pw_uid
1005
gid = pwd.getpwnam("_mandos").pw_gid
1008
gid = pwd.getpwnam("mandos").pw_gid
1011
gid = pwd.getpwnam("nogroup").pw_gid
3159
global mandos_dbus_service
3160
mandos_dbus_service = None
3163
if server_settings["socket"] != "":
3164
socketfd = server_settings["socket"]
3165
tcp_server = MandosServer(
3166
(server_settings["address"], server_settings["port"]),
3168
interface=(server_settings["interface"] or None),
3170
gnutls_priority=server_settings["priority"],
3174
pidfilename = "/run/mandos.pid"
3175
if not os.path.isdir("/run/."):
3176
pidfilename = "/var/run/mandos.pid"
3179
pidfile = codecs.open(pidfilename, "w", encoding="utf-8")
3180
except IOError as e:
3181
log.error("Could not open file %r", pidfilename,
3184
for name, group in (("_mandos", "_mandos"),
3185
("mandos", "mandos"),
3186
("nobody", "nogroup")):
3188
uid = pwd.getpwnam(name).pw_uid
3189
gid = pwd.getpwnam(group).pw_gid
1017
except OSError, error:
1018
if error[0] != errno.EPERM:
1022
service = AvahiService(name = server_settings["servicename"],
1023
servicetype = "_mandos._tcp", )
1024
if server_settings["interface"]:
1025
service.interface = (if_nametoindex
1026
(server_settings["interface"]))
3199
log.debug("Did setuid/setgid to %s:%s", uid, gid)
3200
except OSError as error:
3201
log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,
3202
os.strerror(error.errno))
3203
if error.errno != errno.EPERM:
3207
# Enable all possible GnuTLS debugging
3209
# "Use a log level over 10 to enable all debugging options."
3211
gnutls.global_set_log_level(11)
3214
def debug_gnutls(level, string):
3215
log.debug("GnuTLS: %s",
3216
string[:-1].decode("utf-8", errors="replace"))
3218
gnutls.global_set_log_function(debug_gnutls)
3220
# Redirect stdin so all checkers get /dev/null
3221
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
3222
os.dup2(null, sys.stdin.fileno())
3226
# Need to fork before connecting to D-Bus
3228
# Close all input and output, do double fork, etc.
3231
if gi.version_info < (3, 10, 2):
3232
# multiprocessing will use threads, so before we use GLib we
3233
# need to inform GLib that threads will be used.
1028
3236
global main_loop
1031
3237
# From the Avahi example code
1032
DBusGMainLoop(set_as_default=True )
1033
main_loop = gobject.MainLoop()
3238
DBusGMainLoop(set_as_default=True)
3239
main_loop = GLib.MainLoop()
1034
3240
bus = dbus.SystemBus()
1035
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1036
avahi.DBUS_PATH_SERVER),
1037
avahi.DBUS_INTERFACE_SERVER)
1038
3241
# End of Avahi example code
1040
bus_name = dbus.service.BusName(u"org.mandos-system.Mandos",
1043
clients.update(Set(Client(name = section,
1045
= dict(client_config.items(section)),
1046
use_dbus = use_dbus)
1047
for section in client_config.sections()))
1049
logger.critical(u"No clients defined")
1053
# Redirect stdin so all checkers get /dev/null
1054
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1055
os.dup2(null, sys.stdin.fileno())
1059
# No console logging
1060
logger.removeHandler(console)
1061
# Close all input and output, do double fork, etc.
1066
pidfile.write(str(pid) + "\n")
3244
bus_name = dbus.service.BusName("se.recompile.Mandos",
3247
old_bus_name = dbus.service.BusName(
3248
"se.bsnet.fukt.Mandos", bus,
3250
except dbus.exceptions.DBusException as e:
3251
log.error("Disabling D-Bus:", exc_info=e)
3253
server_settings["use_dbus"] = False
3254
tcp_server.use_dbus = False
3256
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
3257
service = AvahiServiceToSyslog(
3258
name=server_settings["servicename"],
3259
servicetype="_mandos._tcp",
3262
if server_settings["interface"]:
3263
service.interface = if_nametoindex(
3264
server_settings["interface"].encode("utf-8"))
3266
global multiprocessing_manager
3267
multiprocessing_manager = multiprocessing.Manager()
3269
client_class = Client
3271
client_class = functools.partial(ClientDBus, bus=bus)
3273
client_settings = Client.config_parser(client_config)
3274
old_client_settings = {}
3277
# This is used to redirect stdout and stderr for checker processes
3279
wnull = open(os.devnull, "w") # A writable /dev/null
3280
# Only used if server is running in foreground but not in debug
3282
if debug or not foreground:
3285
# Get client data and settings from last running state.
3286
if server_settings["restore"]:
3288
with open(stored_state_path, "rb") as stored_state:
3289
if sys.version_info.major == 2:
3290
clients_data, old_client_settings = pickle.load(
3293
bytes_clients_data, bytes_old_client_settings = (
3294
pickle.load(stored_state, encoding="bytes"))
3295
# Fix bytes to strings
3298
clients_data = {(key.decode("utf-8")
3299
if isinstance(key, bytes)
3302
bytes_clients_data.items()}
3303
del bytes_clients_data
3304
for key in clients_data:
3305
value = {(k.decode("utf-8")
3306
if isinstance(k, bytes) else k): v
3308
clients_data[key].items()}
3309
clients_data[key] = value
3311
value["client_structure"] = [
3313
if isinstance(s, bytes)
3315
value["client_structure"]]
3316
# .name, .host, and .checker_command
3317
for k in ("name", "host", "checker_command"):
3318
if isinstance(value[k], bytes):
3319
value[k] = value[k].decode("utf-8")
3320
if "key_id" not in value:
3321
value["key_id"] = ""
3322
elif "fingerprint" not in value:
3323
value["fingerprint"] = ""
3324
# old_client_settings
3326
old_client_settings = {
3327
(key.decode("utf-8")
3328
if isinstance(key, bytes)
3331
bytes_old_client_settings.items()}
3332
del bytes_old_client_settings
3333
# .host and .checker_command
3334
for value in old_client_settings.values():
3335
for attribute in ("host", "checker_command"):
3336
if isinstance(value[attribute], bytes):
3337
value[attribute] = (value[attribute]
3339
os.remove(stored_state_path)
3340
except IOError as e:
3341
if e.errno == errno.ENOENT:
3342
log.warning("Could not load persistent state:"
3343
" %s", os.strerror(e.errno))
3345
log.critical("Could not load persistent state:",
3348
except EOFError as e:
3349
log.warning("Could not load persistent state: EOFError:",
3352
with PGPEngine() as pgp:
3353
for client_name, client in clients_data.items():
3354
# Skip removed clients
3355
if client_name not in client_settings:
3358
# Decide which value to use after restoring saved state.
3359
# We have three different values: Old config file,
3360
# new config file, and saved state.
3361
# New config value takes precedence if it differs from old
3362
# config value, otherwise use saved state.
3363
for name, value in client_settings[client_name].items():
3365
# For each value in new config, check if it
3366
# differs from the old config value (Except for
3367
# the "secret" attribute)
3368
if (name != "secret"
3370
old_client_settings[client_name][name])):
3371
client[name] = value
3375
# Clients who has passed its expire date can still be
3376
# enabled if its last checker was successful. A Client
3377
# whose checker succeeded before we stored its state is
3378
# assumed to have successfully run all checkers during
3380
if client["enabled"]:
3381
if datetime.datetime.utcnow() >= client["expires"]:
3382
if not client["last_checked_ok"]:
3383
log.warning("disabling client %s - Client"
3384
" never performed a successful"
3385
" checker", client_name)
3386
client["enabled"] = False
3387
elif client["last_checker_status"] != 0:
3388
log.warning("disabling client %s - Client"
3389
" last checker failed with error"
3390
" code %s", client_name,
3391
client["last_checker_status"])
3392
client["enabled"] = False
3394
client["expires"] = (
3395
datetime.datetime.utcnow()
3396
+ client["timeout"])
3397
log.debug("Last checker succeeded, keeping %s"
3398
" enabled", client_name)
3400
client["secret"] = pgp.decrypt(
3401
client["encrypted_secret"],
3402
client_settings[client_name]["secret"])
3404
# If decryption fails, we use secret from new settings
3405
log.debug("Failed to decrypt %s old secret",
3407
client["secret"] = (client_settings[client_name]
3410
# Add/remove clients based on new changes made to config
3411
for client_name in (set(old_client_settings)
3412
- set(client_settings)):
3413
del clients_data[client_name]
3414
for client_name in (set(client_settings)
3415
- set(old_client_settings)):
3416
clients_data[client_name] = client_settings[client_name]
3418
# Create all client objects
3419
for client_name, client in clients_data.items():
3420
tcp_server.clients[client_name] = client_class(
3423
server_settings=server_settings)
3425
if not tcp_server.clients:
3426
log.warning("No clients defined")
3429
if pidfile is not None:
3433
print(pid, file=pidfile)
3435
log.error("Could not write to file %r with PID %d",
1070
logger.error(u"Could not write to file %r with PID %d",
1073
# "pidfile" was never created
1078
"Cleanup function; run on exit"
1080
# From the Avahi example code
1081
if not group is None:
1084
# End of Avahi example code
1087
client = clients.pop()
1088
client.disable_hook = None
1091
atexit.register(cleanup)
1094
signal.signal(signal.SIGINT, signal.SIG_IGN)
1095
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1096
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3440
for termsig in (signal.SIGHUP, signal.SIGTERM):
3441
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3442
lambda: main_loop.quit() and False)
1099
class MandosServer(dbus.service.Object):
3446
@alternate_dbus_interfaces(
3447
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3448
class MandosDBusService(DBusObjectWithObjectManager):
1100
3449
"""A D-Bus proxy object"""
1101
3451
def __init__(self):
1102
dbus.service.Object.__init__(self, bus,
1104
_interface = u"org.mandos_system.Mandos"
3452
dbus.service.Object.__init__(self, bus, "/")
1106
@dbus.service.signal(_interface, signature="oa{sv}")
1107
def ClientAdded(self, objpath, properties):
3454
_interface = "se.recompile.Mandos"
1111
3456
@dbus.service.signal(_interface, signature="o")
1112
def ClientRemoved(self, objpath):
3457
def ClientAdded(self, objpath):
3461
@dbus.service.signal(_interface, signature="ss")
3462
def ClientNotFound(self, key_id, address):
3466
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3468
@dbus.service.signal(_interface, signature="os")
3469
def ClientRemoved(self, objpath, name):
3473
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
1116
3475
@dbus.service.method(_interface, out_signature="ao")
1117
3476
def GetAllClients(self):
1118
return dbus.Array(c.dbus_object_path for c in clients)
3478
return dbus.Array(c.dbus_object_path for c in
3479
tcp_server.clients.values())
1120
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
3481
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3483
@dbus.service.method(_interface,
3484
out_signature="a{oa{sv}}")
1121
3485
def GetAllClientsWithProperties(self):
1122
3487
return dbus.Dictionary(
1123
((c.dbus_object_path, c.GetAllProperties())
3488
{c.dbus_object_path: c.GetAll(
3489
"se.recompile.Mandos.Client")
3490
for c in tcp_server.clients.values()},
1125
3491
signature="oa{sv}")
1127
3493
@dbus.service.method(_interface, in_signature="o")
1128
3494
def RemoveClient(self, object_path):
3496
for c in tcp_server.clients.values():
1130
3497
if c.dbus_object_path == object_path:
1132
# Don't signal anything except ClientRemoved
1136
self.ClientRemoved(object_path)
3498
del tcp_server.clients[c.name]
3499
c.remove_from_connection()
3500
# Don't signal the disabling
3501
c.disable(quiet=True)
3502
# Emit D-Bus signal for removal
3503
self.client_removed_signal(c)
3505
raise KeyError(object_path)
1142
mandos_server = MandosServer()
1144
for client in clients:
3509
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3510
out_signature="a{oa{sa{sv}}}")
3511
def GetManagedObjects(self):
3513
return dbus.Dictionary(
3514
{client.dbus_object_path:
3516
{interface: client.GetAll(interface)
3518
client._get_all_interface_names()})
3519
for client in tcp_server.clients.values()})
3521
def client_added_signal(self, client):
3522
"""Send the new standard signal and the old signal"""
3524
# New standard signal
3525
self.InterfacesAdded(
3526
client.dbus_object_path,
3528
{interface: client.GetAll(interface)
3530
client._get_all_interface_names()}))
3532
self.ClientAdded(client.dbus_object_path)
3534
def client_removed_signal(self, client):
3535
"""Send the new standard signal and the old signal"""
3537
# New standard signal
3538
self.InterfacesRemoved(
3539
client.dbus_object_path,
3540
client._get_all_interface_names())
3542
self.ClientRemoved(client.dbus_object_path,
3545
mandos_dbus_service = MandosDBusService()
3547
# Save modules to variables to exempt the modules from being
3548
# unloaded before the function registered with atexit() is run.
3549
mp = multiprocessing
3553
"Cleanup function; run on exit"
3557
mp.active_children()
3559
if not (tcp_server.clients or client_settings):
3562
# Store client before exiting. Secrets are encrypted with key
3563
# based on what config file has. If config file is
3564
# removed/edited, old secret will thus be unrecovable.
3566
with PGPEngine() as pgp:
3567
for client in tcp_server.clients.values():
3568
key = client_settings[client.name]["secret"]
3569
client.encrypted_secret = pgp.encrypt(client.secret,
3573
# A list of attributes that can not be pickled
3575
exclude = {"bus", "changedstate", "secret",
3576
"checker", "server_settings"}
3577
for name, typ in inspect.getmembers(dbus.service
3581
client_dict["encrypted_secret"] = (client
3583
for attr in client.client_structure:
3584
if attr not in exclude:
3585
client_dict[attr] = getattr(client, attr)
3587
clients[client.name] = client_dict
3588
del client_settings[client.name]["secret"]
3591
with tempfile.NamedTemporaryFile(
3595
dir=os.path.dirname(stored_state_path),
3596
delete=False) as stored_state:
3597
pickle.dump((clients, client_settings), stored_state,
3599
tempname = stored_state.name
3600
os.rename(tempname, stored_state_path)
3601
except (IOError, OSError) as e:
3607
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
3608
log.warning("Could not save persistent state: %s",
3609
os.strerror(e.errno))
3611
log.warning("Could not save persistent state:",
3615
# Delete all clients, and settings from config
3616
while tcp_server.clients:
3617
name, client = tcp_server.clients.popitem()
3619
client.remove_from_connection()
3620
# Don't signal the disabling
3621
client.disable(quiet=True)
3622
# Emit D-Bus signal for removal
3624
mandos_dbus_service.client_removed_signal(client)
3625
client_settings.clear()
3627
atexit.register(cleanup)
3629
for client in tcp_server.clients.values():
1147
mandos_server.ClientAdded(client.dbus_object_path,
1148
client.GetAllProperties())
3631
# Emit D-Bus signal for adding
3632
mandos_dbus_service.client_added_signal(client)
3633
# Need to initiate checking of clients
3635
client.init_checker(randomize_start=True)
1151
3637
tcp_server.enable()
1152
3638
tcp_server.server_activate()
1154
3640
# Find out what port we got
1155
service.port = tcp_server.socket.getsockname()[1]
1156
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1157
u" scope_id %d" % tcp_server.socket.getsockname())
1159
#service.interface = tcp_server.socket.getsockname()[3]
3642
service.port = tcp_server.socket.getsockname()[1]
3644
log.info("Now listening on address %r, port %d, flowinfo %d,"
3645
" scope_id %d", *tcp_server.socket.getsockname())
3647
log.info("Now listening on address %r, port %d",
3648
*tcp_server.socket.getsockname())
3650
# service.interface = tcp_server.socket.getsockname()[3]
1162
# From the Avahi example code
1163
server.connect_to_signal("StateChanged", server_state_changed)
1165
server_state_changed(server.GetState())
1166
except dbus.exceptions.DBusException, error:
1167
logger.critical(u"DBusException: %s", error)
1169
# End of Avahi example code
1171
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1172
lambda *args, **kwargs:
1173
(tcp_server.handle_request
1174
(*args[2:], **kwargs) or True))
1176
logger.debug(u"Starting main loop")
3654
# From the Avahi example code
3657
except dbus.exceptions.DBusException as error:
3658
log.critical("D-Bus Exception", exc_info=error)
3661
# End of Avahi example code
3664
GLib.IOChannel.unix_new(tcp_server.fileno()),
3665
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3666
lambda *args, **kwargs: (tcp_server.handle_request
3667
(*args[2:], **kwargs) or True))
3669
log.debug("Starting main loop")
1177
3670
main_loop.run()
1178
except AvahiError, error:
1179
logger.critical(u"AvahiError: %s", error)
3671
except AvahiError as error:
3672
log.critical("Avahi Error", exc_info=error)
1181
3675
except KeyboardInterrupt:
1185
if __name__ == '__main__':
3677
print("", file=sys.stderr)
3678
log.debug("Server received KeyboardInterrupt")
3679
log.debug("Server exiting")
3680
# Must run before the D-Bus bus name gets deregistered
3684
def parse_test_args():
3685
# type: () -> argparse.Namespace
3686
parser = argparse.ArgumentParser(add_help=False)
3687
parser.add_argument("--check", action="store_true")
3688
parser.add_argument("--prefix", )
3689
args, unknown_args = parser.parse_known_args()
3691
# Remove test options from sys.argv
3692
sys.argv[1:] = unknown_args
3695
# Add all tests from doctest strings
3696
def load_tests(loader, tests, none):
3698
tests.addTests(doctest.DocTestSuite())
3701
if __name__ == "__main__":
3702
options = parse_test_args()
3705
extra_test_prefix = options.prefix
3706
if extra_test_prefix is not None:
3707
if not (unittest.main(argv=[""], exit=False)
3708
.result.wasSuccessful()):
3710
class ExtraTestLoader(unittest.TestLoader):
3711
testMethodPrefix = extra_test_prefix
3712
# Call using ./scriptname --test [--verbose]
3713
unittest.main(argv=[""], testLoader=ExtraTestLoader())
3715
unittest.main(argv=[""])
3723
# (lambda (&optional extra)
3724
# (if (not (funcall run-tests-in-test-buffer default-directory
3726
# (funcall show-test-buffer-in-test-window)
3727
# (funcall remove-test-window)
3728
# (if extra (message "Extra tests run successfully!"))))
3729
# run-tests-in-test-buffer:
3730
# (lambda (dir &optional extra)
3731
# (with-current-buffer (get-buffer-create "*Test*")
3732
# (setq buffer-read-only nil
3733
# default-directory dir)
3735
# (compilation-mode))
3736
# (let ((process-result
3737
# (let ((inhibit-read-only t))
3738
# (process-file-shell-command
3739
# (funcall get-command-line extra) nil "*Test*"))))
3740
# (and (numberp process-result)
3741
# (= process-result 0))))
3743
# (lambda (&optional extra)
3744
# (let ((quoted-script
3745
# (shell-quote-argument (funcall get-script-name))))
3747
# (concat "%s --check" (if extra " --prefix=atest" ""))
3751
# (if (fboundp 'file-local-name)
3752
# (file-local-name (buffer-file-name))
3753
# (or (file-remote-p (buffer-file-name) 'localname)
3754
# (buffer-file-name))))
3755
# remove-test-window:
3757
# (let ((test-window (get-buffer-window "*Test*")))
3758
# (if test-window (delete-window test-window))))
3759
# show-test-buffer-in-test-window:
3761
# (when (not (get-buffer-window-list "*Test*"))
3762
# (setq next-error-last-buffer (get-buffer "*Test*"))
3763
# (let* ((side (if (>= (window-width) 146) 'right 'bottom))
3764
# (display-buffer-overriding-action
3765
# `((display-buffer-in-side-window) (side . ,side)
3766
# (window-height . fit-window-to-buffer)
3767
# (window-width . fit-window-to-buffer))))
3768
# (display-buffer "*Test*"))))
3771
# (let* ((run-extra-tests (lambda () (interactive)
3772
# (funcall run-tests t)))
3773
# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t
3774
# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c
3775
# (setq minor-mode-overriding-map-alist
3776
# (cons `(run-tests . ,outer-keymap)
3777
# minor-mode-overriding-map-alist)))
3778
# (add-hook 'after-save-hook run-tests 90 t))