]> git.stg.codes - stg.git/blob - stglibs/srvconf.lib/netunit.cpp
ec796f7f1506a40885b041d74d5e86146675c268
[stg.git] / stglibs / srvconf.lib / netunit.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 2 of the License, or
5  *    (at your option) 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  */
16
17 /*
18  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
19  */
20
21  /*
22  $Revision: 1.6 $
23  $Date: 2009/02/06 10:25:54 $
24  $Author: faust $
25  */
26
27 //---------------------------------------------------------------------------
28 #include <stdio.h>
29 #include <string.h>
30 #include <netdb.h>
31 #include <arpa/inet.h>
32 #include <unistd.h>
33
34 #include "netunit.h"
35 #include "common.h"
36
37 //---------------------------------------------------------------------------
38
39 #define SEND_DATA_ERROR             "Send data error!"
40 #define RECV_DATA_ANSWER_ERROR      "Recv data answer error!"
41 #define UNKNOWN_ERROR               "Unknown error!"
42 #define CONNECT_FAILED              "Connect failed!"
43 #define INCORRECT_LOGIN             "Incorrect login!"
44 #define INCORRECT_HEADER            "Incorrect header!"
45 #define SEND_LOGIN_ERROR            "Send login error!"
46 #define RECV_LOGIN_ANSWER_ERROR     "Recv login answer error!"
47 #define CREATE_SOCKET_ERROR         "Create socket failed!"
48 #define WSASTARTUP_FAILED           "WSAStartup failed!"
49 #define SEND_HEADER_ERROR           "Send header error!"
50 #define RECV_HEADER_ANSWER_ERROR    "Recv header answer error!"
51
52 //---------------------------------------------------------------------------
53 NETTRANSACT::NETTRANSACT()
54     : port(0),
55       outerSocket(-1),
56       RxCallBack(NULL),
57       dataRxCallBack(NULL)
58 {
59     memset(server, 0, SERVER_NAME_LEN);
60     memset(login, 0, ADM_LOGIN_LEN);
61     memset(password, 0, ADM_PASSWD_LEN);
62     memset(errorMsg, 0, MAX_ERR_STR_LEN);
63 }
64 //-----------------------------------------------------------------------------
65 void NETTRANSACT::EnDecryptInit(const char * passwd, int, BLOWFISH_CTX *ctx)
66 {
67 unsigned char * keyL = NULL; // ��� ������
68
69 keyL = new unsigned char[PASSWD_LEN];
70
71 memset(keyL, 0, PASSWD_LEN);
72
73 strncpy((char *)keyL, passwd, PASSWD_LEN);
74
75 Blowfish_Init(ctx, keyL, PASSWD_LEN);
76
77 delete[] keyL;
78 }
79 //-----------------------------------------------------------------------------
80 void NETTRANSACT::Encrypt(char * d, const char * s, BLOWFISH_CTX *ctx)
81 {
82 EncodeString(d, s, ctx);
83 }
84 //---------------------------------------------------------------------------
85 void NETTRANSACT::Decrypt(char * d, const char * s, BLOWFISH_CTX *ctx)
86 {
87 DecodeString(d, s, ctx);
88 }
89 //---------------------------------------------------------------------------
90 int NETTRANSACT::Connect()
91 {
92 int ret;
93
94 outerSocket = socket(PF_INET, SOCK_STREAM, 0);
95 if (outerSocket < 0)
96     {
97     strcpy(errorMsg, CREATE_SOCKET_ERROR);
98     return st_conn_fail;
99     }
100
101 struct sockaddr_in outerAddr;
102 memset(&outerAddr, 0, sizeof(outerAddr));
103
104 struct hostent he;
105 struct hostent * phe;
106
107 unsigned long ip;
108 ip = inet_addr(server);
109
110 if (ip == INADDR_NONE)
111     {
112     phe = gethostbyname(server);
113     if (phe == NULL)
114         {
115         sprintf(errorMsg, "DNS error.\nCan not reslove %s", server);
116         return st_dns_err;
117         }
118
119     memcpy(&he, phe, sizeof(he));
120     ip = *((long*)he.h_addr_list[0]);
121     }
122 outerAddr.sin_family = AF_INET;
123 outerAddr.sin_port = htons(port);
124 outerAddr.sin_addr.s_addr = ip;
125
126 ret = connect(outerSocket, (struct sockaddr*)&outerAddr, sizeof(outerAddr));
127
128 if (ret < 0)
129     {
130     strcpy(errorMsg, CONNECT_FAILED);
131     close(outerSocket);
132     return st_conn_fail;
133     }
134 return st_ok;
135 }
136 //---------------------------------------------------------------------------
137 int NETTRANSACT::Disconnect()
138 {
139 close(outerSocket);
140 return 0;
141 }
142 //---------------------------------------------------------------------------
143 int NETTRANSACT::Transact(const char * data)
144 {
145 int ret;
146 if ((ret = TxHeader()) != st_ok)
147     {
148     Disconnect();
149     return ret;
150     }
151
152 if ((ret = RxHeaderAnswer()) != st_ok)
153     {
154     Disconnect();
155     return ret;
156     }
157
158 if ((ret = TxLogin()) != st_ok)
159     {
160     Disconnect();
161     return ret;
162     }
163
164 if ((ret = RxLoginAnswer()) != st_ok)
165     {
166     Disconnect();
167     return ret;
168     }
169
170 if ((ret = TxLoginS()) != st_ok)
171     {
172     Disconnect();
173     return ret;
174     }
175
176 if ((ret = RxLoginSAnswer()) != st_ok)
177     {
178     Disconnect();
179     return ret;
180     }
181
182 if ((ret = TxData(data)) != st_ok)
183     {
184     Disconnect();
185     return ret;
186     }
187
188 if ((ret = RxDataAnswer()) != st_ok)
189     {
190     Disconnect();
191     return ret;
192     }
193
194 return st_ok;
195 }
196 //---------------------------------------------------------------------------
197 int NETTRANSACT::TxHeader()
198 {
199 int ret;
200 ret = send(outerSocket, STG_HEADER, strlen(STG_HEADER), 0);
201 if (ret <= 0)
202     {
203     strcpy(errorMsg, SEND_HEADER_ERROR);
204     return st_send_fail;
205     }
206
207 return st_ok;
208 }
209 //---------------------------------------------------------------------------
210 int NETTRANSACT::RxHeaderAnswer()
211 {
212 char buffer[sizeof(STG_HEADER)+1];
213 int ret;
214
215 ret = recv(outerSocket, buffer, strlen(OK_HEADER), 0);
216 if (ret <= 0)
217     {
218     strcpy(errorMsg, RECV_HEADER_ANSWER_ERROR);
219     return st_recv_fail;
220     }
221
222 if (strncmp(OK_HEADER, buffer, strlen(OK_HEADER)) == 0)
223     {
224     return st_ok;
225     }
226 else
227     {
228     if (strncmp(ERR_HEADER, buffer, strlen(ERR_HEADER)) == 0)
229         {
230         strcpy(errorMsg, INCORRECT_HEADER);
231         return st_header_err;
232         }
233     else
234         {
235         strcpy(errorMsg, UNKNOWN_ERROR);
236         return st_unknown_err;
237         }
238     }
239 }
240 //---------------------------------------------------------------------------
241 int NETTRANSACT::TxLogin()
242 {
243 char loginZ[ADM_LOGIN_LEN];
244 int ret;
245
246 memset(loginZ, 0, ADM_LOGIN_LEN);
247 strncpy(loginZ, login, ADM_LOGIN_LEN);
248 ret = send(outerSocket, loginZ, ADM_LOGIN_LEN, 0);
249
250 if (ret <= 0)
251     {
252     strcpy(errorMsg, SEND_LOGIN_ERROR);
253     return st_send_fail;
254     }
255
256 return st_ok;
257 }
258 //---------------------------------------------------------------------------
259 int NETTRANSACT::RxLoginAnswer()
260 {
261 char buffer[sizeof(OK_LOGIN)+1];
262 int ret;//, we;
263
264 ret = recv(outerSocket, buffer, strlen(OK_LOGIN), 0);
265 if (ret <= 0)
266     {
267     strcpy(errorMsg, RECV_LOGIN_ANSWER_ERROR);
268     return st_recv_fail;
269     }
270
271 if (strncmp(OK_LOGIN, buffer, strlen(OK_LOGIN)) == 0)
272     {
273     return st_ok;
274     }
275 else
276     {
277     if (strncmp(ERR_LOGIN, buffer, strlen(ERR_LOGIN)) == 0)
278         {
279         strcpy(errorMsg, INCORRECT_LOGIN);
280         return st_login_err;
281         }
282     else
283         {
284         strcpy(errorMsg, UNKNOWN_ERROR);
285         return st_unknown_err;
286         }
287     }
288 }
289 //---------------------------------------------------------------------------
290 int NETTRANSACT::TxLoginS()
291 {
292 char loginZ[ADM_LOGIN_LEN];
293 char ct[ENC_MSG_LEN];
294 int ret;
295
296 memset(loginZ, 0, ADM_LOGIN_LEN);
297 strncpy(loginZ, login, ADM_LOGIN_LEN);
298
299 BLOWFISH_CTX ctx;
300 EnDecryptInit(password, PASSWD_LEN, &ctx);
301
302 for (int j = 0; j < ADM_LOGIN_LEN / ENC_MSG_LEN; j++)
303     {
304     Encrypt(ct, loginZ + j*ENC_MSG_LEN, &ctx);
305     ret = send(outerSocket, ct, ENC_MSG_LEN, 0);
306     if (ret <= 0)
307         {
308         strcpy(errorMsg, SEND_LOGIN_ERROR);
309         return st_send_fail;
310         }
311     }
312
313 return st_ok;
314 }
315 //---------------------------------------------------------------------------
316 int NETTRANSACT::RxLoginSAnswer()
317 {
318 char buffer[sizeof(OK_LOGINS)+1];
319 int ret;
320
321 ret = recv(outerSocket, buffer, strlen(OK_LOGINS), 0);
322 if (ret <= 0)
323     {
324     strcpy(errorMsg, RECV_LOGIN_ANSWER_ERROR);
325     return st_recv_fail;
326     }
327
328 if (strncmp(OK_LOGINS, buffer, strlen(OK_LOGINS)) == 0)
329     {
330     return st_ok;
331     }
332 else
333     {
334     if (strncmp(ERR_LOGINS, buffer, strlen(ERR_LOGINS)) == 0)
335         {
336         strcpy(errorMsg, INCORRECT_LOGIN);
337         return st_logins_err;
338         }
339     else
340         {
341         strcpy(errorMsg, UNKNOWN_ERROR);
342         return st_unknown_err;
343         }
344     }
345 }
346 //---------------------------------------------------------------------------
347 int NETTRANSACT::TxData(const char * text)
348 {
349 char textZ[ENC_MSG_LEN];
350 char ct[ENC_MSG_LEN];
351 int ret;
352 int j;
353
354 int n = strlen(text) / ENC_MSG_LEN;
355 int r = strlen(text) % ENC_MSG_LEN;
356
357 BLOWFISH_CTX ctx;
358 EnDecryptInit(password, PASSWD_LEN, &ctx);
359
360 for (j = 0; j < n; j++)
361     {
362     strncpy(textZ, text + j*ENC_MSG_LEN, ENC_MSG_LEN);
363     Encrypt(ct, textZ, &ctx);
364     ret = send(outerSocket, ct, ENC_MSG_LEN, 0);
365     if (ret <= 0)
366         {
367         strcpy(errorMsg, SEND_DATA_ERROR);
368         return st_send_fail;
369         }
370     }
371
372 memset(textZ, 0, ENC_MSG_LEN);
373 if (r)
374     strncpy(textZ, text + j*ENC_MSG_LEN, ENC_MSG_LEN);
375
376 EnDecryptInit(password, PASSWD_LEN, &ctx);
377
378 Encrypt(ct, textZ, &ctx);
379 ret = send(outerSocket, ct, ENC_MSG_LEN, 0);
380 if (ret <= 0)
381     {
382     strcpy(errorMsg, SEND_DATA_ERROR);
383     return st_send_fail;
384     }
385
386 return st_ok;
387 }
388 //---------------------------------------------------------------------------
389 int NETTRANSACT::TxData(char * data)
390 {
391 char buff[ENC_MSG_LEN];
392 char buffS[ENC_MSG_LEN];
393 char passwd[ADM_PASSWD_LEN];
394
395 memset(passwd, 0, ADM_PASSWD_LEN);
396 strncpy(passwd, password, ADM_PASSWD_LEN);
397 memset(buff, 0, ENC_MSG_LEN);
398
399 int l = strlen(data)/ENC_MSG_LEN;
400 if (strlen(data)%ENC_MSG_LEN)
401     l++;
402
403 BLOWFISH_CTX ctx;
404 EnDecryptInit(passwd, PASSWD_LEN, &ctx);
405
406 for (int j = 0; j < l; j++)
407     {
408     strncpy(buff, &data[j*ENC_MSG_LEN], ENC_MSG_LEN);
409     Encrypt(buffS, buff, &ctx);
410     send(outerSocket, buffS, ENC_MSG_LEN, 0);
411     }
412
413 return 0;
414 }
415 //---------------------------------------------------------------------------
416 int NETTRANSACT::RxDataAnswer()
417 {
418 int n = 0;
419 int ret;
420 char bufferS[ENC_MSG_LEN];
421 char buffer[ENC_MSG_LEN + 1];
422
423 BLOWFISH_CTX ctx;
424 EnDecryptInit(password, PASSWD_LEN, &ctx);
425
426 while (1)
427     {
428     ret = recv(outerSocket, &bufferS[n++], 1, 0);
429     if (ret <= 0)
430         {
431         close(outerSocket);
432         strcpy(errorMsg, RECV_DATA_ANSWER_ERROR);
433         return st_recv_fail;
434         }
435
436     if (n == ENC_MSG_LEN)
437         {
438
439         n = 0;
440         Decrypt(buffer, bufferS, &ctx);
441         buffer[ENC_MSG_LEN] = 0;
442
443         answerList.push_back(buffer);
444
445         for (int j = 0; j < ENC_MSG_LEN; j++)
446             {
447             if (buffer[j] == 0)
448                 {
449                 if (RxCallBack)
450                     if (st_ok != RxCallBack(dataRxCallBack, &answerList))
451                         {
452                         return st_xml_parse_error;
453                         }
454                 return st_ok;
455                 }
456             }
457         }
458     }
459 }
460 //---------------------------------------------------------------------------
461 void NETTRANSACT::SetLogin(const char * l)
462 {
463 strncpy(login, l, ADM_LOGIN_LEN);
464 }
465 //---------------------------------------------------------------------------
466 void NETTRANSACT::SetPassword(const char * p)
467 {
468 strncpy(password, p, ADM_PASSWD_LEN);
469 }
470 //---------------------------------------------------------------------------
471 void NETTRANSACT::SetServer(const char * serverName)
472 {
473 strncpy(server, serverName, SERVER_NAME_LEN);
474 }
475 //---------------------------------------------------------------------------
476 void NETTRANSACT::SetServerPort(short unsigned p)
477 {
478 port = p;
479 }
480 //---------------------------------------------------------------------------
481 void NETTRANSACT::SetRxCallback(void * data, RxCallback_t cb)
482 {
483 RxCallBack = cb;
484 dataRxCallBack = data;
485 }
486 //---------------------------------------------------------------------------
487 char * NETTRANSACT::GetError()
488 {
489 return errorMsg;
490 }
491 //---------------------------------------------------------------------------
492 void NETTRANSACT::Reset()
493 {
494 answerList.clear();
495 }
496 //---------------------------------------------------------------------------