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