]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/rscript/rscript.cpp
Added license header.
[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 logger("%s reloaded successfully.", rsSettings.GetMapFileName().c_str());
328 printfd(__FILE__, "REMOTE_SCRIPT::Reload() %s reloaded successfully.\n");
329
330 return 0;
331 }
332 //-----------------------------------------------------------------------------
333 bool REMOTE_SCRIPT::PrepareNet()
334 {
335 sock = socket(AF_INET, SOCK_DGRAM, 0);
336
337 if (sock < 0)
338     {
339     errorStr = "Cannot create socket.";
340     logger("Canot create a socket: %s", strerror(errno));
341     printfd(__FILE__, "Cannot create socket\n");
342     return true;
343     }
344
345 return false;
346 }
347 //-----------------------------------------------------------------------------
348 bool REMOTE_SCRIPT::FinalizeNet()
349 {
350 close(sock);
351 return false;
352 }
353 //-----------------------------------------------------------------------------
354 void REMOTE_SCRIPT::PeriodicSend()
355 {
356 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
357
358 std::map<uint32_t, RS::USER>::iterator it(authorizedUsers.begin());
359 while (it != authorizedUsers.end())
360     {
361     if (difftime(stgTime, it->second.lastSentTime) - (rand() % halfPeriod) > sendPeriod)
362         {
363         Send(it->second);
364         }
365     ++it;
366     }
367 }
368 //-----------------------------------------------------------------------------
369 #ifdef NDEBUG
370 bool REMOTE_SCRIPT::PreparePacket(char * buf, size_t, RS::USER & rsu, bool forceDisconnect) const
371 #else
372 bool REMOTE_SCRIPT::PreparePacket(char * buf, size_t bufSize, RS::USER & rsu, bool forceDisconnect) const
373 #endif
374 {
375 RS::PACKET_HEADER packetHead;
376
377 memset(packetHead.padding, 0, sizeof(packetHead.padding));
378 strcpy((char*)packetHead.magic, RS_ID);
379 packetHead.protoVer[0] = '0';
380 packetHead.protoVer[1] = '2';
381 if (forceDisconnect)
382     {
383     packetHead.packetType = RS_DISCONNECT_PACKET;
384     printfd(__FILE__, "RSCRIPT: force disconnect for '%s'\n", rsu.user->GetLogin().c_str());
385     }
386 else
387     {
388     if (rsu.shortPacketsCount % MAX_SHORT_PCKT == 0)
389         {
390         //SendLong
391         packetHead.packetType = rsu.user->IsInetable() ? RS_CONNECT_PACKET : RS_DISCONNECT_PACKET;
392         if (rsu.user->IsInetable())
393             printfd(__FILE__, "RSCRIPT: connect for '%s'\n", rsu.user->GetLogin().c_str());
394         else
395             printfd(__FILE__, "RSCRIPT: disconnect for '%s'\n", rsu.user->GetLogin().c_str());
396         }
397     else
398         {
399         //SendShort
400         packetHead.packetType = rsu.user->IsInetable() ? RS_ALIVE_PACKET : RS_DISCONNECT_PACKET;
401         if (rsu.user->IsInetable())
402             printfd(__FILE__, "RSCRIPT: alive for '%s'\n", rsu.user->GetLogin().c_str());
403         else
404             printfd(__FILE__, "RSCRIPT: disconnect for '%s'\n", rsu.user->GetLogin().c_str());
405         }
406     }
407 rsu.shortPacketsCount++;
408 rsu.lastSentTime = stgTime;
409
410 packetHead.ip = htonl(rsu.ip);
411 packetHead.id = htonl(rsu.user->GetID());
412 strncpy((char*)packetHead.login, rsu.user->GetLogin().c_str(), RS_LOGIN_LEN);
413 packetHead.login[RS_LOGIN_LEN - 1] = 0;
414
415 memcpy(buf, &packetHead, sizeof(packetHead));
416
417 if (packetHead.packetType == RS_ALIVE_PACKET)
418     {
419     return false;
420     }
421
422 RS::PACKET_TAIL packetTail;
423
424 memset(packetTail.padding, 0, sizeof(packetTail.padding));
425 strcpy((char*)packetTail.magic, RS_ID);
426 std::vector<std::string>::const_iterator it;
427 std::string params;
428 for(it = rsSettings.GetUserParams().begin();
429     it != rsSettings.GetUserParams().end();
430     ++it)
431     {
432     std::string parameter(GetUserParam(rsu.user, *it));
433     if (params.length() + parameter.length() > RS_PARAMS_LEN - 1)
434         break;
435     params += parameter + " ";
436     }
437 strncpy((char *)packetTail.params, params.c_str(), RS_PARAMS_LEN);
438 packetTail.params[RS_PARAMS_LEN - 1] = 0;
439
440 assert(sizeof(packetHead) + sizeof(packetTail) <= bufSize && "Insufficient buffer space");
441
442 Encrypt(&ctx, buf + sizeof(packetHead), (char *)&packetTail, sizeof(packetTail) / 8);
443
444 return false;
445 }
446 //-----------------------------------------------------------------------------
447 bool REMOTE_SCRIPT::Send(RS::USER & rsu, bool forceDisconnect) const
448 {
449 char buffer[RS_MAX_PACKET_LEN];
450
451 memset(buffer, 0, sizeof(buffer));
452
453 if (PreparePacket(buffer, sizeof(buffer), rsu, forceDisconnect))
454     {
455     printfd(__FILE__, "REMOTE_SCRIPT::Send() - Invalid packet length!\n");
456     return true;
457     }
458
459 std::for_each(
460         rsu.routers.begin(),
461         rsu.routers.end(),
462         PacketSender(sock, buffer, sizeof(buffer), static_cast<uint16_t>(htons(rsSettings.GetPort())))
463         );
464
465 return false;
466 }
467 //-----------------------------------------------------------------------------
468 bool REMOTE_SCRIPT::SendDirect(RS::USER & rsu, uint32_t routerIP, bool forceDisconnect) const
469 {
470 char buffer[RS_MAX_PACKET_LEN];
471
472 if (PreparePacket(buffer, sizeof(buffer), rsu, forceDisconnect))
473     {
474     printfd(__FILE__, "REMOTE_SCRIPT::SendDirect() - Invalid packet length!\n");
475     return true;
476     }
477
478 struct sockaddr_in sendAddr;
479
480 sendAddr.sin_family = AF_INET;
481 sendAddr.sin_port = static_cast<uint16_t>(htons(rsSettings.GetPort()));
482 sendAddr.sin_addr.s_addr = routerIP;
483
484 ssize_t res = sendto(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&sendAddr, sizeof(sendAddr));
485
486 if (res < 0)
487     logger("sendto error: %s", strerror(errno));
488
489 return (res != sizeof(buffer));
490 }
491 //-----------------------------------------------------------------------------
492 bool REMOTE_SCRIPT::GetUsers()
493 {
494 USER_PTR u;
495
496 int h = users->OpenSearch();
497 assert(h && "USERS::OpenSearch is always correct");
498
499 while (!users->SearchNext(h, &u))
500     {
501     SetUserNotifiers(u);
502     }
503
504 users->CloseSearch(h);
505 return false;
506 }
507 //-----------------------------------------------------------------------------
508 std::vector<uint32_t> REMOTE_SCRIPT::IP2Routers(uint32_t ip)
509 {
510 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
511 for (size_t i = 0; i < netRouters.size(); ++i)
512     {
513     if ((ip & netRouters[i].subnetMask) == (netRouters[i].subnetIP & netRouters[i].subnetMask))
514         {
515         return netRouters[i].routers;
516         }
517     }
518 return std::vector<uint32_t>();
519 }
520 //-----------------------------------------------------------------------------
521 std::string REMOTE_SCRIPT::GetUserParam(USER_PTR u, const std::string & paramName) const
522 {
523 std::string value = "";
524 if (strcasecmp(paramName.c_str(), "cash") == 0)
525     strprintf(&value, "%f", u->GetProperty().cash.Get());
526 else
527 if (strcasecmp(paramName.c_str(), "freeMb") == 0)
528     strprintf(&value, "%f", u->GetProperty().freeMb.Get());
529 else
530 if (strcasecmp(paramName.c_str(), "passive") == 0)
531     strprintf(&value, "%d", u->GetProperty().passive.Get());
532 else
533 if (strcasecmp(paramName.c_str(), "disabled") == 0)
534     strprintf(&value, "%d", u->GetProperty().disabled.Get());
535 else
536 if (strcasecmp(paramName.c_str(), "alwaysOnline") == 0)
537     strprintf(&value, "%d", u->GetProperty().alwaysOnline.Get());
538 else
539 if (strcasecmp(paramName.c_str(), "tariffName") == 0 ||
540     strcasecmp(paramName.c_str(), "tariff") == 0)
541     value = "\"" + u->GetProperty().tariffName.Get() + "\"";
542 else
543 if (strcasecmp(paramName.c_str(), "nextTariff") == 0)
544     value = "\"" + u->GetProperty().nextTariff.Get() + "\"";
545 else
546 if (strcasecmp(paramName.c_str(), "address") == 0)
547     value = "\"" + u->GetProperty().address.Get() + "\"";
548 else
549 if (strcasecmp(paramName.c_str(), "note") == 0)
550     value = "\"" + u->GetProperty().note.Get() + "\"";
551 else
552 if (strcasecmp(paramName.c_str(), "group") == 0)
553     value = "\"" + u->GetProperty().group.Get() + "\"";
554 else
555 if (strcasecmp(paramName.c_str(), "email") == 0)
556     value = "\"" + u->GetProperty().email.Get() + "\"";
557 else
558 if (strcasecmp(paramName.c_str(), "realName") == 0)
559     value = "\"" + u->GetProperty().realName.Get() + "\"";
560 else
561 if (strcasecmp(paramName.c_str(), "credit") == 0)
562     strprintf(&value, "%f", u->GetProperty().credit.Get());
563 else
564 if (strcasecmp(paramName.c_str(), "userdata0") == 0)
565     value = "\"" + u->GetProperty().userdata0.Get() + "\"";
566 else
567 if (strcasecmp(paramName.c_str(), "userdata1") == 0)
568     value = "\"" + u->GetProperty().userdata1.Get() + "\"";
569 else
570 if (strcasecmp(paramName.c_str(), "userdata2") == 0)
571     value = "\"" + u->GetProperty().userdata2.Get() + "\"";
572 else
573 if (strcasecmp(paramName.c_str(), "userdata3") == 0)
574     value = "\"" + u->GetProperty().userdata3.Get() + "\"";
575 else
576 if (strcasecmp(paramName.c_str(), "userdata4") == 0)
577     value = "\"" + u->GetProperty().userdata4.Get() + "\"";
578 else
579 if (strcasecmp(paramName.c_str(), "userdata5") == 0)
580     value = "\"" + u->GetProperty().userdata5.Get() + "\"";
581 else
582 if (strcasecmp(paramName.c_str(), "userdata6") == 0)
583     value = "\"" + u->GetProperty().userdata6.Get() + "\"";
584 else
585 if (strcasecmp(paramName.c_str(), "userdata7") == 0)
586     value = "\"" + u->GetProperty().userdata7.Get() + "\"";
587 else
588 if (strcasecmp(paramName.c_str(), "userdata8") == 0)
589     value = "\"" + u->GetProperty().userdata8.Get() + "\"";
590 else
591 if (strcasecmp(paramName.c_str(), "userdata9") == 0)
592     value = "\"" + u->GetProperty().userdata9.Get() + "\"";
593 else
594 if (strcasecmp(paramName.c_str(), "enabledDirs") == 0)
595     value = u->GetEnabledDirs();
596 else
597     printfd(__FILE__, "Unknown value name: %s\n", paramName.c_str());
598 return value;
599 }
600 //-----------------------------------------------------------------------------
601 void REMOTE_SCRIPT::SetUserNotifiers(USER_PTR u)
602 {
603 ipNotifierList.push_front(RS::IP_NOTIFIER(*this, u));
604 connNotifierList.push_front(RS::CONNECTED_NOTIFIER(*this, u));
605 }
606 //-----------------------------------------------------------------------------
607 void REMOTE_SCRIPT::UnSetUserNotifiers(USER_PTR u)
608 {
609 ipNotifierList.erase(std::remove_if(ipNotifierList.begin(),
610                                     ipNotifierList.end(),
611                                     USER_IS<IP_NOTIFIER>(u)),
612                      ipNotifierList.end());
613 connNotifierList.erase(std::remove_if(connNotifierList.begin(),
614                                       connNotifierList.end(),
615                                       USER_IS<CONNECTED_NOTIFIER>(u)),
616                        connNotifierList.end());
617
618 }
619 //-----------------------------------------------------------------------------
620 void REMOTE_SCRIPT::AddRSU(USER_PTR user)
621 {
622 RS::USER rsu(IP2Routers(user->GetCurrIP()), user);
623 Send(rsu);
624
625 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
626 authorizedUsers.insert(std::make_pair(user->GetCurrIP(), rsu));
627 }
628 //-----------------------------------------------------------------------------
629 void REMOTE_SCRIPT::DelRSU(USER_PTR user)
630 {
631 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
632 const std::map<uint32_t, RS::USER>::iterator it(
633         authorizedUsers.find(user->GetCurrIP())
634         );
635 if (it != authorizedUsers.end())
636     {
637     Send(it->second, true);
638     authorizedUsers.erase(it);
639     }
640 }
641 //-----------------------------------------------------------------------------
642 void RS::IP_NOTIFIER::Notify(const uint32_t & /*oldValue*/, const uint32_t & newValue)
643 {
644 if (newValue)
645     rs.AddRSU(user);
646 else
647     rs.DelRSU(user);
648 }
649 //-----------------------------------------------------------------------------
650 void RS::CONNECTED_NOTIFIER::Notify(const bool & /*oldValue*/, const bool & newValue)
651 {
652 if (newValue)
653     rs.AddRSU(user);
654 else
655     rs.DelRSU(user);
656 }
657 //-----------------------------------------------------------------------------
658 void REMOTE_SCRIPT::InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password) const
659 {
660 unsigned char keyL[PASSWD_LEN];  // Пароль для шифровки
661 memset(keyL, 0, PASSWD_LEN);
662 strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
663 Blowfish_Init(ctx, keyL, PASSWD_LEN);
664 }
665 //-----------------------------------------------------------------------------
666 void REMOTE_SCRIPT::Encrypt(BLOWFISH_CTX * ctx, void * dst, const void * src, size_t len8) const
667 {
668 if (dst != src)
669     memcpy(dst, src, len8 * 8);
670 for (size_t i = 0; i < len8; ++i)
671     Blowfish_Encrypt(ctx, static_cast<uint32_t *>(dst) + i * 2, static_cast<uint32_t *>(dst) + i * 2 + 1);
672 }
673 //-----------------------------------------------------------------------------