X-Git-Url: https://git.stg.codes/stg.git/blobdiff_plain/3dfd70b31d34532a4d2e92fb4d4ee611c1518f18..4e38465a159e5aa365e19ff804efe3c10740c1ec:/stglibs/srvconf.lib/netunit.cpp?ds=inline diff --git a/stglibs/srvconf.lib/netunit.cpp b/stglibs/srvconf.lib/netunit.cpp index 8d559193..baf02004 100644 --- a/stglibs/srvconf.lib/netunit.cpp +++ b/stglibs/srvconf.lib/netunit.cpp @@ -18,22 +18,44 @@ * Author : Boris Mikhailenko */ - /* - $Revision: 1.6 $ - $Date: 2009/02/06 10:25:54 $ - $Author: faust $ - */ +#include "netunit.h" + +#include "stg/servconf_types.h" +#include "stg/common.h" +#include "stg/blowfish.h" +#include "stg/bfstream.h" + +#include // std::min + +#include +#include +#include +#include -//--------------------------------------------------------------------------- #include #include #include -#include -#include +#include +#include +#include -#include "netunit.h" -#include "common.h" +using namespace STG; + +namespace +{ + +const std::string::size_type MAX_XML_CHUNK_LENGTH = 2048; + +struct ReadState +{ + bool final; + NETTRANSACT::CALLBACK callback; + void * callbackData; + NETTRANSACT * nt; +}; + +} //--------------------------------------------------------------------------- @@ -41,6 +63,7 @@ #define RECV_DATA_ANSWER_ERROR "Recv data answer error!" #define UNKNOWN_ERROR "Unknown error!" #define CONNECT_FAILED "Connect failed!" +#define BIND_FAILED "Bind failed!" #define INCORRECT_LOGIN "Incorrect login!" #define INCORRECT_HEADER "Incorrect header!" #define SEND_LOGIN_ERROR "Send login error!" @@ -51,153 +74,153 @@ #define RECV_HEADER_ANSWER_ERROR "Recv header answer error!" //--------------------------------------------------------------------------- -NETTRANSACT::NETTRANSACT() - : port(0), - outerSocket(-1), - RxCallBack(NULL), - dataRxCallBack(NULL) +NETTRANSACT::NETTRANSACT(const std::string & s, uint16_t p, + const std::string & l, const std::string & pwd) + : server(s), + port(p), + localPort(0), + login(l), + password(pwd), + sock(-1) { - memset(login, 0, ADM_LOGIN_LEN); - memset(password, 0, ADM_PASSWD_LEN); } -//----------------------------------------------------------------------------- -void NETTRANSACT::EnDecryptInit(const char * passwd, int, BLOWFISH_CTX *ctx) -{ -unsigned char * keyL = NULL; - -keyL = new unsigned char[PASSWD_LEN]; - -memset(keyL, 0, PASSWD_LEN); - -strncpy((char *)keyL, passwd, PASSWD_LEN); - -Blowfish_Init(ctx, keyL, PASSWD_LEN); - -delete[] keyL; -} -//----------------------------------------------------------------------------- -void NETTRANSACT::Encrypt(char * d, const char * s, BLOWFISH_CTX *ctx) +//--------------------------------------------------------------------------- +NETTRANSACT::NETTRANSACT(const std::string & s, uint16_t p, + const std::string & la, uint16_t lp, + const std::string & l, const std::string & pwd) + : server(s), + port(p), + localAddress(la), + localPort(lp), + login(l), + password(pwd), + sock(-1) { -EncodeString(d, s, ctx); } //--------------------------------------------------------------------------- -void NETTRANSACT::Decrypt(char * d, const char * s, BLOWFISH_CTX *ctx) +NETTRANSACT::~NETTRANSACT() { -DecodeString(d, s, ctx); +Disconnect(); } //--------------------------------------------------------------------------- int NETTRANSACT::Connect() { -int ret; - -outerSocket = socket(PF_INET, SOCK_STREAM, 0); -if (outerSocket < 0) +sock = socket(PF_INET, SOCK_STREAM, 0); +if (sock < 0) { errorMsg = CREATE_SOCKET_ERROR; return st_conn_fail; } +if (!localAddress.empty()) + { + if (localPort == 0) + localPort = port; + + unsigned long ip = inet_addr(localAddress.c_str()); + + if (ip == INADDR_NONE) + { + struct hostent * phe = gethostbyname(localAddress.c_str()); + if (phe == NULL) + { + errorMsg = "DNS error.\nCan not reslove " + localAddress; + return st_dns_err; + } + + struct hostent he; + memcpy(&he, phe, sizeof(he)); + ip = *((long *)he.h_addr_list[0]); + } + + struct sockaddr_in localAddr; + memset(&localAddr, 0, sizeof(localAddr)); + localAddr.sin_family = AF_INET; + localAddr.sin_port = htons(localPort); + localAddr.sin_addr.s_addr = ip; + + if (bind(sock, (struct sockaddr *)&localAddr, sizeof(localAddr)) < 0) + { + errorMsg = BIND_FAILED; + return st_conn_fail; + } + } + struct sockaddr_in outerAddr; memset(&outerAddr, 0, sizeof(outerAddr)); -struct hostent he; -struct hostent * phe; - -unsigned long ip; -ip = inet_addr(server.c_str()); +unsigned long ip = inet_addr(server.c_str()); if (ip == INADDR_NONE) { - phe = gethostbyname(server.c_str()); + struct hostent * phe = gethostbyname(server.c_str()); if (phe == NULL) { errorMsg = "DNS error.\nCan not reslove " + server; return st_dns_err; } + struct hostent he; memcpy(&he, phe, sizeof(he)); - ip = *((long*)he.h_addr_list[0]); + ip = *((long *)he.h_addr_list[0]); } + outerAddr.sin_family = AF_INET; outerAddr.sin_port = htons(port); outerAddr.sin_addr.s_addr = ip; -ret = connect(outerSocket, (struct sockaddr*)&outerAddr, sizeof(outerAddr)); - -if (ret < 0) +if (connect(sock, (struct sockaddr *)&outerAddr, sizeof(outerAddr)) < 0) { errorMsg = CONNECT_FAILED; - close(outerSocket); return st_conn_fail; } + return st_ok; } //--------------------------------------------------------------------------- -int NETTRANSACT::Disconnect() +void NETTRANSACT::Disconnect() { -close(outerSocket); -return 0; +if (sock != -1) + { + shutdown(sock, SHUT_RDWR); + close(sock); + sock = -1; + } } //--------------------------------------------------------------------------- -int NETTRANSACT::Transact(const char * data) +int NETTRANSACT::Transact(const std::string & request, CALLBACK callback, void * data) { int ret; if ((ret = TxHeader()) != st_ok) - { - Disconnect(); return ret; - } if ((ret = RxHeaderAnswer()) != st_ok) - { - Disconnect(); return ret; - } if ((ret = TxLogin()) != st_ok) - { - Disconnect(); return ret; - } if ((ret = RxLoginAnswer()) != st_ok) - { - Disconnect(); return ret; - } if ((ret = TxLoginS()) != st_ok) - { - Disconnect(); return ret; - } if ((ret = RxLoginSAnswer()) != st_ok) - { - Disconnect(); return ret; - } -if ((ret = TxData(data)) != st_ok) - { - Disconnect(); +if ((ret = TxData(request)) != st_ok) return ret; - } -if ((ret = RxDataAnswer()) != st_ok) - { - Disconnect(); +if ((ret = RxDataAnswer(callback, data)) != st_ok) return ret; - } return st_ok; } //--------------------------------------------------------------------------- int NETTRANSACT::TxHeader() { -int ret; -ret = send(outerSocket, STG_HEADER, strlen(STG_HEADER), 0); -if (ret <= 0) +if (!WriteAll(sock, STG_HEADER, strlen(STG_HEADER))) { errorMsg = SEND_HEADER_ERROR; return st_send_fail; @@ -208,45 +231,37 @@ return st_ok; //--------------------------------------------------------------------------- int NETTRANSACT::RxHeaderAnswer() { -char buffer[sizeof(STG_HEADER)+1]; -int ret; +char buffer[sizeof(STG_HEADER) + 1]; -ret = recv(outerSocket, buffer, strlen(OK_HEADER), 0); -if (ret <= 0) +if (!ReadAll(sock, buffer, strlen(OK_HEADER))) { + printf("Receive header answer error: '%s'\n", strerror(errno)); errorMsg = RECV_HEADER_ANSWER_ERROR; return st_recv_fail; } if (strncmp(OK_HEADER, buffer, strlen(OK_HEADER)) == 0) - { return st_ok; + +if (strncmp(ERR_HEADER, buffer, strlen(ERR_HEADER)) == 0) + { + errorMsg = INCORRECT_HEADER; + return st_header_err; } else { - if (strncmp(ERR_HEADER, buffer, strlen(ERR_HEADER)) == 0) - { - errorMsg = INCORRECT_HEADER; - return st_header_err; - } - else - { - errorMsg = UNKNOWN_ERROR; - return st_unknown_err; - } + errorMsg = UNKNOWN_ERROR; + return st_unknown_err; } } //--------------------------------------------------------------------------- int NETTRANSACT::TxLogin() { -char loginZ[ADM_LOGIN_LEN]; -int ret; +char loginZ[ADM_LOGIN_LEN + 1]; +memset(loginZ, 0, ADM_LOGIN_LEN + 1); +strncpy(loginZ, login.c_str(), ADM_LOGIN_LEN); -memset(loginZ, 0, ADM_LOGIN_LEN); -strncpy(loginZ, login, ADM_LOGIN_LEN); -ret = send(outerSocket, loginZ, ADM_LOGIN_LEN, 0); - -if (ret <= 0) +if (!WriteAll(sock, loginZ, ADM_LOGIN_LEN)) { errorMsg = SEND_LOGIN_ERROR; return st_send_fail; @@ -257,56 +272,42 @@ return st_ok; //--------------------------------------------------------------------------- int NETTRANSACT::RxLoginAnswer() { -char buffer[sizeof(OK_LOGIN)+1]; -int ret; +char buffer[sizeof(OK_LOGIN) + 1]; -ret = recv(outerSocket, buffer, strlen(OK_LOGIN), 0); -if (ret <= 0) +if (!ReadAll(sock, buffer, strlen(OK_LOGIN))) { + printf("Receive login answer error: '%s'\n", strerror(errno)); errorMsg = RECV_LOGIN_ANSWER_ERROR; return st_recv_fail; } if (strncmp(OK_LOGIN, buffer, strlen(OK_LOGIN)) == 0) - { return st_ok; + +if (strncmp(ERR_LOGIN, buffer, strlen(ERR_LOGIN)) == 0) + { + errorMsg = INCORRECT_LOGIN; + return st_login_err; } else { - if (strncmp(ERR_LOGIN, buffer, strlen(ERR_LOGIN)) == 0) - { - errorMsg = INCORRECT_LOGIN; - return st_login_err; - } - else - { - errorMsg = UNKNOWN_ERROR; - return st_unknown_err; - } + errorMsg = UNKNOWN_ERROR; + return st_unknown_err; } } //--------------------------------------------------------------------------- int NETTRANSACT::TxLoginS() { -char loginZ[ADM_LOGIN_LEN]; -char ct[ENC_MSG_LEN]; -int ret; - -memset(loginZ, 0, ADM_LOGIN_LEN); -strncpy(loginZ, login, ADM_LOGIN_LEN); +char loginZ[ADM_LOGIN_LEN + 1]; +memset(loginZ, 0, ADM_LOGIN_LEN + 1); BLOWFISH_CTX ctx; -EnDecryptInit(password, PASSWD_LEN, &ctx); - -for (int j = 0; j < ADM_LOGIN_LEN / ENC_MSG_LEN; j++) +InitContext(password.c_str(), PASSWD_LEN, &ctx); +EncryptString(loginZ, login.c_str(), std::min(login.length() + 1, ADM_LOGIN_LEN), &ctx); +if (!WriteAll(sock, loginZ, ADM_LOGIN_LEN)) { - Encrypt(ct, loginZ + j*ENC_MSG_LEN, &ctx); - ret = send(outerSocket, ct, ENC_MSG_LEN, 0); - if (ret <= 0) - { - errorMsg = SEND_LOGIN_ERROR; - return st_send_fail; - } + errorMsg = SEND_LOGIN_ERROR; + return st_send_fail; } return st_ok; @@ -314,69 +315,35 @@ return st_ok; //--------------------------------------------------------------------------- int NETTRANSACT::RxLoginSAnswer() { -char buffer[sizeof(OK_LOGINS)+1]; -int ret; +char buffer[sizeof(OK_LOGINS) + 1]; -ret = recv(outerSocket, buffer, strlen(OK_LOGINS), 0); -if (ret <= 0) +if (!ReadAll(sock, buffer, strlen(OK_LOGINS))) { + printf("Receive secret login answer error: '%s'\n", strerror(errno)); errorMsg = RECV_LOGIN_ANSWER_ERROR; return st_recv_fail; } if (strncmp(OK_LOGINS, buffer, strlen(OK_LOGINS)) == 0) - { return st_ok; + +if (strncmp(ERR_LOGINS, buffer, strlen(ERR_LOGINS)) == 0) + { + errorMsg = INCORRECT_LOGIN; + return st_logins_err; } else { - if (strncmp(ERR_LOGINS, buffer, strlen(ERR_LOGINS)) == 0) - { - errorMsg = INCORRECT_LOGIN; - return st_logins_err; - } - else - { - errorMsg = UNKNOWN_ERROR; - return st_unknown_err; - } + errorMsg = UNKNOWN_ERROR; + return st_unknown_err; } } //--------------------------------------------------------------------------- -int NETTRANSACT::TxData(const char * text) +int NETTRANSACT::TxData(const std::string & text) { -char textZ[ENC_MSG_LEN]; -char ct[ENC_MSG_LEN]; -int ret; -int j; - -int n = strlen(text) / ENC_MSG_LEN; -int r = strlen(text) % ENC_MSG_LEN; - -BLOWFISH_CTX ctx; -EnDecryptInit(password, PASSWD_LEN, &ctx); - -for (j = 0; j < n; j++) - { - strncpy(textZ, text + j*ENC_MSG_LEN, ENC_MSG_LEN); - Encrypt(ct, textZ, &ctx); - ret = send(outerSocket, ct, ENC_MSG_LEN, 0); - if (ret <= 0) - { - errorMsg = SEND_DATA_ERROR; - return st_send_fail; - } - } - -memset(textZ, 0, ENC_MSG_LEN); -if (r) - strncpy(textZ, text + j*ENC_MSG_LEN, ENC_MSG_LEN); - -EnDecryptInit(password, PASSWD_LEN, &ctx); - -Encrypt(ct, textZ, &ctx); -ret = send(outerSocket, ct, ENC_MSG_LEN, 0); -if (ret <= 0) +STG::ENCRYPT_STREAM stream(password, TxCrypto, this); +stream.Put(text.c_str(), text.length() + 1, true); +if (!stream.isOk()) { errorMsg = SEND_DATA_ERROR; return st_send_fail; @@ -385,111 +352,53 @@ if (ret <= 0) return st_ok; } //--------------------------------------------------------------------------- -int NETTRANSACT::TxData(char * data) -{ -char buff[ENC_MSG_LEN]; -char buffS[ENC_MSG_LEN]; -char passwd[ADM_PASSWD_LEN]; - -memset(passwd, 0, ADM_PASSWD_LEN); -strncpy(passwd, password, ADM_PASSWD_LEN); -memset(buff, 0, ENC_MSG_LEN); - -int l = strlen(data)/ENC_MSG_LEN; -if (strlen(data)%ENC_MSG_LEN) - l++; - -BLOWFISH_CTX ctx; -EnDecryptInit(passwd, PASSWD_LEN, &ctx); - -for (int j = 0; j < l; j++) - { - strncpy(buff, &data[j*ENC_MSG_LEN], ENC_MSG_LEN); - Encrypt(buffS, buff, &ctx); - send(outerSocket, buffS, ENC_MSG_LEN, 0); - } - -return 0; -} -//--------------------------------------------------------------------------- -int NETTRANSACT::RxDataAnswer() +int NETTRANSACT::RxDataAnswer(CALLBACK callback, void * data) { -int n = 0; -int ret; -char bufferS[ENC_MSG_LEN]; -char buffer[ENC_MSG_LEN + 1]; - -BLOWFISH_CTX ctx; -EnDecryptInit(password, PASSWD_LEN, &ctx); - -while (1) +ReadState state = {false, callback, data, this}; +STG::DECRYPT_STREAM stream(password, RxCrypto, &state); +while (!state.final) { - ret = recv(outerSocket, &bufferS[n++], 1, 0); - if (ret <= 0) + char buffer[1024]; + ssize_t res = read(sock, buffer, sizeof(buffer)); + if (res < 0) { - close(outerSocket); + printf("Receive data error: '%s'\n", strerror(errno)); errorMsg = RECV_DATA_ANSWER_ERROR; return st_recv_fail; } - - if (n == ENC_MSG_LEN) - { - - n = 0; - Decrypt(buffer, bufferS, &ctx); - buffer[ENC_MSG_LEN] = 0; - - answerList.push_back(buffer); - - for (int j = 0; j < ENC_MSG_LEN; j++) - { - if (buffer[j] == 0) - { - if (RxCallBack) - if (st_ok != RxCallBack(dataRxCallBack, &answerList)) - { - return st_xml_parse_error; - } - return st_ok; - } - } - } + stream.Put(buffer, res, res == 0); + if (!stream.isOk()) + return st_xml_parse_error; } + +return st_ok; } //--------------------------------------------------------------------------- -void NETTRANSACT::SetLogin(const char * l) -{ -strncpy(login, l, ADM_LOGIN_LEN); -} -//--------------------------------------------------------------------------- -void NETTRANSACT::SetPassword(const char * p) -{ -strncpy(password, p, ADM_PASSWD_LEN); -} -//--------------------------------------------------------------------------- -void NETTRANSACT::SetServer(const char * serverName) -{ -server = serverName; -} -//--------------------------------------------------------------------------- -void NETTRANSACT::SetServerPort(short unsigned p) -{ -port = p; -} -//--------------------------------------------------------------------------- -void NETTRANSACT::SetRxCallback(void * data, RxCallback_t cb) -{ -RxCallBack = cb; -dataRxCallBack = data; -} -//--------------------------------------------------------------------------- -const std::string & NETTRANSACT::GetError() const +bool NETTRANSACT::TxCrypto(const void * block, size_t size, void * data) { -return errorMsg; +assert(data != NULL); +NETTRANSACT & nt = *static_cast(data); +if (!WriteAll(nt.sock, block, size)) + return false; +return true; } //--------------------------------------------------------------------------- -void NETTRANSACT::Reset() +bool NETTRANSACT::RxCrypto(const void * block, size_t size, void * data) { -answerList.clear(); +assert(data != NULL); +ReadState & state = *static_cast(data); + +const char * buffer = static_cast(block); +for (size_t pos = 0; pos < size; ++pos) + if (buffer[pos] == 0) + { + state.final = true; + size = pos; // Adjust string size + } + +if (state.callback) + if (!state.callback(std::string(buffer, size), state.final, state.callbackData)) + return false; + +return true; } -//---------------------------------------------------------------------------