/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos

* dbus-mandos.conf: New; to be copied to
                    "/etc/dbus-1/system.d/mandos.conf".

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
79
79
        SO_BINDTODEVICE = None
80
80
 
81
81
 
82
 
version = "1.0.12"
 
82
version = "1.0.14"
83
83
 
84
84
logger = logging.Logger(u'mandos')
85
85
syslogger = (logging.handlers.SysLogHandler
292
292
        elif u"secfile" in config:
293
293
            with closing(open(os.path.expanduser
294
294
                              (os.path.expandvars
295
 
                               (config[u"secfile"])))) as secfile:
 
295
                               (config[u"secfile"])),
 
296
                              "rb")) as secfile:
296
297
                self.secret = secfile.read()
297
298
        else:
298
299
            raise TypeError(u"No secret or secfile for client %s"
324
325
        self.checker_initiator_tag = (gobject.timeout_add
325
326
                                      (self.interval_milliseconds(),
326
327
                                       self.start_checker))
327
 
        # Also start a new checker *right now*.
328
 
        self.start_checker()
329
328
        # Schedule a disable() when 'timeout' has passed
330
329
        self.disable_initiator_tag = (gobject.timeout_add
331
330
                                   (self.timeout_milliseconds(),
332
331
                                    self.disable))
333
332
        self.enabled = True
 
333
        # Also start a new checker *right now*.
 
334
        self.start_checker()
334
335
    
335
 
    def disable(self):
 
336
    def disable(self, quiet=True):
336
337
        """Disable this client."""
337
338
        if not getattr(self, "enabled", False):
338
339
            return False
339
 
        logger.info(u"Disabling client %s", self.name)
 
340
        if not quiet:
 
341
            logger.info(u"Disabling client %s", self.name)
340
342
        if getattr(self, u"disable_initiator_tag", False):
341
343
            gobject.source_remove(self.disable_initiator_tag)
342
344
            self.disable_initiator_tag = None
398
400
        # is as it should be.
399
401
        
400
402
        # If a checker exists, make sure it is not a zombie
401
 
        if self.checker is not None:
 
403
        try:
402
404
            pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
 
405
        except (AttributeError, OSError), error:
 
406
            if (isinstance(error, OSError)
 
407
                and error.errno != errno.ECHILD):
 
408
                raise error
 
409
        else:
403
410
            if pid:
404
411
                logger.warning(u"Checker was a zombie")
405
412
                gobject.source_remove(self.checker_callback_tag)
461
468
        logger.debug(u"Stopping checker for %(name)s", vars(self))
462
469
        try:
463
470
            os.kill(self.checker.pid, signal.SIGTERM)
464
 
            #os.sleep(0.5)
 
471
            #time.sleep(0.5)
465
472
            #if self.checker.poll() is None:
466
473
            #    os.kill(self.checker.pid, signal.SIGKILL)
467
474
        except OSError, error:
620
627
        """Standard D-Bus method, overloaded to insert property tags.
621
628
        """
622
629
        xmlstring = dbus.service.Object.Introspect(self, object_path,
623
 
                                           connection)
624
 
        document = xml.dom.minidom.parseString(xmlstring)
625
 
        del xmlstring
626
 
        def make_tag(document, name, prop):
627
 
            e = document.createElement(u"property")
628
 
            e.setAttribute(u"name", name)
629
 
            e.setAttribute(u"type", prop._dbus_signature)
630
 
            e.setAttribute(u"access", prop._dbus_access)
631
 
            return e
632
 
        for if_tag in document.getElementsByTagName(u"interface"):
633
 
            for tag in (make_tag(document, name, prop)
634
 
                        for name, prop
635
 
                        in self._get_all_dbus_properties()
636
 
                        if prop._dbus_interface
637
 
                        == if_tag.getAttribute(u"name")):
638
 
                if_tag.appendChild(tag)
639
 
        xmlstring = document.toxml(u"utf-8")
640
 
        document.unlink()
 
630
                                                   connection)
 
631
        try:
 
632
            document = xml.dom.minidom.parseString(xmlstring)
 
633
            def make_tag(document, name, prop):
 
634
                e = document.createElement(u"property")
 
635
                e.setAttribute(u"name", name)
 
636
                e.setAttribute(u"type", prop._dbus_signature)
 
637
                e.setAttribute(u"access", prop._dbus_access)
 
638
                return e
 
639
            for if_tag in document.getElementsByTagName(u"interface"):
 
640
                for tag in (make_tag(document, name, prop)
 
641
                            for name, prop
 
642
                            in self._get_all_dbus_properties()
 
643
                            if prop._dbus_interface
 
644
                            == if_tag.getAttribute(u"name")):
 
645
                    if_tag.appendChild(tag)
 
646
                # Add the names to the return values for the
 
647
                # "org.freedesktop.DBus.Properties" methods
 
648
                if (if_tag.getAttribute(u"name")
 
649
                    == u"org.freedesktop.DBus.Properties"):
 
650
                    for cn in if_tag.getElementsByTagName(u"method"):
 
651
                        if cn.getAttribute(u"name") == u"Get":
 
652
                            for arg in cn.getElementsByTagName(u"arg"):
 
653
                                if (arg.getAttribute(u"direction")
 
654
                                    == u"out"):
 
655
                                    arg.setAttribute(u"name", u"value")
 
656
                        elif cn.getAttribute(u"name") == u"GetAll":
 
657
                            for arg in cn.getElementsByTagName(u"arg"):
 
658
                                if (arg.getAttribute(u"direction")
 
659
                                    == u"out"):
 
660
                                    arg.setAttribute(u"name", u"props")
 
661
            xmlstring = document.toxml(u"utf-8")
 
662
            document.unlink()
 
663
        except (AttributeError, xml.dom.DOMException,
 
664
                xml.parsers.expat.ExpatError), error:
 
665
            logger.error(u"Failed to override Introspection method",
 
666
                         error)
641
667
        return xmlstring
642
668
 
643
669
 
680
706
                                       variant_level=1))
681
707
        return r
682
708
    
683
 
    def disable(self, signal = True):
 
709
    def disable(self, quiet = False):
684
710
        oldstate = getattr(self, u"enabled", False)
685
 
        r = Client.disable(self)
686
 
        if signal and oldstate != self.enabled:
 
711
        r = Client.disable(self, quiet=quiet)
 
712
        if not quiet and oldstate != self.enabled:
687
713
            # Emit D-Bus signal
688
714
            self.PropertyChanged(dbus.String(u"enabled"),
689
715
                                 dbus.Boolean(False, variant_level=1))
781
807
        "D-Bus signal"
782
808
        pass
783
809
    
784
 
    # ReceivedSecret - signal
 
810
    # GotSecret - signal
785
811
    @dbus.service.signal(_interface)
786
 
    def ReceivedSecret(self):
 
812
    def GotSecret(self):
787
813
        "D-Bus signal"
788
814
        pass
789
815
    
1276
1302
                    client.checked_ok()
1277
1303
                    if self.use_dbus:
1278
1304
                        # Emit D-Bus signal
1279
 
                        client.ReceivedSecret()
 
1305
                        client.GotSecret()
1280
1306
                    break
1281
1307
            else:
1282
1308
                logger.error(u"Sending secret to unknown client %s",
1320
1346
            elif suffix == u"w":
1321
1347
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1322
1348
            else:
1323
 
                raise ValueError
1324
 
        except (ValueError, IndexError):
1325
 
            raise ValueError
 
1349
                raise ValueError(u"Unknown suffix %r" % suffix)
 
1350
        except (ValueError, IndexError), e:
 
1351
            raise ValueError(e.message)
1326
1352
        timevalue += delta
1327
1353
    return timevalue
1328
1354
 
1367
1393
        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1368
1394
        if not stat.S_ISCHR(os.fstat(null).st_mode):
1369
1395
            raise OSError(errno.ENODEV,
1370
 
                          u"/dev/null not a character device")
 
1396
                          u"%s not a character device"
 
1397
                          % os.path.devnull)
1371
1398
        os.dup2(null, sys.stdin.fileno())
1372
1399
        os.dup2(null, sys.stdout.fileno())
1373
1400
        os.dup2(null, sys.stderr.fileno())
1540
1567
    bus = dbus.SystemBus()
1541
1568
    # End of Avahi example code
1542
1569
    if use_dbus:
1543
 
        bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
 
1570
        try:
 
1571
            bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
 
1572
                                            bus, do_not_queue=True)
 
1573
        except dbus.exceptions.NameExistsException, e:
 
1574
            logger.error(unicode(e) + u", disabling D-Bus")
 
1575
            use_dbus = False
 
1576
            server_settings[u"use_dbus"] = False
 
1577
            tcp_server.use_dbus = False
1544
1578
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1545
1579
    service = AvahiService(name = server_settings[u"servicename"],
1546
1580
                           servicetype = u"_mandos._tcp",
1584
1618
        pass
1585
1619
    del pidfilename
1586
1620
    
1587
 
    def cleanup():
1588
 
        "Cleanup function; run on exit"
1589
 
        service.cleanup()
1590
 
        
1591
 
        while tcp_server.clients:
1592
 
            client = tcp_server.clients.pop()
1593
 
            client.disable_hook = None
1594
 
            client.disable()
1595
 
    
1596
 
    atexit.register(cleanup)
1597
 
    
1598
1621
    if not debug:
1599
1622
        signal.signal(signal.SIGINT, signal.SIG_IGN)
1600
1623
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1645
1668
                        tcp_server.clients.remove(c)
1646
1669
                        c.remove_from_connection()
1647
1670
                        # Don't signal anything except ClientRemoved
1648
 
                        c.disable(signal=False)
 
1671
                        c.disable(quiet=True)
1649
1672
                        # Emit D-Bus signal
1650
1673
                        self.ClientRemoved(object_path, c.name)
1651
1674
                        return
1652
 
                raise KeyError
 
1675
                raise KeyError(object_path)
1653
1676
            
1654
1677
            del _interface
1655
1678
        
1656
1679
        mandos_dbus_service = MandosDBusService()
1657
1680
    
 
1681
    def cleanup():
 
1682
        "Cleanup function; run on exit"
 
1683
        service.cleanup()
 
1684
        
 
1685
        while tcp_server.clients:
 
1686
            client = tcp_server.clients.pop()
 
1687
            if use_dbus:
 
1688
                client.remove_from_connection()
 
1689
            client.disable_hook = None
 
1690
            # Don't signal anything except ClientRemoved
 
1691
            client.disable(quiet=True)
 
1692
            if use_dbus:
 
1693
                # Emit D-Bus signal
 
1694
                mandos_dbus_service.ClientRemoved(client.dbus_object_path,
 
1695
                                                  client.name)
 
1696
    
 
1697
    atexit.register(cleanup)
 
1698
    
1658
1699
    for client in tcp_server.clients:
1659
1700
        if use_dbus:
1660
1701
            # Emit D-Bus signal
1683
1724
            service.activate()
1684
1725
        except dbus.exceptions.DBusException, error:
1685
1726
            logger.critical(u"DBusException: %s", error)
 
1727
            cleanup()
1686
1728
            sys.exit(1)
1687
1729
        # End of Avahi example code
1688
1730
        
1695
1737
        main_loop.run()
1696
1738
    except AvahiError, error:
1697
1739
        logger.critical(u"AvahiError: %s", error)
 
1740
        cleanup()
1698
1741
        sys.exit(1)
1699
1742
    except KeyboardInterrupt:
1700
1743
        if debug:
1701
1744
            print >> sys.stderr
1702
1745
        logger.debug(u"Server received KeyboardInterrupt")
1703
1746
    logger.debug(u"Server exiting")
 
1747
    # Must run before the D-Bus bus name gets deregistered
 
1748
    cleanup()
1704
1749
 
1705
1750
if __name__ == '__main__':
1706
1751
    main()