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 996
- compare with another revision
- download diff
- download tarball
- view history from revision 996
- Committer: Teddy Hogeborn
- Date: 2019-03-02 01:56:35 UTC
- Revision ID: teddy@recompile.se-20190302015635-xgodxd3ivltju7qn
mandos-ctl: Refactor
* mandos-ctl (global tablewords): Refactor into TableOfClients.
(TableOfClients.tablewords): New overrideable class attribute.
* mandos-ctl (global tablewords): Refactor into TableOfClients.
(TableOfClients.tablewords): New overrideable class attribute.
- files added:
- bugs.xml
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
mandos-ctl
1
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
4
from __future__ import division
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*")))); -*-
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2008-2019 Teddy Hogeborn
7
# Copyright © 2008-2019 Björn Påhlsson
8
#
9
# This file is part of Mandos.
10
#
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
13
# the Free Software Foundation, either version 3 of the License, or
14
# (at your option) any later version.
15
#
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
# GNU General Public License for more details.
20
#
21
# You should have received a copy of the GNU General Public License
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23
#
24
# Contact the authors at <mandos@recompile.se>.
25
#
26
27
from __future__ import (division, absolute_import, print_function,
28
unicode_literals)
29
30
try:
31
from future_builtins import *
32
except ImportError:
33
pass
34
5
35
import sys
6
import dbus
7
from optparse import OptionParser
36
import argparse
8
37
import locale
9
38
import datetime
10
39
import re
11
40
import os
12
13
locale.setlocale(locale.LC_ALL, u'')
14
15
tablewords = {
16
'Name': u'Name',
17
'Enabled': u'Enabled',
18
'Timeout': u'Timeout',
19
'LastCheckedOK': u'Last Successful Check',
20
'Created': u'Created',
21
'Interval': u'Interval',
22
'Host': u'Host',
23
'Fingerprint': u'Fingerprint',
24
'CheckerRunning': u'Check Is Running',
25
'LastEnabled': u'Last Enabled',
26
'ApprovalPending': u'Approval Is Pending',
27
'ApprovedByDefault': u'Approved By Default',
28
'ApprovalDelay': u"Approval Delay",
29
'ApprovalDuration': u"Approval Duration",
30
'Checker': u'Checker',
31
}
32
defaultkeywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK')
33
domain = 'se.bsnet.fukt'
34
busname = domain + '.Mandos'
35
server_path = '/'
36
server_interface = domain + '.Mandos'
37
client_interface = domain + '.Mandos.Client'
38
version = "1.0.14"
39
40
def timedelta_to_milliseconds(td):
41
"Convert a datetime.timedelta object to milliseconds"
42
return ((td.days * 24 * 60 * 60 * 1000)
43
+ (td.seconds * 1000)
44
+ (td.microseconds // 1000))
41
import collections
42
import json
43
import unittest
44
import logging
45
46
import dbus
47
48
# Show warnings by default
49
if not sys.warnoptions:
50
import warnings
51
warnings.simplefilter("default")
52
53
log = logging.getLogger(sys.argv[0])
54
logging.basicConfig(level="INFO", # Show info level messages
55
format="%(message)s") # Show basic log messages
56
57
logging.captureWarnings(True) # Show warnings via the logging system
58
59
if sys.version_info.major == 2:
60
str = unicode
61
62
locale.setlocale(locale.LC_ALL, "")
63
64
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
65
domain = "se.recompile"
66
busname = domain + ".Mandos"
67
server_path = "/"
68
server_interface = domain + ".Mandos"
69
client_interface = domain + ".Mandos.Client"
70
version = "1.8.3"
71
72
73
try:
74
dbus.OBJECT_MANAGER_IFACE
75
except AttributeError:
76
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
77
45
78
46
79
def milliseconds_to_string(ms):
47
80
td = datetime.timedelta(0, 0, 0, ms)
48
return (u"%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
49
% { "days": "%dT" % td.days if td.days else "",
50
"hours": td.seconds // 3600,
51
"minutes": (td.seconds % 3600) // 60,
52
"seconds": td.seconds % 60,
53
})
81
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
82
.format(days="{}T".format(td.days) if td.days else "",
83
hours=td.seconds // 3600,
84
minutes=(td.seconds % 3600) // 60,
85
seconds=td.seconds % 60))
86
87
88
def rfc3339_duration_to_delta(duration):
89
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
90
91
>>> rfc3339_duration_to_delta("P7D")
92
datetime.timedelta(7)
93
>>> rfc3339_duration_to_delta("PT60S")
94
datetime.timedelta(0, 60)
95
>>> rfc3339_duration_to_delta("PT60M")
96
datetime.timedelta(0, 3600)
97
>>> rfc3339_duration_to_delta("P60M")
98
datetime.timedelta(1680)
99
>>> rfc3339_duration_to_delta("PT24H")
100
datetime.timedelta(1)
101
>>> rfc3339_duration_to_delta("P1W")
102
datetime.timedelta(7)
103
>>> rfc3339_duration_to_delta("PT5M30S")
104
datetime.timedelta(0, 330)
105
>>> rfc3339_duration_to_delta("P1DT3M20S")
106
datetime.timedelta(1, 200)
107
>>> # Can not be empty:
108
>>> rfc3339_duration_to_delta("")
109
Traceback (most recent call last):
110
...
111
ValueError: Invalid RFC 3339 duration: u''
112
>>> # Must start with "P":
113
>>> rfc3339_duration_to_delta("1D")
114
Traceback (most recent call last):
115
...
116
ValueError: Invalid RFC 3339 duration: u'1D'
117
>>> # Must use correct order
118
>>> rfc3339_duration_to_delta("PT1S2M")
119
Traceback (most recent call last):
120
...
121
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
122
>>> # Time needs time marker
123
>>> rfc3339_duration_to_delta("P1H2S")
124
Traceback (most recent call last):
125
...
126
ValueError: Invalid RFC 3339 duration: u'P1H2S'
127
>>> # Weeks can not be combined with anything else
128
>>> rfc3339_duration_to_delta("P1D2W")
129
Traceback (most recent call last):
130
...
131
ValueError: Invalid RFC 3339 duration: u'P1D2W'
132
>>> rfc3339_duration_to_delta("P2W2H")
133
Traceback (most recent call last):
134
...
135
ValueError: Invalid RFC 3339 duration: u'P2W2H'
136
"""
137
138
# Parsing an RFC 3339 duration with regular expressions is not
139
# possible - there would have to be multiple places for the same
140
# values, like seconds. The current code, while more esoteric, is
141
# cleaner without depending on a parsing library. If Python had a
142
# built-in library for parsing we would use it, but we'd like to
143
# avoid excessive use of external libraries.
144
145
# New type for defining tokens, syntax, and semantics all-in-one
146
Token = collections.namedtuple("Token", (
147
"regexp", # To match token; if "value" is not None, must have
148
# a "group" containing digits
149
"value", # datetime.timedelta or None
150
"followers")) # Tokens valid after this token
151
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
152
# the "duration" ABNF definition in RFC 3339, Appendix A.
153
token_end = Token(re.compile(r"$"), None, frozenset())
154
token_second = Token(re.compile(r"(\d+)S"),
155
datetime.timedelta(seconds=1),
156
frozenset((token_end, )))
157
token_minute = Token(re.compile(r"(\d+)M"),
158
datetime.timedelta(minutes=1),
159
frozenset((token_second, token_end)))
160
token_hour = Token(re.compile(r"(\d+)H"),
161
datetime.timedelta(hours=1),
162
frozenset((token_minute, token_end)))
163
token_time = Token(re.compile(r"T"),
164
None,
165
frozenset((token_hour, token_minute,
166
token_second)))
167
token_day = Token(re.compile(r"(\d+)D"),
168
datetime.timedelta(days=1),
169
frozenset((token_time, token_end)))
170
token_month = Token(re.compile(r"(\d+)M"),
171
datetime.timedelta(weeks=4),
172
frozenset((token_day, token_end)))
173
token_year = Token(re.compile(r"(\d+)Y"),
174
datetime.timedelta(weeks=52),
175
frozenset((token_month, token_end)))
176
token_week = Token(re.compile(r"(\d+)W"),
177
datetime.timedelta(weeks=1),
178
frozenset((token_end, )))
179
token_duration = Token(re.compile(r"P"), None,
180
frozenset((token_year, token_month,
181
token_day, token_time,
182
token_week)))
183
# Define starting values:
184
# Value so far
185
value = datetime.timedelta()
186
found_token = None
187
# Following valid tokens
188
followers = frozenset((token_duration, ))
189
# String left to parse
190
s = duration
191
# Loop until end token is found
192
while found_token is not token_end:
193
# Search for any currently valid tokens
194
for token in followers:
195
match = token.regexp.match(s)
196
if match is not None:
197
# Token found
198
if token.value is not None:
199
# Value found, parse digits
200
factor = int(match.group(1), 10)
201
# Add to value so far
202
value += factor * token.value
203
# Strip token from string
204
s = token.regexp.sub("", s, 1)
205
# Go to found token
206
found_token = token
207
# Set valid next tokens
208
followers = found_token.followers
209
break
210
else:
211
# No currently valid tokens were found
212
raise ValueError("Invalid RFC 3339 duration: {!r}"
213
.format(duration))
214
# End token found
215
return value
54
216
55
217
56
218
def string_to_delta(interval):
57
219
"""Parse a string and return a datetime.timedelta
58
59
>>> string_to_delta('7d')
220
"""
221
222
try:
223
return rfc3339_duration_to_delta(interval)
224
except ValueError as e:
225
log.warning("%s - Parsing as pre-1.6.1 interval instead",
226
' '.join(e.args))
227
return parse_pre_1_6_1_interval(interval)
228
229
230
def parse_pre_1_6_1_interval(interval):
231
"""Parse an interval string as documented by Mandos before 1.6.1, and
232
return a datetime.timedelta
233
>>> parse_pre_1_6_1_interval('7d')
60
234
datetime.timedelta(7)
61
>>> string_to_delta('60s')
235
>>> parse_pre_1_6_1_interval('60s')
62
236
datetime.timedelta(0, 60)
63
>>> string_to_delta('60m')
237
>>> parse_pre_1_6_1_interval('60m')
64
238
datetime.timedelta(0, 3600)
65
>>> string_to_delta('24h')
239
>>> parse_pre_1_6_1_interval('24h')
66
240
datetime.timedelta(1)
67
>>> string_to_delta(u'1w')
241
>>> parse_pre_1_6_1_interval('1w')
68
242
datetime.timedelta(7)
69
>>> string_to_delta('5m 30s')
243
>>> parse_pre_1_6_1_interval('5m 30s')
70
244
datetime.timedelta(0, 330)
245
>>> parse_pre_1_6_1_interval('')
246
datetime.timedelta(0)
247
>>> # Ignore unknown characters, allow any order and repetitions
248
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
249
datetime.timedelta(2, 480, 18000)
250
71
251
"""
72
timevalue = datetime.timedelta(0)
73
regexp = re.compile("\d+[dsmhw]")
74
75
for s in regexp.findall(interval):
76
try:
77
suffix = unicode(s[-1])
78
value = int(s[:-1])
79
if suffix == u"d":
80
delta = datetime.timedelta(value)
81
elif suffix == u"s":
82
delta = datetime.timedelta(0, value)
83
elif suffix == u"m":
84
delta = datetime.timedelta(0, 0, 0, 0, value)
85
elif suffix == u"h":
86
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
87
elif suffix == u"w":
88
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
89
else:
90
raise ValueError
91
except (ValueError, IndexError):
92
raise ValueError
93
timevalue += delta
94
return timevalue
252
253
value = datetime.timedelta(0)
254
regexp = re.compile(r"(\d+)([dsmhw]?)")
255
256
for num, suffix in regexp.findall(interval):
257
if suffix == "d":
258
value += datetime.timedelta(int(num))
259
elif suffix == "s":
260
value += datetime.timedelta(0, int(num))
261
elif suffix == "m":
262
value += datetime.timedelta(0, 0, 0, 0, int(num))
263
elif suffix == "h":
264
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
265
elif suffix == "w":
266
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
267
elif suffix == "":
268
value += datetime.timedelta(0, 0, 0, int(num))
269
return value
270
95
271
96
272
def print_clients(clients, keywords):
273
print('\n'.join(TableOfClients(clients, keywords).rows()))
274
275
class TableOfClients(object):
276
tablewords = {
277
"Name": "Name",
278
"Enabled": "Enabled",
279
"Timeout": "Timeout",
280
"LastCheckedOK": "Last Successful Check",
281
"LastApprovalRequest": "Last Approval Request",
282
"Created": "Created",
283
"Interval": "Interval",
284
"Host": "Host",
285
"Fingerprint": "Fingerprint",
286
"KeyID": "Key ID",
287
"CheckerRunning": "Check Is Running",
288
"LastEnabled": "Last Enabled",
289
"ApprovalPending": "Approval Is Pending",
290
"ApprovedByDefault": "Approved By Default",
291
"ApprovalDelay": "Approval Delay",
292
"ApprovalDuration": "Approval Duration",
293
"Checker": "Checker",
294
"ExtendedTimeout": "Extended Timeout",
295
"Expires": "Expires",
296
"LastCheckerStatus": "Last Checker Status",
297
}
298
299
def __init__(self, clients, keywords, tablewords=None):
300
self.clients = clients
301
self.keywords = keywords
302
if tablewords is not None:
303
self.tablewords = tablewords
304
305
@staticmethod
97
306
def valuetostring(value, keyword):
98
if type(value) is dbus.Boolean:
99
return u"Yes" if value else u"No"
100
if keyword in (u"Timeout", u"Interval", u"ApprovalDelay",
101
u"ApprovalDuration"):
307
if isinstance(value, dbus.Boolean):
308
return "Yes" if value else "No"
309
if keyword in ("Timeout", "Interval", "ApprovalDelay",
310
"ApprovalDuration", "ExtendedTimeout"):
102
311
return milliseconds_to_string(value)
103
return unicode(value)
104
105
# Create format string to print table rows
106
format_string = u' '.join(u'%%-%ds' %
107
max(len(tablewords[key]),
108
max(len(valuetostring(client[key],
109
key))
110
for client in
111
clients))
112
for key in keywords)
113
# Print header line
114
print format_string % tuple(tablewords[key] for key in keywords)
115
for client in clients:
116
print format_string % tuple(valuetostring(client[key], key)
117
for key in keywords)
312
return str(value)
313
314
def rows(self):
315
# Create format string to format table rows
316
format_string = " ".join("{{{key}:{width}}}".format(
317
width=max(len(self.tablewords[key]),
318
max(len(self.valuetostring(client[key], key))
319
for client in self.clients)),
320
key=key)
321
for key in self.keywords)
322
# Start with header line
323
rows = [format_string.format(**self.tablewords)]
324
for client in self.clients:
325
rows.append(format_string
326
.format(**{key: self.valuetostring(client[key], key)
327
for key in self.keywords}))
328
return rows
329
118
330
119
331
def has_actions(options):
120
332
return any((options.enable,
126
338
options.remove,
127
339
options.checker is not None,
128
340
options.timeout is not None,
341
options.extended_timeout is not None,
129
342
options.interval is not None,
130
343
options.approved_by_default is not None,
131
344
options.approval_delay is not None,
134
347
options.secret is not None,
135
348
options.approve,
136
349
options.deny))
137
350
351
138
352
def main():
139
parser = OptionParser(version = "%%prog %s" % version)
140
parser.add_option("-a", "--all", action="store_true",
141
help="Select all clients")
142
parser.add_option("-v", "--verbose", action="store_true",
143
help="Print all fields")
144
parser.add_option("-e", "--enable", action="store_true",
145
help="Enable client")
146
parser.add_option("-d", "--disable", action="store_true",
147
help="disable client")
148
parser.add_option("-b", "--bump-timeout", action="store_true",
149
help="Bump timeout for client")
150
parser.add_option("--start-checker", action="store_true",
151
help="Start checker for client")
152
parser.add_option("--stop-checker", action="store_true",
153
help="Stop checker for client")
154
parser.add_option("-V", "--is-enabled", action="store_true",
155
help="Check if client is enabled")
156
parser.add_option("-r", "--remove", action="store_true",
157
help="Remove client")
158
parser.add_option("-c", "--checker", type="string",
159
help="Set checker command for client")
160
parser.add_option("-t", "--timeout", type="string",
161
help="Set timeout for client")
162
parser.add_option("-i", "--interval", type="string",
163
help="Set checker interval for client")
164
parser.add_option("--approve-by-default", action="store_true",
165
dest=u"approved_by_default",
166
help="Set client to be approved by default")
167
parser.add_option("--deny-by-default", action="store_false",
168
dest=u"approved_by_default",
169
help="Set client to be denied by default")
170
parser.add_option("--approval-delay", type="string",
171
help="Set delay before client approve/deny")
172
parser.add_option("--approval-duration", type="string",
173
help="Set duration of one client approval")
174
parser.add_option("-H", "--host", type="string",
175
help="Set host for client")
176
parser.add_option("-s", "--secret", type="string",
177
help="Set password blob (file) for client")
178
parser.add_option("-A", "--approve", action="store_true",
179
help="Approve any current client request")
180
parser.add_option("-D", "--deny", action="store_true",
181
help="Deny any current client request")
182
options, client_names = parser.parse_args()
183
184
if has_actions(options) and not client_names and not options.all:
185
parser.error('Options require clients names or --all.')
186
if options.verbose and has_actions(options):
187
parser.error('--verbose can only be used alone or with'
188
' --all.')
189
if options.all and not has_actions(options):
190
parser.error('--all requires an action.')
191
192
try:
193
bus = dbus.SystemBus()
194
mandos_dbus_objc = bus.get_object(busname, server_path)
195
except dbus.exceptions.DBusException:
196
print >> sys.stderr, "Could not connect to Mandos server"
197
sys.exit(1)
198
199
mandos_serv = dbus.Interface(mandos_dbus_objc,
200
dbus_interface = server_interface)
201
202
#block stderr since dbus library prints to stderr
203
null = os.open(os.path.devnull, os.O_RDWR)
204
stderrcopy = os.dup(sys.stderr.fileno())
205
os.dup2(null, sys.stderr.fileno())
206
os.close(null)
207
try:
208
try:
209
mandos_clients = mandos_serv.GetAllClientsWithProperties()
210
finally:
211
#restore stderr
212
os.dup2(stderrcopy, sys.stderr.fileno())
213
os.close(stderrcopy)
214
except dbus.exceptions.DBusException, e:
215
print >> sys.stderr, "Access denied: Accessing mandos server through dbus."
216
sys.exit(1)
217
218
# Compile dict of (clients: properties) to process
219
clients={}
220
221
if options.all or not client_names:
222
clients = dict((bus.get_object(busname, path), properties)
223
for path, properties in
224
mandos_clients.iteritems())
225
else:
226
for name in client_names:
227
for path, client in mandos_clients.iteritems():
228
if client['Name'] == name:
229
client_objc = bus.get_object(busname, path)
230
clients[client_objc] = client
231
break
353
parser = argparse.ArgumentParser()
354
parser.add_argument("--version", action="version",
355
version="%(prog)s {}".format(version),
356
help="show version number and exit")
357
parser.add_argument("-a", "--all", action="store_true",
358
help="Select all clients")
359
parser.add_argument("-v", "--verbose", action="store_true",
360
help="Print all fields")
361
parser.add_argument("-j", "--dump-json", action="store_true",
362
help="Dump client data in JSON format")
363
parser.add_argument("-e", "--enable", action="store_true",
364
help="Enable client")
365
parser.add_argument("-d", "--disable", action="store_true",
366
help="disable client")
367
parser.add_argument("-b", "--bump-timeout", action="store_true",
368
help="Bump timeout for client")
369
parser.add_argument("--start-checker", action="store_true",
370
help="Start checker for client")
371
parser.add_argument("--stop-checker", action="store_true",
372
help="Stop checker for client")
373
parser.add_argument("-V", "--is-enabled", action="store_true",
374
help="Check if client is enabled")
375
parser.add_argument("-r", "--remove", action="store_true",
376
help="Remove client")
377
parser.add_argument("-c", "--checker",
378
help="Set checker command for client")
379
parser.add_argument("-t", "--timeout",
380
help="Set timeout for client")
381
parser.add_argument("--extended-timeout",
382
help="Set extended timeout for client")
383
parser.add_argument("-i", "--interval",
384
help="Set checker interval for client")
385
parser.add_argument("--approve-by-default", action="store_true",
386
default=None, dest="approved_by_default",
387
help="Set client to be approved by default")
388
parser.add_argument("--deny-by-default", action="store_false",
389
dest="approved_by_default",
390
help="Set client to be denied by default")
391
parser.add_argument("--approval-delay",
392
help="Set delay before client approve/deny")
393
parser.add_argument("--approval-duration",
394
help="Set duration of one client approval")
395
parser.add_argument("-H", "--host", help="Set host for client")
396
parser.add_argument("-s", "--secret",
397
type=argparse.FileType(mode="rb"),
398
help="Set password blob (file) for client")
399
parser.add_argument("-A", "--approve", action="store_true",
400
help="Approve any current client request")
401
parser.add_argument("-D", "--deny", action="store_true",
402
help="Deny any current client request")
403
parser.add_argument("--check", action="store_true",
404
help="Run self-test")
405
parser.add_argument("client", nargs="*", help="Client name")
406
options = parser.parse_args()
407
408
if has_actions(options) and not (options.client or options.all):
409
parser.error("Options require clients names or --all.")
410
if options.verbose and has_actions(options):
411
parser.error("--verbose can only be used alone.")
412
if options.dump_json and (options.verbose
413
or has_actions(options)):
414
parser.error("--dump-json can only be used alone.")
415
if options.all and not has_actions(options):
416
parser.error("--all requires an action.")
417
418
try:
419
bus = dbus.SystemBus()
420
mandos_dbus_objc = bus.get_object(busname, server_path)
421
except dbus.exceptions.DBusException:
422
log.critical("Could not connect to Mandos server")
423
sys.exit(1)
424
425
mandos_serv = dbus.Interface(mandos_dbus_objc,
426
dbus_interface=server_interface)
427
mandos_serv_object_manager = dbus.Interface(
428
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
429
430
# block stderr since dbus library prints to stderr
431
null = os.open(os.path.devnull, os.O_RDWR)
432
stderrcopy = os.dup(sys.stderr.fileno())
433
os.dup2(null, sys.stderr.fileno())
434
os.close(null)
435
try:
436
try:
437
mandos_clients = {path: ifs_and_props[client_interface]
438
for path, ifs_and_props in
439
mandos_serv_object_manager
440
.GetManagedObjects().items()
441
if client_interface in ifs_and_props}
442
finally:
443
# restore stderr
444
os.dup2(stderrcopy, sys.stderr.fileno())
445
os.close(stderrcopy)
446
except dbus.exceptions.DBusException as e:
447
log.critical("Failed to access Mandos server through D-Bus:"
448
"\n%s", e)
449
sys.exit(1)
450
451
# Compile dict of (clients: properties) to process
452
clients = {}
453
454
if options.all or not options.client:
455
clients = {bus.get_object(busname, path): properties
456
for path, properties in mandos_clients.items()}
457
else:
458
for name in options.client:
459
for path, client in mandos_clients.items():
460
if client["Name"] == name:
461
client_objc = bus.get_object(busname, path)
462
clients[client_objc] = client
463
break
464
else:
465
log.critical("Client not found on server: %r", name)
466
sys.exit(1)
467
468
if not has_actions(options) and clients:
469
if options.verbose or options.dump_json:
470
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
471
"Created", "Interval", "Host", "KeyID",
472
"Fingerprint", "CheckerRunning",
473
"LastEnabled", "ApprovalPending",
474
"ApprovedByDefault", "LastApprovalRequest",
475
"ApprovalDelay", "ApprovalDuration",
476
"Checker", "ExtendedTimeout", "Expires",
477
"LastCheckerStatus")
478
else:
479
keywords = defaultkeywords
480
481
if options.dump_json:
482
json.dump({client["Name"]: {key:
483
bool(client[key])
484
if isinstance(client[key],
485
dbus.Boolean)
486
else client[key]
487
for key in keywords}
488
for client in clients.values()},
489
fp=sys.stdout, indent=4,
490
separators=(',', ': '))
491
print()
492
else:
493
print_clients(clients.values(), keywords)
494
else:
495
# Process each client in the list by all selected options
496
for client in clients:
497
498
def set_client_prop(prop, value):
499
"""Set a Client D-Bus property"""
500
client.Set(client_interface, prop, value,
501
dbus_interface=dbus.PROPERTIES_IFACE)
502
503
def set_client_prop_ms(prop, value):
504
"""Set a Client D-Bus property, converted
505
from a string to milliseconds."""
506
set_client_prop(prop,
507
string_to_delta(value).total_seconds()
508
* 1000)
509
510
if options.remove:
511
mandos_serv.RemoveClient(client.__dbus_object_path__)
512
if options.enable:
513
set_client_prop("Enabled", dbus.Boolean(True))
514
if options.disable:
515
set_client_prop("Enabled", dbus.Boolean(False))
516
if options.bump_timeout:
517
set_client_prop("LastCheckedOK", "")
518
if options.start_checker:
519
set_client_prop("CheckerRunning", dbus.Boolean(True))
520
if options.stop_checker:
521
set_client_prop("CheckerRunning", dbus.Boolean(False))
522
if options.is_enabled:
523
if client.Get(client_interface, "Enabled",
524
dbus_interface=dbus.PROPERTIES_IFACE):
525
sys.exit(0)
232
526
else:
233
print >> sys.stderr, "Client not found on server: %r" % name
234
527
sys.exit(1)
235
236
if not has_actions(options) and clients:
237
if options.verbose:
238
keywords = ('Name', 'Enabled', 'Timeout',
239
'LastCheckedOK', 'Created', 'Interval',
240
'Host', 'Fingerprint', 'CheckerRunning',
241
'LastEnabled', 'ApprovalPending',
242
'ApprovedByDefault', 'ApprovalDelay',
243
'ApprovalDuration', 'Checker')
244
else:
245
keywords = defaultkeywords
246
247
print_clients(clients.values(), keywords)
528
if options.checker is not None:
529
set_client_prop("Checker", options.checker)
530
if options.host is not None:
531
set_client_prop("Host", options.host)
532
if options.interval is not None:
533
set_client_prop_ms("Interval", options.interval)
534
if options.approval_delay is not None:
535
set_client_prop_ms("ApprovalDelay",
536
options.approval_delay)
537
if options.approval_duration is not None:
538
set_client_prop_ms("ApprovalDuration",
539
options.approval_duration)
540
if options.timeout is not None:
541
set_client_prop_ms("Timeout", options.timeout)
542
if options.extended_timeout is not None:
543
set_client_prop_ms("ExtendedTimeout",
544
options.extended_timeout)
545
if options.secret is not None:
546
set_client_prop("Secret",
547
dbus.ByteArray(options.secret.read()))
548
if options.approved_by_default is not None:
549
set_client_prop("ApprovedByDefault",
550
dbus.Boolean(options
551
.approved_by_default))
552
if options.approve:
553
client.Approve(dbus.Boolean(True),
554
dbus_interface=client_interface)
555
elif options.deny:
556
client.Approve(dbus.Boolean(False),
557
dbus_interface=client_interface)
558
559
560
class Test_milliseconds_to_string(unittest.TestCase):
561
def test_all(self):
562
self.assertEqual(milliseconds_to_string(93785000),
563
"1T02:03:05")
564
def test_no_days(self):
565
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
566
def test_all_zero(self):
567
self.assertEqual(milliseconds_to_string(0), "00:00:00")
568
def test_no_fractional_seconds(self):
569
self.assertEqual(milliseconds_to_string(400), "00:00:00")
570
self.assertEqual(milliseconds_to_string(900), "00:00:00")
571
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
572
573
class Test_string_to_delta(unittest.TestCase):
574
def test_handles_basic_rfc3339(self):
575
self.assertEqual(string_to_delta("PT2H"),
576
datetime.timedelta(0, 7200))
577
def test_falls_back_to_pre_1_6_1_with_warning(self):
578
# assertLogs only exists in Python 3.4
579
if hasattr(self, "assertLogs"):
580
with self.assertLogs(log, logging.WARNING):
581
value = string_to_delta("2h")
248
582
else:
249
# Process each client in the list by all selected options
250
for client in clients:
251
if options.remove:
252
mandos_serv.RemoveClient(client.__dbus_object_path__)
253
if options.enable:
254
client.Enable(dbus_interface=client_interface)
255
if options.disable:
256
client.Disable(dbus_interface=client_interface)
257
if options.bump_timeout:
258
client.CheckedOK(dbus_interface=client_interface)
259
if options.start_checker:
260
client.StartChecker(dbus_interface=client_interface)
261
if options.stop_checker:
262
client.StopChecker(dbus_interface=client_interface)
263
if options.is_enabled:
264
sys.exit(0 if client.Get(client_interface,
265
u"Enabled",
266
dbus_interface=dbus.PROPERTIES_IFACE)
267
else 1)
268
if options.checker:
269
client.Set(client_interface, u"Checker", options.checker,
270
dbus_interface=dbus.PROPERTIES_IFACE)
271
if options.host:
272
client.Set(client_interface, u"Host", options.host,
273
dbus_interface=dbus.PROPERTIES_IFACE)
274
if options.interval:
275
client.Set(client_interface, u"Interval",
276
timedelta_to_milliseconds
277
(string_to_delta(options.interval)),
278
dbus_interface=dbus.PROPERTIES_IFACE)
279
if options.approval_delay:
280
client.Set(client_interface, u"ApprovalDelay",
281
timedelta_to_milliseconds
282
(string_to_delta(options.
283
approval_delay)),
284
dbus_interface=dbus.PROPERTIES_IFACE)
285
if options.approval_duration:
286
client.Set(client_interface, u"ApprovalDuration",
287
timedelta_to_milliseconds
288
(string_to_delta(options.
289
approval_duration)),
290
dbus_interface=dbus.PROPERTIES_IFACE)
291
if options.timeout:
292
client.Set(client_interface, u"Timeout",
293
timedelta_to_milliseconds
294
(string_to_delta(options.timeout)),
295
dbus_interface=dbus.PROPERTIES_IFACE)
296
if options.secret:
297
client.Set(client_interface, u"Secret",
298
dbus.ByteArray(open(options.secret,
299
u'rb').read()),
300
dbus_interface=dbus.PROPERTIES_IFACE)
301
if options.approved_by_default is not None:
302
client.Set(client_interface, u"ApprovedByDefault",
303
dbus.Boolean(options
304
.approved_by_default),
305
dbus_interface=dbus.PROPERTIES_IFACE)
306
if options.approve:
307
client.Approve(dbus.Boolean(True),
308
dbus_interface=client_interface)
309
elif options.deny:
310
client.Approve(dbus.Boolean(False),
311
dbus_interface=client_interface)
312
313
if __name__ == '__main__':
314
main()
583
value = string_to_delta("2h")
584
self.assertEqual(value, datetime.timedelta(0, 7200))
585
586
class Test_TableOfClients(unittest.TestCase):
587
def setUp(self):
588
self.tablewords = {
589
"Attr1": "X",
590
"AttrTwo": "Yy",
591
"AttrThree": "Zzz",
592
"Bool": "A D-BUS Boolean",
593
"NonDbusBoolean": "A Non-D-BUS Boolean",
594
"Integer": "An Integer",
595
"Timeout": "Timedelta 1",
596
"Interval": "Timedelta 2",
597
"ApprovalDelay": "Timedelta 3",
598
"ApprovalDuration": "Timedelta 4",
599
"ExtendedTimeout": "Timedelta 5",
600
"String": "A String",
601
}
602
self.keywords = ["Attr1", "AttrTwo"]
603
self.clients = [
604
{
605
"Attr1": "x1",
606
"AttrTwo": "y1",
607
"AttrThree": "z1",
608
"Bool": dbus.Boolean(False),
609
"NonDbusBoolean": False,
610
"Integer": 0,
611
"Timeout": 0,
612
"Interval": 1000,
613
"ApprovalDelay": 2000,
614
"ApprovalDuration": 3000,
615
"ExtendedTimeout": 4000,
616
"String": "",
617
},
618
{
619
"Attr1": "x2",
620
"AttrTwo": "y2",
621
"AttrThree": "z2",
622
"Bool": dbus.Boolean(True),
623
"NonDbusBoolean": True,
624
"Integer": 1,
625
"Timeout": 93785000,
626
"Interval": 93786000,
627
"ApprovalDelay": 93787000,
628
"ApprovalDuration": 93788000,
629
"ExtendedTimeout": 93789000,
630
"String": "A huge string which will not fit," * 10,
631
},
632
]
633
def test_short_header(self):
634
rows = TableOfClients(self.clients, self.keywords,
635
self.tablewords).rows()
636
expected_rows = [
637
"X Yy",
638
"x1 y1",
639
"x2 y2"]
640
self.assertEqual(rows, expected_rows)
641
def test_booleans(self):
642
keywords = ["Bool", "NonDbusBoolean"]
643
rows = TableOfClients(self.clients, keywords,
644
self.tablewords).rows()
645
expected_rows = [
646
"A D-BUS Boolean A Non-D-BUS Boolean",
647
"No False ",
648
"Yes True ",
649
]
650
self.assertEqual(rows, expected_rows)
651
def test_milliseconds_detection(self):
652
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
653
"ApprovalDuration", "ExtendedTimeout"]
654
rows = TableOfClients(self.clients, keywords,
655
self.tablewords).rows()
656
expected_rows = ("""
657
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
658
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
659
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
660
"""
661
).splitlines()[1:]
662
self.assertEqual(rows, expected_rows)
663
def test_empty_and_long_string_values(self):
664
keywords = ["String"]
665
rows = TableOfClients(self.clients, keywords,
666
self.tablewords).rows()
667
expected_rows = ("""
668
A String
669
670
A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,
671
"""
672
).splitlines()[1:]
673
self.assertEqual(rows, expected_rows)
674
675
676
677
def should_only_run_tests():
678
parser = argparse.ArgumentParser(add_help=False)
679
parser.add_argument("--check", action='store_true')
680
args, unknown_args = parser.parse_known_args()
681
run_tests = args.check
682
if run_tests:
683
# Remove --check argument from sys.argv
684
sys.argv[1:] = unknown_args
685
return run_tests
686
687
# Add all tests from doctest strings
688
def load_tests(loader, tests, none):
689
import doctest
690
tests.addTests(doctest.DocTestSuite())
691
return tests
692
693
if __name__ == "__main__":
694
if should_only_run_tests():
695
# Call using ./tdd-python-script --check [--verbose]
696
unittest.main()
697
else:
698
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0