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 #include "netunit.h"
  22
  23 #include "stg/servconf_types.h"
  24 #include "stg/common.h"
  25 #include "stg/blowfish.h"
  26 #include "stg/bfstream.h"
  27
  28 #include <algorithm> // std::min
  29
  30 #include <cstdio>
  31 #include <cerrno>
  32 #include <cstring>
  33 #include <cassert>
  34
  35 #include <netdb.h>
  36 #include <arpa/inet.h>
  37 #include <unistd.h>
  38
  39 #include <sys/types.h>
  40 #include <sys/socket.h>
  41 #include <netinet/in.h>
  42
  43 using namespace STG;
  44
  45 namespace
  46 {
  47
  48 struct ReadState
  49 {
  50     bool final;
  51     NETTRANSACT::CALLBACK callback;
  52     void * callbackData;
  53     NETTRANSACT * nt;
  54 };
  55
  56 }
  57
  58 //---------------------------------------------------------------------------
  59
  60 #define SEND_DATA_ERROR             "Send data error!"
  61 #define RECV_DATA_ANSWER_ERROR      "Recv data answer error!"
  62 #define UNKNOWN_ERROR               "Unknown error!"
  63 #define CONNECT_FAILED              "Connect failed!"
  64 #define BIND_FAILED                 "Bind failed!"
  65 #define INCORRECT_LOGIN             "Incorrect login!"
  66 #define INCORRECT_HEADER            "Incorrect header!"
  67 #define SEND_LOGIN_ERROR            "Send login error!"
  68 #define RECV_LOGIN_ANSWER_ERROR     "Recv login answer error!"
  69 #define CREATE_SOCKET_ERROR         "Create socket failed!"
  70 #define WSASTARTUP_FAILED           "WSAStartup failed!"
  71 #define SEND_HEADER_ERROR           "Send header error!"
  72 #define RECV_HEADER_ANSWER_ERROR    "Recv header answer error!"
  73
  74 //---------------------------------------------------------------------------
  75 NETTRANSACT::NETTRANSACT(const std::string & s, uint16_t p,
  76                          const std::string & l, const std::string & pwd)
  77     : server(s),
  78       port(p),
  79       localPort(0),
  80       login(l),
  81       password(pwd),
  82       sock(-1)
  83 {
  84 }
  85 //---------------------------------------------------------------------------
  86 NETTRANSACT::NETTRANSACT(const std::string & s, uint16_t p,
  87                          const std::string & la, uint16_t lp,
  88                          const std::string & l, const std::string & pwd)
  89     : server(s),
  90       port(p),
  91       localAddress(la),
  92       localPort(lp),
  93       login(l),
  94       password(pwd),
  95       sock(-1)
  96 {
  97 }
  98 //---------------------------------------------------------------------------
  99 NETTRANSACT::~NETTRANSACT()
 100 {
 101 Disconnect();
 102 }
 103 //---------------------------------------------------------------------------
 104 int NETTRANSACT::Connect()
 105 {
 106 sock = socket(PF_INET, SOCK_STREAM, 0);
 107 if (sock < 0)
 108     {
 109     errorMsg = CREATE_SOCKET_ERROR;
 110     return st_conn_fail;
 111     }
 112
 113 if (!localAddress.empty())
 114     {
 115     if (localPort == 0)
 116         localPort = port;
 117
 118     unsigned long ip = inet_addr(localAddress.c_str());
 119
 120     if (ip == INADDR_NONE)
 121         {
 122         struct hostent * phe = gethostbyname(localAddress.c_str());
 123         if (phe == NULL)
 124             {
 125             errorMsg = "DNS error.\nCan not reslove " + localAddress;
 126             return st_dns_err;
 127             }
 128
 129         struct hostent he;
 130         memcpy(&he, phe, sizeof(he));
 131         ip = *((long *)he.h_addr_list[0]);
 132         }
 133
 134     struct sockaddr_in localAddr;
 135     memset(&localAddr, 0, sizeof(localAddr));
 136     localAddr.sin_family = AF_INET;
 137     localAddr.sin_port = htons(localPort);
 138     localAddr.sin_addr.s_addr = ip;
 139
 140     if (bind(sock, (struct sockaddr *)&localAddr, sizeof(localAddr)) < 0)
 141         {
 142         errorMsg = BIND_FAILED;
 143         return st_conn_fail;
 144         }
 145     }
 146
 147 struct sockaddr_in outerAddr;
 148 memset(&outerAddr, 0, sizeof(outerAddr));
 149
 150 unsigned long ip = inet_addr(server.c_str());
 151
 152 if (ip == INADDR_NONE)
 153     {
 154     struct hostent * phe = gethostbyname(server.c_str());
 155     if (phe == NULL)
 156         {
 157         errorMsg = "DNS error.\nCan not reslove " + server;
 158         return st_dns_err;
 159         }
 160
 161     struct hostent he;
 162     memcpy(&he, phe, sizeof(he));
 163     ip = *((long *)he.h_addr_list[0]);
 164     }
 165
 166 outerAddr.sin_family = AF_INET;
 167 outerAddr.sin_port = htons(port);
 168 outerAddr.sin_addr.s_addr = ip;
 169
 170 if (connect(sock, (struct sockaddr *)&outerAddr, sizeof(outerAddr)) < 0)
 171     {
 172     errorMsg = CONNECT_FAILED;
 173     return st_conn_fail;
 174     }
 175
 176 return st_ok;
 177 }
 178 //---------------------------------------------------------------------------
 179 void NETTRANSACT::Disconnect()
 180 {
 181 if (sock != -1)
 182     {
 183     shutdown(sock, SHUT_RDWR);
 184     close(sock);
 185     sock = -1;
 186     }
 187 }
 188 //---------------------------------------------------------------------------
 189 int NETTRANSACT::Transact(const std::string & request, CALLBACK callback, void * data)
 190 {
 191 int ret;
 192 if ((ret = TxHeader()) != st_ok)
 193     return ret;
 194
 195 if ((ret = RxHeaderAnswer()) != st_ok)
 196     return ret;
 197
 198 if ((ret = TxLogin()) != st_ok)
 199     return ret;
 200
 201 if ((ret = RxLoginAnswer()) != st_ok)
 202     return ret;
 203
 204 if ((ret = TxLoginS()) != st_ok)
 205     return ret;
 206
 207 if ((ret = RxLoginSAnswer()) != st_ok)
 208     return ret;
 209
 210 if ((ret = TxData(request)) != st_ok)
 211     return ret;
 212
 213 if ((ret = RxDataAnswer(callback, data)) != st_ok)
 214     return ret;
 215
 216 return st_ok;
 217 }
 218 //---------------------------------------------------------------------------
 219 int NETTRANSACT::TxHeader()
 220 {
 221 if (!WriteAll(sock, STG_HEADER, strlen(STG_HEADER)))
 222     {
 223     errorMsg = SEND_HEADER_ERROR;
 224     return st_send_fail;
 225     }
 226
 227 return st_ok;
 228 }
 229 //---------------------------------------------------------------------------
 230 int NETTRANSACT::RxHeaderAnswer()
 231 {
 232 char buffer[sizeof(STG_HEADER) + 1];
 233
 234 if (!ReadAll(sock, buffer, strlen(OK_HEADER)))
 235     {
 236     printf("Receive header answer error: '%s'\n", strerror(errno));
 237     errorMsg = RECV_HEADER_ANSWER_ERROR;
 238     return st_recv_fail;
 239     }
 240
 241 if (strncmp(OK_HEADER, buffer, strlen(OK_HEADER)) == 0)
 242     return st_ok;
 243
 244 if (strncmp(ERR_HEADER, buffer, strlen(ERR_HEADER)) == 0)
 245     {
 246     errorMsg = INCORRECT_HEADER;
 247     return st_header_err;
 248     }
 249 else
 250     {
 251     errorMsg = UNKNOWN_ERROR;
 252     return st_unknown_err;
 253     }
 254 }
 255 //---------------------------------------------------------------------------
 256 int NETTRANSACT::TxLogin()
 257 {
 258 char loginZ[ADM_LOGIN_LEN + 1];
 259 memset(loginZ, 0, ADM_LOGIN_LEN + 1);
 260 strncpy(loginZ, login.c_str(), ADM_LOGIN_LEN);
 261
 262 if (!WriteAll(sock, loginZ, ADM_LOGIN_LEN))
 263     {
 264     errorMsg = SEND_LOGIN_ERROR;
 265     return st_send_fail;
 266     }
 267
 268 return st_ok;
 269 }
 270 //---------------------------------------------------------------------------
 271 int NETTRANSACT::RxLoginAnswer()
 272 {
 273 char buffer[sizeof(OK_LOGIN) + 1];
 274
 275 if (!ReadAll(sock, buffer, strlen(OK_LOGIN)))
 276     {
 277     printf("Receive login answer error: '%s'\n", strerror(errno));
 278     errorMsg = RECV_LOGIN_ANSWER_ERROR;
 279     return st_recv_fail;
 280     }
 281
 282 if (strncmp(OK_LOGIN, buffer, strlen(OK_LOGIN)) == 0)
 283     return st_ok;
 284
 285 if (strncmp(ERR_LOGIN, buffer, strlen(ERR_LOGIN)) == 0)
 286     {
 287     errorMsg = INCORRECT_LOGIN;
 288     return st_login_err;
 289     }
 290 else
 291     {
 292     errorMsg = UNKNOWN_ERROR;
 293     return st_unknown_err;
 294     }
 295 }
 296 //---------------------------------------------------------------------------
 297 int NETTRANSACT::TxLoginS()
 298 {
 299 char loginZ[ADM_LOGIN_LEN + 1];
 300 memset(loginZ, 0, ADM_LOGIN_LEN + 1);
 301
 302 BLOWFISH_CTX ctx;
 303 InitContext(password.c_str(), PASSWD_LEN, &ctx);
 304 EncryptString(loginZ, login.c_str(), std::min<size_t>(login.length() + 1, ADM_LOGIN_LEN), &ctx);
 305 if (!WriteAll(sock, loginZ, ADM_LOGIN_LEN))
 306     {
 307     errorMsg = SEND_LOGIN_ERROR;
 308     return st_send_fail;
 309     }
 310
 311 return st_ok;
 312 }
 313 //---------------------------------------------------------------------------
 314 int NETTRANSACT::RxLoginSAnswer()
 315 {
 316 char buffer[sizeof(OK_LOGINS) + 1];
 317
 318 if (!ReadAll(sock, buffer, strlen(OK_LOGINS)))
 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     return st_ok;
 327
 328 if (strncmp(ERR_LOGINS, buffer, strlen(ERR_LOGINS)) == 0)
 329     {
 330     errorMsg = INCORRECT_LOGIN;
 331     return st_logins_err;
 332     }
 333 else
 334     {
 335     errorMsg = UNKNOWN_ERROR;
 336     return st_unknown_err;
 337     }
 338 }
 339 //---------------------------------------------------------------------------
 340 int NETTRANSACT::TxData(const std::string & text)
 341 {
 342 STG::ENCRYPT_STREAM stream(password, TxCrypto, this);
 343 stream.Put(text.c_str(), text.length() + 1, true);
 344 if (!stream.IsOk())
 345     {
 346     errorMsg = SEND_DATA_ERROR;
 347     return st_send_fail;
 348     }
 349
 350 return st_ok;
 351 }
 352 //---------------------------------------------------------------------------
 353 int NETTRANSACT::RxDataAnswer(CALLBACK callback, void * data)
 354 {
 355 ReadState state = {false, callback, data, this};
 356 STG::DECRYPT_STREAM stream(password, RxCrypto, &state);
 357 while (!state.final)
 358     {
 359     char buffer[1024];
 360     ssize_t res = read(sock, buffer, sizeof(buffer));
 361     if (res < 0)
 362         {
 363         printf("Receive data error: '%s'\n", strerror(errno));
 364         errorMsg = RECV_DATA_ANSWER_ERROR;
 365         return st_recv_fail;
 366         }
 367     stream.Put(buffer, res, res == 0);
 368     if (!stream.IsOk())
 369         return st_xml_parse_error;
 370     }
 371
 372 return st_ok;
 373 }
 374 //---------------------------------------------------------------------------
 375 bool NETTRANSACT::TxCrypto(const void * block, size_t size, void * data)
 376 {
 377 assert(data != NULL);
 378 NETTRANSACT & nt = *static_cast<NETTRANSACT *>(data);
 379 if (!WriteAll(nt.sock, block, size))
 380     return false;
 381 return true;
 382 }
 383 //---------------------------------------------------------------------------
 384 bool NETTRANSACT::RxCrypto(const void * block, size_t size, void * data)
 385 {
 386 assert(data != NULL);
 387 ReadState & state = *static_cast<ReadState *>(data);
 388
 389 const char * buffer = static_cast<const char *>(block);
 390 for (size_t pos = 0; pos < size; ++pos)
 391     if (buffer[pos] == 0)
 392         {
 393         state.final = true;
 394         size = pos; // Adjust string size
 395         }
 396
 397 if (state.callback)
 398     if (!state.callback(std::string(buffer, size), state.final, state.callbackData))
 399         return false;
 400
 401 return true;
 402 }