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