]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/rscript/rscript.cpp
Merge branch 'stg-2.409'
[stg.git] / projects / stargazer / plugins / other / rscript / rscript.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 #include "rscript.h"
23
24 #include "ur_functor.h"
25 #include "send_functor.h"
26
27 #include "stg/common.h"
28 #include "stg/locker.h"
29 #include "stg/users.h"
30 #include "stg/user_property.h"
31 #include "stg/plugin_creator.h"
32 #include "stg/logger.h"
33
34 #include <algorithm>
35
36 #include <csignal>
37 #include <cassert>
38 #include <cstdlib>
39 #include <cerrno>
40 #include <cstring>
41
42 #include <sys/time.h>
43 #include <netinet/ip.h>
44
45 extern volatile time_t stgTime;
46
47 using RS::REMOTE_SCRIPT;
48
49 namespace {
50
51 template<typename T>
52 struct USER_IS
53 {
54     explicit USER_IS(USER_PTR u) : user(u) {}
55     bool operator()(const T & notifier) { return notifier.GetUser() == user; }
56
57     USER_PTR user;
58 };
59
60 PLUGIN_CREATOR<REMOTE_SCRIPT> rsc;
61
62 } // namespace anonymous
63
64 extern "C" PLUGIN * GetPlugin();
65 //-----------------------------------------------------------------------------
66 //-----------------------------------------------------------------------------
67 //-----------------------------------------------------------------------------
68 //-----------------------------------------------------------------------------
69 //-----------------------------------------------------------------------------
70 //-----------------------------------------------------------------------------
71 PLUGIN * GetPlugin()
72 {
73 return rsc.GetPlugin();
74 }
75 //-----------------------------------------------------------------------------
76 //-----------------------------------------------------------------------------
77 //-----------------------------------------------------------------------------
78 RS::SETTINGS::SETTINGS()
79     : sendPeriod(0),
80       port(0)
81 {
82 }
83 //-----------------------------------------------------------------------------
84 int RS::SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
85 {
86 int p;
87 PARAM_VALUE pv;
88 std::vector<PARAM_VALUE>::const_iterator pvi;
89 netRouters.clear();
90 ///////////////////////////
91 pv.param = "Port";
92 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
93 if (pvi == s.moduleParams.end() || pvi->value.empty())
94     {
95     errorStr = "Parameter \'Port\' not found.";
96     printfd(__FILE__, "Parameter 'Port' not found\n");
97     return -1;
98     }
99 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
100     {
101     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
102     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
103     return -1;
104     }
105 port = static_cast<uint16_t>(p);
106 ///////////////////////////
107 pv.param = "SendPeriod";
108 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
109 if (pvi == s.moduleParams.end() || pvi->value.empty())
110     {
111     errorStr = "Parameter \'SendPeriod\' not found.";
112     printfd(__FILE__, "Parameter 'SendPeriod' not found\n");
113     return -1;
114     }
115
116 if (ParseIntInRange(pvi->value[0], 5, 600, &sendPeriod))
117     {
118     errorStr = "Cannot parse parameter \'SendPeriod\': " + errorStr;
119     printfd(__FILE__, "Cannot parse parameter 'SendPeriod'\n");
120     return -1;
121     }
122 ///////////////////////////
123 pv.param = "UserParams";
124 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
125 if (pvi == s.moduleParams.end() || pvi->value.empty())
126     {
127     errorStr = "Parameter \'UserParams\' not found.";
128     printfd(__FILE__, "Parameter 'UserParams' not found\n");
129     return -1;
130     }
131 userParams = pvi->value;
132 ///////////////////////////
133 pv.param = "Password";
134 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
135 if (pvi == s.moduleParams.end() || pvi->value.empty())
136     {
137     errorStr = "Parameter \'Password\' not found.";
138     printfd(__FILE__, "Parameter 'Password' not found\n");
139     return -1;
140     }
141 password = pvi->value[0];
142 ///////////////////////////
143 pv.param = "SubnetFile";
144 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
145 if (pvi == s.moduleParams.end() || pvi->value.empty())
146     {
147     errorStr = "Parameter \'SubnetFile\' not found.";
148     printfd(__FILE__, "Parameter 'SubnetFile' not found\n");
149     return -1;
150     }
151 subnetFile = pvi->value[0];
152
153 NRMapParser nrMapParser;
154
155 if (!nrMapParser.ReadFile(subnetFile))
156     {
157     netRouters = nrMapParser.GetMap();
158     }
159 else
160     {
161     GetStgLogger()("mod_rscript: error opening subnets file '%s'", subnetFile.c_str());
162     }
163
164 return 0;
165 }
166 //-----------------------------------------------------------------------------
167 //-----------------------------------------------------------------------------
168 //-----------------------------------------------------------------------------
169 REMOTE_SCRIPT::REMOTE_SCRIPT()
170     : ctx(),
171       ipNotifierList(),
172       connNotifierList(),
173       authorizedUsers(),
174       errorStr(),
175       rsSettings(),
176       settings(),
177       sendPeriod(15),
178       halfPeriod(8),
179       nonstop(false),
180       isRunning(false),
181       users(NULL),
182       netRouters(),
183       thread(),
184       mutex(),
185       sock(0),
186       onAddUserNotifier(*this),
187       onDelUserNotifier(*this),
188       logger(GetPluginLogger(GetStgLogger(), "rscript"))
189 {
190 pthread_mutex_init(&mutex, NULL);
191 }
192 //-----------------------------------------------------------------------------
193 REMOTE_SCRIPT::~REMOTE_SCRIPT()
194 {
195 pthread_mutex_destroy(&mutex);
196 }
197 //-----------------------------------------------------------------------------
198 void * REMOTE_SCRIPT::Run(void * d)
199 {
200 sigset_t signalSet;
201 sigfillset(&signalSet);
202 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
203
204 REMOTE_SCRIPT * rs = static_cast<REMOTE_SCRIPT *>(d);
205
206 rs->isRunning = true;
207
208 while (rs->nonstop)
209     {
210     rs->PeriodicSend();
211     sleep(2);
212     }
213
214 rs->isRunning = false;
215 return NULL;
216 }
217 //-----------------------------------------------------------------------------
218 int REMOTE_SCRIPT::ParseSettings()
219 {
220 int ret = rsSettings.ParseSettings(settings);
221 if (ret)
222     errorStr = rsSettings.GetStrError();
223
224 sendPeriod = rsSettings.GetSendPeriod();
225 halfPeriod = sendPeriod / 2;
226
227 return ret;
228 }
229 //-----------------------------------------------------------------------------
230 int REMOTE_SCRIPT::Start()
231 {
232 netRouters = rsSettings.GetSubnetsMap();
233
234 InitEncrypt(&ctx, rsSettings.GetPassword());
235
236 users->AddNotifierUserAdd(&onAddUserNotifier);
237 users->AddNotifierUserDel(&onDelUserNotifier);
238
239 nonstop = true;
240
241 if (GetUsers())
242     {
243     return -1;
244     }
245
246 if (PrepareNet())
247     {
248     return -1;
249     }
250
251 if (!isRunning)
252     {
253     if (pthread_create(&thread, NULL, Run, this))
254         {
255         errorStr = "Cannot create thread.";
256         logger("Cannot create thread.");
257         printfd(__FILE__, "Cannot create thread\n");
258         return -1;
259         }
260     }
261
262 errorStr = "";
263 return 0;
264 }
265 //-----------------------------------------------------------------------------
266 int REMOTE_SCRIPT::Stop()
267 {
268 if (!IsRunning())
269     return 0;
270
271 nonstop = false;
272
273 std::for_each(
274         authorizedUsers.begin(),
275         authorizedUsers.end(),
276         DisconnectUser(*this)
277         );
278
279 FinalizeNet();
280
281 if (isRunning)
282     {
283     //5 seconds to thread stops itself
284     for (int i = 0; i < 25 && isRunning; i++)
285         {
286         struct timespec ts = {0, 200000000};
287         nanosleep(&ts, NULL);
288         }
289     }
290
291 users->DelNotifierUserDel(&onDelUserNotifier);
292 users->DelNotifierUserAdd(&onAddUserNotifier);
293
294 if (isRunning)
295     {
296     logger("Cannot stop thread.");
297     return -1;
298     }
299
300 return 0;
301 }
302 //-----------------------------------------------------------------------------
303 int REMOTE_SCRIPT::Reload(const MODULE_SETTINGS & /*ms*/)
304 {
305 NRMapParser nrMapParser;
306
307 if (nrMapParser.ReadFile(rsSettings.GetMapFileName()))
308     {
309     errorStr = nrMapParser.GetErrorStr();
310     logger("Map file reading error: %s", errorStr.c_str());
311     return -1;
312     }
313
314     {
315     STG_LOCKER lock(&mutex);
316
317     printfd(__FILE__, "REMOTE_SCRIPT::Reload()\n");
318
319     netRouters = nrMapParser.GetMap();
320     }
321
322 std::for_each(authorizedUsers.begin(),
323               authorizedUsers.end(),
324               UpdateRouter(*this));
325
326 logger("%s reloaded successfully.", rsSettings.GetMapFileName().c_str());
327 printfd(__FILE__, "REMOTE_SCRIPT::Reload() %s reloaded successfully.\n");
328
329 return 0;
330 }
331 //-----------------------------------------------------------------------------
332 bool REMOTE_SCRIPT::PrepareNet()
333 {
334 sock = socket(AF_INET, SOCK_DGRAM, 0);
335
336 if (sock < 0)
337     {
338     errorStr = "Cannot create socket.";
339     logger("Canot create a socket: %s", strerror(errno));
340     printfd(__FILE__, "Cannot create socket\n");
341     return true;
342     }
343
344 return false;
345 }
346 //-----------------------------------------------------------------------------
347 bool REMOTE_SCRIPT::FinalizeNet()
348 {
349 close(sock);
350 return false;
351 }
352 //-----------------------------------------------------------------------------
353 void REMOTE_SCRIPT::PeriodicSend()
354 {
355 STG_LOCKER lock(&mutex);
356
357 std::map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());
358 while (it != authorizedUsers.end())
359     {
360     if (difftime(stgTime, it->second.lastSentTime) - (rand() % halfPeriod) > sendPeriod)
361         {
362         Send(it->second);
363         }
364     ++it;
365     }
366 }
367 //-----------------------------------------------------------------------------
368 #ifdef NDEBUG
369 bool REMOTE_SCRIPT::PreparePacket(char * buf, size_t, RS::USER & rsu, bool forceDisconnect) const
370 #else
371 bool REMOTE_SCRIPT::PreparePacket(char * buf, size_t bufSize, RS::USER & rsu, bool forceDisconnect) const
372 #endif
373 {
374 RS::PACKET_HEADER packetHead;
375
376 memset(packetHead.padding, 0, sizeof(packetHead.padding));
377 strcpy((char*)packetHead.magic, RS_ID);
378 packetHead.protoVer[0] = '0';
379 packetHead.protoVer[1] = '2';
380 if (forceDisconnect)
381     {
382     packetHead.packetType = RS_DISCONNECT_PACKET;
383     printfd(__FILE__, "RSCRIPT: force disconnect for '%s'\n", rsu.user->GetLogin().c_str());
384     }
385 else
386     {
387     if (rsu.shortPacketsCount % MAX_SHORT_PCKT == 0)
388         {
389         //SendLong
390         packetHead.packetType = rsu.user->IsInetable() ? RS_CONNECT_PACKET : RS_DISCONNECT_PACKET;
391         if (rsu.user->IsInetable())
392             printfd(__FILE__, "RSCRIPT: connect for '%s'\n", rsu.user->GetLogin().c_str());
393         else
394             printfd(__FILE__, "RSCRIPT: disconnect for '%s'\n", rsu.user->GetLogin().c_str());
395         }
396     else
397         {
398         //SendShort
399         packetHead.packetType = rsu.user->IsInetable() ? RS_ALIVE_PACKET : RS_DISCONNECT_PACKET;
400         if (rsu.user->IsInetable())
401             printfd(__FILE__, "RSCRIPT: alive for '%s'\n", rsu.user->GetLogin().c_str());
402         else
403             printfd(__FILE__, "RSCRIPT: disconnect for '%s'\n", rsu.user->GetLogin().c_str());
404         }
405     }
406 rsu.shortPacketsCount++;
407 rsu.lastSentTime = stgTime;
408
409 packetHead.ip = htonl(rsu.ip);
410 packetHead.id = htonl(rsu.user->GetID());
411 strncpy((char*)packetHead.login, rsu.user->GetLogin().c_str(), RS_LOGIN_LEN);
412 packetHead.login[RS_LOGIN_LEN - 1] = 0;
413
414 memcpy(buf, &packetHead, sizeof(packetHead));
415
416 if (packetHead.packetType == RS_ALIVE_PACKET)
417     {
418     return false;
419     }
420
421 RS::PACKET_TAIL packetTail;
422
423 memset(packetTail.padding, 0, sizeof(packetTail.padding));
424 strcpy((char*)packetTail.magic, RS_ID);
425 std::vector<std::string>::const_iterator it;
426 std::string params;
427 for(it = rsSettings.GetUserParams().begin();
428     it != rsSettings.GetUserParams().end();
429     ++it)
430     {
431     std::string parameter(rsu.user->GetParamValue(it->c_str()));
432     if (params.length() + parameter.length() > RS_PARAMS_LEN - 1)
433     {
434         logger("Script params string length %d exceeds the limit of %d symbols.", params.length() + parameter.length(), RS_PARAMS_LEN);
435         break;
436     }
437     params += parameter + " ";
438     }
439 strncpy((char *)packetTail.params, params.c_str(), RS_PARAMS_LEN);
440 packetTail.params[RS_PARAMS_LEN - 1] = 0;
441
442 assert(sizeof(packetHead) + sizeof(packetTail) <= bufSize && "Insufficient buffer space");
443
444 Encrypt(&ctx, buf + sizeof(packetHead), (char *)&packetTail, sizeof(packetTail) / 8);
445
446 return false;
447 }
448 //-----------------------------------------------------------------------------
449 bool REMOTE_SCRIPT::Send(RS::USER & rsu, bool forceDisconnect) const
450 {
451 char buffer[RS_MAX_PACKET_LEN];
452
453 memset(buffer, 0, sizeof(buffer));
454
455 if (PreparePacket(buffer, sizeof(buffer), rsu, forceDisconnect))
456     {
457     printfd(__FILE__, "REMOTE_SCRIPT::Send() - Invalid packet length!\n");
458     return true;
459     }
460
461 std::for_each(
462         rsu.routers.begin(),
463         rsu.routers.end(),
464         PacketSender(sock, buffer, sizeof(buffer), static_cast<uint16_t>(htons(rsSettings.GetPort())))
465         );
466
467 return false;
468 }
469 //-----------------------------------------------------------------------------
470 bool REMOTE_SCRIPT::SendDirect(RS::USER & rsu, uint32_t routerIP, bool forceDisconnect) const
471 {
472 char buffer[RS_MAX_PACKET_LEN];
473
474 if (PreparePacket(buffer, sizeof(buffer), rsu, forceDisconnect))
475     {
476     printfd(__FILE__, "REMOTE_SCRIPT::SendDirect() - Invalid packet length!\n");
477     return true;
478     }
479
480 struct sockaddr_in sendAddr;
481
482 sendAddr.sin_family = AF_INET;
483 sendAddr.sin_port = static_cast<uint16_t>(htons(rsSettings.GetPort()));
484 sendAddr.sin_addr.s_addr = routerIP;
485
486 ssize_t res = sendto(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&sendAddr, sizeof(sendAddr));
487
488 if (res < 0)
489     logger("sendto error: %s", strerror(errno));
490
491 return (res != sizeof(buffer));
492 }
493 //-----------------------------------------------------------------------------
494 bool REMOTE_SCRIPT::GetUsers()
495 {
496 USER_PTR u;
497
498 int h = users->OpenSearch();
499 assert(h && "USERS::OpenSearch is always correct");
500
501 while (!users->SearchNext(h, &u))
502     {
503     SetUserNotifiers(u);
504     }
505
506 users->CloseSearch(h);
507 return false;
508 }
509 //-----------------------------------------------------------------------------
510 std::vector<uint32_t> REMOTE_SCRIPT::IP2Routers(uint32_t ip)
511 {
512 STG_LOCKER lock(&mutex);
513 for (size_t i = 0; i < netRouters.size(); ++i)
514     {
515     if ((ip & netRouters[i].subnetMask) == (netRouters[i].subnetIP & netRouters[i].subnetMask))
516         {
517         return netRouters[i].routers;
518         }
519     }
520 return std::vector<uint32_t>();
521 }
522 //-----------------------------------------------------------------------------
523 void REMOTE_SCRIPT::SetUserNotifiers(USER_PTR u)
524 {
525 ipNotifierList.push_front(RS::IP_NOTIFIER(*this, u));
526 connNotifierList.push_front(RS::CONNECTED_NOTIFIER(*this, u));
527 }
528 //-----------------------------------------------------------------------------
529 void REMOTE_SCRIPT::UnSetUserNotifiers(USER_PTR u)
530 {
531 ipNotifierList.erase(std::remove_if(ipNotifierList.begin(),
532                                     ipNotifierList.end(),
533                                     USER_IS<IP_NOTIFIER>(u)),
534                      ipNotifierList.end());
535 connNotifierList.erase(std::remove_if(connNotifierList.begin(),
536                                       connNotifierList.end(),
537                                       USER_IS<CONNECTED_NOTIFIER>(u)),
538                        connNotifierList.end());
539
540 }
541 //-----------------------------------------------------------------------------
542 void REMOTE_SCRIPT::AddRSU(USER_PTR user)
543 {
544 RS::USER rsu(IP2Routers(user->GetCurrIP()), user);
545 Send(rsu);
546
547 STG_LOCKER lock(&mutex);
548 authorizedUsers.insert(std::make_pair(user->GetCurrIP(), rsu));
549 }
550 //-----------------------------------------------------------------------------
551 void REMOTE_SCRIPT::DelRSU(USER_PTR user)
552 {
553 STG_LOCKER lock(&mutex);
554 std::map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());
555 while (it != authorizedUsers.end())
556     {
557     if (it->second.user == user)
558         {
559         Send(it->second, true);
560         authorizedUsers.erase(it);
561         return;
562         }
563     ++it;
564     }
565 /*const std::map<uint32_t, RS::USER>::iterator it(
566         authorizedUsers.find(user->GetCurrIP())
567         );
568 if (it != authorizedUsers.end())
569     {
570     Send(it->second, true);
571     authorizedUsers.erase(it);
572     }*/
573 }
574 //-----------------------------------------------------------------------------
575 void RS::IP_NOTIFIER::Notify(const uint32_t & /*oldValue*/, const uint32_t & newValue)
576 {
577 if (newValue)
578     rs.AddRSU(user);
579 else
580     rs.DelRSU(user);
581 }
582 //-----------------------------------------------------------------------------
583 void RS::CONNECTED_NOTIFIER::Notify(const bool & /*oldValue*/, const bool & newValue)
584 {
585 if (newValue)
586     rs.AddRSU(user);
587 else
588     rs.DelRSU(user);
589 }
590 //-----------------------------------------------------------------------------
591 void REMOTE_SCRIPT::InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password) const
592 {
593 unsigned char keyL[PASSWD_LEN];  // Пароль для шифровки
594 memset(keyL, 0, PASSWD_LEN);
595 strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
596 Blowfish_Init(ctx, keyL, PASSWD_LEN);
597 }
598 //-----------------------------------------------------------------------------
599 void REMOTE_SCRIPT::Encrypt(BLOWFISH_CTX * ctx, void * dst, const void * src, size_t len8) const
600 {
601 if (dst != src)
602     memcpy(dst, src, len8 * 8);
603 for (size_t i = 0; i < len8; ++i)
604     Blowfish_Encrypt(ctx, static_cast<uint32_t *>(dst) + i * 2, static_cast<uint32_t *>(dst) + i * 2 + 1);
605 }
606 //-----------------------------------------------------------------------------