]> git.stg.codes - stg.git/blob - stglibs/srvconf.lib/netunit.cpp
Added necessary headers in netlink/nfq checks.
[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 int NETTRANSACT::Connect()
63 {
64 int ret;
65
66 outerSocket = socket(PF_INET, SOCK_STREAM, 0);
67 if (outerSocket < 0)
68     {
69     errorMsg = CREATE_SOCKET_ERROR;
70     return st_conn_fail;
71     }
72
73 struct sockaddr_in outerAddr;
74 memset(&outerAddr, 0, sizeof(outerAddr));
75
76 struct hostent he;
77 struct hostent * phe;
78
79 unsigned long ip;
80 ip = inet_addr(server.c_str());
81
82 if (ip == INADDR_NONE)
83     {
84     phe = gethostbyname(server.c_str());
85     if (phe == NULL)
86         {
87         errorMsg = "DNS error.\nCan not reslove " + server;
88         return st_dns_err;
89         }
90
91     memcpy(&he, phe, sizeof(he));
92     ip = *((long*)he.h_addr_list[0]);
93     }
94 outerAddr.sin_family = AF_INET;
95 outerAddr.sin_port = htons(port);
96 outerAddr.sin_addr.s_addr = ip;
97
98 ret = connect(outerSocket, (struct sockaddr*)&outerAddr, sizeof(outerAddr));
99
100 if (ret < 0)
101     {
102     errorMsg = CONNECT_FAILED;
103     close(outerSocket);
104     return st_conn_fail;
105     }
106 return st_ok;
107 }
108 //---------------------------------------------------------------------------
109 int NETTRANSACT::Disconnect()
110 {
111 close(outerSocket);
112 return 0;
113 }
114 //---------------------------------------------------------------------------
115 int NETTRANSACT::Transact(const char * data)
116 {
117 int ret;
118 if ((ret = TxHeader()) != st_ok)
119     {
120     Disconnect();
121     return ret;
122     }
123
124 if ((ret = RxHeaderAnswer()) != st_ok)
125     {
126     Disconnect();
127     return ret;
128     }
129
130 if ((ret = TxLogin()) != st_ok)
131     {
132     Disconnect();
133     return ret;
134     }
135
136 if ((ret = RxLoginAnswer()) != st_ok)
137     {
138     Disconnect();
139     return ret;
140     }
141
142 if ((ret = TxLoginS()) != st_ok)
143     {
144     Disconnect();
145     return ret;
146     }
147
148 if ((ret = RxLoginSAnswer()) != st_ok)
149     {
150     Disconnect();
151     return ret;
152     }
153
154 if ((ret = TxData(data)) != st_ok)
155     {
156     Disconnect();
157     return ret;
158     }
159
160 if ((ret = RxDataAnswer()) != st_ok)
161     {
162     Disconnect();
163     return ret;
164     }
165
166 return st_ok;
167 }
168 //---------------------------------------------------------------------------
169 int NETTRANSACT::TxHeader()
170 {
171 int ret;
172 ret = send(outerSocket, STG_HEADER, strlen(STG_HEADER), 0);
173 if (ret <= 0)
174     {
175     errorMsg = SEND_HEADER_ERROR;
176     return st_send_fail;
177     }
178
179 return st_ok;
180 }
181 //---------------------------------------------------------------------------
182 int NETTRANSACT::RxHeaderAnswer()
183 {
184 char buffer[sizeof(STG_HEADER)+1];
185 int ret;
186
187 ret = recv(outerSocket, buffer, strlen(OK_HEADER), 0);
188 if (ret <= 0)
189     {
190     errorMsg = RECV_HEADER_ANSWER_ERROR;
191     return st_recv_fail;
192     }
193
194 if (strncmp(OK_HEADER, buffer, strlen(OK_HEADER)) == 0)
195     {
196     return st_ok;
197     }
198 else
199     {
200     if (strncmp(ERR_HEADER, buffer, strlen(ERR_HEADER)) == 0)
201         {
202         errorMsg = INCORRECT_HEADER;
203         return st_header_err;
204         }
205     else
206         {
207         errorMsg = UNKNOWN_ERROR;
208         return st_unknown_err;
209         }
210     }
211 }
212 //---------------------------------------------------------------------------
213 int NETTRANSACT::TxLogin()
214 {
215 char loginZ[ADM_LOGIN_LEN];
216 int ret;
217
218 memset(loginZ, 0, ADM_LOGIN_LEN);
219 strncpy(loginZ, login.c_str(), ADM_LOGIN_LEN);
220 ret = send(outerSocket, loginZ, ADM_LOGIN_LEN, 0);
221
222 if (ret <= 0)
223     {
224     errorMsg = SEND_LOGIN_ERROR;
225     return st_send_fail;
226     }
227
228 return st_ok;
229 }
230 //---------------------------------------------------------------------------
231 int NETTRANSACT::RxLoginAnswer()
232 {
233 char buffer[sizeof(OK_LOGIN)+1];
234 int ret;
235
236 ret = recv(outerSocket, buffer, strlen(OK_LOGIN), 0);
237 if (ret <= 0)
238     {
239     errorMsg = RECV_LOGIN_ANSWER_ERROR;
240     return st_recv_fail;
241     }
242
243 if (strncmp(OK_LOGIN, buffer, strlen(OK_LOGIN)) == 0)
244     {
245     return st_ok;
246     }
247 else
248     {
249     if (strncmp(ERR_LOGIN, buffer, strlen(ERR_LOGIN)) == 0)
250         {
251         errorMsg = INCORRECT_LOGIN;
252         return st_login_err;
253         }
254     else
255         {
256         errorMsg = UNKNOWN_ERROR;
257         return st_unknown_err;
258         }
259     }
260 }
261 //---------------------------------------------------------------------------
262 int NETTRANSACT::TxLoginS()
263 {
264 char loginZ[ADM_LOGIN_LEN];
265
266 memset(loginZ, 0, ADM_LOGIN_LEN);
267 BLOWFISH_CTX ctx;
268 InitContext(password.c_str(), PASSWD_LEN, &ctx);
269 EncryptString(loginZ, login.c_str(), std::min<int>(login.length() + 1, ADM_LOGIN_LEN), &ctx);
270 if (send(outerSocket, loginZ, ADM_LOGIN_LEN, 0) <= 0)
271     {
272     errorMsg = SEND_LOGIN_ERROR;
273     return st_send_fail;
274     }
275 return st_ok;
276 }
277 //---------------------------------------------------------------------------
278 int NETTRANSACT::RxLoginSAnswer()
279 {
280 char buffer[sizeof(OK_LOGINS)+1];
281 int ret;
282
283 ret = recv(outerSocket, buffer, strlen(OK_LOGINS), 0);
284 if (ret <= 0)
285     {
286     errorMsg = RECV_LOGIN_ANSWER_ERROR;
287     return st_recv_fail;
288     }
289
290 if (strncmp(OK_LOGINS, buffer, strlen(OK_LOGINS)) == 0)
291     {
292     return st_ok;
293     }
294 else
295     {
296     if (strncmp(ERR_LOGINS, buffer, strlen(ERR_LOGINS)) == 0)
297         {
298         errorMsg = INCORRECT_LOGIN;
299         return st_logins_err;
300         }
301     else
302         {
303         errorMsg = UNKNOWN_ERROR;
304         return st_unknown_err;
305         }
306     }
307 }
308 //---------------------------------------------------------------------------
309 int NETTRANSACT::TxData(const char * text)
310 {
311 BLOWFISH_CTX ctx;
312 InitContext(password.c_str(), PASSWD_LEN, &ctx);
313 size_t length = strlen(text);
314 char buffer[length + 9];
315 memset(buffer, 0, sizeof(buffer));
316 EncryptString(buffer, text, length + 1, &ctx);
317 if (send(outerSocket, buffer, sizeof(buffer), 0) <= 0)
318     {
319     errorMsg = SEND_DATA_ERROR;
320     return st_send_fail;
321     }
322 return st_ok;
323 }
324 //---------------------------------------------------------------------------
325 int NETTRANSACT::RxDataAnswer()
326 {
327 int n = 0;
328 int ret;
329 char bufferS[ENC_MSG_LEN];
330 char buffer[ENC_MSG_LEN + 1];
331
332 BLOWFISH_CTX ctx;
333 InitContext(password.c_str(), PASSWD_LEN, &ctx);
334
335 while (1)
336     {
337     ret = recv(outerSocket, &bufferS[n++], 1, 0);
338     if (ret <= 0)
339         {
340         close(outerSocket);
341         errorMsg = RECV_DATA_ANSWER_ERROR;
342         return st_recv_fail;
343         }
344
345     if (n == ENC_MSG_LEN)
346         {
347         n = 0;
348         DecryptBlock(buffer, bufferS, &ctx);
349         buffer[ENC_MSG_LEN] = 0;
350
351         answerList.push_back(buffer);
352
353         for (int j = 0; j < ENC_MSG_LEN; j++)
354             {
355             if (buffer[j] == 0)
356                 {
357                 if (RxCallBack)
358                     if (st_ok != RxCallBack(dataRxCallBack, &answerList))
359                         {
360                         return st_xml_parse_error;
361                         }
362                 return st_ok;
363                 }
364             }
365         }
366     }
367 }
368 //---------------------------------------------------------------------------
369 void NETTRANSACT::SetLogin(const char * l)
370 {
371 login = l;
372 }
373 //---------------------------------------------------------------------------
374 void NETTRANSACT::SetPassword(const char * p)
375 {
376 password = p;
377 }
378 //---------------------------------------------------------------------------
379 void NETTRANSACT::SetServer(const char * serverName)
380 {
381 server = serverName;
382 }
383 //---------------------------------------------------------------------------
384 void NETTRANSACT::SetServerPort(short unsigned p)
385 {
386 port = p;
387 }
388 //---------------------------------------------------------------------------
389 void NETTRANSACT::SetRxCallback(void * data, RxCallback_t cb)
390 {
391 RxCallBack = cb;
392 dataRxCallBack = data;
393 }
394 //---------------------------------------------------------------------------
395 const std::string & NETTRANSACT::GetError() const
396 {
397 return errorMsg;
398 }
399 //---------------------------------------------------------------------------
400 void NETTRANSACT::Reset()
401 {
402 answerList.clear();
403 }
404 //---------------------------------------------------------------------------