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-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,
79
65
"ApprovalDelay": "Approval Delay",
80
66
"ApprovalDuration": "Approval Duration",
81
67
"Checker": "Checker",
82
"ExtendedTimeout": "Extended Timeout",
84
"LastCheckerStatus": "Last Checker Status",
68
"ExtendedTimeout": "Extended Timeout"
86
70
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
87
71
domain = "se.recompile"
97
81
except AttributeError:
98
82
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
101
84
def milliseconds_to_string(ms):
102
85
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))
86
return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
87
days = "{}T".format(td.days) if td.days else "",
88
hours = td.seconds // 3600,
89
minutes = (td.seconds % 3600) // 60,
90
seconds = td.seconds % 60))
110
93
def rfc3339_duration_to_delta(duration):
111
94
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
113
96
>>> rfc3339_duration_to_delta("P7D")
114
97
datetime.timedelta(7)
115
98
>>> rfc3339_duration_to_delta("PT60S")
116
99
datetime.timedelta(0, 60)
117
100
>>> rfc3339_duration_to_delta("PT60M")
118
101
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
121
102
>>> rfc3339_duration_to_delta("PT24H")
122
103
datetime.timedelta(1)
123
104
>>> rfc3339_duration_to_delta("P1W")
126
107
datetime.timedelta(0, 330)
127
108
>>> rfc3339_duration_to_delta("P1DT3M20S")
128
109
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
112
# Parsing an RFC 3339 duration with regular expressions is not
161
113
# possible - there would have to be multiple places for the same
162
114
# values, like seconds. The current code, while more esoteric, is
163
115
# cleaner without depending on a parsing library. If Python had a
164
116
# built-in library for parsing we would use it, but we'd like to
165
117
# avoid excessive use of external libraries.
167
119
# New type for defining tokens, syntax, and semantics all-in-one
168
120
Token = collections.namedtuple("Token", (
169
121
"regexp", # To match token; if "value" is not None, must have
202
154
frozenset((token_year, token_month,
203
155
token_day, token_time,
205
# Define starting values:
207
value = datetime.timedelta()
157
# Define starting values
158
value = datetime.timedelta() # Value so far
208
159
found_token = None
209
# Following valid tokens
210
followers = frozenset((token_duration, ))
211
# String left to parse
160
followers = frozenset((token_duration, )) # Following valid tokens
161
s = duration # String left to parse
213
162
# Loop until end token is found
214
163
while found_token is not token_end:
215
164
# Search for any currently valid tokens
281
230
def print_clients(clients, keywords):
282
231
def valuetostring(value, keyword):
283
if isinstance(value, dbus.Boolean):
232
if type(value) is dbus.Boolean:
284
233
return "Yes" if value else "No"
285
234
if keyword in ("Timeout", "Interval", "ApprovalDelay",
286
235
"ApprovalDuration", "ExtendedTimeout"):
287
236
return milliseconds_to_string(value)
288
237
return str(value)
290
239
# Create format string to print table rows
291
240
format_string = " ".join("{{{key}:{width}}}".format(
292
width=max(len(tablewords[key]),
293
max(len(valuetostring(client[key], key))
294
for client in clients)),
241
width = max(len(tablewords[key]),
242
max(len(valuetostring(client[key], key))
243
for client in clients)),
296
245
for key in keywords)
297
246
# Print header line
298
247
print(format_string.format(**tablewords))
299
248
for client in clients:
301
.format(**{key: valuetostring(client[key], key)
302
for key in keywords}))
249
print(format_string.format(**{
250
key: valuetostring(client[key], key)
251
for key in keywords }))
305
254
def has_actions(options):
327
276
parser = argparse.ArgumentParser()
328
277
parser.add_argument("--version", action="version",
329
version="%(prog)s {}".format(version),
278
version = "%(prog)s {}".format(version),
330
279
help="show version number and exit")
331
280
parser.add_argument("-a", "--all", action="store_true",
332
281
help="Select all clients")
378
327
help="Run self-test")
379
328
parser.add_argument("client", nargs="*", help="Client name")
380
329
options = parser.parse_args()
382
331
if has_actions(options) and not (options.client or options.all):
383
332
parser.error("Options require clients names or --all.")
384
333
if options.verbose and has_actions(options):
385
334
parser.error("--verbose can only be used alone.")
386
if options.dump_json and (options.verbose
387
or has_actions(options)):
335
if options.dump_json and (options.verbose or has_actions(options)):
388
336
parser.error("--dump-json can only be used alone.")
389
337
if options.all and not has_actions(options):
390
338
parser.error("--all requires an action.")
341
fail_count, test_count = doctest.testmod()
342
sys.exit(os.EX_OK if fail_count == 0 else 1)
393
345
bus = dbus.SystemBus()
394
346
mandos_dbus_objc = bus.get_object(busname, server_path)
395
347
except dbus.exceptions.DBusException:
396
log.critical("Could not connect to Mandos server")
348
print("Could not connect to Mandos server", file=sys.stderr)
399
351
mandos_serv = dbus.Interface(mandos_dbus_objc,
400
dbus_interface=server_interface)
352
dbus_interface = server_interface)
401
353
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
354
mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)
356
#block stderr since dbus library prints to stderr
405
357
null = os.open(os.path.devnull, os.O_RDWR)
406
358
stderrcopy = os.dup(sys.stderr.fileno())
407
359
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}
363
mandos_clients = { path: ifs_and_props[client_interface]
364
for path, ifs_and_props in
365
mandos_serv_object_manager
366
.GetManagedObjects().items()
367
if client_interface in ifs_and_props }
418
370
os.dup2(stderrcopy, sys.stderr.fileno())
419
371
os.close(stderrcopy)
420
372
except dbus.exceptions.DBusException as e:
421
log.critical("Failed to access Mandos server through D-Bus:"
373
print("Access denied: Accessing mandos server through D-Bus: {}"
374
.format(e), file=sys.stderr)
425
377
# Compile dict of (clients: properties) to process
428
380
if options.all or not options.client:
429
clients = {bus.get_object(busname, path): properties
430
for path, properties in mandos_clients.items()}
381
clients = { bus.get_object(busname, path): properties
382
for path, properties in mandos_clients.items() }
432
384
for name in options.client:
433
385
for path, client in mandos_clients.items():
436
388
clients[client_objc] = client
439
log.critical("Client not found on server: %r", name)
391
print("Client not found on server: {!r}"
392
.format(name), file=sys.stderr)
442
395
if not has_actions(options) and clients:
443
396
if options.verbose or options.dump_json:
444
397
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",
398
"Created", "Interval", "Host", "Fingerprint",
399
"CheckerRunning", "LastEnabled",
400
"ApprovalPending", "ApprovedByDefault",
401
"LastApprovalRequest", "ApprovalDelay",
402
"ApprovalDuration", "Checker",
453
405
keywords = defaultkeywords
455
407
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=(',', ': '))
408
json.dump({client["Name"]: {key: client[key]
409
for key in keywords }
410
for client in clients.values() },
411
fp = sys.stdout, indent = 4,
412
separators = (',', ': '))
467
415
print_clients(clients.values(), keywords)
469
417
# Process each client in the list by all selected options
470
418
for client in clients:
472
420
def set_client_prop(prop, value):
473
421
"""Set a Client D-Bus property"""
474
422
client.Set(client_interface, prop, value,
475
423
dbus_interface=dbus.PROPERTIES_IFACE)
477
425
def set_client_prop_ms(prop, value):
478
426
"""Set a Client D-Bus property, converted
479
427
from a string to milliseconds."""
480
428
set_client_prop(prop,
481
429
string_to_delta(value).total_seconds()
484
432
if options.remove:
485
433
mandos_serv.RemoveClient(client.__dbus_object_path__)
486
434
if options.enable:
494
442
if options.stop_checker:
495
443
set_client_prop("CheckerRunning", dbus.Boolean(False))
496
444
if options.is_enabled:
497
if client.Get(client_interface, "Enabled",
498
dbus_interface=dbus.PROPERTIES_IFACE):
445
sys.exit(0 if client.Get(client_interface,
448
dbus.PROPERTIES_IFACE)
502
450
if options.checker is not None:
503
451
set_client_prop("Checker", options.checker)
504
452
if options.host is not None:
530
478
client.Approve(dbus.Boolean(False),
531
479
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
482
if __name__ == "__main__":
565
if should_only_run_tests():
566
# Call using ./tdd-python-script --check [--verbose]