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