To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 237.7.445
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.445
- Committer: Teddy Hogeborn
- Date: 2017-02-21 22:15:43 UTC
- mto: (237.7.594 trunk)
- mto: This revision was merged to the branch mainline in revision 358.
- Revision ID: teddy@recompile.se-20170221221543-kkh15uag0luiyz4y
Remove useless code (and use "read -r") in initramfs-tools-hook
* initramfs-tools-hook: When reading module names from network hooks
given the "modules" argument, use "read -r" and ignore ${target}
variable (left over from code above it).
* initramfs-tools-hook: When reading module names from network hooks
given the "modules" argument, use "read -r" and ignore ${target}
variable (left over from code above it).
- files added:
- bugs.xml
- debian/upstream
- network-hooks.d
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-ctl
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
#
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2008-2010 Teddy Hogeborn
7
# Copyright © 2008-2010 Björn Påhlsson
8
#
5
#
6
# Copyright © 2008-2016 Teddy Hogeborn
7
# Copyright © 2008-2016 Björn Påhlsson
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
11
11
# the Free Software Foundation, either version 3 of the License, or
15
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
16
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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.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
"Expires": "Expires",
70
"LastCheckerStatus": "Last Checker Status",
71
}
72
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
73
domain = "se.recompile"
74
busname = domain + ".Mandos"
75
server_path = "/"
76
server_interface = domain + ".Mandos"
77
client_interface = domain + ".Mandos.Client"
78
version = "1.7.14"
79
80
81
try:
82
dbus.OBJECT_MANAGER_IFACE
83
except AttributeError:
84
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
85
67
86
68
87
def milliseconds_to_string(ms):
69
88
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
})
89
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
90
.format(days="{}T".format(td.days) if td.days else "",
91
hours=td.seconds // 3600,
92
minutes=(td.seconds % 3600) // 60,
93
seconds=td.seconds % 60))
94
95
96
def rfc3339_duration_to_delta(duration):
97
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
98
99
>>> rfc3339_duration_to_delta("P7D")
100
datetime.timedelta(7)
101
>>> rfc3339_duration_to_delta("PT60S")
102
datetime.timedelta(0, 60)
103
>>> rfc3339_duration_to_delta("PT60M")
104
datetime.timedelta(0, 3600)
105
>>> rfc3339_duration_to_delta("PT24H")
106
datetime.timedelta(1)
107
>>> rfc3339_duration_to_delta("P1W")
108
datetime.timedelta(7)
109
>>> rfc3339_duration_to_delta("PT5M30S")
110
datetime.timedelta(0, 330)
111
>>> rfc3339_duration_to_delta("P1DT3M20S")
112
datetime.timedelta(1, 200)
113
"""
114
115
# Parsing an RFC 3339 duration with regular expressions is not
116
# possible - there would have to be multiple places for the same
117
# values, like seconds. The current code, while more esoteric, is
118
# cleaner without depending on a parsing library. If Python had a
119
# built-in library for parsing we would use it, but we'd like to
120
# avoid excessive use of external libraries.
121
122
# New type for defining tokens, syntax, and semantics all-in-one
123
Token = collections.namedtuple("Token", (
124
"regexp", # To match token; if "value" is not None, must have
125
# a "group" containing digits
126
"value", # datetime.timedelta or None
127
"followers")) # Tokens valid after this token
128
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
129
# the "duration" ABNF definition in RFC 3339, Appendix A.
130
token_end = Token(re.compile(r"$"), None, frozenset())
131
token_second = Token(re.compile(r"(\d+)S"),
132
datetime.timedelta(seconds=1),
133
frozenset((token_end, )))
134
token_minute = Token(re.compile(r"(\d+)M"),
135
datetime.timedelta(minutes=1),
136
frozenset((token_second, token_end)))
137
token_hour = Token(re.compile(r"(\d+)H"),
138
datetime.timedelta(hours=1),
139
frozenset((token_minute, token_end)))
140
token_time = Token(re.compile(r"T"),
141
None,
142
frozenset((token_hour, token_minute,
143
token_second)))
144
token_day = Token(re.compile(r"(\d+)D"),
145
datetime.timedelta(days=1),
146
frozenset((token_time, token_end)))
147
token_month = Token(re.compile(r"(\d+)M"),
148
datetime.timedelta(weeks=4),
149
frozenset((token_day, token_end)))
150
token_year = Token(re.compile(r"(\d+)Y"),
151
datetime.timedelta(weeks=52),
152
frozenset((token_month, token_end)))
153
token_week = Token(re.compile(r"(\d+)W"),
154
datetime.timedelta(weeks=1),
155
frozenset((token_end, )))
156
token_duration = Token(re.compile(r"P"), None,
157
frozenset((token_year, token_month,
158
token_day, token_time,
159
token_week)))
160
# Define starting values:
161
# Value so far
162
value = datetime.timedelta()
163
found_token = None
164
# Following valid tokens
165
followers = frozenset((token_duration, ))
166
# String left to parse
167
s = duration
168
# Loop until end token is found
169
while found_token is not token_end:
170
# Search for any currently valid tokens
171
for token in followers:
172
match = token.regexp.match(s)
173
if match is not None:
174
# Token found
175
if token.value is not None:
176
# Value found, parse digits
177
factor = int(match.group(1), 10)
178
# Add to value so far
179
value += factor * token.value
180
# Strip token from string
181
s = token.regexp.sub("", s, 1)
182
# Go to found token
183
found_token = token
184
# Set valid next tokens
185
followers = found_token.followers
186
break
187
else:
188
# No currently valid tokens were found
189
raise ValueError("Invalid RFC 3339 duration: {!r}"
190
.format(duration))
191
# End token found
192
return value
76
193
77
194
78
195
def string_to_delta(interval):
86
203
datetime.timedelta(0, 3600)
87
204
>>> string_to_delta('24h')
88
205
datetime.timedelta(1)
89
>>> string_to_delta(u'1w')
206
>>> string_to_delta('1w')
90
207
datetime.timedelta(7)
91
208
>>> string_to_delta('5m 30s')
92
209
datetime.timedelta(0, 330)
93
210
"""
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
211
212
try:
213
return rfc3339_duration_to_delta(interval)
214
except ValueError:
215
pass
216
217
value = datetime.timedelta(0)
218
regexp = re.compile(r"(\d+)([dsmhw]?)")
219
220
for num, suffix in regexp.findall(interval):
221
if suffix == "d":
222
value += datetime.timedelta(int(num))
223
elif suffix == "s":
224
value += datetime.timedelta(0, int(num))
225
elif suffix == "m":
226
value += datetime.timedelta(0, 0, 0, 0, int(num))
227
elif suffix == "h":
228
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
229
elif suffix == "w":
230
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
231
elif suffix == "":
232
value += datetime.timedelta(0, 0, 0, int(num))
233
return value
234
117
235
118
236
def print_clients(clients, keywords):
119
237
def valuetostring(value, keyword):
120
238
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"):
239
return "Yes" if value else "No"
240
if keyword in ("Timeout", "Interval", "ApprovalDelay",
241
"ApprovalDuration", "ExtendedTimeout"):
124
242
return milliseconds_to_string(value)
125
return unicode(value)
126
243
return str(value)
244
127
245
# 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)
246
format_string = " ".join("{{{key}:{width}}}".format(
247
width=max(len(tablewords[key]),
248
max(len(valuetostring(client[key], key))
249
for client in clients)),
250
key=key)
251
for key in keywords)
135
252
# Print header line
136
print format_string % tuple(tablewords[key] for key in keywords)
253
print(format_string.format(**tablewords))
137
254
for client in clients:
138
print format_string % tuple(valuetostring(client[key], key)
139
for key in keywords)
255
print(format_string
256
.format(**{key: valuetostring(client[key], key)
257
for key in keywords}))
258
140
259
141
260
def has_actions(options):
142
261
return any((options.enable,
148
267
options.remove,
149
268
options.checker is not None,
150
269
options.timeout is not None,
270
options.extended_timeout is not None,
151
271
options.interval is not None,
152
272
options.approved_by_default is not None,
153
273
options.approval_delay is not None,
156
276
options.secret is not None,
157
277
options.approve,
158
278
options.deny))
159
279
280
160
281
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
282
parser = argparse.ArgumentParser()
283
parser.add_argument("--version", action="version",
284
version="%(prog)s {}".format(version),
285
help="show version number and exit")
286
parser.add_argument("-a", "--all", action="store_true",
287
help="Select all clients")
288
parser.add_argument("-v", "--verbose", action="store_true",
289
help="Print all fields")
290
parser.add_argument("-j", "--dump-json", action="store_true",
291
help="Dump client data in JSON format")
292
parser.add_argument("-e", "--enable", action="store_true",
293
help="Enable client")
294
parser.add_argument("-d", "--disable", action="store_true",
295
help="disable client")
296
parser.add_argument("-b", "--bump-timeout", action="store_true",
297
help="Bump timeout for client")
298
parser.add_argument("--start-checker", action="store_true",
299
help="Start checker for client")
300
parser.add_argument("--stop-checker", action="store_true",
301
help="Stop checker for client")
302
parser.add_argument("-V", "--is-enabled", action="store_true",
303
help="Check if client is enabled")
304
parser.add_argument("-r", "--remove", action="store_true",
305
help="Remove client")
306
parser.add_argument("-c", "--checker",
307
help="Set checker command for client")
308
parser.add_argument("-t", "--timeout",
309
help="Set timeout for client")
310
parser.add_argument("--extended-timeout",
311
help="Set extended timeout for client")
312
parser.add_argument("-i", "--interval",
313
help="Set checker interval for client")
314
parser.add_argument("--approve-by-default", action="store_true",
315
default=None, dest="approved_by_default",
316
help="Set client to be approved by default")
317
parser.add_argument("--deny-by-default", action="store_false",
318
dest="approved_by_default",
319
help="Set client to be denied by default")
320
parser.add_argument("--approval-delay",
321
help="Set delay before client approve/deny")
322
parser.add_argument("--approval-duration",
323
help="Set duration of one client approval")
324
parser.add_argument("-H", "--host", help="Set host for client")
325
parser.add_argument("-s", "--secret",
326
type=argparse.FileType(mode="rb"),
327
help="Set password blob (file) for client")
328
parser.add_argument("-A", "--approve", action="store_true",
329
help="Approve any current client request")
330
parser.add_argument("-D", "--deny", action="store_true",
331
help="Deny any current client request")
332
parser.add_argument("--check", action="store_true",
333
help="Run self-test")
334
parser.add_argument("client", nargs="*", help="Client name")
335
options = parser.parse_args()
336
337
if has_actions(options) and not (options.client or options.all):
338
parser.error("Options require clients names or --all.")
339
if options.verbose and has_actions(options):
340
parser.error("--verbose can only be used alone.")
341
if options.dump_json and (options.verbose
342
or has_actions(options)):
343
parser.error("--dump-json can only be used alone.")
344
if options.all and not has_actions(options):
345
parser.error("--all requires an action.")
346
347
if options.check:
348
fail_count, test_count = doctest.testmod()
349
sys.exit(os.EX_OK if fail_count == 0 else 1)
350
351
try:
352
bus = dbus.SystemBus()
353
mandos_dbus_objc = bus.get_object(busname, server_path)
354
except dbus.exceptions.DBusException:
355
print("Could not connect to Mandos server", file=sys.stderr)
356
sys.exit(1)
357
358
mandos_serv = dbus.Interface(mandos_dbus_objc,
359
dbus_interface=server_interface)
360
mandos_serv_object_manager = dbus.Interface(
361
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
362
363
# block stderr since dbus library prints to stderr
364
null = os.open(os.path.devnull, os.O_RDWR)
365
stderrcopy = os.dup(sys.stderr.fileno())
366
os.dup2(null, sys.stderr.fileno())
367
os.close(null)
368
try:
369
try:
370
mandos_clients = {path: ifs_and_props[client_interface]
371
for path, ifs_and_props in
372
mandos_serv_object_manager
373
.GetManagedObjects().items()
374
if client_interface in ifs_and_props}
375
finally:
376
# restore stderr
377
os.dup2(stderrcopy, sys.stderr.fileno())
378
os.close(stderrcopy)
379
except dbus.exceptions.DBusException as e:
380
print("Access denied: "
381
"Accessing mandos server through D-Bus: {}".format(e),
382
file=sys.stderr)
383
sys.exit(1)
384
385
# Compile dict of (clients: properties) to process
386
clients = {}
387
388
if options.all or not options.client:
389
clients = {bus.get_object(busname, path): properties
390
for path, properties in mandos_clients.items()}
391
else:
392
for name in options.client:
393
for path, client in mandos_clients.items():
394
if client["Name"] == name:
395
client_objc = bus.get_object(busname, path)
396
clients[client_objc] = client
397
break
398
else:
399
print("Client not found on server: {!r}"
400
.format(name), file=sys.stderr)
401
sys.exit(1)
402
403
if not has_actions(options) and clients:
404
if options.verbose or options.dump_json:
405
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
406
"Created", "Interval", "Host", "Fingerprint",
407
"CheckerRunning", "LastEnabled",
408
"ApprovalPending", "ApprovedByDefault",
409
"LastApprovalRequest", "ApprovalDelay",
410
"ApprovalDuration", "Checker",
411
"ExtendedTimeout", "Expires",
412
"LastCheckerStatus")
413
else:
414
keywords = defaultkeywords
415
416
if options.dump_json:
417
json.dump({client["Name"]: {key:
418
bool(client[key])
419
if isinstance(client[key],
420
dbus.Boolean)
421
else client[key]
422
for key in keywords}
423
for client in clients.values()},
424
fp=sys.stdout, indent=4,
425
separators=(',', ': '))
426
print()
427
else:
428
print_clients(clients.values(), keywords)
429
else:
430
# Process each client in the list by all selected options
431
for client in clients:
432
433
def set_client_prop(prop, value):
434
"""Set a Client D-Bus property"""
435
client.Set(client_interface, prop, value,
436
dbus_interface=dbus.PROPERTIES_IFACE)
437
438
def set_client_prop_ms(prop, value):
439
"""Set a Client D-Bus property, converted
440
from a string to milliseconds."""
441
set_client_prop(prop,
442
string_to_delta(value).total_seconds()
443
* 1000)
444
445
if options.remove:
446
mandos_serv.RemoveClient(client.__dbus_object_path__)
447
if options.enable:
448
set_client_prop("Enabled", dbus.Boolean(True))
449
if options.disable:
450
set_client_prop("Enabled", dbus.Boolean(False))
451
if options.bump_timeout:
452
set_client_prop("LastCheckedOK", "")
453
if options.start_checker:
454
set_client_prop("CheckerRunning", dbus.Boolean(True))
455
if options.stop_checker:
456
set_client_prop("CheckerRunning", dbus.Boolean(False))
457
if options.is_enabled:
458
if client.Get(client_interface, "Enabled",
459
dbus_interface=dbus.PROPERTIES_IFACE):
460
sys.exit(0)
254
461
else:
255
print >> sys.stderr, "Client not found on server: %r" % name
256
462
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')
267
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__':
463
if options.checker is not None:
464
set_client_prop("Checker", options.checker)
465
if options.host is not None:
466
set_client_prop("Host", options.host)
467
if options.interval is not None:
468
set_client_prop_ms("Interval", options.interval)
469
if options.approval_delay is not None:
470
set_client_prop_ms("ApprovalDelay",
471
options.approval_delay)
472
if options.approval_duration is not None:
473
set_client_prop_ms("ApprovalDuration",
474
options.approval_duration)
475
if options.timeout is not None:
476
set_client_prop_ms("Timeout", options.timeout)
477
if options.extended_timeout is not None:
478
set_client_prop_ms("ExtendedTimeout",
479
options.extended_timeout)
480
if options.secret is not None:
481
set_client_prop("Secret",
482
dbus.ByteArray(options.secret.read()))
483
if options.approved_by_default is not None:
484
set_client_prop("ApprovedByDefault",
485
dbus.Boolean(options
486
.approved_by_default))
487
if options.approve:
488
client.Approve(dbus.Boolean(True),
489
dbus_interface=client_interface)
490
elif options.deny:
491
client.Approve(dbus.Boolean(False),
492
dbus_interface=client_interface)
493
494
495
if __name__ == "__main__":
337
496
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0