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