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 "stg/blowfish.h"
  36 #include "configproto.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 //-----------------------------------------------------------------------------