projects/stargazer/plugins/authorization/inetaccess/inetaccess.cpp

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