]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/configuration/sgconfig/rsconf.cpp
6ef56d0c90988567d1cd7ec648495c3d7e7d9d8e
[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         {
145         break;
146         }
147
148     if (outerSocket < 0)
149         {
150         logger("accept error: %s", strerror(errno));
151         printfd(__FILE__, "accept failed\n");
152         continue;
153         }
154
155     adminIP = *(unsigned int*)&(outerAddr.sin_addr);
156
157     if (state == confHdr)
158         {
159         if (RecvHdr(outerSocket) < 0)
160             {
161             shutdown(outerSocket, SHUT_RDWR);
162             close(outerSocket);
163             continue;
164             }
165         if (state == confLogin)
166             {
167             if (SendHdrAnswer(outerSocket, ans_ok) < 0)
168                 {
169                 shutdown(outerSocket, SHUT_RDWR);
170                 close(outerSocket);
171                 continue;
172                 }
173             if (RecvLogin(outerSocket) < 0)
174                 {
175                 shutdown(outerSocket, SHUT_RDWR);
176                 close(outerSocket);
177                 continue;
178                 }
179             if (state == confLoginCipher)
180                 {
181                 if (SendLoginAnswer(outerSocket) < 0)
182                     {
183                     shutdown(outerSocket, SHUT_RDWR);
184                     close(outerSocket);
185                     continue;
186                     }
187                 if (RecvLoginS(outerSocket) < 0)
188                     {
189                     shutdown(outerSocket, SHUT_RDWR);
190                     close(outerSocket);
191                     continue;
192                     }
193                 if (state == confData)
194                     {
195                     if (SendLoginSAnswer(outerSocket, ans_ok) < 0)
196                         {
197                         shutdown(outerSocket, SHUT_RDWR);
198                         close(outerSocket);
199                         continue;
200                         }
201                     if (RecvData(outerSocket) < 0)
202                         {
203                         shutdown(outerSocket, SHUT_RDWR);
204                         close(outerSocket);
205                         continue;
206                         }
207                     state = confHdr;
208                     }
209                 else
210                     {
211                     if (SendLoginSAnswer(outerSocket, ans_err) < 0)
212                         {
213                         shutdown(outerSocket, SHUT_RDWR);
214                         close(outerSocket);
215                         continue;
216                         }
217                     WriteLogAccessFailed(adminIP);
218                     }
219                 }
220             else
221                 {
222                 WriteLogAccessFailed(adminIP);
223                 }
224             }
225         else
226             {
227             WriteLogAccessFailed(adminIP);
228             if (SendHdrAnswer(outerSocket, ans_err) < 0)
229                 {
230                 shutdown(outerSocket, SHUT_RDWR);
231                 close(outerSocket);
232                 continue;
233                 }
234             }
235         }
236     else
237         {
238         WriteLogAccessFailed(adminIP);
239         }
240     printfd(__FILE__, "Successfull connection from %s\n", inet_ntostring(outerAddr.sin_addr.s_addr).c_str());
241     shutdown(outerSocket, SHUT_RDWR);
242     close(outerSocket);
243     }
244 }
245 //-----------------------------------------------------------------------------
246 int CONFIGPROTO::RecvHdr(int sock)
247 {
248 char buf[sizeof(STG_HEADER)];
249 memset(buf, 0, sizeof(STG_HEADER));
250 size_t stgHdrLen = sizeof(STG_HEADER) - 1; // Without 0-char
251 size_t pos = 0;
252 while (pos < stgHdrLen)
253     {
254     if (!WaitPackets(sock))
255         {
256         state = confHdr;
257         SendError(sock, "Bad request");
258         return -1;
259         }
260     ssize_t ret = recv(sock, &buf[pos], static_cast<int>(stgHdrLen) - static_cast<int>(pos), 0);
261     if (ret <= 0)
262         {
263         if (ret < 0)
264             logger("recv error: %s", strerror(errno));
265         state = confHdr;
266         return -1;
267         }
268     pos += ret;
269     }
270
271 if (0 == strncmp(buf, STG_HEADER, strlen(STG_HEADER)))
272     {
273     state = confLogin;
274     return 0;
275     }
276 else
277     {
278     SendError(sock, "Bad request");
279     }
280
281 state = confHdr;
282 return -1;
283 }
284 //-----------------------------------------------------------------------------
285 int CONFIGPROTO::SendHdrAnswer(int sock, int err)
286 {
287 if (err)
288     {
289     if (send(sock, ERR_HEADER, sizeof(ERR_HEADER) - 1, 0) < 0)
290         {
291         logger("send error: %s", strerror(errno));
292         return -1;
293         }
294     }
295 else
296     {
297     if (send(sock, OK_HEADER, sizeof(OK_HEADER) - 1, 0) < 0)
298         {
299         logger("send error: %s", strerror(errno));
300         return -1;
301         }
302     }
303
304 return 0;
305 }
306 //-----------------------------------------------------------------------------
307 int CONFIGPROTO::RecvLogin(int sock)
308 {
309 char login[ADM_LOGIN_LEN + 1];
310
311 memset(login, 0, ADM_LOGIN_LEN + 1);
312
313 size_t pos = 0;
314 while (pos < ADM_LOGIN_LEN) {
315     if (!WaitPackets(sock))
316         {
317         state = confHdr;
318         return ENODATA;
319         }
320
321     ssize_t ret = recv(sock, &login[pos], ADM_LOGIN_LEN - static_cast<int>(pos), 0);
322
323     if (ret <= 0)
324         {
325         // Error in network
326         logger("recv error: %s", strerror(errno));
327         state = confHdr;
328         return ENODATA;
329         }
330
331     pos += ret;
332 }
333
334 if (admins->Find(login, &currAdmin))
335     {
336     // Admin not found
337     state = confHdr;
338     return ENODATA;
339     }
340
341 currAdmin->SetIP(adminIP);
342 adminLogin = login;
343 state = confLoginCipher;
344 return 0;
345 }
346 //-----------------------------------------------------------------------------
347 int CONFIGPROTO::SendLoginAnswer(int sock)
348 {
349 if (send(sock, OK_LOGIN, sizeof(OK_LOGIN) - 1, 0) < 0)
350     {
351     logger("Send OK_LOGIN error in SendLoginAnswer.");
352     return -1;
353     }
354 return 0;
355 }
356 //-----------------------------------------------------------------------------
357 int CONFIGPROTO::RecvLoginS(int sock)
358 {
359 char loginS[ADM_LOGIN_LEN + 1];
360 memset(loginS, 0, ADM_LOGIN_LEN + 1);
361
362 size_t pos = 0;
363 while (pos < ADM_LOGIN_LEN)
364     {
365     if (!WaitPackets(sock))
366         {
367         state = confHdr;
368         return ENODATA;
369         }
370
371     ssize_t ret = recv(sock, &loginS[pos], ADM_LOGIN_LEN - static_cast<int>(pos), 0);
372
373     if (ret <= 0)
374         {
375         // Network error
376         printfd(__FILE__, "recv error: '%s'\n", strerror(errno));
377         logger("recv error: %s", strerror(errno));
378         state = confHdr;
379         return ENODATA;
380         }
381
382     pos += ret;
383     }
384
385 if (currAdmin->GetLogin().empty())
386     {
387     state = confHdr;
388     return ENODATA;
389     }
390
391 BLOWFISH_CTX ctx;
392 InitContext(currAdmin->GetPassword().c_str(), ADM_PASSWD_LEN, &ctx);
393
394 char login[ADM_LOGIN_LEN + 1];
395 for (size_t i = 0; i < ADM_LOGIN_LEN / 8; i++)
396     DecryptBlock(login + i * 8, loginS + i * 8, &ctx);
397
398 if (currAdmin == admins->GetNoAdmin())
399     {
400     // If there are no admins registered in the system - give access with any password
401     state = confData;
402     return 0;
403     }
404
405 if (strncmp(currAdmin->GetLogin().c_str(), login, ADM_LOGIN_LEN) != 0)
406     {
407     state = confHdr;
408     return ENODATA;
409     }
410
411 state = confData;
412 adminPassword = currAdmin->GetPassword();
413 return 0;
414 }
415 //-----------------------------------------------------------------------------
416 int CONFIGPROTO::SendLoginSAnswer(int sock, int err)
417 {
418 if (err)
419     {
420     if (send(sock, ERR_LOGINS, sizeof(ERR_LOGINS) - 1, 0) < 0)
421         {
422         logger("send error: %s", strerror(errno));
423         return -1;
424         }
425     }
426 else
427     {
428     if (send(sock, OK_LOGINS, sizeof(OK_LOGINS) - 1, 0) < 0)
429         {
430         logger("send error: %s", strerror(errno));
431         return -1;
432         }
433     }
434 return 0;
435 }
436 //-----------------------------------------------------------------------------
437 int CONFIGPROTO::RecvData(int sock)
438 {
439 requestList.clear();
440 BLOWFISH_CTX ctx;
441
442 InitContext(currAdmin->GetPassword().c_str(), ADM_PASSWD_LEN, &ctx);
443
444 while (1)
445     {
446     bool done = false;
447     char bufferS[8];
448     size_t pos = 0;
449     while (pos < sizeof(bufferS))
450         {
451         if (!WaitPackets(sock))
452             {
453             done = true;
454             break;
455             }
456
457         ssize_t ret = recv(sock, &bufferS[pos], sizeof(bufferS) - static_cast<int>(pos), 0);
458         if (ret < 0)
459             {
460             // Network error
461             logger("recv error: %s", strerror(errno));
462             printfd(__FILE__, "recv error: '%s'\n", strerror(errno));
463             return -1;
464             }
465
466         if (ret == 0)
467             {
468             done = true;
469             break;
470             }
471
472         pos += ret;
473         }
474
475     char buffer[8];
476     buffer[7] = 0;
477
478     DecryptBlock(buffer, bufferS, &ctx);
479     requestList.push_back(std::string(buffer, pos));
480
481     if (done || memchr(buffer, 0, pos) != NULL)
482         {
483         // End of data
484         if (ParseCommand())
485             return SendError(sock, "Bad command");
486         else
487             return SendDataAnswer(sock, GetDataAnswer());
488         }
489     }
490 //return 0;
491 }
492 //-----------------------------------------------------------------------------
493 int CONFIGPROTO::SendDataAnswer(int sock, const std::string & answer)
494 {
495 if (answer.empty())
496     return 0;
497
498 BLOWFISH_CTX ctx;
499 InitContext(adminPassword.c_str(), ADM_PASSWD_LEN, &ctx);
500
501 std::string::size_type pos = 0;
502 std::string::size_type length = answer.length() + 1;
503 while (pos < length)
504     {
505     char buffer[1024];
506     std::string::size_type chunkLength = std::min(length - pos, sizeof(buffer));
507     EncryptString(buffer, answer.c_str() + pos, chunkLength, &ctx);
508     if (send(sock, buffer, (chunkLength & ~7) < chunkLength ? chunkLength + 8 : chunkLength, 0) < 0) // Need to send data adjusted to the 8-byte boundary.
509         return -1;
510     pos += chunkLength;
511     }
512
513 return 1;
514 }
515 //-----------------------------------------------------------------------------
516 int CONFIGPROTO::SendError(int sock, const std::string & text)
517 {
518 return SendDataAnswer(sock, "<Error value=\"" + text + "\"/>");
519 }
520 //-----------------------------------------------------------------------------
521 void CONFIGPROTO::WriteLogAccessFailed(uint32_t ip)
522 {
523 logger("Admin's connection failed. IP %s", inet_ntostring(ip).c_str());
524 }
525 //-----------------------------------------------------------------------------