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 591
- compare with another revision
- download diff
- download tarball
- view history from revision 591
- Committer: Teddy Hogeborn
- Date: 2012-05-26 22:56:38 UTC
- mfrom: (589.1.1 socket-option)
- Revision ID: teddy@recompile.se-20120526225638-4hvqyrvmj0036lfn
Merge "--socket" option for server.
This is suggested by the GNU Coding Standards' Table of Long Options,
and will probably also allow socket activation (e.g. by systemd(8)).
This is suggested by the GNU Coding Standards' Table of Long Options,
and will probably also allow socket activation (e.g. by systemd(8)).
- files added:
- debian/source/local-options
- 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, absolute_import, unicode_literals
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 *
26
30
27
31
import sys
28
32
import dbus
29
from optparse import OptionParser
33
import argparse
30
34
import locale
31
35
import datetime
32
36
import re
51
55
"ApprovalDelay": "Approval Delay",
52
56
"ApprovalDuration": "Approval Duration",
53
57
"Checker": "Checker",
58
"ExtendedTimeout" : "Extended Timeout"
54
59
}
55
60
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
56
domain = "se.bsnet.fukt"
61
domain = "se.recompile"
57
62
busname = domain + ".Mandos"
58
63
server_path = "/"
59
64
server_interface = domain + ".Mandos"
60
65
client_interface = domain + ".Mandos.Client"
61
version = "1.2.3"
66
version = "1.5.4"
62
67
63
68
def timedelta_to_milliseconds(td):
64
69
"""Convert a datetime.timedelta object to milliseconds"""
68
73
69
74
def milliseconds_to_string(ms):
70
75
td = datetime.timedelta(0, 0, 0, ms)
71
return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
72
% { "days": "%dT" % td.days if td.days else "",
73
"hours": td.seconds // 3600,
74
"minutes": (td.seconds % 3600) // 60,
75
"seconds": td.seconds % 60,
76
})
77
76
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
77
.format(days = "{0}T".format(td.days) if td.days else "",
78
hours = td.seconds // 3600,
79
minutes = (td.seconds % 3600) // 60,
80
seconds = td.seconds % 60,
81
))
78
82
79
83
def string_to_delta(interval):
80
84
"""Parse a string and return a datetime.timedelta
81
85
82
86
>>> string_to_delta("7d")
83
87
datetime.timedelta(7)
84
88
>>> string_to_delta("60s")
92
96
>>> string_to_delta("5m 30s")
93
97
datetime.timedelta(0, 330)
94
98
"""
95
timevalue = datetime.timedelta(0)
96
regexp = re.compile("\d+[dsmhw]")
99
value = datetime.timedelta(0)
100
regexp = re.compile("(\d+)([dsmhw]?)")
97
101
98
for s in regexp.findall(interval):
99
try:
100
suffix = unicode(s[-1])
101
value = int(s[:-1])
102
if suffix == "d":
103
delta = datetime.timedelta(value)
104
elif suffix == "s":
105
delta = datetime.timedelta(0, value)
106
elif suffix == "m":
107
delta = datetime.timedelta(0, 0, 0, 0, value)
108
elif suffix == "h":
109
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
110
elif suffix == "w":
111
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
112
else:
113
raise ValueError
114
except (ValueError, IndexError):
115
raise ValueError
116
timevalue += delta
117
return timevalue
102
for num, suffix in regexp.findall(interval):
103
if suffix == "d":
104
value += datetime.timedelta(int(num))
105
elif suffix == "s":
106
value += datetime.timedelta(0, int(num))
107
elif suffix == "m":
108
value += datetime.timedelta(0, 0, 0, 0, int(num))
109
elif suffix == "h":
110
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
111
elif suffix == "w":
112
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
113
elif suffix == "":
114
value += datetime.timedelta(0, 0, 0, int(num))
115
return value
118
116
119
117
def print_clients(clients, keywords):
120
118
def valuetostring(value, keyword):
121
119
if type(value) is dbus.Boolean:
122
120
return "Yes" if value else "No"
123
121
if keyword in ("Timeout", "Interval", "ApprovalDelay",
124
"ApprovalDuration"):
122
"ApprovalDuration", "ExtendedTimeout"):
125
123
return milliseconds_to_string(value)
126
124
return unicode(value)
127
125
128
126
# Create format string to print table rows
129
format_string = " ".join("%%-%ds" %
130
max(len(tablewords[key]),
131
max(len(valuetostring(client[key],
132
key))
133
for client in
134
clients))
135
for key in keywords)
127
format_string = " ".join("{{{key}:{width}}}".format(
128
width = max(len(tablewords[key]),
129
max(len(valuetostring(client[key],
130
key))
131
for client in
132
clients)),
133
key = key) for key in keywords)
136
134
# Print header line
137
print format_string % tuple(tablewords[key] for key in keywords)
135
print(format_string.format(**tablewords))
138
136
for client in clients:
139
print format_string % tuple(valuetostring(client[key], key)
140
for key in keywords)
137
print(format_string.format(**dict((key,
138
valuetostring(client[key],
139
key))
140
for key in keywords)))
141
141
142
142
def has_actions(options):
143
143
return any((options.enable,
149
149
options.remove,
150
150
options.checker is not None,
151
151
options.timeout is not None,
152
options.extended_timeout is not None,
152
153
options.interval is not None,
153
154
options.approved_by_default is not None,
154
155
options.approval_delay is not None,
157
158
options.secret is not None,
158
159
options.approve,
159
160
options.deny))
160
161
161
162
def main():
162
parser = OptionParser(version = "%%prog %s" % version)
163
parser.add_option("-a", "--all", action="store_true",
164
help="Select all clients")
165
parser.add_option("-v", "--verbose", action="store_true",
166
help="Print all fields")
167
parser.add_option("-e", "--enable", action="store_true",
168
help="Enable client")
169
parser.add_option("-d", "--disable", action="store_true",
170
help="disable client")
171
parser.add_option("-b", "--bump-timeout", action="store_true",
172
help="Bump timeout for client")
173
parser.add_option("--start-checker", action="store_true",
174
help="Start checker for client")
175
parser.add_option("--stop-checker", action="store_true",
176
help="Stop checker for client")
177
parser.add_option("-V", "--is-enabled", action="store_true",
178
help="Check if client is enabled")
179
parser.add_option("-r", "--remove", action="store_true",
180
help="Remove client")
181
parser.add_option("-c", "--checker", type="string",
182
help="Set checker command for client")
183
parser.add_option("-t", "--timeout", type="string",
184
help="Set timeout for client")
185
parser.add_option("-i", "--interval", type="string",
186
help="Set checker interval for client")
187
parser.add_option("--approve-by-default", action="store_true",
188
dest="approved_by_default",
189
help="Set client to be approved by default")
190
parser.add_option("--deny-by-default", action="store_false",
191
dest="approved_by_default",
192
help="Set client to be denied by default")
193
parser.add_option("--approval-delay", type="string",
194
help="Set delay before client approve/deny")
195
parser.add_option("--approval-duration", type="string",
196
help="Set duration of one client approval")
197
parser.add_option("-H", "--host", type="string",
198
help="Set host for client")
199
parser.add_option("-s", "--secret", type="string",
200
help="Set password blob (file) for client")
201
parser.add_option("-A", "--approve", action="store_true",
202
help="Approve any current client request")
203
parser.add_option("-D", "--deny", action="store_true",
204
help="Deny any current client request")
205
options, client_names = parser.parse_args()
206
207
if has_actions(options) and not client_names and not options.all:
208
parser.error("Options require clients names or --all.")
209
if options.verbose and has_actions(options):
210
parser.error("--verbose can only be used alone or with"
211
" --all.")
212
if options.all and not has_actions(options):
213
parser.error("--all requires an action.")
214
215
try:
216
bus = dbus.SystemBus()
217
mandos_dbus_objc = bus.get_object(busname, server_path)
218
except dbus.exceptions.DBusException:
219
print >> sys.stderr, "Could not connect to Mandos server"
220
sys.exit(1)
221
222
mandos_serv = dbus.Interface(mandos_dbus_objc,
223
dbus_interface = server_interface)
224
225
#block stderr since dbus library prints to stderr
226
null = os.open(os.path.devnull, os.O_RDWR)
227
stderrcopy = os.dup(sys.stderr.fileno())
228
os.dup2(null, sys.stderr.fileno())
229
os.close(null)
230
try:
231
try:
232
mandos_clients = mandos_serv.GetAllClientsWithProperties()
233
finally:
234
#restore stderr
235
os.dup2(stderrcopy, sys.stderr.fileno())
236
os.close(stderrcopy)
237
except dbus.exceptions.DBusException, e:
238
print >> sys.stderr, "Access denied: Accessing mandos server through dbus."
239
sys.exit(1)
240
241
# Compile dict of (clients: properties) to process
242
clients={}
243
244
if options.all or not client_names:
245
clients = dict((bus.get_object(busname, path), properties)
246
for path, properties in
247
mandos_clients.iteritems())
248
else:
249
for name in client_names:
250
for path, client in mandos_clients.iteritems():
251
if client["Name"] == name:
252
client_objc = bus.get_object(busname, path)
253
clients[client_objc] = client
254
break
255
else:
256
print >> sys.stderr, "Client not found on server: %r" % name
257
sys.exit(1)
258
259
if not has_actions(options) and clients:
260
if options.verbose:
261
keywords = ("Name", "Enabled", "Timeout",
262
"LastCheckedOK", "Created", "Interval",
263
"Host", "Fingerprint", "CheckerRunning",
264
"LastEnabled", "ApprovalPending",
265
"ApprovedByDefault",
266
"LastApprovalRequest", "ApprovalDelay",
267
"ApprovalDuration", "Checker")
163
parser = argparse.ArgumentParser()
164
parser.add_argument("--version", action="version",
165
version = "%(prog)s {0}".format(version),
166
help="show version number and exit")
167
parser.add_argument("-a", "--all", action="store_true",
168
help="Select all clients")
169
parser.add_argument("-v", "--verbose", action="store_true",
170
help="Print all fields")
171
parser.add_argument("-e", "--enable", action="store_true",
172
help="Enable client")
173
parser.add_argument("-d", "--disable", action="store_true",
174
help="disable client")
175
parser.add_argument("-b", "--bump-timeout", action="store_true",
176
help="Bump timeout for client")
177
parser.add_argument("--start-checker", action="store_true",
178
help="Start checker for client")
179
parser.add_argument("--stop-checker", action="store_true",
180
help="Stop checker for client")
181
parser.add_argument("-V", "--is-enabled", action="store_true",
182
help="Check if client is enabled")
183
parser.add_argument("-r", "--remove", action="store_true",
184
help="Remove client")
185
parser.add_argument("-c", "--checker",
186
help="Set checker command for client")
187
parser.add_argument("-t", "--timeout",
188
help="Set timeout for client")
189
parser.add_argument("--extended-timeout",
190
help="Set extended timeout for client")
191
parser.add_argument("-i", "--interval",
192
help="Set checker interval for client")
193
parser.add_argument("--approve-by-default", action="store_true",
194
default=None, dest="approved_by_default",
195
help="Set client to be approved by default")
196
parser.add_argument("--deny-by-default", action="store_false",
197
dest="approved_by_default",
198
help="Set client to be denied by default")
199
parser.add_argument("--approval-delay",
200
help="Set delay before client approve/deny")
201
parser.add_argument("--approval-duration",
202
help="Set duration of one client approval")
203
parser.add_argument("-H", "--host", help="Set host for client")
204
parser.add_argument("-s", "--secret", type=file,
205
help="Set password blob (file) for client")
206
parser.add_argument("-A", "--approve", action="store_true",
207
help="Approve any current client request")
208
parser.add_argument("-D", "--deny", action="store_true",
209
help="Deny any current client request")
210
parser.add_argument("client", nargs="*", help="Client name")
211
options = parser.parse_args()
212
213
if has_actions(options) and not (options.client or options.all):
214
parser.error("Options require clients names or --all.")
215
if options.verbose and has_actions(options):
216
parser.error("--verbose can only be used alone or with"
217
" --all.")
218
if options.all and not has_actions(options):
219
parser.error("--all requires an action.")
220
221
try:
222
bus = dbus.SystemBus()
223
mandos_dbus_objc = bus.get_object(busname, server_path)
224
except dbus.exceptions.DBusException:
225
print("Could not connect to Mandos server",
226
file=sys.stderr)
227
sys.exit(1)
228
229
mandos_serv = dbus.Interface(mandos_dbus_objc,
230
dbus_interface = server_interface)
231
232
#block stderr since dbus library prints to stderr
233
null = os.open(os.path.devnull, os.O_RDWR)
234
stderrcopy = os.dup(sys.stderr.fileno())
235
os.dup2(null, sys.stderr.fileno())
236
os.close(null)
237
try:
238
try:
239
mandos_clients = mandos_serv.GetAllClientsWithProperties()
240
finally:
241
#restore stderr
242
os.dup2(stderrcopy, sys.stderr.fileno())
243
os.close(stderrcopy)
244
except dbus.exceptions.DBusException:
245
print("Access denied: Accessing mandos server through dbus.",
246
file=sys.stderr)
247
sys.exit(1)
248
249
# Compile dict of (clients: properties) to process
250
clients={}
251
252
if options.all or not options.client:
253
clients = dict((bus.get_object(busname, path), properties)
254
for path, properties in
255
mandos_clients.iteritems())
256
else:
257
for name in options.client:
258
for path, client in mandos_clients.iteritems():
259
if client["Name"] == name:
260
client_objc = bus.get_object(busname, path)
261
clients[client_objc] = client
262
break
268
263
else:
269
keywords = defaultkeywords
270
271
print_clients(clients.values(), keywords)
264
print("Client not found on server: {0!r}"
265
.format(name), file=sys.stderr)
266
sys.exit(1)
267
268
if not has_actions(options) and clients:
269
if options.verbose:
270
keywords = ("Name", "Enabled", "Timeout",
271
"LastCheckedOK", "Created", "Interval",
272
"Host", "Fingerprint", "CheckerRunning",
273
"LastEnabled", "ApprovalPending",
274
"ApprovedByDefault",
275
"LastApprovalRequest", "ApprovalDelay",
276
"ApprovalDuration", "Checker",
277
"ExtendedTimeout")
272
278
else:
273
# Process each client in the list by all selected options
274
for client in clients:
275
if options.remove:
276
mandos_serv.RemoveClient(client.__dbus_object_path__)
277
if options.enable:
278
client.Enable(dbus_interface=client_interface)
279
if options.disable:
280
client.Disable(dbus_interface=client_interface)
281
if options.bump_timeout:
282
client.CheckedOK(dbus_interface=client_interface)
283
if options.start_checker:
284
client.StartChecker(dbus_interface=client_interface)
285
if options.stop_checker:
286
client.StopChecker(dbus_interface=client_interface)
287
if options.is_enabled:
288
sys.exit(0 if client.Get(client_interface,
289
"Enabled",
290
dbus_interface=dbus.PROPERTIES_IFACE)
291
else 1)
292
if options.checker:
293
client.Set(client_interface, "Checker", options.checker,
294
dbus_interface=dbus.PROPERTIES_IFACE)
295
if options.host:
296
client.Set(client_interface, "Host", options.host,
297
dbus_interface=dbus.PROPERTIES_IFACE)
298
if options.interval:
299
client.Set(client_interface, "Interval",
300
timedelta_to_milliseconds
301
(string_to_delta(options.interval)),
302
dbus_interface=dbus.PROPERTIES_IFACE)
303
if options.approval_delay:
304
client.Set(client_interface, "ApprovalDelay",
305
timedelta_to_milliseconds
306
(string_to_delta(options.
307
approval_delay)),
308
dbus_interface=dbus.PROPERTIES_IFACE)
309
if options.approval_duration:
310
client.Set(client_interface, "ApprovalDuration",
311
timedelta_to_milliseconds
312
(string_to_delta(options.
313
approval_duration)),
314
dbus_interface=dbus.PROPERTIES_IFACE)
315
if options.timeout:
316
client.Set(client_interface, "Timeout",
317
timedelta_to_milliseconds
318
(string_to_delta(options.timeout)),
319
dbus_interface=dbus.PROPERTIES_IFACE)
320
if options.secret:
321
client.Set(client_interface, "Secret",
322
dbus.ByteArray(open(options.secret,
323
"rb").read()),
324
dbus_interface=dbus.PROPERTIES_IFACE)
325
if options.approved_by_default is not None:
326
client.Set(client_interface, "ApprovedByDefault",
327
dbus.Boolean(options
328
.approved_by_default),
329
dbus_interface=dbus.PROPERTIES_IFACE)
330
if options.approve:
331
client.Approve(dbus.Boolean(True),
332
dbus_interface=client_interface)
333
elif options.deny:
334
client.Approve(dbus.Boolean(False),
335
dbus_interface=client_interface)
279
keywords = defaultkeywords
280
281
print_clients(clients.values(), keywords)
282
else:
283
# Process each client in the list by all selected options
284
for client in clients:
285
def set_client_prop(prop, value):
286
"""Set a Client D-Bus property"""
287
client.Set(client_interface, prop, value,
288
dbus_interface=dbus.PROPERTIES_IFACE)
289
def set_client_prop_ms(prop, value):
290
"""Set a Client D-Bus property, converted
291
from a string to milliseconds."""
292
set_client_prop(prop,
293
timedelta_to_milliseconds
294
(string_to_delta(value)))
295
if options.remove:
296
mandos_serv.RemoveClient(client.__dbus_object_path__)
297
if options.enable:
298
set_client_prop("Enabled", dbus.Boolean(True))
299
if options.disable:
300
set_client_prop("Enabled", dbus.Boolean(False))
301
if options.bump_timeout:
302
set_client_prop("LastCheckedOK", "")
303
if options.start_checker:
304
set_client_prop("CheckerRunning", dbus.Boolean(True))
305
if options.stop_checker:
306
set_client_prop("CheckerRunning", dbus.Boolean(False))
307
if options.is_enabled:
308
sys.exit(0 if client.Get(client_interface,
309
"Enabled",
310
dbus_interface=
311
dbus.PROPERTIES_IFACE)
312
else 1)
313
if options.checker is not None:
314
set_client_prop("Checker", options.checker)
315
if options.host is not None:
316
set_client_prop("Host", options.host)
317
if options.interval is not None:
318
set_client_prop_ms("Interval", options.interval)
319
if options.approval_delay is not None:
320
set_client_prop_ms("ApprovalDelay",
321
options.approval_delay)
322
if options.approval_duration is not None:
323
set_client_prop_ms("ApprovalDuration",
324
options.approval_duration)
325
if options.timeout is not None:
326
set_client_prop_ms("Timeout", options.timeout)
327
if options.extended_timeout is not None:
328
set_client_prop_ms("ExtendedTimeout",
329
options.extended_timeout)
330
if options.secret is not None:
331
set_client_prop("Secret",
332
dbus.ByteArray(options.secret.read()))
333
if options.approved_by_default is not None:
334
set_client_prop("ApprovedByDefault",
335
dbus.Boolean(options
336
.approved_by_default))
337
if options.approve:
338
client.Approve(dbus.Boolean(True),
339
dbus_interface=client_interface)
340
elif options.deny:
341
client.Approve(dbus.Boolean(False),
342
dbus_interface=client_interface)
336
343
337
344
if __name__ == "__main__":
338
345
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0