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