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