projects/rscriptd/main.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  19  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  20  */
  21
  22  /*
  23  $Revision: 1.19 $
  24  $Author: faust $
  25  $Date: 2010/09/10 06:37:45 $
  26  */
  27
  28 #include <sys/types.h>
  29 #include <sys/ipc.h>
  30 #include <sys/msg.h>
  31 #include <sys/stat.h>
  32 #include <sys/wait.h>
  33 #include <fcntl.h> // creat
  34 #include <unistd.h>
  35
  36 #include <cstdlib>
  37 #include <cstdio>
  38 #include <csignal>
  39 #include <set>
  40
  41 #include "stg/common.h"
  42 #include "stg/logger.h"
  43 #include "stg/scriptexecuter.h"
  44 #include "stg/conffiles.h"
  45 #include "stg/version.h"
  46 #include "listener.h"
  47 #include "pidfile.h"
  48
  49 using namespace std;
  50
  51 #ifdef DEBUG
  52 # define MAIN_DEBUG  1
  53 # define NO_DAEMON    1
  54 #endif
  55
  56 #define START_FILE "/._ST_ART_ED_"
  57
  58 static bool childExited = false;
  59 set<pid_t> executersPid;
  60 static pid_t stgChildPid;
  61 volatile time_t stgTime = time(NULL);
  62
  63 class STG_STOPPER
  64 {
  65 public:
  66     STG_STOPPER() { nonstop = true; }
  67     bool GetStatus() const { return nonstop; };
  68     void Stop(const char * __file__, int __line__)
  69         {
  70         #ifdef NO_DAEMON
  71         printfd(__FILE__, "rscriptd stopped at %s:%d\n", __file__, __line__);
  72         #endif
  73         nonstop = false;
  74         }
  75 private:
  76     bool nonstop;
  77 };
  78 //-----------------------------------------------------------------------------
  79 STG_STOPPER nonstop;
  80 //-----------------------------------------------------------------------------
  81 void CatchPROF(int)
  82 {
  83 }
  84 //-----------------------------------------------------------------------------
  85 void CatchUSR1(int)
  86 {
  87 }
  88 //-----------------------------------------------------------------------------
  89 void CatchTERM(int sig)
  90 {
  91 /*
  92  *Function Name:CatchINT
  93  *Parameters: sig_num - signal number
  94  *Description: INT signal handler
  95  *Returns: Nothing
  96  */
  97 STG_LOGGER & WriteServLog = GetStgLogger();
  98 WriteServLog("Shutting down... %d", sig);
  99
 100 nonstop.Stop(__FILE__, __LINE__);
 101
 102 struct sigaction newsa, oldsa;
 103 sigset_t sigmask;
 104
 105 sigemptyset(&sigmask);
 106 sigaddset(&sigmask, SIGTERM);
 107 newsa.sa_handler = SIG_IGN;
 108 newsa.sa_mask = sigmask;
 109 newsa.sa_flags = 0;
 110 sigaction(SIGTERM, &newsa, &oldsa);
 111
 112 sigemptyset(&sigmask);
 113 sigaddset(&sigmask, SIGINT);
 114 newsa.sa_handler = SIG_IGN;
 115 newsa.sa_mask = sigmask;
 116 newsa.sa_flags = 0;
 117 sigaction(SIGINT, &newsa, &oldsa);
 118 }
 119 //-----------------------------------------------------------------------------
 120 void CatchPIPE(int)
 121 {
 122 STG_LOGGER & WriteServLog = GetStgLogger();
 123 WriteServLog("Broken pipe!");
 124 }
 125 //-----------------------------------------------------------------------------
 126 void CatchHUP(int)
 127 {
 128 }
 129 //-----------------------------------------------------------------------------
 130 void CatchCHLD(int)
 131 {
 132 int status;
 133 pid_t childPid;
 134 childPid = waitpid(-1, &status, WNOHANG);
 135
 136 set<pid_t>::iterator pid;
 137 pid = executersPid.find(childPid);
 138 if (pid != executersPid.end())
 139     {
 140     executersPid.erase(pid);
 141     }
 142 if (childPid == stgChildPid)
 143     {
 144     childExited = true;
 145     }
 146 }
 147 //-----------------------------------------------------------------------------
 148 void SetSignalHandlers()
 149 {
 150 struct sigaction newsa, oldsa;
 151 sigset_t sigmask;
 152
 153 sigemptyset(&sigmask);
 154 sigaddset(&sigmask, SIGTERM);
 155 newsa.sa_handler = CatchTERM;
 156 newsa.sa_mask = sigmask;
 157 newsa.sa_flags = 0;
 158 sigaction(SIGTERM, &newsa, &oldsa);
 159
 160 sigemptyset(&sigmask);
 161 sigaddset(&sigmask, SIGUSR1);
 162 newsa.sa_handler = CatchUSR1;
 163 newsa.sa_mask = sigmask;
 164 newsa.sa_flags = 0;
 165 sigaction(SIGUSR1, &newsa, &oldsa);
 166
 167 sigemptyset(&sigmask);
 168 sigaddset(&sigmask, SIGINT);
 169 newsa.sa_handler = CatchTERM;
 170 newsa.sa_mask = sigmask;
 171 newsa.sa_flags = 0;
 172 sigaction(SIGINT, &newsa, &oldsa);
 173
 174 sigemptyset(&sigmask);
 175 sigaddset(&sigmask, SIGPIPE);
 176 newsa.sa_handler = CatchPIPE;
 177 newsa.sa_mask = sigmask;
 178 newsa.sa_flags = 0;
 179 sigaction(SIGPIPE, &newsa, &oldsa);
 180
 181 sigemptyset(&sigmask);
 182 sigaddset(&sigmask, SIGHUP);
 183 newsa.sa_handler = CatchHUP;
 184 newsa.sa_mask = sigmask;
 185 newsa.sa_flags = 0;
 186 sigaction(SIGHUP, &newsa, &oldsa);
 187
 188 sigemptyset(&sigmask);
 189 sigaddset(&sigmask, SIGCHLD);
 190 newsa.sa_handler = CatchCHLD;
 191 newsa.sa_mask = sigmask;
 192 newsa.sa_flags = 0;
 193 sigaction(SIGCHLD, &newsa, &oldsa);
 194 }
 195 //-----------------------------------------------------------------------------
 196 int StartScriptExecuter(char * procName, int msgKey, int * msgID)
 197 {
 198 STG_LOGGER & WriteServLog = GetStgLogger();
 199
 200 if (*msgID == -11)   // If msgID == -11 - first call. Create queue
 201     {
 202     for (int i = 0; i < 2; i++)
 203         {
 204         *msgID = msgget(msgKey, IPC_CREAT | IPC_EXCL | 0600);
 205
 206         if (*msgID == -1)
 207             {
 208             *msgID = msgget(msgKey, 0);
 209             if (*msgID == -1)
 210                 {
 211                 WriteServLog("Message queue not created.");
 212                 return -1;
 213                 }
 214             else
 215                 {
 216                 msgctl(*msgID, IPC_RMID, NULL);
 217                 }
 218             }
 219         else
 220             {
 221             WriteServLog("Message queue created successfully. msgKey=%d msgID=%d", msgKey, *msgID);
 222             break;
 223             }
 224         }
 225     }
 226
 227 pid_t executerPid = fork();
 228
 229 switch (executerPid)
 230     {
 231     case -1:    // Failure
 232         WriteServLog("Fork error!");
 233         return -1;
 234
 235     case 0:     // Child
 236         //close(0);
 237         //close(1);
 238         //close(2);
 239         //setsid();
 240         Executer(msgKey, *msgID, executerPid, procName);
 241         return 1;
 242
 243     default:    // Parent
 244         if (executersPid.empty())
 245             Executer(msgKey, *msgID, executerPid, NULL);
 246         executersPid.insert(executerPid);
 247     }
 248 return 0;
 249 }
 250 //-----------------------------------------------------------------------------
 251 #ifdef NO_DAEMON
 252 int ForkAndWait(const string &)
 253 #else
 254 int ForkAndWait(const string & confDir)
 255 #endif
 256 {
 257 #ifndef NO_DAEMON
 258 stgChildPid = fork();
 259
 260 switch (stgChildPid)
 261     {
 262     case -1:    // Failure
 263         return -1;
 264         break;
 265
 266     case 0:     // Child
 267         //close(0);
 268         close(1);
 269         close(2);
 270         setsid();
 271         break;
 272
 273     default:    // Parent
 274         exit(1);
 275         break;
 276     }
 277 #endif
 278 return 0;
 279 }
 280 //-----------------------------------------------------------------------------
 281 void KillExecuters()
 282 {
 283 set<pid_t>::iterator pid;
 284 pid = executersPid.begin();
 285 while (pid != executersPid.end())
 286     {
 287     printfd(__FILE__, "KillExecuters pid=%d\n", *pid);
 288     kill(*pid, SIGUSR1);
 289     ++pid;
 290     }
 291 }
 292 //-----------------------------------------------------------------------------
 293 int main(int argc, char * argv[])
 294 {
 295
 296 /*
 297   Initialization order:
 298   - Logger
 299   - Config
 300   - Set signal nandlers
 301   - Fork and exit
 302  */
 303
 304 CONFIGFILE * cfg = NULL;
 305 LISTENER * listener = NULL;
 306 int msgID = -11;
 307 int execNum = 0;
 308 int execMsgKey = 0;
 309
 310 string logFileName;
 311 string confDir;
 312 string password;
 313 string onConnect;
 314 string onDisconnect;
 315 int port;
 316 int userTimeout;
 317
 318 if (getuid())
 319     {
 320     printf("You must be root. Exit.\n");
 321     exit(1);
 322     }
 323
 324 if (argc == 2)
 325     cfg = new CONFIGFILE(argv[1]);
 326 else
 327     cfg = new CONFIGFILE("/etc/rscriptd/rscriptd.conf");
 328
 329 if (cfg->Error())
 330     {
 331     STG_LOGGER & WriteServLog = GetStgLogger();
 332     WriteServLog.SetLogFileName("/var/log/rscriptd.log");
 333     WriteServLog("Error reading config file!");
 334     delete cfg;
 335     return EXIT_FAILURE;
 336     }
 337
 338 cfg->ReadString("LogFileName", &logFileName, "/var/log/rscriptd.log");
 339 cfg->ReadInt("ExecutersNum", &execNum, 1);
 340 cfg->ReadInt("ExecMsgKey", &execMsgKey, 5555);
 341 cfg->ReadString("ConfigDir", &confDir, "/etc/rscriptd");
 342 cfg->ReadString("Password", &password, "");
 343 cfg->ReadInt("Port", &port, 5555);
 344 cfg->ReadInt("UserTimeout", &userTimeout, 60);
 345 cfg->ReadString("ScriptOnConnect", &onConnect, "/etc/rscriptd/OnConnect");
 346 cfg->ReadString("ScriptOnDisconnect", &onDisconnect, "/etc/rscriptd/OnDisconnect");
 347
 348 SetSignalHandlers();
 349 if (ForkAndWait(confDir) < 0)
 350     {
 351     STG_LOGGER & WriteServLog = GetStgLogger();
 352     WriteServLog("Fork error!");
 353     delete cfg;
 354     return EXIT_FAILURE;
 355     }
 356
 357 STG_LOGGER & WriteServLog = GetStgLogger();
 358 PIDFile pidFile("/var/run/rscriptd.pid");
 359 WriteServLog.SetLogFileName(logFileName);
 360 WriteServLog("rscriptd v. %s", SERVER_VERSION);
 361
 362 for (int i = 0; i < execNum; i++)
 363     {
 364     int ret = StartScriptExecuter(argv[0], execMsgKey, &msgID);
 365     if (ret < 0)
 366         {
 367         STG_LOGGER & WriteServLog = GetStgLogger();
 368         WriteServLog("Start Script Executer error!");
 369         delete cfg;
 370         return EXIT_FAILURE;
 371         }
 372     if (ret == 1)
 373         {
 374         delete cfg;
 375         return EXIT_SUCCESS;
 376         }
 377     }
 378
 379 listener = new LISTENER();
 380 listener->SetPort(port);
 381 listener->SetPassword(password);
 382 listener->SetUserTimeout(userTimeout);
 383 listener->SetScriptOnConnect(onConnect);
 384 listener->SetScriptOnDisconnect(onDisconnect);
 385
 386 listener->Start();
 387
 388 WriteServLog("rscriptd started successfully.");
 389 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
 390
 391 while (nonstop.GetStatus())
 392     {
 393     usleep(100000);
 394     }
 395
 396 listener->Stop();
 397
 398 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
 399
 400 int res = msgctl(msgID, IPC_RMID, NULL);
 401 if (res)
 402     WriteServLog("Queue was not removed. id=%d", msgID);
 403 else
 404     WriteServLog("Queue removed successfully.");
 405
 406 KillExecuters();
 407
 408 WriteServLog("rscriptd stopped successfully.");
 409 WriteServLog("---------------------------------------------");
 410
 411 delete listener;
 412 delete cfg;
 413 return EXIT_SUCCESS;
 414 }
 415 //-----------------------------------------------------------------------------