2
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2008-2018 Teddy Hogeborn
7
# Copyright © 2008-2018 Björn Påhlsson
9
# This file is part of Mandos.
11
# Mandos is free software: you can redistribute it and/or modify it
12
# under the terms of the GNU General Public License as published by
6
# Copyright © 2008-2016 Teddy Hogeborn
7
# Copyright © 2008-2016 Björn Påhlsson
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
13
11
# the Free Software Foundation, either version 3 of the License, or
14
12
# (at your option) any later version.
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
18
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
17
# GNU General Public License for more details.
21
19
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
24
23
# Contact the authors at <mandos@recompile.se>.
27
26
from __future__ import (division, absolute_import, print_function,
66
64
"ApprovalDelay": "Approval Delay",
67
65
"ApprovalDuration": "Approval Duration",
68
66
"Checker": "Checker",
69
"ExtendedTimeout": "Extended Timeout",
71
"LastCheckerStatus": "Last Checker Status",
67
"ExtendedTimeout": "Extended Timeout"
73
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
74
70
domain = "se.recompile"
84
80
except AttributeError:
85
81
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
88
83
def milliseconds_to_string(ms):
89
84
td = datetime.timedelta(0, 0, 0, ms)
90
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
91
.format(days="{}T".format(td.days) if td.days else "",
92
hours=td.seconds // 3600,
93
minutes=(td.seconds % 3600) // 60,
94
seconds=td.seconds % 60))
85
return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
86
days = "{}T".format(td.days) if td.days else "",
87
hours = td.seconds // 3600,
88
minutes = (td.seconds % 3600) // 60,
89
seconds = td.seconds % 60))
97
92
def rfc3339_duration_to_delta(duration):
98
93
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
100
95
>>> rfc3339_duration_to_delta("P7D")
101
96
datetime.timedelta(7)
102
97
>>> rfc3339_duration_to_delta("PT60S")
112
107
>>> rfc3339_duration_to_delta("P1DT3M20S")
113
108
datetime.timedelta(1, 200)
116
111
# Parsing an RFC 3339 duration with regular expressions is not
117
112
# possible - there would have to be multiple places for the same
118
113
# values, like seconds. The current code, while more esoteric, is
119
114
# cleaner without depending on a parsing library. If Python had a
120
115
# built-in library for parsing we would use it, but we'd like to
121
116
# avoid excessive use of external libraries.
123
118
# New type for defining tokens, syntax, and semantics all-in-one
124
119
Token = collections.namedtuple("Token", (
125
120
"regexp", # To match token; if "value" is not None, must have
158
153
frozenset((token_year, token_month,
159
154
token_day, token_time,
161
# Define starting values:
163
value = datetime.timedelta()
156
# Define starting values
157
value = datetime.timedelta() # Value so far
164
158
found_token = None
165
# Following valid tokens
166
followers = frozenset((token_duration, ))
167
# String left to parse
159
followers = frozenset((token_duration, )) # Following valid tokens
160
s = duration # String left to parse
169
161
# Loop until end token is found
170
162
while found_token is not token_end:
171
163
# Search for any currently valid tokens
242
234
"ApprovalDuration", "ExtendedTimeout"):
243
235
return milliseconds_to_string(value)
244
236
return str(value)
246
238
# Create format string to print table rows
247
239
format_string = " ".join("{{{key}:{width}}}".format(
248
width=max(len(tablewords[key]),
249
max(len(valuetostring(client[key], key))
250
for client in clients)),
240
width = max(len(tablewords[key]),
241
max(len(valuetostring(client[key], key))
242
for client in clients)),
252
244
for key in keywords)
253
245
# Print header line
254
246
print(format_string.format(**tablewords))
255
247
for client in clients:
257
.format(**{key: valuetostring(client[key], key)
258
for key in keywords}))
248
print(format_string.format(**{
249
key: valuetostring(client[key], key)
250
for key in keywords }))
261
253
def has_actions(options):
283
275
parser = argparse.ArgumentParser()
284
276
parser.add_argument("--version", action="version",
285
version="%(prog)s {}".format(version),
277
version = "%(prog)s {}".format(version),
286
278
help="show version number and exit")
287
279
parser.add_argument("-a", "--all", action="store_true",
288
280
help="Select all clients")
289
281
parser.add_argument("-v", "--verbose", action="store_true",
290
282
help="Print all fields")
291
parser.add_argument("-j", "--dump-json", action="store_true",
292
help="Dump client data in JSON format")
293
283
parser.add_argument("-e", "--enable", action="store_true",
294
284
help="Enable client")
295
285
parser.add_argument("-d", "--disable", action="store_true",
334
324
help="Run self-test")
335
325
parser.add_argument("client", nargs="*", help="Client name")
336
326
options = parser.parse_args()
338
328
if has_actions(options) and not (options.client or options.all):
339
329
parser.error("Options require clients names or --all.")
340
330
if options.verbose and has_actions(options):
341
parser.error("--verbose can only be used alone.")
342
if options.dump_json and (options.verbose
343
or has_actions(options)):
344
parser.error("--dump-json can only be used alone.")
331
parser.error("--verbose can only be used alone or with"
345
333
if options.all and not has_actions(options):
346
334
parser.error("--all requires an action.")
348
336
if options.check:
350
337
fail_count, test_count = doctest.testmod()
351
338
sys.exit(os.EX_OK if fail_count == 0 else 1)
354
341
bus = dbus.SystemBus()
355
342
mandos_dbus_objc = bus.get_object(busname, server_path)
356
343
except dbus.exceptions.DBusException:
357
344
print("Could not connect to Mandos server", file=sys.stderr)
360
347
mandos_serv = dbus.Interface(mandos_dbus_objc,
361
dbus_interface=server_interface)
348
dbus_interface = server_interface)
362
349
mandos_serv_object_manager = dbus.Interface(
363
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
365
# block stderr since dbus library prints to stderr
350
mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)
352
#block stderr since dbus library prints to stderr
366
353
null = os.open(os.path.devnull, os.O_RDWR)
367
354
stderrcopy = os.dup(sys.stderr.fileno())
368
355
os.dup2(null, sys.stderr.fileno())
372
mandos_clients = {path: ifs_and_props[client_interface]
373
for path, ifs_and_props in
374
mandos_serv_object_manager
375
.GetManagedObjects().items()
376
if client_interface in ifs_and_props}
359
mandos_clients = { path: ifs_and_props[client_interface]
360
for path, ifs_and_props in
361
mandos_serv_object_manager
362
.GetManagedObjects().items()
363
if client_interface in ifs_and_props }
379
366
os.dup2(stderrcopy, sys.stderr.fileno())
380
367
os.close(stderrcopy)
381
368
except dbus.exceptions.DBusException as e:
382
print("Access denied: "
383
"Accessing mandos server through D-Bus: {}".format(e),
369
print("Access denied: Accessing mandos server through D-Bus: {}"
370
.format(e), file=sys.stderr)
387
373
# Compile dict of (clients: properties) to process
390
376
if options.all or not options.client:
391
clients = {bus.get_object(busname, path): properties
392
for path, properties in mandos_clients.items()}
377
clients = { bus.get_object(busname, path): properties
378
for path, properties in mandos_clients.items() }
394
380
for name in options.client:
395
381
for path, client in mandos_clients.items():
401
387
print("Client not found on server: {!r}"
402
388
.format(name), file=sys.stderr)
405
391
if not has_actions(options) and clients:
406
if options.verbose or options.dump_json:
407
393
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
408
"Created", "Interval", "Host", "KeyID",
409
"Fingerprint", "CheckerRunning",
410
"LastEnabled", "ApprovalPending",
411
"ApprovedByDefault", "LastApprovalRequest",
412
"ApprovalDelay", "ApprovalDuration",
413
"Checker", "ExtendedTimeout", "Expires",
394
"Created", "Interval", "Host", "Fingerprint",
395
"CheckerRunning", "LastEnabled",
396
"ApprovalPending", "ApprovedByDefault",
397
"LastApprovalRequest", "ApprovalDelay",
398
"ApprovalDuration", "Checker",
416
401
keywords = defaultkeywords
418
if options.dump_json:
419
json.dump({client["Name"]: {key:
421
if isinstance(client[key],
425
for client in clients.values()},
426
fp=sys.stdout, indent=4,
427
separators=(',', ': '))
430
print_clients(clients.values(), keywords)
403
print_clients(clients.values(), keywords)
432
405
# Process each client in the list by all selected options
433
406
for client in clients:
435
408
def set_client_prop(prop, value):
436
409
"""Set a Client D-Bus property"""
437
410
client.Set(client_interface, prop, value,
438
411
dbus_interface=dbus.PROPERTIES_IFACE)
440
413
def set_client_prop_ms(prop, value):
441
414
"""Set a Client D-Bus property, converted
442
415
from a string to milliseconds."""
443
416
set_client_prop(prop,
444
417
string_to_delta(value).total_seconds()
447
420
if options.remove:
448
421
mandos_serv.RemoveClient(client.__dbus_object_path__)
449
422
if options.enable:
457
430
if options.stop_checker:
458
431
set_client_prop("CheckerRunning", dbus.Boolean(False))
459
432
if options.is_enabled:
460
if client.Get(client_interface, "Enabled",
461
dbus_interface=dbus.PROPERTIES_IFACE):
433
sys.exit(0 if client.Get(client_interface,
436
dbus.PROPERTIES_IFACE)
465
438
if options.checker is not None:
466
439
set_client_prop("Checker", options.checker)
467
440
if options.host is not None:
added
removed
mandos-ctl
