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