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