2
# -*- mode: python; coding: utf-8; after-save-hook: (lambda () (let ((command (if (and (boundp 'tramp-file-name-structure) (string-match (car tramp-file-name-structure) (buffer-file-name))) (tramp-file-name-localname (tramp-dissect-file-name (buffer-file-name))) (buffer-file-name)))) (if (= (shell-command (format "%s --check" (shell-quote-argument command)) "*Test*") 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)) (kill-buffer "*Test*")) (display-buffer "*Test*")))); -*-
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
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
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,
79
64
"ApprovalDelay": "Approval Delay",
80
65
"ApprovalDuration": "Approval Duration",
81
66
"Checker": "Checker",
82
"ExtendedTimeout": "Extended Timeout",
84
"LastCheckerStatus": "Last Checker Status",
67
"ExtendedTimeout": "Extended Timeout"
86
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
87
70
domain = "se.recompile"
97
80
except AttributeError:
98
81
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
101
83
def milliseconds_to_string(ms):
102
84
td = datetime.timedelta(0, 0, 0, ms)
103
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
104
.format(days="{}T".format(td.days) if td.days else "",
105
hours=td.seconds // 3600,
106
minutes=(td.seconds % 3600) // 60,
107
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))
110
92
def rfc3339_duration_to_delta(duration):
111
93
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
113
95
>>> rfc3339_duration_to_delta("P7D")
114
96
datetime.timedelta(7)
115
97
>>> rfc3339_duration_to_delta("PT60S")
116
98
datetime.timedelta(0, 60)
117
99
>>> rfc3339_duration_to_delta("PT60M")
118
100
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
121
101
>>> rfc3339_duration_to_delta("PT24H")
122
102
datetime.timedelta(1)
123
103
>>> rfc3339_duration_to_delta("P1W")
126
106
datetime.timedelta(0, 330)
127
107
>>> rfc3339_duration_to_delta("P1DT3M20S")
128
108
datetime.timedelta(1, 200)
129
>>> # Can not be empty:
130
>>> rfc3339_duration_to_delta("")
131
Traceback (most recent call last):
133
ValueError: Invalid RFC 3339 duration: u''
134
>>> # Must start with "P":
135
>>> rfc3339_duration_to_delta("1D")
136
Traceback (most recent call last):
138
ValueError: Invalid RFC 3339 duration: u'1D'
139
>>> # Must use correct order
140
>>> rfc3339_duration_to_delta("PT1S2M")
141
Traceback (most recent call last):
143
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
144
>>> # Time needs time marker
145
>>> rfc3339_duration_to_delta("P1H2S")
146
Traceback (most recent call last):
148
ValueError: Invalid RFC 3339 duration: u'P1H2S'
149
>>> # Weeks can not be combined with anything else
150
>>> rfc3339_duration_to_delta("P1D2W")
151
Traceback (most recent call last):
153
ValueError: Invalid RFC 3339 duration: u'P1D2W'
154
>>> rfc3339_duration_to_delta("P2W2H")
155
Traceback (most recent call last):
157
ValueError: Invalid RFC 3339 duration: u'P2W2H'
160
111
# Parsing an RFC 3339 duration with regular expressions is not
161
112
# possible - there would have to be multiple places for the same
162
113
# values, like seconds. The current code, while more esoteric, is
163
114
# cleaner without depending on a parsing library. If Python had a
164
115
# built-in library for parsing we would use it, but we'd like to
165
116
# avoid excessive use of external libraries.
167
118
# New type for defining tokens, syntax, and semantics all-in-one
168
119
Token = collections.namedtuple("Token", (
169
120
"regexp", # To match token; if "value" is not None, must have
202
153
frozenset((token_year, token_month,
203
154
token_day, token_time,
205
# Define starting values:
207
value = datetime.timedelta()
156
# Define starting values
157
value = datetime.timedelta() # Value so far
208
158
found_token = None
209
# Following valid tokens
210
followers = frozenset((token_duration, ))
211
# String left to parse
159
followers = frozenset((token_duration, )) # Following valid tokens
160
s = duration # String left to parse
213
161
# Loop until end token is found
214
162
while found_token is not token_end:
215
163
# Search for any currently valid tokens
281
229
def print_clients(clients, keywords):
282
230
def valuetostring(value, keyword):
283
if isinstance(value, dbus.Boolean):
231
if type(value) is dbus.Boolean:
284
232
return "Yes" if value else "No"
285
233
if keyword in ("Timeout", "Interval", "ApprovalDelay",
286
234
"ApprovalDuration", "ExtendedTimeout"):
287
235
return milliseconds_to_string(value)
288
236
return str(value)
290
238
# Create format string to print table rows
291
239
format_string = " ".join("{{{key}:{width}}}".format(
292
width=max(len(tablewords[key]),
293
max(len(valuetostring(client[key], key))
294
for client in clients)),
240
width = max(len(tablewords[key]),
241
max(len(valuetostring(client[key], key))
242
for client in clients)),
296
244
for key in keywords)
297
245
# Print header line
298
246
print(format_string.format(**tablewords))
299
247
for client in clients:
301
.format(**{key: valuetostring(client[key], key)
302
for key in keywords}))
248
print(format_string.format(**{
249
key: valuetostring(client[key], key)
250
for key in keywords }))
305
253
def has_actions(options):
327
275
parser = argparse.ArgumentParser()
328
276
parser.add_argument("--version", action="version",
329
version="%(prog)s {}".format(version),
277
version = "%(prog)s {}".format(version),
330
278
help="show version number and exit")
331
279
parser.add_argument("-a", "--all", action="store_true",
332
280
help="Select all clients")
333
281
parser.add_argument("-v", "--verbose", action="store_true",
334
282
help="Print all fields")
335
parser.add_argument("-j", "--dump-json", action="store_true",
336
help="Dump client data in JSON format")
337
283
parser.add_argument("-e", "--enable", action="store_true",
338
284
help="Enable client")
339
285
parser.add_argument("-d", "--disable", action="store_true",
378
324
help="Run self-test")
379
325
parser.add_argument("client", nargs="*", help="Client name")
380
326
options = parser.parse_args()
382
328
if has_actions(options) and not (options.client or options.all):
383
329
parser.error("Options require clients names or --all.")
384
330
if options.verbose and has_actions(options):
385
parser.error("--verbose can only be used alone.")
386
if options.dump_json and (options.verbose
387
or has_actions(options)):
388
parser.error("--dump-json can only be used alone.")
331
parser.error("--verbose can only be used alone or with"
389
333
if options.all and not has_actions(options):
390
334
parser.error("--all requires an action.")
337
fail_count, test_count = doctest.testmod()
338
sys.exit(os.EX_OK if fail_count == 0 else 1)
393
341
bus = dbus.SystemBus()
394
342
mandos_dbus_objc = bus.get_object(busname, server_path)
395
343
except dbus.exceptions.DBusException:
396
log.critical("Could not connect to Mandos server")
344
print("Could not connect to Mandos server", file=sys.stderr)
399
347
mandos_serv = dbus.Interface(mandos_dbus_objc,
400
dbus_interface=server_interface)
348
dbus_interface = server_interface)
401
349
mandos_serv_object_manager = dbus.Interface(
402
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
404
# 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
405
353
null = os.open(os.path.devnull, os.O_RDWR)
406
354
stderrcopy = os.dup(sys.stderr.fileno())
407
355
os.dup2(null, sys.stderr.fileno())
411
mandos_clients = {path: ifs_and_props[client_interface]
412
for path, ifs_and_props in
413
mandos_serv_object_manager
414
.GetManagedObjects().items()
415
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 }
418
366
os.dup2(stderrcopy, sys.stderr.fileno())
419
367
os.close(stderrcopy)
420
368
except dbus.exceptions.DBusException as e:
421
log.critical("Failed to access Mandos server through D-Bus:"
369
print("Access denied: Accessing mandos server through D-Bus: {}"
370
.format(e), file=sys.stderr)
425
373
# Compile dict of (clients: properties) to process
428
376
if options.all or not options.client:
429
clients = {bus.get_object(busname, path): properties
430
for path, properties in mandos_clients.items()}
377
clients = { bus.get_object(busname, path): properties
378
for path, properties in mandos_clients.items() }
432
380
for name in options.client:
433
381
for path, client in mandos_clients.items():
436
384
clients[client_objc] = client
439
log.critical("Client not found on server: %r", name)
387
print("Client not found on server: {!r}"
388
.format(name), file=sys.stderr)
442
391
if not has_actions(options) and clients:
443
if options.verbose or options.dump_json:
444
393
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
445
"Created", "Interval", "Host", "KeyID",
446
"Fingerprint", "CheckerRunning",
447
"LastEnabled", "ApprovalPending",
448
"ApprovedByDefault", "LastApprovalRequest",
449
"ApprovalDelay", "ApprovalDuration",
450
"Checker", "ExtendedTimeout", "Expires",
394
"Created", "Interval", "Host", "Fingerprint",
395
"CheckerRunning", "LastEnabled",
396
"ApprovalPending", "ApprovedByDefault",
397
"LastApprovalRequest", "ApprovalDelay",
398
"ApprovalDuration", "Checker",
453
401
keywords = defaultkeywords
455
if options.dump_json:
456
json.dump({client["Name"]: {key:
458
if isinstance(client[key],
462
for client in clients.values()},
463
fp=sys.stdout, indent=4,
464
separators=(',', ': '))
467
print_clients(clients.values(), keywords)
403
print_clients(clients.values(), keywords)
469
405
# Process each client in the list by all selected options
470
406
for client in clients:
472
408
def set_client_prop(prop, value):
473
409
"""Set a Client D-Bus property"""
474
410
client.Set(client_interface, prop, value,
475
411
dbus_interface=dbus.PROPERTIES_IFACE)
477
413
def set_client_prop_ms(prop, value):
478
414
"""Set a Client D-Bus property, converted
479
415
from a string to milliseconds."""
480
416
set_client_prop(prop,
481
417
string_to_delta(value).total_seconds()
484
420
if options.remove:
485
421
mandos_serv.RemoveClient(client.__dbus_object_path__)
486
422
if options.enable:
494
430
if options.stop_checker:
495
431
set_client_prop("CheckerRunning", dbus.Boolean(False))
496
432
if options.is_enabled:
497
if client.Get(client_interface, "Enabled",
498
dbus_interface=dbus.PROPERTIES_IFACE):
433
sys.exit(0 if client.Get(client_interface,
436
dbus.PROPERTIES_IFACE)
502
438
if options.checker is not None:
503
439
set_client_prop("Checker", options.checker)
504
440
if options.host is not None:
530
466
client.Approve(dbus.Boolean(False),
531
467
dbus_interface=client_interface)
534
class Test_milliseconds_to_string(unittest.TestCase):
536
self.assertEqual(milliseconds_to_string(93785000),
538
def test_no_days(self):
539
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
540
def test_all_zero(self):
541
self.assertEqual(milliseconds_to_string(0), "00:00:00")
542
def test_no_fractional_seconds(self):
543
self.assertEqual(milliseconds_to_string(400), "00:00:00")
544
self.assertEqual(milliseconds_to_string(900), "00:00:00")
545
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
548
def should_only_run_tests():
549
parser = argparse.ArgumentParser(add_help=False)
550
parser.add_argument("--check", action='store_true')
551
args, unknown_args = parser.parse_known_args()
552
run_tests = args.check
554
# Remove --check argument from sys.argv
555
sys.argv[1:] = unknown_args
558
# Add all tests from doctest strings
559
def load_tests(loader, tests, none):
561
tests.addTests(doctest.DocTestSuite())
564
470
if __name__ == "__main__":
565
if should_only_run_tests():
566
# Call using ./tdd-python-script --check [--verbose]