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