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