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