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

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