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