]> git.stg.codes - stg.git/blob - stglibs/ia.lib/ia.cpp
Ticket 12. The 'StopOnError' parameter added.
[stg.git] / 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 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 EncryptString(buffer + db, buffer + db, IA_LOGIN_LEN, &ctxHdr);
355
356 db += IA_LOGIN_LEN;
357 int encLen = (len - sizeof(HDR_8) - IA_LOGIN_LEN);
358 EncryptString(buffer + db, buffer + db, encLen, &ctxPass);
359
360 return sendto(sockr, buffer, len, 0, (struct sockaddr*)&servAddr, sizeof(servAddr));
361 }
362 //---------------------------------------------------------------------------
363 int IA_CLIENT_PROT::Recv(char * buffer, int len)
364 {
365 #ifdef WIN32
366 int fromLen;
367 #else
368 socklen_t fromLen;
369 #endif
370
371 struct sockaddr_in addr;
372 fromLen = sizeof(addr);
373 int res = recvfrom(sockr, buffer, len, 0, (struct sockaddr*)&addr, &fromLen);
374
375 if (res == -1)
376     return res;
377
378 if (strcmp(buffer + 4 + sizeof(HDR_8), "ERR"))
379     DecryptString(buffer, buffer, len, &ctxPass);
380
381 return 0;
382 }
383 //---------------------------------------------------------------------------
384 int IA_CLIENT_PROT::NetSend(int n)
385 {
386 char buffer[2048];
387 int msgLen;
388
389 memset(buffer, 0, 2048);
390
391 switch (n)
392     {
393     case CONN_SYN_N:
394         msgLen = Prepare_CONN_SYN_8(buffer);
395         break;
396
397     case CONN_ACK_N:
398         msgLen = Prepare_CONN_ACK_8(buffer);
399         break;
400
401     case ALIVE_ACK_N:
402         msgLen = Prepare_ALIVE_ACK_8(buffer);
403         break;
404
405     case DISCONN_SYN_N:
406         msgLen = Prepare_DISCONN_SYN_8(buffer);
407         break;
408
409     case DISCONN_ACK_N:
410         msgLen = Prepare_DISCONN_ACK_8(buffer);
411         break;
412
413     default:
414         return -1;
415     }
416
417 FillHdr8(buffer, 0);
418 Send(buffer, msgLen);
419
420 return 0;
421 }
422 //---------------------------------------------------------------------------
423 int IA_CLIENT_PROT::NetRecv()
424 {
425 char buffer[2048];
426
427 if (Recv(buffer, sizeof(buffer)) < 0)
428     return -1;
429
430 char packetName[20];
431 strncpy(packetName, buffer + 12, sizeof(packetName));
432 packetName[sizeof(packetName) - 1] = 0;
433 int pn = DeterminatePacketType(buffer + 12);
434
435 int ret;
436 switch (pn)
437     {
438     case CONN_SYN_ACK_N:
439         ret = Process_CONN_SYN_ACK_8(buffer);
440         break;
441
442     case ALIVE_SYN_N:
443         ret = Process_ALIVE_SYN_8(buffer);
444         break;
445
446     case DISCONN_SYN_ACK_N:
447         ret = Process_DISCONN_SYN_ACK_8(buffer);
448         break;
449
450     case FIN_N:
451         ret = Process_FIN_8(buffer);
452         break;
453
454     case INFO_8_N:
455         ret = Process_INFO_8(buffer);
456         break;
457
458     case ERROR_N:
459         ret = Process_ERROR(buffer);
460         break;
461
462     default:
463         ret = -1;
464     }
465 return ret;
466 }
467 //---------------------------------------------------------------------------
468 void IA_CLIENT_PROT::Start()
469 {
470 nonstop = true;
471 #ifdef WIN32
472 unsigned long pt;
473 CreateThread(NULL, 16384, RunW, this, 0, &pt);
474 #else
475 pthread_create(&thread, NULL, RunL, this);
476 #endif
477 }
478 //---------------------------------------------------------------------------
479 void IA_CLIENT_PROT::Stop()
480 {
481 nonstop = false;
482 }
483 //---------------------------------------------------------------------------
484 void IA_CLIENT_PROT::Run()
485 {
486 NetRecv();
487
488 switch (phase)
489     {
490     case 1:
491         if (action == IA_CONNECT)
492             {
493             action = IA_NONE;
494             NetSend(CONN_SYN_N);
495             phase = 2;
496             phaseTime = GetTickCount();
497             }
498         if (reconnect && !firstConnect)
499             {
500             action = IA_CONNECT;
501             }
502         break;
503
504     case 2:
505         if ((int)(GetTickCount() - phaseTime)/1000 > aliveTimeout)
506             {
507             phase = 1;
508             phaseTime = GetTickCount();
509             if (pStatusChangedCb != NULL)
510                 pStatusChangedCb(0, statusChangedCbData);
511             }
512
513         if (action == IA_DISCONNECT)
514             {
515             action = IA_NONE;
516             NetSend(DISCONN_SYN_N);
517             phase = 4;
518             phaseTime = GetTickCount();
519             }
520
521         break;
522
523     case 3:
524         if ((int)(GetTickCount() - phaseTime)/1000 > userTimeout)
525             {
526             phase = 1;
527             phaseTime = GetTickCount();
528             if (pStatusChangedCb != NULL)
529                 pStatusChangedCb(0, statusChangedCbData);
530             firstConnect = false;
531             }
532
533         if (action == IA_DISCONNECT)
534             {
535             action = IA_NONE;
536             NetSend(DISCONN_SYN_N);
537             phase = 4;
538             phaseTime = GetTickCount();
539             }
540
541         break;
542
543     case 4:
544         if ((int)(GetTickCount() - phaseTime)/1000 > aliveTimeout)
545             {
546             phase=1;
547             phaseTime = GetTickCount();
548             if (pStatusChangedCb != NULL)
549                 pStatusChangedCb(0, statusChangedCbData);
550             }
551
552         if (action == IA_CONNECT)
553             {
554             action = IA_NONE;
555             NetSend(CONN_SYN_N);
556             phase = 2;
557             phaseTime = GetTickCount();
558             }
559
560         break;
561
562     case 5:
563         if ((int)(GetTickCount() - phaseTime)/1000 > aliveTimeout)
564             {
565             phase = 1;
566             phaseTime = GetTickCount();
567             if (pStatusChangedCb != NULL)
568                 pStatusChangedCb(0, statusChangedCbData);
569             }
570
571         if (action == IA_CONNECT)
572             {
573             action = IA_NONE;
574             NetSend(CONN_SYN_N);
575             phase = 2;
576             phaseTime = GetTickCount();
577             }
578
579         break;
580     }
581 Sleep(20);
582 return;
583 }
584 //---------------------------------------------------------------------------
585 void IA_CLIENT_PROT::GetStat(LOADSTAT * ls)
586 {
587 memcpy(ls, &stat, sizeof(stat));
588 }
589 //---------------------------------------------------------------------------
590 void IA_CLIENT_PROT::SetServer(const std::string & sn, unsigned short p)
591 {
592 serverName = sn;
593 port = p;
594 PrepareNet();
595 }
596 //---------------------------------------------------------------------------
597 void IA_CLIENT_PROT::SetLogin(const std::string & l)
598 {
599 login = l;
600 }
601 //---------------------------------------------------------------------------
602 void IA_CLIENT_PROT::SetPassword(const std::string & p)
603 {
604 password = p;
605
606 unsigned char keyL[IA_PASSWD_LEN];
607 memset(keyL, 0, IA_PASSWD_LEN);
608 strncpy((char *)keyL, password.c_str(), IA_PASSWD_LEN);
609 Blowfish_Init(&ctxPass, keyL, IA_PASSWD_LEN);
610 }
611 //---------------------------------------------------------------------------
612 void IA_CLIENT_PROT::SetEnabledDirs(const bool * selectedDirs)
613 {
614 memcpy(IA_CLIENT_PROT::selectedDirs, selectedDirs, sizeof(bool) * DIR_NUM);
615 }
616 //---------------------------------------------------------------------------
617 int IA_CLIENT_PROT::Connect()
618 {
619 action = IA_CONNECT;
620 return 0;
621 }
622 //---------------------------------------------------------------------------
623 int IA_CLIENT_PROT::Disconnect()
624 {
625 firstConnect = true;
626 action = IA_DISCONNECT;
627 return 0;
628 }
629 //---------------------------------------------------------------------------
630 int IA_CLIENT_PROT::GetStrError(std::string * error) const
631 {
632 int ret = codeError;
633 *error = strError;
634 strError = "";
635 codeError = 0;
636 return ret;
637 }
638 //---------------------------------------------------------------------------
639 int IA_CLIENT_PROT::Process_CONN_SYN_ACK_8(const char * buffer)
640 {
641 std::vector<std::string> dirNames;
642 connSynAck8 = (CONN_SYN_ACK_8*)buffer;
643
644 #ifdef ARCH_BE
645 SwapBytes(connSynAck8->len);
646 SwapBytes(connSynAck8->rnd);
647 SwapBytes(connSynAck8->userTimeOut);
648 SwapBytes(connSynAck8->aliveDelay);
649 #endif
650
651 rnd = connSynAck8->rnd;
652 userTimeout = connSynAck8->userTimeOut;
653 aliveTimeout = connSynAck8->aliveDelay;
654
655 for (int i = 0; i < DIR_NUM; i++)
656     {
657     dirNames.push_back((const char*)connSynAck8->dirName[i]);
658     }
659
660 if (pDirNameCb != NULL)
661     pDirNameCb(dirNames, dirNameCbData);
662
663 NetSend(CONN_ACK_N);
664 phase = 3;
665 phaseTime = GetTickCount();
666
667 return CONN_SYN_ACK_N;
668 }
669 //---------------------------------------------------------------------------
670 int IA_CLIENT_PROT::Process_ALIVE_SYN_8(const char * buffer)
671 {
672 aliveSyn8 = (ALIVE_SYN_8*)buffer;
673
674 #ifdef ARCH_BE
675 SwapBytes(aliveSyn8->len);
676 SwapBytes(aliveSyn8->rnd);
677 SwapBytes(aliveSyn8->cash);
678 SwapBytes(aliveSyn8->status);
679 for (int i = 0; i < DIR_NUM; ++i)
680     {
681     SwapBytes(aliveSyn8->mu[i]);
682     SwapBytes(aliveSyn8->md[i]);
683     SwapBytes(aliveSyn8->su[i]);
684     SwapBytes(aliveSyn8->sd[i]);
685     }
686 #endif
687
688 rnd = aliveSyn8->rnd;
689 memcpy(&stat, (char*)aliveSyn8->mu, sizeof(stat));
690
691 if (pStatChangedCb != NULL)
692     pStatChangedCb(stat, statChangedCbData);
693
694 if (pStatusChangedCb != NULL)
695     pStatusChangedCb(1, statusChangedCbData);
696 NetSend(ALIVE_ACK_N);
697 phaseTime = GetTickCount();
698
699 return ALIVE_SYN_N;
700 }
701 //---------------------------------------------------------------------------
702 int IA_CLIENT_PROT::Process_DISCONN_SYN_ACK_8(const char * buffer)
703 {
704 disconnSynAck8 = (DISCONN_SYN_ACK_8*)buffer;
705
706 #ifdef ARCH_BE
707 SwapBytes(disconnSynAck8->len);
708 SwapBytes(disconnSynAck8->rnd);
709 #endif
710
711 rnd = disconnSynAck8->rnd;
712
713 NetSend(DISCONN_ACK_N);
714 phase = 5;
715 phaseTime = GetTickCount();
716
717 return DISCONN_SYN_ACK_N;
718 }
719 //---------------------------------------------------------------------------
720 int IA_CLIENT_PROT::Process_FIN_8(const char *)
721 {
722 phase = 1;
723 phaseTime = GetTickCount();
724 if (pStatusChangedCb != NULL)
725     pStatusChangedCb(0, statusChangedCbData);
726
727 return FIN_N;
728 }
729 //---------------------------------------------------------------------------
730 int IA_CLIENT_PROT::Process_INFO_8(const char * buffer)
731 {
732 info = (INFO_8*)buffer;
733
734 #ifdef ARCH_BE
735 SwapBytes(info->len);
736 SwapBytes(info->sendTime);
737 #endif
738
739 if (pInfoCb != NULL)
740     pInfoCb((char*)info->text, info->infoType, info->showTime, info->sendTime, infoCbData);
741 return INFO_8_N;
742 }
743 //---------------------------------------------------------------------------
744 int IA_CLIENT_PROT::Process_ERROR(const char * buffer)
745 {
746 ERR_8 err;
747 memcpy(&err, buffer, sizeof(err));
748
749 #ifdef ARCH_BE
750 SwapBytes(err.len);
751 #endif
752
753 KOIToWin((const char*)err.text, &messageText);
754 if (pErrorCb != NULL)
755     pErrorCb(messageText, IA_SERVER_ERROR, errorCbData);
756 phase = 1;
757 phaseTime = GetTickCount();
758 codeError = IA_SERVER_ERROR;
759
760 return ERROR_N;
761 }
762 //---------------------------------------------------------------------------
763 int IA_CLIENT_PROT::Prepare_CONN_SYN_8(char * buffer)
764 {
765 connSyn8 = (CONN_SYN_8*)buffer;
766
767 assert(sizeof(CONN_SYN_8) == Min8(sizeof(CONN_SYN_8)) && "CONN_SYN_8 is not aligned to 8 bytes");
768
769 connSyn8->len = sizeof(CONN_SYN_8);
770
771 #ifdef ARCH_BE
772 SwapBytes(connSyn8->len);
773 #endif
774
775 strncpy((char*)connSyn8->type, "CONN_SYN", IA_MAX_TYPE_LEN);
776 strncpy((char*)connSyn8->login, login.c_str(), IA_LOGIN_LEN);
777 connSyn8->dirs = 0;
778 for (int i = 0; i < DIR_NUM; i++)
779     {
780     connSyn8->dirs |= (selectedDirs[i] << i);
781     }
782 return sizeof(CONN_SYN_8);
783 }
784 //---------------------------------------------------------------------------
785 int IA_CLIENT_PROT::Prepare_CONN_ACK_8(char * buffer)
786 {
787 connAck8 = (CONN_ACK_8*)buffer;
788
789 assert(sizeof(CONN_ACK_8) == Min8(sizeof(CONN_ACK_8)) && "CONN_ACK_8 is not aligned to 8 bytes");
790
791 connAck8->len = sizeof(CONN_ACK_8);
792 strncpy((char*)connAck8->loginS, login.c_str(), IA_LOGIN_LEN);
793 strncpy((char*)connAck8->type, "CONN_ACK", IA_MAX_TYPE_LEN);
794 rnd++;
795 connAck8->rnd = rnd;
796
797 #ifdef ARCH_BE
798 SwapBytes(connAck8->len);
799 SwapBytes(connAck8->rnd);
800 #endif
801
802 return sizeof(CONN_ACK_8);
803 }
804 //---------------------------------------------------------------------------
805 int IA_CLIENT_PROT::Prepare_ALIVE_ACK_8(char * buffer)
806 {
807 aliveAck8 = (ALIVE_ACK_8*)buffer;
808
809 assert(Min8(sizeof(ALIVE_ACK_8)) == sizeof(ALIVE_ACK_8) && "ALIVE_ACK_8 is not aligned to 8 bytes");
810
811 aliveAck8 = (ALIVE_ACK_8*)buffer;
812 aliveAck8->len = sizeof(ALIVE_ACK_8);
813 strncpy((char*)aliveAck8->loginS, login.c_str(), IA_LOGIN_LEN);
814 strncpy((char*)aliveAck8->type, "ALIVE_ACK", IA_MAX_TYPE_LEN);
815 aliveAck8->rnd = ++rnd;
816
817 #ifdef ARCH_BE
818 SwapBytes(aliveAck8->len);
819 SwapBytes(aliveAck8->rnd);
820 #endif
821
822 return sizeof(ALIVE_ACK_8);
823 }
824 //---------------------------------------------------------------------------
825 int IA_CLIENT_PROT::Prepare_DISCONN_SYN_8(char * buffer)
826 {
827 disconnSyn8 = (DISCONN_SYN_8*)buffer;
828
829 assert(Min8(sizeof(DISCONN_SYN_8)) == sizeof(DISCONN_SYN_8) && "DISCONN_SYN_8 is not aligned to 8 bytes");
830
831 disconnSyn8->len = sizeof(DISCONN_SYN_8);
832
833 #ifdef ARCH_BE
834 SwapBytes(disconnSyn8->len);
835 #endif
836
837 strncpy((char*)disconnSyn8->loginS, login.c_str(), IA_LOGIN_LEN);
838 strncpy((char*)disconnSyn8->type, "DISCONN_SYN", IA_MAX_TYPE_LEN);
839 strncpy((char*)disconnSyn8->login, login.c_str(), IA_LOGIN_LEN);
840 return sizeof(DISCONN_SYN_8);
841 }
842 //---------------------------------------------------------------------------
843 int IA_CLIENT_PROT::Prepare_DISCONN_ACK_8(char * buffer)
844 {
845 disconnAck8 = (DISCONN_ACK_8*)buffer;
846
847 assert(Min8(sizeof(DISCONN_ACK_8)) == sizeof(DISCONN_ACK_8) && "DISCONN_ACK_8 is not aligned to 8 bytes");
848
849 disconnAck8->len = Min8(sizeof(DISCONN_ACK_8));
850 disconnAck8->rnd = rnd + 1;
851
852 #ifdef ARCH_BE
853 SwapBytes(disconnAck8->len);
854 SwapBytes(disconnAck8->rnd);
855 #endif
856
857 strncpy((char*)disconnAck8->loginS, login.c_str(), IA_LOGIN_LEN);
858 strncpy((char*)disconnAck8->type, "DISCONN_ACK", IA_MAX_TYPE_LEN);
859 return Min8(sizeof(DISCONN_ACK_8));
860 }
861 //---------------------------------------------------------------------------
862 void IA_CLIENT_PROT::SetStatusChangedCb(tpStatusChangedCb p, void * data)
863 {
864 pStatusChangedCb = p;
865 statusChangedCbData = data;
866 }
867 //---------------------------------------------------------------------------
868 void IA_CLIENT_PROT::SetStatChangedCb(tpStatChangedCb p, void * data)
869 {
870 pStatChangedCb = p;
871 statChangedCbData = data;
872 }
873 //---------------------------------------------------------------------------
874 void IA_CLIENT_PROT::SetInfoCb(tpCallBackInfoFn p, void * data)
875 {
876 pInfoCb = p;
877 infoCbData = data;
878 }
879 //---------------------------------------------------------------------------
880 void IA_CLIENT_PROT::SetDirNameCb(tpCallBackDirNameFn p, void * data)
881 {
882 pDirNameCb = p;
883 dirNameCbData = data;
884 }
885 //---------------------------------------------------------------------------
886 void IA_CLIENT_PROT::SetErrorCb(tpCallBackErrorFn p, void * data)
887 {
888 pErrorCb = p;
889 errorCbData = data;
890 }
891 //---------------------------------------------------------------------------