/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-09-25 23:52:17 UTC
  • Revision ID: teddy@fukt.bsnet.se-20100925235217-4hhqfryz1ste6uw3
* mandos (ClientDBus.__init__): Bug fix: Translate "-" in client names
                                to "_" in D-Bus object paths.
  (MandosServer.handle_ipc): Bug fix: Send only address string to
                             D-Bus signal, not whole tuple.

* mandos-ctl: New options "--approve-by-default", "--deny-by-default",
              "--approval-delay", and "--approval-duration".
* mandos-ctl.xml (SYNOPSIS, OPTIONS): Document new options.

* mandos-monitor (MandosClientWidget.update): Fix spelling.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
23
23
    'Fingerprint': u'Fingerprint',
24
24
    'CheckerRunning': u'Check Is Running',
25
25
    'LastEnabled': u'Last Enabled',
 
26
    'ApprovalPending': u'Approval Is Pending',
 
27
    'ApprovedByDefault': u'Approved By Default',
 
28
    'ApprovalDelay': u"Approval Delay",
 
29
    'ApprovalDuration': u"Approval Duration",
26
30
    'Checker': u'Checker',
27
31
    }
28
32
defaultkeywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK')
93
97
    def valuetostring(value, keyword):
94
98
        if type(value) is dbus.Boolean:
95
99
            return u"Yes" if value else u"No"
96
 
        if keyword in (u"Timeout", u"Interval"):
 
100
        if keyword in (u"Timeout", u"Interval", u"ApprovalDelay",
 
101
                       u"ApprovalDuration"):
97
102
            return milliseconds_to_string(value)
98
103
        return unicode(value)
99
104
    
122
127
                options.checker is not None,
123
128
                options.timeout is not None,
124
129
                options.interval is not None,
 
130
                options.approved_by_default is not None,
 
131
                options.approval_delay is not None,
 
132
                options.approval_duration is not None,
125
133
                options.host is not None,
126
134
                options.secret is not None,
127
135
                options.approve,
153
161
                          help="Set timeout for client")
154
162
        parser.add_option("-i", "--interval", type="string",
155
163
                          help="Set checker interval for client")
 
164
        parser.add_option("--approve-by-default", action="store_true",
 
165
                          dest=u"approved_by_default",
 
166
                          help="Set client to be approved by default")
 
167
        parser.add_option("--deny-by-default", action="store_false",
 
168
                          dest=u"approved_by_default",
 
169
                          help="Set client to be denied by default")
 
170
        parser.add_option("--approval-delay", type="string",
 
171
                          help="Set delay before client approve/deny")
 
172
        parser.add_option("--approval-duration", type="string",
 
173
                          help="Set duration of one client approval")
156
174
        parser.add_option("-H", "--host", type="string",
157
175
                          help="Set host for client")
158
176
        parser.add_option("-s", "--secret", type="string",
164
182
        options, client_names = parser.parse_args()
165
183
        
166
184
        if has_actions(options) and not client_names and not options.all:
167
 
            parser.error('Options requires clients names or --all.')
 
185
            parser.error('Options require clients names or --all.')
168
186
        if options.verbose and has_actions(options):
169
 
            parser.error('Verbose option can only be used alone or with --all.')
 
187
            parser.error('--verbose can only be used alone or with'
 
188
                         ' --all.')
170
189
        if options.all and not has_actions(options):
171
 
            parser.error('--all requires an action')
172
 
            
 
190
            parser.error('--all requires an action.')
 
191
        
173
192
        try:
174
193
            bus = dbus.SystemBus()
175
194
            mandos_dbus_objc = bus.get_object(busname, server_path)
216
235
            
217
236
        if not has_actions(options) and clients:
218
237
            if options.verbose:
219
 
                keywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK',
220
 
                            'Created', 'Interval', 'Host', 'Fingerprint',
221
 
                            'CheckerRunning', 'LastEnabled', 'Checker')
 
238
                keywords = ('Name', 'Enabled', 'Timeout',
 
239
                            'LastCheckedOK', 'Created', 'Interval',
 
240
                            'Host', 'Fingerprint', 'CheckerRunning',
 
241
                            'LastEnabled', 'ApprovalPending',
 
242
                            'ApprovedByDefault', 'ApprovalDelay',
 
243
                            'ApprovalDuration', 'Checker')
222
244
            else:
223
245
                keywords = defaultkeywords
224
246
                
254
276
                               timedelta_to_milliseconds
255
277
                               (string_to_delta(options.interval)),
256
278
                               dbus_interface=dbus.PROPERTIES_IFACE)
 
279
                if options.approval_delay:
 
280
                    client.Set(client_interface, u"ApprovalDelay",
 
281
                               timedelta_to_milliseconds
 
282
                               (string_to_delta(options.
 
283
                                                approval_delay)),
 
284
                               dbus_interface=dbus.PROPERTIES_IFACE)
 
285
                if options.approval_duration:
 
286
                    client.Set(client_interface, u"ApprovalDuration",
 
287
                               timedelta_to_milliseconds
 
288
                               (string_to_delta(options.
 
289
                                                approval_duration)),
 
290
                               dbus_interface=dbus.PROPERTIES_IFACE)
257
291
                if options.timeout:
258
292
                    client.Set(client_interface, u"Timeout",
259
 
                               timedelta_to_milliseconds(string_to_delta
260
 
                                                         (options.timeout)),
 
293
                               timedelta_to_milliseconds
 
294
                               (string_to_delta(options.timeout)),
261
295
                               dbus_interface=dbus.PROPERTIES_IFACE)
262
296
                if options.secret:
263
297
                    client.Set(client_interface, u"Secret",
264
 
                               dbus.ByteArray(open(options.secret, u'rb').read()),
 
298
                               dbus.ByteArray(open(options.secret,
 
299
                                                   u'rb').read()),
 
300
                               dbus_interface=dbus.PROPERTIES_IFACE)
 
301
                if options.approved_by_default is not None:
 
302
                    client.Set(client_interface, u"ApprovedByDefault",
 
303
                               dbus.Boolean(options
 
304
                                            .approved_by_default),
265
305
                               dbus_interface=dbus.PROPERTIES_IFACE)
266
306
                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)
 
307
                    client.Approve(dbus.Boolean(True),
 
308
                                   dbus_interface=client_interface)
 
309
                elif options.deny:
 
310
                    client.Approve(dbus.Boolean(False),
 
311
                                   dbus_interface=client_interface)
270
312
 
271
313
if __name__ == '__main__':
272
314
    main()