/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-06 16:13:00 UTC
  • Revision ID: teddy@recompile.se-20120506161300-43rls2rr4qub3zhw
* mandos: Use a class decorator instead of a metaclass to provide
          alternate D-Bus interface names on D-Bus object attributes.
  (alternate_dbus_interfaces): New class decorator.
  (AlternateDBusNamesMetaclass, ClientDBusTransitional,
   MandosDBusServiceTransitional): Removed; all users changed.
  (ClientDbus, MandosDBusService): Use new "alternate_dbus_interfaces"
                                   class decorator.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
34
34
from __future__ import (division, absolute_import, print_function,
35
35
                        unicode_literals)
36
36
 
37
 
from future_builtins import *
38
 
 
39
37
import SocketServer as socketserver
40
38
import socket
41
39
import argparse
88
86
    except ImportError:
89
87
        SO_BINDTODEVICE = None
90
88
 
91
 
version = "1.5.5"
 
89
version = "1.5.3"
92
90
stored_state_file = "clients.pickle"
93
91
 
94
92
logger = logging.getLogger()
151
149
    def __enter__(self):
152
150
        return self
153
151
    
154
 
    def __exit__(self, exc_type, exc_value, traceback):
 
152
    def __exit__ (self, exc_type, exc_value, traceback):
155
153
        self._cleanup()
156
154
        return False
157
155
    
379
377
                                 self.server_state_changed)
380
378
        self.server_state_changed(self.server.GetState())
381
379
 
382
 
 
383
380
class AvahiServiceToSyslog(AvahiService):
384
381
    def rename(self):
385
382
        """Add the new name to the syslog messages"""
390
387
                                .format(self.name)))
391
388
        return ret
392
389
 
393
 
 
394
390
def timedelta_to_milliseconds(td):
395
391
    "Convert a datetime.timedelta() to milliseconds"
396
392
    return ((td.days * 24 * 60 * 60 * 1000)
397
393
            + (td.seconds * 1000)
398
394
            + (td.microseconds // 1000))
399
395
 
400
 
 
401
396
class Client(object):
402
397
    """A representation of a client host served by this server.
403
398
    
442
437
    """
443
438
    
444
439
    runtime_expansions = ("approval_delay", "approval_duration",
445
 
                          "created", "enabled", "expires",
446
 
                          "fingerprint", "host", "interval",
447
 
                          "last_approval_request", "last_checked_ok",
 
440
                          "created", "enabled", "fingerprint",
 
441
                          "host", "interval", "last_checked_ok",
448
442
                          "last_enabled", "name", "timeout")
449
443
    client_defaults = { "timeout": "5m",
450
444
                        "extended_timeout": "15m",
576
570
        if getattr(self, "enabled", False):
577
571
            # Already enabled
578
572
            return
 
573
        self.send_changedstate()
579
574
        self.expires = datetime.datetime.utcnow() + self.timeout
580
575
        self.enabled = True
581
576
        self.last_enabled = datetime.datetime.utcnow()
582
577
        self.init_checker()
583
 
        self.send_changedstate()
584
578
    
585
579
    def disable(self, quiet=True):
586
580
        """Disable this client."""
587
581
        if not getattr(self, "enabled", False):
588
582
            return False
589
583
        if not quiet:
 
584
            self.send_changedstate()
 
585
        if not quiet:
590
586
            logger.info("Disabling client %s", self.name)
591
 
        if getattr(self, "disable_initiator_tag", None) is not None:
 
587
        if getattr(self, "disable_initiator_tag", False):
592
588
            gobject.source_remove(self.disable_initiator_tag)
593
589
            self.disable_initiator_tag = None
594
590
        self.expires = None
595
 
        if getattr(self, "checker_initiator_tag", None) is not None:
 
591
        if getattr(self, "checker_initiator_tag", False):
596
592
            gobject.source_remove(self.checker_initiator_tag)
597
593
            self.checker_initiator_tag = None
598
594
        self.stop_checker()
599
595
        self.enabled = False
600
 
        if not quiet:
601
 
            self.send_changedstate()
602
596
        # Do not run this again if called by a gobject.timeout_add
603
597
        return False
604
598
    
608
602
    def init_checker(self):
609
603
        # Schedule a new checker to be started an 'interval' from now,
610
604
        # and every interval from then on.
611
 
        if self.checker_initiator_tag is not None:
612
 
            gobject.source_remove(self.checker_initiator_tag)
613
605
        self.checker_initiator_tag = (gobject.timeout_add
614
606
                                      (self.interval_milliseconds(),
615
607
                                       self.start_checker))
616
608
        # Schedule a disable() when 'timeout' has passed
617
 
        if self.disable_initiator_tag is not None:
618
 
            gobject.source_remove(self.disable_initiator_tag)
619
609
        self.disable_initiator_tag = (gobject.timeout_add
620
610
                                   (self.timeout_milliseconds(),
621
611
                                    self.disable))
652
642
            timeout = self.timeout
653
643
        if self.disable_initiator_tag is not None:
654
644
            gobject.source_remove(self.disable_initiator_tag)
655
 
            self.disable_initiator_tag = None
656
645
        if getattr(self, "enabled", False):
657
646
            self.disable_initiator_tag = (gobject.timeout_add
658
647
                                          (timedelta_to_milliseconds
668
657
        If a checker already exists, leave it running and do
669
658
        nothing."""
670
659
        # The reason for not killing a running checker is that if we
671
 
        # did that, and if a checker (for some reason) started running
672
 
        # slowly and taking more than 'interval' time, then the client
673
 
        # would inevitably timeout, since no checker would get a
674
 
        # chance to run to completion.  If we instead leave running
 
660
        # did that, then if a checker (for some reason) started
 
661
        # running slowly and taking more than 'interval' time, the
 
662
        # client would inevitably timeout, since no checker would get
 
663
        # a chance to run to completion.  If we instead leave running
675
664
        # checkers alone, the checker would have to take more time
676
665
        # than 'timeout' for the client to be disabled, which is as it
677
666
        # should be.
691
680
                                      self.current_checker_command)
692
681
        # Start a new checker if needed
693
682
        if self.checker is None:
694
 
            # Escape attributes for the shell
695
 
            escaped_attrs = dict(
696
 
                (attr, re.escape(unicode(getattr(self, attr))))
697
 
                for attr in
698
 
                self.runtime_expansions)
699
683
            try:
700
 
                command = self.checker_command % escaped_attrs
701
 
            except TypeError as error:
702
 
                logger.error('Could not format string "%s"',
703
 
                             self.checker_command, exc_info=error)
704
 
                return True # Try again later
 
684
                # In case checker_command has exactly one % operator
 
685
                command = self.checker_command % self.host
 
686
            except TypeError:
 
687
                # Escape attributes for the shell
 
688
                escaped_attrs = dict(
 
689
                    (attr,
 
690
                     re.escape(unicode(str(getattr(self, attr, "")),
 
691
                                       errors=
 
692
                                       'replace')))
 
693
                    for attr in
 
694
                    self.runtime_expansions)
 
695
                
 
696
                try:
 
697
                    command = self.checker_command % escaped_attrs
 
698
                except TypeError as error:
 
699
                    logger.error('Could not format string "%s"',
 
700
                                 self.checker_command, exc_info=error)
 
701
                    return True # Try again later
705
702
            self.current_checker_command = command
706
703
            try:
707
704
                logger.info("Starting checker %r for %s",
713
710
                self.checker = subprocess.Popen(command,
714
711
                                                close_fds=True,
715
712
                                                shell=True, cwd="/")
 
713
                self.checker_callback_tag = (gobject.child_watch_add
 
714
                                             (self.checker.pid,
 
715
                                              self.checker_callback,
 
716
                                              data=command))
 
717
                # The checker may have completed before the gobject
 
718
                # watch was added.  Check for this.
 
719
                pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
720
                if pid:
 
721
                    gobject.source_remove(self.checker_callback_tag)
 
722
                    self.checker_callback(pid, status, command)
716
723
            except OSError as error:
717
724
                logger.error("Failed to start subprocess",
718
725
                             exc_info=error)
719
 
            self.checker_callback_tag = (gobject.child_watch_add
720
 
                                         (self.checker.pid,
721
 
                                          self.checker_callback,
722
 
                                          data=command))
723
 
            # The checker may have completed before the gobject
724
 
            # watch was added.  Check for this.
725
 
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
726
 
            if pid:
727
 
                gobject.source_remove(self.checker_callback_tag)
728
 
                self.checker_callback(pid, status, command)
729
726
        # Re-run this periodically if run by gobject.timeout_add
730
727
        return True
731
728
    
982
979
                            tag.appendChild(ann_tag)
983
980
                # Add interface annotation tags
984
981
                for annotation, value in dict(
985
 
                    itertools.chain.from_iterable(
986
 
                        annotations().iteritems()
987
 
                        for name, annotations in
988
 
                        self._get_all_dbus_things("interface")
989
 
                        if name == if_tag.getAttribute("name")
990
 
                        )).iteritems():
 
982
                    itertools.chain(
 
983
                        *(annotations().iteritems()
 
984
                          for name, annotations in
 
985
                          self._get_all_dbus_things("interface")
 
986
                          if name == if_tag.getAttribute("name")
 
987
                          ))).iteritems():
991
988
                    ann_tag = document.createElement("annotation")
992
989
                    ann_tag.setAttribute("name", annotation)
993
990
                    ann_tag.setAttribute("value", value)
1016
1013
        return xmlstring
1017
1014
 
1018
1015
 
1019
 
def datetime_to_dbus(dt, variant_level=0):
 
1016
def datetime_to_dbus (dt, variant_level=0):
1020
1017
    """Convert a UTC datetime.datetime() to a D-Bus type."""
1021
1018
    if dt is None:
1022
1019
        return dbus.String("", variant_level = variant_level)
1030
1027
    interface names according to the "alt_interface_names" mapping.
1031
1028
    Usage:
1032
1029
    
1033
 
    @alternate_dbus_interfaces({"org.example.Interface":
1034
 
                                    "net.example.AlternateInterface"})
 
1030
    @alternate_dbus_names({"org.example.Interface":
 
1031
                               "net.example.AlternateInterface"})
1035
1032
    class SampleDBusObject(dbus.service.Object):
1036
1033
        @dbus.service.method("org.example.Interface")
1037
1034
        def SampleDBusMethod():
1336
1333
        return False
1337
1334
    
1338
1335
    def approve(self, value=True):
 
1336
        self.send_changedstate()
1339
1337
        self.approved = value
1340
1338
        gobject.timeout_add(timedelta_to_milliseconds
1341
1339
                            (self.approval_duration),
1342
1340
                            self._reset_approved)
1343
 
        self.send_changedstate()
1344
1341
    
1345
1342
    ## D-Bus methods, signals & properties
1346
1343
    _interface = "se.recompile.Mandos.Client"
1530
1527
    def Timeout_dbus_property(self, value=None):
1531
1528
        if value is None:       # get
1532
1529
            return dbus.UInt64(self.timeout_milliseconds())
1533
 
        old_timeout = self.timeout
1534
1530
        self.timeout = datetime.timedelta(0, 0, 0, value)
1535
 
        # Reschedule disabling
 
1531
        # Reschedule timeout
1536
1532
        if self.enabled:
1537
1533
            now = datetime.datetime.utcnow()
1538
 
            self.expires += self.timeout - old_timeout
1539
 
            if self.expires <= now:
 
1534
            time_to_die = timedelta_to_milliseconds(
 
1535
                (self.last_checked_ok + self.timeout) - now)
 
1536
            if time_to_die <= 0:
1540
1537
                # The timeout has passed
1541
1538
                self.disable()
1542
1539
            else:
 
1540
                self.expires = (now +
 
1541
                                datetime.timedelta(milliseconds =
 
1542
                                                   time_to_die))
1543
1543
                if (getattr(self, "disable_initiator_tag", None)
1544
1544
                    is None):
1545
1545
                    return
1546
1546
                gobject.source_remove(self.disable_initiator_tag)
1547
 
                self.disable_initiator_tag = (
1548
 
                    gobject.timeout_add(
1549
 
                        timedelta_to_milliseconds(self.expires - now),
1550
 
                        self.disable))
 
1547
                self.disable_initiator_tag = (gobject.timeout_add
 
1548
                                              (time_to_die,
 
1549
                                               self.disable))
1551
1550
    
1552
1551
    # ExtendedTimeout - property
1553
1552
    @dbus_service_property(_interface, signature="t",
1741
1740
                    #wait until timeout or approved
1742
1741
                    time = datetime.datetime.now()
1743
1742
                    client.changedstate.acquire()
1744
 
                    client.changedstate.wait(
1745
 
                        float(timedelta_to_milliseconds(delay)
1746
 
                              / 1000))
 
1743
                    (client.changedstate.wait
 
1744
                     (float(client.timedelta_to_milliseconds(delay)
 
1745
                            / 1000)))
1747
1746
                    client.changedstate.release()
1748
1747
                    time2 = datetime.datetime.now()
1749
1748
                    if (time2 - time) >= delay:
1865
1864
    def process_request(self, request, address):
1866
1865
        """Start a new process to process the request."""
1867
1866
        proc = multiprocessing.Process(target = self.sub_process_main,
1868
 
                                       args = (request, address))
 
1867
                                       args = (request,
 
1868
                                               address))
1869
1869
        proc.start()
1870
1870
        return proc
1871
1871
 
1899
1899
        use_ipv6:       Boolean; to use IPv6 or not
1900
1900
    """
1901
1901
    def __init__(self, server_address, RequestHandlerClass,
1902
 
                 interface=None, use_ipv6=True, socketfd=None):
1903
 
        """If socketfd is set, use that file descriptor instead of
1904
 
        creating a new one with socket.socket().
1905
 
        """
 
1902
                 interface=None, use_ipv6=True):
1906
1903
        self.interface = interface
1907
1904
        if use_ipv6:
1908
1905
            self.address_family = socket.AF_INET6
1909
 
        if socketfd is not None:
1910
 
            # Save the file descriptor
1911
 
            self.socketfd = socketfd
1912
 
            # Save the original socket.socket() function
1913
 
            self.socket_socket = socket.socket
1914
 
            # To implement --socket, we monkey patch socket.socket.
1915
 
            # 
1916
 
            # (When socketserver.TCPServer is a new-style class, we
1917
 
            # could make self.socket into a property instead of monkey
1918
 
            # patching socket.socket.)
1919
 
            # 
1920
 
            # Create a one-time-only replacement for socket.socket()
1921
 
            @functools.wraps(socket.socket)
1922
 
            def socket_wrapper(*args, **kwargs):
1923
 
                # Restore original function so subsequent calls are
1924
 
                # not affected.
1925
 
                socket.socket = self.socket_socket
1926
 
                del self.socket_socket
1927
 
                # This time only, return a new socket object from the
1928
 
                # saved file descriptor.
1929
 
                return socket.fromfd(self.socketfd, *args, **kwargs)
1930
 
            # Replace socket.socket() function with wrapper
1931
 
            socket.socket = socket_wrapper
1932
 
        # The socketserver.TCPServer.__init__ will call
1933
 
        # socket.socket(), which might be our replacement,
1934
 
        # socket_wrapper(), if socketfd was set.
1935
1906
        socketserver.TCPServer.__init__(self, server_address,
1936
1907
                                        RequestHandlerClass)
1937
 
    
1938
1908
    def server_bind(self):
1939
1909
        """This overrides the normal server_bind() function
1940
1910
        to bind to an interface if one was specified, and also NOT to
1951
1921
                                           str(self.interface
1952
1922
                                               + '\0'))
1953
1923
                except socket.error as error:
1954
 
                    if error.errno == errno.EPERM:
 
1924
                    if error[0] == errno.EPERM:
1955
1925
                        logger.error("No permission to"
1956
1926
                                     " bind to interface %s",
1957
1927
                                     self.interface)
1958
 
                    elif error.errno == errno.ENOPROTOOPT:
 
1928
                    elif error[0] == errno.ENOPROTOOPT:
1959
1929
                        logger.error("SO_BINDTODEVICE not available;"
1960
1930
                                     " cannot bind to interface %s",
1961
1931
                                     self.interface)
1962
 
                    elif error.errno == errno.ENODEV:
1963
 
                        logger.error("Interface %s does not"
1964
 
                                     " exist, cannot bind",
1965
 
                                     self.interface)
1966
1932
                    else:
1967
1933
                        raise
1968
1934
        # Only bind(2) the socket if we really need to.
1998
1964
    """
1999
1965
    def __init__(self, server_address, RequestHandlerClass,
2000
1966
                 interface=None, use_ipv6=True, clients=None,
2001
 
                 gnutls_priority=None, use_dbus=True, socketfd=None):
 
1967
                 gnutls_priority=None, use_dbus=True):
2002
1968
        self.enabled = False
2003
1969
        self.clients = clients
2004
1970
        if self.clients is None:
2008
1974
        IPv6_TCPServer.__init__(self, server_address,
2009
1975
                                RequestHandlerClass,
2010
1976
                                interface = interface,
2011
 
                                use_ipv6 = use_ipv6,
2012
 
                                socketfd = socketfd)
 
1977
                                use_ipv6 = use_ipv6)
2013
1978
    def server_activate(self):
2014
1979
        if self.enabled:
2015
1980
            return socketserver.TCPServer.server_activate(self)
2028
1993
    
2029
1994
    def handle_ipc(self, source, condition, parent_pipe=None,
2030
1995
                   proc = None, client_object=None):
 
1996
        condition_names = {
 
1997
            gobject.IO_IN: "IN",   # There is data to read.
 
1998
            gobject.IO_OUT: "OUT", # Data can be written (without
 
1999
                                    # blocking).
 
2000
            gobject.IO_PRI: "PRI", # There is urgent data to read.
 
2001
            gobject.IO_ERR: "ERR", # Error condition.
 
2002
            gobject.IO_HUP: "HUP"  # Hung up (the connection has been
 
2003
                                    # broken, usually for pipes and
 
2004
                                    # sockets).
 
2005
            }
 
2006
        conditions_string = ' | '.join(name
 
2007
                                       for cond, name in
 
2008
                                       condition_names.iteritems()
 
2009
                                       if cond & condition)
2031
2010
        # error, or the other end of multiprocessing.Pipe has closed
2032
 
        if condition & (gobject.IO_ERR | gobject.IO_HUP):
 
2011
        if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
2033
2012
            # Wait for other process to exit
2034
2013
            proc.join()
2035
2014
            return False
2196
2175
    parser.add_argument("--no-restore", action="store_false",
2197
2176
                        dest="restore", help="Do not restore stored"
2198
2177
                        " state")
2199
 
    parser.add_argument("--socket", type=int,
2200
 
                        help="Specify a file descriptor to a network"
2201
 
                        " socket to use instead of creating one")
2202
2178
    parser.add_argument("--statedir", metavar="DIR",
2203
2179
                        help="Directory to save/restore state in")
2204
2180
    
2221
2197
                        "use_ipv6": "True",
2222
2198
                        "debuglevel": "",
2223
2199
                        "restore": "True",
2224
 
                        "socket": "",
2225
2200
                        "statedir": "/var/lib/mandos"
2226
2201
                        }
2227
2202
    
2239
2214
    if server_settings["port"]:
2240
2215
        server_settings["port"] = server_config.getint("DEFAULT",
2241
2216
                                                       "port")
2242
 
    if server_settings["socket"]:
2243
 
        server_settings["socket"] = server_config.getint("DEFAULT",
2244
 
                                                         "socket")
2245
 
        # Later, stdin will, and stdout and stderr might, be dup'ed
2246
 
        # over with an opened os.devnull.  But we don't want this to
2247
 
        # happen with a supplied network socket.
2248
 
        if 0 <= server_settings["socket"] <= 2:
2249
 
            server_settings["socket"] = os.dup(server_settings
2250
 
                                               ["socket"])
2251
2217
    del server_config
2252
2218
    
2253
2219
    # Override the settings from the config file with command line
2255
2221
    for option in ("interface", "address", "port", "debug",
2256
2222
                   "priority", "servicename", "configdir",
2257
2223
                   "use_dbus", "use_ipv6", "debuglevel", "restore",
2258
 
                   "statedir", "socket"):
 
2224
                   "statedir"):
2259
2225
        value = getattr(options, option)
2260
2226
        if value is not None:
2261
2227
            server_settings[option] = value
2309
2275
                              use_ipv6=use_ipv6,
2310
2276
                              gnutls_priority=
2311
2277
                              server_settings["priority"],
2312
 
                              use_dbus=use_dbus,
2313
 
                              socketfd=(server_settings["socket"]
2314
 
                                        or None))
 
2278
                              use_dbus=use_dbus)
2315
2279
    if not debug:
2316
2280
        pidfilename = "/var/run/mandos.pid"
2317
2281
        try:
2334
2298
        os.setgid(gid)
2335
2299
        os.setuid(uid)
2336
2300
    except OSError as error:
2337
 
        if error.errno != errno.EPERM:
 
2301
        if error[0] != errno.EPERM:
2338
2302
            raise error
2339
2303
    
2340
2304
    if debug:
2362
2326
        # Close all input and output, do double fork, etc.
2363
2327
        daemon()
2364
2328
    
2365
 
    # multiprocessing will use threads, so before we use gobject we
2366
 
    # need to inform gobject that threads will be used.
2367
2329
    gobject.threads_init()
2368
2330
    
2369
2331
    global main_loop
2510
2472
            # "pidfile" was never created
2511
2473
            pass
2512
2474
        del pidfilename
 
2475
        signal.signal(signal.SIGINT, signal.SIG_IGN)
2513
2476
    
2514
2477
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2515
2478
    signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2615
2578
                del client_settings[client.name]["secret"]
2616
2579
        
2617
2580
        try:
2618
 
            with (tempfile.NamedTemporaryFile
2619
 
                  (mode='wb', suffix=".pickle", prefix='clients-',
2620
 
                   dir=os.path.dirname(stored_state_path),
2621
 
                   delete=False)) as stored_state:
 
2581
            tempfd, tempname = tempfile.mkstemp(suffix=".pickle",
 
2582
                                                prefix="clients-",
 
2583
                                                dir=os.path.dirname
 
2584
                                                (stored_state_path))
 
2585
            with os.fdopen(tempfd, "wb") as stored_state:
2622
2586
                pickle.dump((clients, client_settings), stored_state)
2623
 
                tempname=stored_state.name
2624
2587
            os.rename(tempname, stored_state_path)
2625
2588
        except (IOError, OSError) as e:
2626
2589
            if not debug: