signalController.cpp

   1 /*
   2  *  anytun
   3  *
   4  *  The secure anycast tunneling protocol (satp) defines a protocol used
   5  *  for communication between any combination of unicast and anycast
   6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
   7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
   8  *  ethernet, ip, arp ...). satp directly includes cryptography and
   9  *  message authentication based on the methodes used by SRTP.  It is
  10  *  intended to deliver a generic, scaleable and secure solution for
  11  *  tunneling and relaying of packets of any protocol.
  12  *
  13  *
  14  *  Copyright (C) 2007 anytun.org <satp@wirdorange.org>
  15  *
  16  *  This program is free software; you can redistribute it and/or modify
  17  *  it under the terms of the GNU General Public License version 2
  18  *  as published by the Free Software Foundation.
  19  *
  20  *  This program is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  *  GNU General Public License for more details.
  24  *
  25  *  You should have received a copy of the GNU General Public License
  26  *  along with this program (see the file COPYING included with this
  27  *  distribution); if not, write to the Free Software Foundation, Inc.,
  28  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  29  */
  30
  31 #include <csignal>
  32 #include <map>
  33
  34 #include <iostream>
  35
  36 #include "threadUtils.hpp"
  37 #include "signalController.h"
  38 #include "log.h"
  39
  40
  41 int SigIntHandler::handle()
  42 {
  43   cLog.msg(Log::PRIO_NOTICE) << "SIG-Int caught";
  44
  45   return 1;
  46 }
  47
  48 int SigQuitHandler::handle()
  49 {
  50   cLog.msg(Log::PRIO_NOTICE) << "SIG-Quit caught";
  51
  52   return 1;
  53 }
  54
  55 int SigHupHandler::handle()
  56 {
  57   cLog.msg(Log::PRIO_NOTICE) << "SIG-Hup caught";
  58
  59   return 0;
  60 }
  61
  62 int SigTermHandler::handle()
  63 {
  64   cLog.msg(Log::PRIO_NOTICE) << "SIG-Term caught";
  65
  66   return 1;
  67 }
  68
  69 int SigUsr1Handler::handle()
  70 {
  71   cLog.msg(Log::PRIO_NOTICE) << "SIG-Usr1 caught";
  72
  73   return 0;
  74 }
  75
  76 int SigUsr2Handler::handle()
  77 {
  78   cLog.msg(Log::PRIO_NOTICE) << "SIG-Usr2 caught";
  79
  80   return 0;
  81 }
  82
  83 SignalController::~SignalController()
  84 {
  85   for(HandlerMap::iterator it = handler.begin(); it != handler.end(); ++it)
  86     delete it->second;
  87 }
  88
  89 void* SignalController::handle(void *s)
  90 {
  91   SignalController* self = reinterpret_cast<SignalController*>(s);
  92   sigset_t signal_set;
  93   int sigNum;
  94
  95   while(1)
  96   {
  97     sigfillset(&signal_set);
  98     sigwait(&signal_set, &sigNum);
  99     {
 100       Lock(self->sigQueueMutex);
 101       self->sigQueue.push(sigNum);
 102     }
 103     self->sigQueueSem.up();
 104   }
 105   pthread_exit(NULL);
 106 }
 107
 108 void SignalController::init()
 109 {
 110   sigset_t signal_set;
 111
 112   sigfillset(&signal_set);
 113   sigdelset(&signal_set, SIGCHLD);
 114   sigdelset(&signal_set, SIGSEGV);
 115   sigdelset(&signal_set, SIGBUS);
 116   sigdelset(&signal_set, SIGFPE);
 117   pthread_sigmask(SIG_BLOCK, &signal_set, NULL);
 118
 119   pthread_create(&thread, NULL, handle, this);
 120   pthread_detach(thread);
 121
 122   handler[SIGINT] = new SigIntHandler;
 123   handler[SIGQUIT] = new SigQuitHandler;
 124   handler[SIGHUP] = new SigHupHandler;
 125   handler[SIGTERM] = new SigTermHandler;
 126   handler[SIGUSR1] = new SigUsr1Handler;
 127   handler[SIGUSR2] = new SigUsr2Handler;
 128 }
 129
 130 int SignalController::run()
 131 {
 132   while(1)
 133   {
 134     sigQueueSem.down();
 135     int sigNum;
 136     {
 137       Lock lock(sigQueueMutex);
 138       sigNum = sigQueue.front();
 139       sigQueue.pop();
 140     }
 141
 142     HandlerMap::iterator it = handler.find(sigNum);
 143     if(it != handler.end())
 144     {
 145       int ret = it->second->handle();
 146       if(ret)
 147         return ret;
 148     }
 149     else
 150       cLog.msg(Log::PRIO_NOTICE) << "SIG " << sigNum << " caught - ignoring";
 151   }
 152   return 0;
 153 }