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