]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/authorization/inetaccess/inetaccess.cpp
Виправлено шлях до файлів docbook-xsl-stylesheets
[stg.git] / projects / stargazer / plugins / authorization / inetaccess / inetaccess.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  */
20
21 /*
22  $Revision: 1.79 $
23  $Date: 2010/03/25 15:18:48 $
24  $Author: faust $
25  */
26  
27 #ifndef _GNU_SOURCE
28 #define _GNU_SOURCE
29 #endif
30
31 #include <sys/types.h>
32 #include <sys/socket.h>
33 #include <csignal>
34 #include <cstdlib>
35 #include <algorithm>
36
37 #include "inetaccess.h"
38 #include "common.h"
39
40 extern volatile const time_t stgTime;
41
42 void InitEncrypt(BLOWFISH_CTX * ctx, const string & password);
43 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
44 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
45
46 //-----------------------------------------------------------------------------
47 class IA_CREATOR
48 {
49 private:
50     AUTH_IA * ia;
51
52 public:
53     IA_CREATOR()
54         : ia(new AUTH_IA())
55         {
56         };
57     ~IA_CREATOR()
58         {
59         delete ia;
60         };
61
62     AUTH_IA * GetPlugin()
63     {
64         return ia;
65     };
66 };
67 //-----------------------------------------------------------------------------
68 //-----------------------------------------------------------------------------
69 //-----------------------------------------------------------------------------
70 IA_CREATOR iac;
71 //-----------------------------------------------------------------------------
72 //-----------------------------------------------------------------------------
73 //-----------------------------------------------------------------------------
74 BASE_PLUGIN * GetPlugin()
75 {
76 return iac.GetPlugin();
77 }
78 //-----------------------------------------------------------------------------
79 //-----------------------------------------------------------------------------
80 //-----------------------------------------------------------------------------
81 AUTH_IA_SETTINGS::AUTH_IA_SETTINGS()
82     : userDelay(0),
83       userTimeout(0),
84       port(0),
85       freeMbShowType(freeMbCash)
86 {
87 }
88 //-----------------------------------------------------------------------------
89 int AUTH_IA_SETTINGS::ParseIntInRange(const string & str, int min, int max, int * val)
90 {
91 if (str2x(str.c_str(), *val))
92     {
93     errorStr = "Incorrect value \'" + str + "\'.";
94     return -1;
95     }
96 if (*val < min || *val > max)
97     {
98     errorStr = "Value \'" + str + "\' out of range.";
99     return -1;
100     }
101 return 0;
102 }
103 //-----------------------------------------------------------------------------
104 int AUTH_IA_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
105 {
106 int p;
107 PARAM_VALUE pv;
108 vector<PARAM_VALUE>::const_iterator pvi;
109 ///////////////////////////
110 pv.param = "Port";
111 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
112 if (pvi == s.moduleParams.end())
113     {
114     errorStr = "Parameter \'Port\' not found.";
115     printfd(__FILE__, "Parameter 'Port' not found\n");
116     return -1;
117     }
118 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
119     {
120     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
121     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
122     return -1;
123     }
124 port = p;
125 ///////////////////////////
126 pv.param = "UserDelay";
127 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
128 if (pvi == s.moduleParams.end())
129     {
130     errorStr = "Parameter \'UserDelay\' not found.";
131     printfd(__FILE__, "Parameter 'UserDelay' not found\n");
132     return -1;
133     }
134
135 if (ParseIntInRange(pvi->value[0], 5, 600, &userDelay))
136     {
137     errorStr = "Cannot parse parameter \'UserDelay\': " + errorStr;
138     printfd(__FILE__, "Cannot parse parameter 'UserDelay'\n");
139     return -1;
140     }
141 ///////////////////////////
142 pv.param = "UserTimeout";
143 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
144 if (pvi == s.moduleParams.end())
145     {
146     errorStr = "Parameter \'UserTimeout\' not found.";
147     printfd(__FILE__, "Parameter 'UserTimeout' not found\n");
148     return -1;
149     }
150
151 if (ParseIntInRange(pvi->value[0], 15, 1200, &userTimeout))
152     {
153     errorStr = "Cannot parse parameter \'UserTimeout\': " + errorStr;
154     printfd(__FILE__, "Cannot parse parameter 'UserTimeout'\n");
155     return -1;
156     }
157 /////////////////////////////////////////////////////////////
158 string freeMbType;
159 int n = 0;
160 pv.param = "FreeMb";
161 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
162 if (pvi == s.moduleParams.end())
163     {
164     errorStr = "Parameter \'FreeMb\' not found.";
165     printfd(__FILE__, "Parameter 'FreeMb' not found\n");
166     return -1;
167     }
168 freeMbType = pvi->value[0];
169
170 if (strcasecmp(freeMbType.c_str(), "cash") == 0)
171     {
172     freeMbShowType = freeMbCash;
173     }
174 else if (strcasecmp(freeMbType.c_str(), "none") == 0)
175     {
176     freeMbShowType = freeMbNone;
177     }
178 else if (!str2x(freeMbType.c_str(), n))
179     {
180     if (n < 0 || n >= DIR_NUM)
181         {
182         errorStr = "Incorrect parameter \'" + freeMbType + "\'.";
183         printfd(__FILE__, "%s\n", errorStr.c_str());
184         return -1;
185         }
186     freeMbShowType = (FREEMB)(freeMb0 + n);
187     }
188 else
189     {
190     errorStr = "Incorrect parameter \'" + freeMbType + "\'.";
191     printfd(__FILE__, "%s\n", errorStr.c_str());
192     return -1;
193     }
194 /////////////////////////////////////////////////////////////
195 return 0;
196 }
197 //-----------------------------------------------------------------------------
198 //-----------------------------------------------------------------------------
199 //-----------------------------------------------------------------------------
200 #ifdef IA_PHASE_DEBUG
201 IA_PHASE::IA_PHASE()
202     : phase(1),
203       flog(NULL)
204 {
205 gettimeofday(&phaseTime, NULL);
206 }
207 #else
208 IA_PHASE::IA_PHASE()
209     : phase(1)
210 {
211 gettimeofday(&phaseTime, NULL);
212 }
213 #endif
214 //-----------------------------------------------------------------------------
215 IA_PHASE::~IA_PHASE()
216 {
217 #ifdef IA_PHASE_DEBUG
218 flog = fopen(log.c_str(), "at");
219 if (flog)
220     {
221     fprintf(flog, "IA %s D\n", login.c_str());
222     fclose(flog);
223     }
224 #endif
225 }
226 //-----------------------------------------------------------------------------
227 #ifdef IA_PHASE_DEBUG
228 void IA_PHASE::SetLogFileName(const string & logFileName)
229 {
230 log = logFileName + ".ia.log";
231 }
232 //-----------------------------------------------------------------------------
233 void IA_PHASE::SetUserLogin(const string & login)
234 {
235 IA_PHASE::login = login;
236 }
237 //-----------------------------------------------------------------------------
238 void IA_PHASE::WritePhaseChange(int newPhase)
239 {
240 UTIME newPhaseTime;
241 gettimeofday(&newPhaseTime, NULL);
242 flog = fopen(log.c_str(), "at");
243 /*int64_t tn = newPhaseTime.GetSec()*1000000 + newPhaseTime.GetUSec();
244 int64_t to = phaseTime.GetSec()*1000000 + phaseTime.GetUSec();*/
245 if (flog)
246     {
247     string action = newPhase == phase ? "U" : "C";
248     double delta = newPhaseTime.GetSec() - phaseTime.GetSec();
249     delta += (newPhaseTime.GetUSec() - phaseTime.GetUSec()) * 1.0e-6;
250     fprintf(flog, "IA %s %s oldPhase = %d, newPhase = %d. dt = %.6f\n",
251             login.c_str(),
252             action.c_str(),
253             phase,
254             newPhase,
255             delta);
256     fclose(flog);
257     }
258 }
259 #endif
260 //-----------------------------------------------------------------------------
261 void IA_PHASE::SetPhase1()
262 {
263 #ifdef IA_PHASE_DEBUG
264 WritePhaseChange(1);
265 #endif
266 phase = 1;
267 gettimeofday(&phaseTime, NULL);
268 }
269 //-----------------------------------------------------------------------------
270 void IA_PHASE::SetPhase2()
271 {
272 #ifdef IA_PHASE_DEBUG
273 WritePhaseChange(2);
274 #endif
275 phase = 2;
276 gettimeofday(&phaseTime, NULL);
277 }
278 //-----------------------------------------------------------------------------
279 void IA_PHASE::SetPhase3()
280 {
281 #ifdef IA_PHASE_DEBUG
282 WritePhaseChange(3);
283 #endif
284 phase = 3;
285 gettimeofday(&phaseTime, NULL);
286 }
287 //-----------------------------------------------------------------------------
288 void IA_PHASE::SetPhase4()
289 {
290 #ifdef IA_PHASE_DEBUG
291 WritePhaseChange(4);
292 #endif
293 phase = 4;
294 gettimeofday(&phaseTime, NULL);
295 }
296 //-----------------------------------------------------------------------------
297 void IA_PHASE::SetPhase5()
298 {
299 #ifdef IA_PHASE_DEBUG
300 WritePhaseChange(5);
301 #endif
302 phase = 5;
303 gettimeofday(&phaseTime, NULL);
304 }
305 //-----------------------------------------------------------------------------
306 int IA_PHASE::GetPhase() const
307 {
308 return phase;
309 }
310 //-----------------------------------------------------------------------------
311 void IA_PHASE::UpdateTime()
312 {
313 #ifdef IA_PHASE_DEBUG
314 WritePhaseChange(phase);
315 #endif
316 gettimeofday(&phaseTime, NULL);
317 }
318 //-----------------------------------------------------------------------------
319 const UTIME & IA_PHASE::GetTime() const
320 {
321 return phaseTime;
322 }
323 //-----------------------------------------------------------------------------
324 //-----------------------------------------------------------------------------
325 //-----------------------------------------------------------------------------
326 AUTH_IA::AUTH_IA()
327     : nonstop(false),
328       isRunningRun(false),
329       isRunningRunTimeouter(false),
330       users(NULL),
331       stgSettings(NULL),
332       listenSocket(-1),
333       WriteServLog(GetStgLogger()),
334       enabledDirs(0xFFffFFff),
335       onDelUserNotifier(*this)
336 {
337 InitEncrypt(&ctxS, "pr7Hhen");
338
339 pthread_mutexattr_t attr;
340 pthread_mutexattr_init(&attr);
341 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
342 pthread_mutex_init(&mutex, &attr);
343
344 memset(&connSynAck6, 0, sizeof(CONN_SYN_ACK_6));
345 memset(&connSynAck8, 0, sizeof(CONN_SYN_ACK_8));
346 memset(&disconnSynAck6, 0, sizeof(DISCONN_SYN_ACK_6));
347 memset(&disconnSynAck8, 0, sizeof(DISCONN_SYN_ACK_8));
348 memset(&aliveSyn6, 0, sizeof(ALIVE_SYN_6));
349 memset(&aliveSyn8, 0, sizeof(ALIVE_SYN_8));
350 memset(&fin6, 0, sizeof(FIN_6));
351 memset(&fin8, 0, sizeof(FIN_8));
352
353 printfd(__FILE__, "sizeof(CONN_SYN_6) = %d %d\n",           sizeof(CONN_SYN_6),     Min8(sizeof(CONN_SYN_6)));
354 printfd(__FILE__, "sizeof(CONN_SYN_8) = %d %d\n",           sizeof(CONN_SYN_8),     Min8(sizeof(CONN_SYN_8)));
355 printfd(__FILE__, "sizeof(CONN_SYN_ACK_6) = %d %d\n",       sizeof(CONN_SYN_ACK_6), Min8(sizeof(CONN_SYN_ACK_6)));
356 printfd(__FILE__, "sizeof(CONN_SYN_ACK_8) = %d %d\n",       sizeof(CONN_SYN_ACK_8), Min8(sizeof(CONN_SYN_ACK_8)));
357 printfd(__FILE__, "sizeof(CONN_ACK_6) = %d %d\n",           sizeof(CONN_ACK_6),     Min8(sizeof(CONN_ACK_6)));
358 printfd(__FILE__, "sizeof(ALIVE_SYN_6) = %d %d\n",          sizeof(ALIVE_SYN_6),    Min8(sizeof(ALIVE_SYN_6)));
359 printfd(__FILE__, "sizeof(ALIVE_SYN_8) = %d %d\n",          sizeof(ALIVE_SYN_8),    Min8(sizeof(ALIVE_SYN_8)));
360 printfd(__FILE__, "sizeof(ALIVE_ACK_6) = %d %d\n",          sizeof(ALIVE_ACK_6),    Min8(sizeof(ALIVE_ACK_6)));
361 printfd(__FILE__, "sizeof(DISCONN_SYN_6) = %d %d\n",        sizeof(DISCONN_SYN_6),  Min8(sizeof(DISCONN_SYN_6)));
362 printfd(__FILE__, "sizeof(DISCONN_SYN_ACK_6) = %d %d\n",    sizeof(DISCONN_SYN_ACK_6), Min8(sizeof(DISCONN_SYN_ACK_6)));
363 printfd(__FILE__, "sizeof(DISCONN_SYN_ACK_8) = %d %d\n",    sizeof(DISCONN_SYN_ACK_8), Min8(sizeof(DISCONN_SYN_ACK_8)));
364 printfd(__FILE__, "sizeof(DISCONN_ACK_6) = %d %d\n",        sizeof(DISCONN_ACK_6),  Min8(sizeof(DISCONN_ACK_6)));
365 printfd(__FILE__, "sizeof(FIN_6) = %d %d\n",                sizeof(FIN_6),          Min8(sizeof(FIN_6)));
366 printfd(__FILE__, "sizeof(FIN_8) = %d %d\n",                sizeof(FIN_8),          Min8(sizeof(FIN_8)));
367 printfd(__FILE__, "sizeof(ERR) = %d %d\n",                  sizeof(ERR),            Min8(sizeof(ERR)));
368 printfd(__FILE__, "sizeof(INFO_6) = %d %d\n",               sizeof(INFO_6),         Min8(sizeof(INFO_6)));
369 printfd(__FILE__, "sizeof(INFO_7) = %d %d\n",               sizeof(INFO_7),         Min8(sizeof(INFO_7)));
370 printfd(__FILE__, "sizeof(INFO_8) = %d %d\n",               sizeof(INFO_8),         Min8(sizeof(INFO_8)));
371
372 packetTypes["CONN_SYN"] = CONN_SYN_N;
373 packetTypes["CONN_SYN_ACK"] = CONN_SYN_ACK_N;
374 packetTypes["CONN_ACK"] = CONN_ACK_N;
375 packetTypes["ALIVE_SYN"] = ALIVE_SYN_N;
376 packetTypes["ALIVE_ACK"] = ALIVE_ACK_N;
377 packetTypes["DISCONN_SYN"] = DISCONN_SYN_N;
378 packetTypes["DISCONN_SYN_ACK"] = DISCONN_SYN_ACK_N;
379 packetTypes["DISCONN_ACK"] = DISCONN_ACK_N;
380 packetTypes["FIN"] = FIN_N;
381 packetTypes["ERR"] = ERROR_N;
382 }
383 //-----------------------------------------------------------------------------
384 AUTH_IA::~AUTH_IA()
385 {
386 pthread_mutex_destroy(&mutex);
387 }
388 //-----------------------------------------------------------------------------
389 int AUTH_IA::Start()
390 {
391 users->AddNotifierUserDel(&onDelUserNotifier);
392 nonstop = true;
393
394 if (PrepareNet())
395     {
396     return -1;
397     }
398
399 if (!isRunningRun)
400     {
401     if (pthread_create(&recvThread, NULL, Run, this))
402         {
403         errorStr = "Cannot create thread.";
404         printfd(__FILE__, "Cannot create recv thread\n");
405         return -1;
406         }
407     }
408
409 if (!isRunningRunTimeouter)
410     {
411     if (pthread_create(&timeouterThread, NULL, RunTimeouter, this))
412         {
413         errorStr = "Cannot create thread.";
414         printfd(__FILE__, "Cannot create timeouter thread\n");
415         return -1;
416         }
417     }
418 errorStr = "";
419 return 0;
420 }
421 //-----------------------------------------------------------------------------
422 int AUTH_IA::Stop()
423 {
424 if (!IsRunning())
425     return 0;
426
427 nonstop = false;
428
429 std::for_each(
430         ip2user.begin(),
431         ip2user.end(),
432         UnauthorizeUser(this)
433         );
434
435 if (isRunningRun)
436     {
437     //5 seconds to thread stops itself
438     for (int i = 0; i < 25 && isRunningRun; i++)
439         {
440         usleep(200000);
441         }
442
443     //after 5 seconds waiting thread still running. now killing it
444     if (isRunningRun)
445         {
446         //TODO pthread_cancel()
447         if (pthread_kill(recvThread, SIGINT))
448             {
449             errorStr = "Cannot kill thread.";
450             printfd(__FILE__, "Cannot kill thread\n");
451             return -1;
452             }
453         for (int i = 0; i < 25 && isRunningRun; ++i)
454             usleep(200000);
455         if (isRunningRun)
456             {
457             printfd(__FILE__, "Failed to stop recv thread\n");
458             }
459         else
460             {
461             pthread_join(recvThread, NULL);
462             }
463         printfd(__FILE__, "AUTH_IA killed Run\n");
464         }
465     }
466
467 FinalizeNet();
468
469 if (isRunningRunTimeouter)
470     {
471     //5 seconds to thread stops itself
472     for (int i = 0; i < 25 && isRunningRunTimeouter; i++)
473         {
474         usleep(200000);
475         }
476
477     //after 5 seconds waiting thread still running. now killing it
478     if (isRunningRunTimeouter)
479         {
480         //TODO pthread_cancel()
481         if (pthread_kill(timeouterThread, SIGINT))
482             {
483             errorStr = "Cannot kill thread.";
484             return -1;
485             }
486         for (int i = 0; i < 25 && isRunningRunTimeouter; ++i)
487             usleep(200000);
488         if (isRunningRunTimeouter)
489             {
490             printfd(__FILE__, "Failed to stop timeouter thread\n");
491             }
492         else
493             {
494             pthread_join(timeouterThread, NULL);
495             }
496         printfd(__FILE__, "AUTH_IA killed Timeouter\n");
497         }
498     }
499 printfd(__FILE__, "AUTH_IA::Stoped successfully.\n");
500 users->DelNotifierUserDel(&onDelUserNotifier);
501 return 0;
502 }
503 //-----------------------------------------------------------------------------
504 void * AUTH_IA::Run(void * d)
505 {
506 AUTH_IA * ia = static_cast<AUTH_IA *>(d);
507
508 ia->isRunningRun = true;
509
510 char buffer[512];
511
512 time_t touchTime = stgTime - MONITOR_TIME_DELAY_SEC;
513
514 while (ia->nonstop)
515     {
516     ia->RecvData(buffer, sizeof(buffer));
517     if ((touchTime + MONITOR_TIME_DELAY_SEC <= stgTime) && ia->stgSettings->GetMonitoring())
518         {
519         touchTime = stgTime;
520         string monFile = ia->stgSettings->GetMonitorDir() + "/inetaccess_r";
521         TouchFile(monFile.c_str());
522         }
523     }
524
525 ia->isRunningRun = false;
526 return NULL;
527 }
528 //-----------------------------------------------------------------------------
529 void * AUTH_IA::RunTimeouter(void * d)
530 {
531 AUTH_IA * ia = static_cast<AUTH_IA *>(d);
532
533 ia->isRunningRunTimeouter = true;
534
535 int a = -1;
536 string monFile = ia->stgSettings->GetMonitorDir() + "/inetaccess_t";
537 while (ia->nonstop)
538     {
539     usleep(20000);
540     ia->Timeouter();
541     // TODO cahange counter to timer and MONITOR_TIME_DELAY_SEC
542     if (++a % (50*60) == 0 && ia->stgSettings->GetMonitoring())
543         {
544         TouchFile(monFile.c_str());
545         }
546     }
547
548 ia->isRunningRunTimeouter = false;
549 return NULL;
550 }
551 //-----------------------------------------------------------------------------
552 int AUTH_IA::ParseSettings()
553 {
554 int ret = iaSettings.ParseSettings(settings);
555 if (ret)
556     errorStr = iaSettings.GetStrError();
557 return ret;
558 }
559 //-----------------------------------------------------------------------------
560 int AUTH_IA::PrepareNet()
561 {
562 struct sockaddr_in listenAddr;
563
564 listenSocket = socket(AF_INET, SOCK_DGRAM, 0);
565
566 if (listenSocket < 0)
567     {
568     errorStr = "Cannot create socket.";
569     return -1;
570     }
571
572 listenAddr.sin_family = AF_INET;
573 listenAddr.sin_port = htons(iaSettings.GetUserPort());
574 listenAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
575
576 if (bind(listenSocket, (struct sockaddr*)&listenAddr, sizeof(listenAddr)) < 0)
577     {
578     errorStr = "AUTH_IA: Bind failed.";
579     return -1;
580     }
581
582 /*int buffLen;
583 if (getsockopt(listenSocket, SOL_SOCKET, SO_SNDBUF, &buffLen, sizeof(buffLen)) < 0)
584     {
585
586     errorStr = "Getsockopt failed. " + string(strerror(errno));
587     return -1;
588     }*/
589
590 //WriteServLog("buffLen = %d", buffLen);
591
592 return 0;
593 }
594 //-----------------------------------------------------------------------------
595 int AUTH_IA::FinalizeNet()
596 {
597 close(listenSocket);
598 return 0;
599 }
600 //-----------------------------------------------------------------------------
601 int AUTH_IA::RecvData(char * buffer, int bufferSize)
602 {
603 if (!WaitPackets(listenSocket)) // Timeout
604     {
605     return 0;
606     }
607
608 struct sockaddr_in outerAddr;
609 socklen_t outerAddrLen(sizeof(outerAddr));
610 int dataLen = recvfrom(listenSocket, buffer, bufferSize, 0, (struct sockaddr *)&outerAddr, &outerAddrLen);
611
612 if (!dataLen) // EOF
613     {
614     return 0;
615     }
616
617 if (dataLen <= 0) // Error
618     {
619     if (errno != EINTR)
620         {
621         printfd(__FILE__, "recvfrom res=%d, error: '%s'\n", dataLen, strerror(errno));
622         return -1;
623         }
624     return 0;
625     }
626
627 if (dataLen > 256)
628     return -1;
629
630 int protoVer;
631 if (CheckHeader(buffer, &protoVer))
632     return -1;
633
634 char login[PASSWD_LEN];  //TODO why PASSWD_LEN ?
635 memset(login, 0, PASSWD_LEN);
636
637 Decrypt(&ctxS, login, buffer + 8, PASSWD_LEN / 8);
638
639 uint32_t sip = *((uint32_t*)&outerAddr.sin_addr);
640 uint16_t sport = htons(outerAddr.sin_port);
641
642 user_iter user;
643 if (users->FindByName(login, &user) == 0)
644     {
645     printfd(__FILE__, "User %s FOUND!\n", user->GetLogin().c_str());
646     PacketProcessor(buffer, dataLen, sip, sport, protoVer, &user);
647     }
648 else
649     {
650     WriteServLog("User\'s connect failed:: user \'%s\' not found. IP \'%s\'",
651                  login,
652                  inet_ntostring(sip).c_str());
653     printfd(__FILE__, "User %s NOT found!\n", login);
654     SendError(sip, sport, protoVer, "îÅÐÒÁ×ÉÌØÎÙÊ ÌÏÇÉΠÉÌÉ ÐÁÒÏÌØ!");
655     }
656
657 return 0;
658
659 }
660 //-----------------------------------------------------------------------------
661 int AUTH_IA::CheckHeader(const char * buffer, int * protoVer)
662 {
663 if (strncmp(IA_ID, buffer, strlen(IA_ID)) != 0)
664     {
665     //SendError(userIP, updateMsg);
666     printfd(__FILE__, "update needed - IA_ID\n");
667     //SendError(userIP, "Incorrect header!");
668     return -1;
669     }
670
671 if (buffer[6] != 0) //proto[0] shoud be 0
672     {
673     printfd(__FILE__, "update needed - PROTO major: %d\n", buffer[6]);
674     //SendError(userIP, updateMsg);
675     return -1;
676     }
677
678 if (buffer[7] < 6)
679     {
680     // need update
681     //SendError(userIP, updateMsg);
682     printfd(__FILE__, "update needed - PROTO minor: %d\n", buffer[7]);
683     return -1;
684     }
685 else
686     {
687     *protoVer = buffer[7];
688     }
689 return 0;
690 }
691 //-----------------------------------------------------------------------------
692 int AUTH_IA::Timeouter()
693 {
694 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
695
696 map<uint32_t, IA_USER>::iterator it;
697 it = ip2user.begin();
698 uint32_t sip;
699
700 while (it != ip2user.end())
701     {
702     sip = it->first;
703
704     static UTIME currTime;
705     gettimeofday(&currTime, NULL);
706
707     if ((it->second.phase.GetPhase() == 2)
708         && (currTime - it->second.phase.GetTime()) > iaSettings.GetUserDelay())
709         {
710         it->second.phase.SetPhase1();
711         printfd(__FILE__, "Phase changed from 2 to 1. Reason: timeout\n");
712         }
713
714     if (it->second.phase.GetPhase() == 3)
715         {
716         if (!it->second.messagesToSend.empty())
717             {
718             if (it->second.protoVer == 6)
719                 RealSendMessage6(*it->second.messagesToSend.begin(), sip, it->second);
720
721             if (it->second.protoVer == 7)
722                 RealSendMessage7(*it->second.messagesToSend.begin(), sip, it->second);
723
724             if (it->second.protoVer == 8)
725                 RealSendMessage8(*it->second.messagesToSend.begin(), sip, it->second);
726
727             it->second.messagesToSend.erase(it->second.messagesToSend.begin());
728             }
729
730         if((currTime - it->second.lastSendAlive) > iaSettings.GetUserDelay())
731             {
732             switch (it->second.protoVer)
733                 {
734                 case 6:
735                     Send_ALIVE_SYN_6(&(it->second), sip);
736                     break;
737                 case 7:
738                     Send_ALIVE_SYN_7(&(it->second), sip);
739                     break;
740                 case 8:
741                     Send_ALIVE_SYN_8(&(it->second), sip);
742                     break;
743                 }
744
745             gettimeofday(&it->second.lastSendAlive, NULL);
746             }
747
748         if ((currTime - it->second.phase.GetTime()) > iaSettings.GetUserTimeout())
749             {
750             it->second.user->Unauthorize(this);
751             ip2user.erase(it++);
752             continue;
753             }
754         }
755
756     if ((it->second.phase.GetPhase() == 4)
757         && ((currTime - it->second.phase.GetTime()) > iaSettings.GetUserDelay()))
758         {
759         it->second.phase.SetPhase3();
760         printfd(__FILE__, "Phase changed from 4 to 3. Reason: timeout\n");
761         }
762
763     ++it;
764     }
765
766 return 0;
767 }
768 //-----------------------------------------------------------------------------
769 int AUTH_IA::PacketProcessor(char * buff, int dataLen, uint32_t sip, uint16_t sport, int protoVer, user_iter * user)
770 {
771 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
772 // ôÕÔ ÓÏÂÒÁÎÙ ÏÂÒÁÂÏÔÞÉËÉ ÒÁÚÎÙÈ ÐÁËÅÔÏ×
773 int pn = -1;
774 const int offset = LOGIN_LEN + 2 + 6; // LOGIN_LEN + sizeOfMagic + sizeOfVer;
775
776 IA_USER * iaUser = NULL;
777
778 CONN_SYN_6 * connSyn6;
779 CONN_SYN_7 * connSyn7;
780 CONN_SYN_8 * connSyn8;
781
782 CONN_ACK_6 * connAck;
783 ALIVE_ACK_6 * aliveAck;
784 DISCONN_SYN_6 * disconnSyn;
785 DISCONN_ACK_6 * disconnAck;
786
787 map<uint32_t, IA_USER>::iterator it;
788 it = ip2user.find(sip);
789
790 if (it == ip2user.end() || (*user)->GetID() != it->second.user->GetID())
791     {
792     // åÝÅ ÎÅ ÂÙÌÏ ÚÁÐÒÏÓÏ× Ó ÜÔÏÇÏ IP
793     printfd(__FILE__, "Add new user\n");
794     ip2user[sip].protoVer = protoVer;
795     ip2user[sip].user = *user;
796     ip2user[sip].port = sport;
797     #ifdef IA_PHASE_DEBUG
798     ip2user[sip].phase.SetLogFileName(stgSettings->GetLogFileName());
799     ip2user[sip].phase.SetUserLogin((*user)->GetLogin());
800     #endif
801
802
803     it = ip2user.find(sip); //TODO
804     if (it == ip2user.end())
805         {
806         printfd(__FILE__, "+++ ERROR +++\n");
807         return -1;
808         }
809     }
810
811 iaUser = &(it->second);
812
813 if (iaUser->port != sport)
814     iaUser->port = sport;
815
816 if (iaUser->password != (*user)->property.password.Get())
817     {
818     InitEncrypt(&iaUser->ctx, (*user)->property.password.Get());
819     iaUser->password = (*user)->property.password.Get();
820     }
821
822 buff += offset;
823 Decrypt(&iaUser->ctx, buff, buff, (dataLen - offset) / 8);
824
825 char packetName[IA_MAX_TYPE_LEN];
826 strncpy(packetName,  buff + 4, IA_MAX_TYPE_LEN);
827 packetName[IA_MAX_TYPE_LEN - 1] = 0;
828
829 map<string, int>::iterator pi;
830 pi = packetTypes.find(packetName);
831 if (pi == packetTypes.end())
832     {
833     SendError(sip, sport, protoVer, "îÅÐÒÁ×ÉÌØÎÙÊ ÌÏÇÉΠÉÌÉ ÐÁÒÏÌØ!");
834     printfd(__FILE__, "Login or password is wrong!\n");
835     WriteServLog("User's connect failed. IP \'%s\'. Wrong login or password", inet_ntostring(sip).c_str());
836     return 0;
837     }
838 else
839     {
840     pn = pi->second;
841     }
842
843 if ((*user)->property.disabled.Get())
844     {
845     SendError(sip, sport, protoVer, "õÞÅÔÎÁÑ ÚÁÐÉÓØ ÚÁÂÌÏËÉÒÏ×ÁÎÁ");
846     return 0;
847     }
848
849 if ((*user)->property.passive.Get())
850     {
851     SendError(sip, sport, protoVer, "õÞÅÔÎÁÑ ÚÁÐÉÓØ ÚÁÍÏÒÏÖÅÎÁ");
852     return 0;
853     }
854
855 if ((*user)->GetAuthorized() && (*user)->GetCurrIP() != sip)
856     {
857     printfd(__FILE__, "Login %s alredy in use. IP \'%s\'\n", (*user)->GetLogin().c_str(), inet_ntostring(sip).c_str());
858     WriteServLog("Login %s alredy in use. IP \'%s\'", (*user)->GetLogin().c_str(), inet_ntostring(sip).c_str());
859     SendError(sip, sport, protoVer, "÷ÁÛ ÌÏÇÉΠÕÖÅ ÉÓÐÏÌØÚÕÅÔÓÑ!");
860     return 0;
861     }
862
863 user_iter u;
864 if (users->FindByIPIdx(sip, &u) == 0 && u->GetLogin() != (*user)->GetLogin())
865     {
866     printfd(__FILE__, "IP address alredy in use. IP \'%s\'", inet_ntostring(sip).c_str());
867     WriteServLog("IP address alredy in use. IP \'%s\'", inet_ntostring(sip).c_str());
868     SendError(sip, sport, protoVer, "÷ÁÛ IP ÁÄÒÅÓ ÕÖÅ ÉÓÐÏÌØÚÕÅÔÓÑ!");
869     return 0;
870     }
871
872 // ôÅÐÅÒØ ÍÙ ÄÏÌÖÎÙ ÐÒÏ×ÅÒÉÔØ, ÍÏÖÅÔ ÌÉ ÐÏÌØÚÏ×ÁÔÅÌØ ÐÏÄËÌÀÞÉÔÓÑ Ó ÜÔÏÇÏ ÁÄÒÅÓÁ.
873 int ipFound = (*user)->property.ips.Get().IsIPInIPS(sip);
874 if (!ipFound)
875     {
876     printfd(__FILE__, "User %s. IP address is incorrect. IP \'%s\'\n", (*user)->GetLogin().c_str(), inet_ntostring(sip).c_str());
877     WriteServLog("User %s. IP address is incorrect. IP \'%s\'", (*user)->GetLogin().c_str(), inet_ntostring(sip).c_str());
878     SendError(sip, sport, protoVer, "ðÏÌØÚÏ×ÁÔÅÌØ ÎÅ ÏÐÏÚÎÁÎ! ðÒÏ×ÅÒØÔÅ IP ÁÄÒÅÓ.");
879     return 0;
880     }
881
882 int ret = -1;
883
884 switch (pn)
885     {
886     case CONN_SYN_N:
887         switch (protoVer)
888             {
889             case 6:
890                 connSyn6 = (CONN_SYN_6*)(buff - offset);
891                 ret = Process_CONN_SYN_6(connSyn6, &(it->second), user, sip);
892                 break;
893             case 7:
894                 connSyn7 = (CONN_SYN_7*)(buff - offset);
895                 ret = Process_CONN_SYN_7(connSyn7, &(it->second), user, sip);
896                 break;
897             case 8:
898                 connSyn8 = (CONN_SYN_8*)(buff - offset);
899                 ret = Process_CONN_SYN_8(connSyn8, &(it->second), user, sip);
900                 break;
901             }
902
903         if (ret != 0)
904             {
905             return 0;
906             }
907         switch (protoVer)
908             {
909             case 6:
910                 Send_CONN_SYN_ACK_6(iaUser, user, sip);
911                 break;
912             case 7:
913                 Send_CONN_SYN_ACK_7(iaUser, user, sip);
914                 break;
915             case 8:
916                 Send_CONN_SYN_ACK_8(iaUser, user, sip);
917                 break;
918             }
919         break;
920
921     case CONN_ACK_N:
922         connAck = (CONN_ACK_6*)(buff - offset);
923         switch (protoVer)
924             {
925             case 6:
926                 ret = Process_CONN_ACK_6(connAck, iaUser, user, sip);
927                 break;
928             case 7:
929                 ret = Process_CONN_ACK_7(connAck, iaUser, user, sip);
930                 break;
931             case 8:
932                 ret = Process_CONN_ACK_8((CONN_ACK_8*)(buff - offset), iaUser, user, sip);
933                 break;
934             }
935
936         if (ret != 0)
937             {
938             SendError(sip, sport, protoVer, errorStr);
939             return 0;
940             }
941
942         switch (protoVer)
943             {
944             case 6:
945                 Send_ALIVE_SYN_6(iaUser, sip);
946                 break;
947             case 7:
948                 Send_ALIVE_SYN_7(iaUser, sip);
949                 break;
950             case 8:
951                 Send_ALIVE_SYN_8(iaUser, sip);
952                 break;
953             }
954
955         break;
956
957         // ðÒÉÂÙÌ ÏÔ×ÅÔ Ó ÐÏÄÔ×ÅÒÖÄÅÎÉÅÍ ALIVE
958     case ALIVE_ACK_N:
959         aliveAck = (ALIVE_ACK_6*)(buff - offset);
960         switch (protoVer)
961             {
962             case 6:
963                 ret = Process_ALIVE_ACK_6(aliveAck, iaUser, user, sip);
964                 break;
965             case 7:
966                 ret = Process_ALIVE_ACK_7(aliveAck, iaUser, user, sip);
967                 break;
968             case 8:
969                 ret = Process_ALIVE_ACK_8((ALIVE_ACK_8*)(buff - offset), iaUser, user, sip);
970                 break;
971             }
972         break;
973
974         // úÁÐÒÏÓ ÎÁ ÏÔËÌÀÞÅÎÉÅ
975     case DISCONN_SYN_N:
976
977         disconnSyn = (DISCONN_SYN_6*)(buff - offset);
978         switch (protoVer)
979             {
980             case 6:
981                 ret = Process_DISCONN_SYN_6(disconnSyn, iaUser, user, sip);
982                 break;
983             case 7:
984                 ret = Process_DISCONN_SYN_7(disconnSyn, iaUser, user, sip);
985                 break;
986             case 8:
987                 ret = Process_DISCONN_SYN_8((DISCONN_SYN_8*)(buff - offset), iaUser, user, sip);
988                 break;
989             }
990
991         if (ret != 0)
992             return 0;
993
994         switch (protoVer)
995             {
996             case 6:
997                 Send_DISCONN_SYN_ACK_6(iaUser, sip);
998                 break;
999             case 7:
1000                 Send_DISCONN_SYN_ACK_7(iaUser, sip);
1001                 break;
1002             case 8:
1003                 Send_DISCONN_SYN_ACK_8(iaUser, sip);
1004                 break;
1005             }
1006         break;
1007
1008     case DISCONN_ACK_N:
1009         disconnAck = (DISCONN_ACK_6*)(buff - offset);
1010
1011         switch (protoVer)
1012             {
1013             case 6:
1014                 ret = Process_DISCONN_ACK_6(disconnAck, iaUser, user, sip, it);
1015                 break;
1016             case 7:
1017                 ret = Process_DISCONN_ACK_7(disconnAck, iaUser, user, sip, it);
1018                 break;
1019             case 8:
1020                 ret = Process_DISCONN_ACK_8((DISCONN_ACK_8*)(buff - offset), iaUser, user, sip, it);
1021                 break;
1022             }
1023
1024         switch (protoVer)
1025             {
1026             case 6:
1027                 Send_FIN_6(iaUser, sip, it);
1028                 break;
1029             case 7:
1030                 Send_FIN_7(iaUser, sip, it);
1031                 break;
1032             case 8:
1033                 Send_FIN_8(iaUser, sip, it);
1034                 break;
1035             }
1036         break;
1037     }
1038
1039 return 0;
1040 }
1041 //-----------------------------------------------------------------------------
1042 void AUTH_IA::DelUser(user_iter u)
1043 {
1044 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1045
1046 uint32_t ip = u->GetCurrIP();
1047
1048 if (!ip)
1049     return;
1050
1051 map<uint32_t, IA_USER>::iterator it;
1052 it = ip2user.find(ip);
1053 if (it == ip2user.end())
1054     {
1055     //Nothing to delete
1056     printfd(__FILE__, "Nothing to delete\n");
1057     return;
1058     }
1059
1060 if (it->second.user == u)
1061     {
1062     printfd(__FILE__, "User removed!\n");
1063     it->second.user->Unauthorize(this);
1064     ip2user.erase(it);
1065     }
1066 }
1067 //-----------------------------------------------------------------------------
1068 int AUTH_IA::SendError(uint32_t ip, uint16_t port, int protoVer, const string & text)
1069 {
1070 struct sockaddr_in sendAddr;
1071 switch (protoVer)
1072     {
1073     int res;
1074     case 6:
1075     case 7:
1076         ERR err;
1077         memset(&err, 0, sizeof(ERR));
1078
1079         sendAddr.sin_family = AF_INET;
1080         sendAddr.sin_port = htons(port);
1081
1082         sendAddr.sin_addr.s_addr = ip;// IP ÐÏÌØÚÏ×ÁÔÅÌÑ
1083
1084         err.len = 1;
1085         strncpy((char*)err.type, "ERR", 16);
1086         strncpy((char*)err.text, text.c_str(), MAX_MSG_LEN);
1087
1088         #ifdef ARCH_BE
1089         SwapBytes(err.len);
1090         #endif
1091
1092         res = sendto(listenSocket, &err, sizeof(err), 0, (struct sockaddr*)&sendAddr, sizeof(sendAddr));
1093         printfd(__FILE__, "SendError %d bytes sent\n", res);
1094         break;
1095
1096     case 8:
1097         ERR_8 err8;
1098         memset(&err8, 0, sizeof(ERR_8));
1099
1100         sendAddr.sin_family = AF_INET;
1101         sendAddr.sin_port = htons(port);
1102
1103         sendAddr.sin_addr.s_addr = ip;// IP ÐÏÌØÚÏ×ÁÔÅÌÑ
1104
1105         err8.len = 256;
1106         strncpy((char*)err8.type, "ERR", 16);
1107         strncpy((char*)err8.text, text.c_str(), MAX_MSG_LEN);
1108
1109         #ifdef ARCH_BE
1110         SwapBytes(err8.len);
1111         #endif
1112
1113         res = sendto(listenSocket, &err8, sizeof(err8), 0, (struct sockaddr*)&sendAddr, sizeof(sendAddr));
1114         printfd(__FILE__, "SendError_8 %d bytes sent\n", res);
1115         break;
1116     }
1117
1118 return 0;
1119 }
1120 //-----------------------------------------------------------------------------
1121 int AUTH_IA::Send(uint32_t ip, uint16_t port, const char * buffer, int len)
1122 {
1123 struct sockaddr_in sendAddr;
1124 int res;
1125
1126 sendAddr.sin_family = AF_INET;
1127 sendAddr.sin_port = htons(port);
1128 sendAddr.sin_addr.s_addr = ip;
1129
1130 res = sendto(listenSocket, buffer, len, 0, (struct sockaddr*)&sendAddr, sizeof(sendAddr));
1131
1132 static struct timeval tv;
1133 gettimeofday(&tv, NULL);
1134
1135 return res;
1136 }
1137 //-----------------------------------------------------------------------------
1138 int AUTH_IA::SendMessage(const STG_MSG & msg, uint32_t ip) const
1139 {
1140 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1141
1142 printfd(__FILE__, "SendMessage userIP=%s\n", inet_ntostring(ip).c_str());
1143
1144 map<uint32_t, IA_USER>::iterator it;
1145 it = ip2user.find(ip);
1146 if (it == ip2user.end())
1147     {
1148     errorStr = "Unknown user.";
1149     return -1;
1150     }
1151 it->second.messagesToSend.push_back(msg);
1152 return 0;
1153 }
1154 //-----------------------------------------------------------------------------
1155 int AUTH_IA::RealSendMessage6(const STG_MSG & msg, uint32_t ip, IA_USER & user)
1156 {
1157 printfd(__FILE__, "RealSendMessage 6 user=%s\n", user.user->GetLogin().c_str());
1158
1159 char buffer[256];
1160 INFO_6 info;
1161
1162 memset(&info, 0, sizeof(INFO_6));
1163
1164 info.len = 256;
1165 strncpy((char*)info.type, "INFO", 16);
1166 info.infoType = 'I';
1167 strncpy((char*)info.text, msg.text.c_str(), 235);
1168 info.text[234] = 0;
1169
1170 size_t len = info.len;
1171 #ifdef ARCH_BE
1172 SwapBytes(info.len);
1173 #endif
1174
1175 memcpy(buffer, &info, sizeof(INFO_6));
1176 Encrypt(&user.ctx, buffer, buffer, len / 8);
1177 Send(ip, iaSettings.GetUserPort(), buffer, len);
1178
1179 return 0;
1180 }
1181 //-----------------------------------------------------------------------------
1182 int AUTH_IA::RealSendMessage7(const STG_MSG & msg, uint32_t ip, IA_USER & user)
1183 {
1184 printfd(__FILE__, "RealSendMessage 7 user=%s\n", user.user->GetLogin().c_str());
1185
1186 char buffer[300];
1187 INFO_7 info;
1188
1189 memset(&info, 0, sizeof(INFO_7));
1190
1191 info.len = 264;
1192 strncpy((char*)info.type, "INFO_7", 16);
1193 info.infoType = msg.header.type;
1194 info.showTime = msg.header.showTime;
1195
1196 info.sendTime = msg.header.creationTime;
1197
1198 size_t len = info.len;
1199 #ifdef ARCH_BE
1200 SwapBytes(info.len);
1201 SwapBytes(info.sendTime);
1202 #endif
1203
1204 strncpy((char*)info.text, msg.text.c_str(), MAX_MSG_LEN - 1);
1205 info.text[MAX_MSG_LEN - 1] = 0;
1206
1207 memcpy(buffer, &info, sizeof(INFO_7));
1208
1209 Encrypt(&user.ctx, buffer, buffer, len / 8);
1210 Send(ip, iaSettings.GetUserPort(), buffer, len);
1211
1212 return 0;
1213 }
1214 //-----------------------------------------------------------------------------
1215 int AUTH_IA::RealSendMessage8(const STG_MSG & msg, uint32_t ip, IA_USER & user)
1216 {
1217 printfd(__FILE__, "RealSendMessage 8 user=%s\n", user.user->GetLogin().c_str());
1218
1219 char buffer[1500];
1220 memset(buffer, 0, sizeof(buffer));
1221
1222 INFO_8 info;
1223
1224 memset(&info, 0, sizeof(INFO_8));
1225
1226 info.len = 1056;
1227 strncpy((char*)info.type, "INFO_8", 16);
1228 info.infoType = msg.header.type;
1229 info.showTime = msg.header.showTime;
1230 info.sendTime = msg.header.creationTime;
1231
1232 strncpy((char*)info.text, msg.text.c_str(), IA_MAX_MSG_LEN_8 - 1);
1233 info.text[IA_MAX_MSG_LEN_8 - 1] = 0;
1234
1235 size_t len = info.len;
1236 #ifdef ARCH_BE
1237 SwapBytes(info.len);
1238 SwapBytes(info.sendTime);
1239 #endif
1240
1241 memcpy(buffer, &info, sizeof(INFO_8));
1242
1243 Encrypt(&user.ctx, buffer, buffer, len / 8);
1244 Send(ip, user.port, buffer, len);
1245
1246 return 0;
1247 }
1248 //-----------------------------------------------------------------------------
1249 int AUTH_IA::Process_CONN_SYN_6(CONN_SYN_6 *, IA_USER * iaUser, user_iter *, uint32_t)
1250 {
1251 if (!(iaUser->phase.GetPhase() == 1 || iaUser->phase.GetPhase() == 3))
1252     return -1;
1253
1254 enabledDirs = 0xFFffFFff;
1255
1256 iaUser->phase.SetPhase2();
1257 printfd(__FILE__, "Phase changed from %d to 2. Reason: CONN_SYN_6\n", iaUser->phase.GetPhase());
1258 return 0;
1259 }
1260 //-----------------------------------------------------------------------------
1261 int AUTH_IA::Process_CONN_SYN_7(CONN_SYN_7 * connSyn, IA_USER * iaUser, user_iter * user, uint32_t sip)
1262 {
1263 return Process_CONN_SYN_6(connSyn, iaUser, user, sip);
1264 }
1265 //-----------------------------------------------------------------------------
1266 int AUTH_IA::Process_CONN_SYN_8(CONN_SYN_8 * connSyn, IA_USER * iaUser, user_iter * user, uint32_t sip)
1267 {
1268 #ifdef ARCH_BE
1269 SwapBytes(connSyn->dirs);
1270 #endif
1271 int ret = Process_CONN_SYN_6((CONN_SYN_6*)connSyn, iaUser, user, sip);
1272 enabledDirs = connSyn->dirs;
1273 return ret;
1274 }
1275 //-----------------------------------------------------------------------------
1276 int AUTH_IA::Process_CONN_ACK_6(CONN_ACK_6 * connAck, IA_USER * iaUser, user_iter *, uint32_t sip)
1277 {
1278 #ifdef ARCH_BE
1279 SwapBytes(connAck->len);
1280 SwapBytes(connAck->rnd);
1281 #endif
1282 printfd( __FILE__, "CONN_ACK_6 %s\n", connAck->type);
1283 // ÕÓÔÁÎÏ×ÉÔØ ÎÏ×ÕÀ ÆÁÚÕ É ×ÒÅÍÑ É ÒÁÚÒÅÛÉÔØ ÉÎÅÔ
1284 if ((iaUser->phase.GetPhase() == 2) && (connAck->rnd == iaUser->rnd + 1))
1285     {
1286     iaUser->phase.UpdateTime();
1287
1288     iaUser->lastSendAlive = iaUser->phase.GetTime();
1289     if (iaUser->user->Authorize(sip, "", enabledDirs, this) == 0)
1290         {
1291         iaUser->phase.SetPhase3();
1292         printfd(__FILE__, "Phase changed from 2 to 3. Reason: CONN_ACK_6\n");
1293         return 0;
1294         }
1295     else
1296         {
1297         errorStr = iaUser->user->GetStrError();
1298         iaUser->phase.SetPhase1();
1299         printfd(__FILE__, "Phase changed from 2 to 1. Reason: failed to authorize user\n");
1300         return -1;
1301         }
1302     }
1303 printfd(__FILE__, "Invalid phase or control number. Phase: %d. Control number: %d\n", iaUser->phase.GetPhase(), connAck->rnd);
1304 return -1;
1305 }
1306 //-----------------------------------------------------------------------------
1307 int AUTH_IA::Process_CONN_ACK_7(CONN_ACK_7 * connAck, IA_USER * iaUser, user_iter * user, uint32_t sip)
1308 {
1309 return Process_CONN_ACK_6(connAck, iaUser, user, sip);
1310 }
1311 //-----------------------------------------------------------------------------
1312 int AUTH_IA::Process_CONN_ACK_8(CONN_ACK_8 * connAck, IA_USER * iaUser, user_iter *, uint32_t sip)
1313 {
1314 #ifdef ARCH_BE
1315 SwapBytes(connAck->len);
1316 SwapBytes(connAck->rnd);
1317 #endif
1318 printfd( __FILE__, "CONN_ACK_8 %s\n", connAck->type);
1319
1320 if ((iaUser->phase.GetPhase() == 2) && (connAck->rnd == iaUser->rnd + 1))
1321     {
1322     iaUser->phase.UpdateTime();
1323     iaUser->lastSendAlive = iaUser->phase.GetTime();
1324     if (iaUser->user->Authorize(sip, "", enabledDirs, this) == 0)
1325         {
1326         iaUser->phase.SetPhase3();
1327         printfd(__FILE__, "Phase changed from 2 to 3. Reason: CONN_ACK_8\n");
1328         return 0;
1329         }
1330     else
1331         {
1332         errorStr = iaUser->user->GetStrError();
1333         iaUser->phase.SetPhase1();
1334         printfd(__FILE__, "Phase changed from 2 to 1. Reason: failed to authorize user\n");
1335         return -1;
1336         }
1337     }
1338 printfd(__FILE__, "Invalid phase or control number. Phase: %d. Control number: %d\n", iaUser->phase.GetPhase(), connAck->rnd);
1339 return -1;
1340 }
1341 //-----------------------------------------------------------------------------
1342 int AUTH_IA::Process_ALIVE_ACK_6(ALIVE_ACK_6 * aliveAck, IA_USER * iaUser, user_iter *, uint32_t)
1343 {
1344 #ifdef ARCH_BE
1345 SwapBytes(aliveAck->len);
1346 SwapBytes(aliveAck->rnd);
1347 #endif
1348 printfd(__FILE__, "ALIVE_ACK_6\n");
1349 if ((iaUser->phase.GetPhase() == 3) && (aliveAck->rnd == iaUser->rnd + 1))
1350     {
1351     iaUser->phase.UpdateTime();
1352     #ifdef IA_DEBUG
1353     iaUser->aliveSent = false;
1354     #endif
1355     }
1356 return 0;
1357 }
1358 //-----------------------------------------------------------------------------
1359 int AUTH_IA::Process_ALIVE_ACK_7(ALIVE_ACK_7 * aliveAck, IA_USER * iaUser, user_iter * user, uint32_t sip)
1360 {
1361 return Process_ALIVE_ACK_6(aliveAck, iaUser, user, sip);
1362 }
1363 //-----------------------------------------------------------------------------
1364 int AUTH_IA::Process_ALIVE_ACK_8(ALIVE_ACK_8 * aliveAck, IA_USER * iaUser, user_iter *, uint32_t)
1365 {
1366 #ifdef ARCH_BE
1367 SwapBytes(aliveAck->len);
1368 SwapBytes(aliveAck->rnd);
1369 #endif
1370 printfd(__FILE__, "ALIVE_ACK_8\n");
1371 if ((iaUser->phase.GetPhase() == 3) && (aliveAck->rnd == iaUser->rnd + 1))
1372     {
1373     iaUser->phase.UpdateTime();
1374     #ifdef IA_DEBUG
1375     iaUser->aliveSent = false;
1376     #endif
1377     }
1378 return 0;
1379 }
1380 //-----------------------------------------------------------------------------
1381 int AUTH_IA::Process_DISCONN_SYN_6(DISCONN_SYN_6 *, IA_USER * iaUser, user_iter *, uint32_t)
1382 {
1383 printfd(__FILE__, "DISCONN_SYN_6\n");
1384 if (iaUser->phase.GetPhase() != 3)
1385     {
1386     printfd(__FILE__, "Invalid phase. Expected 3, actual %d\n", iaUser->phase.GetPhase());
1387     errorStr = "Incorrect request DISCONN_SYN";
1388     return -1;
1389     }
1390
1391 iaUser->phase.SetPhase4();
1392 printfd(__FILE__, "Phase changed from 3 to 4. Reason: DISCONN_SYN_6\n");
1393
1394 return 0;
1395 }
1396 //-----------------------------------------------------------------------------
1397 int AUTH_IA::Process_DISCONN_SYN_7(DISCONN_SYN_7 * disconnSyn, IA_USER * iaUser, user_iter * user, uint32_t sip)
1398 {
1399 return Process_DISCONN_SYN_6(disconnSyn, iaUser, user, sip);
1400 }
1401 //-----------------------------------------------------------------------------
1402 int AUTH_IA::Process_DISCONN_SYN_8(DISCONN_SYN_8 *, IA_USER * iaUser, user_iter *, uint32_t)
1403 {
1404 if (iaUser->phase.GetPhase() != 3)
1405     {
1406     errorStr = "Incorrect request DISCONN_SYN";
1407     printfd(__FILE__, "Invalid phase. Expected 3, actual %d\n", iaUser->phase.GetPhase());
1408     return -1;
1409     }
1410
1411 iaUser->phase.SetPhase4();
1412 printfd(__FILE__, "Phase changed from 3 to 4. Reason: DISCONN_SYN_6\n");
1413
1414 return 0;
1415 }
1416 //-----------------------------------------------------------------------------
1417 int AUTH_IA::Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnAck,
1418                                    IA_USER * iaUser,
1419                                    user_iter *,
1420                                    uint32_t,
1421                                    map<uint32_t, IA_USER>::iterator)
1422 {
1423 #ifdef ARCH_BE
1424 SwapBytes(disconnAck->len);
1425 SwapBytes(disconnAck->rnd);
1426 #endif
1427 printfd(__FILE__, "DISCONN_ACK_6\n");
1428 if (!((iaUser->phase.GetPhase() == 4) && (disconnAck->rnd == iaUser->rnd + 1)))
1429     {
1430     printfd(__FILE__, "Invalid phase or control number. Phase: %d. Control number: %d\n", iaUser->phase.GetPhase(), disconnAck->rnd);
1431     return -1;
1432     }
1433
1434 return 0;
1435 }
1436 //-----------------------------------------------------------------------------
1437 int AUTH_IA::Process_DISCONN_ACK_7(DISCONN_ACK_7 * disconnAck, IA_USER * iaUser, user_iter * user, uint32_t sip, map<uint32_t, IA_USER>::iterator it)
1438 {
1439 return Process_DISCONN_ACK_6(disconnAck, iaUser, user, sip, it);
1440 }
1441 //-----------------------------------------------------------------------------
1442 int AUTH_IA::Process_DISCONN_ACK_8(DISCONN_ACK_8 * disconnAck, IA_USER * iaUser, user_iter *, uint32_t, map<uint32_t, IA_USER>::iterator)
1443 {
1444 #ifdef ARCH_BE
1445 SwapBytes(disconnAck->len);
1446 SwapBytes(disconnAck->rnd);
1447 #endif
1448 printfd(__FILE__, "DISCONN_ACK_8\n");
1449 if (!((iaUser->phase.GetPhase() == 4) && (disconnAck->rnd == iaUser->rnd + 1)))
1450     {
1451     printfd(__FILE__, "Invalid phase or control number. Phase: %d. Control number: %d\n", iaUser->phase.GetPhase(), disconnAck->rnd);
1452     return -1;
1453     }
1454
1455 return 0;
1456 }
1457 //-----------------------------------------------------------------------------
1458 int AUTH_IA::Send_CONN_SYN_ACK_6(IA_USER * iaUser, user_iter *, uint32_t sip)
1459 {
1460 //+++ Fill static data in connSynAck +++
1461 // TODO Move this code. It must be executed only once
1462 connSynAck6.len = Min8(sizeof(CONN_SYN_ACK_6));
1463 strcpy((char*)connSynAck6.type, "CONN_SYN_ACK");
1464 for (int j = 0; j < DIR_NUM; j++)
1465     {
1466     strncpy((char*)connSynAck6.dirName[j],
1467             stgSettings->GetDirName(j).c_str(),
1468             sizeof(string16));
1469
1470     connSynAck6.dirName[j][sizeof(string16) - 1] = 0;
1471     }
1472 //--- Fill static data in connSynAck ---
1473
1474 iaUser->rnd = random();
1475 connSynAck6.rnd = iaUser->rnd;
1476
1477 connSynAck6.userTimeOut = iaSettings.GetUserTimeout();
1478 connSynAck6.aliveDelay = iaSettings.GetUserDelay();
1479
1480 #ifdef ARCH_BE
1481 SwapBytes(connSynAck6.len);
1482 SwapBytes(connSynAck6.rnd);
1483 SwapBytes(connSynAck6.userTimeOut);
1484 SwapBytes(connSynAck6.aliveDelay);
1485 #endif
1486
1487 Encrypt(&iaUser->ctx, (char*)&connSynAck6, (char*)&connSynAck6, Min8(sizeof(CONN_SYN_ACK_6))/8);
1488 return Send(sip, iaSettings.GetUserPort(), (char*)&connSynAck6, Min8(sizeof(CONN_SYN_ACK_6)));;
1489 }
1490 //-----------------------------------------------------------------------------
1491 int AUTH_IA::Send_CONN_SYN_ACK_7(IA_USER * iaUser, user_iter * user, uint32_t sip)
1492 {
1493 return Send_CONN_SYN_ACK_6(iaUser, user, sip);
1494 }
1495 //-----------------------------------------------------------------------------
1496 int AUTH_IA::Send_CONN_SYN_ACK_8(IA_USER * iaUser, user_iter *, uint32_t sip)
1497 {
1498 strcpy((char*)connSynAck8.hdr.magic, IA_ID);
1499 connSynAck8.hdr.protoVer[0] = 0;
1500 connSynAck8.hdr.protoVer[1] = 8;
1501
1502 //+++ Fill static data in connSynAck +++
1503 // TODO Move this code. It must be executed only once
1504 connSynAck8.len = Min8(sizeof(CONN_SYN_ACK_8));
1505 strcpy((char*)connSynAck8.type, "CONN_SYN_ACK");
1506 for (int j = 0; j < DIR_NUM; j++)
1507     {
1508     strncpy((char*)connSynAck8.dirName[j],
1509             stgSettings->GetDirName(j).c_str(),
1510             sizeof(string16));
1511
1512     connSynAck8.dirName[j][sizeof(string16) - 1] = 0;
1513     }
1514 //--- Fill static data in connSynAck ---
1515
1516 iaUser->rnd = random();
1517 connSynAck8.rnd = iaUser->rnd;
1518
1519 connSynAck8.userTimeOut = iaSettings.GetUserTimeout();
1520 connSynAck8.aliveDelay = iaSettings.GetUserDelay();
1521
1522 #ifdef ARCH_BE
1523 SwapBytes(connSynAck8.len);
1524 SwapBytes(connSynAck8.rnd);
1525 SwapBytes(connSynAck8.userTimeOut);
1526 SwapBytes(connSynAck8.aliveDelay);
1527 #endif
1528
1529 Encrypt(&iaUser->ctx, (char*)&connSynAck8, (char*)&connSynAck8, Min8(sizeof(CONN_SYN_ACK_8))/8);
1530 return Send(sip, iaUser->port, (char*)&connSynAck8, Min8(sizeof(CONN_SYN_ACK_8)));
1531 //return Send(sip, iaUser->port, (char*)&connSynAck8, 384);
1532 }
1533 //-----------------------------------------------------------------------------
1534 int AUTH_IA::Send_ALIVE_SYN_6(IA_USER * iaUser, uint32_t sip)
1535 {
1536 aliveSyn6.len = Min8(sizeof(ALIVE_SYN_6));
1537 aliveSyn6.rnd = iaUser->rnd = random();
1538
1539 strcpy((char*)aliveSyn6.type, "ALIVE_SYN");
1540
1541 for (int i = 0; i < DIR_NUM; i++)
1542     {
1543     aliveSyn6.md[i] = iaUser->user->property.down.Get()[i];
1544     aliveSyn6.mu[i] = iaUser->user->property.up.Get()[i];
1545
1546     aliveSyn6.sd[i] = iaUser->user->GetSessionDownload()[i];
1547     aliveSyn6.su[i] = iaUser->user->GetSessionUpload()[i];
1548     }
1549
1550 //TODO
1551 int dn = iaSettings.GetFreeMbShowType();
1552 const TARIFF * tf = iaUser->user->GetTariff();
1553
1554 if (dn < DIR_NUM)
1555     {
1556     double p = tf->GetPriceWithTraffType(aliveSyn6.mu[dn],
1557                                          aliveSyn6.md[dn],
1558                                          dn,
1559                                          stgTime);
1560     p *= (1024 * 1024);
1561     if (p == 0)
1562         {
1563         snprintf((char*)aliveSyn6.freeMb, IA_FREEMB_LEN, "---");
1564         }
1565     else
1566         {
1567         double fmb = iaUser->user->property.freeMb;
1568         fmb = fmb < 0 ? 0 : fmb;
1569         snprintf((char*)aliveSyn6.freeMb, IA_FREEMB_LEN, "%.3f", fmb / p);
1570         }
1571     }
1572 else
1573     {
1574     if (freeMbNone == iaSettings.GetFreeMbShowType())
1575         {
1576         aliveSyn6.freeMb[0] = 0;
1577         }
1578     else
1579         {
1580         double fmb = iaUser->user->property.freeMb;
1581         fmb = fmb < 0 ? 0 : fmb;
1582         snprintf((char*)aliveSyn6.freeMb, IA_FREEMB_LEN, "C%.3f", fmb);
1583         }
1584     }
1585
1586 #ifdef IA_DEBUG
1587 if (iaUser->aliveSent)
1588     {
1589     printfd(__FILE__, "========= ALIVE_ACK_6(7) TIMEOUT !!! %s =========\n", iaUser->user->GetLogin().c_str());
1590     }
1591 iaUser->aliveSent = true;
1592 #endif
1593
1594 aliveSyn6.cash =(int64_t) (iaUser->user->property.cash.Get() * 1000.0);
1595 if (!stgSettings->GetShowFeeInCash())
1596     aliveSyn6.cash -= (int64_t)(tf->GetFee() * 1000.0);
1597
1598 #ifdef ARCH_BE
1599 SwapBytes(aliveSyn6.len);
1600 SwapBytes(aliveSyn6.rnd);
1601 SwapBytes(aliveSyn6.cash);
1602 for (int i = 0; i < DIR_NUM; ++i)
1603     {
1604     SwapBytes(aliveSyn6.mu[i]);
1605     SwapBytes(aliveSyn6.md[i]);
1606     SwapBytes(aliveSyn6.su[i]);
1607     SwapBytes(aliveSyn6.sd[i]);
1608     }
1609 #endif
1610
1611 Encrypt(&(iaUser->ctx), (char*)&aliveSyn6, (char*)&aliveSyn6, Min8(sizeof(aliveSyn6))/8);
1612 return Send(sip, iaSettings.GetUserPort(), (char*)&aliveSyn6, Min8(sizeof(aliveSyn6)));
1613 }
1614 //-----------------------------------------------------------------------------
1615 int AUTH_IA::Send_ALIVE_SYN_7(IA_USER * iaUser, uint32_t sip)
1616 {
1617 return Send_ALIVE_SYN_6(iaUser, sip);
1618 }
1619 //-----------------------------------------------------------------------------
1620 int AUTH_IA::Send_ALIVE_SYN_8(IA_USER * iaUser, uint32_t sip)
1621 {
1622 strcpy((char*)aliveSyn8.hdr.magic, IA_ID);
1623 aliveSyn8.hdr.protoVer[0] = 0;
1624 aliveSyn8.hdr.protoVer[1] = 8;
1625
1626 aliveSyn8.len = Min8(sizeof(ALIVE_SYN_8));
1627 aliveSyn8.rnd = iaUser->rnd = random();
1628
1629 strcpy((char*)aliveSyn8.type, "ALIVE_SYN");
1630
1631 for (int i = 0; i < DIR_NUM; i++)
1632     {
1633     aliveSyn8.md[i] = iaUser->user->property.down.Get()[i];
1634     aliveSyn8.mu[i] = iaUser->user->property.up.Get()[i];
1635
1636     aliveSyn8.sd[i] = iaUser->user->GetSessionDownload()[i];
1637     aliveSyn8.su[i] = iaUser->user->GetSessionUpload()[i];
1638     }
1639
1640 //TODO
1641 int dn = iaSettings.GetFreeMbShowType();
1642
1643 if (dn < DIR_NUM)
1644     {
1645     const TARIFF * tf = iaUser->user->GetTariff();
1646     double p = tf->GetPriceWithTraffType(aliveSyn8.mu[dn],
1647                                          aliveSyn8.md[dn],
1648                                          dn,
1649                                          stgTime);
1650     p *= (1024 * 1024);
1651     if (p == 0)
1652         {
1653         snprintf((char*)aliveSyn8.freeMb, IA_FREEMB_LEN, "---");
1654         }
1655     else
1656         {
1657         double fmb = iaUser->user->property.freeMb;
1658         fmb = fmb < 0 ? 0 : fmb;
1659         snprintf((char*)aliveSyn8.freeMb, IA_FREEMB_LEN, "%.3f", fmb / p);
1660         }
1661     }
1662 else
1663     {
1664     if (freeMbNone == iaSettings.GetFreeMbShowType())
1665         {
1666         aliveSyn8.freeMb[0] = 0;
1667         }
1668     else
1669         {
1670         double fmb = iaUser->user->property.freeMb;
1671         fmb = fmb < 0 ? 0 : fmb;
1672         snprintf((char*)aliveSyn8.freeMb, IA_FREEMB_LEN, "C%.3f", fmb);
1673         }
1674     }
1675
1676 #ifdef IA_DEBUG
1677 if (iaUser->aliveSent)
1678     {
1679     printfd(__FILE__, "========= ALIVE_ACK_8 TIMEOUT !!! =========\n");
1680     }
1681 iaUser->aliveSent = true;
1682 #endif
1683
1684 const TARIFF * tf = iaUser->user->GetTariff();
1685
1686 aliveSyn8.cash =(int64_t) (iaUser->user->property.cash.Get() * 1000.0);
1687 if (!stgSettings->GetShowFeeInCash())
1688     aliveSyn8.cash -= (int64_t)(tf->GetFee() * 1000.0);
1689
1690 #ifdef ARCH_BE
1691 SwapBytes(aliveSyn8.len);
1692 SwapBytes(aliveSyn8.rnd);
1693 SwapBytes(aliveSyn8.cash);
1694 SwapBytes(aliveSyn8.status);
1695 for (int i = 0; i < DIR_NUM; ++i)
1696     {
1697     SwapBytes(aliveSyn8.mu[i]);
1698     SwapBytes(aliveSyn8.md[i]);
1699     SwapBytes(aliveSyn8.su[i]);
1700     SwapBytes(aliveSyn8.sd[i]);
1701     }
1702 #endif
1703
1704 Encrypt(&(iaUser->ctx), (char*)&aliveSyn8, (char*)&aliveSyn8, Min8(sizeof(aliveSyn8))/8);
1705 return Send(sip, iaUser->port, (char*)&aliveSyn8, Min8(sizeof(aliveSyn8)));
1706 }
1707 //-----------------------------------------------------------------------------
1708 int AUTH_IA::Send_DISCONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip)
1709 {
1710 disconnSynAck6.len = Min8(sizeof(DISCONN_SYN_ACK_6));
1711 strcpy((char*)disconnSynAck6.type, "DISCONN_SYN_ACK");
1712 disconnSynAck6.rnd = iaUser->rnd = random();
1713
1714 #ifdef ARCH_BE
1715 SwapBytes(disconnSynAck6.len);
1716 SwapBytes(disconnSynAck6.rnd);
1717 #endif
1718
1719 Encrypt(&iaUser->ctx, (char*)&disconnSynAck6, (char*)&disconnSynAck6, Min8(sizeof(disconnSynAck6))/8);
1720 return Send(sip, iaSettings.GetUserPort(), (char*)&disconnSynAck6, Min8(sizeof(disconnSynAck6)));
1721 }
1722 //-----------------------------------------------------------------------------
1723 int AUTH_IA::Send_DISCONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip)
1724 {
1725 return Send_DISCONN_SYN_ACK_6(iaUser, sip);
1726 }
1727 //-----------------------------------------------------------------------------
1728 int AUTH_IA::Send_DISCONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip)
1729 {
1730 strcpy((char*)disconnSynAck8.hdr.magic, IA_ID);
1731 disconnSynAck8.hdr.protoVer[0] = 0;
1732 disconnSynAck8.hdr.protoVer[1] = 8;
1733
1734 disconnSynAck8.len = Min8(sizeof(DISCONN_SYN_ACK_8));
1735 strcpy((char*)disconnSynAck8.type, "DISCONN_SYN_ACK");
1736 disconnSynAck8.rnd = iaUser->rnd = random();
1737
1738 #ifdef ARCH_BE
1739 SwapBytes(disconnSynAck8.len);
1740 SwapBytes(disconnSynAck8.rnd);
1741 #endif
1742
1743 Encrypt(&iaUser->ctx, (char*)&disconnSynAck8, (char*)&disconnSynAck8, Min8(sizeof(disconnSynAck8))/8);
1744 return Send(sip, iaUser->port, (char*)&disconnSynAck8, Min8(sizeof(disconnSynAck8)));
1745 }
1746 //-----------------------------------------------------------------------------
1747 int AUTH_IA::Send_FIN_6(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it)
1748 {
1749 fin6.len = Min8(sizeof(FIN_6));
1750 strcpy((char*)fin6.type, "FIN");
1751 strcpy((char*)fin6.ok, "OK");
1752
1753 #ifdef ARCH_BE
1754 SwapBytes(fin6.len);
1755 #endif
1756
1757 Encrypt(&iaUser->ctx, (char*)&fin6, (char*)&fin6, Min8(sizeof(fin6))/8);
1758
1759 iaUser->user->Unauthorize(this);
1760
1761 int ret = Send(sip, iaSettings.GetUserPort(), (char*)&fin6, Min8(sizeof(fin6)));
1762 ip2user.erase(it);
1763 return ret;
1764 }
1765 //-----------------------------------------------------------------------------
1766 int AUTH_IA::Send_FIN_7(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it)
1767 {
1768 return Send_FIN_6(iaUser, sip, it);
1769 }
1770 //-----------------------------------------------------------------------------
1771 int AUTH_IA::Send_FIN_8(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it)
1772 {
1773 strcpy((char*)fin8.hdr.magic, IA_ID);
1774 fin8.hdr.protoVer[0] = 0;
1775 fin8.hdr.protoVer[1] = 8;
1776
1777 fin8.len = Min8(sizeof(FIN_8));
1778 strcpy((char*)fin8.type, "FIN");
1779 strcpy((char*)fin8.ok, "OK");
1780
1781 #ifdef ARCH_BE
1782 SwapBytes(fin8.len);
1783 #endif
1784
1785 Encrypt(&iaUser->ctx, (char*)&fin8, (char*)&fin8, Min8(sizeof(fin8))/8);
1786
1787 iaUser->user->Unauthorize(this);
1788
1789 int ret = Send(sip, iaUser->port, (char*)&fin8, Min8(sizeof(fin8)));
1790 ip2user.erase(it);
1791 return ret;
1792 }
1793 //-----------------------------------------------------------------------------
1794 bool AUTH_IA::WaitPackets(int sd) const
1795 {
1796 fd_set rfds;
1797 FD_ZERO(&rfds);
1798 FD_SET(sd, &rfds);
1799
1800 struct timeval tv;
1801 tv.tv_sec = 0;
1802 tv.tv_usec = 500000;
1803
1804 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
1805 if (res == -1) // Error
1806     {
1807     if (errno != EINTR)
1808         {
1809         printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
1810         }
1811     return false;
1812     }
1813
1814 if (res == 0) // Timeout
1815     {
1816     return false;
1817     }
1818
1819 return true;
1820 }
1821 //-----------------------------------------------------------------------------
1822 inline
1823 void InitEncrypt(BLOWFISH_CTX * ctx, const string & password)
1824 {
1825 unsigned char keyL[PASSWD_LEN];  // ðÁÒÏÌØ ÄÌÑ ÛÉÆÒÏ×ËÉ
1826 memset(keyL, 0, PASSWD_LEN);
1827 strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
1828 Blowfish_Init(ctx, keyL, PASSWD_LEN);
1829 }
1830 //-----------------------------------------------------------------------------
1831 inline
1832 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
1833 {
1834 // len8 - ÄÌÉÎÁ × 8-ÍÉ ÂÁÊÔÏ×ÙÈ ÂÌÏËÁÈ
1835
1836 for (int i = 0; i < len8; i++)
1837     DecodeString(dst + i * 8, src + i * 8, ctx);
1838 }
1839 //-----------------------------------------------------------------------------
1840 inline
1841 void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
1842 {
1843 // len8 - ÄÌÉÎÁ × 8-ÍÉ ÂÁÊÔÏ×ÙÈ ÂÌÏËÁÈ
1844
1845 for (int i = 0; i < len8; i++)
1846     EncodeString(dst + i * 8, src + i * 8, ctx);
1847 }