/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: 2008-08-03 03:33:56 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080803033356-6aemgj0g0hoz91ow
* plugins.d/mandosclient.c (pgp_packet_decrypt): Renamed variables.
                                                 On debug, show
                                                 decrypted plaintext
                                                 in hexadecimal.  Free
                                                 the GPGME data
                                                 buffers even on
                                                 errors.

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
 
from __future__ import division
5
 
import sys
6
 
import dbus
7
 
from optparse import OptionParser
8
 
import locale
9
 
import datetime
10
 
import re
11
 
import os
12
 
 
13
 
locale.setlocale(locale.LC_ALL, u'')
14
 
 
15
 
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',
27
 
    }
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"
35
 
 
36
 
def timedelta_to_milliseconds(td):
37
 
    "Convert a datetime.timedelta object to milliseconds"
38
 
    return ((td.days * 24 * 60 * 60 * 1000)
39
 
            + (td.seconds * 1000)
40
 
            + (td.microseconds // 1000))
41
 
 
42
 
def milliseconds_to_string(ms):
43
 
    td = datetime.timedelta(0, 0, 0, ms)
44
 
    return (u"%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
45
 
            % { "days": "%dT" % td.days if td.days else "",
46
 
                "hours": td.seconds // 3600,
47
 
                "minutes": (td.seconds % 3600) // 60,
48
 
                "seconds": td.seconds % 60,
49
 
                })
50
 
 
51
 
 
52
 
def string_to_delta(interval):
53
 
    """Parse a string and return a datetime.timedelta
54
 
 
55
 
    >>> string_to_delta('7d')
56
 
    datetime.timedelta(7)
57
 
    >>> string_to_delta('60s')
58
 
    datetime.timedelta(0, 60)
59
 
    >>> string_to_delta('60m')
60
 
    datetime.timedelta(0, 3600)
61
 
    >>> string_to_delta('24h')
62
 
    datetime.timedelta(1)
63
 
    >>> string_to_delta(u'1w')
64
 
    datetime.timedelta(7)
65
 
    >>> string_to_delta('5m 30s')
66
 
    datetime.timedelta(0, 330)
67
 
    """
68
 
    timevalue = datetime.timedelta(0)
69
 
    regexp = re.compile("\d+[dsmhw]")
70
 
    
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
91
 
 
92
 
def print_clients(clients, keywords):
93
 
    def valuetostring(value, keyword):
94
 
        if type(value) is dbus.Boolean:
95
 
            return u"Yes" if value else u"No"
96
 
        if keyword in (u"Timeout", u"Interval"):
97
 
            return milliseconds_to_string(value)
98
 
        return unicode(value)
99
 
    
100
 
    # 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)
108
 
    # Print header line
109
 
    print format_string % tuple(tablewords[key] for key in keywords)
110
 
    for client in clients:
111
 
        print format_string % tuple(valuetostring(client[key], key)
112
 
                                    for key in keywords)
113
 
 
114
 
def has_actions(options):
115
 
    return any((options.enable,
116
 
                options.disable,
117
 
                options.bump_timeout,
118
 
                options.start_checker,
119
 
                options.stop_checker,
120
 
                options.is_enabled,
121
 
                options.remove,
122
 
                options.checker is not None,
123
 
                options.timeout is not None,
124
 
                options.interval is not None,
125
 
                options.host is not None,
126
 
                options.secret is not None,
127
 
                options.approve,
128
 
                options.deny))
129
 
        
130
 
def main():
131
 
        parser = OptionParser(version = "%%prog %s" % version)
132
 
        parser.add_option("-a", "--all", action="store_true",
133
 
                          help="Select all clients")
134
 
        parser.add_option("-v", "--verbose", action="store_true",
135
 
                          help="Print all fields")
136
 
        parser.add_option("-e", "--enable", action="store_true",
137
 
                          help="Enable client")
138
 
        parser.add_option("-d", "--disable", action="store_true",
139
 
                          help="disable client")
140
 
        parser.add_option("-b", "--bump-timeout", action="store_true",
141
 
                          help="Bump timeout for client")
142
 
        parser.add_option("--start-checker", action="store_true",
143
 
                          help="Start checker for client")
144
 
        parser.add_option("--stop-checker", action="store_true",
145
 
                          help="Stop checker for client")
146
 
        parser.add_option("-V", "--is-enabled", action="store_true",
147
 
                          help="Check if client is enabled")
148
 
        parser.add_option("-r", "--remove", action="store_true",
149
 
                          help="Remove client")
150
 
        parser.add_option("-c", "--checker", type="string",
151
 
                          help="Set checker command for client")
152
 
        parser.add_option("-t", "--timeout", type="string",
153
 
                          help="Set timeout for client")
154
 
        parser.add_option("-i", "--interval", type="string",
155
 
                          help="Set checker interval for client")
156
 
        parser.add_option("-H", "--host", type="string",
157
 
                          help="Set host for client")
158
 
        parser.add_option("-s", "--secret", type="string",
159
 
                          help="Set password blob (file) for client")
160
 
        parser.add_option("-A", "--approve", action="store_true",
161
 
                          help="Approve any current client request")
162
 
        parser.add_option("-D", "--deny", action="store_true",
163
 
                          help="Deny any current client request")
164
 
        options, client_names = parser.parse_args()
165
 
        
166
 
        if has_actions(options) and not client_names and not options.all:
167
 
            parser.error('Options requires clients names or --all.')
168
 
        if options.verbose and has_actions(options):
169
 
            parser.error('Verbose option can only be used alone or with --all.')
170
 
        if options.all and not has_actions(options):
171
 
            parser.error('--all requires an action')
172
 
            
173
 
        try:
174
 
            bus = dbus.SystemBus()
175
 
            mandos_dbus_objc = bus.get_object(busname, server_path)
176
 
        except dbus.exceptions.DBusException:
177
 
            print >> sys.stderr, "Could not connect to Mandos server"
178
 
            sys.exit(1)
179
 
    
180
 
        mandos_serv = dbus.Interface(mandos_dbus_objc,
181
 
                                     dbus_interface = server_interface)
182
 
 
183
 
        #block stderr since dbus library prints to stderr
184
 
        null = os.open(os.path.devnull, os.O_RDWR)
185
 
        stderrcopy = os.dup(sys.stderr.fileno())
186
 
        os.dup2(null, sys.stderr.fileno())
187
 
        os.close(null)
188
 
        try:
189
 
            try:
190
 
                mandos_clients = mandos_serv.GetAllClientsWithProperties()
191
 
            finally:
192
 
                #restore stderr
193
 
                os.dup2(stderrcopy, sys.stderr.fileno())
194
 
                os.close(stderrcopy)
195
 
        except dbus.exceptions.DBusException, e:
196
 
            print >> sys.stderr, "Access denied: Accessing mandos server through dbus."
197
 
            sys.exit(1)
198
 
            
199
 
        # Compile dict of (clients: properties) to process
200
 
        clients={}
201
 
        
202
 
        if options.all or not client_names:
203
 
            clients = dict((bus.get_object(busname, path), properties)
204
 
                           for path, properties in
205
 
                           mandos_clients.iteritems())
206
 
        else:
207
 
            for name in client_names:
208
 
                for path, client in mandos_clients.iteritems():
209
 
                    if client['Name'] == name:
210
 
                        client_objc = bus.get_object(busname, path)
211
 
                        clients[client_objc] = client
212
 
                        break
213
 
                else:
214
 
                    print >> sys.stderr, "Client not found on server: %r" % name
215
 
                    sys.exit(1)
216
 
            
217
 
        if not has_actions(options) and clients:
218
 
            if options.verbose:
219
 
                keywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK',
220
 
                            'Created', 'Interval', 'Host', 'Fingerprint',
221
 
                            'CheckerRunning', 'LastEnabled', 'Checker')
222
 
            else:
223
 
                keywords = defaultkeywords
224
 
                
225
 
            print_clients(clients.values(), keywords)
226
 
        else:
227
 
            # Process each client in the list by all selected options
228
 
            for client in clients:
229
 
                if options.remove:
230
 
                    mandos_serv.RemoveClient(client.__dbus_object_path__)
231
 
                if options.enable:
232
 
                    client.Enable(dbus_interface=client_interface)
233
 
                if options.disable:
234
 
                    client.Disable(dbus_interface=client_interface)
235
 
                if options.bump_timeout:
236
 
                    client.CheckedOK(dbus_interface=client_interface)
237
 
                if options.start_checker:
238
 
                    client.StartChecker(dbus_interface=client_interface)
239
 
                if options.stop_checker:
240
 
                    client.StopChecker(dbus_interface=client_interface)
241
 
                if options.is_enabled:
242
 
                    sys.exit(0 if client.Get(client_interface,
243
 
                                             u"Enabled",
244
 
                                             dbus_interface=dbus.PROPERTIES_IFACE)
245
 
                             else 1)
246
 
                if options.checker:
247
 
                    client.Set(client_interface, u"Checker", options.checker,
248
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
249
 
                if options.host:
250
 
                    client.Set(client_interface, u"Host", options.host,
251
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
252
 
                if options.interval:
253
 
                    client.Set(client_interface, u"Interval",
254
 
                               timedelta_to_milliseconds
255
 
                               (string_to_delta(options.interval)),
256
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
257
 
                if options.timeout:
258
 
                    client.Set(client_interface, u"Timeout",
259
 
                               timedelta_to_milliseconds(string_to_delta
260
 
                                                         (options.timeout)),
261
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
262
 
                if options.secret:
263
 
                    client.Set(client_interface, u"Secret",
264
 
                               dbus.ByteArray(open(options.secret, u'rb').read()),
265
 
                               dbus_interface=dbus.PROPERTIES_IFACE)
266
 
                if options.approve:
267
 
                    client.Approve(dbus.Boolean(True), dbus_interface=client_interface)
268
 
                if options.deny:
269
 
                    client.Approve(dbus.Boolean(False), dbus_interface=client_interface)
270
 
 
271
 
if __name__ == '__main__':
272
 
    main()