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