libs/ia/ia.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 1, or (at your option)
   5 ** 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., 675 Mass Ave, Cambridge, MA 02139, USA.
  15 */
  16
  17 /*
  18  $Author: faust $
  19  $Revision: 1.15 $
  20  $Date: 2010/04/16 11:28:03 $
  21 */
  22
  23 /*
  24 * Author :
  25 * Boris Mikhailenko <stg34@stargazer.dp.ua>
  26 * Maxim Mamontov <faust@stargazer.dp.ua>
  27 * Andrey Rakhmanov <andrey_rakhmanov@yahoo.com> - bugfixes.
  28 */
  29
  30 //---------------------------------------------------------------------------
  31
  32 #include "stg/common.h"
  33 #include "stg/ia.h"
  34
  35 #include <chrono>
  36 #include <cstdio>
  37 #include <cstdlib>
  38 #include <cstring>
  39 #include <cassert>
  40
  41 #ifdef WIN32
  42 #include <winsock2.h>
  43 #include <windows.h>
  44 #include <winbase.h>
  45 #include <winnt.h>
  46 #else
  47 #include <fcntl.h>
  48 #include <netdb.h>
  49 #include <arpa/inet.h>
  50 #include <unistd.h>
  51 #include <csignal>
  52 #endif
  53
  54 #define IA_NONE            (0)
  55 #define IA_CONNECT         (1)
  56 #define IA_DISCONNECT      (2)
  57
  58 #define IA_DEBUGPROTO   1
  59
  60 #define IA_ID "00100"
  61 //---------------------------------------------------------------------------
  62 //---------------------------------------------------------------------------
  63 //---------------------------------------------------------------------------
  64 #ifndef WIN32
  65 #include <sys/time.h>
  66 //---------------------------------------------------------------------------
  67 long GetTickCount()
  68 {
  69 struct timeval tv;
  70 gettimeofday(&tv, NULL);
  71 return tv.tv_sec*1000 + tv.tv_usec/1000;
  72 }
  73 #endif
  74 //---------------------------------------------------------------------------
  75
  76 namespace
  77 {
  78
  79 bool HostNameToIP(const std::string & hostName, uint32_t & ip)
  80 {
  81 ip = inet_addr(hostName.c_str());
  82 if (ip == INADDR_NONE)
  83     {
  84     hostent * phe = gethostbyname(hostName.c_str());
  85     if (phe)
  86         {
  87         ip = *reinterpret_cast<uint32_t*>(phe->h_addr_list[0]);
  88         }
  89     else
  90         {
  91         return false;
  92         }
  93     }
  94
  95 return true;
  96 }
  97
  98 }
  99
 100 //---------------------------------------------------------------------------
 101 //---------------------------------------------------------------------------
 102 //---------------------------------------------------------------------------
 103 IA_CLIENT_PROT::IA_CLIENT_PROT(const std::string & sn, unsigned short p,
 104                                const std::string & ln, uint16_t lp)
 105     : m_action(IA_NONE),
 106       m_phase(1),
 107       m_phaseTime(0),
 108       m_codeError(0),
 109       m_isNetPrepared(false),
 110       m_proxyMode(false),
 111       m_serverName(sn),
 112       m_port(p),
 113       m_ip(0),
 114       m_localName(ln),
 115       m_localPort(lp),
 116       m_firstConnect(true),
 117       m_reconnect(0),
 118       m_sockr(0),
 119       m_protNum(0),
 120       m_userTimeout(60),
 121       m_aliveTimeout(5),
 122       m_rnd(0),
 123       m_pStatusChangedCb(NULL),
 124       m_pStatChangedCb(NULL),
 125       m_pInfoCb(NULL),
 126       m_pErrorCb(NULL),
 127       m_pDirNameCb(NULL),
 128       m_statusChangedCbData(NULL),
 129       m_statChangedCbData(NULL),
 130       m_infoCbData(NULL),
 131       m_errorCbData(NULL),
 132       m_dirNameCbData(NULL),
 133       m_connSyn8(NULL),
 134       m_connSynAck8(NULL),
 135       m_connAck8(NULL),
 136       m_aliveSyn8(NULL),
 137       m_aliveAck8(NULL),
 138       m_disconnSyn8(NULL),
 139       m_disconnSynAck8(NULL),
 140       m_disconnAck8(NULL),
 141       m_info(NULL)
 142 {
 143 memset(&m_stat, 0, sizeof(m_stat));
 144
 145 #ifdef WIN32
 146 WSAStartup(MAKEWORD(2, 0), &m_wsaData);
 147 #endif
 148
 149 m_packetTypes["CONN_SYN"] = CONN_SYN_N;
 150 m_packetTypes["CONN_SYN_ACK"] = CONN_SYN_ACK_N;
 151 m_packetTypes["CONN_ACK"] = CONN_ACK_N;
 152 m_packetTypes["ALIVE_SYN"] = ALIVE_SYN_N;
 153 m_packetTypes["ALIVE_ACK"] = ALIVE_ACK_N;
 154 m_packetTypes["DISCONN_SYN"] = DISCONN_SYN_N;
 155 m_packetTypes["DISCONN_SYN_ACK"] = DISCONN_SYN_ACK_N;
 156 m_packetTypes["DISCONN_ACK"] = DISCONN_ACK_N;
 157 m_packetTypes["FIN"] = FIN_N;
 158 m_packetTypes["ERR"] = ERROR_N;
 159 m_packetTypes["INFO"] = INFO_N;
 160 m_packetTypes["INFO_7"] = INFO_7_N;
 161 m_packetTypes["INFO_8"] = INFO_8_N;
 162
 163 char key[IA_PASSWD_LEN];
 164 memset(key, 0, IA_PASSWD_LEN);
 165 strncpy(key, "pr7Hhen", 8);
 166 Blowfish_Init(&m_ctxHdr, key, IA_PASSWD_LEN);
 167
 168 memset(key, 0, IA_PASSWD_LEN);
 169 Blowfish_Init(&m_ctxPass, key, IA_PASSWD_LEN);
 170
 171 for (size_t i = 0; i < DIR_NUM; ++i)
 172     m_selectedDirs[i] = false;
 173
 174 m_servAddr.sin_family = AF_INET;
 175 m_servAddr.sin_port = htons(m_port);
 176 m_servAddr.sin_addr.s_addr = m_ip;
 177 }
 178 //---------------------------------------------------------------------------
 179 void IA_CLIENT_PROT::PrepareNet()
 180 {
 181 /*struct hostent * phe;
 182 unsigned long ip;
 183
 184 ip = inet_addr(serverName.c_str());
 185 if (ip == INADDR_NONE)
 186     {
 187     phe = gethostbyname(serverName.c_str());
 188     if (phe)
 189         {
 190         ip = *((unsigned long*)phe->h_addr_list[0]);
 191         }
 192     else
 193         {
 194         strError = string("Unknown host ") + "\'" + serverName + "\'";
 195         codeError = IA_GETHOSTBYNAME_ERROR;
 196         if (pErrorCb != NULL)
 197             pErrorCb(strError, IA_GETHOSTBYNAME_ERROR, errorCbData);
 198         }
 199     }*/
 200
 201 if (!HostNameToIP(m_serverName, m_ip))
 202     {
 203     m_ip = 0;
 204     m_strError = std::string("Unknown host ") + "\'" + m_serverName + "\'";
 205     m_codeError = IA_GETHOSTBYNAME_ERROR;
 206     if (m_pErrorCb != NULL)
 207         m_pErrorCb(m_strError, IA_GETHOSTBYNAME_ERROR, m_errorCbData);
 208     return;
 209     }
 210
 211 #ifndef WIN32
 212 close(m_sockr);
 213 #else
 214 closesocket(m_sockr);
 215 #endif
 216
 217 m_sockr = socket(AF_INET, SOCK_DGRAM, 0);
 218
 219 struct sockaddr_in  localAddrR;
 220 localAddrR.sin_family = AF_INET;
 221
 222 if (m_localPort)
 223     localAddrR.sin_port = htons(m_localPort);
 224 else
 225     localAddrR.sin_port = htons(m_port);
 226
 227 if (!m_localName.empty())
 228     {
 229     if (!HostNameToIP(m_localName, m_localIP))
 230         {
 231         m_strError = std::string("Unknown host ") + "\'" + m_serverName + "\'";
 232         m_codeError = IA_GETHOSTBYNAME_ERROR;
 233         if (m_pErrorCb != NULL)
 234             m_pErrorCb(m_strError, IA_GETHOSTBYNAME_ERROR, m_errorCbData);
 235         m_localIP = INADDR_ANY;
 236         }
 237     }
 238 else
 239     {
 240     m_localIP = INADDR_ANY;
 241     }
 242
 243 localAddrR.sin_addr.s_addr = m_localIP;
 244
 245 m_servAddr.sin_family = AF_INET;
 246 m_servAddr.sin_port = htons(m_port);
 247 m_servAddr.sin_addr.s_addr = m_ip;
 248
 249 int res = bind(m_sockr, reinterpret_cast<sockaddr*>(&localAddrR), sizeof(localAddrR));
 250 if (res == -1)
 251     {
 252     m_strError = "bind error";
 253     m_codeError = IA_BIND_ERROR;
 254     if (m_pErrorCb != NULL)
 255         m_pErrorCb(m_strError, IA_BIND_ERROR, m_errorCbData);
 256     return;
 257     }
 258
 259 #ifdef WIN32
 260 unsigned long arg = 1;
 261 ioctlsocket(m_sockr, FIONBIO, &arg);
 262 #else
 263 if (0 != fcntl(m_sockr, F_SETFL, O_NONBLOCK))
 264     {
 265     m_strError = "fcntl error";
 266     m_codeError = IA_FCNTL_ERROR;
 267     if (m_pErrorCb != NULL)
 268         m_pErrorCb(m_strError, IA_FCNTL_ERROR, m_errorCbData);
 269     }
 270 #endif
 271
 272 }
 273 //---------------------------------------------------------------------------
 274 IA_CLIENT_PROT::~IA_CLIENT_PROT()
 275 {
 276 #ifndef WIN32
 277 close(m_sockr);
 278 #else
 279 closesocket(m_sockr);
 280 WSACleanup();
 281 #endif
 282 }
 283 //---------------------------------------------------------------------------
 284 int IA_CLIENT_PROT::DeterminatePacketType(const char * buffer)
 285 {
 286 std::map<std::string, int>::iterator pi;
 287 pi = m_packetTypes.find(buffer);
 288 if (pi == m_packetTypes.end())
 289     {
 290     return -1;
 291     }
 292 else
 293     {
 294     return pi->second;
 295     }
 296 }
 297 //---------------------------------------------------------------------------
 298 void IA_CLIENT_PROT::FillHdr8(char* buffer, unsigned long)
 299 {
 300 strncpy(buffer, IA_ID, 6);
 301 buffer[IA_MAGIC_LEN] = 0;
 302 buffer[IA_MAGIC_LEN + 1] = IA_PROTO_VER;
 303 strncpy(buffer + sizeof(HDR_8), m_login.c_str(), IA_LOGIN_LEN);
 304 }
 305 //---------------------------------------------------------------------------
 306 int IA_CLIENT_PROT::Send(char * buffer, int len)
 307 {
 308 if (!m_isNetPrepared)
 309     {
 310     PrepareNet();
 311     m_isNetPrepared = true;
 312     }
 313
 314 int db = sizeof(HDR_8);
 315 EncryptString(buffer + db, buffer + db, IA_LOGIN_LEN, &m_ctxHdr);
 316
 317 db += IA_LOGIN_LEN;
 318 int encLen = (len - sizeof(HDR_8) - IA_LOGIN_LEN);
 319 EncryptString(buffer + db, buffer + db, encLen, &m_ctxPass);
 320
 321 return sendto(m_sockr, buffer, len, 0, reinterpret_cast<sockaddr*>(&m_servAddr), sizeof(m_servAddr));
 322 }
 323 //---------------------------------------------------------------------------
 324 int IA_CLIENT_PROT::Recv(char * buffer, int len)
 325 {
 326 #ifdef WIN32
 327 int fromLen;
 328 #else
 329 socklen_t fromLen;
 330 #endif
 331
 332 struct sockaddr_in addr;
 333 fromLen = sizeof(addr);
 334 int res = recvfrom(m_sockr, buffer, len, 0, reinterpret_cast<sockaddr*>(&addr), &fromLen);
 335
 336 if (res == -1)
 337     return res;
 338
 339 if (strcmp(buffer + 4 + sizeof(HDR_8), "ERR"))
 340     DecryptString(buffer, buffer, len, &m_ctxPass);
 341
 342 return 0;
 343 }
 344 //---------------------------------------------------------------------------
 345 int IA_CLIENT_PROT::NetSend(int n)
 346 {
 347 char buffer[2048];
 348 int msgLen;
 349
 350 memset(buffer, 0, 2048);
 351
 352 switch (n)
 353     {
 354     case CONN_SYN_N:
 355         msgLen = Prepare_CONN_SYN_8(buffer);
 356         break;
 357
 358     case CONN_ACK_N:
 359         msgLen = Prepare_CONN_ACK_8(buffer);
 360         break;
 361
 362     case ALIVE_ACK_N:
 363         msgLen = Prepare_ALIVE_ACK_8(buffer);
 364         break;
 365
 366     case DISCONN_SYN_N:
 367         msgLen = Prepare_DISCONN_SYN_8(buffer);
 368         break;
 369
 370     case DISCONN_ACK_N:
 371         msgLen = Prepare_DISCONN_ACK_8(buffer);
 372         break;
 373
 374     default:
 375         return -1;
 376     }
 377
 378 FillHdr8(buffer, 0);
 379 Send(buffer, msgLen);
 380
 381 return 0;
 382 }
 383 //---------------------------------------------------------------------------
 384 int IA_CLIENT_PROT::NetRecv()
 385 {
 386 char buffer[2048];
 387
 388 if (Recv(buffer, sizeof(buffer)) < 0)
 389     return -1;
 390
 391 char packetName[20];
 392 strncpy(packetName, buffer + 12, sizeof(packetName));
 393 packetName[sizeof(packetName) - 1] = 0;
 394 int pn = DeterminatePacketType(buffer + 12);
 395
 396 int ret;
 397 switch (pn)
 398     {
 399     case CONN_SYN_ACK_N:
 400         ret = Process_CONN_SYN_ACK_8(buffer);
 401         break;
 402
 403     case ALIVE_SYN_N:
 404         ret = Process_ALIVE_SYN_8(buffer);
 405         break;
 406
 407     case DISCONN_SYN_ACK_N:
 408         ret = Process_DISCONN_SYN_ACK_8(buffer);
 409         break;
 410
 411     case FIN_N:
 412         ret = Process_FIN_8(buffer);
 413         break;
 414
 415     case INFO_8_N:
 416         ret = Process_INFO_8(buffer);
 417         break;
 418
 419     case ERROR_N:
 420         ret = Process_ERROR(buffer);
 421         break;
 422
 423     default:
 424         ret = -1;
 425     }
 426 return ret;
 427 }
 428 //---------------------------------------------------------------------------
 429 void IA_CLIENT_PROT::Start()
 430 {
 431     m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
 432 }
 433 //---------------------------------------------------------------------------
 434 void IA_CLIENT_PROT::Stop()
 435 {
 436     if (m_thread.joinable())
 437         m_thread.request_stop();
 438 }
 439 //---------------------------------------------------------------------------
 440 void IA_CLIENT_PROT::Run(std::stop_token token)
 441 {
 442     while (!token.stop_requested())
 443     {
 444         NetRecv();
 445
 446         switch (m_phase)
 447         {
 448             case 1:
 449                 if (m_action == IA_CONNECT)
 450                 {
 451                     m_action = IA_NONE;
 452                     NetSend(CONN_SYN_N);
 453                     m_phase = 2;
 454                     m_phaseTime = GetTickCount();
 455                 }
 456                 if (m_reconnect && !m_firstConnect)
 457                 {
 458                     m_action = IA_CONNECT;
 459                 }
 460                 break;
 461
 462             case 2:
 463                 if (static_cast<int>(GetTickCount() - m_phaseTime)/1000 > m_aliveTimeout)
 464                 {
 465                     m_phase = 1;
 466                     m_phaseTime = GetTickCount();
 467                     if (m_pStatusChangedCb != NULL)
 468                         m_pStatusChangedCb(0, m_statusChangedCbData);
 469                 }
 470
 471                 if (m_action == IA_DISCONNECT)
 472                 {
 473                     m_action = IA_NONE;
 474                     NetSend(DISCONN_SYN_N);
 475                     m_phase = 4;
 476                     m_phaseTime = GetTickCount();
 477                 }
 478
 479                 break;
 480
 481             case 3:
 482                 if (static_cast<int>(GetTickCount() - m_phaseTime)/1000 > m_userTimeout)
 483                 {
 484                     m_phase = 1;
 485                     m_phaseTime = GetTickCount();
 486                     if (m_pStatusChangedCb != NULL)
 487                         m_pStatusChangedCb(0, m_statusChangedCbData);
 488                     m_firstConnect = false;
 489                 }
 490
 491                 if (m_action == IA_DISCONNECT)
 492                 {
 493                     m_action = IA_NONE;
 494                     NetSend(DISCONN_SYN_N);
 495                     m_phase = 4;
 496                     m_phaseTime = GetTickCount();
 497                 }
 498
 499                 break;
 500
 501             case 4:
 502                 if (static_cast<int>(GetTickCount() - m_phaseTime)/1000 > m_aliveTimeout)
 503                 {
 504                     m_phase=1;
 505                     m_phaseTime = GetTickCount();
 506                     if (m_pStatusChangedCb != NULL)
 507                         m_pStatusChangedCb(0, m_statusChangedCbData);
 508                 }
 509
 510                 if (m_action == IA_CONNECT)
 511                 {
 512                     m_action = IA_NONE;
 513                     NetSend(CONN_SYN_N);
 514                     m_phase = 2;
 515                     m_phaseTime = GetTickCount();
 516                 }
 517
 518                 break;
 519
 520             case 5:
 521                 if (static_cast<int>(GetTickCount() - m_phaseTime)/1000 > m_aliveTimeout)
 522                 {
 523                     m_phase = 1;
 524                     m_phaseTime = GetTickCount();
 525                     if (m_pStatusChangedCb != NULL)
 526                         m_pStatusChangedCb(0, m_statusChangedCbData);
 527                 }
 528
 529                 if (m_action == IA_CONNECT)
 530                 {
 531                     m_action = IA_NONE;
 532                     NetSend(CONN_SYN_N);
 533                     m_phase = 2;
 534                     m_phaseTime = GetTickCount();
 535                 }
 536
 537                 break;
 538         }
 539         std::this_thread::sleep_for(std::chrono::milliseconds(20));
 540     }
 541 }
 542 //---------------------------------------------------------------------------
 543 void IA_CLIENT_PROT::GetStat(LOADSTAT * ls)
 544 {
 545 memcpy(ls, &m_stat, sizeof(m_stat));
 546 }
 547 //---------------------------------------------------------------------------
 548 void IA_CLIENT_PROT::SetServer(const std::string & sn, unsigned short p)
 549 {
 550 m_serverName = sn;
 551 m_port = p;
 552 PrepareNet();
 553 }
 554 //---------------------------------------------------------------------------
 555 void IA_CLIENT_PROT::SetLogin(const std::string & l)
 556 {
 557 m_login = l;
 558 }
 559 //---------------------------------------------------------------------------
 560 void IA_CLIENT_PROT::SetPassword(const std::string & p)
 561 {
 562 m_password = p;
 563
 564 char keyL[IA_PASSWD_LEN];
 565 memset(keyL, 0, IA_PASSWD_LEN);
 566 strncpy(keyL, m_password.c_str(), IA_PASSWD_LEN);
 567 Blowfish_Init(&m_ctxPass, keyL, IA_PASSWD_LEN);
 568 }
 569 //---------------------------------------------------------------------------
 570 void IA_CLIENT_PROT::SetEnabledDirs(const bool * selectedDirs)
 571 {
 572 memcpy(m_selectedDirs, selectedDirs, sizeof(bool) * DIR_NUM);
 573 }
 574 //---------------------------------------------------------------------------
 575 int IA_CLIENT_PROT::Connect()
 576 {
 577 m_action = IA_CONNECT;
 578 return 0;
 579 }
 580 //---------------------------------------------------------------------------
 581 int IA_CLIENT_PROT::Disconnect()
 582 {
 583 m_firstConnect = true;
 584 m_action = IA_DISCONNECT;
 585 return 0;
 586 }
 587 //---------------------------------------------------------------------------
 588 int IA_CLIENT_PROT::GetStrError(std::string * error) const
 589 {
 590 int ret = m_codeError;
 591 *error = m_strError;
 592 m_strError = "";
 593 m_codeError = 0;
 594 return ret;
 595 }
 596 //---------------------------------------------------------------------------
 597 int IA_CLIENT_PROT::Process_CONN_SYN_ACK_8(const void* buffer)
 598 {
 599 std::vector<std::string> dirNames;
 600 m_connSynAck8 = static_cast<const CONN_SYN_ACK_8*>(buffer);
 601
 602 #ifdef ARCH_BE
 603 SwapBytes(m_connSynAck8->len);
 604 SwapBytes(m_connSynAck8->rnd);
 605 SwapBytes(m_connSynAck8->userTimeOut);
 606 SwapBytes(m_connSynAck8->aliveDelay);
 607 #endif
 608
 609 m_rnd = m_connSynAck8->rnd;
 610 m_userTimeout = m_connSynAck8->userTimeOut;
 611 m_aliveTimeout = m_connSynAck8->aliveDelay;
 612
 613 for (int i = 0; i < DIR_NUM; i++)
 614     dirNames.push_back(reinterpret_cast<const char*>(m_connSynAck8->dirName[i]));
 615
 616 if (m_pDirNameCb != NULL)
 617     m_pDirNameCb(dirNames, m_dirNameCbData);
 618
 619 NetSend(CONN_ACK_N);
 620 m_phase = 3;
 621 m_phaseTime = GetTickCount();
 622
 623 return CONN_SYN_ACK_N;
 624 }
 625 //---------------------------------------------------------------------------
 626 int IA_CLIENT_PROT::Process_ALIVE_SYN_8(const void* buffer)
 627 {
 628 m_aliveSyn8 = static_cast<const ALIVE_SYN_8*>(buffer);
 629
 630 #ifdef ARCH_BE
 631 SwapBytes(m_aliveSyn8->len);
 632 SwapBytes(m_aliveSyn8->rnd);
 633 SwapBytes(m_aliveSyn8->cash);
 634 SwapBytes(m_aliveSyn8->status);
 635 for (int i = 0; i < DIR_NUM; ++i)
 636     {
 637     SwapBytes(m_aliveSyn8->mu[i]);
 638     SwapBytes(m_aliveSyn8->md[i]);
 639     SwapBytes(m_aliveSyn8->su[i]);
 640     SwapBytes(m_aliveSyn8->sd[i]);
 641     }
 642 #endif
 643
 644 m_rnd = m_aliveSyn8->rnd;
 645 memcpy(&m_stat, m_aliveSyn8->mu, sizeof(m_stat));
 646
 647 if (m_pStatChangedCb != NULL)
 648     m_pStatChangedCb(m_stat, m_statChangedCbData);
 649
 650 if (m_pStatusChangedCb != NULL)
 651     m_pStatusChangedCb(1, m_statusChangedCbData);
 652 NetSend(ALIVE_ACK_N);
 653 m_phaseTime = GetTickCount();
 654
 655 return ALIVE_SYN_N;
 656 }
 657 //---------------------------------------------------------------------------
 658 int IA_CLIENT_PROT::Process_DISCONN_SYN_ACK_8(const void* buffer)
 659 {
 660 m_disconnSynAck8 = static_cast<const DISCONN_SYN_ACK_8*>(buffer);
 661
 662 #ifdef ARCH_BE
 663 SwapBytes(m_disconnSynAck8->len);
 664 SwapBytes(m_disconnSynAck8->rnd);
 665 #endif
 666
 667 m_rnd = m_disconnSynAck8->rnd;
 668
 669 NetSend(DISCONN_ACK_N);
 670 m_phase = 5;
 671 m_phaseTime = GetTickCount();
 672
 673 return DISCONN_SYN_ACK_N;
 674 }
 675 //---------------------------------------------------------------------------
 676 int IA_CLIENT_PROT::Process_FIN_8(const void*)
 677 {
 678 m_phase = 1;
 679 m_phaseTime = GetTickCount();
 680 if (m_pStatusChangedCb != NULL)
 681     m_pStatusChangedCb(0, m_statusChangedCbData);
 682
 683 return FIN_N;
 684 }
 685 //---------------------------------------------------------------------------
 686 int IA_CLIENT_PROT::Process_INFO_8(const void* buffer)
 687 {
 688 m_info = static_cast<const INFO_8*>(buffer);
 689
 690 #ifdef ARCH_BE
 691 SwapBytes(m_info->len);
 692 SwapBytes(m_info->sendTime);
 693 #endif
 694
 695 if (m_pInfoCb != NULL)
 696     m_pInfoCb(reinterpret_cast<const char*>(m_info->text), m_info->infoType, m_info->showTime, m_info->sendTime, m_infoCbData);
 697 return INFO_8_N;
 698 }
 699 //---------------------------------------------------------------------------
 700 int IA_CLIENT_PROT::Process_ERROR(const void* buffer)
 701 {
 702 ERR_8 err;
 703 memcpy(&err, buffer, sizeof(err));
 704
 705 #ifdef ARCH_BE
 706 SwapBytes(err.len);
 707 #endif
 708
 709 KOIToWin(reinterpret_cast<const char*>(err.text), &m_messageText);
 710 if (m_pErrorCb != NULL)
 711     m_pErrorCb(m_messageText, IA_SERVER_ERROR, m_errorCbData);
 712 m_phase = 1;
 713 m_phaseTime = GetTickCount();
 714 m_codeError = IA_SERVER_ERROR;
 715
 716 return ERROR_N;
 717 }
 718 //---------------------------------------------------------------------------
 719 int IA_CLIENT_PROT::Prepare_CONN_SYN_8(void* buffer)
 720 {
 721 m_connSyn8 = static_cast<CONN_SYN_8*>(buffer);
 722
 723 assert(sizeof(CONN_SYN_8) == Min8(sizeof(CONN_SYN_8)) && "CONN_SYN_8 is not aligned to 8 bytes");
 724
 725 m_connSyn8->len = sizeof(CONN_SYN_8);
 726
 727 #ifdef ARCH_BE
 728 SwapBytes(m_connSyn8->len);
 729 #endif
 730
 731 strncpy(reinterpret_cast<char*>(m_connSyn8->type), "CONN_SYN", IA_MAX_TYPE_LEN);
 732 strncpy(reinterpret_cast<char*>(m_connSyn8->login), m_login.c_str(), IA_LOGIN_LEN);
 733 m_connSyn8->dirs = 0;
 734 for (int i = 0; i < DIR_NUM; i++)
 735     m_connSyn8->dirs |= (m_selectedDirs[i] << i);
 736 return sizeof(CONN_SYN_8);
 737 }
 738 //---------------------------------------------------------------------------
 739 int IA_CLIENT_PROT::Prepare_CONN_ACK_8(void* buffer)
 740 {
 741 m_connAck8 = static_cast<CONN_ACK_8*>(buffer);
 742
 743 assert(sizeof(CONN_ACK_8) == Min8(sizeof(CONN_ACK_8)) && "CONN_ACK_8 is not aligned to 8 bytes");
 744
 745 m_connAck8->len = sizeof(CONN_ACK_8);
 746 strncpy(reinterpret_cast<char*>(m_connAck8->loginS), m_login.c_str(), IA_LOGIN_LEN);
 747 strncpy(reinterpret_cast<char*>(m_connAck8->type), "CONN_ACK", IA_MAX_TYPE_LEN);
 748 m_rnd++;
 749 m_connAck8->rnd = m_rnd;
 750
 751 #ifdef ARCH_BE
 752 SwapBytes(m_connAck8->len);
 753 SwapBytes(m_connAck8->rnd);
 754 #endif
 755
 756 return sizeof(CONN_ACK_8);
 757 }
 758 //---------------------------------------------------------------------------
 759 int IA_CLIENT_PROT::Prepare_ALIVE_ACK_8(void* buffer)
 760 {
 761 m_aliveAck8 = static_cast<ALIVE_ACK_8*>(buffer);
 762
 763 assert(Min8(sizeof(ALIVE_ACK_8)) == sizeof(ALIVE_ACK_8) && "ALIVE_ACK_8 is not aligned to 8 bytes");
 764
 765 m_aliveAck8->len = sizeof(ALIVE_ACK_8);
 766 strncpy(reinterpret_cast<char*>(m_aliveAck8->loginS), m_login.c_str(), IA_LOGIN_LEN);
 767 strncpy(reinterpret_cast<char*>(m_aliveAck8->type), "ALIVE_ACK", IA_MAX_TYPE_LEN);
 768 m_aliveAck8->rnd = ++m_rnd;
 769
 770 #ifdef ARCH_BE
 771 SwapBytes(m_aliveAck8->len);
 772 SwapBytes(m_aliveAck8->rnd);
 773 #endif
 774
 775 return sizeof(ALIVE_ACK_8);
 776 }
 777 //---------------------------------------------------------------------------
 778 int IA_CLIENT_PROT::Prepare_DISCONN_SYN_8(void* buffer)
 779 {
 780 m_disconnSyn8 = static_cast<DISCONN_SYN_8*>(buffer);
 781
 782 assert(Min8(sizeof(DISCONN_SYN_8)) == sizeof(DISCONN_SYN_8) && "DISCONN_SYN_8 is not aligned to 8 bytes");
 783
 784 m_disconnSyn8->len = sizeof(DISCONN_SYN_8);
 785
 786 #ifdef ARCH_BE
 787 SwapBytes(m_disconnSyn8->len);
 788 #endif
 789
 790 strncpy(reinterpret_cast<char*>(m_disconnSyn8->loginS), m_login.c_str(), IA_LOGIN_LEN);
 791 strncpy(reinterpret_cast<char*>(m_disconnSyn8->type), "DISCONN_SYN", IA_MAX_TYPE_LEN);
 792 strncpy(reinterpret_cast<char*>(m_disconnSyn8->login), m_login.c_str(), IA_LOGIN_LEN);
 793 return sizeof(DISCONN_SYN_8);
 794 }
 795 //---------------------------------------------------------------------------
 796 int IA_CLIENT_PROT::Prepare_DISCONN_ACK_8(void* buffer)
 797 {
 798 m_disconnAck8 = static_cast<DISCONN_ACK_8*>(buffer);
 799
 800 assert(Min8(sizeof(DISCONN_ACK_8)) == sizeof(DISCONN_ACK_8) && "DISCONN_ACK_8 is not aligned to 8 bytes");
 801
 802 m_disconnAck8->len = Min8(sizeof(DISCONN_ACK_8));
 803 m_disconnAck8->rnd = m_rnd + 1;
 804
 805 #ifdef ARCH_BE
 806 SwapBytes(m_disconnAck8->len);
 807 SwapBytes(m_disconnAck8->rnd);
 808 #endif
 809
 810 strncpy(reinterpret_cast<char*>(m_disconnAck8->loginS), m_login.c_str(), IA_LOGIN_LEN);
 811 strncpy(reinterpret_cast<char*>(m_disconnAck8->type), "DISCONN_ACK", IA_MAX_TYPE_LEN);
 812 return Min8(sizeof(DISCONN_ACK_8));
 813 }
 814 //---------------------------------------------------------------------------
 815 void IA_CLIENT_PROT::SetStatusChangedCb(tpStatusChangedCb p, void * data)
 816 {
 817 m_pStatusChangedCb = p;
 818 m_statusChangedCbData = data;
 819 }
 820 //---------------------------------------------------------------------------
 821 void IA_CLIENT_PROT::SetStatChangedCb(tpStatChangedCb p, void * data)
 822 {
 823 m_pStatChangedCb = p;
 824 m_statChangedCbData = data;
 825 }
 826 //---------------------------------------------------------------------------
 827 void IA_CLIENT_PROT::SetInfoCb(tpCallBackInfoFn p, void * data)
 828 {
 829 m_pInfoCb = p;
 830 m_infoCbData = data;
 831 }
 832 //---------------------------------------------------------------------------
 833 void IA_CLIENT_PROT::SetDirNameCb(tpCallBackDirNameFn p, void * data)
 834 {
 835 m_pDirNameCb = p;
 836 m_dirNameCbData = data;
 837 }
 838 //---------------------------------------------------------------------------
 839 void IA_CLIENT_PROT::SetErrorCb(tpCallBackErrorFn p, void * data)
 840 {
 841 m_pErrorCb = p;
 842 m_errorCbData = data;
 843 }
 844 //---------------------------------------------------------------------------