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