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