/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: 2009-10-18 08:47:40 UTC
  • Revision ID: teddy@fukt.bsnet.se-20091018084740-fa1qgm22lg125r10
* plugins.d/splashy.c: Use exit codes from <sysexits.h>.

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.14"
 
82
version = "1.0.12"
83
83
 
84
84
logger = logging.Logger(u'mandos')
85
85
syslogger = (logging.handlers.SysLogHandler
325
325
        self.checker_initiator_tag = (gobject.timeout_add
326
326
                                      (self.interval_milliseconds(),
327
327
                                       self.start_checker))
 
328
        # Also start a new checker *right now*.
 
329
        self.start_checker()
328
330
        # Schedule a disable() when 'timeout' has passed
329
331
        self.disable_initiator_tag = (gobject.timeout_add
330
332
                                   (self.timeout_milliseconds(),
331
333
                                    self.disable))
332
334
        self.enabled = True
333
 
        # Also start a new checker *right now*.
334
 
        self.start_checker()
335
335
    
336
 
    def disable(self, quiet=True):
 
336
    def disable(self):
337
337
        """Disable this client."""
338
338
        if not getattr(self, "enabled", False):
339
339
            return False
340
 
        if not quiet:
341
 
            logger.info(u"Disabling client %s", self.name)
 
340
        logger.info(u"Disabling client %s", self.name)
342
341
        if getattr(self, u"disable_initiator_tag", False):
343
342
            gobject.source_remove(self.disable_initiator_tag)
344
343
            self.disable_initiator_tag = None
468
467
        logger.debug(u"Stopping checker for %(name)s", vars(self))
469
468
        try:
470
469
            os.kill(self.checker.pid, signal.SIGTERM)
471
 
            #time.sleep(0.5)
 
470
            #os.sleep(0.5)
472
471
            #if self.checker.poll() is None:
473
472
            #    os.kill(self.checker.pid, signal.SIGKILL)
474
473
        except OSError, error:
706
705
                                       variant_level=1))
707
706
        return r
708
707
    
709
 
    def disable(self, quiet = False):
 
708
    def disable(self, signal = True):
710
709
        oldstate = getattr(self, u"enabled", False)
711
 
        r = Client.disable(self, quiet=quiet)
712
 
        if not quiet and oldstate != self.enabled:
 
710
        r = Client.disable(self)
 
711
        if signal and oldstate != self.enabled:
713
712
            # Emit D-Bus signal
714
713
            self.PropertyChanged(dbus.String(u"enabled"),
715
714
                                 dbus.Boolean(False, variant_level=1))
1346
1345
            elif suffix == u"w":
1347
1346
                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1348
1347
            else:
1349
 
                raise ValueError(u"Unknown suffix %r" % suffix)
1350
 
        except (ValueError, IndexError), e:
1351
 
            raise ValueError(e.message)
 
1348
                raise ValueError
 
1349
        except (ValueError, IndexError):
 
1350
            raise ValueError
1352
1351
        timevalue += delta
1353
1352
    return timevalue
1354
1353
 
1567
1566
    bus = dbus.SystemBus()
1568
1567
    # End of Avahi example code
1569
1568
    if use_dbus:
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
 
1569
        bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1578
1570
    protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1579
1571
    service = AvahiService(name = server_settings[u"servicename"],
1580
1572
                           servicetype = u"_mandos._tcp",
1618
1610
        pass
1619
1611
    del pidfilename
1620
1612
    
 
1613
    def cleanup():
 
1614
        "Cleanup function; run on exit"
 
1615
        service.cleanup()
 
1616
        
 
1617
        while tcp_server.clients:
 
1618
            client = tcp_server.clients.pop()
 
1619
            client.disable_hook = None
 
1620
            client.disable()
 
1621
    
 
1622
    atexit.register(cleanup)
 
1623
    
1621
1624
    if not debug:
1622
1625
        signal.signal(signal.SIGINT, signal.SIG_IGN)
1623
1626
    signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1668
1671
                        tcp_server.clients.remove(c)
1669
1672
                        c.remove_from_connection()
1670
1673
                        # Don't signal anything except ClientRemoved
1671
 
                        c.disable(quiet=True)
 
1674
                        c.disable(signal=False)
1672
1675
                        # Emit D-Bus signal
1673
1676
                        self.ClientRemoved(object_path, c.name)
1674
1677
                        return
1675
 
                raise KeyError(object_path)
 
1678
                raise KeyError
1676
1679
            
1677
1680
            del _interface
1678
1681
        
1679
1682
        mandos_dbus_service = MandosDBusService()
1680
1683
    
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
 
    
1699
1684
    for client in tcp_server.clients:
1700
1685
        if use_dbus:
1701
1686
            # Emit D-Bus signal
1724
1709
            service.activate()
1725
1710
        except dbus.exceptions.DBusException, error:
1726
1711
            logger.critical(u"DBusException: %s", error)
1727
 
            cleanup()
1728
1712
            sys.exit(1)
1729
1713
        # End of Avahi example code
1730
1714
        
1737
1721
        main_loop.run()
1738
1722
    except AvahiError, error:
1739
1723
        logger.critical(u"AvahiError: %s", error)
1740
 
        cleanup()
1741
1724
        sys.exit(1)
1742
1725
    except KeyboardInterrupt:
1743
1726
        if debug:
1744
1727
            print >> sys.stderr
1745
1728
        logger.debug(u"Server received KeyboardInterrupt")
1746
1729
    logger.debug(u"Server exiting")
1747
 
    # Must run before the D-Bus bus name gets deregistered
1748
 
    cleanup()
1749
1730
 
1750
1731
if __name__ == '__main__':
1751
1732
    main()