To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 723
- compare with another revision
- download diff
- download tarball
- view history from revision 723
- Committer: Teddy Hogeborn
- Date: 2014-07-25 22:17:55 UTC
- Revision ID: teddy@recompile.se-20140725221755-7bak9szduz53wwtq
INSTALL: Add org-mode setting to show all text when opening.
* INSTALL (STARTUP): New org-mode setting; set to "showall".
* INSTALL (STARTUP): New org-mode setting; set to "showall".
added
removed
mandos-ctl
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2008-2016 Teddy Hogeborn
7
# Copyright © 2008-2016 Björn Påhlsson
6
# Copyright © 2008-2014 Teddy Hogeborn
7
# Copyright © 2008-2014 Björn Påhlsson
8
8
#
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
39
39
import os
40
40
import collections
41
41
import doctest
42
import json
43
42
44
43
import dbus
45
44
46
if sys.version_info.major == 2:
45
if sys.version_info[0] == 2:
47
46
str = unicode
48
47
49
48
locale.setlocale(locale.LC_ALL, "")
65
64
"ApprovalDelay": "Approval Delay",
66
65
"ApprovalDuration": "Approval Duration",
67
66
"Checker": "Checker",
68
"ExtendedTimeout": "Extended Timeout",
69
"Expires": "Expires",
70
"LastCheckerStatus": "Last Checker Status",
71
}
67
"ExtendedTimeout" : "Extended Timeout"
68
}
72
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
73
70
domain = "se.recompile"
74
71
busname = domain + ".Mandos"
75
72
server_path = "/"
76
73
server_interface = domain + ".Mandos"
77
74
client_interface = domain + ".Mandos.Client"
78
version = "1.7.10"
79
80
81
try:
82
dbus.OBJECT_MANAGER_IFACE
83
except AttributeError:
84
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
75
version = "1.6.7"
76
77
def timedelta_to_milliseconds(td):
78
"""Convert a datetime.timedelta object to milliseconds"""
79
return ((td.days * 24 * 60 * 60 * 1000)
80
+ (td.seconds * 1000)
81
+ (td.microseconds // 1000))
85
82
86
83
def milliseconds_to_string(ms):
87
84
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))
85
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
86
.format(days = "{0}T".format(td.days) if td.days else "",
87
hours = td.seconds // 3600,
88
minutes = (td.seconds % 3600) // 60,
89
seconds = td.seconds % 60,
90
))
93
91
94
92
95
93
def rfc3339_duration_to_delta(duration):
119
117
# avoid excessive use of external libraries.
120
118
121
119
# New type for defining tokens, syntax, and semantics all-in-one
122
Token = collections.namedtuple("Token", (
123
"regexp", # To match token; if "value" is not None, must have
124
# a "group" containing digits
125
"value", # datetime.timedelta or None
126
"followers")) # Tokens valid after this token
120
Token = collections.namedtuple("Token",
121
("regexp", # To match token; if
122
# "value" is not None,
123
# must have a "group"
124
# containing digits
125
"value", # datetime.timedelta or
126
# None
127
"followers")) # Tokens valid after
128
# this token
127
129
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
128
130
# the "duration" ABNF definition in RFC 3339, Appendix A.
129
131
token_end = Token(re.compile(r"$"), None, frozenset())
130
132
token_second = Token(re.compile(r"(\d+)S"),
131
133
datetime.timedelta(seconds=1),
132
frozenset((token_end, )))
134
frozenset((token_end,)))
133
135
token_minute = Token(re.compile(r"(\d+)M"),
134
136
datetime.timedelta(minutes=1),
135
137
frozenset((token_second, token_end)))
151
153
frozenset((token_month, token_end)))
152
154
token_week = Token(re.compile(r"(\d+)W"),
153
155
datetime.timedelta(weeks=1),
154
frozenset((token_end, )))
156
frozenset((token_end,)))
155
157
token_duration = Token(re.compile(r"P"), None,
156
158
frozenset((token_year, token_month,
157
159
token_day, token_time,
159
161
# Define starting values
160
162
value = datetime.timedelta() # Value so far
161
163
found_token = None
162
followers = frozenset((token_duration, )) # Following valid tokens
164
followers = frozenset((token_duration,)) # Following valid tokens
163
165
s = duration # String left to parse
164
166
# Loop until end token is found
165
167
while found_token is not token_end:
182
184
break
183
185
else:
184
186
# No currently valid tokens were found
185
raise ValueError("Invalid RFC 3339 duration: {!r}"
186
.format(duration))
187
raise ValueError("Invalid RFC 3339 duration")
187
188
# End token found
188
189
return value
189
190
191
192
def string_to_delta(interval):
192
193
"""Parse a string and return a datetime.timedelta
193
194
194
>>> string_to_delta('7d')
195
>>> string_to_delta("7d")
195
196
datetime.timedelta(7)
196
>>> string_to_delta('60s')
197
>>> string_to_delta("60s")
197
198
datetime.timedelta(0, 60)
198
>>> string_to_delta('60m')
199
>>> string_to_delta("60m")
199
200
datetime.timedelta(0, 3600)
200
>>> string_to_delta('24h')
201
>>> string_to_delta("24h")
201
202
datetime.timedelta(1)
202
>>> string_to_delta('1w')
203
>>> string_to_delta("1w")
203
204
datetime.timedelta(7)
204
>>> string_to_delta('5m 30s')
205
>>> string_to_delta("5m 30s")
205
206
datetime.timedelta(0, 330)
206
207
"""
207
208
228
229
value += datetime.timedelta(0, 0, 0, int(num))
229
230
return value
230
231
231
232
232
def print_clients(clients, keywords):
233
233
def valuetostring(value, keyword):
234
234
if type(value) is dbus.Boolean:
240
240
241
241
# Create format string to print table rows
242
242
format_string = " ".join("{{{key}:{width}}}".format(
243
width = max(len(tablewords[key]),
244
max(len(valuetostring(client[key], key))
245
for client in clients)),
246
key = key)
247
for key in keywords)
243
width = max(len(tablewords[key]),
244
max(len(valuetostring(client[key],
245
key))
246
for client in
247
clients)),
248
key = key) for key in keywords)
248
249
# Print header line
249
250
print(format_string.format(**tablewords))
250
251
for client in clients:
251
print(format_string.format(**{
252
key: valuetostring(client[key], key)
253
for key in keywords }))
254
252
print(format_string.format(**dict((key,
253
valuetostring(client[key],
254
key))
255
for key in keywords)))
255
256
256
257
def has_actions(options):
257
258
return any((options.enable,
273
274
options.approve,
274
275
options.deny))
275
276
276
277
277
def main():
278
278
parser = argparse.ArgumentParser()
279
279
parser.add_argument("--version", action="version",
280
version = "%(prog)s {}".format(version),
280
version = "%(prog)s {0}".format(version),
281
281
help="show version number and exit")
282
282
parser.add_argument("-a", "--all", action="store_true",
283
283
help="Select all clients")
284
284
parser.add_argument("-v", "--verbose", action="store_true",
285
285
help="Print all fields")
286
parser.add_argument("-j", "--dump-json", action="store_true",
287
help="Dump client data in JSON format")
288
286
parser.add_argument("-e", "--enable", action="store_true",
289
287
help="Enable client")
290
288
parser.add_argument("-d", "--disable", action="store_true",
333
331
if has_actions(options) and not (options.client or options.all):
334
332
parser.error("Options require clients names or --all.")
335
333
if options.verbose and has_actions(options):
336
parser.error("--verbose can only be used alone.")
337
if options.dump_json and (options.verbose or has_actions(options)):
338
parser.error("--dump-json can only be used alone.")
334
parser.error("--verbose can only be used alone or with"
335
" --all.")
339
336
if options.all and not has_actions(options):
340
337
parser.error("--all requires an action.")
341
338
342
339
if options.check:
343
340
fail_count, test_count = doctest.testmod()
344
341
sys.exit(os.EX_OK if fail_count == 0 else 1)
347
344
bus = dbus.SystemBus()
348
345
mandos_dbus_objc = bus.get_object(busname, server_path)
349
346
except dbus.exceptions.DBusException:
350
print("Could not connect to Mandos server", file=sys.stderr)
347
print("Could not connect to Mandos server",
348
file=sys.stderr)
351
349
sys.exit(1)
352
350
353
351
mandos_serv = dbus.Interface(mandos_dbus_objc,
354
352
dbus_interface = server_interface)
355
mandos_serv_object_manager = dbus.Interface(
356
mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)
357
353
358
354
#block stderr since dbus library prints to stderr
359
355
null = os.open(os.path.devnull, os.O_RDWR)
362
358
os.close(null)
363
359
try:
364
360
try:
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 }
361
mandos_clients = mandos_serv.GetAllClientsWithProperties()
370
362
finally:
371
363
#restore stderr
372
364
os.dup2(stderrcopy, sys.stderr.fileno())
373
365
os.close(stderrcopy)
374
except dbus.exceptions.DBusException as e:
375
print("Access denied: Accessing mandos server through D-Bus: {}"
376
.format(e), file=sys.stderr)
366
except dbus.exceptions.DBusException:
367
print("Access denied: Accessing mandos server through dbus.",
368
file=sys.stderr)
377
369
sys.exit(1)
378
370
379
371
# Compile dict of (clients: properties) to process
380
372
clients={}
381
373
382
374
if options.all or not options.client:
383
clients = { bus.get_object(busname, path): properties
384
for path, properties in mandos_clients.items() }
375
clients = dict((bus.get_object(busname, path), properties)
376
for path, properties in
377
mandos_clients.items())
385
378
else:
386
379
for name in options.client:
387
for path, client in mandos_clients.items():
380
for path, client in mandos_clients.iteritems():
388
381
if client["Name"] == name:
389
382
client_objc = bus.get_object(busname, path)
390
383
clients[client_objc] = client
391
384
break
392
385
else:
393
print("Client not found on server: {!r}"
386
print("Client not found on server: {0!r}"
394
387
.format(name), file=sys.stderr)
395
388
sys.exit(1)
396
389
397
390
if not has_actions(options) and clients:
398
if options.verbose or options.dump_json:
399
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
400
"Created", "Interval", "Host", "Fingerprint",
401
"CheckerRunning", "LastEnabled",
402
"ApprovalPending", "ApprovedByDefault",
391
if options.verbose:
392
keywords = ("Name", "Enabled", "Timeout",
393
"LastCheckedOK", "Created", "Interval",
394
"Host", "Fingerprint", "CheckerRunning",
395
"LastEnabled", "ApprovalPending",
396
"ApprovedByDefault",
403
397
"LastApprovalRequest", "ApprovalDelay",
404
398
"ApprovalDuration", "Checker",
405
"ExtendedTimeout", "Expires",
406
"LastCheckerStatus")
399
"ExtendedTimeout")
407
400
else:
408
401
keywords = defaultkeywords
409
402
410
if options.dump_json:
411
json.dump({client["Name"]: {key:
412
bool(client[key])
413
if isinstance(client[key],
414
dbus.Boolean)
415
else client[key]
416
for key in keywords }
417
for client in clients.values() },
418
fp = sys.stdout, indent = 4,
419
separators = (',', ': '))
420
print()
421
else:
422
print_clients(clients.values(), keywords)
403
print_clients(clients.values(), keywords)
423
404
else:
424
405
# Process each client in the list by all selected options
425
406
for client in clients:
426
427
407
def set_client_prop(prop, value):
428
408
"""Set a Client D-Bus property"""
429
409
client.Set(client_interface, prop, value,
430
410
dbus_interface=dbus.PROPERTIES_IFACE)
431
432
411
def set_client_prop_ms(prop, value):
433
412
"""Set a Client D-Bus property, converted
434
413
from a string to milliseconds."""
435
414
set_client_prop(prop,
436
string_to_delta(value).total_seconds()
437
* 1000)
438
415
timedelta_to_milliseconds
416
(string_to_delta(value)))
439
417
if options.remove:
440
418
mandos_serv.RemoveClient(client.__dbus_object_path__)
441
419
if options.enable:
485
463
client.Approve(dbus.Boolean(False),
486
464
dbus_interface=client_interface)
487
465
488
489
466
if __name__ == "__main__":
490
467
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0