64
64
"ApprovalDelay": "Approval Delay",
65
65
"ApprovalDuration": "Approval Duration",
66
66
"Checker": "Checker",
67
"ExtendedTimeout" : "Extended Timeout"
67
"ExtendedTimeout": "Extended Timeout",
69
"LastCheckerStatus": "Last Checker Status",
69
71
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
70
72
domain = "se.recompile"
71
73
busname = domain + ".Mandos"
73
75
server_interface = domain + ".Mandos"
74
76
client_interface = domain + ".Mandos.Client"
77
def timedelta_to_milliseconds(td):
78
"""Convert a datetime.timedelta object to milliseconds"""
79
return ((td.days * 24 * 60 * 60 * 1000)
81
+ (td.microseconds // 1000))
81
dbus.OBJECT_MANAGER_IFACE
82
except AttributeError:
83
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
83
86
def milliseconds_to_string(ms):
84
87
td = datetime.timedelta(0, 0, 0, ms)
85
88
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
86
.format(days = "{0}T".format(td.days) if td.days else "",
87
hours = td.seconds // 3600,
88
minutes = (td.seconds % 3600) // 60,
89
seconds = td.seconds % 60,
89
.format(days="{}T".format(td.days) if td.days else "",
90
hours=td.seconds // 3600,
91
minutes=(td.seconds % 3600) // 60,
92
seconds=td.seconds % 60))
93
95
def rfc3339_duration_to_delta(duration):
94
96
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
96
98
>>> rfc3339_duration_to_delta("P7D")
97
99
datetime.timedelta(7)
98
100
>>> rfc3339_duration_to_delta("PT60S")
108
110
>>> rfc3339_duration_to_delta("P1DT3M20S")
109
111
datetime.timedelta(1, 200)
112
114
# Parsing an RFC 3339 duration with regular expressions is not
113
115
# possible - there would have to be multiple places for the same
114
116
# values, like seconds. The current code, while more esoteric, is
115
117
# cleaner without depending on a parsing library. If Python had a
116
118
# built-in library for parsing we would use it, but we'd like to
117
119
# avoid excessive use of external libraries.
119
121
# New type for defining tokens, syntax, and semantics all-in-one
120
Token = collections.namedtuple("Token",
121
("regexp", # To match token; if
122
# "value" is not None,
123
# must have a "group"
125
"value", # datetime.timedelta or
127
"followers")) # Tokens valid after
122
Token = collections.namedtuple("Token", (
123
"regexp", # To match token; if "value" is not None, must have
124
# a "group" containing digits
125
"value", # datetime.timedelta or None
126
"followers")) # Tokens valid after this token
129
127
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
130
128
# the "duration" ABNF definition in RFC 3339, Appendix A.
131
129
token_end = Token(re.compile(r"$"), None, frozenset())
132
130
token_second = Token(re.compile(r"(\d+)S"),
133
131
datetime.timedelta(seconds=1),
134
frozenset((token_end,)))
132
frozenset((token_end, )))
135
133
token_minute = Token(re.compile(r"(\d+)M"),
136
134
datetime.timedelta(minutes=1),
137
135
frozenset((token_second, token_end)))
153
151
frozenset((token_month, token_end)))
154
152
token_week = Token(re.compile(r"(\d+)W"),
155
153
datetime.timedelta(weeks=1),
156
frozenset((token_end,)))
154
frozenset((token_end, )))
157
155
token_duration = Token(re.compile(r"P"), None,
158
156
frozenset((token_year, token_month,
159
157
token_day, token_time,
161
# Define starting values
162
value = datetime.timedelta() # Value so far
159
# Define starting values:
161
value = datetime.timedelta()
163
162
found_token = None
164
followers = frozenset((token_duration,)) # Following valid tokens
165
s = duration # String left to parse
163
# Following valid tokens
164
followers = frozenset((token_duration, ))
165
# String left to parse
166
167
# Loop until end token is found
167
168
while found_token is not token_end:
168
169
# Search for any currently valid tokens
186
187
# No currently valid tokens were found
187
raise ValueError("Invalid RFC 3339 duration")
188
raise ValueError("Invalid RFC 3339 duration: {!r}"
188
190
# End token found
192
194
def string_to_delta(interval):
193
195
"""Parse a string and return a datetime.timedelta
195
>>> string_to_delta("7d")
197
>>> string_to_delta('7d')
196
198
datetime.timedelta(7)
197
>>> string_to_delta("60s")
199
>>> string_to_delta('60s')
198
200
datetime.timedelta(0, 60)
199
>>> string_to_delta("60m")
201
>>> string_to_delta('60m')
200
202
datetime.timedelta(0, 3600)
201
>>> string_to_delta("24h")
203
>>> string_to_delta('24h')
202
204
datetime.timedelta(1)
203
>>> string_to_delta("1w")
205
>>> string_to_delta('1w')
204
206
datetime.timedelta(7)
205
>>> string_to_delta("5m 30s")
207
>>> string_to_delta('5m 30s')
206
208
datetime.timedelta(0, 330)
210
212
return rfc3339_duration_to_delta(interval)
211
213
except ValueError:
214
216
value = datetime.timedelta(0)
215
217
regexp = re.compile(r"(\d+)([dsmhw]?)")
217
219
for num, suffix in regexp.findall(interval):
218
220
if suffix == "d":
219
221
value += datetime.timedelta(int(num))
278
281
parser = argparse.ArgumentParser()
279
282
parser.add_argument("--version", action="version",
280
version = "%(prog)s {0}".format(version),
283
version="%(prog)s {}".format(version),
281
284
help="show version number and exit")
282
285
parser.add_argument("-a", "--all", action="store_true",
283
286
help="Select all clients")
284
287
parser.add_argument("-v", "--verbose", action="store_true",
285
288
help="Print all fields")
289
parser.add_argument("-j", "--dump-json", action="store_true",
290
help="Dump client data in JSON format")
286
291
parser.add_argument("-e", "--enable", action="store_true",
287
292
help="Enable client")
288
293
parser.add_argument("-d", "--disable", action="store_true",
327
332
help="Run self-test")
328
333
parser.add_argument("client", nargs="*", help="Client name")
329
334
options = parser.parse_args()
331
336
if has_actions(options) and not (options.client or options.all):
332
337
parser.error("Options require clients names or --all.")
333
338
if options.verbose and has_actions(options):
334
parser.error("--verbose can only be used alone or with"
339
parser.error("--verbose can only be used alone.")
340
if options.dump_json and (options.verbose
341
or has_actions(options)):
342
parser.error("--dump-json can only be used alone.")
336
343
if options.all and not has_actions(options):
337
344
parser.error("--all requires an action.")
339
346
if options.check:
340
348
fail_count, test_count = doctest.testmod()
341
349
sys.exit(os.EX_OK if fail_count == 0 else 1)
344
352
bus = dbus.SystemBus()
345
353
mandos_dbus_objc = bus.get_object(busname, server_path)
346
354
except dbus.exceptions.DBusException:
347
print("Could not connect to Mandos server",
355
print("Could not connect to Mandos server", file=sys.stderr)
351
358
mandos_serv = dbus.Interface(mandos_dbus_objc,
352
dbus_interface = server_interface)
354
#block stderr since dbus library prints to stderr
359
dbus_interface=server_interface)
360
mandos_serv_object_manager = dbus.Interface(
361
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
363
# block stderr since dbus library prints to stderr
355
364
null = os.open(os.path.devnull, os.O_RDWR)
356
365
stderrcopy = os.dup(sys.stderr.fileno())
357
366
os.dup2(null, sys.stderr.fileno())
361
mandos_clients = mandos_serv.GetAllClientsWithProperties()
370
mandos_clients = {path: ifs_and_props[client_interface]
371
for path, ifs_and_props in
372
mandos_serv_object_manager
373
.GetManagedObjects().items()
374
if client_interface in ifs_and_props}
364
377
os.dup2(stderrcopy, sys.stderr.fileno())
365
378
os.close(stderrcopy)
366
except dbus.exceptions.DBusException:
367
print("Access denied: Accessing mandos server through dbus.",
379
except dbus.exceptions.DBusException as e:
380
print("Access denied: "
381
"Accessing mandos server through D-Bus: {}".format(e),
371
385
# Compile dict of (clients: properties) to process
374
388
if options.all or not options.client:
375
clients = dict((bus.get_object(busname, path), properties)
376
for path, properties in
377
mandos_clients.items())
389
clients = {bus.get_object(busname, path): properties
390
for path, properties in mandos_clients.items()}
379
392
for name in options.client:
380
for path, client in mandos_clients.iteritems():
393
for path, client in mandos_clients.items():
381
394
if client["Name"] == name:
382
395
client_objc = bus.get_object(busname, path)
383
396
clients[client_objc] = client
386
print("Client not found on server: {0!r}"
399
print("Client not found on server: {!r}"
387
400
.format(name), file=sys.stderr)
390
403
if not has_actions(options) and clients:
392
keywords = ("Name", "Enabled", "Timeout",
393
"LastCheckedOK", "Created", "Interval",
394
"Host", "Fingerprint", "CheckerRunning",
395
"LastEnabled", "ApprovalPending",
404
if options.verbose or options.dump_json:
405
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
406
"Created", "Interval", "Host", "Fingerprint",
407
"CheckerRunning", "LastEnabled",
408
"ApprovalPending", "ApprovedByDefault",
397
409
"LastApprovalRequest", "ApprovalDelay",
398
410
"ApprovalDuration", "Checker",
411
"ExtendedTimeout", "Expires",
401
414
keywords = defaultkeywords
403
print_clients(clients.values(), keywords)
416
if options.dump_json:
417
json.dump({client["Name"]: {key:
419
if isinstance(client[key],
423
for client in clients.values()},
424
fp=sys.stdout, indent=4,
425
separators=(',', ': '))
428
print_clients(clients.values(), keywords)
405
430
# Process each client in the list by all selected options
406
431
for client in clients:
407
433
def set_client_prop(prop, value):
408
434
"""Set a Client D-Bus property"""
409
435
client.Set(client_interface, prop, value,
410
436
dbus_interface=dbus.PROPERTIES_IFACE)
411
438
def set_client_prop_ms(prop, value):
412
439
"""Set a Client D-Bus property, converted
413
440
from a string to milliseconds."""
414
441
set_client_prop(prop,
415
timedelta_to_milliseconds
416
(string_to_delta(value)))
442
string_to_delta(value).total_seconds()
417
445
if options.remove:
418
446
mandos_serv.RemoveClient(client.__dbus_object_path__)
419
447
if options.enable: