/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

  • Committer: Teddy Hogeborn
  • Date: 2008-07-20 06:33:48 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080720063348-jscgy5p0itrgvlo8
* mandos-clients.conf ([foo]): Uncommented.
  ([foo]/secret): New.
  ([foo]/secfile): Commented out.
  ([foo]/checker): Changed to "fping -q -- %%(fqdn)s".
  ([foo]/timeout): New.

* server.py: New modeline for Python and Emacs.  Set a logging format.
  (Client.__init__): Bug fix: Choose either the value from the options
                     object or pass the argument through string_to_delta
                     for both "timeout" and "interval".
  (Client.checker_callback): Bug fix: Do not log spurious "Checker for
                             <foo> failed" messages.
  (Client.start_checker): Moved "Starting checker" log message down to
                          just before actually starting the subprocess.
                          Do not redirect the subprocesses' stdout to a
                          pipe.
  (peer_certificate, fingerprint): Added docstrings.
  (entry_group_state_changed): Call "killme()" instead of
                               "main_loop.quit()".
  (daemon, killme): New functions.
  (exitstatus, main_loop_started): New global variables.
  (__main__): Removed the "--cert", "--key", "--ca", and "--crl"
              options.  Removed the sleep command from the default
              checker.  Add a console logger in debug mode.  Call
              "killme()" instead of "main_loop.quit()" when there are no
              more clients.  Call "daemon()" if not in debug mode.
              Register "cleanup()" to run at exit.  Ignore some
              signals.  Catch DBusException to detect another running
              server and exit cleanly.  Exit with "exitstatus".
  (cleanup): New function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
1
 
#!/usr/bin/python
2
 
# -*- mode: python; coding: utf-8 -*-
3
 
# 
4
 
# Mandos Monitor - Control and monitor the Mandos server
5
 
# 
6
 
# Copyright © 2008-2010 Teddy Hogeborn
7
 
# Copyright © 2008-2010 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@fukt.bsnet.se>.
23
 
# 
24
 
 
25
 
from __future__ import (division, absolute_import, print_function,
26
 
                        unicode_literals)
27
 
 
28
 
import sys
29
 
import dbus
30
 
import argparse
31
 
import locale
32
 
import datetime
33
 
import re
34
 
import os
35
 
 
36
 
locale.setlocale(locale.LC_ALL, "")
37
 
 
38
 
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
 
    }
56
 
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
57
 
domain = "se.bsnet.fukt"
58
 
busname = domain + ".Mandos"
59
 
server_path = "/"
60
 
server_interface = domain + ".Mandos"
61
 
client_interface = domain + ".Mandos.Client"
62
 
version = "1.3.0"
63
 
 
64
 
def timedelta_to_milliseconds(td):
65
 
    """Convert a datetime.timedelta object to milliseconds"""
66
 
    return ((td.days * 24 * 60 * 60 * 1000)
67
 
            + (td.seconds * 1000)
68
 
            + (td.microseconds // 1000))
69
 
 
70
 
def milliseconds_to_string(ms):
71
 
    td = datetime.timedelta(0, 0, 0, ms)
72
 
    return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
73
 
            % { "days": "%dT" % td.days if td.days else "",
74
 
                "hours": td.seconds // 3600,
75
 
                "minutes": (td.seconds % 3600) // 60,
76
 
                "seconds": td.seconds % 60,
77
 
                })
78
 
 
79
 
def string_to_delta(interval):
80
 
    """Parse a string and return a datetime.timedelta
81
 
    
82
 
    >>> string_to_delta("7d")
83
 
    datetime.timedelta(7)
84
 
    >>> string_to_delta("60s")
85
 
    datetime.timedelta(0, 60)
86
 
    >>> string_to_delta("60m")
87
 
    datetime.timedelta(0, 3600)
88
 
    >>> string_to_delta("24h")
89
 
    datetime.timedelta(1)
90
 
    >>> string_to_delta("1w")
91
 
    datetime.timedelta(7)
92
 
    >>> string_to_delta("5m 30s")
93
 
    datetime.timedelta(0, 330)
94
 
    """
95
 
    timevalue = datetime.timedelta(0)
96
 
    regexp = re.compile("\d+[dsmhw]")
97
 
    
98
 
    for s in regexp.findall(interval):
99
 
        try:
100
 
            suffix = unicode(s[-1])
101
 
            value = int(s[:-1])
102
 
            if suffix == "d":
103
 
                delta = datetime.timedelta(value)
104
 
            elif suffix == "s":
105
 
                delta = datetime.timedelta(0, value)
106
 
            elif suffix == "m":
107
 
                delta = datetime.timedelta(0, 0, 0, 0, value)
108
 
            elif suffix == "h":
109
 
                delta = datetime.timedelta(0, 0, 0, 0, 0, value)
110
 
            elif suffix == "w":
111
 
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
112
 
            else:
113
 
                raise ValueError
114
 
        except (ValueError, IndexError):
115
 
            raise ValueError
116
 
        timevalue += delta
117
 
    return timevalue
118
 
 
119
 
def print_clients(clients, keywords):
120
 
    def valuetostring(value, keyword):
121
 
        if type(value) is dbus.Boolean:
122
 
            return "Yes" if value else "No"
123
 
        if keyword in ("Timeout", "Interval", "ApprovalDelay",
124
 
                       "ApprovalDuration"):
125
 
            return milliseconds_to_string(value)
126
 
        return unicode(value)
127
 
    
128
 
    # Create format string to print table rows
129
 
    format_string = " ".join("%%-%ds" %
130
 
                             max(len(tablewords[key]),
131
 
                                 max(len(valuetostring(client[key],
132
 
                                                       key))
133
 
                                     for client in
134
 
                                     clients))
135
 
                             for key in keywords)
136
 
    # Print header line
137
 
    print(format_string % tuple(tablewords[key] for key in keywords))
138
 
    for client in clients:
139
 
        print(format_string % tuple(valuetostring(client[key], key)
140
 
                                    for key in keywords))
141
 
 
142
 
def has_actions(options):
143
 
    return any((options.enable,
144
 
                options.disable,
145
 
                options.bump_timeout,
146
 
                options.start_checker,
147
 
                options.stop_checker,
148
 
                options.is_enabled,
149
 
                options.remove,
150
 
                options.checker is not None,
151
 
                options.timeout is not None,
152
 
                options.interval is not None,
153
 
                options.approved_by_default is not None,
154
 
                options.approval_delay is not None,
155
 
                options.approval_duration is not None,
156
 
                options.host is not None,
157
 
                options.secret is not None,
158
 
                options.approve,
159
 
                options.deny))
160
 
 
161
 
def main():
162
 
    parser = argparse.ArgumentParser()
163
 
    parser.add_argument("--version", action="version",
164
 
                        version = "%%prog %s" % version,
165
 
                        help="show version number and exit")
166
 
    parser.add_argument("-a", "--all", action="store_true",
167
 
                        help="Select all clients")
168
 
    parser.add_argument("-v", "--verbose", action="store_true",
169
 
                        help="Print all fields")
170
 
    parser.add_argument("-e", "--enable", action="store_true",
171
 
                        help="Enable client")
172
 
    parser.add_argument("-d", "--disable", action="store_true",
173
 
                        help="disable client")
174
 
    parser.add_argument("-b", "--bump-timeout", action="store_true",
175
 
                        help="Bump timeout for client")
176
 
    parser.add_argument("--start-checker", action="store_true",
177
 
                        help="Start checker for client")
178
 
    parser.add_argument("--stop-checker", action="store_true",
179
 
                        help="Stop checker for client")
180
 
    parser.add_argument("-V", "--is-enabled", action="store_true",
181
 
                        help="Check if client is enabled")
182
 
    parser.add_argument("-r", "--remove", action="store_true",
183
 
                        help="Remove client")
184
 
    parser.add_argument("-c", "--checker",
185
 
                        help="Set checker command for client")
186
 
    parser.add_argument("-t", "--timeout",
187
 
                        help="Set 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, e:
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
260
 
            else:
261
 
                print("Client not found on server: %r" % name,
262
 
                      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
 
        else:
275
 
            keywords = defaultkeywords
276
 
        
277
 
        print_clients(clients.values(), keywords)
278
 
    else:
279
 
        # Process each client in the list by all selected options
280
 
        for client in clients:
281
 
            if options.remove:
282
 
                mandos_serv.RemoveClient(client.__dbus_object_path__)
283
 
            if options.enable:
284
 
                client.Enable(dbus_interface=client_interface)
285
 
            if options.disable:
286
 
                client.Disable(dbus_interface=client_interface)
287
 
            if options.bump_timeout:
288
 
                client.CheckedOK(dbus_interface=client_interface)
289
 
            if options.start_checker:
290
 
                client.StartChecker(dbus_interface=client_interface)
291
 
            if options.stop_checker:
292
 
                client.StopChecker(dbus_interface=client_interface)
293
 
            if options.is_enabled:
294
 
                sys.exit(0 if client.Get(client_interface,
295
 
                                         "Enabled",
296
 
                                         dbus_interface=
297
 
                                         dbus.PROPERTIES_IFACE)
298
 
                         else 1)
299
 
            if options.checker:
300
 
                client.Set(client_interface, "Checker",
301
 
                           options.checker,
302
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
303
 
            if options.host:
304
 
                client.Set(client_interface, "Host", options.host,
305
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
306
 
            if options.interval:
307
 
                client.Set(client_interface, "Interval",
308
 
                           timedelta_to_milliseconds
309
 
                           (string_to_delta(options.interval)),
310
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
311
 
            if options.approval_delay:
312
 
                client.Set(client_interface, "ApprovalDelay",
313
 
                           timedelta_to_milliseconds
314
 
                           (string_to_delta(options.
315
 
                                            approval_delay)),
316
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
317
 
            if options.approval_duration:
318
 
                client.Set(client_interface, "ApprovalDuration",
319
 
                           timedelta_to_milliseconds
320
 
                           (string_to_delta(options.
321
 
                                            approval_duration)),
322
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
323
 
            if options.timeout:
324
 
                client.Set(client_interface, "Timeout",
325
 
                           timedelta_to_milliseconds
326
 
                           (string_to_delta(options.timeout)),
327
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
328
 
            if options.secret:
329
 
                client.Set(client_interface, "Secret",
330
 
                           dbus.ByteArray(open(options.secret,
331
 
                                               "rb").read()),
332
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
333
 
            if options.approved_by_default is not None:
334
 
                client.Set(client_interface, "ApprovedByDefault",
335
 
                           dbus.Boolean(options
336
 
                                        .approved_by_default),
337
 
                           dbus_interface=dbus.PROPERTIES_IFACE)
338
 
            if options.approve:
339
 
                client.Approve(dbus.Boolean(True),
340
 
                               dbus_interface=client_interface)
341
 
            elif options.deny:
342
 
                client.Approve(dbus.Boolean(False),
343
 
                               dbus_interface=client_interface)
344
 
 
345
 
if __name__ == "__main__":
346
 
    main()