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

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