stglibs/srvconf.lib/netunit.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  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  19  */
  20
  21  /*
  22  $Revision: 1.6 $
  23  $Date: 2009/02/06 10:25:54 $
  24  $Author: faust $
  25  */
  26
  27 //---------------------------------------------------------------------------
  28
  29 #include "netunit.h"
  30
  31 #include "stg/servconf_types.h"
  32 #include "stg/common.h"
  33 #include "stg/blowfish.h"
  34
  35 #include <cstdio>
  36 #include <cerrno>
  37 #include <cstring>
  38
  39 #include <netdb.h>
  40 #include <arpa/inet.h>
  41 #include <unistd.h>
  42
  43 #include <sys/types.h>
  44 #include <sys/socket.h>
  45 #include <netinet/in.h>
  46
  47 using namespace STG;
  48
  49 namespace
  50 {
  51
  52 const std::string::size_type MAX_XML_CHUNK_LENGTH = 2048;
  53
  54 }
  55
  56 //---------------------------------------------------------------------------
  57
  58 #define SEND_DATA_ERROR             "Send data error!"
  59 #define RECV_DATA_ANSWER_ERROR      "Recv data answer error!"
  60 #define UNKNOWN_ERROR               "Unknown error!"
  61 #define CONNECT_FAILED              "Connect failed!"
  62 #define INCORRECT_LOGIN             "Incorrect login!"
  63 #define INCORRECT_HEADER            "Incorrect header!"
  64 #define SEND_LOGIN_ERROR            "Send login error!"
  65 #define RECV_LOGIN_ANSWER_ERROR     "Recv login answer error!"
  66 #define CREATE_SOCKET_ERROR         "Create socket failed!"
  67 #define WSASTARTUP_FAILED           "WSAStartup failed!"
  68 #define SEND_HEADER_ERROR           "Send header error!"
  69 #define RECV_HEADER_ANSWER_ERROR    "Recv header answer error!"
  70
  71 //---------------------------------------------------------------------------
  72 NETTRANSACT::NETTRANSACT(const std::string & s, uint16_t p,
  73                          const std::string & l, const std::string & pwd)
  74     : server(s),
  75       port(p),
  76       login(l),
  77       password(pwd),
  78       outerSocket(-1),
  79       RxCallBack(NULL),
  80       dataRxCallBack(NULL)
  81 {
  82 }
  83 //---------------------------------------------------------------------------
  84 int NETTRANSACT::Connect()
  85 {
  86 int ret;
  87
  88 outerSocket = socket(PF_INET, SOCK_STREAM, 0);
  89 if (outerSocket < 0)
  90     {
  91     errorMsg = CREATE_SOCKET_ERROR;
  92     return st_conn_fail;
  93     }
  94
  95 struct sockaddr_in outerAddr;
  96 memset(&outerAddr, 0, sizeof(outerAddr));
  97
  98 struct hostent he;
  99 struct hostent * phe;
 100
 101 unsigned long ip;
 102 ip = inet_addr(server.c_str());
 103
 104 if (ip == INADDR_NONE)
 105     {
 106     phe = gethostbyname(server.c_str());
 107     if (phe == NULL)
 108         {
 109         errorMsg = "DNS error.\nCan not reslove " + server;
 110         return st_dns_err;
 111         }
 112
 113     memcpy(&he, phe, sizeof(he));
 114     ip = *((long*)he.h_addr_list[0]);
 115     }
 116 outerAddr.sin_family = AF_INET;
 117 outerAddr.sin_port = htons(port);
 118 outerAddr.sin_addr.s_addr = ip;
 119
 120 ret = connect(outerSocket, (struct sockaddr*)&outerAddr, sizeof(outerAddr));
 121
 122 if (ret < 0)
 123     {
 124     errorMsg = CONNECT_FAILED;
 125     close(outerSocket);
 126     return st_conn_fail;
 127     }
 128 return st_ok;
 129 }
 130 //---------------------------------------------------------------------------
 131 int NETTRANSACT::Disconnect()
 132 {
 133 close(outerSocket);
 134 return 0;
 135 }
 136 //---------------------------------------------------------------------------
 137 int NETTRANSACT::Transact(const char * data)
 138 {
 139 int ret;
 140 if ((ret = TxHeader()) != st_ok)
 141     {
 142     Disconnect();
 143     return ret;
 144     }
 145
 146 if ((ret = RxHeaderAnswer()) != st_ok)
 147     {
 148     Disconnect();
 149     return ret;
 150     }
 151
 152 if ((ret = TxLogin()) != st_ok)
 153     {
 154     Disconnect();
 155     return ret;
 156     }
 157
 158 if ((ret = RxLoginAnswer()) != st_ok)
 159     {
 160     Disconnect();
 161     return ret;
 162     }
 163
 164 if ((ret = TxLoginS()) != st_ok)
 165     {
 166     Disconnect();
 167     return ret;
 168     }
 169
 170 if ((ret = RxLoginSAnswer()) != st_ok)
 171     {
 172     Disconnect();
 173     return ret;
 174     }
 175
 176 if ((ret = TxData(data)) != st_ok)
 177     {
 178     Disconnect();
 179     return ret;
 180     }
 181
 182 if ((ret = RxDataAnswer()) != st_ok)
 183     {
 184     Disconnect();
 185     return ret;
 186     }
 187
 188 return st_ok;
 189 }
 190 //---------------------------------------------------------------------------
 191 int NETTRANSACT::TxHeader()
 192 {
 193 int ret;
 194 ret = send(outerSocket, STG_HEADER, strlen(STG_HEADER), 0);
 195 if (ret <= 0)
 196     {
 197     errorMsg = SEND_HEADER_ERROR;
 198     return st_send_fail;
 199     }
 200
 201 return st_ok;
 202 }
 203 //---------------------------------------------------------------------------
 204 int NETTRANSACT::RxHeaderAnswer()
 205 {
 206 char buffer[sizeof(STG_HEADER)+1];
 207 int ret;
 208
 209 ret = recv(outerSocket, buffer, strlen(OK_HEADER), 0);
 210 if (ret <= 0)
 211     {
 212     printf("Receive header answer error: '%s'\n", strerror(errno));
 213     errorMsg = RECV_HEADER_ANSWER_ERROR;
 214     return st_recv_fail;
 215     }
 216
 217 if (strncmp(OK_HEADER, buffer, strlen(OK_HEADER)) == 0)
 218     {
 219     return st_ok;
 220     }
 221 else
 222     {
 223     if (strncmp(ERR_HEADER, buffer, strlen(ERR_HEADER)) == 0)
 224         {
 225         errorMsg = INCORRECT_HEADER;
 226         return st_header_err;
 227         }
 228     else
 229         {
 230         errorMsg = UNKNOWN_ERROR;
 231         return st_unknown_err;
 232         }
 233     }
 234 }
 235 //---------------------------------------------------------------------------
 236 int NETTRANSACT::TxLogin()
 237 {
 238 char loginZ[ADM_LOGIN_LEN];
 239 int ret;
 240
 241 memset(loginZ, 0, ADM_LOGIN_LEN);
 242 strncpy(loginZ, login.c_str(), ADM_LOGIN_LEN);
 243 ret = send(outerSocket, loginZ, ADM_LOGIN_LEN, 0);
 244
 245 if (ret <= 0)
 246     {
 247     errorMsg = SEND_LOGIN_ERROR;
 248     return st_send_fail;
 249     }
 250
 251 return st_ok;
 252 }
 253 //---------------------------------------------------------------------------
 254 int NETTRANSACT::RxLoginAnswer()
 255 {
 256 char buffer[sizeof(OK_LOGIN)+1];
 257 int ret;
 258
 259 ret = recv(outerSocket, buffer, strlen(OK_LOGIN), 0);
 260 if (ret <= 0)
 261     {
 262     printf("Receive login answer error: '%s'\n", strerror(errno));
 263     errorMsg = RECV_LOGIN_ANSWER_ERROR;
 264     return st_recv_fail;
 265     }
 266
 267 if (strncmp(OK_LOGIN, buffer, strlen(OK_LOGIN)) == 0)
 268     {
 269     return st_ok;
 270     }
 271 else
 272     {
 273     if (strncmp(ERR_LOGIN, buffer, strlen(ERR_LOGIN)) == 0)
 274         {
 275         errorMsg = INCORRECT_LOGIN;
 276         return st_login_err;
 277         }
 278     else
 279         {
 280         errorMsg = UNKNOWN_ERROR;
 281         return st_unknown_err;
 282         }
 283     }
 284 }
 285 //---------------------------------------------------------------------------
 286 int NETTRANSACT::TxLoginS()
 287 {
 288 char loginZ[ADM_LOGIN_LEN];
 289 char ct[ENC_MSG_LEN];
 290 int ret;
 291
 292 memset(loginZ, 0, ADM_LOGIN_LEN);
 293 strncpy(loginZ, login.c_str(), ADM_LOGIN_LEN);
 294
 295 BLOWFISH_CTX ctx;
 296 EnDecodeInit(password.c_str(), PASSWD_LEN, &ctx);
 297
 298 for (int j = 0; j < ADM_LOGIN_LEN / ENC_MSG_LEN; j++)
 299     {
 300     EncodeString(ct, loginZ + j*ENC_MSG_LEN, &ctx);
 301     ret = send(outerSocket, ct, ENC_MSG_LEN, 0);
 302     if (ret <= 0)
 303         {
 304         errorMsg = SEND_LOGIN_ERROR;
 305         return st_send_fail;
 306         }
 307     }
 308
 309 return st_ok;
 310 }
 311 //---------------------------------------------------------------------------
 312 int NETTRANSACT::RxLoginSAnswer()
 313 {
 314 char buffer[sizeof(OK_LOGINS)+1];
 315 int ret;
 316
 317 ret = recv(outerSocket, buffer, strlen(OK_LOGINS), 0);
 318 if (ret <= 0)
 319     {
 320     printf("Receive secret login answer error: '%s'\n", strerror(errno));
 321     errorMsg = RECV_LOGIN_ANSWER_ERROR;
 322     return st_recv_fail;
 323     }
 324
 325 if (strncmp(OK_LOGINS, buffer, strlen(OK_LOGINS)) == 0)
 326     {
 327     return st_ok;
 328     }
 329 else
 330     {
 331     if (strncmp(ERR_LOGINS, buffer, strlen(ERR_LOGINS)) == 0)
 332         {
 333         errorMsg = INCORRECT_LOGIN;
 334         return st_logins_err;
 335         }
 336     else
 337         {
 338         errorMsg = UNKNOWN_ERROR;
 339         return st_unknown_err;
 340         }
 341     }
 342 }
 343 //---------------------------------------------------------------------------
 344 int NETTRANSACT::TxData(const char * text)
 345 {
 346 char textZ[ENC_MSG_LEN];
 347 char ct[ENC_MSG_LEN];
 348 int ret;
 349 int j;
 350
 351 int n = strlen(text) / ENC_MSG_LEN;
 352 int r = strlen(text) % ENC_MSG_LEN;
 353
 354 BLOWFISH_CTX ctx;
 355 EnDecodeInit(password.c_str(), PASSWD_LEN, &ctx);
 356
 357 for (j = 0; j < n; j++)
 358     {
 359     strncpy(textZ, text + j*ENC_MSG_LEN, ENC_MSG_LEN);
 360     EncodeString(ct, textZ, &ctx);
 361     ret = send(outerSocket, ct, ENC_MSG_LEN, 0);
 362     if (ret <= 0)
 363         {
 364         errorMsg = SEND_DATA_ERROR;
 365         return st_send_fail;
 366         }
 367     }
 368
 369 memset(textZ, 0, ENC_MSG_LEN);
 370 if (r)
 371     strncpy(textZ, text + j*ENC_MSG_LEN, ENC_MSG_LEN);
 372
 373 EnDecodeInit(password.c_str(), PASSWD_LEN, &ctx);
 374
 375 EncodeString(ct, textZ, &ctx);
 376 ret = send(outerSocket, ct, ENC_MSG_LEN, 0);
 377 if (ret <= 0)
 378     {
 379     errorMsg = SEND_DATA_ERROR;
 380     return st_send_fail;
 381     }
 382
 383 return st_ok;
 384 }
 385 //---------------------------------------------------------------------------
 386 int NETTRANSACT::TxData(char * data)
 387 {
 388 char buff[ENC_MSG_LEN];
 389 char buffS[ENC_MSG_LEN];
 390 char passwd[ADM_PASSWD_LEN];
 391
 392 memset(passwd, 0, ADM_PASSWD_LEN);
 393 strncpy(passwd, password.c_str(), ADM_PASSWD_LEN);
 394 memset(buff, 0, ENC_MSG_LEN);
 395
 396 int l = strlen(data)/ENC_MSG_LEN;
 397 if (strlen(data)%ENC_MSG_LEN)
 398     l++;
 399
 400 BLOWFISH_CTX ctx;
 401 EnDecodeInit(passwd, PASSWD_LEN, &ctx);
 402
 403 for (int j = 0; j < l; j++)
 404     {
 405     strncpy(buff, &data[j*ENC_MSG_LEN], ENC_MSG_LEN);
 406     EncodeString(buffS, buff, &ctx);
 407     send(outerSocket, buffS, ENC_MSG_LEN, 0);
 408     }
 409
 410 return 0;
 411 }
 412 //---------------------------------------------------------------------------
 413 int NETTRANSACT::RxDataAnswer()
 414 {
 415 BLOWFISH_CTX ctx;
 416 EnDecodeInit(password.c_str(), PASSWD_LEN, &ctx);
 417
 418 std::string chunk;
 419 while (true)
 420     {
 421     char bufferS[ENC_MSG_LEN];
 422     size_t toRead = ENC_MSG_LEN;
 423     while (toRead > 0)
 424         {
 425         int ret = recv(outerSocket, &bufferS[ENC_MSG_LEN - toRead], toRead, 0);
 426         if (ret <= 0)
 427             {
 428             printf("Receive data error: '%s'\n", strerror(errno));
 429             close(outerSocket);
 430             errorMsg = RECV_DATA_ANSWER_ERROR;
 431             return st_recv_fail;
 432             }
 433         toRead -= ret;
 434         }
 435
 436     char buffer[ENC_MSG_LEN];
 437     DecodeString(buffer, bufferS, &ctx);
 438
 439     bool final = false;
 440     size_t pos = 0;
 441     for (; pos < ENC_MSG_LEN && buffer[pos] != 0; pos++) ;
 442     if (pos < ENC_MSG_LEN && buffer[pos] == 0)
 443         final = true;
 444
 445     if (pos > 0)
 446         chunk.append(&buffer[0], &buffer[pos]);
 447
 448     if (chunk.length() > MAX_XML_CHUNK_LENGTH || final)
 449         {
 450         if (RxCallBack != NULL)
 451             if (!RxCallBack(dataRxCallBack, chunk, final))
 452                 return st_xml_parse_error;
 453         chunk.clear();
 454         }
 455
 456     if (final)
 457         return st_ok;
 458     }
 459 }
 460 //---------------------------------------------------------------------------
 461 void NETTRANSACT::SetRxCallback(void * data, RxCallback_t cb)
 462 {
 463 RxCallBack = cb;
 464 dataRxCallBack = data;
 465 }
 466 //---------------------------------------------------------------------------
 467 const std::string & NETTRANSACT::GetError() const
 468 {
 469 return errorMsg;
 470 }
 471 //---------------------------------------------------------------------------