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