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