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