From 1bdddd7da2ebe39b0b817e08673aef7756438796 Mon Sep 17 00:00:00 2001 From: Christian Pointner Date: Wed, 20 Jan 2010 06:52:41 +0000 Subject: moved from SignalHandler Classes to boost::functions --- src/posix/signalHandler.hpp | 94 +++++++++++++++------------------------------ src/signalController.cpp | 34 ++++++++-------- src/signalController.h | 36 +++++------------ 3 files changed, 59 insertions(+), 105 deletions(-) diff --git a/src/posix/signalHandler.hpp b/src/posix/signalHandler.hpp index 92a66bd..d52b4d6 100644 --- a/src/posix/signalHandler.hpp +++ b/src/posix/signalHandler.hpp @@ -37,73 +37,43 @@ #include #include -class SigIntHandler : public SignalHandler +int SigIntHandler(const SigNum& /*sig*/, const std::string& /*msg*/) { -public: - SigIntHandler() : SignalHandler(SIGINT) {} - int handle() - { - cLog.msg(Log::PRIO_NOTICE) << "SIG-Int caught, exiting"; - return 1; - } -}; + cLog.msg(Log::PRIO_NOTICE) << "SIG-Int caught, exiting"; + return 1; +} -class SigQuitHandler : public SignalHandler +int SigQuitHandler(const SigNum& /*sig*/, const std::string& /*msg*/) { -public: - SigQuitHandler() : SignalHandler(SIGQUIT) {} - int handle() - { - cLog.msg(Log::PRIO_NOTICE) << "SIG-Quit caught, exiting"; - return 1; - } -}; + cLog.msg(Log::PRIO_NOTICE) << "SIG-Quit caught, exiting"; + return 1; +} -class SigHupHandler : public SignalHandler +int SigHupHandler(const SigNum& /*sig*/, const std::string& /*msg*/) { -public: - SigHupHandler() : SignalHandler(SIGHUP) {} - int handle() - { - cLog.msg(Log::PRIO_NOTICE) << "SIG-Hup caught"; - return 0; - } -}; + cLog.msg(Log::PRIO_NOTICE) << "SIG-Hup caught"; + return 0; +} -class SigUsr1Handler : public SignalHandler +int SigTermHandler(const SigNum& /*sig*/, const std::string& /*msg*/) { -public: - SigUsr1Handler() : SignalHandler(SIGUSR1) {} - int handle() - { - cLog.msg(Log::PRIO_NOTICE) << "SIG-Term caught, exiting"; - return 1; - } -}; + cLog.msg(Log::PRIO_NOTICE) << "SIG-Term caught, exiting"; + return 1; +} -class SigUsr2Handler : public SignalHandler +int SigUsr1Handler(const SigNum& /*sig*/, const std::string& /*msg*/) { -public: - SigUsr2Handler() : SignalHandler(SIGUSR2) {} - int handle() - { - cLog.msg(Log::PRIO_NOTICE) << "SIG-Usr1 caught"; - return 0; - } -}; + cLog.msg(Log::PRIO_NOTICE) << "SIG-Usr1 caught"; + return 0; +} -class SigTermHandler : public SignalHandler +int SigUsr2Handler(const SigNum& /*sig*/, const std::string& /*msg*/) { -public: - SigTermHandler() : SignalHandler(SIGTERM) {} - int handle() - { - cLog.msg(Log::PRIO_NOTICE) << "SIG-Usr2 caught"; - return 0; - } -}; + cLog.msg(Log::PRIO_NOTICE) << "SIG-Usr2 caught"; + return 0; +} -void handle() +void handleSignal() { sigset_t signal_set; int sigNum; @@ -138,14 +108,14 @@ void registerSignalHandler(SignalController& ctrl) #error The signalhandler works only with pthreads #endif - boost::thread(boost::bind(handle)); + boost::thread(boost::bind(handleSignal)); - ctrl.handler[SIGINT] = new SigIntHandler; - ctrl.handler[SIGQUIT] = new SigQuitHandler; - ctrl.handler[SIGHUP] = new SigHupHandler; - ctrl.handler[SIGTERM] = new SigTermHandler; - ctrl.handler[SIGUSR1] = new SigUsr1Handler; - ctrl.handler[SIGUSR2] = new SigUsr2Handler; + ctrl.handler[SIGINT] = boost::bind(SigIntHandler, _1, _2); + ctrl.handler[SIGQUIT] = boost::bind(SigQuitHandler, _1, _2); + ctrl.handler[SIGHUP] = boost::bind(SigHupHandler, _1, _2); + ctrl.handler[SIGTERM] = boost::bind(SigTermHandler, _1, _2); + ctrl.handler[SIGUSR1] = boost::bind(SigUsr1Handler, _1, _2); + ctrl.handler[SIGUSR2] = boost::bind(SigUsr2Handler, _1, _2); cLog.msg(Log::PRIO_DEBUG) << "signal handlers are now registered"; } diff --git a/src/signalController.cpp b/src/signalController.cpp index cc31c75..f0191fe 100644 --- a/src/signalController.cpp +++ b/src/signalController.cpp @@ -32,13 +32,13 @@ #include #include +#include #include "signalController.h" #include "log.h" #include "anytunError.h" #include "threadUtils.hpp" - SignalController* SignalController::inst = NULL; Mutex SignalController::instMutex; SignalController& gSignalController = SignalController::instance(); @@ -53,30 +53,24 @@ SignalController& SignalController::instance() return *inst; } -int SigErrorHandler::handle(const std::string& msg) +int SigErrorHandler(const SigNum& /*sig*/, const std::string& msg) { AnytunError::throwErr() << msg; return 0; } -// use system specific signal handler +//use system specific signal handler #ifndef _MSC_VER #include "signalHandler.hpp" #else #include "win32/signalHandler.hpp" #endif -SignalController::~SignalController() -{ - for(HandlerMap::iterator it = handler.begin(); it != handler.end(); ++it) - delete it->second; -} - void SignalController::init() { registerSignalHandler(*this); - handler[SIGERROR] = new SigErrorHandler; + handler[SIGERROR] = boost::bind(SigErrorHandler, _1, _2); } void SignalController::inject(int sig, const std::string& msg) @@ -90,6 +84,11 @@ void SignalController::inject(int sig, const std::string& msg) int SignalController::run() { + for(CallbackMap::iterator it = callbacks.begin(); it != callbacks.end(); ++it) + if(it->first == CALLB_RUNNING) + it->second(CALLB_RUNNING); + + int ret = 0; while(1) { sigQueueSem.down(); SigPair sig; @@ -102,18 +101,19 @@ int SignalController::run() HandlerMap::iterator it = handler.find(sig.first); if(it != handler.end()) { - int ret; - if(sig.second == "") - ret = it->second->handle(); - else - ret = it->second->handle(sig.second); + ret = it->second(sig.first, sig.second); if(ret) - return ret; + break; } else cLog.msg(Log::PRIO_NOTICE) << "SIG " << sig.first << " caught with message '" << sig.second << "' - ignoring"; } - return 0; + + for(CallbackMap::iterator it = callbacks.begin(); it != callbacks.end(); ++it) + if(it->first == CALLB_STOPPING) + it->second(CALLB_STOPPING); + + return ret; } diff --git a/src/signalController.h b/src/signalController.h index fdf5034..2602cc0 100644 --- a/src/signalController.h +++ b/src/signalController.h @@ -35,33 +35,16 @@ #include #include +#include #include "threadUtils.hpp" #define SIGERROR -1 -class SignalHandler -{ -public: - virtual ~SignalHandler() {} - - virtual int handle() { return 0; } - virtual int handle(const std::string& msg) { return 0; } - -protected: - SignalHandler(int s) : sigNum(s) {} - -private: - int sigNum; - friend class SignalController; -}; - -class SigErrorHandler : public SignalHandler -{ -public: - SigErrorHandler() : SignalHandler(SIGERROR) {} - int handle(const std::string& msg); -}; +typedef int SigNum; +typedef boost::function SignalHandler; +typedef enum { CALLB_RUNNING, CALLB_STOPPING } CallbackType; +typedef boost::function ServiceCallback; class SignalController { @@ -73,10 +56,8 @@ public: void inject(int sig, const std::string& msg = ""); private: - typedef std::map HandlerMap; - SignalController() {}; - ~SignalController(); + ~SignalController() {}; SignalController(const SignalController &s); void operator=(const SignalController &s); @@ -95,8 +76,11 @@ private: Mutex sigQueueMutex; Semaphore sigQueueSem; + typedef std::map HandlerMap; HandlerMap handler; - + typedef std::map CallbackMap; + CallbackMap callbacks; + friend void registerSignalHandler(SignalController& ctrl); }; -- cgit v1.2.3