/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: 2010-10-11 17:45:21 UTC
  • mto: (237.4.29 release)
  • mto: This revision was merged to the branch mainline in revision 459.
  • Revision ID: teddy@fukt.bsnet.se-20101011174521-e8we3lh7p0ns3oba
Tags: version-1.2.3-1
* Makefile (version): Changed to "1.2.3".
* NEWS (Version 1.2.3): New entry.
* debian/changelog (1.2.3-1): - '' -

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