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.160
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.160
- Committer: Björn Påhlsson
- Date: 2012-07-03 20:55:09 UTC
- mto: (237.7.272 trunk)
- mto: This revision was merged to the branch mainline in revision 303.
- 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
- 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/>.
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
from future_builtins import *
30
28
31
import sys
29
import dbus
30
from optparse import OptionParser
32
import argparse
31
33
import locale
32
34
import datetime
33
35
import re
34
36
import os
37
import collections
38
import doctest
39
40
import dbus
35
41
36
42
locale.setlocale(locale.LC_ALL, "")
37
43
52
58
"ApprovalDelay": "Approval Delay",
53
59
"ApprovalDuration": "Approval Duration",
54
60
"Checker": "Checker",
61
"ExtendedTimeout" : "Extended Timeout"
55
62
}
56
63
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
57
domain = "se.bsnet.fukt"
64
domain = "se.recompile"
58
65
busname = domain + ".Mandos"
59
66
server_path = "/"
60
67
server_interface = domain + ".Mandos"
61
68
client_interface = domain + ".Mandos.Client"
62
version = "1.3.0"
69
version = "1.6.0"
63
70
64
71
def timedelta_to_milliseconds(td):
65
72
"""Convert a datetime.timedelta object to milliseconds"""
69
76
70
77
def milliseconds_to_string(ms):
71
78
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
})
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
78
184
79
185
80
186
def string_to_delta(interval):
81
187
"""Parse a string and return a datetime.timedelta
82
188
83
189
>>> string_to_delta("7d")
84
190
datetime.timedelta(7)
85
191
>>> string_to_delta("60s")
93
199
>>> string_to_delta("5m 30s")
94
200
datetime.timedelta(0, 330)
95
201
"""
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
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
119
224
120
225
def print_clients(clients, keywords):
121
226
def valuetostring(value, keyword):
122
227
if type(value) is dbus.Boolean:
123
228
return "Yes" if value else "No"
124
229
if keyword in ("Timeout", "Interval", "ApprovalDelay",
125
"ApprovalDuration"):
230
"ApprovalDuration", "ExtendedTimeout"):
126
231
return milliseconds_to_string(value)
127
232
return unicode(value)
128
233
129
234
# 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))
136
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)
137
242
# Print header line
138
print(format_string % tuple(tablewords[key] for key in keywords))
243
print(format_string.format(**tablewords))
139
244
for client in clients:
140
print(format_string % tuple(valuetostring(client[key], key)
141
for key in keywords))
245
print(format_string.format(**dict((key,
246
valuetostring(client[key],
247
key))
248
for key in keywords)))
142
249
143
250
def has_actions(options):
144
251
return any((options.enable,
150
257
options.remove,
151
258
options.checker is not None,
152
259
options.timeout is not None,
260
options.extended_timeout is not None,
153
261
options.interval is not None,
154
262
options.approved_by_default is not None,
155
263
options.approval_delay is not None,
158
266
options.secret is not None,
159
267
options.approve,
160
268
options.deny))
161
269
162
270
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)
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()
223
322
224
mandos_serv = dbus.Interface(mandos_dbus_objc,
225
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.")
226
330
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)
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:
232
352
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")
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
272
377
else:
273
keywords = defaultkeywords
274
275
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")
276
392
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)
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)
340
457
341
458
if __name__ == "__main__":
342
459
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0