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