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