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