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