/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

Merge in branch to interpret an empty device name to mean
"autodetect".

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
8
8
import locale
9
9
import datetime
10
10
import re
11
 
import os
12
11
 
13
12
locale.setlocale(locale.LC_ALL, u'')
14
13
 
15
14
tablewords = {
16
 
    'Name': u'Name',
17
 
    'Enabled': u'Enabled',
18
 
    'Timeout': u'Timeout',
19
 
    'LastCheckedOK': u'Last Successful Check',
20
 
    'Created': u'Created',
21
 
    'Interval': u'Interval',
22
 
    'Host': u'Host',
23
 
    'Fingerprint': u'Fingerprint',
24
 
    'CheckerRunning': u'Check Is Running',
25
 
    'LastEnabled': u'Last Enabled',
26
 
    'Checker': u'Checker',
 
15
    'name': u'Name',
 
16
    'enabled': u'Enabled',
 
17
    'timeout': u'Timeout',
 
18
    'last_checked_ok': u'Last Successful Check',
 
19
    'created': u'Created',
 
20
    'interval': u'Interval',
 
21
    'host': u'Host',
 
22
    'fingerprint': u'Fingerprint',
 
23
    'checker_running': u'Check Is Running',
 
24
    'last_enabled': u'Last Enabled',
 
25
    'checker': u'Checker',
27
26
    }
28
 
defaultkeywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK')
 
27
defaultkeywords = ('name', 'enabled', 'timeout', 'last_checked_ok')
29
28
domain = 'se.bsnet.fukt'
30
29
busname = domain + '.Mandos'
31
30
server_path = '/'
32
31
server_interface = domain + '.Mandos'
33
32
client_interface = domain + '.Mandos.Client'
34
33
version = "1.0.14"
 
34
bus = dbus.SystemBus()
 
35
mandos_dbus_objc = bus.get_object(busname, server_path)
 
36
mandos_serv = dbus.Interface(mandos_dbus_objc,
 
37
                             dbus_interface = server_interface)
 
38
mandos_clients = mandos_serv.GetAllClientsWithProperties()
35
39
 
36
40
def timedelta_to_milliseconds(td):
37
41
    "Convert a datetime.timedelta object to milliseconds"
89
93
        timevalue += delta
90
94
    return timevalue
91
95
 
92
 
def print_clients(clients, keywords):
 
96
def print_clients(clients):
93
97
    def valuetostring(value, keyword):
94
98
        if type(value) is dbus.Boolean:
95
99
            return u"Yes" if value else u"No"
100
104
    # Create format string to print table rows
101
105
    format_string = u' '.join(u'%%-%ds' %
102
106
                              max(len(tablewords[key]),
103
 
                                  max(len(valuetostring(client[key],
104
 
                                                        key))
 
107
                                  max(len(valuetostring(client[key], key))
105
108
                                      for client in
106
109
                                      clients))
107
110
                              for key in keywords)
110
113
    for client in clients:
111
114
        print format_string % tuple(valuetostring(client[key], key)
112
115
                                    for key in keywords)
113
 
def has_actions(options):
114
 
    return any((options.enable,
115
 
                options.disable,
116
 
                options.bump_timeout,
117
 
                options.start_checker,
118
 
                options.stop_checker,
119
 
                options.is_enabled,
120
 
                options.remove,
121
 
                options.checker is not None,
122
 
                options.timeout is not None,
123
 
                options.interval is not None,
124
 
                options.host is not None,
125
 
                options.secret is not None,
126
 
                options.approve,
127
 
                options.deny))
128
 
        
129
 
def main():
130
 
        parser = OptionParser(version = "%%prog %s" % version)
131
 
        parser.add_option("-a", "--all", action="store_true",
132
 
                          help="Select all clients")
133
 
        parser.add_option("-v", "--verbose", action="store_true",
134
 
                          help="Print all fields")
135
 
        parser.add_option("-e", "--enable", action="store_true",
136
 
                          help="Enable client")
137
 
        parser.add_option("-d", "--disable", action="store_true",
138
 
                          help="disable client")
139
 
        parser.add_option("-b", "--bump-timeout", action="store_true",
140
 
                          help="Bump timeout for client")
141
 
        parser.add_option("--start-checker", action="store_true",
142
 
                          help="Start checker for client")
143
 
        parser.add_option("--stop-checker", action="store_true",
144
 
                          help="Stop checker for client")
145
 
        parser.add_option("-V", "--is-enabled", action="store_true",
146
 
                          help="Check if client is enabled")
147
 
        parser.add_option("-r", "--remove", action="store_true",
148
 
                          help="Remove client")
149
 
        parser.add_option("-c", "--checker", type="string",
150
 
                          help="Set checker command for client")
151
 
        parser.add_option("-t", "--timeout", type="string",
152
 
                          help="Set timeout for client")
153
 
        parser.add_option("-i", "--interval", type="string",
154
 
                          help="Set checker interval for client")
155
 
        parser.add_option("-H", "--host", type="string",
156
 
                          help="Set host for client")
157
 
        parser.add_option("-s", "--secret", type="string",
158
 
                          help="Set password blob (file) for client")
159
 
        parser.add_option("-A", "--approve", action="store_true",
160
 
                          help="Approve any current client request")
161
 
        parser.add_option("-D", "--deny", action="store_true",
162
 
                          help="Deny any current client request")
163
 
        options, client_names = parser.parse_args()
164
 
        
165
 
        if has_actions(options) and not client_names and not options.all:
166
 
            parser.error('Options requires clients names or --all.')
167
 
        if options.verbose and has_actions(options):
168
 
            parser.error('Verbose option can only be used alone or with --all.')
169
 
        if options.all and not has_actions(options):
170
 
            parser.error('--all requires an action')
171
 
            
172
 
        try:
173
 
            bus = dbus.SystemBus()
174
 
            mandos_dbus_objc = bus.get_object(busname, server_path)
175
 
        except dbus.exceptions.DBusException:
176
 
            print >> sys.stderr, "Could not connect to Mandos server"
177
 
            sys.exit(1)
178
 
    
179
 
        mandos_serv = dbus.Interface(mandos_dbus_objc,
180
 
                                     dbus_interface = server_interface)
181
 
 
182
 
        #block stderr since dbus library prints to stderr
183
 
        null = os.open(os.path.devnull, os.O_RDWR)
184
 
        stderrcopy = os.dup(sys.stderr.fileno())
185
 
        os.dup2(null, sys.stderr.fileno())
186
 
        os.close(null)
187
 
        try:
188
 
            try:
189
 
                mandos_clients = mandos_serv.GetAllClientsWithProperties()
190
 
            finally:
191
 
                #restore stderr
192
 
                os.dup2(stderrcopy, sys.stderr.fileno())
193
 
                os.close(stderrcopy)
194
 
        except dbus.exceptions.DBusException, e:
195
 
            print >> sys.stderr, "Access denied: Accessing mandos server through dbus."
196
 
            sys.exit(1)
197
 
            
198
 
        # Compile dict of (clients: properties) to process
199
 
        clients={}
200
 
        
201
 
        if options.all or not client_names:
202
 
            clients = dict((bus.get_object(busname, path), properties)
203
 
                           for path, properties in
204
 
                           mandos_clients.iteritems())
205
 
        else:
206
 
            for name in client_names:
207
 
                for path, client in mandos_clients.iteritems():
208
 
                    if client['Name'] == name:
209
 
                        client_objc = bus.get_object(busname, path)
210
 
                        clients[client_objc] = client
211
 
                        break
212
 
                else:
213
 
                    print >> sys.stderr, "Client not found on server: %r" % name
214
 
                    sys.exit(1)
215
 
            
216
 
        if not has_actions(options) and clients:
217
 
            if options.verbose:
218
 
                keywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK',
219
 
                            'Created', 'Interval', 'Host', 'Fingerprint',
220
 
                            'CheckerRunning', 'LastEnabled', 'Checker')
221
 
            else:
222
 
                keywords = defaultkeywords
223
 
                
224
 
            print_clients(clients.values(), keywords)
225
 
        else:
226
 
            # Process each client in the list by all selected options
227
 
            for client in clients:
228
 
                if options.remove:
229
 
                    mandos_serv.RemoveClient(client.__dbus_object_path__)
230
 
                if options.enable:
231
 
                    client.Enable(dbus_interface=client_interface)
232
 
                if options.disable:
233
 
                    client.Disable(dbus_interface=client_interface)
234
 
                if options.bump_timeout:
235
 
                    client.CheckedOK(dbus_interface=client_interface)
236
 
                if options.start_checker:
237
 
                    client.StartChecker(dbus_interface=client_interface)
238
 
                if options.stop_checker:
239
 
                    client.StopChecker(dbus_interface=client_interface)
240
 
                if options.is_enabled:
241
 
                    sys.exit(0 if client.Get(client_interface,
242
 
                                             u"Enabled",
243
 
                                             dbus_interface=dbus.PROPERTIES_IFACE)
244
 
                             else 1)
245
 
                if options.checker:
246
 
                    client.Set(client_interface, u"Checker", options.checker,
247
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
248
 
                if options.host:
249
 
                    client.Set(client_interface, u"Host", options.host,
250
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
251
 
                if options.interval:
252
 
                    client.Set(client_interface, u"Interval",
253
 
                               timedelta_to_milliseconds
254
 
                               (string_to_delta(options.interval)),
255
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
256
 
                if options.timeout:
257
 
                    client.Set(client_interface, u"Timeout",
258
 
                               timedelta_to_milliseconds(string_to_delta
259
 
                                                         (options.timeout)),
260
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
261
 
                if options.secret:
262
 
                    client.Set(client_interface, u"Secret",
263
 
                               dbus.ByteArray(open(options.secret, u'rb').read()),
264
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
265
 
                if options.approve:
266
 
                    client.Approve(dbus.Boolean(True), dbus_interface=client_interface)
267
 
                if options.deny:
268
 
                    client.Approve(dbus.Boolean(False), dbus_interface=client_interface)
269
 
 
270
 
if __name__ == '__main__':
271
 
    main()
 
116
 
 
117
parser = OptionParser(version = "%%prog %s" % version)
 
118
parser.add_option("-a", "--all", action="store_true",
 
119
                  help="Print all fields")
 
120
parser.add_option("-e", "--enable", action="store_true",
 
121
                  help="Enable client")
 
122
parser.add_option("-d", "--disable", action="store_true",
 
123
                  help="disable client")
 
124
parser.add_option("-b", "--bump-timeout", action="store_true",
 
125
                  help="Bump timeout for client")
 
126
parser.add_option("--start-checker", action="store_true",
 
127
                  help="Start checker for client")
 
128
parser.add_option("--stop-checker", action="store_true",
 
129
                  help="Stop checker for client")
 
130
parser.add_option("-V", "--is-enabled", action="store_true",
 
131
                  help="Check if client is enabled")
 
132
parser.add_option("-r", "--remove", action="store_true",
 
133
                  help="Remove client")
 
134
parser.add_option("-c", "--checker", type="string",
 
135
                  help="Set checker command for client")
 
136
parser.add_option("-t", "--timeout", type="string",
 
137
                  help="Set timeout for client")
 
138
parser.add_option("-i", "--interval", type="string",
 
139
                  help="Set checker interval for client")
 
140
parser.add_option("-H", "--host", type="string",
 
141
                  help="Set host for client")
 
142
parser.add_option("-s", "--secret", type="string",
 
143
                  help="Set password blob (file) for client")
 
144
options, client_names = parser.parse_args()
 
145
 
 
146
# Compile list of clients to process
 
147
clients=[]
 
148
for name in client_names:
 
149
    for path, client in mandos_clients.iteritems():
 
150
        if client['name'] == name:
 
151
            client_objc = bus.get_object(busname, path)
 
152
            clients.append(client_objc)
 
153
            break
 
154
    else:
 
155
        print >> sys.stderr, "Client not found on server: %r" % name
 
156
        sys.exit(1)
 
157
 
 
158
if not clients and mandos_clients.values():
 
159
    keywords = defaultkeywords
 
160
    if options.all:
 
161
        keywords = ('name', 'enabled', 'timeout', 'last_checked_ok',
 
162
                    'created', 'interval', 'host', 'fingerprint',
 
163
                    'checker_running', 'last_enabled', 'checker')
 
164
    print_clients(mandos_clients.values())
 
165
 
 
166
# Process each client in the list by all selected options
 
167
for client in clients:
 
168
    if options.remove:
 
169
        mandos_serv.RemoveClient(client.__dbus_object_path__)
 
170
    if options.enable:
 
171
        client.Enable(dbus_interface=client_interface)
 
172
    if options.disable:
 
173
        client.Disable(dbus_interface=client_interface)
 
174
    if options.bump_timeout:
 
175
        client.CheckedOK(dbus_interface=client_interface)
 
176
    if options.start_checker:
 
177
        client.StartChecker(dbus_interface=client_interface)
 
178
    if options.stop_checker:
 
179
        client.StopChecker(dbus_interface=client_interface)
 
180
    if options.is_enabled:
 
181
        sys.exit(0 if client.Get(client_interface,
 
182
                                 u"enabled",
 
183
                                 dbus_interface=dbus.PROPERTIES_IFACE)
 
184
                 else 1)
 
185
    if options.checker:
 
186
        client.Set(client_interface, u"checker", options.checker,
 
187
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
188
    if options.host:
 
189
        client.Set(client_interface, u"host", options.host,
 
190
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
191
    if options.interval:
 
192
        client.Set(client_interface, u"interval",
 
193
                   timedelta_to_milliseconds
 
194
                   (string_to_delta(options.interval)),
 
195
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
196
    if options.timeout:
 
197
        client.Set(client_interface, u"timeout",
 
198
                   timedelta_to_milliseconds(string_to_delta
 
199
                                             (options.timeout)),
 
200
                   dbus_interface=dbus.PROPERTIES_IFACE)
 
201
    if options.secret:
 
202
        client.Set(client_interface, u"secret",
 
203
                   dbus.ByteArray(open(options.secret, u'rb').read()),
 
204
                   dbus_interface=dbus.PROPERTIES_IFACE)