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