/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: 2015-07-20 03:03:33 UTC
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

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-2015 Teddy Hogeborn
 
7
# Copyright © 2008-2015 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
 
21
# <http://www.gnu.org/licenses/>.
 
22
# 
 
23
# Contact the authors at <mandos@recompile.se>.
 
24
# 
 
25
 
 
26
from __future__ import (division, absolute_import, print_function,
 
27
                        unicode_literals)
 
28
 
 
29
try:
 
30
    from future_builtins import *
 
31
except ImportError:
 
32
    pass
 
33
 
5
34
import sys
6
 
import dbus
7
 
from optparse import OptionParser
 
35
import argparse
8
36
import locale
9
37
import datetime
10
38
import re
11
 
 
12
 
locale.setlocale(locale.LC_ALL, u'')
 
39
import os
 
40
import collections
 
41
import doctest
 
42
 
 
43
import dbus
 
44
 
 
45
if sys.version_info.major == 2:
 
46
    str = unicode
 
47
 
 
48
locale.setlocale(locale.LC_ALL, "")
13
49
 
14
50
tablewords = {
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',
26
 
    }
27
 
defaultkeywords = ('name', 'enabled', 'timeout', 'last_checked_ok',
28
 
                   'checker')
29
 
busname = 'org.mandos-system.Mandos'
30
 
server_path = '/Mandos'
31
 
server_interface = 'org.mandos_system.Mandos'
32
 
client_interface = 'org.mandos_system.Mandos.Client'
33
 
version = "1.0.4"
34
 
 
35
 
bus = dbus.SystemBus()
36
 
mandos_dbus_objc = bus.get_object(busname, server_path)
37
 
mandos_serv = dbus.Interface(mandos_dbus_objc,
38
 
                             dbus_interface = server_interface)
39
 
mandos_clients = mandos_serv.GetAllClientsWithProperties()
40
 
 
41
 
def datetime_to_milliseconds(dt):
42
 
    "Return the 'timeout' attribute in milliseconds"
43
 
    return ((dt.days * 24 * 60 * 60 * 1000)
44
 
            + (dt.seconds * 1000)
45
 
            + (dt.microseconds // 1000))
 
51
    "Name": "Name",
 
52
    "Enabled": "Enabled",
 
53
    "Timeout": "Timeout",
 
54
    "LastCheckedOK": "Last Successful Check",
 
55
    "LastApprovalRequest": "Last Approval Request",
 
56
    "Created": "Created",
 
57
    "Interval": "Interval",
 
58
    "Host": "Host",
 
59
    "Fingerprint": "Fingerprint",
 
60
    "CheckerRunning": "Check Is Running",
 
61
    "LastEnabled": "Last Enabled",
 
62
    "ApprovalPending": "Approval Is Pending",
 
63
    "ApprovedByDefault": "Approved By Default",
 
64
    "ApprovalDelay": "Approval Delay",
 
65
    "ApprovalDuration": "Approval Duration",
 
66
    "Checker": "Checker",
 
67
    "ExtendedTimeout": "Extended Timeout"
 
68
}
 
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
 
70
domain = "se.recompile"
 
71
busname = domain + ".Mandos"
 
72
server_path = "/"
 
73
server_interface = domain + ".Mandos"
 
74
client_interface = domain + ".Mandos.Client"
 
75
version = "1.6.9"
 
76
 
46
77
 
47
78
def milliseconds_to_string(ms):
48
79
    td = datetime.timedelta(0, 0, 0, ms)
49
 
    return "%s%02d:%02d:%02d" % (("%dT" % td.days) if td.days else "", # days
50
 
                           td.seconds // 3600,        # hours
51
 
                           (td.seconds % 3600) // 60, # minutes
52
 
                           (td.seconds % 60))         # seconds
 
80
    return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
 
81
        days = "{}T".format(td.days) if td.days else "",
 
82
        hours = td.seconds // 3600,
 
83
        minutes = (td.seconds % 3600) // 60,
 
84
        seconds = td.seconds % 60))
 
85
 
 
86
 
 
87
def rfc3339_duration_to_delta(duration):
 
88
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
89
    
 
90
    >>> rfc3339_duration_to_delta("P7D")
 
91
    datetime.timedelta(7)
 
92
    >>> rfc3339_duration_to_delta("PT60S")
 
93
    datetime.timedelta(0, 60)
 
94
    >>> rfc3339_duration_to_delta("PT60M")
 
95
    datetime.timedelta(0, 3600)
 
96
    >>> rfc3339_duration_to_delta("PT24H")
 
97
    datetime.timedelta(1)
 
98
    >>> rfc3339_duration_to_delta("P1W")
 
99
    datetime.timedelta(7)
 
100
    >>> rfc3339_duration_to_delta("PT5M30S")
 
101
    datetime.timedelta(0, 330)
 
102
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
103
    datetime.timedelta(1, 200)
 
104
    """
 
105
    
 
106
    # Parsing an RFC 3339 duration with regular expressions is not
 
107
    # possible - there would have to be multiple places for the same
 
108
    # values, like seconds.  The current code, while more esoteric, is
 
109
    # cleaner without depending on a parsing library.  If Python had a
 
110
    # built-in library for parsing we would use it, but we'd like to
 
111
    # avoid excessive use of external libraries.
 
112
    
 
113
    # New type for defining tokens, syntax, and semantics all-in-one
 
114
    Token = collections.namedtuple("Token", (
 
115
        "regexp",  # To match token; if "value" is not None, must have
 
116
                   # a "group" containing digits
 
117
        "value",   # datetime.timedelta or None
 
118
        "followers"))           # Tokens valid after this token
 
119
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
120
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
121
    token_end = Token(re.compile(r"$"), None, frozenset())
 
122
    token_second = Token(re.compile(r"(\d+)S"),
 
123
                         datetime.timedelta(seconds=1),
 
124
                         frozenset((token_end, )))
 
125
    token_minute = Token(re.compile(r"(\d+)M"),
 
126
                         datetime.timedelta(minutes=1),
 
127
                         frozenset((token_second, token_end)))
 
128
    token_hour = Token(re.compile(r"(\d+)H"),
 
129
                       datetime.timedelta(hours=1),
 
130
                       frozenset((token_minute, token_end)))
 
131
    token_time = Token(re.compile(r"T"),
 
132
                       None,
 
133
                       frozenset((token_hour, token_minute,
 
134
                                  token_second)))
 
135
    token_day = Token(re.compile(r"(\d+)D"),
 
136
                      datetime.timedelta(days=1),
 
137
                      frozenset((token_time, token_end)))
 
138
    token_month = Token(re.compile(r"(\d+)M"),
 
139
                        datetime.timedelta(weeks=4),
 
140
                        frozenset((token_day, token_end)))
 
141
    token_year = Token(re.compile(r"(\d+)Y"),
 
142
                       datetime.timedelta(weeks=52),
 
143
                       frozenset((token_month, token_end)))
 
144
    token_week = Token(re.compile(r"(\d+)W"),
 
145
                       datetime.timedelta(weeks=1),
 
146
                       frozenset((token_end, )))
 
147
    token_duration = Token(re.compile(r"P"), None,
 
148
                           frozenset((token_year, token_month,
 
149
                                      token_day, token_time,
 
150
                                      token_week)))
 
151
    # Define starting values
 
152
    value = datetime.timedelta() # Value so far
 
153
    found_token = None
 
154
    followers = frozenset((token_duration, )) # Following valid tokens
 
155
    s = duration                # String left to parse
 
156
    # Loop until end token is found
 
157
    while found_token is not token_end:
 
158
        # Search for any currently valid tokens
 
159
        for token in followers:
 
160
            match = token.regexp.match(s)
 
161
            if match is not None:
 
162
                # Token found
 
163
                if token.value is not None:
 
164
                    # Value found, parse digits
 
165
                    factor = int(match.group(1), 10)
 
166
                    # Add to value so far
 
167
                    value += factor * token.value
 
168
                # Strip token from string
 
169
                s = token.regexp.sub("", s, 1)
 
170
                # Go to found token
 
171
                found_token = token
 
172
                # Set valid next tokens
 
173
                followers = found_token.followers
 
174
                break
 
175
        else:
 
176
            # No currently valid tokens were found
 
177
            raise ValueError("Invalid RFC 3339 duration: {!r}"
 
178
                             .format(duration))
 
179
    # End token found
 
180
    return value
53
181
 
54
182
 
55
183
def string_to_delta(interval):
56
184
    """Parse a string and return a datetime.timedelta
57
 
 
 
185
    
58
186
    >>> string_to_delta('7d')
59
187
    datetime.timedelta(7)
60
188
    >>> string_to_delta('60s')
63
191
    datetime.timedelta(0, 3600)
64
192
    >>> string_to_delta('24h')
65
193
    datetime.timedelta(1)
66
 
    >>> string_to_delta(u'1w')
 
194
    >>> string_to_delta('1w')
67
195
    datetime.timedelta(7)
68
196
    >>> string_to_delta('5m 30s')
69
197
    datetime.timedelta(0, 330)
70
198
    """
71
 
    timevalue = datetime.timedelta(0)
72
 
    regexp = re.compile("\d+[dsmhw]")
73
 
    
74
 
    for s in regexp.findall(interval):
75
 
        try:
76
 
            suffix = unicode(s[-1])
77
 
            value = int(s[:-1])
78
 
            if suffix == u"d":
79
 
                delta = datetime.timedelta(value)
80
 
            elif suffix == u"s":
81
 
                delta = datetime.timedelta(0, value)
82
 
            elif suffix == u"m":
83
 
                delta = datetime.timedelta(0, 0, 0, 0, value)
84
 
            elif suffix == u"h":
85
 
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
86
 
            elif suffix == u"w":
87
 
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
88
 
            else:
89
 
                raise ValueError
90
 
        except (ValueError, IndexError):
91
 
            raise ValueError
92
 
        timevalue += delta
93
 
    return timevalue
94
 
 
95
 
def print_clients(clients):
 
199
    
 
200
    try:
 
201
        return rfc3339_duration_to_delta(interval)
 
202
    except ValueError:
 
203
        pass
 
204
    
 
205
    value = datetime.timedelta(0)
 
206
    regexp = re.compile(r"(\d+)([dsmhw]?)")
 
207
    
 
208
    for num, suffix in regexp.findall(interval):
 
209
        if suffix == "d":
 
210
            value += datetime.timedelta(int(num))
 
211
        elif suffix == "s":
 
212
            value += datetime.timedelta(0, int(num))
 
213
        elif suffix == "m":
 
214
            value += datetime.timedelta(0, 0, 0, 0, int(num))
 
215
        elif suffix == "h":
 
216
            value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
 
217
        elif suffix == "w":
 
218
            value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
 
219
        elif suffix == "":
 
220
            value += datetime.timedelta(0, 0, 0, int(num))
 
221
    return value
 
222
 
 
223
 
 
224
def print_clients(clients, keywords):
96
225
    def valuetostring(value, keyword):
97
226
        if type(value) is dbus.Boolean:
98
 
            return u"Yes" if value else u"No"
99
 
        if keyword in ("timeout", "interval"):
 
227
            return "Yes" if value else "No"
 
228
        if keyword in ("Timeout", "Interval", "ApprovalDelay",
 
229
                       "ApprovalDuration", "ExtendedTimeout"):
100
230
            return milliseconds_to_string(value)
101
 
        return unicode(value)
 
231
        return str(value)
102
232
    
103
 
    format_string = u' '.join(u'%%-%ds' %
104
 
                              max(len(tablewords[key]),
105
 
                                  max(len(valuetostring(client[key], key))
106
 
                                      for client in
107
 
                                      clients))
108
 
                              for key in keywords)
109
 
    print format_string % tuple(tablewords[key] for key in keywords) 
 
233
    # Create format string to print table rows
 
234
    format_string = " ".join("{{{key}:{width}}}".format(
 
235
        width = max(len(tablewords[key]),
 
236
                    max(len(valuetostring(client[key], key))
 
237
                        for client in clients)),
 
238
        key = key)
 
239
                             for key in keywords)
 
240
    # Print header line
 
241
    print(format_string.format(**tablewords))
110
242
    for client in clients:
111
 
        print format_string % tuple(valuetostring(client[key], key)
112
 
                                    for key in keywords)
113
 
 
114
 
parser = OptionParser(version = "%%prog %s" % version)
115
 
parser.add_option("-a", "--all", action="store_true",
116
 
                  help="Print all fields")
117
 
parser.add_option("-e", "--enable", action="store_true",
118
 
                  help="Enable specified client")
119
 
parser.add_option("-d", "--disable", action="store_true",
120
 
                  help="disable specified client")
121
 
parser.add_option("-b", "--bump-timeout", action="store_true",
122
 
                  help="Bump timeout of specified client")
123
 
parser.add_option("--start-checker", action="store_true",
124
 
                  help="Start checker for specified client")
125
 
parser.add_option("--stop-checker", action="store_true",
126
 
                  help="Stop checker for specified client")
127
 
parser.add_option("-v", "--is-valid", action="store_true",
128
 
                  help="Stop checker for specified client")
129
 
parser.add_option("-c", "--checker", type="string",
130
 
                  help="Set checker command for specified client")
131
 
parser.add_option("-t", "--timeout", type="string",
132
 
                  help="Set timeout for specified client")
133
 
parser.add_option("-i", "--interval", type="string",
134
 
                  help="Set checker interval for specified client")
135
 
parser.add_option("-H", "--host", type="string",
136
 
                  help="Set host for specified client")
137
 
parser.add_option("-s", "--secret", type="string",
138
 
                  help="Set password blob (file) for specified client")
139
 
options, client_names = parser.parse_args()
140
 
 
141
 
clients=[]
142
 
for name in client_names:
143
 
    for path, client in mandos_clients.iteritems():
144
 
        if client['name'] == name:
145
 
            client_objc = bus.get_object(busname, path)
146
 
            clients.append(dbus.Interface(client_objc,
147
 
                                          dbus_interface
148
 
                                          = client_interface))
149
 
            break
150
 
    else:
151
 
        print >> sys.stderr, "Client not found on server: %r" % name
152
 
        sys.exit(1)
153
 
 
154
 
if not clients:
155
 
    keywords = defaultkeywords
156
 
    if options.all:
157
 
        keywords = ('name', 'enabled', 'timeout', 'last_checked_ok',
158
 
                    'created', 'interval', 'host', 'fingerprint',
159
 
                    'checker_running', 'last_enabled', 'checker')
160
 
    print_clients(mandos_clients.values())
161
 
    
162
 
for client in clients:
163
 
    if options.enable:
164
 
        client.Enable()
165
 
    if options.disable:
166
 
        client.Disable()
167
 
    if options.bump_timeout:
168
 
        client.BumpTimeout()
169
 
    if options.start_checker:
170
 
        client.StartChecker()
171
 
    if options.stop_checker:
172
 
        client.StopChecker()
173
 
    if options.is_valid:
174
 
        sys.exit(0 if client.IsStillValid() else 1)
175
 
    if options.checker:
176
 
        client.SetChecker(options.checker)
177
 
    if options.host:
178
 
        client.SetHost(options.host)
179
 
    if options.interval:
180
 
        client.SetInterval(datetime_to_milliseconds
181
 
                           (string_to_delta(options.interval)))
182
 
    if options.timeout:
183
 
        client.SetTimeout(datetime_to_milliseconds
184
 
                          (string_to_delta(options.timeout)))
185
 
    if options.secret:
186
 
        client.SetSecret(dbus.ByteArray(open(options.secret, 'rb').read()))
187
 
    
 
243
        print(format_string.format(**{
 
244
            key: valuetostring(client[key], key)
 
245
            for key in keywords }))
 
246
 
 
247
 
 
248
def has_actions(options):
 
249
    return any((options.enable,
 
250
                options.disable,
 
251
                options.bump_timeout,
 
252
                options.start_checker,
 
253
                options.stop_checker,
 
254
                options.is_enabled,
 
255
                options.remove,
 
256
                options.checker is not None,
 
257
                options.timeout is not None,
 
258
                options.extended_timeout is not None,
 
259
                options.interval is not None,
 
260
                options.approved_by_default is not None,
 
261
                options.approval_delay is not None,
 
262
                options.approval_duration is not None,
 
263
                options.host is not None,
 
264
                options.secret is not None,
 
265
                options.approve,
 
266
                options.deny))
 
267
 
 
268
 
 
269
def main():
 
270
    parser = argparse.ArgumentParser()
 
271
    parser.add_argument("--version", action="version",
 
272
                        version = "%(prog)s {}".format(version),
 
273
                        help="show version number and exit")
 
274
    parser.add_argument("-a", "--all", action="store_true",
 
275
                        help="Select all clients")
 
276
    parser.add_argument("-v", "--verbose", action="store_true",
 
277
                        help="Print all fields")
 
278
    parser.add_argument("-e", "--enable", action="store_true",
 
279
                        help="Enable client")
 
280
    parser.add_argument("-d", "--disable", action="store_true",
 
281
                        help="disable client")
 
282
    parser.add_argument("-b", "--bump-timeout", action="store_true",
 
283
                        help="Bump timeout for client")
 
284
    parser.add_argument("--start-checker", action="store_true",
 
285
                        help="Start checker for client")
 
286
    parser.add_argument("--stop-checker", action="store_true",
 
287
                        help="Stop checker for client")
 
288
    parser.add_argument("-V", "--is-enabled", action="store_true",
 
289
                        help="Check if client is enabled")
 
290
    parser.add_argument("-r", "--remove", action="store_true",
 
291
                        help="Remove client")
 
292
    parser.add_argument("-c", "--checker",
 
293
                        help="Set checker command for client")
 
294
    parser.add_argument("-t", "--timeout",
 
295
                        help="Set timeout for client")
 
296
    parser.add_argument("--extended-timeout",
 
297
                        help="Set extended timeout for client")
 
298
    parser.add_argument("-i", "--interval",
 
299
                        help="Set checker interval for client")
 
300
    parser.add_argument("--approve-by-default", action="store_true",
 
301
                        default=None, dest="approved_by_default",
 
302
                        help="Set client to be approved by default")
 
303
    parser.add_argument("--deny-by-default", action="store_false",
 
304
                        dest="approved_by_default",
 
305
                        help="Set client to be denied by default")
 
306
    parser.add_argument("--approval-delay",
 
307
                        help="Set delay before client approve/deny")
 
308
    parser.add_argument("--approval-duration",
 
309
                        help="Set duration of one client approval")
 
310
    parser.add_argument("-H", "--host", help="Set host for client")
 
311
    parser.add_argument("-s", "--secret",
 
312
                        type=argparse.FileType(mode="rb"),
 
313
                        help="Set password blob (file) for client")
 
314
    parser.add_argument("-A", "--approve", action="store_true",
 
315
                        help="Approve any current client request")
 
316
    parser.add_argument("-D", "--deny", action="store_true",
 
317
                        help="Deny any current client request")
 
318
    parser.add_argument("--check", action="store_true",
 
319
                        help="Run self-test")
 
320
    parser.add_argument("client", nargs="*", help="Client name")
 
321
    options = parser.parse_args()
 
322
    
 
323
    if has_actions(options) and not (options.client or options.all):
 
324
        parser.error("Options require clients names or --all.")
 
325
    if options.verbose and has_actions(options):
 
326
        parser.error("--verbose can only be used alone or with"
 
327
                     " --all.")
 
328
    if options.all and not has_actions(options):
 
329
        parser.error("--all requires an action.")
 
330
 
 
331
    if options.check:
 
332
        fail_count, test_count = doctest.testmod()
 
333
        sys.exit(os.EX_OK if fail_count == 0 else 1)
 
334
    
 
335
    try:
 
336
        bus = dbus.SystemBus()
 
337
        mandos_dbus_objc = bus.get_object(busname, server_path)
 
338
    except dbus.exceptions.DBusException:
 
339
        print("Could not connect to Mandos server", file=sys.stderr)
 
340
        sys.exit(1)
 
341
    
 
342
    mandos_serv = dbus.Interface(mandos_dbus_objc,
 
343
                                 dbus_interface = server_interface)
 
344
    
 
345
    #block stderr since dbus library prints to stderr
 
346
    null = os.open(os.path.devnull, os.O_RDWR)
 
347
    stderrcopy = os.dup(sys.stderr.fileno())
 
348
    os.dup2(null, sys.stderr.fileno())
 
349
    os.close(null)
 
350
    try:
 
351
        try:
 
352
            mandos_clients = mandos_serv.GetAllClientsWithProperties()
 
353
        finally:
 
354
            #restore stderr
 
355
            os.dup2(stderrcopy, sys.stderr.fileno())
 
356
            os.close(stderrcopy)
 
357
    except dbus.exceptions.DBusException:
 
358
        print("Access denied: Accessing mandos server through dbus.",
 
359
              file=sys.stderr)
 
360
        sys.exit(1)
 
361
    
 
362
    # Compile dict of (clients: properties) to process
 
363
    clients={}
 
364
    
 
365
    if options.all or not options.client:
 
366
        clients = { bus.get_object(busname, path): properties
 
367
                    for path, properties in mandos_clients.items() }
 
368
    else:
 
369
        for name in options.client:
 
370
            for path, client in mandos_clients.items():
 
371
                if client["Name"] == name:
 
372
                    client_objc = bus.get_object(busname, path)
 
373
                    clients[client_objc] = client
 
374
                    break
 
375
            else:
 
376
                print("Client not found on server: {!r}"
 
377
                      .format(name), file=sys.stderr)
 
378
                sys.exit(1)
 
379
    
 
380
    if not has_actions(options) and clients:
 
381
        if options.verbose:
 
382
            keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
 
383
                        "Created", "Interval", "Host", "Fingerprint",
 
384
                        "CheckerRunning", "LastEnabled",
 
385
                        "ApprovalPending", "ApprovedByDefault",
 
386
                        "LastApprovalRequest", "ApprovalDelay",
 
387
                        "ApprovalDuration", "Checker",
 
388
                        "ExtendedTimeout")
 
389
        else:
 
390
            keywords = defaultkeywords
 
391
        
 
392
        print_clients(clients.values(), keywords)
 
393
    else:
 
394
        # Process each client in the list by all selected options
 
395
        for client in clients:
 
396
            
 
397
            def set_client_prop(prop, value):
 
398
                """Set a Client D-Bus property"""
 
399
                client.Set(client_interface, prop, value,
 
400
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
401
            
 
402
            def set_client_prop_ms(prop, value):
 
403
                """Set a Client D-Bus property, converted
 
404
                from a string to milliseconds."""
 
405
                set_client_prop(prop,
 
406
                                string_to_delta(value).total_seconds()
 
407
                                * 1000)
 
408
            
 
409
            if options.remove:
 
410
                mandos_serv.RemoveClient(client.__dbus_object_path__)
 
411
            if options.enable:
 
412
                set_client_prop("Enabled", dbus.Boolean(True))
 
413
            if options.disable:
 
414
                set_client_prop("Enabled", dbus.Boolean(False))
 
415
            if options.bump_timeout:
 
416
                set_client_prop("LastCheckedOK", "")
 
417
            if options.start_checker:
 
418
                set_client_prop("CheckerRunning", dbus.Boolean(True))
 
419
            if options.stop_checker:
 
420
                set_client_prop("CheckerRunning", dbus.Boolean(False))
 
421
            if options.is_enabled:
 
422
                sys.exit(0 if client.Get(client_interface,
 
423
                                         "Enabled",
 
424
                                         dbus_interface=
 
425
                                         dbus.PROPERTIES_IFACE)
 
426
                         else 1)
 
427
            if options.checker is not None:
 
428
                set_client_prop("Checker", options.checker)
 
429
            if options.host is not None:
 
430
                set_client_prop("Host", options.host)
 
431
            if options.interval is not None:
 
432
                set_client_prop_ms("Interval", options.interval)
 
433
            if options.approval_delay is not None:
 
434
                set_client_prop_ms("ApprovalDelay",
 
435
                                   options.approval_delay)
 
436
            if options.approval_duration is not None:
 
437
                set_client_prop_ms("ApprovalDuration",
 
438
                                   options.approval_duration)
 
439
            if options.timeout is not None:
 
440
                set_client_prop_ms("Timeout", options.timeout)
 
441
            if options.extended_timeout is not None:
 
442
                set_client_prop_ms("ExtendedTimeout",
 
443
                                   options.extended_timeout)
 
444
            if options.secret is not None:
 
445
                set_client_prop("Secret",
 
446
                                dbus.ByteArray(options.secret.read()))
 
447
            if options.approved_by_default is not None:
 
448
                set_client_prop("ApprovedByDefault",
 
449
                                dbus.Boolean(options
 
450
                                             .approved_by_default))
 
451
            if options.approve:
 
452
                client.Approve(dbus.Boolean(True),
 
453
                               dbus_interface=client_interface)
 
454
            elif options.deny:
 
455
                client.Approve(dbus.Boolean(False),
 
456
                               dbus_interface=client_interface)
 
457
 
 
458
 
 
459
if __name__ == "__main__":
 
460
    main()