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