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-2015 Teddy Hogeborn
7
# Copyright © 2008-2015 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"
77
73
server_interface = domain + ".Mandos"
78
74
client_interface = domain + ".Mandos.Client"
83
dbus.OBJECT_MANAGER_IFACE
84
except AttributeError:
85
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
88
78
def milliseconds_to_string(ms):
89
79
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))
80
return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
81
days = "{}T".format(td.days) if td.days else "",
82
hours = td.seconds // 3600,
83
minutes = (td.seconds % 3600) // 60,
84
seconds = td.seconds % 60))
97
87
def rfc3339_duration_to_delta(duration):
98
88
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
100
90
>>> rfc3339_duration_to_delta("P7D")
101
91
datetime.timedelta(7)
102
92
>>> rfc3339_duration_to_delta("PT60S")
112
102
>>> rfc3339_duration_to_delta("P1DT3M20S")
113
103
datetime.timedelta(1, 200)
116
106
# Parsing an RFC 3339 duration with regular expressions is not
117
107
# possible - there would have to be multiple places for the same
118
108
# values, like seconds. The current code, while more esoteric, is
119
109
# cleaner without depending on a parsing library. If Python had a
120
110
# built-in library for parsing we would use it, but we'd like to
121
111
# avoid excessive use of external libraries.
123
113
# New type for defining tokens, syntax, and semantics all-in-one
124
114
Token = collections.namedtuple("Token", (
125
115
"regexp", # To match token; if "value" is not None, must have
158
148
frozenset((token_year, token_month,
159
149
token_day, token_time,
161
# Define starting values:
163
value = datetime.timedelta()
151
# Define starting values
152
value = datetime.timedelta() # Value so far
164
153
found_token = None
165
# Following valid tokens
166
followers = frozenset((token_duration, ))
167
# String left to parse
154
followers = frozenset((token_duration, )) # Following valid tokens
155
s = duration # String left to parse
169
156
# Loop until end token is found
170
157
while found_token is not token_end:
171
158
# Search for any currently valid tokens
209
196
>>> string_to_delta('5m 30s')
210
197
datetime.timedelta(0, 330)
214
201
return rfc3339_duration_to_delta(interval)
215
202
except ValueError:
218
205
value = datetime.timedelta(0)
219
206
regexp = re.compile(r"(\d+)([dsmhw]?)")
221
208
for num, suffix in regexp.findall(interval):
222
209
if suffix == "d":
223
210
value += datetime.timedelta(int(num))
242
229
"ApprovalDuration", "ExtendedTimeout"):
243
230
return milliseconds_to_string(value)
244
231
return str(value)
246
233
# Create format string to print table rows
247
234
format_string = " ".join("{{{key}:{width}}}".format(
248
width=max(len(tablewords[key]),
249
max(len(valuetostring(client[key], key))
250
for client in clients)),
235
width = max(len(tablewords[key]),
236
max(len(valuetostring(client[key], key))
237
for client in clients)),
252
239
for key in keywords)
253
240
# Print header line
254
241
print(format_string.format(**tablewords))
255
242
for client in clients:
257
.format(**{key: valuetostring(client[key], key)
258
for key in keywords}))
243
print(format_string.format(**{
244
key: valuetostring(client[key], key)
245
for key in keywords }))
261
248
def has_actions(options):
283
270
parser = argparse.ArgumentParser()
284
271
parser.add_argument("--version", action="version",
285
version="%(prog)s {}".format(version),
272
version = "%(prog)s {}".format(version),
286
273
help="show version number and exit")
287
274
parser.add_argument("-a", "--all", action="store_true",
288
275
help="Select all clients")
289
276
parser.add_argument("-v", "--verbose", action="store_true",
290
277
help="Print all fields")
291
parser.add_argument("-j", "--dump-json", action="store_true",
292
help="Dump client data in JSON format")
293
278
parser.add_argument("-e", "--enable", action="store_true",
294
279
help="Enable client")
295
280
parser.add_argument("-d", "--disable", action="store_true",
334
319
help="Run self-test")
335
320
parser.add_argument("client", nargs="*", help="Client name")
336
321
options = parser.parse_args()
338
323
if has_actions(options) and not (options.client or options.all):
339
324
parser.error("Options require clients names or --all.")
340
325
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.")
326
parser.error("--verbose can only be used alone or with"
345
328
if options.all and not has_actions(options):
346
329
parser.error("--all requires an action.")
348
331
if options.check:
350
332
fail_count, test_count = doctest.testmod()
351
333
sys.exit(os.EX_OK if fail_count == 0 else 1)
354
336
bus = dbus.SystemBus()
355
337
mandos_dbus_objc = bus.get_object(busname, server_path)
356
338
except dbus.exceptions.DBusException:
357
339
print("Could not connect to Mandos server", file=sys.stderr)
360
342
mandos_serv = dbus.Interface(mandos_dbus_objc,
361
dbus_interface=server_interface)
362
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
343
dbus_interface = server_interface)
345
#block stderr since dbus library prints to stderr
366
346
null = os.open(os.path.devnull, os.O_RDWR)
367
347
stderrcopy = os.dup(sys.stderr.fileno())
368
348
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}
352
mandos_clients = mandos_serv.GetAllClientsWithProperties()
379
355
os.dup2(stderrcopy, sys.stderr.fileno())
380
356
os.close(stderrcopy)
381
except dbus.exceptions.DBusException as e:
382
print("Access denied: "
383
"Accessing mandos server through D-Bus: {}".format(e),
357
except dbus.exceptions.DBusException:
358
print("Access denied: Accessing mandos server through dbus.",
387
362
# Compile dict of (clients: properties) to process
390
365
if options.all or not options.client:
391
clients = {bus.get_object(busname, path): properties
392
for path, properties in mandos_clients.items()}
366
clients = { bus.get_object(busname, path): properties
367
for path, properties in mandos_clients.items() }
394
369
for name in options.client:
395
370
for path, client in mandos_clients.items():
401
376
print("Client not found on server: {!r}"
402
377
.format(name), file=sys.stderr)
405
380
if not has_actions(options) and clients:
406
if options.verbose or options.dump_json:
407
382
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",
383
"Created", "Interval", "Host", "Fingerprint",
384
"CheckerRunning", "LastEnabled",
385
"ApprovalPending", "ApprovedByDefault",
386
"LastApprovalRequest", "ApprovalDelay",
387
"ApprovalDuration", "Checker",
416
390
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)
392
print_clients(clients.values(), keywords)
432
394
# Process each client in the list by all selected options
433
395
for client in clients:
435
397
def set_client_prop(prop, value):
436
398
"""Set a Client D-Bus property"""
437
399
client.Set(client_interface, prop, value,
438
400
dbus_interface=dbus.PROPERTIES_IFACE)
440
402
def set_client_prop_ms(prop, value):
441
403
"""Set a Client D-Bus property, converted
442
404
from a string to milliseconds."""
443
405
set_client_prop(prop,
444
406
string_to_delta(value).total_seconds()
447
409
if options.remove:
448
410
mandos_serv.RemoveClient(client.__dbus_object_path__)
449
411
if options.enable:
457
419
if options.stop_checker:
458
420
set_client_prop("CheckerRunning", dbus.Boolean(False))
459
421
if options.is_enabled:
460
if client.Get(client_interface, "Enabled",
461
dbus_interface=dbus.PROPERTIES_IFACE):
422
sys.exit(0 if client.Get(client_interface,
425
dbus.PROPERTIES_IFACE)
465
427
if options.checker is not None:
466
428
set_client_prop("Checker", options.checker)
467
429
if options.host is not None:
added
removed
mandos-ctl
