stglibs/ia_auth_c.lib/ia_auth_c.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 * Andrey Rakhmanov <andrey_rakhmanov@yahoo.com> - èñïðàâëåíèå äâóõ áàãîâ.
  27 */
  28
  29 //---------------------------------------------------------------------------
  30
  31 #include <cstdio>
  32 #include <cstdlib>
  33 #include <cstring>
  34 #include <cassert>
  35
  36 #ifdef WIN32
  37     #include <winsock2.h>
  38     #include <windows.h>
  39     #include <winbase.h>
  40     #include <winnt.h>
  41 #else
  42     #include <fcntl.h>
  43     #include <sys/types.h>
  44     #include <sys/socket.h>
  45     #include <netdb.h>
  46     #include <netinet/in.h>
  47     #include <arpa/inet.h>
  48     #include <unistd.h>
  49 #endif
  50
  51 #include "common.h"
  52 #include "ia_auth_c.h"
  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 void * RunL(void * data)
  67 {
  68
  69 IA_CLIENT_PROT * c = (IA_CLIENT_PROT *)data;
  70 static int a = 0;
  71
  72 if (a == 0)
  73     {
  74     usleep(50000);
  75     a = 1;
  76     }
  77
  78 while (c->GetNonstop())
  79     {
  80     c->Run();
  81     }
  82 return NULL;
  83 }
  84 //---------------------------------------------------------------------------
  85 void Sleep(int ms)
  86 {
  87 usleep(ms * 1000);
  88 }
  89 //---------------------------------------------------------------------------
  90 long GetTickCount()
  91 {
  92 struct timeval tv;
  93 gettimeofday(&tv, NULL);
  94 return tv.tv_sec*1000 + tv.tv_usec/1000;
  95 }
  96 #else
  97 //---------------------------------------------------------------------------
  98 unsigned long WINAPI RunW(void * data)
  99 {
 100 IA_CLIENT_PROT * c = (IA_CLIENT_PROT *)data;
 101 while (c->GetNonstop())
 102     c->Run();
 103 return 0;
 104 }
 105 //---------------------------------------------------------------------------
 106 #endif
 107 //---------------------------------------------------------------------------
 108 //---------------------------------------------------------------------------
 109 //---------------------------------------------------------------------------
 110 IA_CLIENT_PROT::IA_CLIENT_PROT(const string & sn, unsigned short p, uint16_t localPort)
 111     : action(IA_NONE),
 112       phase(1),
 113       phaseTime(0),
 114       codeError(0),
 115       nonstop(false),
 116       isNetPrepared(false),
 117       proxyMode(false),
 118       serverName(sn),
 119       port(p),
 120       ip(0),
 121       localPort(localPort),
 122       firstConnect(true),
 123       reconnect(0),
 124       sockr(0),
 125       protNum(0),
 126       userTimeout(60),
 127       aliveTimeout(5),
 128       rnd(0),
 129       pStatusChangedCb(NULL),
 130       pStatChangedCb(NULL),
 131       pInfoCb(NULL),
 132       pErrorCb(NULL),
 133       pDirNameCb(NULL),
 134       statusChangedCbData(NULL),
 135       statChangedCbData(NULL),
 136       infoCbData(NULL),
 137       errorCbData(NULL),
 138       dirNameCbData(NULL),
 139       connSyn8(NULL),
 140       connSynAck8(NULL),
 141       connAck8(NULL),
 142       aliveSyn8(NULL),
 143       aliveAck8(NULL),
 144       disconnSyn8(NULL),
 145       disconnSynAck8(NULL),
 146       disconnAck8(NULL),
 147       info(NULL)
 148 {
 149 memset(&stat, 0, sizeof(stat));
 150
 151 #ifdef WIN32
 152 WSAStartup(MAKEWORD(2, 0), &wsaData);
 153 #endif
 154
 155 packetTypes["CONN_SYN"] = CONN_SYN_N;
 156 packetTypes["CONN_SYN_ACK"] = CONN_SYN_ACK_N;
 157 packetTypes["CONN_ACK"] = CONN_ACK_N;
 158 packetTypes["ALIVE_SYN"] = ALIVE_SYN_N;
 159 packetTypes["ALIVE_ACK"] = ALIVE_ACK_N;
 160 packetTypes["DISCONN_SYN"] = DISCONN_SYN_N;
 161 packetTypes["DISCONN_SYN_ACK"] = DISCONN_SYN_ACK_N;
 162 packetTypes["DISCONN_ACK"] = DISCONN_ACK_N;
 163 packetTypes["FIN"] = FIN_N;
 164 packetTypes["ERR"] = ERROR_N;
 165 packetTypes["INFO"] = INFO_N;
 166 packetTypes["INFO_7"] = INFO_7_N;
 167 packetTypes["INFO_8"] = INFO_8_N;
 168
 169 unsigned char key[IA_PASSWD_LEN];
 170 memset(key, 0, IA_PASSWD_LEN);
 171 strncpy((char *)key, "pr7Hhen", 8);
 172 Blowfish_Init(&ctxHdr, key, IA_PASSWD_LEN);
 173
 174 memset(key, 0, IA_PASSWD_LEN);
 175 Blowfish_Init(&ctxPass, key, IA_PASSWD_LEN);
 176
 177 for (size_t i = 0; i < DIR_NUM; ++i)
 178     {
 179     selectedDirs[i] = false;
 180     }
 181
 182 servAddr.sin_family = AF_INET;
 183 servAddr.sin_port = htons(port);
 184 servAddr.sin_addr.s_addr = ip;
 185 }
 186 //---------------------------------------------------------------------------
 187 void IA_CLIENT_PROT::PrepareNet()
 188 {
 189 struct hostent * phe;
 190 unsigned long ip;
 191
 192 ip = inet_addr(serverName.c_str());
 193 if (ip == INADDR_NONE)
 194     {
 195     phe = gethostbyname(serverName.c_str());
 196     if (phe)
 197         {
 198         ip = *((unsigned long*)phe->h_addr_list[0]);
 199         }
 200     else
 201         {
 202         strError = string("Unknown host ") + "\'" + serverName + "\'";
 203         codeError = IA_GETHOSTBYNAME_ERROR;
 204         if (pErrorCb != NULL)
 205             pErrorCb(strError, IA_GETHOSTBYNAME_ERROR, errorCbData);
 206         }
 207     }
 208
 209 #ifndef WIN32
 210 close(sockr);
 211 #else
 212 closesocket(sockr);
 213 #endif
 214
 215 sockr = socket(AF_INET, SOCK_DGRAM, 0);  // Cîêåò ÷åðåç êîòîðûé øëåì è ïðèíèìàåì
 216
 217 struct sockaddr_in  localAddrR;      // Íàø àäðåñ
 218 localAddrR.sin_family = AF_INET;
 219
 220 if (localPort)
 221     localAddrR.sin_port = htons(localPort);
 222 else
 223     localAddrR.sin_port = htons(port);
 224 localAddrR.sin_addr.s_addr = inet_addr("0.0.0.0");
 225
 226 servAddr.sin_family = AF_INET;
 227 servAddr.sin_port = htons(port);
 228 servAddr.sin_addr.s_addr = ip;
 229
 230 int res = bind(sockr, (struct sockaddr*)&localAddrR, sizeof(localAddrR));
 231 if (res == -1)
 232     {
 233     strError = "bind error";
 234     codeError = IA_BIND_ERROR;
 235     if (pErrorCb != NULL)
 236         pErrorCb(strError, IA_BIND_ERROR, errorCbData);
 237     return;
 238     }
 239
 240 #ifdef WIN32
 241 unsigned long arg = 1;
 242 res = ioctlsocket(sockr, FIONBIO, &arg);
 243 #else
 244 if (0 != fcntl(sockr, F_SETFL, O_NONBLOCK))
 245     {
 246     strError = "fcntl error";
 247     codeError = IA_FCNTL_ERROR;
 248     if (pErrorCb != NULL)
 249         pErrorCb(strError, IA_FCNTL_ERROR, errorCbData);
 250     }
 251 #endif
 252
 253 }
 254 //---------------------------------------------------------------------------
 255 IA_CLIENT_PROT::~IA_CLIENT_PROT()
 256 {
 257 #ifndef WIN32
 258 close(sockr);
 259 #else
 260 closesocket(sockr);
 261 WSACleanup();
 262 #endif
 263 }
 264 //---------------------------------------------------------------------------
 265 int IA_CLIENT_PROT::DeterminatePacketType(const char * buffer)
 266 {
 267 map<string, int>::iterator pi;
 268 pi = packetTypes.find(buffer);
 269 if (pi == packetTypes.end())
 270     {
 271     return -1;
 272     }
 273 else
 274     {
 275     return pi->second;
 276     }
 277 }
 278 //---------------------------------------------------------------------------
 279 void IA_CLIENT_PROT::FillHdr8(char * buffer, unsigned long)
 280 {
 281 strncpy(buffer, IA_ID, 6);
 282 buffer[IA_MAGIC_LEN] = 0;
 283 buffer[IA_MAGIC_LEN + 1] = IA_PROTO_VER;
 284 strncpy(buffer + sizeof(HDR_8), login.c_str(), IA_LOGIN_LEN);
 285 }
 286 //---------------------------------------------------------------------------
 287 int IA_CLIENT_PROT::Send(char * buffer, int len)
 288 {
 289 if (!isNetPrepared)
 290     {
 291     PrepareNet();
 292     isNetPrepared = true;
 293     }
 294
 295 // Øèôðóåì LoginS
 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 // Øèôðóåì âñ¸ îñòàëüíîå
 303 db += IA_LOGIN_LEN;
 304 int encLen = (len - sizeof(HDR_8) - IA_LOGIN_LEN)/8;
 305 for (int i = 0; i < encLen; i++)
 306     {
 307     Blowfish_Encrypt(&ctxPass, (uint32_t*)(buffer + db), (uint32_t*)(buffer + db + 4));
 308     db += 8;
 309     }
 310
 311 return sendto(sockr, buffer, len, 0, (struct sockaddr*)&servAddr, sizeof(servAddr));
 312 }
 313 //---------------------------------------------------------------------------
 314 int IA_CLIENT_PROT::Recv(char * buffer, int len)
 315 {
 316 #ifdef WIN32
 317 int fromLen;
 318 #else
 319 socklen_t fromLen;
 320 #endif
 321
 322 struct sockaddr_in addr;
 323 fromLen = sizeof(addr);
 324 int res = recvfrom(sockr, buffer, len, 0, (struct sockaddr*)&addr, &fromLen);
 325
 326 if (res == -1)
 327     return res;
 328
 329 if (strcmp(buffer + 4 + sizeof(HDR_8), "ERR"))
 330     {
 331     for (int i = 0; i < len/8; i++)
 332         Blowfish_Decrypt(&ctxPass, (uint32_t*)(buffer + i*8), (uint32_t*)(buffer + i*8 + 4));
 333     }
 334
 335 return 0;
 336 }
 337 //---------------------------------------------------------------------------
 338 int IA_CLIENT_PROT::NetSend(int n)
 339 {
 340 char buffer[2048];
 341 int msgLen;
 342
 343 memset(buffer, 0, 2048);
 344
 345 switch (n)
 346     {
 347     case CONN_SYN_N:
 348         msgLen = Prepare_CONN_SYN_8(buffer);
 349         break;
 350
 351     case CONN_ACK_N:
 352         msgLen = Prepare_CONN_ACK_8(buffer);
 353         break;
 354
 355     case ALIVE_ACK_N:
 356         msgLen = Prepare_ALIVE_ACK_8(buffer);
 357         break;
 358
 359     case DISCONN_SYN_N:
 360         msgLen = Prepare_DISCONN_SYN_8(buffer);
 361         break;
 362
 363     case DISCONN_ACK_N:
 364         msgLen = Prepare_DISCONN_ACK_8(buffer);
 365         break;
 366
 367     default:
 368         return -1;
 369     }
 370
 371 FillHdr8(buffer, 0);
 372 Send(buffer, msgLen);
 373
 374 return 0;
 375 }
 376 //---------------------------------------------------------------------------
 377 int IA_CLIENT_PROT::NetRecv()
 378 {
 379 char buffer[2048];
 380
 381 if (Recv(buffer, sizeof(buffer)) < 0)
 382     return -1;
 383
 384 char packetName[20];
 385 strncpy(packetName, buffer + 12, sizeof(packetName));
 386 packetName[sizeof(packetName) - 1] = 0;
 387 int pn = DeterminatePacketType(buffer + 12);
 388
 389 int ret;
 390 switch (pn)
 391     {
 392     case CONN_SYN_ACK_N:
 393         ret = Process_CONN_SYN_ACK_8(buffer);
 394         break;
 395
 396     case ALIVE_SYN_N:
 397         ret = Process_ALIVE_SYN_8(buffer);
 398         break;
 399
 400     case DISCONN_SYN_ACK_N:
 401         ret = Process_DISCONN_SYN_ACK_8(buffer);
 402         break;
 403
 404     case FIN_N:
 405         ret = Process_FIN_8(buffer);
 406         break;
 407
 408     case INFO_8_N:
 409         ret = Process_INFO_8(buffer);
 410         break;
 411
 412     case ERROR_N:
 413         ret = Process_ERROR(buffer);
 414         break;
 415
 416     default:
 417         ret = -1;
 418     }
 419 return ret;
 420 }
 421 //---------------------------------------------------------------------------
 422 void IA_CLIENT_PROT::Start()
 423 {
 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 memcpy(&err, buffer, sizeof(err));
 700
 701 #ifdef ARCH_BE
 702 SwapBytes(err.len);
 703 #endif
 704
 705 KOIToWin((const char*)err.text, &messageText);
 706 if (pErrorCb != NULL)
 707     pErrorCb(messageText, IA_SERVER_ERROR, errorCbData);
 708 phase = 1;
 709 phaseTime = GetTickCount();
 710 codeError = IA_SERVER_ERROR;
 711
 712 return ERROR_N;
 713 }
 714 //---------------------------------------------------------------------------
 715 int IA_CLIENT_PROT::Prepare_CONN_SYN_8(char * buffer)
 716 {
 717 connSyn8 = (CONN_SYN_8*)buffer;
 718
 719 #ifdef ARCH_BE
 720 SwapBytes(connSyn8->len);
 721 #endif
 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 strncpy((char*)connSyn8->type, "CONN_SYN", IA_MAX_TYPE_LEN);
 727 strncpy((char*)connSyn8->login, login.c_str(), IA_LOGIN_LEN);
 728 connSyn8->dirs = 0;
 729 for (int i = 0; i < DIR_NUM; i++)
 730     {
 731     connSyn8->dirs |= (selectedDirs[i] << i);
 732     }
 733 return connSyn8->len;
 734 }
 735 //---------------------------------------------------------------------------
 736 int IA_CLIENT_PROT::Prepare_CONN_ACK_8(char * buffer)
 737 {
 738 connAck8 = (CONN_ACK_8*)buffer;
 739
 740 #ifdef ARCH_BE
 741 SwapBytes(connAck8->len);
 742 SwapBytes(connAck8->rnd);
 743 #endif
 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 return connAck8->len;
 754 }
 755 //---------------------------------------------------------------------------
 756 int IA_CLIENT_PROT::Prepare_ALIVE_ACK_8(char * buffer)
 757 {
 758 aliveAck8 = (ALIVE_ACK_8*)buffer;
 759
 760 #ifdef ARCH_BE
 761 SwapBytes(aliveAck8->len);
 762 SwapBytes(aliveAck8->rnd);
 763 #endif
 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 return aliveAck8->len;
 773 }
 774 //---------------------------------------------------------------------------
 775 int IA_CLIENT_PROT::Prepare_DISCONN_SYN_8(char * buffer)
 776 {
 777 disconnSyn8 = (DISCONN_SYN_8*)buffer;
 778
 779 #ifdef ARCH_BE
 780 SwapBytes(disconnSyn8->len);
 781 #endif
 782
 783 assert(Min8(sizeof(DISCONN_SYN_8)) == sizeof(DISCONN_SYN_8) && "DISCONN_SYN_8 is not aligned to 8 bytes");
 784
 785 disconnSyn8->len = sizeof(DISCONN_SYN_8);
 786 strncpy((char*)disconnSyn8->loginS, login.c_str(), IA_LOGIN_LEN);
 787 strncpy((char*)disconnSyn8->type, "DISCONN_SYN", IA_MAX_TYPE_LEN);
 788 strncpy((char*)disconnSyn8->login, login.c_str(), IA_LOGIN_LEN);
 789 return disconnSyn8->len;
 790 }
 791 //---------------------------------------------------------------------------
 792 int IA_CLIENT_PROT::Prepare_DISCONN_ACK_8(char * buffer)
 793 {
 794 disconnAck8 = (DISCONN_ACK_8*)buffer;
 795
 796 #ifdef ARCH_BE
 797 SwapBytes(disconnAck8->len);
 798 SwapBytes(disconnAck8->rnd);
 799 #endif
 800
 801 assert(Min8(sizeof(DISCONN_ACK_8)) == sizeof(DISCONN_ACK_8) && "DISCONN_ACK_8 is not aligned to 8 bytes");
 802
 803 disconnAck8->len = Min8(sizeof(DISCONN_ACK_8));
 804 disconnAck8->rnd = rnd + 1;
 805 strncpy((char*)disconnAck8->loginS, login.c_str(), IA_LOGIN_LEN);
 806 strncpy((char*)disconnAck8->type, "DISCONN_ACK", IA_MAX_TYPE_LEN);
 807 return disconnAck8->len;
 808 }
 809 //---------------------------------------------------------------------------
 810 void IA_CLIENT_PROT::SetStatusChangedCb(tpStatusChangedCb p, void * data)
 811 {
 812 pStatusChangedCb = p;
 813 statusChangedCbData = data;
 814 }
 815 //---------------------------------------------------------------------------
 816 void IA_CLIENT_PROT::SetStatChangedCb(tpStatChangedCb p, void * data)
 817 {
 818 pStatChangedCb = p;
 819 statChangedCbData = data;
 820 }
 821 //---------------------------------------------------------------------------
 822 void IA_CLIENT_PROT::SetInfoCb(tpCallBackInfoFn p, void * data)
 823 {
 824 pInfoCb = p;
 825 infoCbData = data;
 826 }
 827 //---------------------------------------------------------------------------
 828 void IA_CLIENT_PROT::SetDirNameCb(tpCallBackDirNameFn p, void * data)
 829 {
 830 pDirNameCb = p;
 831 dirNameCbData = data;
 832 }
 833 //---------------------------------------------------------------------------
 834 void IA_CLIENT_PROT::SetErrorCb(tpCallBackErrorFn p, void * data)
 835 {
 836 pErrorCb = p;
 837 errorCbData = data;
 838 }
 839 //---------------------------------------------------------------------------