/mandos/trunk

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

  • Committer: Teddy Hogeborn
  • Date: 2011-12-31 20:07:11 UTC
  • mfrom: (535.1.9 wireless-network-hook)
  • Revision ID: teddy@recompile.se-20111231200711-6dli3r8drftem57r
Merge new wireless network hook.  Fix bridge network hook to use
hardware addresses instead of interface names.  Implement and document
new "CONNECT" environment variable for network hooks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
3
3
# 
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
# 
6
 
# Copyright © 2008-2012 Teddy Hogeborn
7
 
# Copyright © 2008-2012 Björn Påhlsson
 
6
# Copyright © 2008-2011 Teddy Hogeborn
 
7
# Copyright © 2008-2011 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
60
60
server_path = "/"
61
61
server_interface = domain + ".Mandos"
62
62
client_interface = domain + ".Mandos.Client"
63
 
version = "1.5.3"
 
63
version = "1.4.1"
64
64
 
65
65
def timedelta_to_milliseconds(td):
66
66
    """Convert a datetime.timedelta object to milliseconds"""
70
70
 
71
71
def milliseconds_to_string(ms):
72
72
    td = datetime.timedelta(0, 0, 0, ms)
73
 
    return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
74
 
            .format(days = "{0}T".format(td.days) if td.days else "",
75
 
                    hours = td.seconds // 3600,
76
 
                    minutes = (td.seconds % 3600) // 60,
77
 
                    seconds = td.seconds % 60,
78
 
                    ))
 
73
    return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
 
74
            % { "days": "%dT" % td.days if td.days else "",
 
75
                "hours": td.seconds // 3600,
 
76
                "minutes": (td.seconds % 3600) // 60,
 
77
                "seconds": td.seconds % 60,
 
78
                })
79
79
 
80
80
def string_to_delta(interval):
81
81
    """Parse a string and return a datetime.timedelta
116
116
        if type(value) is dbus.Boolean:
117
117
            return "Yes" if value else "No"
118
118
        if keyword in ("Timeout", "Interval", "ApprovalDelay",
119
 
                       "ApprovalDuration", "ExtendedTimeout"):
 
119
                       "ApprovalDuration"):
120
120
            return milliseconds_to_string(value)
121
121
        return unicode(value)
122
122
    
123
123
    # Create format string to print table rows
124
 
    format_string = " ".join("{{{key}:{width}}}".format(
125
 
            width = max(len(tablewords[key]),
126
 
                        max(len(valuetostring(client[key],
127
 
                                              key))
128
 
                            for client in
129
 
                            clients)),
130
 
            key = key) for key in keywords)
 
124
    format_string = " ".join("%%-%ds" %
 
125
                             max(len(tablewords[key]),
 
126
                                 max(len(valuetostring(client[key],
 
127
                                                       key))
 
128
                                     for client in
 
129
                                     clients))
 
130
                             for key in keywords)
131
131
    # Print header line
132
 
    print(format_string.format(**tablewords))
 
132
    print(format_string % tuple(tablewords[key] for key in keywords))
133
133
    for client in clients:
134
 
        print(format_string.format(**dict((key,
135
 
                                           valuetostring(client[key],
136
 
                                                         key))
137
 
                                          for key in keywords)))
 
134
        print(format_string % tuple(valuetostring(client[key], key)
 
135
                                    for key in keywords))
138
136
 
139
137
def has_actions(options):
140
138
    return any((options.enable,
159
157
def main():
160
158
    parser = argparse.ArgumentParser()
161
159
    parser.add_argument("--version", action="version",
162
 
                        version = "%(prog)s {0}".format(version),
 
160
                        version = "%%prog %s" % version,
163
161
                        help="show version number and exit")
164
162
    parser.add_argument("-a", "--all", action="store_true",
165
163
                        help="Select all clients")
258
256
                    clients[client_objc] = client
259
257
                    break
260
258
            else:
261
 
                print("Client not found on server: {0!r}"
262
 
                      .format(name), file=sys.stderr)
 
259
                print("Client not found on server: %r" % name,
 
260
                      file=sys.stderr)
263
261
                sys.exit(1)
264
262
    
265
263
    if not has_actions(options) and clients:
279
277
    else:
280
278
        # Process each client in the list by all selected options
281
279
        for client in clients:
282
 
            def set_client_prop(prop, value):
283
 
                """Set a Client D-Bus property"""
284
 
                client.Set(client_interface, prop, value,
285
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
286
 
            def set_client_prop_ms(prop, value):
287
 
                """Set a Client D-Bus property, converted
288
 
                from a string to milliseconds."""
289
 
                set_client_prop(prop,
290
 
                                timedelta_to_milliseconds
291
 
                                (string_to_delta(value)))
292
280
            if options.remove:
293
281
                mandos_serv.RemoveClient(client.__dbus_object_path__)
294
282
            if options.enable:
295
 
                set_client_prop("Enabled", dbus.Boolean(True))
 
283
                client.Enable(dbus_interface=client_interface)
296
284
            if options.disable:
297
 
                set_client_prop("Enabled", dbus.Boolean(False))
 
285
                client.Disable(dbus_interface=client_interface)
298
286
            if options.bump_timeout:
299
 
                set_client_prop("LastCheckedOK", "")
 
287
                client.CheckedOK(dbus_interface=client_interface)
300
288
            if options.start_checker:
301
 
                set_client_prop("CheckerRunning", dbus.Boolean(True))
 
289
                client.StartChecker(dbus_interface=client_interface)
302
290
            if options.stop_checker:
303
 
                set_client_prop("CheckerRunning", dbus.Boolean(False))
 
291
                client.StopChecker(dbus_interface=client_interface)
304
292
            if options.is_enabled:
305
293
                sys.exit(0 if client.Get(client_interface,
306
294
                                         "Enabled",
308
296
                                         dbus.PROPERTIES_IFACE)
309
297
                         else 1)
310
298
            if options.checker is not None:
311
 
                set_client_prop("Checker", options.checker)
 
299
                client.Set(client_interface, "Checker",
 
300
                           options.checker,
 
301
                           dbus_interface=dbus.PROPERTIES_IFACE)
312
302
            if options.host is not None:
313
 
                set_client_prop("Host", options.host)
 
303
                client.Set(client_interface, "Host", options.host,
 
304
                           dbus_interface=dbus.PROPERTIES_IFACE)
314
305
            if options.interval is not None:
315
 
                set_client_prop_ms("Interval", options.interval)
 
306
                client.Set(client_interface, "Interval",
 
307
                           timedelta_to_milliseconds
 
308
                           (string_to_delta(options.interval)),
 
309
                           dbus_interface=dbus.PROPERTIES_IFACE)
316
310
            if options.approval_delay is not None:
317
 
                set_client_prop_ms("ApprovalDelay",
318
 
                                   options.approval_delay)
 
311
                client.Set(client_interface, "ApprovalDelay",
 
312
                           timedelta_to_milliseconds
 
313
                           (string_to_delta(options.
 
314
                                            approval_delay)),
 
315
                           dbus_interface=dbus.PROPERTIES_IFACE)
319
316
            if options.approval_duration is not None:
320
 
                set_client_prop_ms("ApprovalDuration",
321
 
                                   options.approval_duration)
 
317
                client.Set(client_interface, "ApprovalDuration",
 
318
                           timedelta_to_milliseconds
 
319
                           (string_to_delta(options.
 
320
                                            approval_duration)),
 
321
                           dbus_interface=dbus.PROPERTIES_IFACE)
322
322
            if options.timeout is not None:
323
 
                set_client_prop_ms("Timeout", options.timeout)
 
323
                client.Set(client_interface, "Timeout",
 
324
                           timedelta_to_milliseconds
 
325
                           (string_to_delta(options.timeout)),
 
326
                           dbus_interface=dbus.PROPERTIES_IFACE)
324
327
            if options.extended_timeout is not None:
325
 
                set_client_prop_ms("ExtendedTimeout",
326
 
                                   options.extended_timeout)
 
328
                client.Set(client_interface, "ExtendedTimeout",
 
329
                           timedelta_to_milliseconds
 
330
                           (string_to_delta(options.extended_timeout)),
 
331
                           dbus_interface=dbus.PROPERTIES_IFACE)
327
332
            if options.secret is not None:
328
 
                set_client_prop("Secret",
329
 
                                dbus.ByteArray(options.secret.read()))
 
333
                client.Set(client_interface, "Secret",
 
334
                           dbus.ByteArray(open(options.secret,
 
335
                                               "rb").read()),
 
336
                           dbus_interface=dbus.PROPERTIES_IFACE)
330
337
            if options.approved_by_default is not None:
331
 
                set_client_prop("ApprovedByDefault",
332
 
                                dbus.Boolean(options
333
 
                                             .approved_by_default))
 
338
                client.Set(client_interface, "ApprovedByDefault",
 
339
                           dbus.Boolean(options
 
340
                                        .approved_by_default),
 
341
                           dbus_interface=dbus.PROPERTIES_IFACE)
334
342
            if options.approve:
335
343
                client.Approve(dbus.Boolean(True),
336
344
                               dbus_interface=client_interface)