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