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 863
- compare with another revision
- download diff
- download tarball
- view history from revision 863
- Committer: Teddy Hogeborn
- Date: 2016-06-27 20:21:50 UTC
- Revision ID: teddy@recompile.se-20160627202150-ml201ilxwjf1g29w
mandos-ctl: Implement --dump-json option
* mandos-ctl (main): Implement --dump-json option
* mandos-ctl.xml (NAME, DESCRIPTION): Change description to the more
accurate "control or query".
(SYNOPSIS): Add required group around action options and add new
"--dump-json" option.
(OPTIONS): Document new "--dump-json" option.
* mandos-ctl (main): Implement --dump-json option
* mandos-ctl.xml (NAME, DESCRIPTION): Change description to the more
accurate "control or query".
(SYNOPSIS): Add required group around action options and add new
"--dump-json" option.
(OPTIONS): Document new "--dump-json" option.
- files added:
- bugs.xml
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-ctl
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2008-2010 Teddy Hogeborn
7
# Copyright © 2008-2010 Björn Påhlsson
6
# Copyright © 2008-2016 Teddy Hogeborn
7
# Copyright © 2008-2016 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
17
17
# GNU General Public License for more details.
18
18
#
19
19
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
21
#
22
# Contact the authors at <mandos@fukt.bsnet.se>.
23
#
24
25
from __future__ import division
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
22
#
23
# Contact the authors at <mandos@recompile.se>.
24
#
25
26
from __future__ import (division, absolute_import, print_function,
27
unicode_literals)
28
29
try:
30
from future_builtins import *
31
except ImportError:
32
pass
33
26
34
import sys
27
import dbus
28
from optparse import OptionParser
35
import argparse
29
36
import locale
30
37
import datetime
31
38
import re
32
39
import os
33
34
locale.setlocale(locale.LC_ALL, u'')
40
import collections
41
import doctest
42
import json
43
44
import dbus
45
46
if sys.version_info.major == 2:
47
str = unicode
48
49
locale.setlocale(locale.LC_ALL, "")
35
50
36
51
tablewords = {
37
'Name': u'Name',
38
'Enabled': u'Enabled',
39
'Timeout': u'Timeout',
40
'LastCheckedOK': u'Last Successful Check',
41
'LastApprovalRequest': u'Last Approval Request',
42
'Created': u'Created',
43
'Interval': u'Interval',
44
'Host': u'Host',
45
'Fingerprint': u'Fingerprint',
46
'CheckerRunning': u'Check Is Running',
47
'LastEnabled': u'Last Enabled',
48
'ApprovalPending': u'Approval Is Pending',
49
'ApprovedByDefault': u'Approved By Default',
50
'ApprovalDelay': u"Approval Delay",
51
'ApprovalDuration': u"Approval Duration",
52
'Checker': u'Checker',
53
}
54
defaultkeywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK')
55
domain = 'se.bsnet.fukt'
56
busname = domain + '.Mandos'
57
server_path = '/'
58
server_interface = domain + '.Mandos'
59
client_interface = domain + '.Mandos.Client'
60
version = "1.2"
61
62
def timedelta_to_milliseconds(td):
63
"Convert a datetime.timedelta object to milliseconds"
64
return ((td.days * 24 * 60 * 60 * 1000)
65
+ (td.seconds * 1000)
66
+ (td.microseconds // 1000))
52
"Name": "Name",
53
"Enabled": "Enabled",
54
"Timeout": "Timeout",
55
"LastCheckedOK": "Last Successful Check",
56
"LastApprovalRequest": "Last Approval Request",
57
"Created": "Created",
58
"Interval": "Interval",
59
"Host": "Host",
60
"Fingerprint": "Fingerprint",
61
"CheckerRunning": "Check Is Running",
62
"LastEnabled": "Last Enabled",
63
"ApprovalPending": "Approval Is Pending",
64
"ApprovedByDefault": "Approved By Default",
65
"ApprovalDelay": "Approval Delay",
66
"ApprovalDuration": "Approval Duration",
67
"Checker": "Checker",
68
"ExtendedTimeout": "Extended Timeout"
69
}
70
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
71
domain = "se.recompile"
72
busname = domain + ".Mandos"
73
server_path = "/"
74
server_interface = domain + ".Mandos"
75
client_interface = domain + ".Mandos.Client"
76
version = "1.7.10"
77
78
79
try:
80
dbus.OBJECT_MANAGER_IFACE
81
except AttributeError:
82
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
67
83
68
84
def milliseconds_to_string(ms):
69
85
td = datetime.timedelta(0, 0, 0, ms)
70
return (u"%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
71
% { "days": "%dT" % td.days if td.days else "",
72
"hours": td.seconds // 3600,
73
"minutes": (td.seconds % 3600) // 60,
74
"seconds": td.seconds % 60,
75
})
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))
91
92
93
def rfc3339_duration_to_delta(duration):
94
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
95
96
>>> rfc3339_duration_to_delta("P7D")
97
datetime.timedelta(7)
98
>>> rfc3339_duration_to_delta("PT60S")
99
datetime.timedelta(0, 60)
100
>>> rfc3339_duration_to_delta("PT60M")
101
datetime.timedelta(0, 3600)
102
>>> rfc3339_duration_to_delta("PT24H")
103
datetime.timedelta(1)
104
>>> rfc3339_duration_to_delta("P1W")
105
datetime.timedelta(7)
106
>>> rfc3339_duration_to_delta("PT5M30S")
107
datetime.timedelta(0, 330)
108
>>> rfc3339_duration_to_delta("P1DT3M20S")
109
datetime.timedelta(1, 200)
110
"""
111
112
# Parsing an RFC 3339 duration with regular expressions is not
113
# possible - there would have to be multiple places for the same
114
# values, like seconds. The current code, while more esoteric, is
115
# cleaner without depending on a parsing library. If Python had a
116
# built-in library for parsing we would use it, but we'd like to
117
# avoid excessive use of external libraries.
118
119
# New type for defining tokens, syntax, and semantics all-in-one
120
Token = collections.namedtuple("Token", (
121
"regexp", # To match token; if "value" is not None, must have
122
# a "group" containing digits
123
"value", # datetime.timedelta or None
124
"followers")) # Tokens valid after this token
125
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
126
# the "duration" ABNF definition in RFC 3339, Appendix A.
127
token_end = Token(re.compile(r"$"), None, frozenset())
128
token_second = Token(re.compile(r"(\d+)S"),
129
datetime.timedelta(seconds=1),
130
frozenset((token_end, )))
131
token_minute = Token(re.compile(r"(\d+)M"),
132
datetime.timedelta(minutes=1),
133
frozenset((token_second, token_end)))
134
token_hour = Token(re.compile(r"(\d+)H"),
135
datetime.timedelta(hours=1),
136
frozenset((token_minute, token_end)))
137
token_time = Token(re.compile(r"T"),
138
None,
139
frozenset((token_hour, token_minute,
140
token_second)))
141
token_day = Token(re.compile(r"(\d+)D"),
142
datetime.timedelta(days=1),
143
frozenset((token_time, token_end)))
144
token_month = Token(re.compile(r"(\d+)M"),
145
datetime.timedelta(weeks=4),
146
frozenset((token_day, token_end)))
147
token_year = Token(re.compile(r"(\d+)Y"),
148
datetime.timedelta(weeks=52),
149
frozenset((token_month, token_end)))
150
token_week = Token(re.compile(r"(\d+)W"),
151
datetime.timedelta(weeks=1),
152
frozenset((token_end, )))
153
token_duration = Token(re.compile(r"P"), None,
154
frozenset((token_year, token_month,
155
token_day, token_time,
156
token_week)))
157
# Define starting values
158
value = datetime.timedelta() # Value so far
159
found_token = None
160
followers = frozenset((token_duration, )) # Following valid tokens
161
s = duration # String left to parse
162
# Loop until end token is found
163
while found_token is not token_end:
164
# Search for any currently valid tokens
165
for token in followers:
166
match = token.regexp.match(s)
167
if match is not None:
168
# Token found
169
if token.value is not None:
170
# Value found, parse digits
171
factor = int(match.group(1), 10)
172
# Add to value so far
173
value += factor * token.value
174
# Strip token from string
175
s = token.regexp.sub("", s, 1)
176
# Go to found token
177
found_token = token
178
# Set valid next tokens
179
followers = found_token.followers
180
break
181
else:
182
# No currently valid tokens were found
183
raise ValueError("Invalid RFC 3339 duration: {!r}"
184
.format(duration))
185
# End token found
186
return value
76
187
77
188
78
189
def string_to_delta(interval):
79
190
"""Parse a string and return a datetime.timedelta
80
191
81
192
>>> string_to_delta('7d')
82
193
datetime.timedelta(7)
83
194
>>> string_to_delta('60s')
86
197
datetime.timedelta(0, 3600)
87
198
>>> string_to_delta('24h')
88
199
datetime.timedelta(1)
89
>>> string_to_delta(u'1w')
200
>>> string_to_delta('1w')
90
201
datetime.timedelta(7)
91
202
>>> string_to_delta('5m 30s')
92
203
datetime.timedelta(0, 330)
93
204
"""
94
timevalue = datetime.timedelta(0)
95
regexp = re.compile("\d+[dsmhw]")
96
97
for s in regexp.findall(interval):
98
try:
99
suffix = unicode(s[-1])
100
value = int(s[:-1])
101
if suffix == u"d":
102
delta = datetime.timedelta(value)
103
elif suffix == u"s":
104
delta = datetime.timedelta(0, value)
105
elif suffix == u"m":
106
delta = datetime.timedelta(0, 0, 0, 0, value)
107
elif suffix == u"h":
108
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
109
elif suffix == u"w":
110
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
111
else:
112
raise ValueError
113
except (ValueError, IndexError):
114
raise ValueError
115
timevalue += delta
116
return timevalue
205
206
try:
207
return rfc3339_duration_to_delta(interval)
208
except ValueError:
209
pass
210
211
value = datetime.timedelta(0)
212
regexp = re.compile(r"(\d+)([dsmhw]?)")
213
214
for num, suffix in regexp.findall(interval):
215
if suffix == "d":
216
value += datetime.timedelta(int(num))
217
elif suffix == "s":
218
value += datetime.timedelta(0, int(num))
219
elif suffix == "m":
220
value += datetime.timedelta(0, 0, 0, 0, int(num))
221
elif suffix == "h":
222
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
223
elif suffix == "w":
224
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
225
elif suffix == "":
226
value += datetime.timedelta(0, 0, 0, int(num))
227
return value
228
117
229
118
230
def print_clients(clients, keywords):
119
231
def valuetostring(value, keyword):
120
232
if type(value) is dbus.Boolean:
121
return u"Yes" if value else u"No"
122
if keyword in (u"Timeout", u"Interval", u"ApprovalDelay",
123
u"ApprovalDuration"):
233
return "Yes" if value else "No"
234
if keyword in ("Timeout", "Interval", "ApprovalDelay",
235
"ApprovalDuration", "ExtendedTimeout"):
124
236
return milliseconds_to_string(value)
125
return unicode(value)
237
return str(value)
126
238
127
239
# Create format string to print table rows
128
format_string = u' '.join(u'%%-%ds' %
129
max(len(tablewords[key]),
130
max(len(valuetostring(client[key],
131
key))
132
for client in
133
clients))
134
for key in keywords)
240
format_string = " ".join("{{{key}:{width}}}".format(
241
width = max(len(tablewords[key]),
242
max(len(valuetostring(client[key], key))
243
for client in clients)),
244
key = key)
245
for key in keywords)
135
246
# Print header line
136
print format_string % tuple(tablewords[key] for key in keywords)
247
print(format_string.format(**tablewords))
137
248
for client in clients:
138
print format_string % tuple(valuetostring(client[key], key)
139
for key in keywords)
249
print(format_string.format(**{
250
key: valuetostring(client[key], key)
251
for key in keywords }))
252
140
253
141
254
def has_actions(options):
142
255
return any((options.enable,
148
261
options.remove,
149
262
options.checker is not None,
150
263
options.timeout is not None,
264
options.extended_timeout is not None,
151
265
options.interval is not None,
152
266
options.approved_by_default is not None,
153
267
options.approval_delay is not None,
156
270
options.secret is not None,
157
271
options.approve,
158
272
options.deny))
159
273
274
160
275
def main():
161
parser = OptionParser(version = "%%prog %s" % version)
162
parser.add_option("-a", "--all", action="store_true",
163
help="Select all clients")
164
parser.add_option("-v", "--verbose", action="store_true",
165
help="Print all fields")
166
parser.add_option("-e", "--enable", action="store_true",
167
help="Enable client")
168
parser.add_option("-d", "--disable", action="store_true",
169
help="disable client")
170
parser.add_option("-b", "--bump-timeout", action="store_true",
171
help="Bump timeout for client")
172
parser.add_option("--start-checker", action="store_true",
173
help="Start checker for client")
174
parser.add_option("--stop-checker", action="store_true",
175
help="Stop checker for client")
176
parser.add_option("-V", "--is-enabled", action="store_true",
177
help="Check if client is enabled")
178
parser.add_option("-r", "--remove", action="store_true",
179
help="Remove client")
180
parser.add_option("-c", "--checker", type="string",
181
help="Set checker command for client")
182
parser.add_option("-t", "--timeout", type="string",
183
help="Set timeout for client")
184
parser.add_option("-i", "--interval", type="string",
185
help="Set checker interval for client")
186
parser.add_option("--approve-by-default", action="store_true",
187
dest=u"approved_by_default",
188
help="Set client to be approved by default")
189
parser.add_option("--deny-by-default", action="store_false",
190
dest=u"approved_by_default",
191
help="Set client to be denied by default")
192
parser.add_option("--approval-delay", type="string",
193
help="Set delay before client approve/deny")
194
parser.add_option("--approval-duration", type="string",
195
help="Set duration of one client approval")
196
parser.add_option("-H", "--host", type="string",
197
help="Set host for client")
198
parser.add_option("-s", "--secret", type="string",
199
help="Set password blob (file) for client")
200
parser.add_option("-A", "--approve", action="store_true",
201
help="Approve any current client request")
202
parser.add_option("-D", "--deny", action="store_true",
203
help="Deny any current client request")
204
options, client_names = parser.parse_args()
205
206
if has_actions(options) and not client_names and not options.all:
207
parser.error('Options require clients names or --all.')
208
if options.verbose and has_actions(options):
209
parser.error('--verbose can only be used alone or with'
210
' --all.')
211
if options.all and not has_actions(options):
212
parser.error('--all requires an action.')
213
214
try:
215
bus = dbus.SystemBus()
216
mandos_dbus_objc = bus.get_object(busname, server_path)
217
except dbus.exceptions.DBusException:
218
print >> sys.stderr, "Could not connect to Mandos server"
219
sys.exit(1)
220
221
mandos_serv = dbus.Interface(mandos_dbus_objc,
222
dbus_interface = server_interface)
223
224
#block stderr since dbus library prints to stderr
225
null = os.open(os.path.devnull, os.O_RDWR)
226
stderrcopy = os.dup(sys.stderr.fileno())
227
os.dup2(null, sys.stderr.fileno())
228
os.close(null)
229
try:
230
try:
231
mandos_clients = mandos_serv.GetAllClientsWithProperties()
232
finally:
233
#restore stderr
234
os.dup2(stderrcopy, sys.stderr.fileno())
235
os.close(stderrcopy)
236
except dbus.exceptions.DBusException, e:
237
print >> sys.stderr, "Access denied: Accessing mandos server through dbus."
238
sys.exit(1)
239
240
# Compile dict of (clients: properties) to process
241
clients={}
242
243
if options.all or not client_names:
244
clients = dict((bus.get_object(busname, path), properties)
245
for path, properties in
246
mandos_clients.iteritems())
247
else:
248
for name in client_names:
249
for path, client in mandos_clients.iteritems():
250
if client['Name'] == name:
251
client_objc = bus.get_object(busname, path)
252
clients[client_objc] = client
253
break
254
else:
255
print >> sys.stderr, "Client not found on server: %r" % name
256
sys.exit(1)
257
258
if not has_actions(options) and clients:
259
if options.verbose:
260
keywords = ('Name', 'Enabled', 'Timeout',
261
'LastCheckedOK', 'Created', 'Interval',
262
'Host', 'Fingerprint', 'CheckerRunning',
263
'LastEnabled', 'ApprovalPending',
264
'ApprovedByDefault',
265
'LastApprovalRequest', 'ApprovalDelay',
266
'ApprovalDuration', 'Checker')
276
parser = argparse.ArgumentParser()
277
parser.add_argument("--version", action="version",
278
version = "%(prog)s {}".format(version),
279
help="show version number and exit")
280
parser.add_argument("-a", "--all", action="store_true",
281
help="Select all clients")
282
parser.add_argument("-v", "--verbose", action="store_true",
283
help="Print all fields")
284
parser.add_argument("-j", "--dump-json", action="store_true",
285
help="Dump client data in JSON format")
286
parser.add_argument("-e", "--enable", action="store_true",
287
help="Enable client")
288
parser.add_argument("-d", "--disable", action="store_true",
289
help="disable client")
290
parser.add_argument("-b", "--bump-timeout", action="store_true",
291
help="Bump timeout for client")
292
parser.add_argument("--start-checker", action="store_true",
293
help="Start checker for client")
294
parser.add_argument("--stop-checker", action="store_true",
295
help="Stop checker for client")
296
parser.add_argument("-V", "--is-enabled", action="store_true",
297
help="Check if client is enabled")
298
parser.add_argument("-r", "--remove", action="store_true",
299
help="Remove client")
300
parser.add_argument("-c", "--checker",
301
help="Set checker command for client")
302
parser.add_argument("-t", "--timeout",
303
help="Set timeout for client")
304
parser.add_argument("--extended-timeout",
305
help="Set extended timeout for client")
306
parser.add_argument("-i", "--interval",
307
help="Set checker interval for client")
308
parser.add_argument("--approve-by-default", action="store_true",
309
default=None, dest="approved_by_default",
310
help="Set client to be approved by default")
311
parser.add_argument("--deny-by-default", action="store_false",
312
dest="approved_by_default",
313
help="Set client to be denied by default")
314
parser.add_argument("--approval-delay",
315
help="Set delay before client approve/deny")
316
parser.add_argument("--approval-duration",
317
help="Set duration of one client approval")
318
parser.add_argument("-H", "--host", help="Set host for client")
319
parser.add_argument("-s", "--secret",
320
type=argparse.FileType(mode="rb"),
321
help="Set password blob (file) for client")
322
parser.add_argument("-A", "--approve", action="store_true",
323
help="Approve any current client request")
324
parser.add_argument("-D", "--deny", action="store_true",
325
help="Deny any current client request")
326
parser.add_argument("--check", action="store_true",
327
help="Run self-test")
328
parser.add_argument("client", nargs="*", help="Client name")
329
options = parser.parse_args()
330
331
if has_actions(options) and not (options.client or options.all):
332
parser.error("Options require clients names or --all.")
333
if options.verbose and has_actions(options):
334
parser.error("--verbose can only be used alone.")
335
if options.dump_json and (options.verbose or has_actions(options)):
336
parser.error("--dump-json can only be used alone.")
337
if options.all and not has_actions(options):
338
parser.error("--all requires an action.")
339
340
if options.check:
341
fail_count, test_count = doctest.testmod()
342
sys.exit(os.EX_OK if fail_count == 0 else 1)
343
344
try:
345
bus = dbus.SystemBus()
346
mandos_dbus_objc = bus.get_object(busname, server_path)
347
except dbus.exceptions.DBusException:
348
print("Could not connect to Mandos server", file=sys.stderr)
349
sys.exit(1)
350
351
mandos_serv = dbus.Interface(mandos_dbus_objc,
352
dbus_interface = server_interface)
353
mandos_serv_object_manager = dbus.Interface(
354
mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)
355
356
#block stderr since dbus library prints to stderr
357
null = os.open(os.path.devnull, os.O_RDWR)
358
stderrcopy = os.dup(sys.stderr.fileno())
359
os.dup2(null, sys.stderr.fileno())
360
os.close(null)
361
try:
362
try:
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 }
368
finally:
369
#restore stderr
370
os.dup2(stderrcopy, sys.stderr.fileno())
371
os.close(stderrcopy)
372
except dbus.exceptions.DBusException as e:
373
print("Access denied: Accessing mandos server through D-Bus: {}"
374
.format(e), file=sys.stderr)
375
sys.exit(1)
376
377
# Compile dict of (clients: properties) to process
378
clients={}
379
380
if options.all or not options.client:
381
clients = { bus.get_object(busname, path): properties
382
for path, properties in mandos_clients.items() }
383
else:
384
for name in options.client:
385
for path, client in mandos_clients.items():
386
if client["Name"] == name:
387
client_objc = bus.get_object(busname, path)
388
clients[client_objc] = client
389
break
267
390
else:
268
keywords = defaultkeywords
269
270
print_clients(clients.values(), keywords)
271
else:
272
# Process each client in the list by all selected options
273
for client in clients:
274
if options.remove:
275
mandos_serv.RemoveClient(client.__dbus_object_path__)
276
if options.enable:
277
client.Enable(dbus_interface=client_interface)
278
if options.disable:
279
client.Disable(dbus_interface=client_interface)
280
if options.bump_timeout:
281
client.CheckedOK(dbus_interface=client_interface)
282
if options.start_checker:
283
client.StartChecker(dbus_interface=client_interface)
284
if options.stop_checker:
285
client.StopChecker(dbus_interface=client_interface)
286
if options.is_enabled:
287
sys.exit(0 if client.Get(client_interface,
288
u"Enabled",
289
dbus_interface=dbus.PROPERTIES_IFACE)
290
else 1)
291
if options.checker:
292
client.Set(client_interface, u"Checker", options.checker,
293
dbus_interface=dbus.PROPERTIES_IFACE)
294
if options.host:
295
client.Set(client_interface, u"Host", options.host,
296
dbus_interface=dbus.PROPERTIES_IFACE)
297
if options.interval:
298
client.Set(client_interface, u"Interval",
299
timedelta_to_milliseconds
300
(string_to_delta(options.interval)),
301
dbus_interface=dbus.PROPERTIES_IFACE)
302
if options.approval_delay:
303
client.Set(client_interface, u"ApprovalDelay",
304
timedelta_to_milliseconds
305
(string_to_delta(options.
306
approval_delay)),
307
dbus_interface=dbus.PROPERTIES_IFACE)
308
if options.approval_duration:
309
client.Set(client_interface, u"ApprovalDuration",
310
timedelta_to_milliseconds
311
(string_to_delta(options.
312
approval_duration)),
313
dbus_interface=dbus.PROPERTIES_IFACE)
314
if options.timeout:
315
client.Set(client_interface, u"Timeout",
316
timedelta_to_milliseconds
317
(string_to_delta(options.timeout)),
318
dbus_interface=dbus.PROPERTIES_IFACE)
319
if options.secret:
320
client.Set(client_interface, u"Secret",
321
dbus.ByteArray(open(options.secret,
322
u'rb').read()),
323
dbus_interface=dbus.PROPERTIES_IFACE)
324
if options.approved_by_default is not None:
325
client.Set(client_interface, u"ApprovedByDefault",
326
dbus.Boolean(options
327
.approved_by_default),
328
dbus_interface=dbus.PROPERTIES_IFACE)
329
if options.approve:
330
client.Approve(dbus.Boolean(True),
331
dbus_interface=client_interface)
332
elif options.deny:
333
client.Approve(dbus.Boolean(False),
334
dbus_interface=client_interface)
335
336
if __name__ == '__main__':
391
print("Client not found on server: {!r}"
392
.format(name), file=sys.stderr)
393
sys.exit(1)
394
395
if not has_actions(options) and clients:
396
if options.verbose or options.dump_json:
397
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
398
"Created", "Interval", "Host", "Fingerprint",
399
"CheckerRunning", "LastEnabled",
400
"ApprovalPending", "ApprovedByDefault",
401
"LastApprovalRequest", "ApprovalDelay",
402
"ApprovalDuration", "Checker",
403
"ExtendedTimeout")
404
else:
405
keywords = defaultkeywords
406
407
if options.dump_json:
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 = (',', ': '))
413
print()
414
else:
415
print_clients(clients.values(), keywords)
416
else:
417
# Process each client in the list by all selected options
418
for client in clients:
419
420
def set_client_prop(prop, value):
421
"""Set a Client D-Bus property"""
422
client.Set(client_interface, prop, value,
423
dbus_interface=dbus.PROPERTIES_IFACE)
424
425
def set_client_prop_ms(prop, value):
426
"""Set a Client D-Bus property, converted
427
from a string to milliseconds."""
428
set_client_prop(prop,
429
string_to_delta(value).total_seconds()
430
* 1000)
431
432
if options.remove:
433
mandos_serv.RemoveClient(client.__dbus_object_path__)
434
if options.enable:
435
set_client_prop("Enabled", dbus.Boolean(True))
436
if options.disable:
437
set_client_prop("Enabled", dbus.Boolean(False))
438
if options.bump_timeout:
439
set_client_prop("LastCheckedOK", "")
440
if options.start_checker:
441
set_client_prop("CheckerRunning", dbus.Boolean(True))
442
if options.stop_checker:
443
set_client_prop("CheckerRunning", dbus.Boolean(False))
444
if options.is_enabled:
445
sys.exit(0 if client.Get(client_interface,
446
"Enabled",
447
dbus_interface=
448
dbus.PROPERTIES_IFACE)
449
else 1)
450
if options.checker is not None:
451
set_client_prop("Checker", options.checker)
452
if options.host is not None:
453
set_client_prop("Host", options.host)
454
if options.interval is not None:
455
set_client_prop_ms("Interval", options.interval)
456
if options.approval_delay is not None:
457
set_client_prop_ms("ApprovalDelay",
458
options.approval_delay)
459
if options.approval_duration is not None:
460
set_client_prop_ms("ApprovalDuration",
461
options.approval_duration)
462
if options.timeout is not None:
463
set_client_prop_ms("Timeout", options.timeout)
464
if options.extended_timeout is not None:
465
set_client_prop_ms("ExtendedTimeout",
466
options.extended_timeout)
467
if options.secret is not None:
468
set_client_prop("Secret",
469
dbus.ByteArray(options.secret.read()))
470
if options.approved_by_default is not None:
471
set_client_prop("ApprovedByDefault",
472
dbus.Boolean(options
473
.approved_by_default))
474
if options.approve:
475
client.Approve(dbus.Boolean(True),
476
dbus_interface=client_interface)
477
elif options.deny:
478
client.Approve(dbus.Boolean(False),
479
dbus_interface=client_interface)
480
481
482
if __name__ == "__main__":
337
483
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0