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