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