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