/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: 2014-08-09 13:12:55 UTC
  • Revision ID: teddy@recompile.se-20140809131255-lp31j98u2pl0xpe6
mandos: Stop using str() and remove unnecessary unicode() calls.

* mandos (if_nametoindex): Use "bytes" literal instead of str().
  (initlogger): Use a unicode string for log device.
  (AvahiError.__unicode__): Removed.
  (DBusPropertyException.__unicode__): - '' -
  (ClientDBus.Secret_dbus_property): Use bytes() instead of str().
  (IPv6_TCPServer.server_bind): Use .encode() instead of str().
  (string_to_delta): Removed unnecessary unicode() call.
  (main): Use "isinstance(x, bytes)" instead of "type(x) is str", use
          .decode() instead of unicode(), and use .encode() instead of
          str().

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/python
 
1
#!/usr/bin/python2.7
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
4
4
# Mandos server - give out binary blobs to connecting clients.
11
11
# "AvahiService" class, and some lines in "main".
12
12
13
13
# Everything else is
14
 
# Copyright © 2008-2012 Teddy Hogeborn
15
 
# Copyright © 2008-2012 Björn Påhlsson
 
14
# Copyright © 2008-2014 Teddy Hogeborn
 
15
# Copyright © 2008-2014 Björn Påhlsson
16
16
17
17
# This program is free software: you can redistribute it and/or modify
18
18
# it under the terms of the GNU General Public License as published by
34
34
from __future__ import (division, absolute_import, print_function,
35
35
                        unicode_literals)
36
36
 
 
37
from future_builtins import *
 
38
 
37
39
import SocketServer as socketserver
38
40
import socket
39
41
import argparse
65
67
import types
66
68
import binascii
67
69
import tempfile
 
70
import itertools
 
71
import collections
68
72
 
69
73
import dbus
70
74
import dbus.service
75
79
import ctypes.util
76
80
import xml.dom.minidom
77
81
import inspect
78
 
import GnuPGInterface
79
82
 
80
83
try:
81
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
85
88
    except ImportError:
86
89
        SO_BINDTODEVICE = None
87
90
 
88
 
version = "1.5.2"
 
91
version = "1.6.8"
89
92
stored_state_file = "clients.pickle"
90
93
 
91
94
logger = logging.getLogger()
92
 
syslogger = (logging.handlers.SysLogHandler
93
 
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
94
 
              address = str("/dev/log")))
 
95
syslogger = None
95
96
 
96
97
try:
97
98
    if_nametoindex = (ctypes.cdll.LoadLibrary
103
104
        SIOCGIFINDEX = 0x8933  # From /usr/include/linux/sockios.h
104
105
        with contextlib.closing(socket.socket()) as s:
105
106
            ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
106
 
                                struct.pack(str("16s16x"),
107
 
                                            interface))
108
 
        interface_index = struct.unpack(str("I"),
109
 
                                        ifreq[16:20])[0]
 
107
                                struct.pack(b"16s16x", interface))
 
108
        interface_index = struct.unpack("I", ifreq[16:20])[0]
110
109
        return interface_index
111
110
 
112
111
 
113
112
def initlogger(debug, level=logging.WARNING):
114
113
    """init logger and add loglevel"""
115
114
    
 
115
    global syslogger
 
116
    syslogger = (logging.handlers.SysLogHandler
 
117
                 (facility =
 
118
                  logging.handlers.SysLogHandler.LOG_DAEMON,
 
119
                  address = "/dev/log"))
116
120
    syslogger.setFormatter(logging.Formatter
117
121
                           ('Mandos [%(process)d]: %(levelname)s:'
118
122
                            ' %(message)s'))
136
140
class PGPEngine(object):
137
141
    """A simple class for OpenPGP symmetric encryption & decryption"""
138
142
    def __init__(self):
139
 
        self.gnupg = GnuPGInterface.GnuPG()
140
143
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
141
 
        self.gnupg = GnuPGInterface.GnuPG()
142
 
        self.gnupg.options.meta_interactive = False
143
 
        self.gnupg.options.homedir = self.tempdir
144
 
        self.gnupg.options.extra_args.extend(['--force-mdc',
145
 
                                              '--quiet',
146
 
                                              '--no-use-agent'])
 
144
        self.gnupgargs = ['--batch',
 
145
                          '--home', self.tempdir,
 
146
                          '--force-mdc',
 
147
                          '--quiet',
 
148
                          '--no-use-agent']
147
149
    
148
150
    def __enter__(self):
149
151
        return self
150
152
    
151
 
    def __exit__ (self, exc_type, exc_value, traceback):
 
153
    def __exit__(self, exc_type, exc_value, traceback):
152
154
        self._cleanup()
153
155
        return False
154
156
    
171
173
    def password_encode(self, password):
172
174
        # Passphrase can not be empty and can not contain newlines or
173
175
        # NUL bytes.  So we prefix it and hex encode it.
174
 
        return b"mandos" + binascii.hexlify(password)
 
176
        encoded = b"mandos" + binascii.hexlify(password)
 
177
        if len(encoded) > 2048:
 
178
            # GnuPG can't handle long passwords, so encode differently
 
179
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
 
180
                       .replace(b"\n", b"\\n")
 
181
                       .replace(b"\0", b"\\x00"))
 
182
        return encoded
175
183
    
176
184
    def encrypt(self, data, password):
177
 
        self.gnupg.passphrase = self.password_encode(password)
178
 
        with open(os.devnull) as devnull:
179
 
            try:
180
 
                proc = self.gnupg.run(['--symmetric'],
181
 
                                      create_fhs=['stdin', 'stdout'],
182
 
                                      attach_fhs={'stderr': devnull})
183
 
                with contextlib.closing(proc.handles['stdin']) as f:
184
 
                    f.write(data)
185
 
                with contextlib.closing(proc.handles['stdout']) as f:
186
 
                    ciphertext = f.read()
187
 
                proc.wait()
188
 
            except IOError as e:
189
 
                raise PGPError(e)
190
 
        self.gnupg.passphrase = None
 
185
        passphrase = self.password_encode(password)
 
186
        with tempfile.NamedTemporaryFile(dir=self.tempdir
 
187
                                         ) as passfile:
 
188
            passfile.write(passphrase)
 
189
            passfile.flush()
 
190
            proc = subprocess.Popen(['gpg', '--symmetric',
 
191
                                     '--passphrase-file',
 
192
                                     passfile.name]
 
193
                                    + self.gnupgargs,
 
194
                                    stdin = subprocess.PIPE,
 
195
                                    stdout = subprocess.PIPE,
 
196
                                    stderr = subprocess.PIPE)
 
197
            ciphertext, err = proc.communicate(input = data)
 
198
        if proc.returncode != 0:
 
199
            raise PGPError(err)
191
200
        return ciphertext
192
201
    
193
202
    def decrypt(self, data, password):
194
 
        self.gnupg.passphrase = self.password_encode(password)
195
 
        with open(os.devnull) as devnull:
196
 
            try:
197
 
                proc = self.gnupg.run(['--decrypt'],
198
 
                                      create_fhs=['stdin', 'stdout'],
199
 
                                      attach_fhs={'stderr': devnull})
200
 
                with contextlib.closing(proc.handles['stdin'] ) as f:
201
 
                    f.write(data)
202
 
                with contextlib.closing(proc.handles['stdout']) as f:
203
 
                    decrypted_plaintext = f.read()
204
 
                proc.wait()
205
 
            except IOError as e:
206
 
                raise PGPError(e)
207
 
        self.gnupg.passphrase = None
 
203
        passphrase = self.password_encode(password)
 
204
        with tempfile.NamedTemporaryFile(dir = self.tempdir
 
205
                                         ) as passfile:
 
206
            passfile.write(passphrase)
 
207
            passfile.flush()
 
208
            proc = subprocess.Popen(['gpg', '--decrypt',
 
209
                                     '--passphrase-file',
 
210
                                     passfile.name]
 
211
                                    + self.gnupgargs,
 
212
                                    stdin = subprocess.PIPE,
 
213
                                    stdout = subprocess.PIPE,
 
214
                                    stderr = subprocess.PIPE)
 
215
            decrypted_plaintext, err = proc.communicate(input
 
216
                                                        = data)
 
217
        if proc.returncode != 0:
 
218
            raise PGPError(err)
208
219
        return decrypted_plaintext
209
220
 
210
221
 
211
 
 
212
222
class AvahiError(Exception):
213
223
    def __init__(self, value, *args, **kwargs):
214
224
        self.value = value
215
 
        super(AvahiError, self).__init__(value, *args, **kwargs)
216
 
    def __unicode__(self):
217
 
        return unicode(repr(self.value))
 
225
        return super(AvahiError, self).__init__(value, *args,
 
226
                                                **kwargs)
218
227
 
219
228
class AvahiServiceError(AvahiError):
220
229
    pass
231
240
               Used to optionally bind to the specified interface.
232
241
    name: string; Example: 'Mandos'
233
242
    type: string; Example: '_mandos._tcp'.
234
 
                  See <http://www.dns-sd.org/ServiceTypes.html>
 
243
     See <https://www.iana.org/assignments/service-names-port-numbers>
235
244
    port: integer; what port to announce
236
245
    TXT: list of strings; TXT record for the service
237
246
    domain: string; Domain to publish on, default to .local if empty.
243
252
    server: D-Bus Server
244
253
    bus: dbus.SystemBus()
245
254
    """
 
255
    
246
256
    def __init__(self, interface = avahi.IF_UNSPEC, name = None,
247
257
                 servicetype = None, port = None, TXT = None,
248
258
                 domain = "", host = "", max_renames = 32768,
261
271
        self.server = None
262
272
        self.bus = bus
263
273
        self.entry_group_state_changed_match = None
 
274
    
264
275
    def rename(self):
265
276
        """Derived from the Avahi example code"""
266
277
        if self.rename_count >= self.max_renames:
276
287
        try:
277
288
            self.add()
278
289
        except dbus.exceptions.DBusException as error:
279
 
            logger.critical("DBusException: %s", error)
 
290
            logger.critical("D-Bus Exception", exc_info=error)
280
291
            self.cleanup()
281
292
            os._exit(1)
282
293
        self.rename_count += 1
 
294
    
283
295
    def remove(self):
284
296
        """Derived from the Avahi example code"""
285
297
        if self.entry_group_state_changed_match is not None:
287
299
            self.entry_group_state_changed_match = None
288
300
        if self.group is not None:
289
301
            self.group.Reset()
 
302
    
290
303
    def add(self):
291
304
        """Derived from the Avahi example code"""
292
305
        self.remove()
309
322
            dbus.UInt16(self.port),
310
323
            avahi.string_array_to_txt_array(self.TXT))
311
324
        self.group.Commit()
 
325
    
312
326
    def entry_group_state_changed(self, state, error):
313
327
        """Derived from the Avahi example code"""
314
328
        logger.debug("Avahi entry group state change: %i", state)
321
335
        elif state == avahi.ENTRY_GROUP_FAILURE:
322
336
            logger.critical("Avahi: Error in group state changed %s",
323
337
                            unicode(error))
324
 
            raise AvahiGroupError("State changed: %s"
325
 
                                  % unicode(error))
 
338
            raise AvahiGroupError("State changed: {!s}"
 
339
                                  .format(error))
 
340
    
326
341
    def cleanup(self):
327
342
        """Derived from the Avahi example code"""
328
343
        if self.group is not None:
333
348
                pass
334
349
            self.group = None
335
350
        self.remove()
 
351
    
336
352
    def server_state_changed(self, state, error=None):
337
353
        """Derived from the Avahi example code"""
338
354
        logger.debug("Avahi server state change: %i", state)
357
373
                logger.debug("Unknown state: %r", state)
358
374
            else:
359
375
                logger.debug("Unknown state: %r: %r", state, error)
 
376
    
360
377
    def activate(self):
361
378
        """Derived from the Avahi example code"""
362
379
        if self.server is None:
369
386
                                 self.server_state_changed)
370
387
        self.server_state_changed(self.server.GetState())
371
388
 
 
389
 
372
390
class AvahiServiceToSyslog(AvahiService):
373
391
    def rename(self):
374
392
        """Add the new name to the syslog messages"""
375
393
        ret = AvahiService.rename(self)
376
394
        syslogger.setFormatter(logging.Formatter
377
 
                               ('Mandos (%s) [%%(process)d]:'
378
 
                                ' %%(levelname)s: %%(message)s'
379
 
                                % self.name))
 
395
                               ('Mandos ({}) [%(process)d]:'
 
396
                                ' %(levelname)s: %(message)s'
 
397
                                .format(self.name)))
380
398
        return ret
381
399
 
382
 
def timedelta_to_milliseconds(td):
383
 
    "Convert a datetime.timedelta() to milliseconds"
384
 
    return ((td.days * 24 * 60 * 60 * 1000)
385
 
            + (td.seconds * 1000)
386
 
            + (td.microseconds // 1000))
387
 
        
 
400
 
388
401
class Client(object):
389
402
    """A representation of a client host served by this server.
390
403
    
426
439
    runtime_expansions: Allowed attributes for runtime expansion.
427
440
    expires:    datetime.datetime(); time (UTC) when a client will be
428
441
                disabled, or None
 
442
    server_settings: The server_settings dict from main()
429
443
    """
430
444
    
431
445
    runtime_expansions = ("approval_delay", "approval_duration",
432
 
                          "created", "enabled", "fingerprint",
433
 
                          "host", "interval", "last_checked_ok",
 
446
                          "created", "enabled", "expires",
 
447
                          "fingerprint", "host", "interval",
 
448
                          "last_approval_request", "last_checked_ok",
434
449
                          "last_enabled", "name", "timeout")
435
 
    client_defaults = { "timeout": "5m",
436
 
                        "extended_timeout": "15m",
437
 
                        "interval": "2m",
 
450
    client_defaults = { "timeout": "PT5M",
 
451
                        "extended_timeout": "PT15M",
 
452
                        "interval": "PT2M",
438
453
                        "checker": "fping -q -- %%(host)s",
439
454
                        "host": "",
440
 
                        "approval_delay": "0s",
441
 
                        "approval_duration": "1s",
 
455
                        "approval_delay": "PT0S",
 
456
                        "approval_duration": "PT1S",
442
457
                        "approved_by_default": "True",
443
458
                        "enabled": "True",
444
459
                        }
445
460
    
446
 
    def timeout_milliseconds(self):
447
 
        "Return the 'timeout' attribute in milliseconds"
448
 
        return timedelta_to_milliseconds(self.timeout)
449
 
    
450
 
    def extended_timeout_milliseconds(self):
451
 
        "Return the 'extended_timeout' attribute in milliseconds"
452
 
        return timedelta_to_milliseconds(self.extended_timeout)
453
 
    
454
 
    def interval_milliseconds(self):
455
 
        "Return the 'interval' attribute in milliseconds"
456
 
        return timedelta_to_milliseconds(self.interval)
457
 
    
458
 
    def approval_delay_milliseconds(self):
459
 
        return timedelta_to_milliseconds(self.approval_delay)
460
 
 
461
461
    @staticmethod
462
462
    def config_parser(config):
463
463
        """Construct a new dict of client settings of this form:
488
488
                          "rb") as secfile:
489
489
                    client["secret"] = secfile.read()
490
490
            else:
491
 
                raise TypeError("No secret or secfile for section %s"
492
 
                                % section)
 
491
                raise TypeError("No secret or secfile for section {}"
 
492
                                .format(section))
493
493
            client["timeout"] = string_to_delta(section["timeout"])
494
494
            client["extended_timeout"] = string_to_delta(
495
495
                section["extended_timeout"])
504
504
            client["last_checker_status"] = -2
505
505
        
506
506
        return settings
507
 
        
508
 
        
509
 
    def __init__(self, settings, name = None):
510
 
        """Note: the 'checker' key in 'config' sets the
511
 
        'checker_command' attribute and *not* the 'checker'
512
 
        attribute."""
 
507
    
 
508
    def __init__(self, settings, name = None, server_settings=None):
513
509
        self.name = name
 
510
        if server_settings is None:
 
511
            server_settings = {}
 
512
        self.server_settings = server_settings
514
513
        # adding all client settings
515
 
        for setting, value in settings.iteritems():
 
514
        for setting, value in settings.items():
516
515
            setattr(self, setting, value)
517
516
        
518
517
        if self.enabled:
524
523
        else:
525
524
            self.last_enabled = None
526
525
            self.expires = None
527
 
       
 
526
        
528
527
        logger.debug("Creating client %r", self.name)
529
528
        # Uppercase and remove spaces from fingerprint for later
530
529
        # comparison purposes with return value from the fingerprint()
532
531
        logger.debug("  Fingerprint: %s", self.fingerprint)
533
532
        self.created = settings.get("created",
534
533
                                    datetime.datetime.utcnow())
535
 
 
 
534
        
536
535
        # attributes specific for this server instance
537
536
        self.checker = None
538
537
        self.checker_initiator_tag = None
566
565
        if getattr(self, "enabled", False):
567
566
            # Already enabled
568
567
            return
569
 
        self.send_changedstate()
570
568
        self.expires = datetime.datetime.utcnow() + self.timeout
571
569
        self.enabled = True
572
570
        self.last_enabled = datetime.datetime.utcnow()
573
571
        self.init_checker()
 
572
        self.send_changedstate()
574
573
    
575
574
    def disable(self, quiet=True):
576
575
        """Disable this client."""
577
576
        if not getattr(self, "enabled", False):
578
577
            return False
579
578
        if not quiet:
580
 
            self.send_changedstate()
581
 
        if not quiet:
582
579
            logger.info("Disabling client %s", self.name)
583
 
        if getattr(self, "disable_initiator_tag", False):
 
580
        if getattr(self, "disable_initiator_tag", None) is not None:
584
581
            gobject.source_remove(self.disable_initiator_tag)
585
582
            self.disable_initiator_tag = None
586
583
        self.expires = None
587
 
        if getattr(self, "checker_initiator_tag", False):
 
584
        if getattr(self, "checker_initiator_tag", None) is not None:
588
585
            gobject.source_remove(self.checker_initiator_tag)
589
586
            self.checker_initiator_tag = None
590
587
        self.stop_checker()
591
588
        self.enabled = False
 
589
        if not quiet:
 
590
            self.send_changedstate()
592
591
        # Do not run this again if called by a gobject.timeout_add
593
592
        return False
594
593
    
598
597
    def init_checker(self):
599
598
        # Schedule a new checker to be started an 'interval' from now,
600
599
        # and every interval from then on.
 
600
        if self.checker_initiator_tag is not None:
 
601
            gobject.source_remove(self.checker_initiator_tag)
601
602
        self.checker_initiator_tag = (gobject.timeout_add
602
 
                                      (self.interval_milliseconds(),
 
603
                                      (int(self.interval
 
604
                                           .total_seconds() * 1000),
603
605
                                       self.start_checker))
604
606
        # Schedule a disable() when 'timeout' has passed
 
607
        if self.disable_initiator_tag is not None:
 
608
            gobject.source_remove(self.disable_initiator_tag)
605
609
        self.disable_initiator_tag = (gobject.timeout_add
606
 
                                   (self.timeout_milliseconds(),
607
 
                                    self.disable))
 
610
                                      (int(self.timeout
 
611
                                           .total_seconds() * 1000),
 
612
                                       self.disable))
608
613
        # Also start a new checker *right now*.
609
614
        self.start_checker()
610
615
    
638
643
            timeout = self.timeout
639
644
        if self.disable_initiator_tag is not None:
640
645
            gobject.source_remove(self.disable_initiator_tag)
 
646
            self.disable_initiator_tag = None
641
647
        if getattr(self, "enabled", False):
642
648
            self.disable_initiator_tag = (gobject.timeout_add
643
 
                                          (timedelta_to_milliseconds
644
 
                                           (timeout), self.disable))
 
649
                                          (int(timeout.total_seconds()
 
650
                                               * 1000), self.disable))
645
651
            self.expires = datetime.datetime.utcnow() + timeout
646
652
    
647
653
    def need_approval(self):
653
659
        If a checker already exists, leave it running and do
654
660
        nothing."""
655
661
        # The reason for not killing a running checker is that if we
656
 
        # did that, then if a checker (for some reason) started
657
 
        # running slowly and taking more than 'interval' time, the
658
 
        # client would inevitably timeout, since no checker would get
659
 
        # a chance to run to completion.  If we instead leave running
 
662
        # did that, and if a checker (for some reason) started running
 
663
        # slowly and taking more than 'interval' time, then the client
 
664
        # would inevitably timeout, since no checker would get a
 
665
        # chance to run to completion.  If we instead leave running
660
666
        # checkers alone, the checker would have to take more time
661
667
        # than 'timeout' for the client to be disabled, which is as it
662
668
        # should be.
664
670
        # If a checker exists, make sure it is not a zombie
665
671
        try:
666
672
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
667
 
        except (AttributeError, OSError) as error:
668
 
            if (isinstance(error, OSError)
669
 
                and error.errno != errno.ECHILD):
670
 
                raise error
 
673
        except AttributeError:
 
674
            pass
 
675
        except OSError as error:
 
676
            if error.errno != errno.ECHILD:
 
677
                raise
671
678
        else:
672
679
            if pid:
673
680
                logger.warning("Checker was a zombie")
676
683
                                      self.current_checker_command)
677
684
        # Start a new checker if needed
678
685
        if self.checker is None:
 
686
            # Escape attributes for the shell
 
687
            escaped_attrs = { attr:
 
688
                                  re.escape(unicode(getattr(self,
 
689
                                                            attr)))
 
690
                              for attr in self.runtime_expansions }
679
691
            try:
680
 
                # In case checker_command has exactly one % operator
681
 
                command = self.checker_command % self.host
682
 
            except TypeError:
683
 
                # Escape attributes for the shell
684
 
                escaped_attrs = dict(
685
 
                    (attr,
686
 
                     re.escape(unicode(str(getattr(self, attr, "")),
687
 
                                       errors=
688
 
                                       'replace')))
689
 
                    for attr in
690
 
                    self.runtime_expansions)
691
 
                
692
 
                try:
693
 
                    command = self.checker_command % escaped_attrs
694
 
                except TypeError as error:
695
 
                    logger.error('Could not format string "%s":'
696
 
                                 ' %s', self.checker_command, error)
697
 
                    return True # Try again later
 
692
                command = self.checker_command % escaped_attrs
 
693
            except TypeError as error:
 
694
                logger.error('Could not format string "%s"',
 
695
                             self.checker_command, exc_info=error)
 
696
                return True # Try again later
698
697
            self.current_checker_command = command
699
698
            try:
700
699
                logger.info("Starting checker %r for %s",
703
702
                # in normal mode, that is already done by daemon(),
704
703
                # and in debug mode we don't want to.  (Stdin is
705
704
                # always replaced by /dev/null.)
 
705
                # The exception is when not debugging but nevertheless
 
706
                # running in the foreground; use the previously
 
707
                # created wnull.
 
708
                popen_args = {}
 
709
                if (not self.server_settings["debug"]
 
710
                    and self.server_settings["foreground"]):
 
711
                    popen_args.update({"stdout": wnull,
 
712
                                       "stderr": wnull })
706
713
                self.checker = subprocess.Popen(command,
707
714
                                                close_fds=True,
708
 
                                                shell=True, cwd="/")
709
 
                self.checker_callback_tag = (gobject.child_watch_add
710
 
                                             (self.checker.pid,
711
 
                                              self.checker_callback,
712
 
                                              data=command))
713
 
                # The checker may have completed before the gobject
714
 
                # watch was added.  Check for this.
 
715
                                                shell=True, cwd="/",
 
716
                                                **popen_args)
 
717
            except OSError as error:
 
718
                logger.error("Failed to start subprocess",
 
719
                             exc_info=error)
 
720
                return True
 
721
            self.checker_callback_tag = (gobject.child_watch_add
 
722
                                         (self.checker.pid,
 
723
                                          self.checker_callback,
 
724
                                          data=command))
 
725
            # The checker may have completed before the gobject
 
726
            # watch was added.  Check for this.
 
727
            try:
715
728
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
716
 
                if pid:
717
 
                    gobject.source_remove(self.checker_callback_tag)
718
 
                    self.checker_callback(pid, status, command)
719
729
            except OSError as error:
720
 
                logger.error("Failed to start subprocess: %s",
721
 
                             error)
 
730
                if error.errno == errno.ECHILD:
 
731
                    # This should never happen
 
732
                    logger.error("Child process vanished",
 
733
                                 exc_info=error)
 
734
                    return True
 
735
                raise
 
736
            if pid:
 
737
                gobject.source_remove(self.checker_callback_tag)
 
738
                self.checker_callback(pid, status, command)
722
739
        # Re-run this periodically if run by gobject.timeout_add
723
740
        return True
724
741
    
731
748
            return
732
749
        logger.debug("Stopping checker for %(name)s", vars(self))
733
750
        try:
734
 
            os.kill(self.checker.pid, signal.SIGTERM)
 
751
            self.checker.terminate()
735
752
            #time.sleep(0.5)
736
753
            #if self.checker.poll() is None:
737
 
            #    os.kill(self.checker.pid, signal.SIGKILL)
 
754
            #    self.checker.kill()
738
755
        except OSError as error:
739
756
            if error.errno != errno.ESRCH: # No such process
740
757
                raise
757
774
    # "Set" method, so we fail early here:
758
775
    if byte_arrays and signature != "ay":
759
776
        raise ValueError("Byte arrays not supported for non-'ay'"
760
 
                         " signature %r" % signature)
 
777
                         " signature {!r}".format(signature))
761
778
    def decorator(func):
762
779
        func._dbus_is_property = True
763
780
        func._dbus_interface = dbus_interface
771
788
    return decorator
772
789
 
773
790
 
 
791
def dbus_interface_annotations(dbus_interface):
 
792
    """Decorator for marking functions returning interface annotations
 
793
    
 
794
    Usage:
 
795
    
 
796
    @dbus_interface_annotations("org.example.Interface")
 
797
    def _foo(self):  # Function name does not matter
 
798
        return {"org.freedesktop.DBus.Deprecated": "true",
 
799
                "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
800
                    "false"}
 
801
    """
 
802
    def decorator(func):
 
803
        func._dbus_is_interface = True
 
804
        func._dbus_interface = dbus_interface
 
805
        func._dbus_name = dbus_interface
 
806
        return func
 
807
    return decorator
 
808
 
 
809
 
 
810
def dbus_annotations(annotations):
 
811
    """Decorator to annotate D-Bus methods, signals or properties
 
812
    Usage:
 
813
    
 
814
    @dbus_service_property("org.example.Interface", signature="b",
 
815
                           access="r")
 
816
    @dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",
 
817
                        "org.freedesktop.DBus.Property."
 
818
                        "EmitsChangedSignal": "false"})
 
819
    def Property_dbus_property(self):
 
820
        return dbus.Boolean(False)
 
821
    """
 
822
    def decorator(func):
 
823
        func._dbus_annotations = annotations
 
824
        return func
 
825
    return decorator
 
826
 
 
827
 
774
828
class DBusPropertyException(dbus.exceptions.DBusException):
775
829
    """A base class for D-Bus property-related exceptions
776
830
    """
777
 
    def __unicode__(self):
778
 
        return unicode(str(self))
779
 
 
 
831
    pass
780
832
 
781
833
class DBusPropertyAccessException(DBusPropertyException):
782
834
    """A property's access permissions disallows an operation.
799
851
    """
800
852
    
801
853
    @staticmethod
802
 
    def _is_dbus_property(obj):
803
 
        return getattr(obj, "_dbus_is_property", False)
 
854
    def _is_dbus_thing(thing):
 
855
        """Returns a function testing if an attribute is a D-Bus thing
 
856
        
 
857
        If called like _is_dbus_thing("method") it returns a function
 
858
        suitable for use as predicate to inspect.getmembers().
 
859
        """
 
860
        return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
 
861
                                   False)
804
862
    
805
 
    def _get_all_dbus_properties(self):
 
863
    def _get_all_dbus_things(self, thing):
806
864
        """Returns a generator of (name, attribute) pairs
807
865
        """
808
 
        return ((prop.__get__(self)._dbus_name, prop.__get__(self))
 
866
        return ((getattr(athing.__get__(self), "_dbus_name",
 
867
                         name),
 
868
                 athing.__get__(self))
809
869
                for cls in self.__class__.__mro__
810
 
                for name, prop in
811
 
                inspect.getmembers(cls, self._is_dbus_property))
 
870
                for name, athing in
 
871
                inspect.getmembers(cls,
 
872
                                   self._is_dbus_thing(thing)))
812
873
    
813
874
    def _get_dbus_property(self, interface_name, property_name):
814
875
        """Returns a bound method if one exists which is a D-Bus
816
877
        """
817
878
        for cls in  self.__class__.__mro__:
818
879
            for name, value in (inspect.getmembers
819
 
                                (cls, self._is_dbus_property)):
 
880
                                (cls,
 
881
                                 self._is_dbus_thing("property"))):
820
882
                if (value._dbus_name == property_name
821
883
                    and value._dbus_interface == interface_name):
822
884
                    return value.__get__(self)
850
912
            # The byte_arrays option is not supported yet on
851
913
            # signatures other than "ay".
852
914
            if prop._dbus_signature != "ay":
853
 
                raise ValueError
 
915
                raise ValueError("Byte arrays not supported for non-"
 
916
                                 "'ay' signature {!r}"
 
917
                                 .format(prop._dbus_signature))
854
918
            value = dbus.ByteArray(b''.join(chr(byte)
855
919
                                            for byte in value))
856
920
        prop(value)
864
928
        Note: Will not include properties with access="write".
865
929
        """
866
930
        properties = {}
867
 
        for name, prop in self._get_all_dbus_properties():
 
931
        for name, prop in self._get_all_dbus_things("property"):
868
932
            if (interface_name
869
933
                and interface_name != prop._dbus_interface):
870
934
                # Interface non-empty but did not match
885
949
                         path_keyword='object_path',
886
950
                         connection_keyword='connection')
887
951
    def Introspect(self, object_path, connection):
888
 
        """Standard D-Bus method, overloaded to insert property tags.
 
952
        """Overloading of standard D-Bus method.
 
953
        
 
954
        Inserts property tags and interface annotation tags.
889
955
        """
890
956
        xmlstring = dbus.service.Object.Introspect(self, object_path,
891
957
                                                   connection)
898
964
                e.setAttribute("access", prop._dbus_access)
899
965
                return e
900
966
            for if_tag in document.getElementsByTagName("interface"):
 
967
                # Add property tags
901
968
                for tag in (make_tag(document, name, prop)
902
969
                            for name, prop
903
 
                            in self._get_all_dbus_properties()
 
970
                            in self._get_all_dbus_things("property")
904
971
                            if prop._dbus_interface
905
972
                            == if_tag.getAttribute("name")):
906
973
                    if_tag.appendChild(tag)
 
974
                # Add annotation tags
 
975
                for typ in ("method", "signal", "property"):
 
976
                    for tag in if_tag.getElementsByTagName(typ):
 
977
                        annots = dict()
 
978
                        for name, prop in (self.
 
979
                                           _get_all_dbus_things(typ)):
 
980
                            if (name == tag.getAttribute("name")
 
981
                                and prop._dbus_interface
 
982
                                == if_tag.getAttribute("name")):
 
983
                                annots.update(getattr
 
984
                                              (prop,
 
985
                                               "_dbus_annotations",
 
986
                                               {}))
 
987
                        for name, value in annots.items():
 
988
                            ann_tag = document.createElement(
 
989
                                "annotation")
 
990
                            ann_tag.setAttribute("name", name)
 
991
                            ann_tag.setAttribute("value", value)
 
992
                            tag.appendChild(ann_tag)
 
993
                # Add interface annotation tags
 
994
                for annotation, value in dict(
 
995
                    itertools.chain.from_iterable(
 
996
                        annotations().items()
 
997
                        for name, annotations in
 
998
                        self._get_all_dbus_things("interface")
 
999
                        if name == if_tag.getAttribute("name")
 
1000
                        )).items():
 
1001
                    ann_tag = document.createElement("annotation")
 
1002
                    ann_tag.setAttribute("name", annotation)
 
1003
                    ann_tag.setAttribute("value", value)
 
1004
                    if_tag.appendChild(ann_tag)
907
1005
                # Add the names to the return values for the
908
1006
                # "org.freedesktop.DBus.Properties" methods
909
1007
                if (if_tag.getAttribute("name")
924
1022
        except (AttributeError, xml.dom.DOMException,
925
1023
                xml.parsers.expat.ExpatError) as error:
926
1024
            logger.error("Failed to override Introspection method",
927
 
                         error)
 
1025
                         exc_info=error)
928
1026
        return xmlstring
929
1027
 
930
1028
 
931
 
def datetime_to_dbus (dt, variant_level=0):
 
1029
def datetime_to_dbus(dt, variant_level=0):
932
1030
    """Convert a UTC datetime.datetime() to a D-Bus type."""
933
1031
    if dt is None:
934
1032
        return dbus.String("", variant_level = variant_level)
936
1034
                       variant_level=variant_level)
937
1035
 
938
1036
 
939
 
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
940
 
                                  .__metaclass__):
941
 
    """Applied to an empty subclass of a D-Bus object, this metaclass
942
 
    will add additional D-Bus attributes matching a certain pattern.
 
1037
def alternate_dbus_interfaces(alt_interface_names, deprecate=True):
 
1038
    """A class decorator; applied to a subclass of
 
1039
    dbus.service.Object, it will add alternate D-Bus attributes with
 
1040
    interface names according to the "alt_interface_names" mapping.
 
1041
    Usage:
 
1042
    
 
1043
    @alternate_dbus_interfaces({"org.example.Interface":
 
1044
                                    "net.example.AlternateInterface"})
 
1045
    class SampleDBusObject(dbus.service.Object):
 
1046
        @dbus.service.method("org.example.Interface")
 
1047
        def SampleDBusMethod():
 
1048
            pass
 
1049
    
 
1050
    The above "SampleDBusMethod" on "SampleDBusObject" will be
 
1051
    reachable via two interfaces: "org.example.Interface" and
 
1052
    "net.example.AlternateInterface", the latter of which will have
 
1053
    its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
 
1054
    "true", unless "deprecate" is passed with a False value.
 
1055
    
 
1056
    This works for methods and signals, and also for D-Bus properties
 
1057
    (from DBusObjectWithProperties) and interfaces (from the
 
1058
    dbus_interface_annotations decorator).
943
1059
    """
944
 
    def __new__(mcs, name, bases, attr):
945
 
        # Go through all the base classes which could have D-Bus
946
 
        # methods, signals, or properties in them
947
 
        for base in (b for b in bases
948
 
                     if issubclass(b, dbus.service.Object)):
949
 
            # Go though all attributes of the base class
950
 
            for attrname, attribute in inspect.getmembers(base):
 
1060
    def wrapper(cls):
 
1061
        for orig_interface_name, alt_interface_name in (
 
1062
            alt_interface_names.items()):
 
1063
            attr = {}
 
1064
            interface_names = set()
 
1065
            # Go though all attributes of the class
 
1066
            for attrname, attribute in inspect.getmembers(cls):
951
1067
                # Ignore non-D-Bus attributes, and D-Bus attributes
952
1068
                # with the wrong interface name
953
1069
                if (not hasattr(attribute, "_dbus_interface")
954
1070
                    or not attribute._dbus_interface
955
 
                    .startswith("se.recompile.Mandos")):
 
1071
                    .startswith(orig_interface_name)):
956
1072
                    continue
957
1073
                # Create an alternate D-Bus interface name based on
958
1074
                # the current name
959
1075
                alt_interface = (attribute._dbus_interface
960
 
                                 .replace("se.recompile.Mandos",
961
 
                                          "se.bsnet.fukt.Mandos"))
 
1076
                                 .replace(orig_interface_name,
 
1077
                                          alt_interface_name))
 
1078
                interface_names.add(alt_interface)
962
1079
                # Is this a D-Bus signal?
963
1080
                if getattr(attribute, "_dbus_is_signal", False):
964
 
                    # Extract the original non-method function by
965
 
                    # black magic
 
1081
                    # Extract the original non-method undecorated
 
1082
                    # function by black magic
966
1083
                    nonmethod_func = (dict(
967
1084
                            zip(attribute.func_code.co_freevars,
968
1085
                                attribute.__closure__))["func"]
979
1096
                                nonmethod_func.func_name,
980
1097
                                nonmethod_func.func_defaults,
981
1098
                                nonmethod_func.func_closure)))
 
1099
                    # Copy annotations, if any
 
1100
                    try:
 
1101
                        new_function._dbus_annotations = (
 
1102
                            dict(attribute._dbus_annotations))
 
1103
                    except AttributeError:
 
1104
                        pass
982
1105
                    # Define a creator of a function to call both the
983
 
                    # old and new functions, so both the old and new
984
 
                    # signals gets sent when the function is called
 
1106
                    # original and alternate functions, so both the
 
1107
                    # original and alternate signals gets sent when
 
1108
                    # the function is called
985
1109
                    def fixscope(func1, func2):
986
1110
                        """This function is a scope container to pass
987
1111
                        func1 and func2 to the "call_both" function
994
1118
                        return call_both
995
1119
                    # Create the "call_both" function and add it to
996
1120
                    # the class
997
 
                    attr[attrname] = fixscope(attribute,
998
 
                                              new_function)
 
1121
                    attr[attrname] = fixscope(attribute, new_function)
999
1122
                # Is this a D-Bus method?
1000
1123
                elif getattr(attribute, "_dbus_is_method", False):
1001
1124
                    # Create a new, but exactly alike, function
1012
1135
                                        attribute.func_name,
1013
1136
                                        attribute.func_defaults,
1014
1137
                                        attribute.func_closure)))
 
1138
                    # Copy annotations, if any
 
1139
                    try:
 
1140
                        attr[attrname]._dbus_annotations = (
 
1141
                            dict(attribute._dbus_annotations))
 
1142
                    except AttributeError:
 
1143
                        pass
1015
1144
                # Is this a D-Bus property?
1016
1145
                elif getattr(attribute, "_dbus_is_property", False):
1017
1146
                    # Create a new, but exactly alike, function
1031
1160
                                        attribute.func_name,
1032
1161
                                        attribute.func_defaults,
1033
1162
                                        attribute.func_closure)))
1034
 
        return type.__new__(mcs, name, bases, attr)
1035
 
 
1036
 
 
 
1163
                    # Copy annotations, if any
 
1164
                    try:
 
1165
                        attr[attrname]._dbus_annotations = (
 
1166
                            dict(attribute._dbus_annotations))
 
1167
                    except AttributeError:
 
1168
                        pass
 
1169
                # Is this a D-Bus interface?
 
1170
                elif getattr(attribute, "_dbus_is_interface", False):
 
1171
                    # Create a new, but exactly alike, function
 
1172
                    # object.  Decorate it to be a new D-Bus interface
 
1173
                    # with the alternate D-Bus interface name.  Add it
 
1174
                    # to the class.
 
1175
                    attr[attrname] = (dbus_interface_annotations
 
1176
                                      (alt_interface)
 
1177
                                      (types.FunctionType
 
1178
                                       (attribute.func_code,
 
1179
                                        attribute.func_globals,
 
1180
                                        attribute.func_name,
 
1181
                                        attribute.func_defaults,
 
1182
                                        attribute.func_closure)))
 
1183
            if deprecate:
 
1184
                # Deprecate all alternate interfaces
 
1185
                iname="_AlternateDBusNames_interface_annotation{}"
 
1186
                for interface_name in interface_names:
 
1187
                    @dbus_interface_annotations(interface_name)
 
1188
                    def func(self):
 
1189
                        return { "org.freedesktop.DBus.Deprecated":
 
1190
                                     "true" }
 
1191
                    # Find an unused name
 
1192
                    for aname in (iname.format(i)
 
1193
                                  for i in itertools.count()):
 
1194
                        if aname not in attr:
 
1195
                            attr[aname] = func
 
1196
                            break
 
1197
            if interface_names:
 
1198
                # Replace the class with a new subclass of it with
 
1199
                # methods, signals, etc. as created above.
 
1200
                cls = type(b"{}Alternate".format(cls.__name__),
 
1201
                           (cls,), attr)
 
1202
        return cls
 
1203
    return wrapper
 
1204
 
 
1205
 
 
1206
@alternate_dbus_interfaces({"se.recompile.Mandos":
 
1207
                                "se.bsnet.fukt.Mandos"})
1037
1208
class ClientDBus(Client, DBusObjectWithProperties):
1038
1209
    """A Client class using D-Bus
1039
1210
    
1059
1230
                                 ("/clients/" + client_object_name))
1060
1231
        DBusObjectWithProperties.__init__(self, self.bus,
1061
1232
                                          self.dbus_object_path)
1062
 
        
 
1233
    
1063
1234
    def notifychangeproperty(transform_func,
1064
1235
                             dbus_name, type_func=lambda x: x,
1065
1236
                             variant_level=1):
1073
1244
                   to the D-Bus.  Default: no transform
1074
1245
        variant_level: D-Bus variant level.  Default: 1
1075
1246
        """
1076
 
        attrname = "_{0}".format(dbus_name)
 
1247
        attrname = "_{}".format(dbus_name)
1077
1248
        def setter(self, value):
1078
1249
            if hasattr(self, "dbus_object_path"):
1079
1250
                if (not hasattr(self, attrname) or
1088
1259
        
1089
1260
        return property(lambda self: getattr(self, attrname), setter)
1090
1261
    
1091
 
    
1092
1262
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1093
1263
    approvals_pending = notifychangeproperty(dbus.Boolean,
1094
1264
                                             "ApprovalPending",
1110
1280
    approval_delay = notifychangeproperty(dbus.UInt64,
1111
1281
                                          "ApprovalDelay",
1112
1282
                                          type_func =
1113
 
                                          timedelta_to_milliseconds)
 
1283
                                          lambda td: td.total_seconds()
 
1284
                                          * 1000)
1114
1285
    approval_duration = notifychangeproperty(
1115
1286
        dbus.UInt64, "ApprovalDuration",
1116
 
        type_func = timedelta_to_milliseconds)
 
1287
        type_func = lambda td: td.total_seconds() * 1000)
1117
1288
    host = notifychangeproperty(dbus.String, "Host")
1118
1289
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1119
 
                                   type_func =
1120
 
                                   timedelta_to_milliseconds)
 
1290
                                   type_func = lambda td:
 
1291
                                       td.total_seconds() * 1000)
1121
1292
    extended_timeout = notifychangeproperty(
1122
1293
        dbus.UInt64, "ExtendedTimeout",
1123
 
        type_func = timedelta_to_milliseconds)
 
1294
        type_func = lambda td: td.total_seconds() * 1000)
1124
1295
    interval = notifychangeproperty(dbus.UInt64,
1125
1296
                                    "Interval",
1126
1297
                                    type_func =
1127
 
                                    timedelta_to_milliseconds)
 
1298
                                    lambda td: td.total_seconds()
 
1299
                                    * 1000)
1128
1300
    checker_command = notifychangeproperty(dbus.String, "Checker")
1129
1301
    
1130
1302
    del notifychangeproperty
1158
1330
                                       *args, **kwargs)
1159
1331
    
1160
1332
    def start_checker(self, *args, **kwargs):
1161
 
        old_checker = self.checker
1162
 
        if self.checker is not None:
1163
 
            old_checker_pid = self.checker.pid
1164
 
        else:
1165
 
            old_checker_pid = None
 
1333
        old_checker_pid = getattr(self.checker, "pid", None)
1166
1334
        r = Client.start_checker(self, *args, **kwargs)
1167
1335
        # Only if new checker process was started
1168
1336
        if (self.checker is not None
1176
1344
        return False
1177
1345
    
1178
1346
    def approve(self, value=True):
1179
 
        self.send_changedstate()
1180
1347
        self.approved = value
1181
 
        gobject.timeout_add(timedelta_to_milliseconds
1182
 
                            (self.approval_duration),
1183
 
                            self._reset_approved)
1184
 
    
 
1348
        gobject.timeout_add(int(self.approval_duration.total_seconds()
 
1349
                                * 1000), self._reset_approved)
 
1350
        self.send_changedstate()
1185
1351
    
1186
1352
    ## D-Bus methods, signals & properties
1187
1353
    _interface = "se.recompile.Mandos.Client"
1188
1354
    
 
1355
    ## Interfaces
 
1356
    
 
1357
    @dbus_interface_annotations(_interface)
 
1358
    def _foo(self):
 
1359
        return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
1360
                     "false"}
 
1361
    
1189
1362
    ## Signals
1190
1363
    
1191
1364
    # CheckerCompleted - signal
1282
1455
                           access="readwrite")
1283
1456
    def ApprovalDelay_dbus_property(self, value=None):
1284
1457
        if value is None:       # get
1285
 
            return dbus.UInt64(self.approval_delay_milliseconds())
 
1458
            return dbus.UInt64(self.approval_delay.total_seconds()
 
1459
                               * 1000)
1286
1460
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
1287
1461
    
1288
1462
    # ApprovalDuration - property
1290
1464
                           access="readwrite")
1291
1465
    def ApprovalDuration_dbus_property(self, value=None):
1292
1466
        if value is None:       # get
1293
 
            return dbus.UInt64(timedelta_to_milliseconds(
1294
 
                    self.approval_duration))
 
1467
            return dbus.UInt64(self.approval_duration.total_seconds()
 
1468
                               * 1000)
1295
1469
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1296
1470
    
1297
1471
    # Name - property
1363
1537
                           access="readwrite")
1364
1538
    def Timeout_dbus_property(self, value=None):
1365
1539
        if value is None:       # get
1366
 
            return dbus.UInt64(self.timeout_milliseconds())
 
1540
            return dbus.UInt64(self.timeout.total_seconds() * 1000)
 
1541
        old_timeout = self.timeout
1367
1542
        self.timeout = datetime.timedelta(0, 0, 0, value)
1368
 
        # Reschedule timeout
 
1543
        # Reschedule disabling
1369
1544
        if self.enabled:
1370
1545
            now = datetime.datetime.utcnow()
1371
 
            time_to_die = timedelta_to_milliseconds(
1372
 
                (self.last_checked_ok + self.timeout) - now)
1373
 
            if time_to_die <= 0:
 
1546
            self.expires += self.timeout - old_timeout
 
1547
            if self.expires <= now:
1374
1548
                # The timeout has passed
1375
1549
                self.disable()
1376
1550
            else:
1377
 
                self.expires = (now +
1378
 
                                datetime.timedelta(milliseconds =
1379
 
                                                   time_to_die))
1380
1551
                if (getattr(self, "disable_initiator_tag", None)
1381
1552
                    is None):
1382
1553
                    return
1383
1554
                gobject.source_remove(self.disable_initiator_tag)
1384
 
                self.disable_initiator_tag = (gobject.timeout_add
1385
 
                                              (time_to_die,
1386
 
                                               self.disable))
 
1555
                self.disable_initiator_tag = (
 
1556
                    gobject.timeout_add(
 
1557
                        int((self.expires - now).total_seconds()
 
1558
                            * 1000), self.disable))
1387
1559
    
1388
1560
    # ExtendedTimeout - property
1389
1561
    @dbus_service_property(_interface, signature="t",
1390
1562
                           access="readwrite")
1391
1563
    def ExtendedTimeout_dbus_property(self, value=None):
1392
1564
        if value is None:       # get
1393
 
            return dbus.UInt64(self.extended_timeout_milliseconds())
 
1565
            return dbus.UInt64(self.extended_timeout.total_seconds()
 
1566
                               * 1000)
1394
1567
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1395
1568
    
1396
1569
    # Interval - property
1398
1571
                           access="readwrite")
1399
1572
    def Interval_dbus_property(self, value=None):
1400
1573
        if value is None:       # get
1401
 
            return dbus.UInt64(self.interval_milliseconds())
 
1574
            return dbus.UInt64(self.interval.total_seconds() * 1000)
1402
1575
        self.interval = datetime.timedelta(0, 0, 0, value)
1403
1576
        if getattr(self, "checker_initiator_tag", None) is None:
1404
1577
            return
1437
1610
    @dbus_service_property(_interface, signature="ay",
1438
1611
                           access="write", byte_arrays=True)
1439
1612
    def Secret_dbus_property(self, value):
1440
 
        self.secret = str(value)
 
1613
        self.secret = bytes(value)
1441
1614
    
1442
1615
    del _interface
1443
1616
 
1468
1641
        self._pipe.send(('setattr', name, value))
1469
1642
 
1470
1643
 
1471
 
class ClientDBusTransitional(ClientDBus):
1472
 
    __metaclass__ = AlternateDBusNamesMetaclass
1473
 
 
1474
 
 
1475
1644
class ClientHandler(socketserver.BaseRequestHandler, object):
1476
1645
    """A class to handle client connections.
1477
1646
    
1513
1682
            logger.debug("Protocol version: %r", line)
1514
1683
            try:
1515
1684
                if int(line.strip().split()[0]) > 1:
1516
 
                    raise RuntimeError
 
1685
                    raise RuntimeError(line)
1517
1686
            except (ValueError, IndexError, RuntimeError) as error:
1518
1687
                logger.error("Unknown protocol version: %s", error)
1519
1688
                return
1568
1737
                        if self.server.use_dbus:
1569
1738
                            # Emit D-Bus signal
1570
1739
                            client.NeedApproval(
1571
 
                                client.approval_delay_milliseconds(),
1572
 
                                client.approved_by_default)
 
1740
                                client.approval_delay.total_seconds()
 
1741
                                * 1000, client.approved_by_default)
1573
1742
                    else:
1574
1743
                        logger.warning("Client %s was not approved",
1575
1744
                                       client.name)
1581
1750
                    #wait until timeout or approved
1582
1751
                    time = datetime.datetime.now()
1583
1752
                    client.changedstate.acquire()
1584
 
                    (client.changedstate.wait
1585
 
                     (float(client.timedelta_to_milliseconds(delay)
1586
 
                            / 1000)))
 
1753
                    client.changedstate.wait(delay.total_seconds())
1587
1754
                    client.changedstate.release()
1588
1755
                    time2 = datetime.datetime.now()
1589
1756
                    if (time2 - time) >= delay:
1605
1772
                    try:
1606
1773
                        sent = session.send(client.secret[sent_size:])
1607
1774
                    except gnutls.errors.GNUTLSError as error:
1608
 
                        logger.warning("gnutls send failed")
 
1775
                        logger.warning("gnutls send failed",
 
1776
                                       exc_info=error)
1609
1777
                        return
1610
1778
                    logger.debug("Sent: %d, remaining: %d",
1611
1779
                                 sent, len(client.secret)
1625
1793
                try:
1626
1794
                    session.bye()
1627
1795
                except gnutls.errors.GNUTLSError as error:
1628
 
                    logger.warning("GnuTLS bye failed")
 
1796
                    logger.warning("GnuTLS bye failed",
 
1797
                                   exc_info=error)
1629
1798
    
1630
1799
    @staticmethod
1631
1800
    def peer_certificate(session):
1703
1872
    def process_request(self, request, address):
1704
1873
        """Start a new process to process the request."""
1705
1874
        proc = multiprocessing.Process(target = self.sub_process_main,
1706
 
                                       args = (request,
1707
 
                                               address))
 
1875
                                       args = (request, address))
1708
1876
        proc.start()
1709
1877
        return proc
1710
1878
 
1725
1893
    
1726
1894
    def add_pipe(self, parent_pipe, proc):
1727
1895
        """Dummy function; override as necessary"""
1728
 
        raise NotImplementedError
 
1896
        raise NotImplementedError()
1729
1897
 
1730
1898
 
1731
1899
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1738
1906
        use_ipv6:       Boolean; to use IPv6 or not
1739
1907
    """
1740
1908
    def __init__(self, server_address, RequestHandlerClass,
1741
 
                 interface=None, use_ipv6=True):
 
1909
                 interface=None, use_ipv6=True, socketfd=None):
 
1910
        """If socketfd is set, use that file descriptor instead of
 
1911
        creating a new one with socket.socket().
 
1912
        """
1742
1913
        self.interface = interface
1743
1914
        if use_ipv6:
1744
1915
            self.address_family = socket.AF_INET6
 
1916
        if socketfd is not None:
 
1917
            # Save the file descriptor
 
1918
            self.socketfd = socketfd
 
1919
            # Save the original socket.socket() function
 
1920
            self.socket_socket = socket.socket
 
1921
            # To implement --socket, we monkey patch socket.socket.
 
1922
            # 
 
1923
            # (When socketserver.TCPServer is a new-style class, we
 
1924
            # could make self.socket into a property instead of monkey
 
1925
            # patching socket.socket.)
 
1926
            # 
 
1927
            # Create a one-time-only replacement for socket.socket()
 
1928
            @functools.wraps(socket.socket)
 
1929
            def socket_wrapper(*args, **kwargs):
 
1930
                # Restore original function so subsequent calls are
 
1931
                # not affected.
 
1932
                socket.socket = self.socket_socket
 
1933
                del self.socket_socket
 
1934
                # This time only, return a new socket object from the
 
1935
                # saved file descriptor.
 
1936
                return socket.fromfd(self.socketfd, *args, **kwargs)
 
1937
            # Replace socket.socket() function with wrapper
 
1938
            socket.socket = socket_wrapper
 
1939
        # The socketserver.TCPServer.__init__ will call
 
1940
        # socket.socket(), which might be our replacement,
 
1941
        # socket_wrapper(), if socketfd was set.
1745
1942
        socketserver.TCPServer.__init__(self, server_address,
1746
1943
                                        RequestHandlerClass)
 
1944
    
1747
1945
    def server_bind(self):
1748
1946
        """This overrides the normal server_bind() function
1749
1947
        to bind to an interface if one was specified, and also NOT to
1757
1955
                try:
1758
1956
                    self.socket.setsockopt(socket.SOL_SOCKET,
1759
1957
                                           SO_BINDTODEVICE,
1760
 
                                           str(self.interface
1761
 
                                               + '\0'))
 
1958
                                           (self.interface + "\0")
 
1959
                                           .encode("utf-8"))
1762
1960
                except socket.error as error:
1763
 
                    if error[0] == errno.EPERM:
1764
 
                        logger.error("No permission to"
1765
 
                                     " bind to interface %s",
1766
 
                                     self.interface)
1767
 
                    elif error[0] == errno.ENOPROTOOPT:
 
1961
                    if error.errno == errno.EPERM:
 
1962
                        logger.error("No permission to bind to"
 
1963
                                     " interface %s", self.interface)
 
1964
                    elif error.errno == errno.ENOPROTOOPT:
1768
1965
                        logger.error("SO_BINDTODEVICE not available;"
1769
1966
                                     " cannot bind to interface %s",
1770
1967
                                     self.interface)
 
1968
                    elif error.errno == errno.ENODEV:
 
1969
                        logger.error("Interface %s does not exist,"
 
1970
                                     " cannot bind", self.interface)
1771
1971
                    else:
1772
1972
                        raise
1773
1973
        # Only bind(2) the socket if we really need to.
1776
1976
                if self.address_family == socket.AF_INET6:
1777
1977
                    any_address = "::" # in6addr_any
1778
1978
                else:
1779
 
                    any_address = socket.INADDR_ANY
 
1979
                    any_address = "0.0.0.0" # INADDR_ANY
1780
1980
                self.server_address = (any_address,
1781
1981
                                       self.server_address[1])
1782
1982
            elif not self.server_address[1]:
1803
2003
    """
1804
2004
    def __init__(self, server_address, RequestHandlerClass,
1805
2005
                 interface=None, use_ipv6=True, clients=None,
1806
 
                 gnutls_priority=None, use_dbus=True):
 
2006
                 gnutls_priority=None, use_dbus=True, socketfd=None):
1807
2007
        self.enabled = False
1808
2008
        self.clients = clients
1809
2009
        if self.clients is None:
1813
2013
        IPv6_TCPServer.__init__(self, server_address,
1814
2014
                                RequestHandlerClass,
1815
2015
                                interface = interface,
1816
 
                                use_ipv6 = use_ipv6)
 
2016
                                use_ipv6 = use_ipv6,
 
2017
                                socketfd = socketfd)
1817
2018
    def server_activate(self):
1818
2019
        if self.enabled:
1819
2020
            return socketserver.TCPServer.server_activate(self)
1832
2033
    
1833
2034
    def handle_ipc(self, source, condition, parent_pipe=None,
1834
2035
                   proc = None, client_object=None):
1835
 
        condition_names = {
1836
 
            gobject.IO_IN: "IN",   # There is data to read.
1837
 
            gobject.IO_OUT: "OUT", # Data can be written (without
1838
 
                                    # blocking).
1839
 
            gobject.IO_PRI: "PRI", # There is urgent data to read.
1840
 
            gobject.IO_ERR: "ERR", # Error condition.
1841
 
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
1842
 
                                    # broken, usually for pipes and
1843
 
                                    # sockets).
1844
 
            }
1845
 
        conditions_string = ' | '.join(name
1846
 
                                       for cond, name in
1847
 
                                       condition_names.iteritems()
1848
 
                                       if cond & condition)
1849
2036
        # error, or the other end of multiprocessing.Pipe has closed
1850
 
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
2037
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
1851
2038
            # Wait for other process to exit
1852
2039
            proc.join()
1853
2040
            return False
1911
2098
        return True
1912
2099
 
1913
2100
 
 
2101
def rfc3339_duration_to_delta(duration):
 
2102
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
 
2103
    
 
2104
    >>> rfc3339_duration_to_delta("P7D")
 
2105
    datetime.timedelta(7)
 
2106
    >>> rfc3339_duration_to_delta("PT60S")
 
2107
    datetime.timedelta(0, 60)
 
2108
    >>> rfc3339_duration_to_delta("PT60M")
 
2109
    datetime.timedelta(0, 3600)
 
2110
    >>> rfc3339_duration_to_delta("PT24H")
 
2111
    datetime.timedelta(1)
 
2112
    >>> rfc3339_duration_to_delta("P1W")
 
2113
    datetime.timedelta(7)
 
2114
    >>> rfc3339_duration_to_delta("PT5M30S")
 
2115
    datetime.timedelta(0, 330)
 
2116
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
2117
    datetime.timedelta(1, 200)
 
2118
    """
 
2119
    
 
2120
    # Parsing an RFC 3339 duration with regular expressions is not
 
2121
    # possible - there would have to be multiple places for the same
 
2122
    # values, like seconds.  The current code, while more esoteric, is
 
2123
    # cleaner without depending on a parsing library.  If Python had a
 
2124
    # built-in library for parsing we would use it, but we'd like to
 
2125
    # avoid excessive use of external libraries.
 
2126
    
 
2127
    # New type for defining tokens, syntax, and semantics all-in-one
 
2128
    Token = collections.namedtuple("Token",
 
2129
                                   ("regexp", # To match token; if
 
2130
                                              # "value" is not None,
 
2131
                                              # must have a "group"
 
2132
                                              # containing digits
 
2133
                                    "value",  # datetime.timedelta or
 
2134
                                              # None
 
2135
                                    "followers")) # Tokens valid after
 
2136
                                                  # this token
 
2137
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
2138
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
2139
    token_end = Token(re.compile(r"$"), None, frozenset())
 
2140
    token_second = Token(re.compile(r"(\d+)S"),
 
2141
                         datetime.timedelta(seconds=1),
 
2142
                         frozenset((token_end,)))
 
2143
    token_minute = Token(re.compile(r"(\d+)M"),
 
2144
                         datetime.timedelta(minutes=1),
 
2145
                         frozenset((token_second, token_end)))
 
2146
    token_hour = Token(re.compile(r"(\d+)H"),
 
2147
                       datetime.timedelta(hours=1),
 
2148
                       frozenset((token_minute, token_end)))
 
2149
    token_time = Token(re.compile(r"T"),
 
2150
                       None,
 
2151
                       frozenset((token_hour, token_minute,
 
2152
                                  token_second)))
 
2153
    token_day = Token(re.compile(r"(\d+)D"),
 
2154
                      datetime.timedelta(days=1),
 
2155
                      frozenset((token_time, token_end)))
 
2156
    token_month = Token(re.compile(r"(\d+)M"),
 
2157
                        datetime.timedelta(weeks=4),
 
2158
                        frozenset((token_day, token_end)))
 
2159
    token_year = Token(re.compile(r"(\d+)Y"),
 
2160
                       datetime.timedelta(weeks=52),
 
2161
                       frozenset((token_month, token_end)))
 
2162
    token_week = Token(re.compile(r"(\d+)W"),
 
2163
                       datetime.timedelta(weeks=1),
 
2164
                       frozenset((token_end,)))
 
2165
    token_duration = Token(re.compile(r"P"), None,
 
2166
                           frozenset((token_year, token_month,
 
2167
                                      token_day, token_time,
 
2168
                                      token_week)))
 
2169
    # Define starting values
 
2170
    value = datetime.timedelta() # Value so far
 
2171
    found_token = None
 
2172
    followers = frozenset((token_duration,)) # Following valid tokens
 
2173
    s = duration                # String left to parse
 
2174
    # Loop until end token is found
 
2175
    while found_token is not token_end:
 
2176
        # Search for any currently valid tokens
 
2177
        for token in followers:
 
2178
            match = token.regexp.match(s)
 
2179
            if match is not None:
 
2180
                # Token found
 
2181
                if token.value is not None:
 
2182
                    # Value found, parse digits
 
2183
                    factor = int(match.group(1), 10)
 
2184
                    # Add to value so far
 
2185
                    value += factor * token.value
 
2186
                # Strip token from string
 
2187
                s = token.regexp.sub("", s, 1)
 
2188
                # Go to found token
 
2189
                found_token = token
 
2190
                # Set valid next tokens
 
2191
                followers = found_token.followers
 
2192
                break
 
2193
        else:
 
2194
            # No currently valid tokens were found
 
2195
            raise ValueError("Invalid RFC 3339 duration")
 
2196
    # End token found
 
2197
    return value
 
2198
 
 
2199
 
1914
2200
def string_to_delta(interval):
1915
2201
    """Parse a string and return a datetime.timedelta
1916
2202
    
1927
2213
    >>> string_to_delta('5m 30s')
1928
2214
    datetime.timedelta(0, 330)
1929
2215
    """
 
2216
    
 
2217
    try:
 
2218
        return rfc3339_duration_to_delta(interval)
 
2219
    except ValueError:
 
2220
        pass
 
2221
    
1930
2222
    timevalue = datetime.timedelta(0)
1931
2223
    for s in interval.split():
1932
2224
        try:
1933
 
            suffix = unicode(s[-1])
 
2225
            suffix = s[-1]
1934
2226
            value = int(s[:-1])
1935
2227
            if suffix == "d":
1936
2228
                delta = datetime.timedelta(value)
1943
2235
            elif suffix == "w":
1944
2236
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1945
2237
            else:
1946
 
                raise ValueError("Unknown suffix %r" % suffix)
1947
 
        except (ValueError, IndexError) as e:
 
2238
                raise ValueError("Unknown suffix {!r}"
 
2239
                                 .format(suffix))
 
2240
        except IndexError as e:
1948
2241
            raise ValueError(*(e.args))
1949
2242
        timevalue += delta
1950
2243
    return timevalue
1963
2256
        sys.exit()
1964
2257
    if not noclose:
1965
2258
        # Close all standard open file descriptors
1966
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2259
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1967
2260
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1968
 
            raise OSError(errno.ENODEV,
1969
 
                          "%s not a character device"
1970
 
                          % os.path.devnull)
 
2261
            raise OSError(errno.ENODEV, "{} not a character device"
 
2262
                          .format(os.devnull))
1971
2263
        os.dup2(null, sys.stdin.fileno())
1972
2264
        os.dup2(null, sys.stdout.fileno())
1973
2265
        os.dup2(null, sys.stderr.fileno())
1982
2274
    
1983
2275
    parser = argparse.ArgumentParser()
1984
2276
    parser.add_argument("-v", "--version", action="version",
1985
 
                        version = "%%(prog)s %s" % version,
 
2277
                        version = "%(prog)s {}".format(version),
1986
2278
                        help="show version number and exit")
1987
2279
    parser.add_argument("-i", "--interface", metavar="IF",
1988
2280
                        help="Bind to interface IF")
1994
2286
                        help="Run self-test")
1995
2287
    parser.add_argument("--debug", action="store_true",
1996
2288
                        help="Debug mode; run in foreground and log"
1997
 
                        " to terminal")
 
2289
                        " to terminal", default=None)
1998
2290
    parser.add_argument("--debuglevel", metavar="LEVEL",
1999
2291
                        help="Debug level for stdout output")
2000
2292
    parser.add_argument("--priority", help="GnuTLS"
2007
2299
                        " files")
2008
2300
    parser.add_argument("--no-dbus", action="store_false",
2009
2301
                        dest="use_dbus", help="Do not provide D-Bus"
2010
 
                        " system bus interface")
 
2302
                        " system bus interface", default=None)
2011
2303
    parser.add_argument("--no-ipv6", action="store_false",
2012
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2304
                        dest="use_ipv6", help="Do not use IPv6",
 
2305
                        default=None)
2013
2306
    parser.add_argument("--no-restore", action="store_false",
2014
2307
                        dest="restore", help="Do not restore stored"
2015
 
                        " state")
 
2308
                        " state", default=None)
 
2309
    parser.add_argument("--socket", type=int,
 
2310
                        help="Specify a file descriptor to a network"
 
2311
                        " socket to use instead of creating one")
2016
2312
    parser.add_argument("--statedir", metavar="DIR",
2017
2313
                        help="Directory to save/restore state in")
 
2314
    parser.add_argument("--foreground", action="store_true",
 
2315
                        help="Run in foreground", default=None)
 
2316
    parser.add_argument("--no-zeroconf", action="store_false",
 
2317
                        dest="zeroconf", help="Do not use Zeroconf",
 
2318
                        default=None)
2018
2319
    
2019
2320
    options = parser.parse_args()
2020
2321
    
2021
2322
    if options.check:
2022
2323
        import doctest
2023
 
        doctest.testmod()
2024
 
        sys.exit()
 
2324
        fail_count, test_count = doctest.testmod()
 
2325
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2025
2326
    
2026
2327
    # Default values for config file for server-global settings
2027
2328
    server_defaults = { "interface": "",
2029
2330
                        "port": "",
2030
2331
                        "debug": "False",
2031
2332
                        "priority":
2032
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2333
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2033
2334
                        "servicename": "Mandos",
2034
2335
                        "use_dbus": "True",
2035
2336
                        "use_ipv6": "True",
2036
2337
                        "debuglevel": "",
2037
2338
                        "restore": "True",
2038
 
                        "statedir": "/var/lib/mandos"
 
2339
                        "socket": "",
 
2340
                        "statedir": "/var/lib/mandos",
 
2341
                        "foreground": "False",
 
2342
                        "zeroconf": "True",
2039
2343
                        }
2040
2344
    
2041
2345
    # Parse config file for server-global settings
2046
2350
    # Convert the SafeConfigParser object to a dict
2047
2351
    server_settings = server_config.defaults()
2048
2352
    # Use the appropriate methods on the non-string config options
2049
 
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2353
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2050
2354
        server_settings[option] = server_config.getboolean("DEFAULT",
2051
2355
                                                           option)
2052
2356
    if server_settings["port"]:
2053
2357
        server_settings["port"] = server_config.getint("DEFAULT",
2054
2358
                                                       "port")
 
2359
    if server_settings["socket"]:
 
2360
        server_settings["socket"] = server_config.getint("DEFAULT",
 
2361
                                                         "socket")
 
2362
        # Later, stdin will, and stdout and stderr might, be dup'ed
 
2363
        # over with an opened os.devnull.  But we don't want this to
 
2364
        # happen with a supplied network socket.
 
2365
        if 0 <= server_settings["socket"] <= 2:
 
2366
            server_settings["socket"] = os.dup(server_settings
 
2367
                                               ["socket"])
2055
2368
    del server_config
2056
2369
    
2057
2370
    # Override the settings from the config file with command line
2059
2372
    for option in ("interface", "address", "port", "debug",
2060
2373
                   "priority", "servicename", "configdir",
2061
2374
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2062
 
                   "statedir"):
 
2375
                   "statedir", "socket", "foreground", "zeroconf"):
2063
2376
        value = getattr(options, option)
2064
2377
        if value is not None:
2065
2378
            server_settings[option] = value
2066
2379
    del options
2067
2380
    # Force all strings to be unicode
2068
2381
    for option in server_settings.keys():
2069
 
        if type(server_settings[option]) is str:
2070
 
            server_settings[option] = unicode(server_settings[option])
 
2382
        if isinstance(server_settings[option], bytes):
 
2383
            server_settings[option] = (server_settings[option]
 
2384
                                       .decode("utf-8"))
 
2385
    # Force all boolean options to be boolean
 
2386
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
 
2387
                   "foreground", "zeroconf"):
 
2388
        server_settings[option] = bool(server_settings[option])
 
2389
    # Debug implies foreground
 
2390
    if server_settings["debug"]:
 
2391
        server_settings["foreground"] = True
2071
2392
    # Now we have our good server settings in "server_settings"
2072
2393
    
2073
2394
    ##################################################################
2074
2395
    
 
2396
    if (not server_settings["zeroconf"] and
 
2397
        not (server_settings["port"]
 
2398
             or server_settings["socket"] != "")):
 
2399
            parser.error("Needs port or socket to work without"
 
2400
                         " Zeroconf")
 
2401
    
2075
2402
    # For convenience
2076
2403
    debug = server_settings["debug"]
2077
2404
    debuglevel = server_settings["debuglevel"]
2079
2406
    use_ipv6 = server_settings["use_ipv6"]
2080
2407
    stored_state_path = os.path.join(server_settings["statedir"],
2081
2408
                                     stored_state_file)
 
2409
    foreground = server_settings["foreground"]
 
2410
    zeroconf = server_settings["zeroconf"]
2082
2411
    
2083
2412
    if debug:
2084
2413
        initlogger(debug, logging.DEBUG)
2091
2420
    
2092
2421
    if server_settings["servicename"] != "Mandos":
2093
2422
        syslogger.setFormatter(logging.Formatter
2094
 
                               ('Mandos (%s) [%%(process)d]:'
2095
 
                                ' %%(levelname)s: %%(message)s'
2096
 
                                % server_settings["servicename"]))
 
2423
                               ('Mandos ({}) [%(process)d]:'
 
2424
                                ' %(levelname)s: %(message)s'
 
2425
                                .format(server_settings
 
2426
                                        ["servicename"])))
2097
2427
    
2098
2428
    # Parse config file with clients
2099
2429
    client_config = configparser.SafeConfigParser(Client
2104
2434
    global mandos_dbus_service
2105
2435
    mandos_dbus_service = None
2106
2436
    
 
2437
    socketfd = None
 
2438
    if server_settings["socket"] != "":
 
2439
        socketfd = server_settings["socket"]
2107
2440
    tcp_server = MandosServer((server_settings["address"],
2108
2441
                               server_settings["port"]),
2109
2442
                              ClientHandler,
2112
2445
                              use_ipv6=use_ipv6,
2113
2446
                              gnutls_priority=
2114
2447
                              server_settings["priority"],
2115
 
                              use_dbus=use_dbus)
2116
 
    if not debug:
2117
 
        pidfilename = "/var/run/mandos.pid"
 
2448
                              use_dbus=use_dbus,
 
2449
                              socketfd=socketfd)
 
2450
    if not foreground:
 
2451
        pidfilename = "/run/mandos.pid"
 
2452
        if not os.path.isdir("/run/."):
 
2453
            pidfilename = "/var/run/mandos.pid"
 
2454
        pidfile = None
2118
2455
        try:
2119
2456
            pidfile = open(pidfilename, "w")
2120
 
        except IOError:
2121
 
            logger.error("Could not open file %r", pidfilename)
 
2457
        except IOError as e:
 
2458
            logger.error("Could not open file %r", pidfilename,
 
2459
                         exc_info=e)
2122
2460
    
2123
 
    try:
2124
 
        uid = pwd.getpwnam("_mandos").pw_uid
2125
 
        gid = pwd.getpwnam("_mandos").pw_gid
2126
 
    except KeyError:
 
2461
    for name in ("_mandos", "mandos", "nobody"):
2127
2462
        try:
2128
 
            uid = pwd.getpwnam("mandos").pw_uid
2129
 
            gid = pwd.getpwnam("mandos").pw_gid
 
2463
            uid = pwd.getpwnam(name).pw_uid
 
2464
            gid = pwd.getpwnam(name).pw_gid
 
2465
            break
2130
2466
        except KeyError:
2131
 
            try:
2132
 
                uid = pwd.getpwnam("nobody").pw_uid
2133
 
                gid = pwd.getpwnam("nobody").pw_gid
2134
 
            except KeyError:
2135
 
                uid = 65534
2136
 
                gid = 65534
 
2467
            continue
 
2468
    else:
 
2469
        uid = 65534
 
2470
        gid = 65534
2137
2471
    try:
2138
2472
        os.setgid(gid)
2139
2473
        os.setuid(uid)
2140
2474
    except OSError as error:
2141
 
        if error[0] != errno.EPERM:
2142
 
            raise error
 
2475
        if error.errno != errno.EPERM:
 
2476
            raise
2143
2477
    
2144
2478
    if debug:
2145
2479
        # Enable all possible GnuTLS debugging
2156
2490
         .gnutls_global_set_log_function(debug_gnutls))
2157
2491
        
2158
2492
        # Redirect stdin so all checkers get /dev/null
2159
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2493
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2160
2494
        os.dup2(null, sys.stdin.fileno())
2161
2495
        if null > 2:
2162
2496
            os.close(null)
2163
2497
    
2164
2498
    # Need to fork before connecting to D-Bus
2165
 
    if not debug:
 
2499
    if not foreground:
2166
2500
        # Close all input and output, do double fork, etc.
2167
2501
        daemon()
2168
2502
    
 
2503
    # multiprocessing will use threads, so before we use gobject we
 
2504
    # need to inform gobject that threads will be used.
2169
2505
    gobject.threads_init()
2170
2506
    
2171
2507
    global main_loop
2172
2508
    # From the Avahi example code
2173
 
    DBusGMainLoop(set_as_default=True )
 
2509
    DBusGMainLoop(set_as_default=True)
2174
2510
    main_loop = gobject.MainLoop()
2175
2511
    bus = dbus.SystemBus()
2176
2512
    # End of Avahi example code
2182
2518
                            ("se.bsnet.fukt.Mandos", bus,
2183
2519
                             do_not_queue=True))
2184
2520
        except dbus.exceptions.NameExistsException as e:
2185
 
            logger.error(unicode(e) + ", disabling D-Bus")
 
2521
            logger.error("Disabling D-Bus:", exc_info=e)
2186
2522
            use_dbus = False
2187
2523
            server_settings["use_dbus"] = False
2188
2524
            tcp_server.use_dbus = False
2189
 
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2190
 
    service = AvahiServiceToSyslog(name =
2191
 
                                   server_settings["servicename"],
2192
 
                                   servicetype = "_mandos._tcp",
2193
 
                                   protocol = protocol, bus = bus)
2194
 
    if server_settings["interface"]:
2195
 
        service.interface = (if_nametoindex
2196
 
                             (str(server_settings["interface"])))
 
2525
    if zeroconf:
 
2526
        protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
 
2527
        service = AvahiServiceToSyslog(name =
 
2528
                                       server_settings["servicename"],
 
2529
                                       servicetype = "_mandos._tcp",
 
2530
                                       protocol = protocol, bus = bus)
 
2531
        if server_settings["interface"]:
 
2532
            service.interface = (if_nametoindex
 
2533
                                 (server_settings["interface"]
 
2534
                                  .encode("utf-8")))
2197
2535
    
2198
2536
    global multiprocessing_manager
2199
2537
    multiprocessing_manager = multiprocessing.Manager()
2200
2538
    
2201
2539
    client_class = Client
2202
2540
    if use_dbus:
2203
 
        client_class = functools.partial(ClientDBusTransitional,
2204
 
                                         bus = bus)
 
2541
        client_class = functools.partial(ClientDBus, bus = bus)
2205
2542
    
2206
2543
    client_settings = Client.config_parser(client_config)
2207
2544
    old_client_settings = {}
2208
2545
    clients_data = {}
2209
2546
    
 
2547
    # This is used to redirect stdout and stderr for checker processes
 
2548
    global wnull
 
2549
    wnull = open(os.devnull, "w") # A writable /dev/null
 
2550
    # Only used if server is running in foreground but not in debug
 
2551
    # mode
 
2552
    if debug or not foreground:
 
2553
        wnull.close()
 
2554
    
2210
2555
    # Get client data and settings from last running state.
2211
2556
    if server_settings["restore"]:
2212
2557
        try:
2215
2560
                                                     (stored_state))
2216
2561
            os.remove(stored_state_path)
2217
2562
        except IOError as e:
2218
 
            logger.warning("Could not load persistent state: {0}"
2219
 
                           .format(e))
2220
 
            if e.errno != errno.ENOENT:
 
2563
            if e.errno == errno.ENOENT:
 
2564
                logger.warning("Could not load persistent state: {}"
 
2565
                                .format(os.strerror(e.errno)))
 
2566
            else:
 
2567
                logger.critical("Could not load persistent state:",
 
2568
                                exc_info=e)
2221
2569
                raise
2222
2570
        except EOFError as e:
2223
2571
            logger.warning("Could not load persistent state: "
2224
 
                           "EOFError: {0}".format(e))
 
2572
                           "EOFError:", exc_info=e)
2225
2573
    
2226
2574
    with PGPEngine() as pgp:
2227
 
        for client_name, client in clients_data.iteritems():
 
2575
        for client_name, client in clients_data.items():
 
2576
            # Skip removed clients
 
2577
            if client_name not in client_settings:
 
2578
                continue
 
2579
            
2228
2580
            # Decide which value to use after restoring saved state.
2229
2581
            # We have three different values: Old config file,
2230
2582
            # new config file, and saved state.
2251
2603
                if datetime.datetime.utcnow() >= client["expires"]:
2252
2604
                    if not client["last_checked_ok"]:
2253
2605
                        logger.warning(
2254
 
                            "disabling client {0} - Client never "
 
2606
                            "disabling client {} - Client never "
2255
2607
                            "performed a successful checker"
2256
2608
                            .format(client_name))
2257
2609
                        client["enabled"] = False
2258
2610
                    elif client["last_checker_status"] != 0:
2259
2611
                        logger.warning(
2260
 
                            "disabling client {0} - Client "
2261
 
                            "last checker failed with error code {1}"
 
2612
                            "disabling client {} - Client last"
 
2613
                            " checker failed with error code {}"
2262
2614
                            .format(client_name,
2263
2615
                                    client["last_checker_status"]))
2264
2616
                        client["enabled"] = False
2267
2619
                                             .utcnow()
2268
2620
                                             + client["timeout"])
2269
2621
                        logger.debug("Last checker succeeded,"
2270
 
                                     " keeping {0} enabled"
 
2622
                                     " keeping {} enabled"
2271
2623
                                     .format(client_name))
2272
2624
            try:
2273
2625
                client["secret"] = (
2276
2628
                                ["secret"]))
2277
2629
            except PGPError:
2278
2630
                # If decryption fails, we use secret from new settings
2279
 
                logger.debug("Failed to decrypt {0} old secret"
 
2631
                logger.debug("Failed to decrypt {} old secret"
2280
2632
                             .format(client_name))
2281
2633
                client["secret"] = (
2282
2634
                    client_settings[client_name]["secret"])
2283
 
 
2284
2635
    
2285
2636
    # Add/remove clients based on new changes made to config
2286
2637
    for client_name in (set(old_client_settings)
2289
2640
    for client_name in (set(client_settings)
2290
2641
                        - set(old_client_settings)):
2291
2642
        clients_data[client_name] = client_settings[client_name]
2292
 
 
 
2643
    
2293
2644
    # Create all client objects
2294
 
    for client_name, client in clients_data.iteritems():
 
2645
    for client_name, client in clients_data.items():
2295
2646
        tcp_server.clients[client_name] = client_class(
2296
 
            name = client_name, settings = client)
 
2647
            name = client_name, settings = client,
 
2648
            server_settings = server_settings)
2297
2649
    
2298
2650
    if not tcp_server.clients:
2299
2651
        logger.warning("No clients defined")
2300
 
        
2301
 
    if not debug:
2302
 
        try:
2303
 
            with pidfile:
2304
 
                pid = os.getpid()
2305
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
2306
 
            del pidfile
2307
 
        except IOError:
2308
 
            logger.error("Could not write to file %r with PID %d",
2309
 
                         pidfilename, pid)
2310
 
        except NameError:
2311
 
            # "pidfile" was never created
2312
 
            pass
 
2652
    
 
2653
    if not foreground:
 
2654
        if pidfile is not None:
 
2655
            try:
 
2656
                with pidfile:
 
2657
                    pid = os.getpid()
 
2658
                    pidfile.write("{}\n".format(pid).encode("utf-8"))
 
2659
            except IOError:
 
2660
                logger.error("Could not write to file %r with PID %d",
 
2661
                             pidfilename, pid)
 
2662
        del pidfile
2313
2663
        del pidfilename
2314
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2315
2664
    
2316
2665
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2317
2666
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2318
2667
    
2319
2668
    if use_dbus:
2320
 
        class MandosDBusService(dbus.service.Object):
 
2669
        @alternate_dbus_interfaces({"se.recompile.Mandos":
 
2670
                                        "se.bsnet.fukt.Mandos"})
 
2671
        class MandosDBusService(DBusObjectWithProperties):
2321
2672
            """A D-Bus proxy object"""
2322
2673
            def __init__(self):
2323
2674
                dbus.service.Object.__init__(self, bus, "/")
2324
2675
            _interface = "se.recompile.Mandos"
2325
2676
            
 
2677
            @dbus_interface_annotations(_interface)
 
2678
            def _foo(self):
 
2679
                return { "org.freedesktop.DBus.Property"
 
2680
                         ".EmitsChangedSignal":
 
2681
                             "false"}
 
2682
            
2326
2683
            @dbus.service.signal(_interface, signature="o")
2327
2684
            def ClientAdded(self, objpath):
2328
2685
                "D-Bus signal"
2370
2727
            
2371
2728
            del _interface
2372
2729
        
2373
 
        class MandosDBusServiceTransitional(MandosDBusService):
2374
 
            __metaclass__ = AlternateDBusNamesMetaclass
2375
 
        mandos_dbus_service = MandosDBusServiceTransitional()
 
2730
        mandos_dbus_service = MandosDBusService()
2376
2731
    
2377
2732
    def cleanup():
2378
2733
        "Cleanup function; run on exit"
2379
 
        service.cleanup()
 
2734
        if zeroconf:
 
2735
            service.cleanup()
2380
2736
        
2381
2737
        multiprocessing.active_children()
 
2738
        wnull.close()
2382
2739
        if not (tcp_server.clients or client_settings):
2383
2740
            return
2384
2741
        
2395
2752
                
2396
2753
                # A list of attributes that can not be pickled
2397
2754
                # + secret.
2398
 
                exclude = set(("bus", "changedstate", "secret",
2399
 
                               "checker"))
 
2755
                exclude = { "bus", "changedstate", "secret",
 
2756
                            "checker", "server_settings" }
2400
2757
                for name, typ in (inspect.getmembers
2401
2758
                                  (dbus.service.Object)):
2402
2759
                    exclude.add(name)
2411
2768
                del client_settings[client.name]["secret"]
2412
2769
        
2413
2770
        try:
2414
 
            tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2415
 
                                                prefix="clients-",
2416
 
                                                dir=os.path.dirname
2417
 
                                                (stored_state_path))
2418
 
            with os.fdopen(tempfd, "wb") as stored_state:
 
2771
            with (tempfile.NamedTemporaryFile
 
2772
                  (mode='wb', suffix=".pickle", prefix='clients-',
 
2773
                   dir=os.path.dirname(stored_state_path),
 
2774
                   delete=False)) as stored_state:
2419
2775
                pickle.dump((clients, client_settings), stored_state)
 
2776
                tempname=stored_state.name
2420
2777
            os.rename(tempname, stored_state_path)
2421
2778
        except (IOError, OSError) as e:
2422
 
            logger.warning("Could not save persistent state: {0}"
2423
 
                           .format(e))
2424
2779
            if not debug:
2425
2780
                try:
2426
2781
                    os.remove(tempname)
2427
2782
                except NameError:
2428
2783
                    pass
2429
 
            if e.errno not in set((errno.ENOENT, errno.EACCES,
2430
 
                                   errno.EEXIST)):
2431
 
                raise e
 
2784
            if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):
 
2785
                logger.warning("Could not save persistent state: {}"
 
2786
                               .format(os.strerror(e.errno)))
 
2787
            else:
 
2788
                logger.warning("Could not save persistent state:",
 
2789
                               exc_info=e)
 
2790
                raise
2432
2791
        
2433
2792
        # Delete all clients, and settings from config
2434
2793
        while tcp_server.clients:
2458
2817
    tcp_server.server_activate()
2459
2818
    
2460
2819
    # Find out what port we got
2461
 
    service.port = tcp_server.socket.getsockname()[1]
 
2820
    if zeroconf:
 
2821
        service.port = tcp_server.socket.getsockname()[1]
2462
2822
    if use_ipv6:
2463
2823
        logger.info("Now listening on address %r, port %d,"
2464
 
                    " flowinfo %d, scope_id %d"
2465
 
                    % tcp_server.socket.getsockname())
 
2824
                    " flowinfo %d, scope_id %d",
 
2825
                    *tcp_server.socket.getsockname())
2466
2826
    else:                       # IPv4
2467
 
        logger.info("Now listening on address %r, port %d"
2468
 
                    % tcp_server.socket.getsockname())
 
2827
        logger.info("Now listening on address %r, port %d",
 
2828
                    *tcp_server.socket.getsockname())
2469
2829
    
2470
2830
    #service.interface = tcp_server.socket.getsockname()[3]
2471
2831
    
2472
2832
    try:
2473
 
        # From the Avahi example code
2474
 
        try:
2475
 
            service.activate()
2476
 
        except dbus.exceptions.DBusException as error:
2477
 
            logger.critical("DBusException: %s", error)
2478
 
            cleanup()
2479
 
            sys.exit(1)
2480
 
        # End of Avahi example code
 
2833
        if zeroconf:
 
2834
            # From the Avahi example code
 
2835
            try:
 
2836
                service.activate()
 
2837
            except dbus.exceptions.DBusException as error:
 
2838
                logger.critical("D-Bus Exception", exc_info=error)
 
2839
                cleanup()
 
2840
                sys.exit(1)
 
2841
            # End of Avahi example code
2481
2842
        
2482
2843
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2483
2844
                             lambda *args, **kwargs:
2487
2848
        logger.debug("Starting main loop")
2488
2849
        main_loop.run()
2489
2850
    except AvahiError as error:
2490
 
        logger.critical("AvahiError: %s", error)
 
2851
        logger.critical("Avahi Error", exc_info=error)
2491
2852
        cleanup()
2492
2853
        sys.exit(1)
2493
2854
    except KeyboardInterrupt: