411
427
interval: datetime.timedelta(); How often to start a new checker
412
428
last_approval_request: datetime.datetime(); (UTC) or None
413
429
last_checked_ok: datetime.datetime(); (UTC) or None
415
430
last_checker_status: integer between 0 and 255 reflecting exit
416
431
status of last checker. -1 reflects crashed
418
last_enabled: datetime.datetime(); (UTC)
432
checker, -2 means no checker completed yet.
433
last_enabled: datetime.datetime(); (UTC) or None
419
434
name: string; from the config file, used in log messages and
420
435
D-Bus identifiers
421
436
secret: bytestring; sent verbatim (over TLS) to client
422
437
timeout: datetime.timedelta(); How long from last_checked_ok
423
438
until this client is disabled
424
extended_timeout: extra long timeout when password has been sent
439
extended_timeout: extra long timeout when secret has been sent
425
440
runtime_expansions: Allowed attributes for runtime expansion.
426
441
expires: datetime.datetime(); time (UTC) when a client will be
427
442
disabled, or None
430
445
runtime_expansions = ("approval_delay", "approval_duration",
431
"created", "enabled", "fingerprint",
432
"host", "interval", "last_checked_ok",
446
"created", "enabled", "expires",
447
"fingerprint", "host", "interval",
448
"last_approval_request", "last_checked_ok",
433
449
"last_enabled", "name", "timeout")
450
client_defaults = { "timeout": "PT5M",
451
"extended_timeout": "PT15M",
453
"checker": "fping -q -- %%(host)s",
455
"approval_delay": "PT0S",
456
"approval_duration": "PT1S",
457
"approved_by_default": "True",
435
461
def timeout_milliseconds(self):
436
462
"Return the 'timeout' attribute in milliseconds"
437
return _timedelta_to_milliseconds(self.timeout)
463
return timedelta_to_milliseconds(self.timeout)
439
465
def extended_timeout_milliseconds(self):
440
466
"Return the 'extended_timeout' attribute in milliseconds"
441
return _timedelta_to_milliseconds(self.extended_timeout)
467
return timedelta_to_milliseconds(self.extended_timeout)
443
469
def interval_milliseconds(self):
444
470
"Return the 'interval' attribute in milliseconds"
445
return _timedelta_to_milliseconds(self.interval)
471
return timedelta_to_milliseconds(self.interval)
447
473
def approval_delay_milliseconds(self):
448
return _timedelta_to_milliseconds(self.approval_delay)
450
def __init__(self, name = None, config=None):
451
"""Note: the 'checker' key in 'config' sets the
452
'checker_command' attribute and *not* the 'checker'
474
return timedelta_to_milliseconds(self.approval_delay)
477
def config_parser(config):
478
"""Construct a new dict of client settings of this form:
479
{ client_name: {setting_name: value, ...}, ...}
480
with exceptions for any special settings as defined above.
481
NOTE: Must be a pure function. Must return the same result
482
value given the same arguments.
485
for client_name in config.sections():
486
section = dict(config.items(client_name))
487
client = settings[client_name] = {}
489
client["host"] = section["host"]
490
# Reformat values from string types to Python types
491
client["approved_by_default"] = config.getboolean(
492
client_name, "approved_by_default")
493
client["enabled"] = config.getboolean(client_name,
496
client["fingerprint"] = (section["fingerprint"].upper()
498
if "secret" in section:
499
client["secret"] = section["secret"].decode("base64")
500
elif "secfile" in section:
501
with open(os.path.expanduser(os.path.expandvars
502
(section["secfile"])),
504
client["secret"] = secfile.read()
506
raise TypeError("No secret or secfile for section {0}"
508
client["timeout"] = string_to_delta(section["timeout"])
509
client["extended_timeout"] = string_to_delta(
510
section["extended_timeout"])
511
client["interval"] = string_to_delta(section["interval"])
512
client["approval_delay"] = string_to_delta(
513
section["approval_delay"])
514
client["approval_duration"] = string_to_delta(
515
section["approval_duration"])
516
client["checker_command"] = section["checker"]
517
client["last_approval_request"] = None
518
client["last_checked_ok"] = None
519
client["last_checker_status"] = -2
523
def __init__(self, settings, name = None):
525
# adding all client settings
526
for setting, value in settings.iteritems():
527
setattr(self, setting, value)
530
if not hasattr(self, "last_enabled"):
531
self.last_enabled = datetime.datetime.utcnow()
532
if not hasattr(self, "expires"):
533
self.expires = (datetime.datetime.utcnow()
536
self.last_enabled = None
457
539
logger.debug("Creating client %r", self.name)
458
540
# Uppercase and remove spaces from fingerprint for later
459
541
# comparison purposes with return value from the fingerprint()
461
self.fingerprint = (config["fingerprint"].upper()
463
543
logger.debug(" Fingerprint: %s", self.fingerprint)
464
if "secret" in config:
465
self.secret = config["secret"].decode("base64")
466
elif "secfile" in config:
467
with open(os.path.expanduser(os.path.expandvars
468
(config["secfile"])),
470
self.secret = secfile.read()
472
raise TypeError("No secret or secfile for client %s"
474
self.host = config.get("host", "")
475
self.created = datetime.datetime.utcnow()
477
self.last_approval_request = None
478
self.last_enabled = datetime.datetime.utcnow()
479
self.last_checked_ok = None
480
self.last_checker_status = None
481
self.timeout = string_to_delta(config["timeout"])
482
self.extended_timeout = string_to_delta(config
483
["extended_timeout"])
484
self.interval = string_to_delta(config["interval"])
544
self.created = settings.get("created",
545
datetime.datetime.utcnow())
547
# attributes specific for this server instance
485
548
self.checker = None
486
549
self.checker_initiator_tag = None
487
550
self.disable_initiator_tag = None
488
self.expires = datetime.datetime.utcnow() + self.timeout
489
551
self.checker_callback_tag = None
490
self.checker_command = config["checker"]
491
552
self.current_checker_command = None
492
self._approved = None
493
self.approved_by_default = config.get("approved_by_default",
495
554
self.approvals_pending = 0
496
self.approval_delay = string_to_delta(
497
config["approval_delay"])
498
self.approval_duration = string_to_delta(
499
config["approval_duration"])
500
555
self.changedstate = (multiprocessing_manager
501
556
.Condition(multiprocessing_manager
853
964
e.setAttribute("access", prop._dbus_access)
855
966
for if_tag in document.getElementsByTagName("interface"):
856
968
for tag in (make_tag(document, name, prop)
858
in self._get_all_dbus_properties()
970
in self._get_all_dbus_things("property")
859
971
if prop._dbus_interface
860
972
== if_tag.getAttribute("name")):
861
973
if_tag.appendChild(tag)
974
# Add annotation tags
975
for typ in ("method", "signal", "property"):
976
for tag in if_tag.getElementsByTagName(typ):
978
for name, prop in (self.
979
_get_all_dbus_things(typ)):
980
if (name == tag.getAttribute("name")
981
and prop._dbus_interface
982
== if_tag.getAttribute("name")):
983
annots.update(getattr
987
for name, value in annots.iteritems():
988
ann_tag = document.createElement(
990
ann_tag.setAttribute("name", name)
991
ann_tag.setAttribute("value", value)
992
tag.appendChild(ann_tag)
993
# Add interface annotation tags
994
for annotation, value in dict(
995
itertools.chain.from_iterable(
996
annotations().iteritems()
997
for name, annotations in
998
self._get_all_dbus_things("interface")
999
if name == if_tag.getAttribute("name")
1001
ann_tag = document.createElement("annotation")
1002
ann_tag.setAttribute("name", annotation)
1003
ann_tag.setAttribute("value", value)
1004
if_tag.appendChild(ann_tag)
862
1005
# Add the names to the return values for the
863
1006
# "org.freedesktop.DBus.Properties" methods
864
1007
if (if_tag.getAttribute("name")
891
1034
variant_level=variant_level)
894
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
896
"""Applied to an empty subclass of a D-Bus object, this metaclass
897
will add additional D-Bus attributes matching a certain pattern.
1037
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
1038
"""A class decorator; applied to a subclass of
1039
dbus.service.Object, it will add alternate D-Bus attributes with
1040
interface names according to the "alt_interface_names" mapping.
1043
@alternate_dbus_interfaces({"org.example.Interface":
1044
"net.example.AlternateInterface"})
1045
class SampleDBusObject(dbus.service.Object):
1046
@dbus.service.method("org.example.Interface")
1047
def SampleDBusMethod():
1050
The above "SampleDBusMethod" on "SampleDBusObject" will be
1051
reachable via two interfaces: "org.example.Interface" and
1052
"net.example.AlternateInterface", the latter of which will have
1053
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1054
"true", unless "deprecate" is passed with a False value.
1056
This works for methods and signals, and also for D-Bus properties
1057
(from DBusObjectWithProperties) and interfaces (from the
1058
dbus_interface_annotations decorator).
899
def __new__(mcs, name, bases, attr):
900
# Go through all the base classes which could have D-Bus
901
# methods, signals, or properties in them
902
for base in (b for b in bases
903
if issubclass(b, dbus.service.Object)):
904
# Go though all attributes of the base class
905
for attrname, attribute in inspect.getmembers(base):
1061
for orig_interface_name, alt_interface_name in (
1062
alt_interface_names.iteritems()):
1064
interface_names = set()
1065
# Go though all attributes of the class
1066
for attrname, attribute in inspect.getmembers(cls):
906
1067
# Ignore non-D-Bus attributes, and D-Bus attributes
907
1068
# with the wrong interface name
908
1069
if (not hasattr(attribute, "_dbus_interface")
909
1070
or not attribute._dbus_interface
910
.startswith("se.recompile.Mandos")):
1071
.startswith(orig_interface_name)):
912
1073
# Create an alternate D-Bus interface name based on
913
1074
# the current name
914
1075
alt_interface = (attribute._dbus_interface
915
.replace("se.recompile.Mandos",
916
"se.bsnet.fukt.Mandos"))
1076
.replace(orig_interface_name,
1077
alt_interface_name))
1078
interface_names.add(alt_interface)
917
1079
# Is this a D-Bus signal?
918
1080
if getattr(attribute, "_dbus_is_signal", False):
919
1081
# Extract the original non-method function by
986
1160
attribute.func_name,
987
1161
attribute.func_defaults,
988
1162
attribute.func_closure)))
989
return type.__new__(mcs, name, bases, attr)
1163
# Copy annotations, if any
1165
attr[attrname]._dbus_annotations = (
1166
dict(attribute._dbus_annotations))
1167
except AttributeError:
1169
# Is this a D-Bus interface?
1170
elif getattr(attribute, "_dbus_is_interface", False):
1171
# Create a new, but exactly alike, function
1172
# object. Decorate it to be a new D-Bus interface
1173
# with the alternate D-Bus interface name. Add it
1175
attr[attrname] = (dbus_interface_annotations
1178
(attribute.func_code,
1179
attribute.func_globals,
1180
attribute.func_name,
1181
attribute.func_defaults,
1182
attribute.func_closure)))
1184
# Deprecate all alternate interfaces
1185
iname="_AlternateDBusNames_interface_annotation{0}"
1186
for interface_name in interface_names:
1187
@dbus_interface_annotations(interface_name)
1189
return { "org.freedesktop.DBus.Deprecated":
1191
# Find an unused name
1192
for aname in (iname.format(i)
1193
for i in itertools.count()):
1194
if aname not in attr:
1198
# Replace the class with a new subclass of it with
1199
# methods, signals, etc. as created above.
1200
cls = type(b"{0}Alternate".format(cls.__name__),
1206
@alternate_dbus_interfaces({"se.recompile.Mandos":
1207
"se.bsnet.fukt.Mandos"})
992
1208
class ClientDBus(Client, DBusObjectWithProperties):
993
1209
"""A Client class using D-Bus
1058
1271
checker is not None)
1059
1272
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1060
1273
"LastCheckedOK")
1274
last_checker_status = notifychangeproperty(dbus.Int16,
1275
"LastCheckerStatus")
1061
1276
last_approval_request = notifychangeproperty(
1062
1277
datetime_to_dbus, "LastApprovalRequest")
1063
1278
approved_by_default = notifychangeproperty(dbus.Boolean,
1064
1279
"ApprovedByDefault")
1065
approval_delay = notifychangeproperty(dbus.UInt16,
1280
approval_delay = notifychangeproperty(dbus.UInt64,
1066
1281
"ApprovalDelay",
1068
_timedelta_to_milliseconds)
1283
timedelta_to_milliseconds)
1069
1284
approval_duration = notifychangeproperty(
1070
dbus.UInt16, "ApprovalDuration",
1071
type_func = _timedelta_to_milliseconds)
1285
dbus.UInt64, "ApprovalDuration",
1286
type_func = timedelta_to_milliseconds)
1072
1287
host = notifychangeproperty(dbus.String, "Host")
1073
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1288
timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1075
_timedelta_to_milliseconds)
1290
timedelta_to_milliseconds)
1076
1291
extended_timeout = notifychangeproperty(
1077
dbus.UInt16, "ExtendedTimeout",
1078
type_func = _timedelta_to_milliseconds)
1079
interval = notifychangeproperty(dbus.UInt16,
1292
dbus.UInt64, "ExtendedTimeout",
1293
type_func = timedelta_to_milliseconds)
1294
interval = notifychangeproperty(dbus.UInt64,
1082
_timedelta_to_milliseconds)
1297
timedelta_to_milliseconds)
1083
1298
checker_command = notifychangeproperty(dbus.String, "Checker")
1085
1300
del notifychangeproperty
1698
1909
use_ipv6: Boolean; to use IPv6 or not
1700
1911
def __init__(self, server_address, RequestHandlerClass,
1701
interface=None, use_ipv6=True):
1912
interface=None, use_ipv6=True, socketfd=None):
1913
"""If socketfd is set, use that file descriptor instead of
1914
creating a new one with socket.socket().
1702
1916
self.interface = interface
1704
1918
self.address_family = socket.AF_INET6
1919
if socketfd is not None:
1920
# Save the file descriptor
1921
self.socketfd = socketfd
1922
# Save the original socket.socket() function
1923
self.socket_socket = socket.socket
1924
# To implement --socket, we monkey patch socket.socket.
1926
# (When socketserver.TCPServer is a new-style class, we
1927
# could make self.socket into a property instead of monkey
1928
# patching socket.socket.)
1930
# Create a one-time-only replacement for socket.socket()
1931
@functools.wraps(socket.socket)
1932
def socket_wrapper(*args, **kwargs):
1933
# Restore original function so subsequent calls are
1935
socket.socket = self.socket_socket
1936
del self.socket_socket
1937
# This time only, return a new socket object from the
1938
# saved file descriptor.
1939
return socket.fromfd(self.socketfd, *args, **kwargs)
1940
# Replace socket.socket() function with wrapper
1941
socket.socket = socket_wrapper
1942
# The socketserver.TCPServer.__init__ will call
1943
# socket.socket(), which might be our replacement,
1944
# socket_wrapper(), if socketfd was set.
1705
1945
socketserver.TCPServer.__init__(self, server_address,
1706
1946
RequestHandlerClass)
1707
1948
def server_bind(self):
1708
1949
"""This overrides the normal server_bind() function
1709
1950
to bind to an interface if one was specified, and also NOT to
2103
def rfc3339_duration_to_delta(duration):
2104
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2106
>>> rfc3339_duration_to_delta("P7D")
2107
datetime.timedelta(7)
2108
>>> rfc3339_duration_to_delta("PT60S")
2109
datetime.timedelta(0, 60)
2110
>>> rfc3339_duration_to_delta("PT60M")
2111
datetime.timedelta(0, 3600)
2112
>>> rfc3339_duration_to_delta("PT24H")
2113
datetime.timedelta(1)
2114
>>> rfc3339_duration_to_delta("P1W")
2115
datetime.timedelta(7)
2116
>>> rfc3339_duration_to_delta("PT5M30S")
2117
datetime.timedelta(0, 330)
2118
>>> rfc3339_duration_to_delta("P1DT3M20S")
2119
datetime.timedelta(1, 200)
2122
# Parsing an RFC 3339 duration with regular expressions is not
2123
# possible - there would have to be multiple places for the same
2124
# values, like seconds. The current code, while more esoteric, is
2125
# cleaner without depending on a parsing library. If Python had a
2126
# built-in library for parsing we would use it, but we'd like to
2127
# avoid excessive use of external libraries.
2129
# New type for defining tokens, syntax, and semantics all-in-one
2130
Token = collections.namedtuple("Token",
2131
("regexp", # To match token; if
2132
# "value" is not None,
2133
# must have a "group"
2135
"value", # datetime.timedelta or
2137
"followers")) # Tokens valid after
2139
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
2140
# the "duration" ABNF definition in RFC 3339, Appendix A.
2141
token_end = Token(re.compile(r"$"), None, frozenset())
2142
token_second = Token(re.compile(r"(\d+)S"),
2143
datetime.timedelta(seconds=1),
2144
frozenset((token_end,)))
2145
token_minute = Token(re.compile(r"(\d+)M"),
2146
datetime.timedelta(minutes=1),
2147
frozenset((token_second, token_end)))
2148
token_hour = Token(re.compile(r"(\d+)H"),
2149
datetime.timedelta(hours=1),
2150
frozenset((token_minute, token_end)))
2151
token_time = Token(re.compile(r"T"),
2153
frozenset((token_hour, token_minute,
2155
token_day = Token(re.compile(r"(\d+)D"),
2156
datetime.timedelta(days=1),
2157
frozenset((token_time, token_end)))
2158
token_month = Token(re.compile(r"(\d+)M"),
2159
datetime.timedelta(weeks=4),
2160
frozenset((token_day, token_end)))
2161
token_year = Token(re.compile(r"(\d+)Y"),
2162
datetime.timedelta(weeks=52),
2163
frozenset((token_month, token_end)))
2164
token_week = Token(re.compile(r"(\d+)W"),
2165
datetime.timedelta(weeks=1),
2166
frozenset((token_end,)))
2167
token_duration = Token(re.compile(r"P"), None,
2168
frozenset((token_year, token_month,
2169
token_day, token_time,
2171
# Define starting values
2172
value = datetime.timedelta() # Value so far
2174
followers = frozenset(token_duration,) # Following valid tokens
2175
s = duration # String left to parse
2176
# Loop until end token is found
2177
while found_token is not token_end:
2178
# Search for any currently valid tokens
2179
for token in followers:
2180
match = token.regexp.match(s)
2181
if match is not None:
2183
if token.value is not None:
2184
# Value found, parse digits
2185
factor = int(match.group(1), 10)
2186
# Add to value so far
2187
value += factor * token.value
2188
# Strip token from string
2189
s = token.regexp.sub("", s, 1)
2192
# Set valid next tokens
2193
followers = found_token.followers
2196
# No currently valid tokens were found
2197
raise ValueError("Invalid RFC 3339 duration")
1874
2202
def string_to_delta(interval):
1875
2203
"""Parse a string and return a datetime.timedelta
2002
2348
# Convert the SafeConfigParser object to a dict
2003
2349
server_settings = server_config.defaults()
2004
2350
# Use the appropriate methods on the non-string config options
2005
for option in ("debug", "use_dbus", "use_ipv6"):
2351
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2006
2352
server_settings[option] = server_config.getboolean("DEFAULT",
2008
2354
if server_settings["port"]:
2009
2355
server_settings["port"] = server_config.getint("DEFAULT",
2357
if server_settings["socket"]:
2358
server_settings["socket"] = server_config.getint("DEFAULT",
2360
# Later, stdin will, and stdout and stderr might, be dup'ed
2361
# over with an opened os.devnull. But we don't want this to
2362
# happen with a supplied network socket.
2363
if 0 <= server_settings["socket"] <= 2:
2364
server_settings["socket"] = os.dup(server_settings
2011
2366
del server_config
2013
2368
# Override the settings from the config file with command line
2014
2369
# options, if set.
2015
2370
for option in ("interface", "address", "port", "debug",
2016
2371
"priority", "servicename", "configdir",
2017
"use_dbus", "use_ipv6", "debuglevel", "restore"):
2372
"use_dbus", "use_ipv6", "debuglevel", "restore",
2373
"statedir", "socket", "foreground"):
2018
2374
value = getattr(options, option)
2019
2375
if value is not None:
2020
2376
server_settings[option] = value
2032
2391
debuglevel = server_settings["debuglevel"]
2033
2392
use_dbus = server_settings["use_dbus"]
2034
2393
use_ipv6 = server_settings["use_ipv6"]
2394
stored_state_path = os.path.join(server_settings["statedir"],
2396
foreground = server_settings["foreground"]
2037
initlogger(logging.DEBUG)
2399
initlogger(debug, logging.DEBUG)
2039
2401
if not debuglevel:
2042
2404
level = getattr(logging, debuglevel.upper())
2405
initlogger(debug, level)
2045
2407
if server_settings["servicename"] != "Mandos":
2046
2408
syslogger.setFormatter(logging.Formatter
2047
('Mandos (%s) [%%(process)d]:'
2048
' %%(levelname)s: %%(message)s'
2049
% server_settings["servicename"]))
2409
('Mandos ({0}) [%(process)d]:'
2410
' %(levelname)s: %(message)s'
2411
.format(server_settings
2051
2414
# Parse config file with clients
2052
client_defaults = { "timeout": "5m",
2053
"extended_timeout": "15m",
2055
"checker": "fping -q -- %%(host)s",
2057
"approval_delay": "0s",
2058
"approval_duration": "1s",
2060
client_config = configparser.SafeConfigParser(client_defaults)
2415
client_config = configparser.SafeConfigParser(Client
2061
2417
client_config.read(os.path.join(server_settings["configdir"],
2062
2418
"clients.conf"))
2217
2558
if (name != "secret" and
2218
2559
value != old_client_settings[client_name]
2220
setattr(client, name, value)
2561
client[name] = value
2221
2562
except KeyError:
2224
2565
# Clients who has passed its expire date can still be
2225
# enabled if its last checker was sucessful. Clients
2226
# whose checker failed before we stored its state is
2227
# assumed to have failed all checkers during downtime.
2228
if client["enabled"] and client["last_checked_ok"]:
2229
if ((datetime.datetime.utcnow()
2230
- client["last_checked_ok"])
2231
> client["interval"]):
2232
if client["last_checker_status"] != 0:
2566
# enabled if its last checker was successful. Clients
2567
# whose checker succeeded before we stored its state is
2568
# assumed to have successfully run all checkers during
2570
if client["enabled"]:
2571
if datetime.datetime.utcnow() >= client["expires"]:
2572
if not client["last_checked_ok"]:
2574
"disabling client {0} - Client never "
2575
"performed a successful checker"
2576
.format(client_name))
2577
client["enabled"] = False
2578
elif client["last_checker_status"] != 0:
2580
"disabling client {0} - Client "
2581
"last checker failed with error code {1}"
2582
.format(client_name,
2583
client["last_checker_status"]))
2233
2584
client["enabled"] = False
2235
2586
client["expires"] = (datetime.datetime
2237
2588
+ client["timeout"])
2239
client["changedstate"] = (multiprocessing_manager
2241
(multiprocessing_manager
2244
new_client = (ClientDBusTransitional.__new__
2245
(ClientDBusTransitional))
2246
tcp_server.clients[client_name] = new_client
2247
new_client.bus = bus
2248
for name, value in client.iteritems():
2249
setattr(new_client, name, value)
2250
client_object_name = unicode(client_name).translate(
2251
{ord("."): ord("_"),
2252
ord("-"): ord("_")})
2253
new_client.dbus_object_path = (dbus.ObjectPath
2255
+ client_object_name))
2256
DBusObjectWithProperties.__init__(new_client,
2261
tcp_server.clients[client_name] = (Client.__new__
2263
for name, value in client.iteritems():
2264
setattr(tcp_server.clients[client_name],
2589
logger.debug("Last checker succeeded,"
2590
" keeping {0} enabled"
2591
.format(client_name))
2268
tcp_server.clients[client_name].secret = (
2269
crypt.decrypt(tcp_server.clients[client_name]
2271
client_settings[client_name]
2593
client["secret"] = (
2594
pgp.decrypt(client["encrypted_secret"],
2595
client_settings[client_name]
2274
2598
# If decryption fails, we use secret from new settings
2275
tcp_server.clients[client_name].secret = (
2599
logger.debug("Failed to decrypt {0} old secret"
2600
.format(client_name))
2601
client["secret"] = (
2276
2602
client_settings[client_name]["secret"])
2278
# Create/remove clients based on new changes made to config
2279
for clientname in set(old_client_settings) - set(client_settings):
2280
del tcp_server.clients[clientname]
2281
for clientname in set(client_settings) - set(old_client_settings):
2282
tcp_server.clients[clientname] = (client_class(name
2604
# Add/remove clients based on new changes made to config
2605
for client_name in (set(old_client_settings)
2606
- set(client_settings)):
2607
del clients_data[client_name]
2608
for client_name in (set(client_settings)
2609
- set(old_client_settings)):
2610
clients_data[client_name] = client_settings[client_name]
2612
# Create all client objects
2613
for client_name, client in clients_data.iteritems():
2614
tcp_server.clients[client_name] = client_class(
2615
name = client_name, settings = client)
2288
2617
if not tcp_server.clients:
2289
2618
logger.warning("No clients defined")
2295
pidfile.write(str(pid) + "\n".encode("utf-8"))
2298
logger.error("Could not write to file %r with PID %d",
2301
# "pidfile" was never created
2621
if pidfile is not None:
2625
pidfile.write(str(pid) + "\n".encode("utf-8"))
2627
logger.error("Could not write to file %r with PID %d",
2303
2630
del pidfilename
2305
signal.signal(signal.SIGINT, signal.SIG_IGN)
2307
2632
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2308
2633
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2311
class MandosDBusService(dbus.service.Object):
2636
@alternate_dbus_interfaces({"se.recompile.Mandos":
2637
"se.bsnet.fukt.Mandos"})
2638
class MandosDBusService(DBusObjectWithProperties):
2312
2639
"""A D-Bus proxy object"""
2313
2640
def __init__(self):
2314
2641
dbus.service.Object.__init__(self, bus, "/")
2315
2642
_interface = "se.recompile.Mandos"
2644
@dbus_interface_annotations(_interface)
2646
return { "org.freedesktop.DBus.Property"
2647
".EmitsChangedSignal":
2317
2650
@dbus.service.signal(_interface, signature="o")
2318
2651
def ClientAdded(self, objpath):
2397
2729
if attr not in exclude:
2398
2730
client_dict[attr] = getattr(client, attr)
2400
clients.append(client_dict)
2732
clients[client.name] = client_dict
2401
2733
del client_settings[client.name]["secret"]
2404
with os.fdopen(os.open(stored_state_path,
2405
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2406
0600), "wb") as stored_state:
2736
with (tempfile.NamedTemporaryFile
2737
(mode='wb', suffix=".pickle", prefix='clients-',
2738
dir=os.path.dirname(stored_state_path),
2739
delete=False)) as stored_state:
2407
2740
pickle.dump((clients, client_settings), stored_state)
2741
tempname=stored_state.name
2742
os.rename(tempname, stored_state_path)
2408
2743
except (IOError, OSError) as e:
2409
logger.warning("Could not save persistent state: {0}"
2411
if e.errno not in (errno.ENOENT, errno.EACCES):
2749
if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
2750
logger.warning("Could not save persistent state: {0}"
2751
.format(os.strerror(e.errno)))
2753
logger.warning("Could not save persistent state:",
2414
2757
# Delete all clients, and settings from config
2415
2758
while tcp_server.clients: