/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.1"
 
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
    
415
428
    last_checked_ok: datetime.datetime(); (UTC) or None
416
429
    last_checker_status: integer between 0 and 255 reflecting exit
417
430
                         status of last checker. -1 reflects crashed
418
 
                         checker, or None.
 
431
                         checker, -2 means no checker completed yet.
419
432
    last_enabled: datetime.datetime(); (UTC) or None
420
433
    name:       string; from the config file, used in log messages and
421
434
                        D-Bus identifiers
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"])
501
501
            client["checker_command"] = section["checker"]
502
502
            client["last_approval_request"] = None
503
503
            client["last_checked_ok"] = None
504
 
            client["last_checker_status"] = None
 
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
    
626
631
            logger.warning("Checker for %(name)s crashed?",
627
632
                           vars(self))
628
633
    
629
 
    def checked_ok(self, timeout=None):
630
 
        """Bump up the timeout for this client.
631
 
        
632
 
        This should only be called when the client has been seen,
633
 
        alive and well.
634
 
        """
 
634
    def checked_ok(self):
 
635
        """Assert that the client has been seen, alive and well."""
 
636
        self.last_checked_ok = datetime.datetime.utcnow()
 
637
        self.last_checker_status = 0
 
638
        self.bump_timeout()
 
639
    
 
640
    def bump_timeout(self, timeout=None):
 
641
        """Bump up the timeout for this client."""
635
642
        if timeout is None:
636
643
            timeout = self.timeout
637
 
        self.last_checked_ok = datetime.datetime.utcnow()
638
644
        if self.disable_initiator_tag is not None:
639
645
            gobject.source_remove(self.disable_initiator_tag)
 
646
            self.disable_initiator_tag = None
640
647
        if getattr(self, "enabled", False):
641
648
            self.disable_initiator_tag = (gobject.timeout_add
642
 
                                          (timedelta_to_milliseconds
643
 
                                           (timeout), self.disable))
 
649
                                          (int(timeout.total_seconds()
 
650
                                               * 1000), self.disable))
644
651
            self.expires = datetime.datetime.utcnow() + timeout
645
652
    
646
653
    def need_approval(self):
652
659
        If a checker already exists, leave it running and do
653
660
        nothing."""
654
661
        # The reason for not killing a running checker is that if we
655
 
        # did that, then if a checker (for some reason) started
656
 
        # running slowly and taking more than 'interval' time, the
657
 
        # client would inevitably timeout, since no checker would get
658
 
        # 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
659
666
        # checkers alone, the checker would have to take more time
660
667
        # than 'timeout' for the client to be disabled, which is as it
661
668
        # should be.
663
670
        # If a checker exists, make sure it is not a zombie
664
671
        try:
665
672
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
666
 
        except (AttributeError, OSError) as error:
667
 
            if (isinstance(error, OSError)
668
 
                and error.errno != errno.ECHILD):
669
 
                raise error
 
673
        except AttributeError:
 
674
            pass
 
675
        except OSError as error:
 
676
            if error.errno != errno.ECHILD:
 
677
                raise
670
678
        else:
671
679
            if pid:
672
680
                logger.warning("Checker was a zombie")
675
683
                                      self.current_checker_command)
676
684
        # Start a new checker if needed
677
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 }
678
691
            try:
679
 
                # In case checker_command has exactly one % operator
680
 
                command = self.checker_command % self.host
681
 
            except TypeError:
682
 
                # Escape attributes for the shell
683
 
                escaped_attrs = dict(
684
 
                    (attr,
685
 
                     re.escape(unicode(str(getattr(self, attr, "")),
686
 
                                       errors=
687
 
                                       'replace')))
688
 
                    for attr in
689
 
                    self.runtime_expansions)
690
 
                
691
 
                try:
692
 
                    command = self.checker_command % escaped_attrs
693
 
                except TypeError as error:
694
 
                    logger.error('Could not format string "%s":'
695
 
                                 ' %s', self.checker_command, error)
696
 
                    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
697
697
            self.current_checker_command = command
698
698
            try:
699
699
                logger.info("Starting checker %r for %s",
702
702
                # in normal mode, that is already done by daemon(),
703
703
                # and in debug mode we don't want to.  (Stdin is
704
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 })
705
713
                self.checker = subprocess.Popen(command,
706
714
                                                close_fds=True,
707
 
                                                shell=True, cwd="/")
708
 
                self.checker_callback_tag = (gobject.child_watch_add
709
 
                                             (self.checker.pid,
710
 
                                              self.checker_callback,
711
 
                                              data=command))
712
 
                # The checker may have completed before the gobject
713
 
                # 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:
714
728
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
715
 
                if pid:
716
 
                    gobject.source_remove(self.checker_callback_tag)
717
 
                    self.checker_callback(pid, status, command)
718
729
            except OSError as error:
719
 
                logger.error("Failed to start subprocess: %s",
720
 
                             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)
721
739
        # Re-run this periodically if run by gobject.timeout_add
722
740
        return True
723
741
    
730
748
            return
731
749
        logger.debug("Stopping checker for %(name)s", vars(self))
732
750
        try:
733
 
            os.kill(self.checker.pid, signal.SIGTERM)
 
751
            self.checker.terminate()
734
752
            #time.sleep(0.5)
735
753
            #if self.checker.poll() is None:
736
 
            #    os.kill(self.checker.pid, signal.SIGKILL)
 
754
            #    self.checker.kill()
737
755
        except OSError as error:
738
756
            if error.errno != errno.ESRCH: # No such process
739
757
                raise
756
774
    # "Set" method, so we fail early here:
757
775
    if byte_arrays and signature != "ay":
758
776
        raise ValueError("Byte arrays not supported for non-'ay'"
759
 
                         " signature %r" % signature)
 
777
                         " signature {!r}".format(signature))
760
778
    def decorator(func):
761
779
        func._dbus_is_property = True
762
780
        func._dbus_interface = dbus_interface
770
788
    return decorator
771
789
 
772
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
 
773
828
class DBusPropertyException(dbus.exceptions.DBusException):
774
829
    """A base class for D-Bus property-related exceptions
775
830
    """
776
 
    def __unicode__(self):
777
 
        return unicode(str(self))
778
 
 
 
831
    pass
779
832
 
780
833
class DBusPropertyAccessException(DBusPropertyException):
781
834
    """A property's access permissions disallows an operation.
798
851
    """
799
852
    
800
853
    @staticmethod
801
 
    def _is_dbus_property(obj):
802
 
        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)
803
862
    
804
 
    def _get_all_dbus_properties(self):
 
863
    def _get_all_dbus_things(self, thing):
805
864
        """Returns a generator of (name, attribute) pairs
806
865
        """
807
 
        return ((prop.__get__(self)._dbus_name, prop.__get__(self))
 
866
        return ((getattr(athing.__get__(self), "_dbus_name",
 
867
                         name),
 
868
                 athing.__get__(self))
808
869
                for cls in self.__class__.__mro__
809
 
                for name, prop in
810
 
                inspect.getmembers(cls, self._is_dbus_property))
 
870
                for name, athing in
 
871
                inspect.getmembers(cls,
 
872
                                   self._is_dbus_thing(thing)))
811
873
    
812
874
    def _get_dbus_property(self, interface_name, property_name):
813
875
        """Returns a bound method if one exists which is a D-Bus
815
877
        """
816
878
        for cls in  self.__class__.__mro__:
817
879
            for name, value in (inspect.getmembers
818
 
                                (cls, self._is_dbus_property)):
 
880
                                (cls,
 
881
                                 self._is_dbus_thing("property"))):
819
882
                if (value._dbus_name == property_name
820
883
                    and value._dbus_interface == interface_name):
821
884
                    return value.__get__(self)
849
912
            # The byte_arrays option is not supported yet on
850
913
            # signatures other than "ay".
851
914
            if prop._dbus_signature != "ay":
852
 
                raise ValueError
 
915
                raise ValueError("Byte arrays not supported for non-"
 
916
                                 "'ay' signature {!r}"
 
917
                                 .format(prop._dbus_signature))
853
918
            value = dbus.ByteArray(b''.join(chr(byte)
854
919
                                            for byte in value))
855
920
        prop(value)
863
928
        Note: Will not include properties with access="write".
864
929
        """
865
930
        properties = {}
866
 
        for name, prop in self._get_all_dbus_properties():
 
931
        for name, prop in self._get_all_dbus_things("property"):
867
932
            if (interface_name
868
933
                and interface_name != prop._dbus_interface):
869
934
                # Interface non-empty but did not match
884
949
                         path_keyword='object_path',
885
950
                         connection_keyword='connection')
886
951
    def Introspect(self, object_path, connection):
887
 
        """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.
888
955
        """
889
956
        xmlstring = dbus.service.Object.Introspect(self, object_path,
890
957
                                                   connection)
897
964
                e.setAttribute("access", prop._dbus_access)
898
965
                return e
899
966
            for if_tag in document.getElementsByTagName("interface"):
 
967
                # Add property tags
900
968
                for tag in (make_tag(document, name, prop)
901
969
                            for name, prop
902
 
                            in self._get_all_dbus_properties()
 
970
                            in self._get_all_dbus_things("property")
903
971
                            if prop._dbus_interface
904
972
                            == if_tag.getAttribute("name")):
905
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)
906
1005
                # Add the names to the return values for the
907
1006
                # "org.freedesktop.DBus.Properties" methods
908
1007
                if (if_tag.getAttribute("name")
923
1022
        except (AttributeError, xml.dom.DOMException,
924
1023
                xml.parsers.expat.ExpatError) as error:
925
1024
            logger.error("Failed to override Introspection method",
926
 
                         error)
 
1025
                         exc_info=error)
927
1026
        return xmlstring
928
1027
 
929
1028
 
930
 
def datetime_to_dbus (dt, variant_level=0):
 
1029
def datetime_to_dbus(dt, variant_level=0):
931
1030
    """Convert a UTC datetime.datetime() to a D-Bus type."""
932
1031
    if dt is None:
933
1032
        return dbus.String("", variant_level = variant_level)
935
1034
                       variant_level=variant_level)
936
1035
 
937
1036
 
938
 
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
939
 
                                  .__metaclass__):
940
 
    """Applied to an empty subclass of a D-Bus object, this metaclass
941
 
    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).
942
1059
    """
943
 
    def __new__(mcs, name, bases, attr):
944
 
        # Go through all the base classes which could have D-Bus
945
 
        # methods, signals, or properties in them
946
 
        for base in (b for b in bases
947
 
                     if issubclass(b, dbus.service.Object)):
948
 
            # Go though all attributes of the base class
949
 
            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):
950
1067
                # Ignore non-D-Bus attributes, and D-Bus attributes
951
1068
                # with the wrong interface name
952
1069
                if (not hasattr(attribute, "_dbus_interface")
953
1070
                    or not attribute._dbus_interface
954
 
                    .startswith("se.recompile.Mandos")):
 
1071
                    .startswith(orig_interface_name)):
955
1072
                    continue
956
1073
                # Create an alternate D-Bus interface name based on
957
1074
                # the current name
958
1075
                alt_interface = (attribute._dbus_interface
959
 
                                 .replace("se.recompile.Mandos",
960
 
                                          "se.bsnet.fukt.Mandos"))
 
1076
                                 .replace(orig_interface_name,
 
1077
                                          alt_interface_name))
 
1078
                interface_names.add(alt_interface)
961
1079
                # Is this a D-Bus signal?
962
1080
                if getattr(attribute, "_dbus_is_signal", False):
963
 
                    # Extract the original non-method function by
964
 
                    # black magic
 
1081
                    # Extract the original non-method undecorated
 
1082
                    # function by black magic
965
1083
                    nonmethod_func = (dict(
966
1084
                            zip(attribute.func_code.co_freevars,
967
1085
                                attribute.__closure__))["func"]
978
1096
                                nonmethod_func.func_name,
979
1097
                                nonmethod_func.func_defaults,
980
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
981
1105
                    # Define a creator of a function to call both the
982
 
                    # old and new functions, so both the old and new
983
 
                    # 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
984
1109
                    def fixscope(func1, func2):
985
1110
                        """This function is a scope container to pass
986
1111
                        func1 and func2 to the "call_both" function
993
1118
                        return call_both
994
1119
                    # Create the "call_both" function and add it to
995
1120
                    # the class
996
 
                    attr[attrname] = fixscope(attribute,
997
 
                                              new_function)
 
1121
                    attr[attrname] = fixscope(attribute, new_function)
998
1122
                # Is this a D-Bus method?
999
1123
                elif getattr(attribute, "_dbus_is_method", False):
1000
1124
                    # Create a new, but exactly alike, function
1011
1135
                                        attribute.func_name,
1012
1136
                                        attribute.func_defaults,
1013
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
1014
1144
                # Is this a D-Bus property?
1015
1145
                elif getattr(attribute, "_dbus_is_property", False):
1016
1146
                    # Create a new, but exactly alike, function
1030
1160
                                        attribute.func_name,
1031
1161
                                        attribute.func_defaults,
1032
1162
                                        attribute.func_closure)))
1033
 
        return type.__new__(mcs, name, bases, attr)
1034
 
 
1035
 
 
 
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"})
1036
1208
class ClientDBus(Client, DBusObjectWithProperties):
1037
1209
    """A Client class using D-Bus
1038
1210
    
1058
1230
                                 ("/clients/" + client_object_name))
1059
1231
        DBusObjectWithProperties.__init__(self, self.bus,
1060
1232
                                          self.dbus_object_path)
1061
 
        
 
1233
    
1062
1234
    def notifychangeproperty(transform_func,
1063
1235
                             dbus_name, type_func=lambda x: x,
1064
1236
                             variant_level=1):
1072
1244
                   to the D-Bus.  Default: no transform
1073
1245
        variant_level: D-Bus variant level.  Default: 1
1074
1246
        """
1075
 
        attrname = "_{0}".format(dbus_name)
 
1247
        attrname = "_{}".format(dbus_name)
1076
1248
        def setter(self, value):
1077
1249
            if hasattr(self, "dbus_object_path"):
1078
1250
                if (not hasattr(self, attrname) or
1087
1259
        
1088
1260
        return property(lambda self: getattr(self, attrname), setter)
1089
1261
    
1090
 
    
1091
1262
    expires = notifychangeproperty(datetime_to_dbus, "Expires")
1092
1263
    approvals_pending = notifychangeproperty(dbus.Boolean,
1093
1264
                                             "ApprovalPending",
1100
1271
                                       checker is not None)
1101
1272
    last_checked_ok = notifychangeproperty(datetime_to_dbus,
1102
1273
                                           "LastCheckedOK")
 
1274
    last_checker_status = notifychangeproperty(dbus.Int16,
 
1275
                                               "LastCheckerStatus")
1103
1276
    last_approval_request = notifychangeproperty(
1104
1277
        datetime_to_dbus, "LastApprovalRequest")
1105
1278
    approved_by_default = notifychangeproperty(dbus.Boolean,
1107
1280
    approval_delay = notifychangeproperty(dbus.UInt64,
1108
1281
                                          "ApprovalDelay",
1109
1282
                                          type_func =
1110
 
                                          timedelta_to_milliseconds)
 
1283
                                          lambda td: td.total_seconds()
 
1284
                                          * 1000)
1111
1285
    approval_duration = notifychangeproperty(
1112
1286
        dbus.UInt64, "ApprovalDuration",
1113
 
        type_func = timedelta_to_milliseconds)
 
1287
        type_func = lambda td: td.total_seconds() * 1000)
1114
1288
    host = notifychangeproperty(dbus.String, "Host")
1115
1289
    timeout = notifychangeproperty(dbus.UInt64, "Timeout",
1116
 
                                   type_func =
1117
 
                                   timedelta_to_milliseconds)
 
1290
                                   type_func = lambda td:
 
1291
                                       td.total_seconds() * 1000)
1118
1292
    extended_timeout = notifychangeproperty(
1119
1293
        dbus.UInt64, "ExtendedTimeout",
1120
 
        type_func = timedelta_to_milliseconds)
 
1294
        type_func = lambda td: td.total_seconds() * 1000)
1121
1295
    interval = notifychangeproperty(dbus.UInt64,
1122
1296
                                    "Interval",
1123
1297
                                    type_func =
1124
 
                                    timedelta_to_milliseconds)
 
1298
                                    lambda td: td.total_seconds()
 
1299
                                    * 1000)
1125
1300
    checker_command = notifychangeproperty(dbus.String, "Checker")
1126
1301
    
1127
1302
    del notifychangeproperty
1155
1330
                                       *args, **kwargs)
1156
1331
    
1157
1332
    def start_checker(self, *args, **kwargs):
1158
 
        old_checker = self.checker
1159
 
        if self.checker is not None:
1160
 
            old_checker_pid = self.checker.pid
1161
 
        else:
1162
 
            old_checker_pid = None
 
1333
        old_checker_pid = getattr(self.checker, "pid", None)
1163
1334
        r = Client.start_checker(self, *args, **kwargs)
1164
1335
        # Only if new checker process was started
1165
1336
        if (self.checker is not None
1173
1344
        return False
1174
1345
    
1175
1346
    def approve(self, value=True):
1176
 
        self.send_changedstate()
1177
1347
        self.approved = value
1178
 
        gobject.timeout_add(timedelta_to_milliseconds
1179
 
                            (self.approval_duration),
1180
 
                            self._reset_approved)
1181
 
    
 
1348
        gobject.timeout_add(int(self.approval_duration.total_seconds()
 
1349
                                * 1000), self._reset_approved)
 
1350
        self.send_changedstate()
1182
1351
    
1183
1352
    ## D-Bus methods, signals & properties
1184
1353
    _interface = "se.recompile.Mandos.Client"
1185
1354
    
 
1355
    ## Interfaces
 
1356
    
 
1357
    @dbus_interface_annotations(_interface)
 
1358
    def _foo(self):
 
1359
        return { "org.freedesktop.DBus.Property.EmitsChangedSignal":
 
1360
                     "false"}
 
1361
    
1186
1362
    ## Signals
1187
1363
    
1188
1364
    # CheckerCompleted - signal
1279
1455
                           access="readwrite")
1280
1456
    def ApprovalDelay_dbus_property(self, value=None):
1281
1457
        if value is None:       # get
1282
 
            return dbus.UInt64(self.approval_delay_milliseconds())
 
1458
            return dbus.UInt64(self.approval_delay.total_seconds()
 
1459
                               * 1000)
1283
1460
        self.approval_delay = datetime.timedelta(0, 0, 0, value)
1284
1461
    
1285
1462
    # ApprovalDuration - property
1287
1464
                           access="readwrite")
1288
1465
    def ApprovalDuration_dbus_property(self, value=None):
1289
1466
        if value is None:       # get
1290
 
            return dbus.UInt64(timedelta_to_milliseconds(
1291
 
                    self.approval_duration))
 
1467
            return dbus.UInt64(self.approval_duration.total_seconds()
 
1468
                               * 1000)
1292
1469
        self.approval_duration = datetime.timedelta(0, 0, 0, value)
1293
1470
    
1294
1471
    # Name - property
1339
1516
            return
1340
1517
        return datetime_to_dbus(self.last_checked_ok)
1341
1518
    
 
1519
    # LastCheckerStatus - property
 
1520
    @dbus_service_property(_interface, signature="n",
 
1521
                           access="read")
 
1522
    def LastCheckerStatus_dbus_property(self):
 
1523
        return dbus.Int16(self.last_checker_status)
 
1524
    
1342
1525
    # Expires - property
1343
1526
    @dbus_service_property(_interface, signature="s", access="read")
1344
1527
    def Expires_dbus_property(self):
1354
1537
                           access="readwrite")
1355
1538
    def Timeout_dbus_property(self, value=None):
1356
1539
        if value is None:       # get
1357
 
            return dbus.UInt64(self.timeout_milliseconds())
 
1540
            return dbus.UInt64(self.timeout.total_seconds() * 1000)
 
1541
        old_timeout = self.timeout
1358
1542
        self.timeout = datetime.timedelta(0, 0, 0, value)
1359
 
        # Reschedule timeout
 
1543
        # Reschedule disabling
1360
1544
        if self.enabled:
1361
1545
            now = datetime.datetime.utcnow()
1362
 
            time_to_die = timedelta_to_milliseconds(
1363
 
                (self.last_checked_ok + self.timeout) - now)
1364
 
            if time_to_die <= 0:
 
1546
            self.expires += self.timeout - old_timeout
 
1547
            if self.expires <= now:
1365
1548
                # The timeout has passed
1366
1549
                self.disable()
1367
1550
            else:
1368
 
                self.expires = (now +
1369
 
                                datetime.timedelta(milliseconds =
1370
 
                                                   time_to_die))
1371
1551
                if (getattr(self, "disable_initiator_tag", None)
1372
1552
                    is None):
1373
1553
                    return
1374
1554
                gobject.source_remove(self.disable_initiator_tag)
1375
 
                self.disable_initiator_tag = (gobject.timeout_add
1376
 
                                              (time_to_die,
1377
 
                                               self.disable))
 
1555
                self.disable_initiator_tag = (
 
1556
                    gobject.timeout_add(
 
1557
                        int((self.expires - now).total_seconds()
 
1558
                            * 1000), self.disable))
1378
1559
    
1379
1560
    # ExtendedTimeout - property
1380
1561
    @dbus_service_property(_interface, signature="t",
1381
1562
                           access="readwrite")
1382
1563
    def ExtendedTimeout_dbus_property(self, value=None):
1383
1564
        if value is None:       # get
1384
 
            return dbus.UInt64(self.extended_timeout_milliseconds())
 
1565
            return dbus.UInt64(self.extended_timeout.total_seconds()
 
1566
                               * 1000)
1385
1567
        self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1386
1568
    
1387
1569
    # Interval - property
1389
1571
                           access="readwrite")
1390
1572
    def Interval_dbus_property(self, value=None):
1391
1573
        if value is None:       # get
1392
 
            return dbus.UInt64(self.interval_milliseconds())
 
1574
            return dbus.UInt64(self.interval.total_seconds() * 1000)
1393
1575
        self.interval = datetime.timedelta(0, 0, 0, value)
1394
1576
        if getattr(self, "checker_initiator_tag", None) is None:
1395
1577
            return
1428
1610
    @dbus_service_property(_interface, signature="ay",
1429
1611
                           access="write", byte_arrays=True)
1430
1612
    def Secret_dbus_property(self, value):
1431
 
        self.secret = str(value)
 
1613
        self.secret = bytes(value)
1432
1614
    
1433
1615
    del _interface
1434
1616
 
1459
1641
        self._pipe.send(('setattr', name, value))
1460
1642
 
1461
1643
 
1462
 
class ClientDBusTransitional(ClientDBus):
1463
 
    __metaclass__ = AlternateDBusNamesMetaclass
1464
 
 
1465
 
 
1466
1644
class ClientHandler(socketserver.BaseRequestHandler, object):
1467
1645
    """A class to handle client connections.
1468
1646
    
1504
1682
            logger.debug("Protocol version: %r", line)
1505
1683
            try:
1506
1684
                if int(line.strip().split()[0]) > 1:
1507
 
                    raise RuntimeError
 
1685
                    raise RuntimeError(line)
1508
1686
            except (ValueError, IndexError, RuntimeError) as error:
1509
1687
                logger.error("Unknown protocol version: %s", error)
1510
1688
                return
1559
1737
                        if self.server.use_dbus:
1560
1738
                            # Emit D-Bus signal
1561
1739
                            client.NeedApproval(
1562
 
                                client.approval_delay_milliseconds(),
1563
 
                                client.approved_by_default)
 
1740
                                client.approval_delay.total_seconds()
 
1741
                                * 1000, client.approved_by_default)
1564
1742
                    else:
1565
1743
                        logger.warning("Client %s was not approved",
1566
1744
                                       client.name)
1572
1750
                    #wait until timeout or approved
1573
1751
                    time = datetime.datetime.now()
1574
1752
                    client.changedstate.acquire()
1575
 
                    (client.changedstate.wait
1576
 
                     (float(client.timedelta_to_milliseconds(delay)
1577
 
                            / 1000)))
 
1753
                    client.changedstate.wait(delay.total_seconds())
1578
1754
                    client.changedstate.release()
1579
1755
                    time2 = datetime.datetime.now()
1580
1756
                    if (time2 - time) >= delay:
1596
1772
                    try:
1597
1773
                        sent = session.send(client.secret[sent_size:])
1598
1774
                    except gnutls.errors.GNUTLSError as error:
1599
 
                        logger.warning("gnutls send failed")
 
1775
                        logger.warning("gnutls send failed",
 
1776
                                       exc_info=error)
1600
1777
                        return
1601
1778
                    logger.debug("Sent: %d, remaining: %d",
1602
1779
                                 sent, len(client.secret)
1605
1782
                
1606
1783
                logger.info("Sending secret to %s", client.name)
1607
1784
                # bump the timeout using extended_timeout
1608
 
                client.checked_ok(client.extended_timeout)
 
1785
                client.bump_timeout(client.extended_timeout)
1609
1786
                if self.server.use_dbus:
1610
1787
                    # Emit D-Bus signal
1611
1788
                    client.GotSecret()
1616
1793
                try:
1617
1794
                    session.bye()
1618
1795
                except gnutls.errors.GNUTLSError as error:
1619
 
                    logger.warning("GnuTLS bye failed")
 
1796
                    logger.warning("GnuTLS bye failed",
 
1797
                                   exc_info=error)
1620
1798
    
1621
1799
    @staticmethod
1622
1800
    def peer_certificate(session):
1694
1872
    def process_request(self, request, address):
1695
1873
        """Start a new process to process the request."""
1696
1874
        proc = multiprocessing.Process(target = self.sub_process_main,
1697
 
                                       args = (request,
1698
 
                                               address))
 
1875
                                       args = (request, address))
1699
1876
        proc.start()
1700
1877
        return proc
1701
1878
 
1716
1893
    
1717
1894
    def add_pipe(self, parent_pipe, proc):
1718
1895
        """Dummy function; override as necessary"""
1719
 
        raise NotImplementedError
 
1896
        raise NotImplementedError()
1720
1897
 
1721
1898
 
1722
1899
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1729
1906
        use_ipv6:       Boolean; to use IPv6 or not
1730
1907
    """
1731
1908
    def __init__(self, server_address, RequestHandlerClass,
1732
 
                 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
        """
1733
1913
        self.interface = interface
1734
1914
        if use_ipv6:
1735
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.
1736
1942
        socketserver.TCPServer.__init__(self, server_address,
1737
1943
                                        RequestHandlerClass)
 
1944
    
1738
1945
    def server_bind(self):
1739
1946
        """This overrides the normal server_bind() function
1740
1947
        to bind to an interface if one was specified, and also NOT to
1748
1955
                try:
1749
1956
                    self.socket.setsockopt(socket.SOL_SOCKET,
1750
1957
                                           SO_BINDTODEVICE,
1751
 
                                           str(self.interface
1752
 
                                               + '\0'))
 
1958
                                           (self.interface + "\0")
 
1959
                                           .encode("utf-8"))
1753
1960
                except socket.error as error:
1754
 
                    if error[0] == errno.EPERM:
1755
 
                        logger.error("No permission to"
1756
 
                                     " bind to interface %s",
1757
 
                                     self.interface)
1758
 
                    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:
1759
1965
                        logger.error("SO_BINDTODEVICE not available;"
1760
1966
                                     " cannot bind to interface %s",
1761
1967
                                     self.interface)
 
1968
                    elif error.errno == errno.ENODEV:
 
1969
                        logger.error("Interface %s does not exist,"
 
1970
                                     " cannot bind", self.interface)
1762
1971
                    else:
1763
1972
                        raise
1764
1973
        # Only bind(2) the socket if we really need to.
1767
1976
                if self.address_family == socket.AF_INET6:
1768
1977
                    any_address = "::" # in6addr_any
1769
1978
                else:
1770
 
                    any_address = socket.INADDR_ANY
 
1979
                    any_address = "0.0.0.0" # INADDR_ANY
1771
1980
                self.server_address = (any_address,
1772
1981
                                       self.server_address[1])
1773
1982
            elif not self.server_address[1]:
1794
2003
    """
1795
2004
    def __init__(self, server_address, RequestHandlerClass,
1796
2005
                 interface=None, use_ipv6=True, clients=None,
1797
 
                 gnutls_priority=None, use_dbus=True):
 
2006
                 gnutls_priority=None, use_dbus=True, socketfd=None):
1798
2007
        self.enabled = False
1799
2008
        self.clients = clients
1800
2009
        if self.clients is None:
1804
2013
        IPv6_TCPServer.__init__(self, server_address,
1805
2014
                                RequestHandlerClass,
1806
2015
                                interface = interface,
1807
 
                                use_ipv6 = use_ipv6)
 
2016
                                use_ipv6 = use_ipv6,
 
2017
                                socketfd = socketfd)
1808
2018
    def server_activate(self):
1809
2019
        if self.enabled:
1810
2020
            return socketserver.TCPServer.server_activate(self)
1823
2033
    
1824
2034
    def handle_ipc(self, source, condition, parent_pipe=None,
1825
2035
                   proc = None, client_object=None):
1826
 
        condition_names = {
1827
 
            gobject.IO_IN: "IN",   # There is data to read.
1828
 
            gobject.IO_OUT: "OUT", # Data can be written (without
1829
 
                                    # blocking).
1830
 
            gobject.IO_PRI: "PRI", # There is urgent data to read.
1831
 
            gobject.IO_ERR: "ERR", # Error condition.
1832
 
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
1833
 
                                    # broken, usually for pipes and
1834
 
                                    # sockets).
1835
 
            }
1836
 
        conditions_string = ' | '.join(name
1837
 
                                       for cond, name in
1838
 
                                       condition_names.iteritems()
1839
 
                                       if cond & condition)
1840
2036
        # error, or the other end of multiprocessing.Pipe has closed
1841
 
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
 
2037
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
1842
2038
            # Wait for other process to exit
1843
2039
            proc.join()
1844
2040
            return False
1902
2098
        return True
1903
2099
 
1904
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
 
1905
2200
def string_to_delta(interval):
1906
2201
    """Parse a string and return a datetime.timedelta
1907
2202
    
1918
2213
    >>> string_to_delta('5m 30s')
1919
2214
    datetime.timedelta(0, 330)
1920
2215
    """
 
2216
    
 
2217
    try:
 
2218
        return rfc3339_duration_to_delta(interval)
 
2219
    except ValueError:
 
2220
        pass
 
2221
    
1921
2222
    timevalue = datetime.timedelta(0)
1922
2223
    for s in interval.split():
1923
2224
        try:
1924
 
            suffix = unicode(s[-1])
 
2225
            suffix = s[-1]
1925
2226
            value = int(s[:-1])
1926
2227
            if suffix == "d":
1927
2228
                delta = datetime.timedelta(value)
1934
2235
            elif suffix == "w":
1935
2236
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1936
2237
            else:
1937
 
                raise ValueError("Unknown suffix %r" % suffix)
1938
 
        except (ValueError, IndexError) as e:
 
2238
                raise ValueError("Unknown suffix {!r}"
 
2239
                                 .format(suffix))
 
2240
        except IndexError as e:
1939
2241
            raise ValueError(*(e.args))
1940
2242
        timevalue += delta
1941
2243
    return timevalue
1954
2256
        sys.exit()
1955
2257
    if not noclose:
1956
2258
        # Close all standard open file descriptors
1957
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2259
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
1958
2260
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1959
 
            raise OSError(errno.ENODEV,
1960
 
                          "%s not a character device"
1961
 
                          % os.path.devnull)
 
2261
            raise OSError(errno.ENODEV, "{} not a character device"
 
2262
                          .format(os.devnull))
1962
2263
        os.dup2(null, sys.stdin.fileno())
1963
2264
        os.dup2(null, sys.stdout.fileno())
1964
2265
        os.dup2(null, sys.stderr.fileno())
1973
2274
    
1974
2275
    parser = argparse.ArgumentParser()
1975
2276
    parser.add_argument("-v", "--version", action="version",
1976
 
                        version = "%%(prog)s %s" % version,
 
2277
                        version = "%(prog)s {}".format(version),
1977
2278
                        help="show version number and exit")
1978
2279
    parser.add_argument("-i", "--interface", metavar="IF",
1979
2280
                        help="Bind to interface IF")
1985
2286
                        help="Run self-test")
1986
2287
    parser.add_argument("--debug", action="store_true",
1987
2288
                        help="Debug mode; run in foreground and log"
1988
 
                        " to terminal")
 
2289
                        " to terminal", default=None)
1989
2290
    parser.add_argument("--debuglevel", metavar="LEVEL",
1990
2291
                        help="Debug level for stdout output")
1991
2292
    parser.add_argument("--priority", help="GnuTLS"
1998
2299
                        " files")
1999
2300
    parser.add_argument("--no-dbus", action="store_false",
2000
2301
                        dest="use_dbus", help="Do not provide D-Bus"
2001
 
                        " system bus interface")
 
2302
                        " system bus interface", default=None)
2002
2303
    parser.add_argument("--no-ipv6", action="store_false",
2003
 
                        dest="use_ipv6", help="Do not use IPv6")
 
2304
                        dest="use_ipv6", help="Do not use IPv6",
 
2305
                        default=None)
2004
2306
    parser.add_argument("--no-restore", action="store_false",
2005
2307
                        dest="restore", help="Do not restore stored"
2006
 
                        " 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")
2007
2312
    parser.add_argument("--statedir", metavar="DIR",
2008
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)
2009
2319
    
2010
2320
    options = parser.parse_args()
2011
2321
    
2012
2322
    if options.check:
2013
2323
        import doctest
2014
 
        doctest.testmod()
2015
 
        sys.exit()
 
2324
        fail_count, test_count = doctest.testmod()
 
2325
        sys.exit(os.EX_OK if fail_count == 0 else 1)
2016
2326
    
2017
2327
    # Default values for config file for server-global settings
2018
2328
    server_defaults = { "interface": "",
2020
2330
                        "port": "",
2021
2331
                        "debug": "False",
2022
2332
                        "priority":
2023
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
 
2333
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
2024
2334
                        "servicename": "Mandos",
2025
2335
                        "use_dbus": "True",
2026
2336
                        "use_ipv6": "True",
2027
2337
                        "debuglevel": "",
2028
2338
                        "restore": "True",
2029
 
                        "statedir": "/var/lib/mandos"
 
2339
                        "socket": "",
 
2340
                        "statedir": "/var/lib/mandos",
 
2341
                        "foreground": "False",
 
2342
                        "zeroconf": "True",
2030
2343
                        }
2031
2344
    
2032
2345
    # Parse config file for server-global settings
2037
2350
    # Convert the SafeConfigParser object to a dict
2038
2351
    server_settings = server_config.defaults()
2039
2352
    # Use the appropriate methods on the non-string config options
2040
 
    for option in ("debug", "use_dbus", "use_ipv6"):
 
2353
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
2041
2354
        server_settings[option] = server_config.getboolean("DEFAULT",
2042
2355
                                                           option)
2043
2356
    if server_settings["port"]:
2044
2357
        server_settings["port"] = server_config.getint("DEFAULT",
2045
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"])
2046
2368
    del server_config
2047
2369
    
2048
2370
    # Override the settings from the config file with command line
2050
2372
    for option in ("interface", "address", "port", "debug",
2051
2373
                   "priority", "servicename", "configdir",
2052
2374
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2053
 
                   "statedir"):
 
2375
                   "statedir", "socket", "foreground", "zeroconf"):
2054
2376
        value = getattr(options, option)
2055
2377
        if value is not None:
2056
2378
            server_settings[option] = value
2057
2379
    del options
2058
2380
    # Force all strings to be unicode
2059
2381
    for option in server_settings.keys():
2060
 
        if type(server_settings[option]) is str:
2061
 
            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
2062
2392
    # Now we have our good server settings in "server_settings"
2063
2393
    
2064
2394
    ##################################################################
2065
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
    
2066
2402
    # For convenience
2067
2403
    debug = server_settings["debug"]
2068
2404
    debuglevel = server_settings["debuglevel"]
2070
2406
    use_ipv6 = server_settings["use_ipv6"]
2071
2407
    stored_state_path = os.path.join(server_settings["statedir"],
2072
2408
                                     stored_state_file)
 
2409
    foreground = server_settings["foreground"]
 
2410
    zeroconf = server_settings["zeroconf"]
2073
2411
    
2074
2412
    if debug:
2075
2413
        initlogger(debug, logging.DEBUG)
2082
2420
    
2083
2421
    if server_settings["servicename"] != "Mandos":
2084
2422
        syslogger.setFormatter(logging.Formatter
2085
 
                               ('Mandos (%s) [%%(process)d]:'
2086
 
                                ' %%(levelname)s: %%(message)s'
2087
 
                                % server_settings["servicename"]))
 
2423
                               ('Mandos ({}) [%(process)d]:'
 
2424
                                ' %(levelname)s: %(message)s'
 
2425
                                .format(server_settings
 
2426
                                        ["servicename"])))
2088
2427
    
2089
2428
    # Parse config file with clients
2090
2429
    client_config = configparser.SafeConfigParser(Client
2095
2434
    global mandos_dbus_service
2096
2435
    mandos_dbus_service = None
2097
2436
    
 
2437
    socketfd = None
 
2438
    if server_settings["socket"] != "":
 
2439
        socketfd = server_settings["socket"]
2098
2440
    tcp_server = MandosServer((server_settings["address"],
2099
2441
                               server_settings["port"]),
2100
2442
                              ClientHandler,
2103
2445
                              use_ipv6=use_ipv6,
2104
2446
                              gnutls_priority=
2105
2447
                              server_settings["priority"],
2106
 
                              use_dbus=use_dbus)
2107
 
    if not debug:
2108
 
        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
2109
2455
        try:
2110
2456
            pidfile = open(pidfilename, "w")
2111
 
        except IOError:
2112
 
            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)
2113
2460
    
2114
 
    try:
2115
 
        uid = pwd.getpwnam("_mandos").pw_uid
2116
 
        gid = pwd.getpwnam("_mandos").pw_gid
2117
 
    except KeyError:
 
2461
    for name in ("_mandos", "mandos", "nobody"):
2118
2462
        try:
2119
 
            uid = pwd.getpwnam("mandos").pw_uid
2120
 
            gid = pwd.getpwnam("mandos").pw_gid
 
2463
            uid = pwd.getpwnam(name).pw_uid
 
2464
            gid = pwd.getpwnam(name).pw_gid
 
2465
            break
2121
2466
        except KeyError:
2122
 
            try:
2123
 
                uid = pwd.getpwnam("nobody").pw_uid
2124
 
                gid = pwd.getpwnam("nobody").pw_gid
2125
 
            except KeyError:
2126
 
                uid = 65534
2127
 
                gid = 65534
 
2467
            continue
 
2468
    else:
 
2469
        uid = 65534
 
2470
        gid = 65534
2128
2471
    try:
2129
2472
        os.setgid(gid)
2130
2473
        os.setuid(uid)
2131
2474
    except OSError as error:
2132
 
        if error[0] != errno.EPERM:
2133
 
            raise error
 
2475
        if error.errno != errno.EPERM:
 
2476
            raise
2134
2477
    
2135
2478
    if debug:
2136
2479
        # Enable all possible GnuTLS debugging
2147
2490
         .gnutls_global_set_log_function(debug_gnutls))
2148
2491
        
2149
2492
        # Redirect stdin so all checkers get /dev/null
2150
 
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
 
2493
        null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2151
2494
        os.dup2(null, sys.stdin.fileno())
2152
2495
        if null > 2:
2153
2496
            os.close(null)
2154
2497
    
2155
2498
    # Need to fork before connecting to D-Bus
2156
 
    if not debug:
 
2499
    if not foreground:
2157
2500
        # Close all input and output, do double fork, etc.
2158
2501
        daemon()
2159
2502
    
 
2503
    # multiprocessing will use threads, so before we use gobject we
 
2504
    # need to inform gobject that threads will be used.
2160
2505
    gobject.threads_init()
2161
2506
    
2162
2507
    global main_loop
2163
2508
    # From the Avahi example code
2164
 
    DBusGMainLoop(set_as_default=True )
 
2509
    DBusGMainLoop(set_as_default=True)
2165
2510
    main_loop = gobject.MainLoop()
2166
2511
    bus = dbus.SystemBus()
2167
2512
    # End of Avahi example code
2173
2518
                            ("se.bsnet.fukt.Mandos", bus,
2174
2519
                             do_not_queue=True))
2175
2520
        except dbus.exceptions.NameExistsException as e:
2176
 
            logger.error(unicode(e) + ", disabling D-Bus")
 
2521
            logger.error("Disabling D-Bus:", exc_info=e)
2177
2522
            use_dbus = False
2178
2523
            server_settings["use_dbus"] = False
2179
2524
            tcp_server.use_dbus = False
2180
 
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2181
 
    service = AvahiServiceToSyslog(name =
2182
 
                                   server_settings["servicename"],
2183
 
                                   servicetype = "_mandos._tcp",
2184
 
                                   protocol = protocol, bus = bus)
2185
 
    if server_settings["interface"]:
2186
 
        service.interface = (if_nametoindex
2187
 
                             (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")))
2188
2535
    
2189
2536
    global multiprocessing_manager
2190
2537
    multiprocessing_manager = multiprocessing.Manager()
2191
2538
    
2192
2539
    client_class = Client
2193
2540
    if use_dbus:
2194
 
        client_class = functools.partial(ClientDBusTransitional,
2195
 
                                         bus = bus)
 
2541
        client_class = functools.partial(ClientDBus, bus = bus)
2196
2542
    
2197
2543
    client_settings = Client.config_parser(client_config)
2198
2544
    old_client_settings = {}
2199
2545
    clients_data = {}
2200
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
    
2201
2555
    # Get client data and settings from last running state.
2202
2556
    if server_settings["restore"]:
2203
2557
        try:
2206
2560
                                                     (stored_state))
2207
2561
            os.remove(stored_state_path)
2208
2562
        except IOError as e:
2209
 
            logger.warning("Could not load persistent state: {0}"
2210
 
                           .format(e))
2211
 
            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)
2212
2569
                raise
2213
2570
        except EOFError as e:
2214
2571
            logger.warning("Could not load persistent state: "
2215
 
                           "EOFError: {0}".format(e))
 
2572
                           "EOFError:", exc_info=e)
2216
2573
    
2217
2574
    with PGPEngine() as pgp:
2218
 
        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
            
2219
2580
            # Decide which value to use after restoring saved state.
2220
2581
            # We have three different values: Old config file,
2221
2582
            # new config file, and saved state.
2242
2603
                if datetime.datetime.utcnow() >= client["expires"]:
2243
2604
                    if not client["last_checked_ok"]:
2244
2605
                        logger.warning(
2245
 
                            "disabling client {0} - Client never "
 
2606
                            "disabling client {} - Client never "
2246
2607
                            "performed a successful checker"
2247
2608
                            .format(client_name))
2248
2609
                        client["enabled"] = False
2249
2610
                    elif client["last_checker_status"] != 0:
2250
2611
                        logger.warning(
2251
 
                            "disabling client {0} - Client "
2252
 
                            "last checker failed with error code {1}"
 
2612
                            "disabling client {} - Client last"
 
2613
                            " checker failed with error code {}"
2253
2614
                            .format(client_name,
2254
2615
                                    client["last_checker_status"]))
2255
2616
                        client["enabled"] = False
2258
2619
                                             .utcnow()
2259
2620
                                             + client["timeout"])
2260
2621
                        logger.debug("Last checker succeeded,"
2261
 
                                     " keeping {0} enabled"
 
2622
                                     " keeping {} enabled"
2262
2623
                                     .format(client_name))
2263
2624
            try:
2264
2625
                client["secret"] = (
2267
2628
                                ["secret"]))
2268
2629
            except PGPError:
2269
2630
                # If decryption fails, we use secret from new settings
2270
 
                logger.debug("Failed to decrypt {0} old secret"
 
2631
                logger.debug("Failed to decrypt {} old secret"
2271
2632
                             .format(client_name))
2272
2633
                client["secret"] = (
2273
2634
                    client_settings[client_name]["secret"])
2274
 
 
2275
2635
    
2276
2636
    # Add/remove clients based on new changes made to config
2277
2637
    for client_name in (set(old_client_settings)
2280
2640
    for client_name in (set(client_settings)
2281
2641
                        - set(old_client_settings)):
2282
2642
        clients_data[client_name] = client_settings[client_name]
2283
 
 
 
2643
    
2284
2644
    # Create all client objects
2285
 
    for client_name, client in clients_data.iteritems():
 
2645
    for client_name, client in clients_data.items():
2286
2646
        tcp_server.clients[client_name] = client_class(
2287
 
            name = client_name, settings = client)
 
2647
            name = client_name, settings = client,
 
2648
            server_settings = server_settings)
2288
2649
    
2289
2650
    if not tcp_server.clients:
2290
2651
        logger.warning("No clients defined")
2291
 
        
2292
 
    if not debug:
2293
 
        try:
2294
 
            with pidfile:
2295
 
                pid = os.getpid()
2296
 
                pidfile.write(str(pid) + "\n".encode("utf-8"))
2297
 
            del pidfile
2298
 
        except IOError:
2299
 
            logger.error("Could not write to file %r with PID %d",
2300
 
                         pidfilename, pid)
2301
 
        except NameError:
2302
 
            # "pidfile" was never created
2303
 
            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
2304
2663
        del pidfilename
2305
 
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2306
2664
    
2307
2665
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2308
2666
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2309
2667
    
2310
2668
    if use_dbus:
2311
 
        class MandosDBusService(dbus.service.Object):
 
2669
        @alternate_dbus_interfaces({"se.recompile.Mandos":
 
2670
                                        "se.bsnet.fukt.Mandos"})
 
2671
        class MandosDBusService(DBusObjectWithProperties):
2312
2672
            """A D-Bus proxy object"""
2313
2673
            def __init__(self):
2314
2674
                dbus.service.Object.__init__(self, bus, "/")
2315
2675
            _interface = "se.recompile.Mandos"
2316
2676
            
 
2677
            @dbus_interface_annotations(_interface)
 
2678
            def _foo(self):
 
2679
                return { "org.freedesktop.DBus.Property"
 
2680
                         ".EmitsChangedSignal":
 
2681
                             "false"}
 
2682
            
2317
2683
            @dbus.service.signal(_interface, signature="o")
2318
2684
            def ClientAdded(self, objpath):
2319
2685
                "D-Bus signal"
2361
2727
            
2362
2728
            del _interface
2363
2729
        
2364
 
        class MandosDBusServiceTransitional(MandosDBusService):
2365
 
            __metaclass__ = AlternateDBusNamesMetaclass
2366
 
        mandos_dbus_service = MandosDBusServiceTransitional()
 
2730
        mandos_dbus_service = MandosDBusService()
2367
2731
    
2368
2732
    def cleanup():
2369
2733
        "Cleanup function; run on exit"
2370
 
        service.cleanup()
 
2734
        if zeroconf:
 
2735
            service.cleanup()
2371
2736
        
2372
2737
        multiprocessing.active_children()
 
2738
        wnull.close()
2373
2739
        if not (tcp_server.clients or client_settings):
2374
2740
            return
2375
2741
        
2386
2752
                
2387
2753
                # A list of attributes that can not be pickled
2388
2754
                # + secret.
2389
 
                exclude = set(("bus", "changedstate", "secret",
2390
 
                               "checker"))
 
2755
                exclude = { "bus", "changedstate", "secret",
 
2756
                            "checker", "server_settings" }
2391
2757
                for name, typ in (inspect.getmembers
2392
2758
                                  (dbus.service.Object)):
2393
2759
                    exclude.add(name)
2402
2768
                del client_settings[client.name]["secret"]
2403
2769
        
2404
2770
        try:
2405
 
            tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
2406
 
                                                prefix="clients-",
2407
 
                                                dir=os.path.dirname
2408
 
                                                (stored_state_path))
2409
 
            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:
2410
2775
                pickle.dump((clients, client_settings), stored_state)
 
2776
                tempname=stored_state.name
2411
2777
            os.rename(tempname, stored_state_path)
2412
2778
        except (IOError, OSError) as e:
2413
 
            logger.warning("Could not save persistent state: {0}"
2414
 
                           .format(e))
2415
2779
            if not debug:
2416
2780
                try:
2417
2781
                    os.remove(tempname)
2418
2782
                except NameError:
2419
2783
                    pass
2420
 
            if e.errno not in set((errno.ENOENT, errno.EACCES,
2421
 
                                   errno.EEXIST)):
2422
 
                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
2423
2791
        
2424
2792
        # Delete all clients, and settings from config
2425
2793
        while tcp_server.clients:
2449
2817
    tcp_server.server_activate()
2450
2818
    
2451
2819
    # Find out what port we got
2452
 
    service.port = tcp_server.socket.getsockname()[1]
 
2820
    if zeroconf:
 
2821
        service.port = tcp_server.socket.getsockname()[1]
2453
2822
    if use_ipv6:
2454
2823
        logger.info("Now listening on address %r, port %d,"
2455
 
                    " flowinfo %d, scope_id %d"
2456
 
                    % tcp_server.socket.getsockname())
 
2824
                    " flowinfo %d, scope_id %d",
 
2825
                    *tcp_server.socket.getsockname())
2457
2826
    else:                       # IPv4
2458
 
        logger.info("Now listening on address %r, port %d"
2459
 
                    % tcp_server.socket.getsockname())
 
2827
        logger.info("Now listening on address %r, port %d",
 
2828
                    *tcp_server.socket.getsockname())
2460
2829
    
2461
2830
    #service.interface = tcp_server.socket.getsockname()[3]
2462
2831
    
2463
2832
    try:
2464
 
        # From the Avahi example code
2465
 
        try:
2466
 
            service.activate()
2467
 
        except dbus.exceptions.DBusException as error:
2468
 
            logger.critical("DBusException: %s", error)
2469
 
            cleanup()
2470
 
            sys.exit(1)
2471
 
        # 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
2472
2842
        
2473
2843
        gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2474
2844
                             lambda *args, **kwargs:
2478
2848
        logger.debug("Starting main loop")
2479
2849
        main_loop.run()
2480
2850
    except AvahiError as error:
2481
 
        logger.critical("AvahiError: %s", error)
 
2851
        logger.critical("Avahi Error", exc_info=error)
2482
2852
        cleanup()
2483
2853
        sys.exit(1)
2484
2854
    except KeyboardInterrupt: