/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: 2012-05-07 20:46:51 UTC
  • Revision ID: teddy@recompile.se-20120507204651-qx5o5ztwmau54mh4
* mandos-monitor: Speedup: Use properties from D-Bus
                  GetAllClientsWithProperties() call.  Also use
                  super() properly - only use keyword arguments and
                  strip them off as "kwargs" is passed on.
  (MandosClientPropertyCache.__init__): Take new "properties"
                                        argument; use it to skip
                                        calling D-Bus GetAll() method.
                                        Call super().  Bind self._
  (MandosClientPropertyCache._property_changed): New helper function.
  (MandosClientPropertyCache.property_changed): Changed to take
                                                keyword arguments.
  (MandosClientPropertyCache.delete): Bug fix: Don't call
                                      super().__init__().
  (MandosClientWidget.__init__): Don't take *args.  Strip used keyword
                                 arguments before calling super().
  (MandosClientWidget.property_changed): Removed dead code.
  (MandosClientWidget.delete): Don't take *args.
  (MandosClientWidget.property_changed): Don't take "value" argument,
                                         since it is not used.
  (ConstrainedListBox.keypress): Take *args, **kwargs and pass them on
                                 to super().

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
11
11
# "AvahiService" class, and some lines in "main".
12
12
# 
13
13
# Everything else is
14
 
# Copyright © 2008-2014 Teddy Hogeborn
15
 
# Copyright © 2008-2014 Björn Påhlsson
 
14
# Copyright © 2008-2012 Teddy Hogeborn
 
15
# Copyright © 2008-2012 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
68
68
import binascii
69
69
import tempfile
70
70
import itertools
71
 
import collections
72
71
 
73
72
import dbus
74
73
import dbus.service
79
78
import ctypes.util
80
79
import xml.dom.minidom
81
80
import inspect
 
81
import GnuPGInterface
82
82
 
83
83
try:
84
84
    SO_BINDTODEVICE = socket.SO_BINDTODEVICE
88
88
    except ImportError:
89
89
        SO_BINDTODEVICE = None
90
90
 
91
 
version = "1.6.4"
 
91
version = "1.5.3"
92
92
stored_state_file = "clients.pickle"
93
93
 
94
94
logger = logging.getLogger()
95
 
syslogger = None
 
95
syslogger = (logging.handlers.SysLogHandler
 
96
             (facility = logging.handlers.SysLogHandler.LOG_DAEMON,
 
97
              address = str("/dev/log")))
96
98
 
97
99
try:
98
100
    if_nametoindex = (ctypes.cdll.LoadLibrary
114
116
def initlogger(debug, level=logging.WARNING):
115
117
    """init logger and add loglevel"""
116
118
    
117
 
    syslogger = (logging.handlers.SysLogHandler
118
 
                 (facility =
119
 
                  logging.handlers.SysLogHandler.LOG_DAEMON,
120
 
                  address = str("/dev/log")))
121
119
    syslogger.setFormatter(logging.Formatter
122
120
                           ('Mandos [%(process)d]: %(levelname)s:'
123
121
                            ' %(message)s'))
141
139
class PGPEngine(object):
142
140
    """A simple class for OpenPGP symmetric encryption & decryption"""
143
141
    def __init__(self):
 
142
        self.gnupg = GnuPGInterface.GnuPG()
144
143
        self.tempdir = tempfile.mkdtemp(prefix="mandos-")
145
 
        self.gnupgargs = ['--batch',
146
 
                          '--home', self.tempdir,
147
 
                          '--force-mdc',
148
 
                          '--quiet',
149
 
                          '--no-use-agent']
 
144
        self.gnupg = GnuPGInterface.GnuPG()
 
145
        self.gnupg.options.meta_interactive = False
 
146
        self.gnupg.options.homedir = self.tempdir
 
147
        self.gnupg.options.extra_args.extend(['--force-mdc',
 
148
                                              '--quiet',
 
149
                                              '--no-use-agent'])
150
150
    
151
151
    def __enter__(self):
152
152
        return self
153
153
    
154
 
    def __exit__(self, exc_type, exc_value, traceback):
 
154
    def __exit__ (self, exc_type, exc_value, traceback):
155
155
        self._cleanup()
156
156
        return False
157
157
    
174
174
    def password_encode(self, password):
175
175
        # Passphrase can not be empty and can not contain newlines or
176
176
        # NUL bytes.  So we prefix it and hex encode it.
177
 
        encoded = b"mandos" + binascii.hexlify(password)
178
 
        if len(encoded) > 2048:
179
 
            # GnuPG can't handle long passwords, so encode differently
180
 
            encoded = (b"mandos" + password.replace(b"\\", b"\\\\")
181
 
                       .replace(b"\n", b"\\n")
182
 
                       .replace(b"\0", b"\\x00"))
183
 
        return encoded
 
177
        return b"mandos" + binascii.hexlify(password)
184
178
    
185
179
    def encrypt(self, data, password):
186
 
        passphrase = self.password_encode(password)
187
 
        with tempfile.NamedTemporaryFile(dir=self.tempdir
188
 
                                         ) as passfile:
189
 
            passfile.write(passphrase)
190
 
            passfile.flush()
191
 
            proc = subprocess.Popen(['gpg', '--symmetric',
192
 
                                     '--passphrase-file',
193
 
                                     passfile.name]
194
 
                                    + self.gnupgargs,
195
 
                                    stdin = subprocess.PIPE,
196
 
                                    stdout = subprocess.PIPE,
197
 
                                    stderr = subprocess.PIPE)
198
 
            ciphertext, err = proc.communicate(input = data)
199
 
        if proc.returncode != 0:
200
 
            raise PGPError(err)
 
180
        self.gnupg.passphrase = self.password_encode(password)
 
181
        with open(os.devnull, "w") as devnull:
 
182
            try:
 
183
                proc = self.gnupg.run(['--symmetric'],
 
184
                                      create_fhs=['stdin', 'stdout'],
 
185
                                      attach_fhs={'stderr': devnull})
 
186
                with contextlib.closing(proc.handles['stdin']) as f:
 
187
                    f.write(data)
 
188
                with contextlib.closing(proc.handles['stdout']) as f:
 
189
                    ciphertext = f.read()
 
190
                proc.wait()
 
191
            except IOError as e:
 
192
                raise PGPError(e)
 
193
        self.gnupg.passphrase = None
201
194
        return ciphertext
202
195
    
203
196
    def decrypt(self, data, password):
204
 
        passphrase = self.password_encode(password)
205
 
        with tempfile.NamedTemporaryFile(dir = self.tempdir
206
 
                                         ) as passfile:
207
 
            passfile.write(passphrase)
208
 
            passfile.flush()
209
 
            proc = subprocess.Popen(['gpg', '--decrypt',
210
 
                                     '--passphrase-file',
211
 
                                     passfile.name]
212
 
                                    + self.gnupgargs,
213
 
                                    stdin = subprocess.PIPE,
214
 
                                    stdout = subprocess.PIPE,
215
 
                                    stderr = subprocess.PIPE)
216
 
            decrypted_plaintext, err = proc.communicate(input
217
 
                                                        = data)
218
 
        if proc.returncode != 0:
219
 
            raise PGPError(err)
 
197
        self.gnupg.passphrase = self.password_encode(password)
 
198
        with open(os.devnull, "w") as devnull:
 
199
            try:
 
200
                proc = self.gnupg.run(['--decrypt'],
 
201
                                      create_fhs=['stdin', 'stdout'],
 
202
                                      attach_fhs={'stderr': devnull})
 
203
                with contextlib.closing(proc.handles['stdin']) as f:
 
204
                    f.write(data)
 
205
                with contextlib.closing(proc.handles['stdout']) as f:
 
206
                    decrypted_plaintext = f.read()
 
207
                proc.wait()
 
208
            except IOError as e:
 
209
                raise PGPError(e)
 
210
        self.gnupg.passphrase = None
220
211
        return decrypted_plaintext
221
212
 
222
213
 
242
233
               Used to optionally bind to the specified interface.
243
234
    name: string; Example: 'Mandos'
244
235
    type: string; Example: '_mandos._tcp'.
245
 
     See <https://www.iana.org/assignments/service-names-port-numbers>
 
236
                  See <http://www.dns-sd.org/ServiceTypes.html>
246
237
    port: integer; what port to announce
247
238
    TXT: list of strings; TXT record for the service
248
239
    domain: string; Domain to publish on, default to .local if empty.
388
379
                                 self.server_state_changed)
389
380
        self.server_state_changed(self.server.GetState())
390
381
 
391
 
 
392
382
class AvahiServiceToSyslog(AvahiService):
393
383
    def rename(self):
394
384
        """Add the new name to the syslog messages"""
399
389
                                .format(self.name)))
400
390
        return ret
401
391
 
402
 
 
403
392
def timedelta_to_milliseconds(td):
404
393
    "Convert a datetime.timedelta() to milliseconds"
405
394
    return ((td.days * 24 * 60 * 60 * 1000)
406
395
            + (td.seconds * 1000)
407
396
            + (td.microseconds // 1000))
408
397
 
409
 
 
410
398
class Client(object):
411
399
    """A representation of a client host served by this server.
412
400
    
448
436
    runtime_expansions: Allowed attributes for runtime expansion.
449
437
    expires:    datetime.datetime(); time (UTC) when a client will be
450
438
                disabled, or None
451
 
    server_settings: The server_settings dict from main()
452
439
    """
453
440
    
454
441
    runtime_expansions = ("approval_delay", "approval_duration",
455
 
                          "created", "enabled", "expires",
456
 
                          "fingerprint", "host", "interval",
457
 
                          "last_approval_request", "last_checked_ok",
 
442
                          "created", "enabled", "fingerprint",
 
443
                          "host", "interval", "last_checked_ok",
458
444
                          "last_enabled", "name", "timeout")
459
 
    client_defaults = { "timeout": "PT5M",
460
 
                        "extended_timeout": "PT15M",
461
 
                        "interval": "PT2M",
 
445
    client_defaults = { "timeout": "5m",
 
446
                        "extended_timeout": "15m",
 
447
                        "interval": "2m",
462
448
                        "checker": "fping -q -- %%(host)s",
463
449
                        "host": "",
464
 
                        "approval_delay": "PT0S",
465
 
                        "approval_duration": "PT1S",
 
450
                        "approval_delay": "0s",
 
451
                        "approval_duration": "1s",
466
452
                        "approved_by_default": "True",
467
453
                        "enabled": "True",
468
454
                        }
529
515
        
530
516
        return settings
531
517
    
532
 
    def __init__(self, settings, name = None, server_settings=None):
 
518
    def __init__(self, settings, name = None):
533
519
        self.name = name
534
 
        if server_settings is None:
535
 
            server_settings = {}
536
 
        self.server_settings = server_settings
537
520
        # adding all client settings
538
521
        for setting, value in settings.iteritems():
539
522
            setattr(self, setting, value)
589
572
        if getattr(self, "enabled", False):
590
573
            # Already enabled
591
574
            return
 
575
        self.send_changedstate()
592
576
        self.expires = datetime.datetime.utcnow() + self.timeout
593
577
        self.enabled = True
594
578
        self.last_enabled = datetime.datetime.utcnow()
595
579
        self.init_checker()
596
 
        self.send_changedstate()
597
580
    
598
581
    def disable(self, quiet=True):
599
582
        """Disable this client."""
600
583
        if not getattr(self, "enabled", False):
601
584
            return False
602
585
        if not quiet:
 
586
            self.send_changedstate()
 
587
        if not quiet:
603
588
            logger.info("Disabling client %s", self.name)
604
 
        if getattr(self, "disable_initiator_tag", None) is not None:
 
589
        if getattr(self, "disable_initiator_tag", False):
605
590
            gobject.source_remove(self.disable_initiator_tag)
606
591
            self.disable_initiator_tag = None
607
592
        self.expires = None
608
 
        if getattr(self, "checker_initiator_tag", None) is not None:
 
593
        if getattr(self, "checker_initiator_tag", False):
609
594
            gobject.source_remove(self.checker_initiator_tag)
610
595
            self.checker_initiator_tag = None
611
596
        self.stop_checker()
612
597
        self.enabled = False
613
 
        if not quiet:
614
 
            self.send_changedstate()
615
598
        # Do not run this again if called by a gobject.timeout_add
616
599
        return False
617
600
    
621
604
    def init_checker(self):
622
605
        # Schedule a new checker to be started an 'interval' from now,
623
606
        # and every interval from then on.
624
 
        if self.checker_initiator_tag is not None:
625
 
            gobject.source_remove(self.checker_initiator_tag)
626
607
        self.checker_initiator_tag = (gobject.timeout_add
627
608
                                      (self.interval_milliseconds(),
628
609
                                       self.start_checker))
629
610
        # Schedule a disable() when 'timeout' has passed
630
 
        if self.disable_initiator_tag is not None:
631
 
            gobject.source_remove(self.disable_initiator_tag)
632
611
        self.disable_initiator_tag = (gobject.timeout_add
633
612
                                   (self.timeout_milliseconds(),
634
613
                                    self.disable))
665
644
            timeout = self.timeout
666
645
        if self.disable_initiator_tag is not None:
667
646
            gobject.source_remove(self.disable_initiator_tag)
668
 
            self.disable_initiator_tag = None
669
647
        if getattr(self, "enabled", False):
670
648
            self.disable_initiator_tag = (gobject.timeout_add
671
649
                                          (timedelta_to_milliseconds
692
670
        # If a checker exists, make sure it is not a zombie
693
671
        try:
694
672
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
695
 
        except AttributeError:
696
 
            pass
697
 
        except OSError as error:
698
 
            if error.errno != errno.ECHILD:
699
 
                raise
 
673
        except (AttributeError, OSError) as error:
 
674
            if (isinstance(error, OSError)
 
675
                and error.errno != errno.ECHILD):
 
676
                raise error
700
677
        else:
701
678
            if pid:
702
679
                logger.warning("Checker was a zombie")
705
682
                                      self.current_checker_command)
706
683
        # Start a new checker if needed
707
684
        if self.checker is None:
708
 
            # Escape attributes for the shell
709
 
            escaped_attrs = dict(
710
 
                (attr, re.escape(unicode(getattr(self, attr))))
711
 
                for attr in
712
 
                self.runtime_expansions)
713
685
            try:
714
 
                command = self.checker_command % escaped_attrs
715
 
            except TypeError as error:
716
 
                logger.error('Could not format string "%s"',
717
 
                             self.checker_command, exc_info=error)
718
 
                return True # Try again later
 
686
                # In case checker_command has exactly one % operator
 
687
                command = self.checker_command % self.host
 
688
            except TypeError:
 
689
                # Escape attributes for the shell
 
690
                escaped_attrs = dict(
 
691
                    (attr,
 
692
                     re.escape(unicode(str(getattr(self, attr, "")),
 
693
                                       errors=
 
694
                                       'replace')))
 
695
                    for attr in
 
696
                    self.runtime_expansions)
 
697
                
 
698
                try:
 
699
                    command = self.checker_command % escaped_attrs
 
700
                except TypeError as error:
 
701
                    logger.error('Could not format string "%s"',
 
702
                                 self.checker_command, exc_info=error)
 
703
                    return True # Try again later
719
704
            self.current_checker_command = command
720
705
            try:
721
706
                logger.info("Starting checker %r for %s",
724
709
                # in normal mode, that is already done by daemon(),
725
710
                # and in debug mode we don't want to.  (Stdin is
726
711
                # always replaced by /dev/null.)
727
 
                # The exception is when not debugging but nevertheless
728
 
                # running in the foreground; use the previously
729
 
                # created wnull.
730
 
                popen_args = {}
731
 
                if (not self.server_settings["debug"]
732
 
                    and self.server_settings["foreground"]):
733
 
                    popen_args.update({"stdout": wnull,
734
 
                                       "stderr": wnull })
735
712
                self.checker = subprocess.Popen(command,
736
713
                                                close_fds=True,
737
 
                                                shell=True, cwd="/",
738
 
                                                **popen_args)
 
714
                                                shell=True, cwd="/")
 
715
                self.checker_callback_tag = (gobject.child_watch_add
 
716
                                             (self.checker.pid,
 
717
                                              self.checker_callback,
 
718
                                              data=command))
 
719
                # The checker may have completed before the gobject
 
720
                # watch was added.  Check for this.
 
721
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
722
                if pid:
 
723
                    gobject.source_remove(self.checker_callback_tag)
 
724
                    self.checker_callback(pid, status, command)
739
725
            except OSError as error:
740
726
                logger.error("Failed to start subprocess",
741
727
                             exc_info=error)
742
 
                return True
743
 
            self.checker_callback_tag = (gobject.child_watch_add
744
 
                                         (self.checker.pid,
745
 
                                          self.checker_callback,
746
 
                                          data=command))
747
 
            # The checker may have completed before the gobject
748
 
            # watch was added.  Check for this.
749
 
            try:
750
 
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
751
 
            except OSError as error:
752
 
                if error.errno == errno.ECHILD:
753
 
                    # This should never happen
754
 
                    logger.error("Child process vanished",
755
 
                                 exc_info=error)
756
 
                    return True
757
 
                raise
758
 
            if pid:
759
 
                gobject.source_remove(self.checker_callback_tag)
760
 
                self.checker_callback(pid, status, command)
761
728
        # Re-run this periodically if run by gobject.timeout_add
762
729
        return True
763
730
    
936
903
            # The byte_arrays option is not supported yet on
937
904
            # signatures other than "ay".
938
905
            if prop._dbus_signature != "ay":
939
 
                raise ValueError("Byte arrays not supported for non-"
940
 
                                 "'ay' signature {0!r}"
941
 
                                 .format(prop._dbus_signature))
 
906
                raise ValueError
942
907
            value = dbus.ByteArray(b''.join(chr(byte)
943
908
                                            for byte in value))
944
909
        prop(value)
1050
1015
        return xmlstring
1051
1016
 
1052
1017
 
1053
 
def datetime_to_dbus(dt, variant_level=0):
 
1018
def datetime_to_dbus (dt, variant_level=0):
1054
1019
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1055
1020
    if dt is None:
1056
1021
        return dbus.String("", variant_level = variant_level)
1064
1029
    interface names according to the "alt_interface_names" mapping.
1065
1030
    Usage:
1066
1031
    
1067
 
    @alternate_dbus_interfaces({"org.example.Interface":
1068
 
                                    "net.example.AlternateInterface"})
 
1032
    @alternate_dbus_names({"org.example.Interface":
 
1033
                               "net.example.AlternateInterface"})
1069
1034
    class SampleDBusObject(dbus.service.Object):
1070
1035
        @dbus.service.method("org.example.Interface")
1071
1036
        def SampleDBusMethod():
1102
1067
                interface_names.add(alt_interface)
1103
1068
                # Is this a D-Bus signal?
1104
1069
                if getattr(attribute, "_dbus_is_signal", False):
1105
 
                    # Extract the original non-method undecorated
1106
 
                    # function by black magic
 
1070
                    # Extract the original non-method function by
 
1071
                    # black magic
1107
1072
                    nonmethod_func = (dict(
1108
1073
                            zip(attribute.func_code.co_freevars,
1109
1074
                                attribute.__closure__))["func"]
1352
1317
                                       *args, **kwargs)
1353
1318
    
1354
1319
    def start_checker(self, *args, **kwargs):
1355
 
        old_checker_pid = getattr(self.checker, "pid", None)
 
1320
        old_checker = self.checker
 
1321
        if self.checker is not None:
 
1322
            old_checker_pid = self.checker.pid
 
1323
        else:
 
1324
            old_checker_pid = None
1356
1325
        r = Client.start_checker(self, *args, **kwargs)
1357
1326
        # Only if new checker process was started
1358
1327
        if (self.checker is not None
1366
1335
        return False
1367
1336
    
1368
1337
    def approve(self, value=True):
 
1338
        self.send_changedstate()
1369
1339
        self.approved = value
1370
1340
        gobject.timeout_add(timedelta_to_milliseconds
1371
1341
                            (self.approval_duration),
1372
1342
                            self._reset_approved)
1373
 
        self.send_changedstate()
1374
1343
    
1375
1344
    ## D-Bus methods, signals & properties
1376
1345
    _interface = "se.recompile.Mandos.Client"
1560
1529
    def Timeout_dbus_property(self, value=None):
1561
1530
        if value is None:       # get
1562
1531
            return dbus.UInt64(self.timeout_milliseconds())
1563
 
        old_timeout = self.timeout
1564
1532
        self.timeout = datetime.timedelta(0, 0, 0, value)
1565
 
        # Reschedule disabling
 
1533
        # Reschedule timeout
1566
1534
        if self.enabled:
1567
1535
            now = datetime.datetime.utcnow()
1568
 
            self.expires += self.timeout - old_timeout
1569
 
            if self.expires <= now:
 
1536
            time_to_die = timedelta_to_milliseconds(
 
1537
                (self.last_checked_ok + self.timeout) - now)
 
1538
            if time_to_die <= 0:
1570
1539
                # The timeout has passed
1571
1540
                self.disable()
1572
1541
            else:
 
1542
                self.expires = (now +
 
1543
                                datetime.timedelta(milliseconds =
 
1544
                                                   time_to_die))
1573
1545
                if (getattr(self, "disable_initiator_tag", None)
1574
1546
                    is None):
1575
1547
                    return
1576
1548
                gobject.source_remove(self.disable_initiator_tag)
1577
 
                self.disable_initiator_tag = (
1578
 
                    gobject.timeout_add(
1579
 
                        timedelta_to_milliseconds(self.expires - now),
1580
 
                        self.disable))
 
1549
                self.disable_initiator_tag = (gobject.timeout_add
 
1550
                                              (time_to_die,
 
1551
                                               self.disable))
1581
1552
    
1582
1553
    # ExtendedTimeout - property
1583
1554
    @dbus_service_property(_interface, signature="t",
1703
1674
            logger.debug("Protocol version: %r", line)
1704
1675
            try:
1705
1676
                if int(line.strip().split()[0]) > 1:
1706
 
                    raise RuntimeError(line)
 
1677
                    raise RuntimeError
1707
1678
            except (ValueError, IndexError, RuntimeError) as error:
1708
1679
                logger.error("Unknown protocol version: %s", error)
1709
1680
                return
1771
1742
                    #wait until timeout or approved
1772
1743
                    time = datetime.datetime.now()
1773
1744
                    client.changedstate.acquire()
1774
 
                    client.changedstate.wait(
1775
 
                        float(timedelta_to_milliseconds(delay)
1776
 
                              / 1000))
 
1745
                    (client.changedstate.wait
 
1746
                     (float(client.timedelta_to_milliseconds(delay)
 
1747
                            / 1000)))
1777
1748
                    client.changedstate.release()
1778
1749
                    time2 = datetime.datetime.now()
1779
1750
                    if (time2 - time) >= delay:
1916
1887
    
1917
1888
    def add_pipe(self, parent_pipe, proc):
1918
1889
        """Dummy function; override as necessary"""
1919
 
        raise NotImplementedError()
 
1890
        raise NotImplementedError
1920
1891
 
1921
1892
 
1922
1893
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1929
1900
        use_ipv6:       Boolean; to use IPv6 or not
1930
1901
    """
1931
1902
    def __init__(self, server_address, RequestHandlerClass,
1932
 
                 interface=None, use_ipv6=True, socketfd=None):
1933
 
        """If socketfd is set, use that file descriptor instead of
1934
 
        creating a new one with socket.socket().
1935
 
        """
 
1903
                 interface=None, use_ipv6=True):
1936
1904
        self.interface = interface
1937
1905
        if use_ipv6:
1938
1906
            self.address_family = socket.AF_INET6
1939
 
        if socketfd is not None:
1940
 
            # Save the file descriptor
1941
 
            self.socketfd = socketfd
1942
 
            # Save the original socket.socket() function
1943
 
            self.socket_socket = socket.socket
1944
 
            # To implement --socket, we monkey patch socket.socket.
1945
 
            # 
1946
 
            # (When socketserver.TCPServer is a new-style class, we
1947
 
            # could make self.socket into a property instead of monkey
1948
 
            # patching socket.socket.)
1949
 
            # 
1950
 
            # Create a one-time-only replacement for socket.socket()
1951
 
            @functools.wraps(socket.socket)
1952
 
            def socket_wrapper(*args, **kwargs):
1953
 
                # Restore original function so subsequent calls are
1954
 
                # not affected.
1955
 
                socket.socket = self.socket_socket
1956
 
                del self.socket_socket
1957
 
                # This time only, return a new socket object from the
1958
 
                # saved file descriptor.
1959
 
                return socket.fromfd(self.socketfd, *args, **kwargs)
1960
 
            # Replace socket.socket() function with wrapper
1961
 
            socket.socket = socket_wrapper
1962
 
        # The socketserver.TCPServer.__init__ will call
1963
 
        # socket.socket(), which might be our replacement,
1964
 
        # socket_wrapper(), if socketfd was set.
1965
1907
        socketserver.TCPServer.__init__(self, server_address,
1966
1908
                                        RequestHandlerClass)
1967
 
    
1968
1909
    def server_bind(self):
1969
1910
        """This overrides the normal server_bind() function
1970
1911
        to bind to an interface if one was specified, and also NOT to
1978
1919
                try:
1979
1920
                    self.socket.setsockopt(socket.SOL_SOCKET,
1980
1921
                                           SO_BINDTODEVICE,
1981
 
                                           str(self.interface + '\0'))
 
1922
                                           str(self.interface
 
1923
                                               + '\0'))
1982
1924
                except socket.error as error:
1983
 
                    if error.errno == errno.EPERM:
1984
 
                        logger.error("No permission to bind to"
1985
 
                                     " interface %s", self.interface)
1986
 
                    elif error.errno == errno.ENOPROTOOPT:
 
1925
                    if error[0] == errno.EPERM:
 
1926
                        logger.error("No permission to"
 
1927
                                     " bind to interface %s",
 
1928
                                     self.interface)
 
1929
                    elif error[0] == errno.ENOPROTOOPT:
1987
1930
                        logger.error("SO_BINDTODEVICE not available;"
1988
1931
                                     " cannot bind to interface %s",
1989
1932
                                     self.interface)
1990
 
                    elif error.errno == errno.ENODEV:
1991
 
                        logger.error("Interface %s does not exist,"
1992
 
                                     " cannot bind", self.interface)
1993
1933
                    else:
1994
1934
                        raise
1995
1935
        # Only bind(2) the socket if we really need to.
1998
1938
                if self.address_family == socket.AF_INET6:
1999
1939
                    any_address = "::" # in6addr_any
2000
1940
                else:
2001
 
                    any_address = "0.0.0.0" # INADDR_ANY
 
1941
                    any_address = socket.INADDR_ANY
2002
1942
                self.server_address = (any_address,
2003
1943
                                       self.server_address[1])
2004
1944
            elif not self.server_address[1]:
2025
1965
    """
2026
1966
    def __init__(self, server_address, RequestHandlerClass,
2027
1967
                 interface=None, use_ipv6=True, clients=None,
2028
 
                 gnutls_priority=None, use_dbus=True, socketfd=None):
 
1968
                 gnutls_priority=None, use_dbus=True):
2029
1969
        self.enabled = False
2030
1970
        self.clients = clients
2031
1971
        if self.clients is None:
2035
1975
        IPv6_TCPServer.__init__(self, server_address,
2036
1976
                                RequestHandlerClass,
2037
1977
                                interface = interface,
2038
 
                                use_ipv6 = use_ipv6,
2039
 
                                socketfd = socketfd)
 
1978
                                use_ipv6 = use_ipv6)
2040
1979
    def server_activate(self):
2041
1980
        if self.enabled:
2042
1981
            return socketserver.TCPServer.server_activate(self)
2120
2059
        return True
2121
2060
 
2122
2061
 
2123
 
def rfc3339_duration_to_delta(duration):
2124
 
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2125
 
    
2126
 
    >>> rfc3339_duration_to_delta("P7D")
2127
 
    datetime.timedelta(7)
2128
 
    >>> rfc3339_duration_to_delta("PT60S")
2129
 
    datetime.timedelta(0, 60)
2130
 
    >>> rfc3339_duration_to_delta("PT60M")
2131
 
    datetime.timedelta(0, 3600)
2132
 
    >>> rfc3339_duration_to_delta("PT24H")
2133
 
    datetime.timedelta(1)
2134
 
    >>> rfc3339_duration_to_delta("P1W")
2135
 
    datetime.timedelta(7)
2136
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2137
 
    datetime.timedelta(0, 330)
2138
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2139
 
    datetime.timedelta(1, 200)
2140
 
    """
2141
 
    
2142
 
    # Parsing an RFC 3339 duration with regular expressions is not
2143
 
    # possible - there would have to be multiple places for the same
2144
 
    # values, like seconds.  The current code, while more esoteric, is
2145
 
    # cleaner without depending on a parsing library.  If Python had a
2146
 
    # built-in library for parsing we would use it, but we'd like to
2147
 
    # avoid excessive use of external libraries.
2148
 
    
2149
 
    # New type for defining tokens, syntax, and semantics all-in-one
2150
 
    Token = collections.namedtuple("Token",
2151
 
                                   ("regexp", # To match token; if
2152
 
                                              # "value" is not None,
2153
 
                                              # must have a "group"
2154
 
                                              # containing digits
2155
 
                                    "value",  # datetime.timedelta or
2156
 
                                              # None
2157
 
                                    "followers")) # Tokens valid after
2158
 
                                                  # this token
2159
 
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
2160
 
    # the "duration" ABNF definition in RFC 3339, Appendix A.
2161
 
    token_end = Token(re.compile(r"$"), None, frozenset())
2162
 
    token_second = Token(re.compile(r"(\d+)S"),
2163
 
                         datetime.timedelta(seconds=1),
2164
 
                         frozenset((token_end,)))
2165
 
    token_minute = Token(re.compile(r"(\d+)M"),
2166
 
                         datetime.timedelta(minutes=1),
2167
 
                         frozenset((token_second, token_end)))
2168
 
    token_hour = Token(re.compile(r"(\d+)H"),
2169
 
                       datetime.timedelta(hours=1),
2170
 
                       frozenset((token_minute, token_end)))
2171
 
    token_time = Token(re.compile(r"T"),
2172
 
                       None,
2173
 
                       frozenset((token_hour, token_minute,
2174
 
                                  token_second)))
2175
 
    token_day = Token(re.compile(r"(\d+)D"),
2176
 
                      datetime.timedelta(days=1),
2177
 
                      frozenset((token_time, token_end)))
2178
 
    token_month = Token(re.compile(r"(\d+)M"),
2179
 
                        datetime.timedelta(weeks=4),
2180
 
                        frozenset((token_day, token_end)))
2181
 
    token_year = Token(re.compile(r"(\d+)Y"),
2182
 
                       datetime.timedelta(weeks=52),
2183
 
                       frozenset((token_month, token_end)))
2184
 
    token_week = Token(re.compile(r"(\d+)W"),
2185
 
                       datetime.timedelta(weeks=1),
2186
 
                       frozenset((token_end,)))
2187
 
    token_duration = Token(re.compile(r"P"), None,
2188
 
                           frozenset((token_year, token_month,
2189
 
                                      token_day, token_time,
2190
 
                                      token_week))),
2191
 
    # Define starting values
2192
 
    value = datetime.timedelta() # Value so far
2193
 
    found_token = None
2194
 
    followers = frozenset(token_duration,) # Following valid tokens
2195
 
    s = duration                # String left to parse
2196
 
    # Loop until end token is found
2197
 
    while found_token is not token_end:
2198
 
        # Search for any currently valid tokens
2199
 
        for token in followers:
2200
 
            match = token.regexp.match(s)
2201
 
            if match is not None:
2202
 
                # Token found
2203
 
                if token.value is not None:
2204
 
                    # Value found, parse digits
2205
 
                    factor = int(match.group(1), 10)
2206
 
                    # Add to value so far
2207
 
                    value += factor * token.value
2208
 
                # Strip token from string
2209
 
                s = token.regexp.sub("", s, 1)
2210
 
                # Go to found token
2211
 
                found_token = token
2212
 
                # Set valid next tokens
2213
 
                followers = found_token.followers
2214
 
                break
2215
 
        else:
2216
 
            # No currently valid tokens were found
2217
 
            raise ValueError("Invalid RFC 3339 duration")
2218
 
    # End token found
2219
 
    return value
2220
 
 
2221
 
 
2222
2062
def string_to_delta(interval):
2223
2063
    """Parse a string and return a datetime.timedelta
2224
2064
    
2235
2075
    >>> string_to_delta('5m 30s')
2236
2076
    datetime.timedelta(0, 330)
2237
2077
    """
2238
 
    
2239
 
    try:
2240
 
        return rfc3339_duration_to_delta(interval)
2241
 
    except ValueError:
2242
 
        pass
2243
 
    
2244
2078
    timevalue = datetime.timedelta(0)
2245
2079
    for s in interval.split():
2246
2080
        try:
2259
2093
            else:
2260
2094
                raise ValueError("Unknown suffix {0!r}"
2261
2095
                                 .format(suffix))
2262
 
        except IndexError as e:
 
2096
        except (ValueError, IndexError) as e:
2263
2097
            raise ValueError(*(e.args))
2264
2098
        timevalue += delta
2265
2099
    return timevalue
2309
2143
                        help="Run self-test")
2310
2144
    parser.add_argument("--debug", action="store_true",
2311
2145
                        help="Debug mode; run in foreground and log"
2312
 
                        " to terminal", default=None)
 
2146
                        " to terminal")
2313
2147
    parser.add_argument("--debuglevel", metavar="LEVEL",
2314
2148
                        help="Debug level for stdout output")
2315
2149
    parser.add_argument("--priority", help="GnuTLS"
2322
2156
                        " files")
2323
2157
    parser.add_argument("--no-dbus", action="store_false",
2324
2158
                        dest="use_dbus", help="Do not provide D-Bus"
2325
 
                        " system bus interface", default=None)
 
2159
                        " system bus interface")
2326
2160
    parser.add_argument("--no-ipv6", action="store_false",
2327
 
                        dest="use_ipv6", help="Do not use IPv6",
2328
 
                        default=None)
 
2161
                        dest="use_ipv6", help="Do not use IPv6")
2329
2162
    parser.add_argument("--no-restore", action="store_false",
2330
2163
                        dest="restore", help="Do not restore stored"
2331
 
                        " state", default=None)
2332
 
    parser.add_argument("--socket", type=int,
2333
 
                        help="Specify a file descriptor to a network"
2334
 
                        " socket to use instead of creating one")
 
2164
                        " state")
2335
2165
    parser.add_argument("--statedir", metavar="DIR",
2336
2166
                        help="Directory to save/restore state in")
2337
 
    parser.add_argument("--foreground", action="store_true",
2338
 
                        help="Run in foreground", default=None)
2339
2167
    
2340
2168
    options = parser.parse_args()
2341
2169
    
2342
2170
    if options.check:
2343
2171
        import doctest
2344
 
        fail_count, test_count = doctest.testmod()
2345
 
        sys.exit(os.EX_OK if fail_count == 0 else 1)
 
2172
        doctest.testmod()
 
2173
        sys.exit()
2346
2174
    
2347
2175
    # Default values for config file for server-global settings
2348
2176
    server_defaults = { "interface": "",
2350
2178
                        "port": "",
2351
2179
                        "debug": "False",
2352
2180
                        "priority":
2353
 
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",
 
2181
                        "SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2354
2182
                        "servicename": "Mandos",
2355
2183
                        "use_dbus": "True",
2356
2184
                        "use_ipv6": "True",
2357
2185
                        "debuglevel": "",
2358
2186
                        "restore": "True",
2359
 
                        "socket": "",
2360
 
                        "statedir": "/var/lib/mandos",
2361
 
                        "foreground": "False",
 
2187
                        "statedir": "/var/lib/mandos"
2362
2188
                        }
2363
2189
    
2364
2190
    # Parse config file for server-global settings
2369
2195
    # Convert the SafeConfigParser object to a dict
2370
2196
    server_settings = server_config.defaults()
2371
2197
    # Use the appropriate methods on the non-string config options
2372
 
    for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
 
2198
    for option in ("debug", "use_dbus", "use_ipv6"):
2373
2199
        server_settings[option] = server_config.getboolean("DEFAULT",
2374
2200
                                                           option)
2375
2201
    if server_settings["port"]:
2376
2202
        server_settings["port"] = server_config.getint("DEFAULT",
2377
2203
                                                       "port")
2378
 
    if server_settings["socket"]:
2379
 
        server_settings["socket"] = server_config.getint("DEFAULT",
2380
 
                                                         "socket")
2381
 
        # Later, stdin will, and stdout and stderr might, be dup'ed
2382
 
        # over with an opened os.devnull.  But we don't want this to
2383
 
        # happen with a supplied network socket.
2384
 
        if 0 <= server_settings["socket"] <= 2:
2385
 
            server_settings["socket"] = os.dup(server_settings
2386
 
                                               ["socket"])
2387
2204
    del server_config
2388
2205
    
2389
2206
    # Override the settings from the config file with command line
2391
2208
    for option in ("interface", "address", "port", "debug",
2392
2209
                   "priority", "servicename", "configdir",
2393
2210
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2394
 
                   "statedir", "socket", "foreground"):
 
2211
                   "statedir"):
2395
2212
        value = getattr(options, option)
2396
2213
        if value is not None:
2397
2214
            server_settings[option] = value
2400
2217
    for option in server_settings.keys():
2401
2218
        if type(server_settings[option]) is str:
2402
2219
            server_settings[option] = unicode(server_settings[option])
2403
 
    # Force all boolean options to be boolean
2404
 
    for option in ("debug", "use_dbus", "use_ipv6", "restore",
2405
 
                   "foreground"):
2406
 
        server_settings[option] = bool(server_settings[option])
2407
 
    # Debug implies foreground
2408
 
    if server_settings["debug"]:
2409
 
        server_settings["foreground"] = True
2410
2220
    # Now we have our good server settings in "server_settings"
2411
2221
    
2412
2222
    ##################################################################
2418
2228
    use_ipv6 = server_settings["use_ipv6"]
2419
2229
    stored_state_path = os.path.join(server_settings["statedir"],
2420
2230
                                     stored_state_file)
2421
 
    foreground = server_settings["foreground"]
2422
2231
    
2423
2232
    if debug:
2424
2233
        initlogger(debug, logging.DEBUG)
2453
2262
                              use_ipv6=use_ipv6,
2454
2263
                              gnutls_priority=
2455
2264
                              server_settings["priority"],
2456
 
                              use_dbus=use_dbus,
2457
 
                              socketfd=(server_settings["socket"]
2458
 
                                        or None))
2459
 
    if not foreground:
2460
 
        pidfilename = "/run/mandos.pid"
2461
 
        if not os.path.isdir("/run/."):
2462
 
            pidfilename = "/var/run/mandos.pid"
2463
 
        pidfile = None
 
2265
                              use_dbus=use_dbus)
 
2266
    if not debug:
 
2267
        pidfilename = "/var/run/mandos.pid"
2464
2268
        try:
2465
2269
            pidfile = open(pidfilename, "w")
2466
2270
        except IOError as e:
2481
2285
        os.setgid(gid)
2482
2286
        os.setuid(uid)
2483
2287
    except OSError as error:
2484
 
        if error.errno != errno.EPERM:
2485
 
            raise
 
2288
        if error[0] != errno.EPERM:
 
2289
            raise error
2486
2290
    
2487
2291
    if debug:
2488
2292
        # Enable all possible GnuTLS debugging
2505
2309
            os.close(null)
2506
2310
    
2507
2311
    # Need to fork before connecting to D-Bus
2508
 
    if not foreground:
 
2312
    if not debug:
2509
2313
        # Close all input and output, do double fork, etc.
2510
2314
        daemon()
2511
2315
    
2512
 
    # multiprocessing will use threads, so before we use gobject we
2513
 
    # need to inform gobject that threads will be used.
2514
2316
    gobject.threads_init()
2515
2317
    
2516
2318
    global main_loop
2551
2353
    old_client_settings = {}
2552
2354
    clients_data = {}
2553
2355
    
2554
 
    # This is used to redirect stdout and stderr for checker processes
2555
 
    global wnull
2556
 
    wnull = open(os.devnull, "w") # A writable /dev/null
2557
 
    # Only used if server is running in foreground but not in debug
2558
 
    # mode
2559
 
    if debug or not foreground:
2560
 
        wnull.close()
2561
 
    
2562
2356
    # Get client data and settings from last running state.
2563
2357
    if server_settings["restore"]:
2564
2358
        try:
2580
2374
    
2581
2375
    with PGPEngine() as pgp:
2582
2376
        for client_name, client in clients_data.iteritems():
2583
 
            # Skip removed clients
2584
 
            if client_name not in client_settings:
2585
 
                continue
2586
 
            
2587
2377
            # Decide which value to use after restoring saved state.
2588
2378
            # We have three different values: Old config file,
2589
2379
            # new config file, and saved state.
2651
2441
    # Create all client objects
2652
2442
    for client_name, client in clients_data.iteritems():
2653
2443
        tcp_server.clients[client_name] = client_class(
2654
 
            name = client_name, settings = client,
2655
 
            server_settings = server_settings)
 
2444
            name = client_name, settings = client)
2656
2445
    
2657
2446
    if not tcp_server.clients:
2658
2447
        logger.warning("No clients defined")
2659
2448
    
2660
 
    if not foreground:
2661
 
        if pidfile is not None:
2662
 
            try:
2663
 
                with pidfile:
2664
 
                    pid = os.getpid()
2665
 
                    pidfile.write(str(pid) + "\n".encode("utf-8"))
2666
 
            except IOError:
2667
 
                logger.error("Could not write to file %r with PID %d",
2668
 
                             pidfilename, pid)
2669
 
        del pidfile
 
2449
    if not debug:
 
2450
        try:
 
2451
            with pidfile:
 
2452
                pid = os.getpid()
 
2453
                pidfile.write(str(pid) + "\n".encode("utf-8"))
 
2454
            del pidfile
 
2455
        except IOError:
 
2456
            logger.error("Could not write to file %r with PID %d",
 
2457
                         pidfilename, pid)
 
2458
        except NameError:
 
2459
            # "pidfile" was never created
 
2460
            pass
2670
2461
        del pidfilename
 
2462
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2671
2463
    
2672
2464
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2673
2465
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2741
2533
        service.cleanup()
2742
2534
        
2743
2535
        multiprocessing.active_children()
2744
 
        wnull.close()
2745
2536
        if not (tcp_server.clients or client_settings):
2746
2537
            return
2747
2538
        
2759
2550
                # A list of attributes that can not be pickled
2760
2551
                # + secret.
2761
2552
                exclude = set(("bus", "changedstate", "secret",
2762
 
                               "checker", "server_settings"))
 
2553
                               "checker"))
2763
2554
                for name, typ in (inspect.getmembers
2764
2555
                                  (dbus.service.Object)):
2765
2556
                    exclude.add(name)
2793
2584
            else:
2794
2585
                logger.warning("Could not save persistent state:",
2795
2586
                               exc_info=e)
2796
 
                raise
 
2587
                raise e
2797
2588
        
2798
2589
        # Delete all clients, and settings from config
2799
2590
        while tcp_server.clients: