/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

  • Committer: Teddy Hogeborn
  • Date: 2008-11-11 16:07:18 UTC
  • mto: (24.1.113 mandos)
  • mto: This revision was merged to the branch mainline in revision 238.
  • Revision ID: teddy@fukt.bsnet.se-20081111160718-gvqhs581md4inh5u
Further steps towards a D-Bus server interface, plus minor syntax
changes.

* mandos: Split copyright line.  Throughout, use parentheses instead
          of backslashes to continue long lines.
  (AvahiService.__init__): Use new "foo if bar else baz" syntax.
  (Client): All D-Bus methods renamed to be capitalized.
  (Client.__init__): Use D-Bus path "/Mandos/clients/%s".
  (Client.created): Changed to always be in UTC.  All users changed.
  (Client.started): Changed to be a "datetime.datetime()" in UTC.  All
                    users changed.
  (Client.stop): Bug fix: set "self.started" to "None".
  (Client.interface): Renamed to "_interface".
  (Client._datetime_to_dbus_struct): New temporary function.
  (Client.CheckerIsRunning): New D-Bus method.
  (Client.GetChecker): - '' -
  (Client.GetCreated): - '' -
  (Client.GetHost): - '' -
  (Client.GetStarted): - '' -
  (Client.SetHost): - '' -
  (Client.SetChecker): - '' -
  (Client.SetInterval): - '' -
  (Client.SetTimeout): - '' -
  (Client.StartChecker): - '' -
  (Client.TimeoutChanged): New D-Bus signal.
  (TCP_handler.handle): Use new "for...else" syntax.
  (main): Bug fix: get a D-Bus bus name.

* mandos-keygen: Split copyright line.
* plugin-runner.c: - '' -
* plugins.d/mandos-client: - '' -
* plugins.d/password-prompt.c: - '' -

* plugins.d/askpass-fifo.c: Added copyright statement and license.
* plugins.s/splashy.c: - '' -
* plugins.d/usplash.c: - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
11
11
# and some lines in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008 Teddy Hogeborn & Björn Påhlsson
 
14
# Copyright © 2008 Teddy Hogeborn
 
15
# Copyright © 2008 Björn Påhlsson
15
16
# 
16
17
# This program is free software: you can redistribute it and/or modify
17
18
# it under the terms of the GNU General Public License as published by
68
69
version = "1.0.2"
69
70
 
70
71
logger = logging.Logger('mandos')
71
 
syslogger = logging.handlers.SysLogHandler\
72
 
            (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
73
 
             address = "/dev/log")
74
 
syslogger.setFormatter(logging.Formatter\
75
 
                        ('Mandos: %(levelname)s: %(message)s'))
 
72
syslogger = (logging.handlers.SysLogHandler
 
73
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
74
              address = "/dev/log"))
 
75
syslogger.setFormatter(logging.Formatter
 
76
                       ('Mandos: %(levelname)s: %(message)s'))
76
77
logger.addHandler(syslogger)
77
78
 
78
79
console = logging.StreamHandler()
111
112
                  a sensible number of times
112
113
    """
113
114
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
114
 
                 servicetype = None, port = None, TXT = None, domain = "",
115
 
                 host = "", max_renames = 32768):
 
115
                 servicetype = None, port = None, TXT = None,
 
116
                 domain = "", host = "", max_renames = 32768):
116
117
        self.interface = interface
117
118
        self.name = name
118
119
        self.type = servicetype
119
120
        self.port = port
120
 
        if TXT is None:
121
 
            self.TXT = []
122
 
        else:
123
 
            self.TXT = TXT
 
121
        self.TXT = TXT if TXT is not None else []
124
122
        self.domain = domain
125
123
        self.host = host
126
124
        self.rename_count = 0
135
133
        self.name = server.GetAlternativeServiceName(self.name)
136
134
        logger.info(u"Changing Zeroconf service name to %r ...",
137
135
                    str(self.name))
138
 
        syslogger.setFormatter(logging.Formatter\
 
136
        syslogger.setFormatter(logging.Formatter
139
137
                               ('Mandos (%s): %%(levelname)s:'
140
 
                               ' %%(message)s' % self.name))
 
138
                                ' %%(message)s' % self.name))
141
139
        self.remove()
142
140
        self.add()
143
141
        self.rename_count += 1
149
147
        """Derived from the Avahi example code"""
150
148
        global group
151
149
        if group is None:
152
 
            group = dbus.Interface\
153
 
                    (bus.get_object(avahi.DBUS_NAME,
 
150
            group = dbus.Interface(bus.get_object
 
151
                                   (avahi.DBUS_NAME,
154
152
                                    server.EntryGroupNew()),
155
 
                     avahi.DBUS_INTERFACE_ENTRY_GROUP)
 
153
                                   avahi.DBUS_INTERFACE_ENTRY_GROUP)
156
154
            group.connect_to_signal('StateChanged',
157
155
                                    entry_group_state_changed)
158
156
        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
180
178
                 uniquely identify the client
181
179
    secret:    bytestring; sent verbatim (over TLS) to client
182
180
    host:      string; available for use by the checker command
183
 
    created:   datetime.datetime(); object creation, not client host
184
 
    started:   bool()
185
 
    last_checked_ok: datetime.datetime() or None if not yet checked OK
 
181
    created:   datetime.datetime(); (UTC) object creation
 
182
    started:   datetime.datetime(); (UTC) last started
 
183
    last_checked_ok: datetime.datetime(); (UTC) or None
186
184
    timeout:   datetime.timedelta(); How long from last_checked_ok
187
185
                                     until this client is invalid
188
186
    interval:  datetime.timedelta(); How often to start a new checker
203
201
    _timeout_milliseconds: Used when calling gobject.timeout_add()
204
202
    _interval_milliseconds: - '' -
205
203
    """
206
 
    interface = u"org.mandos_system.Mandos.Clients"
207
 
    
208
 
    @dbus.service.method(interface, out_signature="s")
209
 
    def getName(self):
210
 
        "D-Bus getter method"
211
 
        return self.name
212
 
    
213
 
    @dbus.service.method(interface, out_signature="s")
214
 
    def getFingerprint(self):
215
 
        "D-Bus getter method"
216
 
        return self.fingerprint
217
 
    
218
 
    @dbus.service.method(interface, in_signature="ay",
219
 
                         byte_arrays=True)
220
 
    def setSecret(self, secret):
221
 
        "D-Bus setter method"
222
 
        self.secret = secret
223
 
    
224
204
    def _set_timeout(self, timeout):
225
205
        "Setter function for the 'timeout' attribute"
226
206
        self._timeout = timeout
234
214
    timeout = property(lambda self: self._timeout, _set_timeout)
235
215
    del _set_timeout
236
216
    
237
 
    @dbus.service.method(interface, out_signature="t")
238
 
    def getTimeout(self):
239
 
        "D-Bus getter method"
240
 
        return self._timeout_milliseconds
241
 
    
242
 
    @dbus.service.signal(interface, signature="t")
243
 
    def TimeoutChanged(self, t):
244
 
        "D-Bus signal"
245
 
        pass
246
 
    
247
217
    def _set_interval(self, interval):
248
218
        "Setter function for the 'interval' attribute"
249
219
        self._interval = interval
258
228
    interval = property(lambda self: self._interval, _set_interval)
259
229
    del _set_interval
260
230
    
261
 
    @dbus.service.method(interface, out_signature="t")
262
 
    def getInterval(self):
263
 
        "D-Bus getter method"
264
 
        return self._interval_milliseconds
265
 
    
266
 
    @dbus.service.signal(interface, signature="t")
267
 
    def IntervalChanged(self, t):
268
 
        "D-Bus signal"
269
 
        pass
270
 
    
271
231
    def __init__(self, name = None, stop_hook=None, config=None):
272
232
        """Note: the 'checker' key in 'config' sets the
273
233
        'checker_command' attribute and *not* the 'checker'
274
234
        attribute."""
275
235
        dbus.service.Object.__init__(self, bus,
276
 
                                     "/Mandos/Clients/%s"
 
236
                                     "/Mandos/clients/%s"
277
237
                                     % name.replace(".", "_"))
278
238
        if config is None:
279
239
            config = {}
282
242
        # Uppercase and remove spaces from fingerprint for later
283
243
        # comparison purposes with return value from the fingerprint()
284
244
        # function
285
 
        self.fingerprint = config["fingerprint"].upper()\
286
 
                           .replace(u" ", u"")
 
245
        self.fingerprint = (config["fingerprint"].upper()
 
246
                            .replace(u" ", u""))
287
247
        logger.debug(u"  Fingerprint: %s", self.fingerprint)
288
248
        if "secret" in config:
289
249
            self.secret = config["secret"].decode(u"base64")
290
250
        elif "secfile" in config:
291
251
            with closing(open(os.path.expanduser
292
252
                              (os.path.expandvars
293
 
                               (config["secfile"])))) \
294
 
                               as secfile:
 
253
                               (config["secfile"])))) as secfile:
295
254
                self.secret = secfile.read()
296
255
        else:
297
256
            raise TypeError(u"No secret or secfile for client %s"
298
257
                            % self.name)
299
258
        self.host = config.get("host", "")
300
 
        self.created = datetime.datetime.now()
301
 
        self.started = False
 
259
        self.created = datetime.datetime.utcnow()
 
260
        self.started = None
302
261
        self.last_checked_ok = None
303
262
        self.timeout = string_to_delta(config["timeout"])
304
263
        self.interval = string_to_delta(config["interval"])
311
270
    
312
271
    def start(self):
313
272
        """Start this client's checker and timeout hooks"""
314
 
        self.started = True
 
273
        self.started = datetime.datetime.utcnow()
315
274
        # Schedule a new checker to be started an 'interval' from now,
316
275
        # and every interval from then on.
317
 
        self.checker_initiator_tag = gobject.timeout_add\
318
 
                                     (self._interval_milliseconds,
319
 
                                      self.start_checker)
 
276
        self.checker_initiator_tag = (gobject.timeout_add
 
277
                                      (self._interval_milliseconds,
 
278
                                       self.start_checker))
320
279
        # Also start a new checker *right now*.
321
280
        self.start_checker()
322
281
        # Schedule a stop() when 'timeout' has passed
323
 
        self.stop_initiator_tag = gobject.timeout_add\
324
 
                                  (self._timeout_milliseconds,
325
 
                                   self.stop)
 
282
        self.stop_initiator_tag = (gobject.timeout_add
 
283
                                   (self._timeout_milliseconds,
 
284
                                    self.stop))
326
285
        # Emit D-Bus signal
327
286
        self.StateChanged(True)
328
287
    
329
 
    @dbus.service.signal(interface, signature="b")
330
 
    def StateChanged(self, started):
331
 
        "D-Bus signal"
332
 
        pass
333
 
    
334
288
    def stop(self):
335
289
        """Stop this client."""
336
 
        if getattr(self, "started", False):
 
290
        if getattr(self, "started", None) is not None:
337
291
            logger.info(u"Stopping client %s", self.name)
338
292
        else:
339
293
            return False
346
300
        self.stop_checker()
347
301
        if self.stop_hook:
348
302
            self.stop_hook(self)
 
303
        self.started = None
349
304
        # Emit D-Bus signal
350
305
        self.StateChanged(False)
351
306
        # Do not run this again if called by a gobject.timeout_add
352
307
        return False
353
 
    # D-Bus variant
354
 
    Stop = dbus.service.method(interface)(stop)
355
308
    
356
309
    def __del__(self):
357
310
        self.stop_hook = None
361
314
        """The checker has completed, so take appropriate actions."""
362
315
        self.checker_callback_tag = None
363
316
        self.checker = None
364
 
        if os.WIFEXITED(condition) \
365
 
               and (os.WEXITSTATUS(condition) == 0):
 
317
        if (os.WIFEXITED(condition) 
 
318
            and (os.WEXITSTATUS(condition) == 0)):
366
319
            logger.info(u"Checker for %(name)s succeeded",
367
320
                        vars(self))
368
321
            # Emit D-Bus signal
379
332
            # Emit D-Bus signal
380
333
            self.CheckerCompleted(False)
381
334
    
382
 
    @dbus.service.signal(interface, signature="b")
383
 
    def CheckerCompleted(self, success):
384
 
        "D-Bus signal"
385
 
        pass
386
 
    
387
335
    def bump_timeout(self):
388
336
        """Bump up the timeout for this client.
389
337
        This should only be called when the client has been seen,
390
338
        alive and well.
391
339
        """
392
 
        self.last_checked_ok = datetime.datetime.now()
 
340
        self.last_checked_ok = datetime.datetime.utcnow()
393
341
        gobject.source_remove(self.stop_initiator_tag)
394
 
        self.stop_initiator_tag = gobject.timeout_add\
395
 
            (self._timeout_milliseconds, self.stop)
396
 
    # D-Bus variant
397
 
    bumpTimeout = dbus.service.method(interface)(bump_timeout)
 
342
        self.stop_initiator_tag = (gobject.timeout_add
 
343
                                   (self._timeout_milliseconds,
 
344
                                    self.stop))
398
345
    
399
346
    def start_checker(self):
400
347
        """Start a new checker subprocess if one is not running.
433
380
                self.checker = subprocess.Popen(command,
434
381
                                                close_fds=True,
435
382
                                                shell=True, cwd="/")
436
 
                self.checker_callback_tag = gobject.child_watch_add\
437
 
                                            (self.checker.pid,
438
 
                                             self.checker_callback)
 
383
                self.checker_callback_tag = (gobject.child_watch_add
 
384
                                             (self.checker.pid,
 
385
                                              self.checker_callback))
439
386
                # Emit D-Bus signal
440
387
                self.CheckerStarted(command)
441
388
            except OSError, error:
444
391
        # Re-run this periodically if run by gobject.timeout_add
445
392
        return True
446
393
    
447
 
    @dbus.service.signal(interface, signature="s")
448
 
    def CheckerStarted(self, command):
449
 
        pass
450
 
    
451
 
    @dbus.service.method(interface, out_signature="b")
452
 
    def checkerIsRunning(self):
453
 
        "D-Bus getter method"
454
 
        return self.checker is not None
455
 
    
456
394
    def stop_checker(self):
457
395
        """Force the checker process, if any, to stop."""
458
396
        if self.checker_callback_tag:
470
408
            if error.errno != errno.ESRCH: # No such process
471
409
                raise
472
410
        self.checker = None
473
 
    # D-Bus variant
474
 
    StopChecker = dbus.service.method(interface)(stop_checker)
475
411
    
476
412
    def still_valid(self):
477
413
        """Has the timeout not yet passed for this client?"""
478
414
        if not self.started:
479
415
            return False
480
 
        now = datetime.datetime.now()
 
416
        now = datetime.datetime.utcnow()
481
417
        if self.last_checked_ok is None:
482
418
            return now < (self.created + self.timeout)
483
419
        else:
484
420
            return now < (self.last_checked_ok + self.timeout)
485
 
    # D-Bus variant
486
 
    stillValid = dbus.service.method(interface, out_signature="b")\
487
 
        (still_valid)
488
 
    
489
 
    del interface
 
421
    
 
422
    ## D-Bus methods & signals
 
423
    _interface = u"org.mandos_system.Mandos.Client"
 
424
    
 
425
    def _datetime_to_dbus_struct(dt):
 
426
        return dbus.Struct(dt.year, dt.month, dt.day, dt.hour,
 
427
                           dt.minute, dt.second, dt.microsecond,
 
428
                           signature="nyyyyyu")
 
429
    
 
430
    # BumpTimeout - method
 
431
    BumpTimeout = dbus.service.method(_interface)(bump_timeout)
 
432
    BumpTimeout.__name__ = "BumpTimeout"
 
433
    
 
434
    # IntervalChanged - signal
 
435
    @dbus.service.signal(_interface, signature="t")
 
436
    def IntervalChanged(self, t):
 
437
        "D-Bus signal"
 
438
        pass
 
439
    
 
440
    # CheckerCompleted - signal
 
441
    @dbus.service.signal(_interface, signature="b")
 
442
    def CheckerCompleted(self, success):
 
443
        "D-Bus signal"
 
444
        pass
 
445
    
 
446
    # CheckerIsRunning - method
 
447
    @dbus.service.method(_interface, out_signature="b")
 
448
    def CheckerIsRunning(self):
 
449
        "D-Bus getter method"
 
450
        return self.checker is not None
 
451
    
 
452
    # CheckerStarted - signal
 
453
    @dbus.service.signal(_interface, signature="s")
 
454
    def CheckerStarted(self, command):
 
455
        "D-Bus signal"
 
456
        pass
 
457
    
 
458
    # GetChecker - method
 
459
    @dbus.service.method(_interface, out_signature="s")
 
460
    def GetChecker(self):
 
461
        "D-Bus getter method"
 
462
        return self.checker_command
 
463
    
 
464
    # GetCreated - method
 
465
    @dbus.service.method(_interface, out_signature="(nyyyyyu)")
 
466
    def GetCreated(self):
 
467
        "D-Bus getter method"
 
468
        return datetime_to_dbus_struct(self.created)
 
469
    
 
470
    # GetFingerprint - method
 
471
    @dbus.service.method(_interface, out_signature="s")
 
472
    def GetFingerprint(self):
 
473
        "D-Bus getter method"
 
474
        return self.fingerprint
 
475
    
 
476
    # GetHost - method
 
477
    @dbus.service.method(_interface, out_signature="s")
 
478
    def GetHost(self):
 
479
        "D-Bus getter method"
 
480
        return self.host
 
481
    
 
482
    # GetInterval - method
 
483
    @dbus.service.method(_interface, out_signature="t")
 
484
    def GetInterval(self):
 
485
        "D-Bus getter method"
 
486
        return self._interval_milliseconds
 
487
    
 
488
    # GetName - method
 
489
    @dbus.service.method(_interface, out_signature="s")
 
490
    def GetName(self):
 
491
        "D-Bus getter method"
 
492
        return self.name
 
493
    
 
494
    # GetStarted - method
 
495
    @dbus.service.method(_interface, out_signature="(nyyyyyu)")
 
496
    def GetStarted(self):
 
497
        "D-Bus getter method"
 
498
        if self.started is not None:
 
499
            return datetime_to_dbus_struct(self.started)
 
500
        else:
 
501
            return dbus.Struct(0, 0, 0, 0, 0, 0, 0,
 
502
                               signature="nyyyyyu")
 
503
    
 
504
    # GetTimeout - method
 
505
    @dbus.service.method(_interface, out_signature="t")
 
506
    def GetTimeout(self):
 
507
        "D-Bus getter method"
 
508
        return self._timeout_milliseconds
 
509
    
 
510
    # SetChecker - method
 
511
    @dbus.service.method(_interface, in_signature="s")
 
512
    def SetChecker(self, checker):
 
513
        "D-Bus setter method"
 
514
        self.checker_command = checker
 
515
    
 
516
    # SetHost - method
 
517
    @dbus.service.method(_interface, in_signature="s")
 
518
    def SetHost(self, host):
 
519
        "D-Bus setter method"
 
520
        self.host = host
 
521
    
 
522
    # SetInterval - method
 
523
    @dbus.service.method(_interface, in_signature="t")
 
524
    def SetInterval(self, milliseconds):
 
525
        self.interval = datetime.timdeelta(0, 0, 0, milliseconds)
 
526
    
 
527
    # SetTimeout - method
 
528
    @dbus.service.method(_interface, in_signature="t")
 
529
    def SetTimeout(self, milliseconds):
 
530
        self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
 
531
    
 
532
    # SetSecret - method
 
533
    @dbus.service.method(_interface, in_signature="ay",
 
534
                         byte_arrays=True)
 
535
    def SetSecret(self, secret):
 
536
        "D-Bus setter method"
 
537
        self.secret = str(secret)
 
538
    
 
539
    # Start - method
 
540
    Start = dbus.service.method(_interface)(start)
 
541
    Start.__name__ = "Start"
 
542
    
 
543
    # StartChecker - method
 
544
    StartChecker = dbus.service.method(_interface)(start_checker)
 
545
    StartChecker.__name__ = "StartChecker"
 
546
    
 
547
    # StateChanged - signal
 
548
    @dbus.service.signal(_interface, signature="b")
 
549
    def StateChanged(self, started):
 
550
        "D-Bus signal"
 
551
        pass
 
552
    
 
553
    # StillValid - method
 
554
    StillValid = (dbus.service.method(_interface, out_signature="b")
 
555
                  (still_valid))
 
556
    StillValid.__name__ = "StillValid"
 
557
    
 
558
    # Stop - method
 
559
    Stop = dbus.service.method(_interface)(stop)
 
560
    Stop.__name__ = "Stop"
 
561
    
 
562
    # StopChecker - method
 
563
    StopChecker = dbus.service.method(_interface)(stop_checker)
 
564
    StopChecker.__name__ = "StopChecker"
 
565
    
 
566
    # TimeoutChanged - signal
 
567
    @dbus.service.signal(_interface, signature="t")
 
568
    def TimeoutChanged(self, t):
 
569
        "D-Bus signal"
 
570
        pass
 
571
    
 
572
    del _datetime_to_dbus_struct
 
573
    del _interface
490
574
 
491
575
 
492
576
def peer_certificate(session):
493
577
    "Return the peer's OpenPGP certificate as a bytestring"
494
578
    # If not an OpenPGP certificate...
495
 
    if gnutls.library.functions.gnutls_certificate_type_get\
496
 
            (session._c_object) \
497
 
           != gnutls.library.constants.GNUTLS_CRT_OPENPGP:
 
579
    if (gnutls.library.functions
 
580
        .gnutls_certificate_type_get(session._c_object)
 
581
        != gnutls.library.constants.GNUTLS_CRT_OPENPGP):
498
582
        # ...do the normal thing
499
583
        return session.peer_certificate
500
584
    list_size = ctypes.c_uint()
501
 
    cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
502
 
        (session._c_object, ctypes.byref(list_size))
 
585
    cert_list = (gnutls.library.functions
 
586
                 .gnutls_certificate_get_peers
 
587
                 (session._c_object, ctypes.byref(list_size)))
503
588
    if list_size.value == 0:
504
589
        return None
505
590
    cert = cert_list[0]
509
594
def fingerprint(openpgp):
510
595
    "Convert an OpenPGP bytestring to a hexdigit fingerprint string"
511
596
    # New GnuTLS "datum" with the OpenPGP public key
512
 
    datum = gnutls.library.types.gnutls_datum_t\
513
 
        (ctypes.cast(ctypes.c_char_p(openpgp),
514
 
                     ctypes.POINTER(ctypes.c_ubyte)),
515
 
         ctypes.c_uint(len(openpgp)))
 
597
    datum = (gnutls.library.types
 
598
             .gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
 
599
                                         ctypes.POINTER
 
600
                                         (ctypes.c_ubyte)),
 
601
                             ctypes.c_uint(len(openpgp))))
516
602
    # New empty GnuTLS certificate
517
603
    crt = gnutls.library.types.gnutls_openpgp_crt_t()
518
 
    gnutls.library.functions.gnutls_openpgp_crt_init\
519
 
        (ctypes.byref(crt))
 
604
    (gnutls.library.functions
 
605
     .gnutls_openpgp_crt_init(ctypes.byref(crt)))
520
606
    # Import the OpenPGP public key into the certificate
521
 
    gnutls.library.functions.gnutls_openpgp_crt_import\
522
 
                    (crt, ctypes.byref(datum),
523
 
                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
 
607
    (gnutls.library.functions
 
608
     .gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
 
609
                                gnutls.library.constants
 
610
                                .GNUTLS_OPENPGP_FMT_RAW))
524
611
    # Verify the self signature in the key
525
612
    crtverify = ctypes.c_uint()
526
 
    gnutls.library.functions.gnutls_openpgp_crt_verify_self\
527
 
        (crt, 0, ctypes.byref(crtverify))
 
613
    (gnutls.library.functions
 
614
     .gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))
528
615
    if crtverify.value != 0:
529
616
        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
530
617
        raise gnutls.errors.CertificateSecurityError("Verify failed")
532
619
    buf = ctypes.create_string_buffer(20)
533
620
    buf_len = ctypes.c_size_t()
534
621
    # Get the fingerprint from the certificate into the buffer
535
 
    gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
536
 
        (crt, ctypes.byref(buf), ctypes.byref(buf_len))
 
622
    (gnutls.library.functions
 
623
     .gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
 
624
                                         ctypes.byref(buf_len)))
537
625
    # Deinit the certificate
538
626
    gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
539
627
    # Convert the buffer to a Python bytestring
551
639
    def handle(self):
552
640
        logger.info(u"TCP connection from: %s",
553
641
                    unicode(self.client_address))
554
 
        session = gnutls.connection.ClientSession\
555
 
                  (self.request, gnutls.connection.X509Credentials())
 
642
        session = (gnutls.connection
 
643
                   .ClientSession(self.request,
 
644
                                  gnutls.connection
 
645
                                  .X509Credentials()))
556
646
        
557
647
        line = self.request.makefile().readline()
558
648
        logger.debug(u"Protocol version: %r", line)
573
663
        #                "+DHE-DSS"))
574
664
        # Use a fallback default, since this MUST be set.
575
665
        priority = self.server.settings.get("priority", "NORMAL")
576
 
        gnutls.library.functions.gnutls_priority_set_direct\
577
 
            (session._c_object, priority, None)
 
666
        (gnutls.library.functions
 
667
         .gnutls_priority_set_direct(session._c_object,
 
668
                                     priority, None))
578
669
        
579
670
        try:
580
671
            session.handshake()
590
681
            session.bye()
591
682
            return
592
683
        logger.debug(u"Fingerprint: %s", fpr)
593
 
        client = None
594
684
        for c in self.server.clients:
595
685
            if c.fingerprint == fpr:
596
686
                client = c
597
687
                break
598
 
        if not client:
 
688
        else:
599
689
            logger.warning(u"Client not found for fingerprint: %s",
600
690
                           fpr)
601
691
            session.bye()
746
836
    """Call the C function if_nametoindex(), or equivalent"""
747
837
    global if_nametoindex
748
838
    try:
749
 
        if_nametoindex = ctypes.cdll.LoadLibrary\
750
 
            (ctypes.util.find_library("c")).if_nametoindex
 
839
        if_nametoindex = (ctypes.cdll.LoadLibrary
 
840
                          (ctypes.util.find_library("c"))
 
841
                          .if_nametoindex)
751
842
    except (OSError, AttributeError):
752
843
        if "struct" not in sys.modules:
753
844
            import struct
832
923
    # Convert the SafeConfigParser object to a dict
833
924
    server_settings = server_config.defaults()
834
925
    # Use getboolean on the boolean config option
835
 
    server_settings["debug"] = server_config.getboolean\
836
 
                               ("DEFAULT", "debug")
 
926
    server_settings["debug"] = (server_config.getboolean
 
927
                                ("DEFAULT", "debug"))
837
928
    del server_config
838
929
    
839
930
    # Override the settings from the config file with command line
853
944
        console.setLevel(logging.WARNING)
854
945
    
855
946
    if server_settings["servicename"] != "Mandos":
856
 
        syslogger.setFormatter(logging.Formatter\
 
947
        syslogger.setFormatter(logging.Formatter
857
948
                               ('Mandos (%s): %%(levelname)s:'
858
949
                                ' %%(message)s'
859
950
                                % server_settings["servicename"]))
907
998
    service = AvahiService(name = server_settings["servicename"],
908
999
                           servicetype = "_mandos._tcp", )
909
1000
    if server_settings["interface"]:
910
 
        service.interface = if_nametoindex\
911
 
                            (server_settings["interface"])
 
1001
        service.interface = (if_nametoindex
 
1002
                             (server_settings["interface"]))
912
1003
    
913
1004
    global main_loop
914
1005
    global bus
921
1012
                                           avahi.DBUS_PATH_SERVER),
922
1013
                            avahi.DBUS_INTERFACE_SERVER)
923
1014
    # End of Avahi example code
 
1015
    bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)
924
1016
    
925
1017
    def remove_from_clients(client):
926
1018
        clients.remove(client)
1008
1100
        
1009
1101
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1010
1102
                             lambda *args, **kwargs:
1011
 
                             tcp_server.handle_request\
1012
 
                             (*args[2:], **kwargs) or True)
 
1103
                             (tcp_server.handle_request
 
1104
                              (*args[2:], **kwargs) or True))
1013
1105
        
1014
1106
        logger.debug(u"Starting main loop")
1015
1107
        main_loop.run()