125
386
self.rename_count = 0
126
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):
128
395
"""Derived from the Avahi example code"""
129
396
if self.rename_count >= self.max_renames:
130
logger.critical(u"No suitable Zeroconf service name found"
131
u" after %i retries, exiting.",
133
raise AvahiServiceError(u"Too many renames")
134
self.name = server.GetAlternativeServiceName(self.name)
135
logger.info(u"Changing Zeroconf service name to %r ...",
137
syslogger.setFormatter(logging.Formatter
138
('Mandos (%s): %%(levelname)s:'
139
' %%(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))
142
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)
143
420
def remove(self):
144
421
"""Derived from the Avahi example code"""
145
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:
148
429
"""Derived from the Avahi example code"""
151
group = dbus.Interface(bus.get_object
153
server.EntryGroupNew()),
154
avahi.DBUS_INTERFACE_ENTRY_GROUP)
155
group.connect_to_signal('StateChanged',
156
entry_group_state_changed)
157
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
158
service.name, service.type)
160
self.interface, # interface
161
avahi.PROTO_INET6, # protocol
162
dbus.UInt32(0), # flags
163
self.name, self.type,
164
self.domain, self.host,
165
dbus.UInt16(self.port),
166
avahi.string_array_to_txt_array(self.TXT))
169
# From the Avahi example code:
170
group = None # our entry group
171
# End of Avahi example code
174
def _datetime_to_dbus(dt, variant_level=0):
175
"""Convert a UTC datetime.datetime() to a D-Bus type."""
176
return dbus.String(dt.isoformat(), variant_level=variant_level)
179
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))
180
875
"""A representation of a client host served by this server.
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
896
fingerprint: string (40 or 32 hexadecimal digits); used to
897
uniquely identify an OpenPGP client
898
key_id: string (64 hexadecimal digits); used to uniquely identify
899
a client using raw public keys
900
host: string; available for use by the checker command
901
interval: datetime.timedelta(); How often to start a new checker
902
last_approval_request: datetime.datetime(); (UTC) or None
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
182
910
name: string; from the config file, used in log messages and
183
911
D-Bus identifiers
184
fingerprint: string (40 or 32 hexadecimal digits); used to
185
uniquely identify the client
186
912
secret: bytestring; sent verbatim (over TLS) to client
187
host: string; available for use by the checker command
188
created: datetime.datetime(); (UTC) object creation
189
last_enabled: datetime.datetime(); (UTC)
191
last_checked_ok: datetime.datetime(); (UTC) or None
192
913
timeout: datetime.timedelta(); How long from last_checked_ok
193
until this client is invalid
194
interval: datetime.timedelta(); How often to start a new checker
195
disable_hook: If set, called by disable() as disable_hook(self)
196
checker: subprocess.Popen(); a running checker process used
197
to see if the client lives.
198
'None' if no process is running.
199
checker_initiator_tag: a gobject event source tag, or None
200
disable_initiator_tag: - '' -
201
checker_callback_tag: - '' -
202
checker_command: string; External command which is run to check if
203
client lives. %() expansions are done at
204
runtime with vars(self) as dict, so that for
205
instance %(name)s can be used in the command.
206
use_dbus: bool(); Whether to provide D-Bus interface and signals
207
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()
209
def timeout_milliseconds(self):
210
"Return the 'timeout' attribute in milliseconds"
211
return ((self.timeout.days * 24 * 60 * 60 * 1000)
212
+ (self.timeout.seconds * 1000)
213
+ (self.timeout.microseconds // 1000))
215
def interval_milliseconds(self):
216
"Return the 'interval' attribute in milliseconds"
217
return ((self.interval.days * 24 * 60 * 60 * 1000)
218
+ (self.interval.seconds * 1000)
219
+ (self.interval.microseconds // 1000))
221
def __init__(self, name = None, disable_hook=None, config=None,
223
"""Note: the 'checker' key in 'config' sets the
224
'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):
229
logger.debug(u"Creating client %r", self.name)
230
self.use_dbus = False # During __init__
231
# Uppercase and remove spaces from fingerprint for later
232
# comparison purposes with return value from the fingerprint()
234
self.fingerprint = (config["fingerprint"].upper()
236
logger.debug(u" Fingerprint: %s", self.fingerprint)
237
if "secret" in config:
238
self.secret = config["secret"].decode(u"base64")
239
elif "secfile" in config:
240
with closing(open(os.path.expanduser
242
(config["secfile"])))) as secfile:
243
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()
245
raise TypeError(u"No secret or secfile for client %s"
247
self.host = config.get("host", "")
248
self.created = datetime.datetime.utcnow()
250
self.last_enabled = None
251
self.last_checked_ok = None
252
self.timeout = string_to_delta(config["timeout"])
253
self.interval = string_to_delta(config["interval"])
254
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
255
1019
self.checker = None
256
1020
self.checker_initiator_tag = None
257
1021
self.disable_initiator_tag = None
258
1022
self.checker_callback_tag = None
259
self.checker_command = config["checker"]
260
self.last_connect = None
261
# Only now, when this client is initialized, can it show up on
263
self.use_dbus = use_dbus
265
self.dbus_object_path = (dbus.ObjectPath
267
+ self.name.replace(".", "_")))
268
dbus.service.Object.__init__(self, bus,
269
self.dbus_object_path)
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()
271
1043
def enable(self):
272
1044
"""Start this client's checker and timeout hooks"""
1045
if getattr(self, "enabled", False):
273
1049
self.last_enabled = datetime.datetime.utcnow()
274
# Schedule a new checker to be started an 'interval' from now,
275
# and every interval from then on.
276
self.checker_initiator_tag = (gobject.timeout_add
277
(self.interval_milliseconds(),
279
# Also start a new checker *right now*.
281
# Schedule a disable() when 'timeout' has passed
282
self.disable_initiator_tag = (gobject.timeout_add
283
(self.timeout_milliseconds(),
288
self.PropertyChanged(dbus.String(u"enabled"),
289
dbus.Boolean(True, variant_level=1))
290
self.PropertyChanged(dbus.String(u"last_enabled"),
291
(_datetime_to_dbus(self.last_enabled,
1051
self.send_changedstate()
1053
def disable(self, quiet=True):
295
1054
"""Disable this client."""
296
1055
if not getattr(self, "enabled", False):
298
logger.info(u"Disabling client %s", self.name)
299
if getattr(self, "disable_initiator_tag", False):
300
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)
301
1061
self.disable_initiator_tag = None
302
if getattr(self, "checker_initiator_tag", False):
303
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)
304
1065
self.checker_initiator_tag = None
305
1066
self.stop_checker()
306
if self.disable_hook:
307
self.disable_hook(self)
308
1067
self.enabled = False
311
self.PropertyChanged(dbus.String(u"enabled"),
312
dbus.Boolean(False, variant_level=1))
313
# 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
316
1073
def __del__(self):
317
self.disable_hook = None
320
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,
321
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:
322
1114
self.checker_callback_tag = None
323
1115
self.checker = None
326
self.PropertyChanged(dbus.String(u"checker_running"),
327
dbus.Boolean(False, variant_level=1))
328
if os.WIFEXITED(condition):
329
exitstatus = os.WEXITSTATUS(condition)
331
logger.info(u"Checker for %(name)s succeeded",
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))
333
1122
self.checked_ok()
335
logger.info(u"Checker for %(name)s failed",
339
self.CheckerCompleted(dbus.Int16(exitstatus),
340
dbus.Int64(condition),
341
dbus.String(command))
1124
log.info("Checker for %(name)s failed", vars(self))
343
logger.warning(u"Checker for %(name)s crashed?",
347
self.CheckerCompleted(dbus.Int16(-1),
348
dbus.Int64(condition),
349
dbus.String(command))
1126
self.last_checker_status = -1
1127
self.last_checker_signal = -returncode
1128
log.warning("Checker for %(name)s crashed?", vars(self))
351
1131
def checked_ok(self):
352
"""Bump up the timeout for this client.
353
This should only be called when the client has been seen,
1132
"""Assert that the client has been seen, alive and well."""
356
1133
self.last_checked_ok = datetime.datetime.utcnow()
357
gobject.source_remove(self.disable_initiator_tag)
358
self.disable_initiator_tag = (gobject.timeout_add
359
(self.timeout_milliseconds(),
363
self.PropertyChanged(
364
dbus.String(u"last_checked_ok"),
365
(_datetime_to_dbus(self.last_checked_ok,
368
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):
369
1154
"""Start a new checker subprocess if one is not running.
370
1156
If a checker already exists, leave it running and do
372
1158
# The reason for not killing a running checker is that if we
373
# did that, then if a checker (for some reason) started
374
# running slowly and taking more than 'interval' time, the
375
# client would inevitably timeout, since no checker would get
376
# 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
377
1163
# checkers alone, the checker would have to take more time
378
# than 'timeout' for the client to be declared invalid, which
379
# 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
380
1172
if self.checker is None:
382
# In case checker_command has exactly one % operator
383
command = self.checker_command % self.host
385
# Escape attributes for the shell
386
escaped_attrs = dict((key, re.escape(str(val)))
388
vars(self).iteritems())
390
command = self.checker_command % escaped_attrs
391
except TypeError, error:
392
logger.error(u'Could not format string "%s":'
393
u' %s', self.checker_command, error)
394
return True # Try again later
396
logger.info(u"Starting checker %r for %s",
398
# We don't need to redirect stdout and stderr, since
399
# in normal mode, that is already done by daemon(),
400
# and in debug mode we don't want to. (Stdin is
401
# always replaced by /dev/null.)
402
self.checker = subprocess.Popen(command,
407
self.CheckerStarted(command)
408
self.PropertyChanged(
409
dbus.String("checker_running"),
410
dbus.Boolean(True, variant_level=1))
411
self.checker_callback_tag = (gobject.child_watch_add
413
self.checker_callback,
415
except OSError, error:
416
logger.error(u"Failed to start subprocess: %s",
418
# 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
421
1223
def stop_checker(self):
422
1224
"""Force the checker process, if any, to stop."""
423
1225
if self.checker_callback_tag:
424
gobject.source_remove(self.checker_callback_tag)
1226
GLib.source_remove(self.checker_callback_tag)
425
1227
self.checker_callback_tag = None
426
1228
if getattr(self, "checker", None) is None:
428
logger.debug(u"Stopping checker for %(name)s", vars(self))
430
os.kill(self.checker.pid, signal.SIGTERM)
432
#if self.checker.poll() is None:
433
# os.kill(self.checker.pid, signal.SIGKILL)
434
except OSError, error:
435
if error.errno != errno.ESRCH: # No such process
1230
log.debug("Stopping checker for %(name)s", vars(self))
1231
self.checker.terminate()
437
1232
self.checker = None
439
self.PropertyChanged(dbus.String(u"checker_running"),
440
dbus.Boolean(False, variant_level=1))
442
def still_valid(self):
443
"""Has the timeout not yet passed for this client?"""
444
if not getattr(self, "enabled", False):
446
now = datetime.datetime.utcnow()
447
if self.last_checked_ok is None:
448
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))
450
return now < (self.last_checked_ok + self.timeout)
452
## D-Bus methods & signals
453
_interface = u"se.bsnet.fukt.Mandos.Client"
456
CheckedOK = dbus.service.method(_interface)(checked_ok)
457
CheckedOK.__name__ = "CheckedOK"
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
459
2001
# CheckerCompleted - signal
460
2002
@dbus.service.signal(_interface, signature="nxs")
461
2003
def CheckerCompleted(self, exitcode, waitstatus, command):
465
2007
# CheckerStarted - signal
466
2008
@dbus.service.signal(_interface, signature="s")
467
2009
def CheckerStarted(self, command):
471
# GetAllProperties - method
472
@dbus.service.method(_interface, out_signature="a{sv}")
473
def GetAllProperties(self):
475
return dbus.Dictionary({
477
dbus.String(self.name, variant_level=1),
478
dbus.String("fingerprint"):
479
dbus.String(self.fingerprint, variant_level=1),
481
dbus.String(self.host, variant_level=1),
482
dbus.String("created"):
483
_datetime_to_dbus(self.created, variant_level=1),
484
dbus.String("last_enabled"):
485
(_datetime_to_dbus(self.last_enabled,
487
if self.last_enabled is not None
488
else dbus.Boolean(False, variant_level=1)),
489
dbus.String("enabled"):
490
dbus.Boolean(self.enabled, variant_level=1),
491
dbus.String("last_checked_ok"):
492
(_datetime_to_dbus(self.last_checked_ok,
494
if self.last_checked_ok is not None
495
else dbus.Boolean (False, variant_level=1)),
496
dbus.String("timeout"):
497
dbus.UInt64(self.timeout_milliseconds(),
499
dbus.String("interval"):
500
dbus.UInt64(self.interval_milliseconds(),
502
dbus.String("checker"):
503
dbus.String(self.checker_command,
505
dbus.String("checker_running"):
506
dbus.Boolean(self.checker is not None,
508
dbus.String("object_path"):
509
dbus.ObjectPath(self.dbus_object_path,
513
# IsStillValid - method
514
IsStillValid = (dbus.service.method(_interface, out_signature="b")
516
IsStillValid.__name__ = "IsStillValid"
518
2013
# PropertyChanged - signal
2014
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
519
2015
@dbus.service.signal(_interface, signature="sv")
520
2016
def PropertyChanged(self, property, value):
524
# SetChecker - method
525
@dbus.service.method(_interface, in_signature="s")
526
def SetChecker(self, checker):
527
"D-Bus setter method"
528
self.checker_command = checker
530
self.PropertyChanged(dbus.String(u"checker"),
531
dbus.String(self.checker_command,
535
@dbus.service.method(_interface, in_signature="s")
536
def SetHost(self, host):
537
"D-Bus setter method"
540
self.PropertyChanged(dbus.String(u"host"),
541
dbus.String(self.host, variant_level=1))
543
# SetInterval - method
544
@dbus.service.method(_interface, in_signature="t")
545
def SetInterval(self, milliseconds):
546
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
548
self.PropertyChanged(dbus.String(u"interval"),
549
(dbus.UInt64(self.interval_milliseconds(),
553
@dbus.service.method(_interface, in_signature="ay",
555
def SetSecret(self, secret):
556
"D-Bus setter method"
557
self.secret = str(secret)
559
# SetTimeout - method
560
@dbus.service.method(_interface, in_signature="t")
561
def SetTimeout(self, milliseconds):
562
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
564
self.PropertyChanged(dbus.String(u"timeout"),
565
(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):
568
2053
# Enable - method
569
Enable = dbus.service.method(_interface)(enable)
570
Enable.__name__ = "Enable"
2054
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
2055
@dbus.service.method(_interface)
572
2060
# StartChecker - method
2061
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
573
2062
@dbus.service.method(_interface)
574
2063
def StartChecker(self):
576
2065
self.start_checker()
578
2067
# Disable - method
2068
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
579
2069
@dbus.service.method(_interface)
580
2070
def Disable(self):
584
2074
# StopChecker - method
585
StopChecker = dbus.service.method(_interface)(stop_checker)
586
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)
591
def peer_certificate(session):
592
"Return the peer's OpenPGP certificate as a bytestring"
593
# If not an OpenPGP certificate...
594
if (gnutls.library.functions
595
.gnutls_certificate_type_get(session._c_object)
596
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
597
# ...do the normal thing
598
return session.peer_certificate
599
list_size = ctypes.c_uint(1)
600
cert_list = (gnutls.library.functions
601
.gnutls_certificate_get_peers
602
(session._c_object, ctypes.byref(list_size)))
603
if not bool(cert_list) and list_size.value != 0:
604
raise gnutls.errors.GNUTLSError("error getting peer"
606
if list_size.value == 0:
609
return ctypes.string_at(cert.data, cert.size)
612
def fingerprint(openpgp):
613
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
614
# New GnuTLS "datum" with the OpenPGP public key
615
datum = (gnutls.library.types
616
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
619
ctypes.c_uint(len(openpgp))))
620
# New empty GnuTLS certificate
621
crt = gnutls.library.types.gnutls_openpgp_crt_t()
622
(gnutls.library.functions
623
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
624
# Import the OpenPGP public key into the certificate
625
(gnutls.library.functions
626
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
627
gnutls.library.constants
628
.GNUTLS_OPENPGP_FMT_RAW))
629
# Verify the self signature in the key
630
crtverify = ctypes.c_uint()
631
(gnutls.library.functions
632
.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
633
if crtverify.value != 0:
634
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
635
raise gnutls.errors.CertificateSecurityError("Verify failed")
636
# New buffer for the fingerprint
637
buf = ctypes.create_string_buffer(20)
638
buf_len = ctypes.c_size_t()
639
# Get the fingerprint from the certificate into the buffer
640
(gnutls.library.functions
641
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
642
ctypes.byref(buf_len)))
643
# Deinit the certificate
644
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
645
# Convert the buffer to a Python bytestring
646
fpr = ctypes.string_at(buf, buf_len.value)
647
# Convert the bytestring to hexadecimal notation
648
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
652
class TCP_handler(SocketServer.BaseRequestHandler, object):
653
"""A TCP request handler class.
654
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.
655
2322
Note: This will run in its own forked process."""
657
2324
def handle(self):
658
logger.info(u"TCP connection from: %s",
659
unicode(self.client_address))
660
session = (gnutls.connection
661
.ClientSession(self.request,
665
line = self.request.makefile().readline()
666
logger.debug(u"Protocol version: %r", line)
668
if int(line.strip().split()[0]) > 1:
670
except (ValueError, IndexError, RuntimeError), error:
671
logger.error(u"Unknown protocol version: %s", error)
674
# Note: gnutls.connection.X509Credentials is really a generic
675
# GnuTLS certificate credentials object so long as no X.509
676
# keys are added to it. Therefore, we can use it here despite
677
# using OpenPGP certificates.
679
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
680
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
682
# Use a fallback default, since this MUST be set.
683
priority = self.server.settings.get("priority", "NORMAL")
684
(gnutls.library.functions
685
.gnutls_priority_set_direct(session._c_object,
690
except gnutls.errors.GNUTLSError, error:
691
logger.warning(u"Handshake failed: %s", error)
692
# Do not run session.bye() here: the session is not
693
# established. Just abandon the request.
695
logger.debug(u"Handshake succeeded")
697
fpr = fingerprint(peer_certificate(session))
698
except (TypeError, gnutls.errors.GNUTLSError), error:
699
logger.warning(u"Bad certificate: %s", error)
702
logger.debug(u"Fingerprint: %s", fpr)
704
for c in self.server.clients:
705
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,))
709
logger.warning(u"Client not found for fingerprint: %s",
713
# Have to check if client.still_valid(), since it is possible
714
# that the client timed out while establishing the GnuTLS
716
if not client.still_valid():
717
logger.warning(u"Client %(name)s is invalid",
721
## This won't work here, since we're in a fork.
722
# client.checked_ok()
724
while sent_size < len(client.secret):
725
sent = session.send(client.secret[sent_size:])
726
logger.debug(u"Sent: %d, remaining: %d",
727
sent, len(client.secret)
728
- (sent_size + sent))
733
class IPv6_TCPServer(SocketServer.ForkingMixIn,
734
SocketServer.TCPServer, object):
735
"""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
737
settings: Server settings
738
clients: Set() of Client objects
739
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
741
address_family = socket.AF_INET6
742
def __init__(self, *args, **kwargs):
743
if "settings" in kwargs:
744
self.settings = kwargs["settings"]
745
del kwargs["settings"]
746
if "clients" in kwargs:
747
self.clients = kwargs["clients"]
748
del kwargs["clients"]
750
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)
751
2655
def server_bind(self):
752
2656
"""This overrides the normal server_bind() function
753
2657
to bind to an interface if one was specified, and also NOT to
754
2658
bind to an address or port if they were not specified."""
755
if self.settings["interface"]:
756
# 25 is from /usr/include/asm-i486/socket.h
757
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
759
self.socket.setsockopt(socket.SOL_SOCKET,
761
self.settings["interface"])
762
except socket.error, error:
763
if error[0] == errno.EPERM:
764
logger.error(u"No permission to"
765
u" bind to interface %s",
766
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)
769
2682
# Only bind(2) the socket if we really need to.
770
2683
if self.server_address[0] or self.server_address[1]:
2684
if self.server_address[1]:
2685
self.allow_reuse_address = True
771
2686
if not self.server_address[0]:
773
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,
774
2692
self.server_address[1])
775
2693
elif not self.server_address[1]:
776
self.server_address = (self.server_address[0],
778
# if self.settings["interface"]:
2694
self.server_address = (self.server_address[0], 0)
2695
# if self.interface:
779
2696
# self.server_address = (self.server_address[0],
782
2699
# if_nametoindex
785
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,
786
2734
def server_activate(self):
787
2735
if self.enabled:
788
return super(IPv6_TCPServer, self).server_activate()
2736
return socketserver.TCPServer.server_activate(self)
789
2738
def enable(self):
790
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}"
793
2927
def string_to_delta(interval):
794
2928
"""Parse a string and return a datetime.timedelta
796
>>> string_to_delta('7d')
797
datetime.timedelta(7)
798
>>> string_to_delta('60s')
799
datetime.timedelta(0, 60)
800
>>> string_to_delta('60m')
801
datetime.timedelta(0, 3600)
802
>>> string_to_delta('24h')
803
datetime.timedelta(1)
804
>>> string_to_delta(u'1w')
805
datetime.timedelta(7)
806
>>> string_to_delta('5m 30s')
807
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)
809
2949
timevalue = datetime.timedelta(0)
810
2950
for s in interval.split():
812
suffix = unicode(s[-1])
813
2953
value = int(s[:-1])
815
2955
delta = datetime.timedelta(value)
817
2957
delta = datetime.timedelta(0, value)
819
2959
delta = datetime.timedelta(0, 0, 0, 0, value)
821
2961
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
823
2963
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
826
except (ValueError, IndexError):
2965
raise ValueError("Unknown suffix {!r}".format(suffix))
2966
except IndexError as e:
2967
raise ValueError(*(e.args))
828
2968
timevalue += delta
829
2969
return timevalue
832
def server_state_changed(state):
833
"""Derived from the Avahi example code"""
834
if state == avahi.SERVER_COLLISION:
835
logger.error(u"Zeroconf server name collision")
837
elif state == avahi.SERVER_RUNNING:
841
def entry_group_state_changed(state, error):
842
"""Derived from the Avahi example code"""
843
logger.debug(u"Avahi state change: %i", state)
845
if state == avahi.ENTRY_GROUP_ESTABLISHED:
846
logger.debug(u"Zeroconf service established.")
847
elif state == avahi.ENTRY_GROUP_COLLISION:
848
logger.warning(u"Zeroconf service name collision.")
850
elif state == avahi.ENTRY_GROUP_FAILURE:
851
logger.critical(u"Avahi: Error in group state changed %s",
853
raise AvahiGroupError(u"State changed: %s" % unicode(error))
855
def if_nametoindex(interface):
856
"""Call the C function if_nametoindex(), or equivalent"""
857
global if_nametoindex
859
if_nametoindex = (ctypes.cdll.LoadLibrary
860
(ctypes.util.find_library("c"))
862
except (OSError, AttributeError):
863
if "struct" not in sys.modules:
865
if "fcntl" not in sys.modules:
867
def if_nametoindex(interface):
868
"Get an interface index the hard way, i.e. using fcntl()"
869
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
870
with closing(socket.socket()) as s:
871
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
872
struct.pack("16s16x", interface))
873
interface_index = struct.unpack("I", ifreq[16:20])[0]
874
return interface_index
875
return if_nametoindex(interface)
878
def daemon(nochdir = False, noclose = False):
2972
def daemon(nochdir=False, noclose=False):
879
2973
"""See daemon(3). Standard BSD Unix function.
880
2975
This should really exist as os.daemon, but it doesn't (yet)."""
902
parser = optparse.OptionParser(version = "%%prog %s" % version)
903
parser.add_option("-i", "--interface", type="string",
904
metavar="IF", help="Bind to interface IF")
905
parser.add_option("-a", "--address", type="string",
906
help="Address to listen for requests on")
907
parser.add_option("-p", "--port", type="int",
908
help="Port number to receive requests on")
909
parser.add_option("--check", action="store_true",
910
help="Run self-test")
911
parser.add_option("--debug", action="store_true",
912
help="Debug mode; run in foreground and log to"
914
parser.add_option("--priority", type="string", help="GnuTLS"
915
" priority string (see GnuTLS documentation)")
916
parser.add_option("--servicename", type="string", metavar="NAME",
917
help="Zeroconf service name")
918
parser.add_option("--configdir", type="string",
919
default="/etc/mandos", metavar="DIR",
920
help="Directory to search for configuration"
922
parser.add_option("--no-dbus", action="store_false",
924
help="Do not provide D-Bus system bus"
926
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()
933
3049
# Default values for config file for server-global settings
934
server_defaults = { "interface": "",
939
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
940
"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",
944
3073
# Parse config file for server-global settings
945
server_config = ConfigParser.SafeConfigParser(server_defaults)
3074
server_config = configparser.ConfigParser(server_defaults)
946
3075
del server_defaults
947
3076
server_config.read(os.path.join(options.configdir, "mandos.conf"))
948
# Convert the SafeConfigParser object to a dict
3077
# Convert the ConfigParser object to a dict
949
3078
server_settings = server_config.defaults()
950
3079
# Use the appropriate methods on the non-string config options
951
server_settings["debug"] = server_config.getboolean("DEFAULT",
953
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
3080
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3081
"foreground", "zeroconf"):
3082
server_settings[option] = server_config.getboolean("DEFAULT",
955
3084
if server_settings["port"]:
956
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
958
3096
del server_config
960
3098
# Override the settings from the config file with command line
961
3099
# options, if set.
962
3100
for option in ("interface", "address", "port", "debug",
963
"priority", "servicename", "configdir",
3101
"priority", "servicename", "configdir", "use_dbus",
3102
"use_ipv6", "debuglevel", "restore", "statedir",
3103
"socket", "foreground", "zeroconf"):
965
3104
value = getattr(options, option)
966
3105
if value is not None:
967
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
969
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")
971
3129
# For convenience
972
3130
debug = server_settings["debug"]
3131
debuglevel = server_settings["debuglevel"]
973
3132
use_dbus = server_settings["use_dbus"]
976
syslogger.setLevel(logging.WARNING)
977
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)
979
3148
if server_settings["servicename"] != "Mandos":
980
syslogger.setFormatter(logging.Formatter
981
('Mandos (%s): %%(levelname)s:'
983
% server_settings["servicename"]))
3149
syslogger.setFormatter(
3150
logging.Formatter("Mandos ({}) [%(process)d]:"
3151
" %(levelname)s: %(message)s".format(
3152
server_settings["servicename"])))
985
3154
# Parse config file with clients
986
client_defaults = { "timeout": "1h",
988
"checker": "fping -q -- %%(host)s",
991
client_config = ConfigParser.SafeConfigParser(client_defaults)
3155
client_config = configparser.ConfigParser(Client.client_defaults)
992
3156
client_config.read(os.path.join(server_settings["configdir"],
993
3157
"clients.conf"))
996
tcp_server = IPv6_TCPServer((server_settings["address"],
997
server_settings["port"]),
999
settings=server_settings,
1001
pidfilename = "/var/run/mandos.pid"
1003
pidfile = open(pidfilename, "w")
1005
logger.error("Could not open file %r", pidfilename)
1008
uid = pwd.getpwnam("_mandos").pw_uid
1009
gid = pwd.getpwnam("_mandos").pw_gid
1012
uid = pwd.getpwnam("mandos").pw_uid
1013
gid = pwd.getpwnam("mandos").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
1014
3191
except KeyError:
1016
uid = pwd.getpwnam("nobody").pw_uid
1017
gid = pwd.getpwnam("nogroup").pw_gid
1024
except OSError, error:
1025
if error[0] != errno.EPERM:
1028
# Enable all possible GnuTLS debugging
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
1030
3209
# "Use a log level over 10 to enable all debugging options."
1031
3210
# - GnuTLS manual
1032
gnutls.library.functions.gnutls_global_set_log_level(11)
1034
@gnutls.library.types.gnutls_log_func
3211
gnutls.global_set_log_level(11)
1035
3214
def debug_gnutls(level, string):
1036
logger.debug("GnuTLS: %s", string[:-1])
1038
(gnutls.library.functions
1039
.gnutls_global_set_log_function(debug_gnutls))
1042
service = AvahiService(name = server_settings["servicename"],
1043
servicetype = "_mandos._tcp", )
1044
if server_settings["interface"]:
1045
service.interface = (if_nametoindex
1046
(server_settings["interface"]))
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.
1048
3236
global main_loop
1051
3237
# From the Avahi example code
1052
DBusGMainLoop(set_as_default=True )
1053
main_loop = gobject.MainLoop()
3238
DBusGMainLoop(set_as_default=True)
3239
main_loop = GLib.MainLoop()
1054
3240
bus = dbus.SystemBus()
1055
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1056
avahi.DBUS_PATH_SERVER),
1057
avahi.DBUS_INTERFACE_SERVER)
1058
3241
# End of Avahi example code
1060
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1062
clients.update(Set(Client(name = section,
1064
= dict(client_config.items(section)),
1065
use_dbus = use_dbus)
1066
for section in client_config.sections()))
1068
logger.warning(u"No clients defined")
1071
# Redirect stdin so all checkers get /dev/null
1072
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1073
os.dup2(null, sys.stdin.fileno())
1077
# No console logging
1078
logger.removeHandler(console)
1079
# Close all input and output, do double fork, etc.
1084
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",
1088
logger.error(u"Could not write to file %r with PID %d",
1091
# "pidfile" was never created
1096
"Cleanup function; run on exit"
1098
# From the Avahi example code
1099
if not group is None:
1102
# End of Avahi example code
1105
client = clients.pop()
1106
client.disable_hook = None
1109
atexit.register(cleanup)
1112
signal.signal(signal.SIGINT, signal.SIG_IGN)
1113
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1114
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)
1117
class MandosServer(dbus.service.Object):
3446
@alternate_dbus_interfaces(
3447
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3448
class MandosDBusService(DBusObjectWithObjectManager):
1118
3449
"""A D-Bus proxy object"""
1119
3451
def __init__(self):
1120
3452
dbus.service.Object.__init__(self, bus, "/")
1121
_interface = u"se.bsnet.fukt.Mandos"
1123
@dbus.service.signal(_interface, signature="oa{sv}")
1124
def ClientAdded(self, objpath, properties):
3454
_interface = "se.recompile.Mandos"
3456
@dbus.service.signal(_interface, signature="o")
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":
1128
3468
@dbus.service.signal(_interface, signature="os")
1129
3469
def ClientRemoved(self, objpath, name):
3473
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
1133
3475
@dbus.service.method(_interface, out_signature="ao")
1134
3476
def GetAllClients(self):
1136
return dbus.Array(c.dbus_object_path for c in clients)
1138
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
3478
return dbus.Array(c.dbus_object_path for c in
3479
tcp_server.clients.values())
3481
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3483
@dbus.service.method(_interface,
3484
out_signature="a{oa{sv}}")
1139
3485
def GetAllClientsWithProperties(self):
1141
3487
return dbus.Dictionary(
1142
((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()},
1144
3491
signature="oa{sv}")
1146
3493
@dbus.service.method(_interface, in_signature="o")
1147
3494
def RemoveClient(self, object_path):
3496
for c in tcp_server.clients.values():
1150
3497
if c.dbus_object_path == object_path:
1152
# Don't signal anything except ClientRemoved
1156
self.ClientRemoved(object_path, c.name)
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)
1162
mandos_server = MandosServer()
1164
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():
1167
mandos_server.ClientAdded(client.dbus_object_path,
1168
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)
1171
3637
tcp_server.enable()
1172
3638
tcp_server.server_activate()
1174
3640
# Find out what port we got
1175
service.port = tcp_server.socket.getsockname()[1]
1176
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
1177
u" scope_id %d" % tcp_server.socket.getsockname())
1179
#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]
1182
# From the Avahi example code
1183
server.connect_to_signal("StateChanged", server_state_changed)
1185
server_state_changed(server.GetState())
1186
except dbus.exceptions.DBusException, error:
1187
logger.critical(u"DBusException: %s", error)
1189
# End of Avahi example code
1191
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1192
lambda *args, **kwargs:
1193
(tcp_server.handle_request
1194
(*args[2:], **kwargs) or True))
1196
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")
1197
3670
main_loop.run()
1198
except AvahiError, error:
1199
logger.critical(u"AvahiError: %s", error)
3671
except AvahiError as error:
3672
log.critical("Avahi Error", exc_info=error)
1201
3675
except KeyboardInterrupt:
1204
logger.debug("Server received KeyboardInterrupt")
1205
logger.debug("Server exiting")
1207
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))