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