]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/configuration/sgconfig/rsconf.cpp
520aebf7cd1bfe81726b7c0896aea5e61a0bd4e4
[stg.git] / projects / stargazer / plugins / configuration / sgconfig / rsconf.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 *
19 *    DESCRIPTION: æÁÊÌ Ó ÏÓÎÏ×ÎÙÍÉ ÆÕÎËÃÉÑÍÉ ÄÌÑ ÓÅÔÅ×ÏÇÏ ÏÂÍÅÎÁ ÄÁÎÎÙÍÉ
20 *    Ó ÍÅÎÅÄÖÅÒÏÍ ËÌÉÅÎÔÏ×. ðÒÉÅÍ, ÐÅÒÅÄÁÞÁ É ÛÉÆÒÏ×ÁÎÉÅ ÓÏÏÂÝÅÎÉÊ.
21 *
22 *    AUTHOR: Boris Mikhailenko <stg34@stargazer.dp.ua>
23 *
24 *    $Revision: 1.24 $
25 *    $Date: 2010/10/04 20:24:54 $
26 *
27 *******************************************************************/
28
29 #include <cerrno>
30 #include <csignal>
31
32 #include "configproto.h"
33 #include "blowfish.h"
34
35 enum CONF_STATE
36     {
37     confHdr,
38     confLogin,
39     confLoginCipher,
40     confData
41     };
42
43 enum
44     {
45     ans_ok = 0,
46     ans_err
47     };
48
49 //-----------------------------------------------------------------------------
50 int CONFIGPROTO::Prepare()
51 {
52 list<string> ansList; //óÀÄÁ ÂÕÄÅÔ ÐÏÍÅÝÅΠÏÔ×ÅÔ ÄÌÑ ÍÅÎÅÄÖÅÒÁ ËÌÉÅÎÔÏ×
53 int res;
54 struct sockaddr_in listenAddr;
55
56 sigset_t sigmask, oldmask;
57 sigemptyset(&sigmask);
58 sigaddset(&sigmask, SIGINT);
59 sigaddset(&sigmask, SIGTERM);
60 sigaddset(&sigmask, SIGUSR1);
61 sigaddset(&sigmask, SIGHUP);
62 pthread_sigmask(SIG_BLOCK, &sigmask, &oldmask);
63
64 listenSocket = socket(PF_INET, SOCK_STREAM, 0);
65
66 if (listenSocket < 0)
67     {
68     errorStr = "Create NET_CONFIGURATOR socket failed.";
69     return -1;
70     }
71
72 listenAddr.sin_family = PF_INET;
73 listenAddr.sin_port = htons(port);
74 listenAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
75
76 int lng = 1;
77
78 if (0 != setsockopt(listenSocket, SOL_SOCKET, SO_REUSEADDR, &lng, 4))
79     {
80     errorStr = "Setsockopt failed. " + string(strerror(errno));
81     return -1;
82     }
83
84 res = bind(listenSocket, (struct sockaddr*)&listenAddr, sizeof(listenAddr));
85
86 if (res == -1)
87     {
88     errorStr = "Bind admin socket failed";
89     return -1;
90     }
91
92 res = listen(listenSocket, 0);
93 if (res == -1)
94     {
95     errorStr = "Listen admin socket failed";
96     return -1;
97     }
98
99 errorStr = "";
100 nonstop = true;
101 return 0;
102 }
103 //-----------------------------------------------------------------------------
104 int CONFIGPROTO::Stop()
105 {
106 nonstop = false;
107 close(listenSocket);
108 //TODO: Idiotism
109 int                 sock;
110 struct sockaddr_in  addr;
111 socklen_t           addrLen;
112 addr.sin_family = PF_INET;
113 addr.sin_port = htons(port);
114 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
115
116 addrLen = sizeof(addr);
117 sock = socket(PF_INET, SOCK_STREAM, 0);
118 connect(sock, (sockaddr*)&addr, addrLen);
119 close(sock);
120 //Idiotism end
121 return 0;
122 }
123 //-----------------------------------------------------------------------------
124 // æÕÎËÃÉÑ ÏÂÝÅÎÉÑ Ó ËÏÎÆÉÇÕÒÁÔÏÒÏÍ
125 void * CONFIGPROTO::Run(void * a)
126 {
127 /*
128  * Function Name:ReciveSendConf
129  * Parameters: void * a ÕËÁÚÁÔÅÌØ ÎÁ ÜËÚÅÍÐÌÑÒ ËÌÁÓÓÁ CONFIGPROTO
130  * Description: üÔÁ ÆÕÎËÃÉÑ ÏÂÅÓÐÅÞÉ×ÁÅÔ ÓÅÔÅ×ÏÅ ×ÚÁÉÍÏÄÅÊÓÔ×ÉÅ
131  *  Ó íÅÎÅÄÖÅÒÏÍ ëÌÉÅÎÔÏ×. ÷ ÅÅ ÚÁÄÁÞÉ ×ÈÏÄÉÔ: ÐÒÉÅÍ ÚÁÐÒÏÓÏ× ÐÏ TCP/IP
132  *  ÉÈ ÒÁÓÛÉÆÒÏ×ËÁ, ÐÅÒÅÄÁÞÁ ÐÒÉÎÑÔÙÈ ÄÁÎÎÙÈ ÁÎÁÌÉÚÁÔÏÒÕ É ÏÔÐÒÁ×ËÁ ÏÔ×ÅÔÁ ÎÁÚÁÄ.
133  * Returns: ×ÏÚ×ÒÁÝÁÅÔ NULL
134  */
135
136 CONFIGPROTO * cp = (CONFIGPROTO*)a;
137 cp->state = confHdr;
138
139 while (cp->nonstop)
140     {
141     cp->state = confHdr;
142     struct sockaddr_in outerAddr;
143     socklen_t outerAddrLen(sizeof(outerAddr));
144     int outerSocket = accept(cp->listenSocket,
145                              (struct sockaddr*)(&outerAddr),
146                              &outerAddrLen);
147
148     if (!cp->nonstop)
149         {
150         continue;
151         }
152
153     if (outerSocket == -1)
154         {
155         printfd(__FILE__, "accept failed\n");
156         usleep(100000);
157         continue;
158         }
159
160     cp->adminIP = *(unsigned int*)&(outerAddr.sin_addr);
161
162     printfd(__FILE__, "Connection accepted from %s\n", inet_ntostring(outerAddr.sin_addr.s_addr).c_str());
163
164     if (cp->state == confHdr)
165         {
166         if (cp->RecvHdr(outerSocket) < 0)
167             {
168             close(outerSocket);
169             continue;
170             }
171         if (cp->state == confLogin)
172             {
173             if (cp->SendHdrAnswer(outerSocket, ans_ok) < 0)
174                 {
175                 close(outerSocket);
176                 continue;
177                 }
178
179             if (cp->RecvLogin(outerSocket) < 0)
180                 {
181                 close(outerSocket);
182                 continue;
183                 }
184
185             if (cp->state == confLoginCipher)
186                 {
187                 if (cp->SendLoginAnswer(outerSocket, ans_ok) < 0)
188                     {
189                     close(outerSocket);
190                     continue;
191                     }
192                 if (cp->RecvLoginS(outerSocket) < 0)
193                     {
194                     close(outerSocket);
195                     continue;
196                     }
197
198                 if (cp->state == confData)
199                     {
200                     if (cp->SendLoginSAnswer(outerSocket, ans_ok) < 0)
201                         {
202                         close(outerSocket);
203                         continue;
204                         }
205                     if (cp->RecvData(outerSocket) < 0)
206                         {
207                         close(outerSocket);
208                         continue;
209                         }
210                     cp->state = confHdr;
211                     }
212                 else
213                     {
214                     if (cp->SendLoginSAnswer(outerSocket, ans_err) < 0)
215                         {
216                         close(outerSocket);
217                         continue;
218                         }
219                     cp->WriteLogAccessFailed(cp->adminIP);
220                     }
221                 }
222             else
223                 {
224                 cp->WriteLogAccessFailed(cp->adminIP);
225                 }
226             }
227         else
228             {
229             cp->WriteLogAccessFailed(cp->adminIP);
230             if (cp->SendHdrAnswer(outerSocket, ans_err) < 0)
231                 {
232                 close(outerSocket);
233                 continue;
234                 }
235             }
236         }
237     else
238         {
239         cp->WriteLogAccessFailed(cp->adminIP);
240         }
241     close(outerSocket);
242     }
243
244 return NULL;
245 }
246 //-----------------------------------------------------------------------------
247 int CONFIGPROTO::RecvHdr(int sock)
248 {
249 char buf[sizeof(STG_HEADER)];
250 memset(buf, 0, sizeof(STG_HEADER));
251 int ret;
252 int stgHdrLen = strlen(STG_HEADER);
253 for (int i = 0; i < stgHdrLen; i++)
254     {
255     ret = recv(sock, &buf[i], 1, 0);
256     if (ret <= 0)
257         {
258         state = confHdr;
259         return -1;
260         }
261     }
262
263 if (0 == strncmp(buf, STG_HEADER, strlen(STG_HEADER)))
264     {
265     state = confLogin;
266     return 0;
267     }
268 else
269     {
270     SendError("Bad request");
271     }
272
273 state = confHdr;
274 return -1;
275 }
276 //-----------------------------------------------------------------------------
277 int CONFIGPROTO::SendHdrAnswer(int sock, int err)
278 {
279 int ret;
280
281 if (err)
282     {
283     ret = send(sock, ERR_HEADER, sizeof(ERR_HEADER)-1, 0);
284     if (ret < 0)
285         {
286         WriteServLog("send ERR_HEADER error in SendHdrAnswer.");
287         return -1;
288         }
289     }
290 else
291     {
292     ret = send(sock, OK_HEADER, sizeof(OK_HEADER)-1, 0);
293     if (ret < 0)
294         {
295         WriteServLog("send OK_HEADER error in SendHdrAnswer.");
296         return -1;
297         }
298     }
299
300 return 0;
301 }
302 //-----------------------------------------------------------------------------
303 int CONFIGPROTO::RecvLogin(int sock)
304 {
305 char login[ADM_LOGIN_LEN+1];
306 int ret;
307
308 memset(login, 0, ADM_LOGIN_LEN + 1);
309
310 ret = recv(sock, login, ADM_LOGIN_LEN, 0);
311
312 if (ret < 0)
313     {
314     // Error in network
315     close(sock);
316     state = confHdr;
317     return ENODATA;
318     }
319
320 if (ret < ADM_LOGIN_LEN)
321     {
322     // Error in protocol
323     close(sock);
324     state = confHdr;
325     return ENODATA;
326     }
327
328 if (admins->FindAdmin(login, &currAdmin))
329     {
330     // Admin not found
331     close(sock);
332     state = confHdr;
333     return ENODATA;
334     }
335 currAdmin.SetAdminIP(adminIP);
336 adminLogin = login;
337 state = confLoginCipher;
338 return 0;
339 }
340 //-----------------------------------------------------------------------------
341 int CONFIGPROTO::SendLoginAnswer(int sock, int)
342 {
343 int ret;
344
345 ret = send(sock, OK_LOGIN, sizeof(OK_LOGIN)-1, 0);
346 if (ret < 0)
347     {
348     WriteServLog("Send OK_LOGIN error in SendLoginAnswer.");
349     return -1;
350     }
351 return 0;
352 }
353 //-----------------------------------------------------------------------------
354 int CONFIGPROTO::RecvLoginS(int sock)
355 {
356 char loginS[ADM_LOGIN_LEN + 1];
357 char login[ADM_LOGIN_LEN + 1];
358 int ret;
359 BLOWFISH_CTX ctx;
360 memset(loginS, 0, ADM_LOGIN_LEN + 1);
361
362 int total = 0;
363
364 while (total < ADM_LOGIN_LEN)
365     {
366     ret = recv(sock, &loginS[total], ADM_LOGIN_LEN - total, 0);
367
368     if (ret < 0)
369         {
370         // Network error
371         printfd(__FILE__, "recv error: '%s'\n", strerror(errno));
372         close(sock);
373         state = confHdr;
374         return ENODATA;
375         }
376
377     total += ret;
378     }
379
380 if (currAdmin.GetLogin() == "")
381     {
382     state = confHdr;
383     return ENODATA;
384     }
385
386 EnDecodeInit(currAdmin.GetPassword().c_str(), ADM_PASSWD_LEN, &ctx);
387
388 for (int i = 0; i < ADM_LOGIN_LEN/8; i++)
389     {
390     DecodeString(login + i*8, loginS + i*8, &ctx);
391     }
392
393 if (currAdmin == admins->GetNoAdmin())
394     {
395     // If there are no admins registered in the system - give access with any password
396     state = confData;
397     return 0;
398     }
399
400 if (strncmp(currAdmin.GetLogin().c_str(), login, ADM_LOGIN_LEN) != 0)
401     {
402     state = confHdr;
403     return ENODATA;
404     }
405
406 state = confData;
407 return 0;
408 }
409 //-----------------------------------------------------------------------------
410 int CONFIGPROTO::SendLoginSAnswer(int sock, int err)
411 {
412 int ret;
413
414 if (err)
415     {
416     ret = send(sock, ERR_LOGINS, sizeof(ERR_LOGINS)-1, 0);
417     if (ret < 0)
418         {
419         WriteServLog("send ERR_LOGIN error in SendLoginAnswer.");
420         return -1;
421         }
422     }
423 else
424     {
425     ret = send(sock, OK_LOGINS, sizeof(OK_LOGINS)-1, 0);
426     if (ret < 0)
427         {
428         WriteServLog("send OK_LOGINS error in SendLoginSAnswer.");
429         return -1;
430         }
431     }
432 return 0;
433 }
434 //-----------------------------------------------------------------------------
435 int CONFIGPROTO::RecvData(int sock)
436 {
437 int ret;
438 char bufferS[8];
439 char buffer[9];
440
441 buffer[8] = 0;
442
443 requestList.clear();
444 BLOWFISH_CTX ctx;
445
446 EnDecodeInit(currAdmin.GetPassword().c_str(), ADM_PASSWD_LEN, &ctx);
447
448 while (1)
449     {
450     int total = 0;
451     bool done = false;
452     while (total < 8)
453         {
454         ret = recv(sock, &bufferS[total], 8 - total, 0);
455         if (ret < 0)
456             {
457             // Network error
458             close(sock);
459             return 0;
460             }
461
462         if (ret < 8)
463             {
464             if (memchr(buffer, 0, ret) != NULL)
465                 {
466                 done = true;
467                 break;
468                 }
469             }
470
471         total += ret;
472         }
473
474     DecodeString(buffer, bufferS, &ctx);
475     requestList.push_back(std::string(buffer, total));
476
477     if (done || memchr(buffer, 0, total) != NULL)
478         {
479         // ëÏÎÅàÐÏÓÙÌËÉ
480         if (ParseCommand())
481             {
482             SendError("Bad command");
483             }
484         return SendDataAnswer(sock);
485         }
486     }
487 return 0;
488 }
489 //-----------------------------------------------------------------------------
490 int CONFIGPROTO::SendDataAnswer(int sock)
491 {
492 list<string>::iterator li;
493 li = answerList.begin();
494
495 BLOWFISH_CTX ctx;
496
497 char buff[8];
498 char buffS[8];
499 int n = 0;
500 int k = 0;
501 int ret = 0;
502
503 EnDecodeInit(currAdmin.GetPassword().c_str(), ADM_PASSWD_LEN, &ctx);
504
505 while (li != answerList.end())
506     {
507     while ((*li).c_str()[k])
508         {
509         buff[n%8] = (*li).c_str()[k];
510         n++;
511         k++;
512
513         if (n%8 == 0)
514             {
515             EncodeString(buffS, buff, &ctx);
516             ret = send(sock, buffS, 8, 0);
517             if (ret < 0)
518                 {
519                 return -1;
520                 }
521             }
522         }
523     k = 0;// new node
524     li++;
525     }
526
527 if (answerList.empty()) {
528     return 0;
529 }
530
531 buff[n%8] = 0;
532 EncodeString(buffS, buff, &ctx);
533
534 answerList.clear();
535
536 return send(sock, buffS, 8, 0);
537 }
538 //-----------------------------------------------------------------------------
539 void CONFIGPROTO::SendError(const char * text)
540 {
541 char s[255];
542 answerList.clear();
543 sprintf(s, "<Error value=\"%s\"/>", text);
544 answerList.push_back(s);
545 }
546 //-----------------------------------------------------------------------------
547 void CONFIGPROTO::WriteLogAccessFailed(uint32_t ip)
548 {
549 WriteServLog("Admin's connect failed. IP %s", inet_ntostring(ip).c_str());
550 }
551 //-----------------------------------------------------------------------------