cpp/src/IceUtil/CtrlCHandler.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #ifdef __sun
  11 #    define _POSIX_PTHREAD_SEMANTICS
  12 #endif
  13
  14 #include <IceUtil/CtrlCHandler.h>
  15 #include <IceUtil/MutexPtrLock.h>
  16 #include <IceUtil/Mutex.h>
  17
  18 #ifndef _WIN32
  19 #   include <signal.h>
  20 #endif
  21
  22 using namespace std;
  23 using namespace IceUtil;
  24
  25 namespace
  26 {
  27
  28 CtrlCHandlerCallback _callback = 0;
  29 const CtrlCHandler* _handler = 0;
  30
  31 IceUtil::Mutex* globalMutex = 0;
  32
  33 class Init
  34 {
  35 public:
  36
  37     Init()
  38     {
  39         globalMutex = new IceUtil::Mutex;
  40     }
  41
  42     ~Init()
  43     {
  44         delete globalMutex;
  45         globalMutex = 0;
  46     }
  47 };
  48
  49 Init init;
  50
  51 }
  52
  53 CtrlCHandlerException::CtrlCHandlerException(const char* file, int line) :
  54     Exception(file, line)
  55 {
  56 }
  57
  58 static const char* ctrlCHandlerName = "IceUtil::CtrlCHandlerException";
  59
  60 string
  61 CtrlCHandlerException::ice_name() const
  62 {
  63     return ctrlCHandlerName;
  64 }
  65
  66 Exception*
  67 CtrlCHandlerException::ice_clone() const
  68 {
  69     return new CtrlCHandlerException(*this);
  70 }
  71
  72 void
  73 CtrlCHandlerException::ice_throw() const
  74 {
  75     throw *this;
  76 }
  77
  78 void
  79 CtrlCHandler::setCallback(CtrlCHandlerCallback callback)
  80 {
  81     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
  82     _callback = callback;
  83 }
  84
  85 CtrlCHandlerCallback
  86 CtrlCHandler::getCallback() const
  87 {
  88     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
  89     return _callback;
  90 }
  91
  92 #ifdef _WIN32
  93
  94 static BOOL WINAPI handlerRoutine(DWORD dwCtrlType)
  95 {
  96     CtrlCHandlerCallback callback = _handler->getCallback();
  97     if(callback != 0)
  98     {
  99         callback(dwCtrlType);
 100     }
 101     return TRUE;
 102 }
 103
 104
 105 CtrlCHandler::CtrlCHandler(CtrlCHandlerCallback callback)
 106 {
 107     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
 108     bool handler = _handler != 0;
 109
 110     if(handler)
 111     {
 112         throw CtrlCHandlerException(__FILE__, __LINE__);
 113     }
 114     else
 115     {
 116         _callback = callback;
 117         _handler = this;
 118         lock.release();
 119
 120         SetConsoleCtrlHandler(handlerRoutine, TRUE);
 121     }
 122 }
 123
 124 CtrlCHandler::~CtrlCHandler()
 125 {
 126     SetConsoleCtrlHandler(handlerRoutine, FALSE);
 127     {
 128         IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
 129         _handler = 0;
 130     }
 131 }
 132
 133 #else
 134
 135 extern "C"
 136 {
 137
 138 static void*
 139 sigwaitThread(void*)
 140 {
 141     sigset_t ctrlCLikeSignals;
 142     sigemptyset(&ctrlCLikeSignals);
 143     sigaddset(&ctrlCLikeSignals, SIGHUP);
 144     sigaddset(&ctrlCLikeSignals, SIGINT);
 145     sigaddset(&ctrlCLikeSignals, SIGTERM);
 146
 147     //
 148     // Run until I'm cancelled (in sigwait())
 149     //
 150     for(;;)
 151     {
 152         int signal = 0;
 153         int rc = sigwait(&ctrlCLikeSignals, &signal);
 154 #if defined(__APPLE__)
 155         //
 156         // WORKAROUND: sigwait is not a cancelation point on MacOS X. To cancel this thread, the
 157         // destructor cancels the thread and send a signal to the thread to unblock sigwait, then
 158         // we explicitly test for cancellation.
 159         //
 160         pthread_testcancel();
 161 #endif
 162         //
 163         // Some sigwait() implementations incorrectly return EINTR
 164         // when interrupted by an unblocked caught signal
 165         //
 166         if(rc == EINTR)
 167         {
 168             continue;
 169         }
 170         assert(rc == 0);
 171
 172         rc = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
 173         assert(rc == 0);
 174
 175         CtrlCHandlerCallback callback = _handler->getCallback();
 176
 177         if(callback != 0)
 178         {
 179             callback(signal);
 180         }
 181
 182         rc = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
 183         assert(rc == 0);
 184     }
 185     return 0;
 186 }
 187
 188 }
 189
 190 namespace
 191 {
 192
 193 pthread_t _tid;
 194
 195 }
 196
 197 CtrlCHandler::CtrlCHandler(CtrlCHandlerCallback callback)
 198 {
 199     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
 200     bool handler = _handler != 0;
 201
 202     if(handler)
 203     {
 204         throw CtrlCHandlerException(__FILE__, __LINE__);
 205     }
 206     else
 207     {
 208         _callback = callback;
 209         _handler = this;
 210
 211         lock.release();
 212
 213         // We block these CTRL+C like signals in the main thread,
 214         // and by default all other threads will inherit this signal
 215         // mask.
 216
 217         sigset_t ctrlCLikeSignals;
 218         sigemptyset(&ctrlCLikeSignals);
 219         sigaddset(&ctrlCLikeSignals, SIGHUP);
 220         sigaddset(&ctrlCLikeSignals, SIGINT);
 221         sigaddset(&ctrlCLikeSignals, SIGTERM);
 222         int rc = pthread_sigmask(SIG_BLOCK, &ctrlCLikeSignals, 0);
 223         assert(rc == 0);
 224
 225         // Joinable thread
 226         rc = pthread_create(&_tid, 0, sigwaitThread, 0);
 227         assert(rc == 0);
 228     }
 229 }
 230
 231 CtrlCHandler::~CtrlCHandler()
 232 {
 233     int rc = pthread_cancel(_tid);
 234     assert(rc == 0);
 235 #if defined(__APPLE__)
 236     //
 237     // WORKAROUND: sigwait isn't a cancellation point on MacOS X, see
 238     // comment in sigwaitThread
 239     //
 240     rc = pthread_kill(_tid, SIGTERM);
 241     //assert(rc == 0); For some reaosns, this assert is sometime triggered
 242 #endif
 243     void* status = 0;
 244     rc = pthread_join(_tid, &status);
 245     assert(rc == 0);
 246 #if !defined(__APPLE__)
 247     assert(status == PTHREAD_CANCELED);
 248 #endif
 249     {
 250         IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
 251         _handler = 0;
 252     }
 253 }
 254
 255 #endif
 256