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