]> git.stg.codes - stg.git/blob - projects/stargazer/main.cpp
Переіменовано пару змінних для збереження семантики, виправлено розмір
[stg.git] / projects / stargazer / 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  */
20
21  /*
22  $Revision: 1.124 $
23  $Date: 2010/10/04 20:19:12 $
24  $Author: faust $
25  */
26
27 //#include <stdio.h>
28 #include <sys/types.h>
29 #include <sys/socket.h>
30 #include <netinet/in.h>
31 #include <arpa/inet.h>
32 #include <unistd.h>
33 #include <sys/ipc.h>
34 #include <sys/msg.h>
35 #include <sys/stat.h>
36 #include <sys/wait.h>
37 #include <dlfcn.h>
38 #include <fcntl.h>
39
40 #include <csignal>
41 #include <cerrno>
42 #include <fstream>
43 #include <vector>
44 #include <set>
45 #include <list>
46
47 #include "settings.h"
48 #include "user.h"
49 #include "users.h"
50 #include "admins.h"
51 #include "common.h"
52 #include "traffcounter.h"
53 #include "base_plugin.h"
54 #include "stg_logger.h"
55 #include "stg_timer.h"
56 #include "plugin_runner.h"
57 #include "script_executer.h"
58 #include "conffiles.h"
59 #include "version.h"
60 #include "store_loader.h"
61 #include "pidfile.h"
62 #include "eventloop.h"
63
64 using namespace std;
65 uint32_t        eip;
66
67 #ifdef DEBUG
68     #define MAIN_DEBUG (1)
69     #define NO_DAEMON  (1)
70 #endif
71
72 #define START_FILE "/._ST_ART_ED_"
73
74 static bool needRulesReloading = false;
75 static bool childExited = false;
76 //static pid_t executerPid;
77 set<pid_t> executersPid;
78 static pid_t stgChildPid;
79
80 #include "pinger.h"
81
82 //-----------------------------------------------------------------------------
83 bool StartModCmp(const PLUGIN_RUNNER & lhs, const PLUGIN_RUNNER & rhs)
84 {
85 return lhs.GetStartPosition() < rhs.GetStartPosition();
86 }
87 //-----------------------------------------------------------------------------
88 bool StopModCmp(const PLUGIN_RUNNER & lhs, const PLUGIN_RUNNER & rhs)
89 {
90 return lhs.GetStopPosition() > rhs.GetStopPosition();
91 }
92 //-----------------------------------------------------------------------------
93 class STG_STOPPER
94 {
95 public:
96     STG_STOPPER() { nonstop = true; }
97     bool    GetStatus() const { return nonstop; };
98     #ifdef NO_DAEMON
99     void    Stop(const char * __file__, int __line__)
100     #else
101     void    Stop(const char *, int)
102     #endif
103         {
104         #ifdef NO_DAEMON
105         printfd(__FILE__, "Stg stopped at %s:%d\n", __file__, __line__);
106         #endif
107         nonstop = false;
108         }
109 private:
110     bool nonstop;
111 };
112 //-----------------------------------------------------------------------------
113 STG_STOPPER nonstop;
114 //-----------------------------------------------------------------------------
115 static void StartTimer()
116 {
117 STG_LOGGER & WriteServLog = GetStgLogger();
118
119 if (RunStgTimer())
120     {
121     WriteServLog("Cannot start timer. Fatal.");
122     //printfd(__FILE__, "Cannot start timer. Fatal.\n");
123     exit(1);
124     }
125 else
126     {
127     WriteServLog("Timer thread started successfully.");
128     //printfd(__FILE__, "Timer thread started successfully.\n");
129     }
130 }
131 //-----------------------------------------------------------------------------
132 void CatchUSR1(int)
133 {
134
135 }
136 //-----------------------------------------------------------------------------
137 void CatchTERM(int sig)
138 {
139 /*
140  *Function Name:CatchINT
141  *Parameters: sig_num - ÎÏÍÅÒ ÓÉÇÎÁÌÁ
142  *Description: ïÂÒÁÂÏÔÞÉË ÓÉÇÎÁÌÁ INT
143  *Returns: îÉÞÅÇÏ
144  */
145 STG_LOGGER & WriteServLog = GetStgLogger();
146 WriteServLog("Shutting down... %d", sig);
147
148 //nonstop = false;
149 nonstop.Stop(__FILE__, __LINE__);
150
151 struct sigaction newsa, oldsa;
152 sigset_t sigmask;
153
154 sigemptyset(&sigmask);
155 sigaddset(&sigmask, SIGTERM);
156 newsa.sa_handler = SIG_IGN;
157 newsa.sa_mask = sigmask;
158 newsa.sa_flags = 0;
159 sigaction(SIGTERM, &newsa, &oldsa);
160
161 sigemptyset(&sigmask);
162 sigaddset(&sigmask, SIGINT);
163 newsa.sa_handler = SIG_IGN;
164 newsa.sa_mask = sigmask;
165 newsa.sa_flags = 0;
166 sigaction(SIGINT, &newsa, &oldsa);
167 }
168 //-----------------------------------------------------------------------------
169 void CatchPIPE(int)
170 {
171 STG_LOGGER & WriteServLog = GetStgLogger();
172 WriteServLog("Broken pipe!");
173 }
174 //-----------------------------------------------------------------------------
175 void CatchHUP(int)
176 {
177 needRulesReloading = true;
178 }
179 //-----------------------------------------------------------------------------
180 void CatchCHLD(int)
181 {
182 int status;
183 pid_t childPid;
184 childPid = waitpid(-1, &status, WNOHANG);
185
186 set<pid_t>::iterator pid;
187 pid = executersPid.find(childPid);
188 if (pid != executersPid.end())
189     {
190     executersPid.erase(pid);
191     if (executersPid.empty() && nonstop.GetStatus())
192         {
193         nonstop.Stop(__FILE__, __LINE__);
194         }
195     }
196 if (childPid == stgChildPid)
197     {
198     childExited = true;
199     }
200 }
201 /*//-----------------------------------------------------------------------------
202 void CatchSEGV(int, siginfo_t *, void *)
203 {
204 char fileName[50];
205 sprintf(fileName, "/tmp/stg_segv.%d", getpid());
206 FILE * f = fopen(fileName, "wt");
207 if (f)
208     {
209     fprintf(f, "\nSignal info:\n~~~~~~~~~~~~\n");
210     fprintf(f, "numb:\t %d (%d)\n", sinfo->si_signo, sig);
211     fprintf(f, "errn:\t %d\n", sinfo->si_errno);
212     fprintf(f, "code:\t %d ", sinfo->si_code);
213
214     switch (sinfo->si_code)
215         {
216         case SEGV_MAPERR:
217             fprintf(f, "(SEGV_MAPERR - address not mapped to object)\n");
218             break;
219
220         case SEGV_ACCERR:
221             fprintf(f, "(SEGV_ACCERR - invalid permissions for mapped object)\n");
222             break;
223
224         default:
225             fprintf(f, "???\n");
226         }
227
228     fprintf(f, "addr:\t 0x%.8X\n",
229         (unsigned int)sinfo->si_addr);
230
231     Dl_info dlinfo;
232     //asm("movl %eip, eip");
233     if (dladdr((void*)CatchCHLD, &dlinfo))
234         {
235         fprintf(f, "SEGV point: %s %s\n", dlinfo.dli_fname, dlinfo.dli_sname);
236         }
237     else
238         {
239         fprintf(f, "Cannot find SEGV point\n");
240         }
241
242     fclose(f);
243     }
244
245 struct sigaction segv_action, segv_action_old;
246
247 segv_action.sa_handler = SIG_DFL;
248 segv_action.sa_sigaction = NULL;
249 segv_action.sa_flags = SA_SIGINFO;
250 segv_action.sa_restorer = NULL;
251
252 sigaction(SIGSEGV, &segv_action, &segv_action_old);
253 }*/
254 //-----------------------------------------------------------------------------
255 static void SetSignalHandlers()
256 {
257 struct sigaction newsa, oldsa;
258 sigset_t sigmask;
259 ///////
260 sigemptyset(&sigmask);
261 sigaddset(&sigmask, SIGTERM);
262 newsa.sa_handler = CatchTERM;
263 newsa.sa_mask = sigmask;
264 newsa.sa_flags = 0;
265 sigaction(SIGTERM, &newsa, &oldsa);
266 ///////
267 sigemptyset(&sigmask);
268 sigaddset(&sigmask, SIGUSR1);
269 newsa.sa_handler = CatchUSR1;
270 newsa.sa_mask = sigmask;
271 newsa.sa_flags = 0;
272 sigaction(SIGUSR1, &newsa, &oldsa);
273 ///////
274 sigemptyset(&sigmask);
275 sigaddset(&sigmask, SIGINT);
276 newsa.sa_handler = CatchTERM;
277 newsa.sa_mask = sigmask;
278 newsa.sa_flags = 0;
279 sigaction(SIGINT, &newsa, &oldsa);
280 //////
281 sigemptyset(&sigmask);
282 sigaddset(&sigmask, SIGPIPE);
283 newsa.sa_handler = CatchPIPE;
284 newsa.sa_mask = sigmask;
285 newsa.sa_flags = 0;
286 sigaction(SIGPIPE, &newsa, &oldsa);
287 //////
288 sigemptyset(&sigmask);
289 sigaddset(&sigmask, SIGHUP);
290 newsa.sa_handler = CatchHUP;
291 newsa.sa_mask = sigmask;
292 newsa.sa_flags = 0;
293 sigaction(SIGHUP, &newsa, &oldsa);
294 //////
295 sigemptyset(&sigmask);
296 sigaddset(&sigmask, SIGCHLD);
297 newsa.sa_handler = CatchCHLD;
298 newsa.sa_mask = sigmask;
299 newsa.sa_flags = 0;
300 sigaction(SIGCHLD, &newsa, &oldsa);
301
302 /*newsa.sa_handler = NULL;
303 newsa.sa_sigaction = CatchSEGV;
304 newsa.sa_flags = SA_SIGINFO;
305 newsa.sa_restorer = NULL;
306 sigaction(SIGSEGV, &newsa, &oldsa);*/
307
308 return;
309 }
310 //-----------------------------------------------------------------------------
311 int StartScriptExecuter(char * procName, int msgKey, int * msgID, SETTINGS * settings)
312 {
313 STG_LOGGER & WriteServLog = GetStgLogger();
314
315 if (*msgID == -11)   // If msgID == -11 - first call. Create queue
316     {
317     for (int i = 0; i < 2; i++)
318         {
319         //WriteServLog("Creating queue with key=%d ...", msgKey);
320         *msgID = msgget(msgKey, IPC_CREAT | IPC_EXCL | 0600);
321
322         if (*msgID == -1)
323             {
324             *msgID = msgget(msgKey, 0);
325             if (*msgID == -1)
326                 {
327                 WriteServLog("Message queue not created.");
328                 return -1;
329                 }
330             else
331                 {
332                 msgctl(*msgID, IPC_RMID, NULL);
333                 //printfd(__FILE__, "Queue removed!");
334                 }
335             }
336         else
337             {
338             WriteServLog("Message queue created successfully. msgKey=%d msgID=%d", msgKey, *msgID);
339             break;
340             }
341         }
342     }
343
344 pid_t executerPid = fork();
345
346 switch (executerPid)
347     {
348     case -1:    // ìÁÖÁ
349         WriteServLog("Fork error!");
350         return -1;
351
352     case 0:     // ðÏÔÏÍÏË
353         //close(0);
354         //close(1);
355         //close(2);
356         //setsid();
357         delete settings;
358         Executer(msgKey, *msgID, executerPid, procName);
359         return 1;
360
361     default:    // ïÓÎÏ×ÎÏÊ ÐÒÏÃÅÓÓ
362         if (executersPid.empty()) {
363             Executer(msgKey, *msgID, executerPid, NULL);
364         }
365         executersPid.insert(executerPid);
366     }
367 return 0;
368 }
369 //-----------------------------------------------------------------------------
370 #ifndef NO_DAEMON
371 int ForkAndWait(const string & confDir)
372 #else
373 int ForkAndWait(const string &)
374 #endif
375 {
376 #ifndef NO_DAEMON
377 stgChildPid = fork();
378 string startFile = confDir + START_FILE;
379 unlink(startFile.c_str());
380
381 switch (stgChildPid)
382     {
383     case -1:    // ìÁÖÁ
384         return -1;
385         break;
386
387     case 0:     // ðÏÔÏÍÏË
388         //close(0);
389         close(1);
390         close(2);
391         setsid();
392         break;
393
394     default:    // ïÓÎÏ×ÎÏÊ ÐÒÏÃÅÓÓ
395         for (int i = 0; i < 120 * 5; i++)
396             {
397             if (access(startFile.c_str(), F_OK) == 0)
398                 {
399                 //printf("Fork successfull. Exit.\n");
400                 unlink(startFile.c_str());
401                 exit(0);
402                 }
403
404             if (childExited)
405                 {
406                 unlink(startFile.c_str());
407                 exit(1);
408                 }
409             usleep(200000);
410             }
411         unlink(startFile.c_str());
412         exit(1);
413         break;
414     }
415 #endif
416 return 0;
417 }
418 //-----------------------------------------------------------------------------
419 void KillExecuters()
420 {
421 set<pid_t>::iterator pid;
422 pid = executersPid.begin();
423 while (pid != executersPid.end())
424     {
425     printfd(__FILE__, "KillExecuters pid=%d\n", *pid);
426     kill(*pid, SIGUSR1);
427     ++pid;
428     }
429 }
430 //-----------------------------------------------------------------------------
431 int main(int argc, char * argv[])
432 {
433
434 /*
435   Initialization order:
436   - Logger
437   - Stg timer
438   - Settings
439   - Plugins
440   - Plugins settings
441   - Read Admins
442   - Read Tariffs
443   - Read Users
444   - Start Users
445   - Start Traffcounter
446   - Start Plugins
447   - Start pinger
448   - Set signal nandlers
449   - Fork and exit
450  * */
451
452 SETTINGS * settings = NULL;
453 BASE_STORE * dataStore = NULL;
454 TARIFFS * tariffs = NULL;
455 ADMINS * admins = NULL;
456 USERS * users = NULL;
457 TRAFFCOUNTER * traffCnt = NULL;
458 int msgID = -11;
459
460     {
461     STG_LOGGER & WriteServLog = GetStgLogger();
462     WriteServLog.SetLogFileName("/var/log/stargazer.log");
463     }
464
465 vector<MODULE_SETTINGS> modSettings;
466 list<PLUGIN_RUNNER> modules;
467
468 list<PLUGIN_RUNNER>::iterator modIter;
469
470 if (getuid())
471     {
472     printf("You must be root. Exit.\n");
473     exit(1);
474     }
475
476 if (argc == 2)
477     settings = new SETTINGS(argv[1]);
478 else
479     settings = new SETTINGS();
480
481 if (settings->ReadSettings())
482     {
483     //printfd(__FILE__, "ReadSettings error.\n");
484     STG_LOGGER & WriteServLog = GetStgLogger();
485
486     if (settings->GetLogFileName() != "")
487         WriteServLog.SetLogFileName(settings->GetLogFileName());
488
489     WriteServLog("ReadSettings error. %s", settings->GetStrError().c_str());
490     exit(1);
491     }
492
493 #ifndef NO_DAEMON
494 string startFile(settings->GetConfDir() + START_FILE);
495 #endif
496
497 if (ForkAndWait(settings->GetConfDir()) < 0)
498     {
499     STG_LOGGER & WriteServLog = GetStgLogger();
500     WriteServLog("Fork error!");
501     exit(1);
502     }
503
504 STG_LOGGER & WriteServLog = GetStgLogger();
505 WriteServLog.SetLogFileName(settings->GetLogFileName());
506 WriteServLog("Stg v. %s", SERVER_VERSION);
507
508 for (size_t i = 0; i < settings->GetExecutersNum(); i++)
509     {
510     int ret = StartScriptExecuter(argv[0], settings->GetExecMsgKey(), &msgID, settings);
511     if (ret < 0)
512         {
513         STG_LOGGER & WriteServLog = GetStgLogger();
514         WriteServLog("Start Script Executer error!");
515         return 1;
516         }
517     if (ret == 1)
518         {
519         // Stopping child
520         return 0;
521         }
522     }
523
524 PIDFile pidFile(settings->GetPIDFileName());
525
526 StartTimer();
527 WaitTimer();
528 if (!IsStgTimerRunning())
529     {
530     printfd(__FILE__, "Timer thread not started in 1 sec!\n");
531     WriteServLog("Timer thread not started in 1 sec!");
532     }
533
534 EVENT_LOOP & loop(EVENT_LOOP_SINGLETON::GetInstance());
535
536 STORE_LOADER storeLoader(*settings);
537 if (storeLoader.Load())
538     {
539     WriteServLog("Storage plugin: '%s'", storeLoader.GetStrError().c_str());
540     goto exitLblNotStarted;
541     }
542
543 if (loop.Start())
544     {
545     WriteServLog("Event loop not started.");
546     goto exitLblNotStarted;
547     }
548
549 dataStore = storeLoader.GetStore();
550 WriteServLog("Storage plugin: %s. Loading successfull.", dataStore->GetVersion().c_str());
551
552 tariffs = new TARIFFS(dataStore);
553 admins = new ADMINS(dataStore);
554 users = new USERS(settings, dataStore, tariffs, admins->GetSysAdmin());
555 traffCnt = new TRAFFCOUNTER(users, tariffs, settings->GetRulesFileName());
556 traffCnt->SetMonitorDir(settings->GetMonitorDir());
557
558 modSettings = settings->GetModulesSettings();
559
560 for (unsigned i = 0; i < modSettings.size(); i++)
561     {
562     string modulePath = settings->GetModulesPath();
563     modulePath += "/mod_";
564     modulePath += modSettings[i].moduleName;
565     modulePath += ".so";
566     printfd(__FILE__, "Module: %s\n", modulePath.c_str());
567     modules.push_back(
568         PLUGIN_RUNNER(modulePath,
569                       modSettings[i],
570                       admins,
571                       tariffs,
572                       users,
573                       traffCnt,
574                       dataStore,
575                       settings)
576         );
577     }
578
579 modIter = modules.begin();
580
581 while (modIter != modules.end())
582     {
583     //Loading modules
584     if (modIter->Load())
585         {
586         WriteServLog("Error: %s",
587                      modIter->GetStrError().c_str());
588         goto exitLblNotStarted;
589         }
590     ++modIter;
591     }
592
593 //Start section
594 if (users->Start())
595     {
596     goto exitLblNotStarted;
597     }
598 WriteServLog("Users started successfully.");
599
600 if (traffCnt->Start())
601     {
602     goto exitLblNotStarted;
603     }
604 WriteServLog("Traffcounter started successfully.");
605
606 //Sort by start order
607 modules.sort(StartModCmp);
608 modIter = modules.begin();
609
610 while (modIter != modules.end())
611     {
612     if (modIter->Start())
613         {
614         WriteServLog("Error: %s",
615                      modIter->GetStrError().c_str());
616         //printfd(__FILE__, "Error: %s\n", capRunner.GetStrError().c_str());
617         goto exitLbl;
618         }
619     WriteServLog("Module: \'%s\'. Start successfull. %d", modIter->GetPlugin()->GetVersion().c_str(),
620         modIter->GetPlugin()->GetStartPosition());
621     ++modIter;
622     }
623 SetSignalHandlers();
624
625 srandom(stgTime);
626
627 /*
628  * Note that an implementation in which nice returns the new nice value
629  * can legitimately return -1.   To  reliably  detect  an  error,  set
630  * errno to 0 before the call, and check its value when nice returns -1.
631  *
632  *
633  * (c) man 2 nice
634  */
635 errno = 0;
636 if (nice(-19) && errno) {
637     printfd(__FILE__, "nice failed: '%s'\n", strerror(errno));
638     WriteServLog("nice failed: '%s'", strerror(errno));
639 }
640
641 WriteServLog("Stg started successfully.");
642 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
643
644 #ifndef NO_DAEMON
645 creat(startFile.c_str(), S_IRUSR);
646 #endif
647
648 while (nonstop.GetStatus())
649     {
650     if (needRulesReloading)
651         {
652         needRulesReloading = false;
653         traffCnt->Reload();
654
655         modIter = modules.begin();
656         for (; modIter != modules.end(); ++modIter)
657             {
658             if (modIter->Reload())
659                 {
660                 WriteServLog("Error reloading %s ('%s')", modIter->GetPlugin()->GetVersion().c_str(),
661                                                           modIter->GetStrError().c_str());
662                 printfd(__FILE__, "Error reloading %s ('%s')\n", modIter->GetPlugin()->GetVersion().c_str(),
663                                                                  modIter->GetStrError().c_str());
664                 }
665             }
666         }
667     stgUsleep(100000);
668     }
669
670 exitLbl:
671
672 WriteServLog("+++++++++++++++++++++++++++++++++++++++++++++");
673
674 //Sort by start order
675 modules.sort(StopModCmp);
676 modIter = modules.begin();
677 while (modIter != modules.end())
678     {
679     std::string name = modIter->GetFileName();
680     printfd(__FILE__, "Stopping module '%s'\n", name.c_str());
681     if (modIter->Stop())
682         {
683         WriteServLog("Module \'%s\': Error: %s",
684                      modIter->GetPlugin()->GetVersion().c_str(),
685                      modIter->GetStrError().c_str());
686         printfd(__FILE__, "Failed to stop module '%s'\n", name.c_str());
687         //printfd(__FILE__, "Error: %s\n", capRunner.GetStrError().c_str());
688         //goto exitLbl;
689         }
690     WriteServLog("Module: \'%s\'. Stop successfull.", modIter->GetPlugin()->GetVersion().c_str());
691     ++modIter;
692     }
693
694 if (loop.Stop())
695     {
696     WriteServLog("Event loop not stopped.");
697     }
698
699 exitLblNotStarted:
700
701 modIter = modules.begin();
702 while (modIter != modules.end())
703     {
704     std::string name = modIter->GetFileName();
705     printfd(__FILE__, "Unloading module '%s'\n", name.c_str());
706     if (modIter->Unload())
707         {
708         WriteServLog("Module \'%s\': Error: %s",
709                      name.c_str(),
710                      modIter->GetStrError().c_str());
711         printfd(__FILE__, "Failed to unload module '%s'\n", name.c_str());
712         }
713     ++modIter;
714     }
715
716 if (traffCnt)
717     {
718     traffCnt->Stop();
719     WriteServLog("Traffcounter: Stop successfull.");
720     }
721
722 if (users)
723     {
724     users->Stop();
725     WriteServLog("Users: Stop successfull.");
726     }
727
728 sleep(1);
729 int res = msgctl(msgID, IPC_RMID, NULL);
730 if (res)
731     WriteServLog("Queue was not removed. id=%d", msgID);
732 else
733     WriteServLog("Queue removed successfully.");
734
735 /*struct sigaction newsa, oldsa;
736 sigset_t sigmask;
737 sigemptyset(&sigmask);
738 sigaddset(&sigmask, SIGCHLD);
739 newsa.sa_handler = SIG_IGN;
740 newsa.sa_mask = sigmask;
741 newsa.sa_flags = 0;
742 sigaction(SIGCHLD, &newsa, &oldsa);*/
743
744 KillExecuters();
745
746 StopStgTimer();
747 WriteServLog("StgTimer: Stop successfull.");
748
749 WriteServLog("Stg stopped successfully.");
750 sleep(1);
751 WriteServLog("---------------------------------------------");
752
753 delete traffCnt;
754 delete users;
755 delete admins;
756 delete tariffs;
757 delete settings;
758
759 return 0;
760 }
761 //-----------------------------------------------------------------------------
762
763