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