/mandos/release

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

  • Committer: teddy at bsnet
  • Date: 2011-02-15 19:27:23 UTC
  • mto: (237.7.13 mandos)
  • mto: This revision was merged to the branch mainline in revision 282.
  • Revision ID: teddy@fukt.bsnet.se-20110215192723-qpftjhlvzadm5cjc
* mandos-ctl: Use unicode string literals.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
22
22
# Contact the authors at <mandos@fukt.bsnet.se>.
23
23
# 
24
24
 
25
 
from __future__ import (division, absolute_import, print_function,
26
 
                        unicode_literals)
 
25
from __future__ import division, absolute_import, unicode_literals
27
26
 
28
27
import sys
29
28
import dbus
30
 
import argparse
 
29
from optparse import OptionParser
31
30
import locale
32
31
import datetime
33
32
import re
59
58
server_path = "/"
60
59
server_interface = domain + ".Mandos"
61
60
client_interface = domain + ".Mandos.Client"
62
 
version = "1.3.0"
 
61
version = "1.2.3"
63
62
 
64
63
def timedelta_to_milliseconds(td):
65
64
    """Convert a datetime.timedelta object to milliseconds"""
76
75
                "seconds": td.seconds % 60,
77
76
                })
78
77
 
 
78
 
79
79
def string_to_delta(interval):
80
80
    """Parse a string and return a datetime.timedelta
81
 
    
 
81
 
82
82
    >>> string_to_delta("7d")
83
83
    datetime.timedelta(7)
84
84
    >>> string_to_delta("60s")
134
134
                                     clients))
135
135
                             for key in keywords)
136
136
    # Print header line
137
 
    print(format_string % tuple(tablewords[key] for key in keywords))
 
137
    print format_string % tuple(tablewords[key] for key in keywords)
138
138
    for client in clients:
139
 
        print(format_string % tuple(valuetostring(client[key], key)
140
 
                                    for key in keywords))
 
139
        print format_string % tuple(valuetostring(client[key], key)
 
140
                                    for key in keywords)
141
141
 
142
142
def has_actions(options):
143
143
    return any((options.enable,
157
157
                options.secret is not None,
158
158
                options.approve,
159
159
                options.deny))
160
 
 
 
160
        
161
161
def main():
162
 
    parser = argparse.ArgumentParser()
163
 
    parser.add_argument("--version", action="version",
164
 
                        version = "%%prog %s" % version,
165
 
                        help="show version number and exit")
166
 
    parser.add_argument("-a", "--all", action="store_true",
167
 
                        help="Select all clients")
168
 
    parser.add_argument("-v", "--verbose", action="store_true",
169
 
                        help="Print all fields")
170
 
    parser.add_argument("-e", "--enable", action="store_true",
171
 
                        help="Enable client")
172
 
    parser.add_argument("-d", "--disable", action="store_true",
173
 
                        help="disable client")
174
 
    parser.add_argument("-b", "--bump-timeout", action="store_true",
175
 
                        help="Bump timeout for client")
176
 
    parser.add_argument("--start-checker", action="store_true",
177
 
                        help="Start checker for client")
178
 
    parser.add_argument("--stop-checker", action="store_true",
179
 
                        help="Stop checker for client")
180
 
    parser.add_argument("-V", "--is-enabled", action="store_true",
181
 
                        help="Check if client is enabled")
182
 
    parser.add_argument("-r", "--remove", action="store_true",
183
 
                        help="Remove client")
184
 
    parser.add_argument("-c", "--checker",
185
 
                        help="Set checker command for client")
186
 
    parser.add_argument("-t", "--timeout",
187
 
                        help="Set timeout for client")
188
 
    parser.add_argument("-i", "--interval",
189
 
                        help="Set checker interval for client")
190
 
    parser.add_argument("--approve-by-default", action="store_true",
191
 
                        default=None, dest="approved_by_default",
192
 
                        help="Set client to be approved by default")
193
 
    parser.add_argument("--deny-by-default", action="store_false",
194
 
                        dest="approved_by_default",
195
 
                        help="Set client to be denied by default")
196
 
    parser.add_argument("--approval-delay",
197
 
                        help="Set delay before client approve/deny")
198
 
    parser.add_argument("--approval-duration",
199
 
                        help="Set duration of one client approval")
200
 
    parser.add_argument("-H", "--host", help="Set host for client")
201
 
    parser.add_argument("-s", "--secret", type=file,
202
 
                        help="Set password blob (file) for client")
203
 
    parser.add_argument("-A", "--approve", action="store_true",
204
 
                        help="Approve any current client request")
205
 
    parser.add_argument("-D", "--deny", action="store_true",
206
 
                        help="Deny any current client request")
207
 
    parser.add_argument("client", nargs="*", help="Client name")
208
 
    options = parser.parse_args()
209
 
    
210
 
    if has_actions(options) and not options.client and not options.all:
211
 
        parser.error("Options require clients names or --all.")
212
 
    if options.verbose and has_actions(options):
213
 
        parser.error("--verbose can only be used alone or with"
214
 
                     " --all.")
215
 
    if options.all and not has_actions(options):
216
 
        parser.error("--all requires an action.")
217
 
    
218
 
    try:
219
 
        bus = dbus.SystemBus()
220
 
        mandos_dbus_objc = bus.get_object(busname, server_path)
221
 
    except dbus.exceptions.DBusException:
222
 
        print("Could not connect to Mandos server",
223
 
              file=sys.stderr)
224
 
        sys.exit(1)
225
 
    
226
 
    mandos_serv = dbus.Interface(mandos_dbus_objc,
227
 
                                 dbus_interface = server_interface)
228
 
    
229
 
    #block stderr since dbus library prints to stderr
230
 
    null = os.open(os.path.devnull, os.O_RDWR)
231
 
    stderrcopy = os.dup(sys.stderr.fileno())
232
 
    os.dup2(null, sys.stderr.fileno())
233
 
    os.close(null)
234
 
    try:
235
 
        try:
236
 
            mandos_clients = mandos_serv.GetAllClientsWithProperties()
237
 
        finally:
238
 
            #restore stderr
239
 
            os.dup2(stderrcopy, sys.stderr.fileno())
240
 
            os.close(stderrcopy)
241
 
    except dbus.exceptions.DBusException, e:
242
 
        print("Access denied: Accessing mandos server through dbus.",
243
 
              file=sys.stderr)
244
 
        sys.exit(1)
245
 
    
246
 
    # Compile dict of (clients: properties) to process
247
 
    clients={}
248
 
    
249
 
    if options.all or not options.client:
250
 
        clients = dict((bus.get_object(busname, path), properties)
251
 
                       for path, properties in
252
 
                       mandos_clients.iteritems())
253
 
    else:
254
 
        for name in options.client:
255
 
            for path, client in mandos_clients.iteritems():
256
 
                if client["Name"] == name:
257
 
                    client_objc = bus.get_object(busname, path)
258
 
                    clients[client_objc] = client
259
 
                    break
 
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")
260
268
            else:
261
 
                print("Client not found on server: %r" % name,
262
 
                      file=sys.stderr)
263
 
                sys.exit(1)
264
 
    
265
 
    if not has_actions(options) and clients:
266
 
        if options.verbose:
267
 
            keywords = ("Name", "Enabled", "Timeout",
268
 
                        "LastCheckedOK", "Created", "Interval",
269
 
                        "Host", "Fingerprint", "CheckerRunning",
270
 
                        "LastEnabled", "ApprovalPending",
271
 
                        "ApprovedByDefault",
272
 
                        "LastApprovalRequest", "ApprovalDelay",
273
 
                        "ApprovalDuration", "Checker")
 
269
                keywords = defaultkeywords
 
270
            
 
271
            print_clients(clients.values(), keywords)
274
272
        else:
275
 
            keywords = defaultkeywords
276
 
        
277
 
        print_clients(clients.values(), keywords)
278
 
    else:
279
 
        # Process each client in the list by all selected options
280
 
        for client in clients:
281
 
            if options.remove:
282
 
                mandos_serv.RemoveClient(client.__dbus_object_path__)
283
 
            if options.enable:
284
 
                client.Enable(dbus_interface=client_interface)
285
 
            if options.disable:
286
 
                client.Disable(dbus_interface=client_interface)
287
 
            if options.bump_timeout:
288
 
                client.CheckedOK(dbus_interface=client_interface)
289
 
            if options.start_checker:
290
 
                client.StartChecker(dbus_interface=client_interface)
291
 
            if options.stop_checker:
292
 
                client.StopChecker(dbus_interface=client_interface)
293
 
            if options.is_enabled:
294
 
                sys.exit(0 if client.Get(client_interface,
295
 
                                         "Enabled",
296
 
                                         dbus_interface=
297
 
                                         dbus.PROPERTIES_IFACE)
298
 
                         else 1)
299
 
            if options.checker:
300
 
                client.Set(client_interface, "Checker",
301
 
                           options.checker,
302
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
303
 
            if options.host:
304
 
                client.Set(client_interface, "Host", options.host,
305
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
306
 
            if options.interval:
307
 
                client.Set(client_interface, "Interval",
308
 
                           timedelta_to_milliseconds
309
 
                           (string_to_delta(options.interval)),
310
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
311
 
            if options.approval_delay:
312
 
                client.Set(client_interface, "ApprovalDelay",
313
 
                           timedelta_to_milliseconds
314
 
                           (string_to_delta(options.
315
 
                                            approval_delay)),
316
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
317
 
            if options.approval_duration:
318
 
                client.Set(client_interface, "ApprovalDuration",
319
 
                           timedelta_to_milliseconds
320
 
                           (string_to_delta(options.
321
 
                                            approval_duration)),
322
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
323
 
            if options.timeout:
324
 
                client.Set(client_interface, "Timeout",
325
 
                           timedelta_to_milliseconds
326
 
                           (string_to_delta(options.timeout)),
327
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
328
 
            if options.secret:
329
 
                client.Set(client_interface, "Secret",
330
 
                           dbus.ByteArray(open(options.secret,
331
 
                                               "rb").read()),
332
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
333
 
            if options.approved_by_default is not None:
334
 
                client.Set(client_interface, "ApprovedByDefault",
335
 
                           dbus.Boolean(options
336
 
                                        .approved_by_default),
337
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
338
 
            if options.approve:
339
 
                client.Approve(dbus.Boolean(True),
340
 
                               dbus_interface=client_interface)
341
 
            elif options.deny:
342
 
                client.Approve(dbus.Boolean(False),
343
 
                               dbus_interface=client_interface)
 
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)
344
336
 
345
337
if __name__ == "__main__":
346
338
    main()