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