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