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