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