bool SimpleHttpClient::write () {
if (!checkSocket()) {
return false;
}
//printf("write():\n%s\n", (_writeBuffer.c_str() + _written));
#ifdef __APPLE__
int status = ::send(_socket, _writeBuffer.c_str() + _written, _writeBuffer.length() - _written, 0);
#else
int status = ::send(_socket, _writeBuffer.c_str() + _written, _writeBuffer.length() - _written, MSG_NOSIGNAL);
#endif
if (status == -1) {
_errorMessage = "::send() failed with: " + string(strerror(errno));
//LOGGER_ERROR << "::send() failed with " << strerror(errno);
close();
return false;
}
_written += status;
if (_written == _writeBuffer.length()) {
_state = IN_READ_HEADER;
}
return true;
}
int EasySocket::listen(int count)
{
if(!checkSocket(m_socket)) return -1;
int res = ::listen(m_socket,count);
checkResult(res);
return res;
}
int CTCPSocket::sendMsg(char* pBuffer, int iLen, int iTimeout)
{
const char *pTemp = pBuffer;
int iRemainSize = iLen;
int iSendSize;
//int iCounter = 0;
g_insLogMng.debug("socket", CLogMng::LogMode3, "Begin to send message block.");
while(iRemainSize > 0)
{
// wait until the socket is writable
if(checkSocket(iTimeout, WriteMode) == -1)
{
g_insLogMng.error( "Send message failed as check socket timeout.");
return -1; //等待出错
}
iSendSize = send(m_iFd, pTemp, iRemainSize, 0);
if(iSendSize < 0)
{
if(errno == ENOBUFS || errno == EAGAIN)
{
iSendSize = 0;
}
/* ignore signal */
//kevinliu modify temp 10-04
//else if(errno == EINTR && nCounter < MaxIgnoreSignal && iSendSize < 0)
else if(errno == EINTR && iSendSize < 0)
{
//iCounter++;
iSendSize = 0;
CComFun::sleep_msec(0, 10);
}
else
{
g_insLogMng.error( "Send message failed because send to socket error.");
return -2; //发送出错
}
}
iRemainSize = iRemainSize - iSendSize;
if(iRemainSize > 0)
{
pTemp = pTemp + iSendSize;
}
}
// code stream
g_insLogMng.bin("socket", CLogMng::LogMode3, pBuffer, iLen);
g_insLogMng.debug("socket", CLogMng::LogMode3, "End to send message block.");
return 0;
}
int EasySocket::accept()
{
if(!checkSocket(m_socket)) return -1;
m_replySocket = ::accept(m_socket,nullptr,nullptr);
checkResult((int)m_replySocket);
if(checkSocket(m_replySocket))
{
int send_buffer = 64*1024*1024;
int send_buffer_sizeof = sizeof(int);
setsockopt(m_replySocket, SOL_SOCKET, SO_SNDBUF, (char*)&send_buffer, send_buffer_sizeof);
//int flag = 1;
//int result = setsockopt(m_replySocket,IPPROTO_TCP,TCP_NODELAY,(char *)&flag,sizeof(int));
//setBlocking(m_replySocket,true);
}
return (int)m_replySocket;
}
bool SimpleHttpClient::connectSocket (struct addrinfo *aip) {
// create socket and connect socket here
_socket = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
// check socket and set the socket not blocking and close on exit
if (_socket == -1) {
//setErrorMessage("Socket not connected. socket() faild with: " + string(strerror(errno)), errno);
return false;
}
if (!setNonBlocking(_socket)) {
//setErrorMessage("Socket not connected. Set non blocking failed with: " + string(strerror(errno)), errno);
::close(_socket);
_socket = -1;
return false;
}
if (!setCloseOnExec(_socket)) {
//setErrorMessage("Socket not connected. Set close on exec failed with: " + string(strerror(errno)), errno);
::close(_socket);
_socket = -1;
return false;
}
::connect(_socket, (const struct sockaddr *) aip->ai_addr, aip->ai_addrlen);
struct timeval tv;
fd_set fdset;
tv.tv_sec = (uint64_t) _connectTimeout;
tv.tv_usec = ((uint64_t) (_connectTimeout * 1000000.0)) % 1000000;
FD_ZERO(&fdset);
FD_SET(_socket, &fdset);
if (select(_socket + 1, NULL, &fdset, NULL, &tv) > 0) {
if (checkSocket()) {
return true;
}
return false;
}
// connect timeout reached
_errorMessage = "Could not conect to server in " + StringUtils::ftoa(_connectTimeout) + " seconds.";
LOGGER_WARNING << "Could not conect to server in " << _connectTimeout << " seconds.";
::close(_socket);
return false;
}
int EasySocket::bind(uint16_t portno)
{
if (!checkSocket(m_socket)) return -1;
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
auto res = ::bind(m_socket, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
return res;
}
int EasySocket::send(const void *buf, size_t nbyte)
{
if(!checkSocket(m_replySocket)) return -1;
int res = 0;
#ifdef _WIN32
res = ::send(m_replySocket, (const char*)buf, (int)nbyte, 0);
#else
res = ::write(m_replySocket,buf,nbyte);
#endif
checkResult(res);
return res;
}
int SFSUnix::exec_server()
{
while (1)
{
FD_ZERO(&_fd_read);
SetFdMax();
if (select(_fd_max + 1, &_fd_read, NULL, NULL, &_tv) == -1)
perror("select");
checkSocket();
}
return (0);
}
bool SimpleHttpClient::readable () {
fd_set fdset;
FD_ZERO(&fdset);
FD_SET(_socket, &fdset);
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
if (select(_socket + 1, &fdset, NULL, NULL, &tv) == 1) {
return checkSocket();
}
return false;
}
/**
* Main task dispatcher for the buffered socket abstraction.
* @todo Fix the polling...
*/
int BufferedSocket::run() {
dcdebug("BufferedSocket::run() start %p\n", (void*)this);
while(true) {
try {
if(!checkEvents())
break;
checkSocket();
} catch(const Exception& e) {
fail(e.getError());
}
}
dcdebug("BufferedSocket::run() end %p\n", (void*)this);
delete this;
return 0;
}
int EasySocket::receive(void *buf, size_t nbyte)
{
if(!checkSocket(m_replySocket)) return -1;
int res = 0;
#ifdef _WIN32
res = ::recv(m_replySocket, (char*)buf, (int)nbyte, 0);
#else
res = ::read(m_replySocket,buf,nbyte);
#endif
checkResult(res);
if (res == 0){
m_state = CONNECTION_STATE_DISCONNECTED;
}
return res;
}
void
RegisterCommand::requestToken()
{
kDebug( 14100 ) << "requestToken Initialisation";
state = RegisterStateWaitingForToken;
if ( !( session_ = gg_token( 1 ) ) ) {
emit error( i18n( "Gadu-Gadu" ), i18n( "Unable to retrieve token." ) );
state = RegisterStateNoToken;
return;
}
connect( this, SIGNAL(socketReady()), SLOT(watcher()) );
checkSocket( session_->fd, session_->check );
return;
}
void
RegisterCommand::execute()
{
if ( state != RegisterStateGotToken || email_.isEmpty() || password_.isEmpty() || tokenString.isEmpty() ) {
// get token first || fill information
kDebug(14100) << "not enough info to run execute, state: " << state << " , email: " << email_ << ", password present " << !password_.isEmpty() << ", token string:" << tokenString;
return;
}
session_ = gg_register3( email_.toAscii(), password_.toAscii(), tokenId.toAscii(), tokenString.toAscii(), 1 );
if ( !session_ ) {
error( i18n( "Gadu-Gadu" ), i18n( "Registration FAILED" ) );
return;
}
state = RegisterStateWaitingForNumber;
connect( this, SIGNAL(socketReady()), SLOT(watcher()) );
checkSocket( session_->fd, session_->check );
}
bool SimpleHttpClient::read () {
if (!checkSocket()) {
return false;
}
do {
char buffer[READBUFFER_SIZE];
int len_read = ::read(_socket, buffer, READBUFFER_SIZE - 1);
if (len_read <= 0) {
// error: stop reading
break;
}
_readBuffer.appendText(buffer, len_read);
}
while(readable());
switch (_state) {
case (IN_READ_HEADER):
readHeader();
break;
case (IN_READ_BODY):
readBody();
break;
case (IN_READ_CHUNKED_HEADER):
readChunkedHeader();
break;
case (IN_READ_CHUNKED_BODY):
readChunkedBody();
break;
default:
break;
}
return true;
}
void EasySocket::init()
{
if (wsaret == 0)
{
int protocol = 0;
#ifdef _WIN32
protocol = IPPROTO_TCP;
#endif
m_socket = socket(AF_INET, SOCK_STREAM, protocol);
if (!checkSocket(m_socket)) {
return;
}
}else
return;
setBlocking(m_socket,true);
#ifndef _WIN32
wsaret = 1;
#endif
int opt = 1;
setsockopt(m_socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt));
}
void mk_Connct(int sfd,int cap_conn, struct sockaddr_in their_addr){
int sockStat = checkSocket(sfd);
int bindStat = bindStatus(sfd);
int LstStat = listenStat(sfd,cap_conn);
if(sockStat == 1 && bindStat == 1 && LstStat == 1 ){
printf("socket created\n..binding succesful\n..listening for incoming connections\n..");
// return 1;
}else{
printf("error:");
if(sockStat == 0){
printf("socket not created...\n");
}else if(bindStat == 0){
printf("binding failed...\n");
}else if(LstStat == 0){
printf("Listen failed...\n");
}
else{
printf("information missing");
}
// return 0;
}
acceptStat(sfd,their_addr);
}
int CTCPSocket::connectServer()
{
g_insLogMng.debug("socket", CLogMng::LogMode2, "Begin to connect to server......");
m_iFd = socket(AF_INET, SOCK_STREAM, 0);
if( m_iFd <= 0)
{
g_insLogMng.error( "socket(AF_INET, SOCK_STREAM, 0) for %s failed, m_iFd = %d", m_sIP);
return -1;
}
//g_insLogMng.runlog("Create:fd=%d;ip=%s", m_iFd, m_sIP);
g_insLogMng.debug("socket", CLogMng::LogMode2, "Create fd = %d for connect (%s) successfully.",
m_iFd, m_sIP);
struct sockaddr_in stInAddr;
memset(&stInAddr,0,sizeof(stInAddr));
stInAddr.sin_family = AF_INET; //family
stInAddr.sin_port = htons(m_iPort); //port
struct in_addr tmpAddr;
//inet_aton() converts the Internet host address cp from the standard num-
//bers-and-dots notation into binary data and stores it in the structure
//that inp points to. inet_aton returns nonzero if the address is valid,
//zero if not.
if (0 == inet_aton(m_sIP, &tmpAddr))
{
g_insLogMng.debug("socket", CLogMng::LogMode2, "Connect to server failed, server IP(%s) is invalid.", m_sIP);
closeSocket(); // kevinliu add 06-06
return -1;
}
stInAddr.sin_addr = tmpAddr; //ip
//建立非阻塞方式，目的是connect超时可控制，完成后恢复
if (0 != setBlockMode(NonBlock))
{
g_insLogMng.debug("socket", CLogMng::LogMode2, "Connect to server failed, setBlockMode NonBlock failed.");
closeSocket(); // kevinliu add 06-06
return -1;
}
int iRet = connect(m_iFd, (struct sockaddr*)&stInAddr, sizeof(stInAddr));
if(iRet < 0)
{
g_insLogMng.debug("socket", CLogMng::LogMode2, "Connect to server(%s) error.errno=%d, %s",
m_sIP, errno, strerror(errno));
if (errno != EINPROGRESS && errno != EALREADY // in process //delete && errno != EINTR
&& errno != EAGAIN) // try again
{
g_insLogMng.error( "Connect to server(%s) error.errno=%d, %s",
m_sIP, errno, strerror(errno));
closeSocket();
return -1;
}
else // 其他的再尝试检查端口的状态
{
if ( 0 > checkSocket(g_insConfigMng.m_tComCfg.m_iRecvMsgTimeout, CTCPSocket::WriteMode))
{
g_insLogMng.error("Connect to Server(%s) failed, checksocket timeout.", m_sIP);
closeSocket();
return -1;
}
}
}
//恢复回阻塞方式
if (0 != setBlockMode(Block))
{
g_insLogMng.debug("socket", CLogMng::LogMode2, "Connect to server failed, recover setBlockMode Block failed.");
closeSocket();
return -1;
}
// Check if there were any error 这一块应该没有太大作用,去掉
/*
int err;
socklen_t err_len = sizeof(int);
int ret = getsockopt(m_iFd, SOL_SOCKET,SO_ERROR,&err,&err_len);
if(ret < 0)
{
g_insLogMng.error("getsockopt return -1");
closeSocket();
return -1;
}
if(err > 0)
{
g_insLogMng.error("getsockopt return error");
closeSocket();
return -1;
}
*/
g_insLogMng.debug("socket", CLogMng::LogMode1, "Connect to server(%s) successfully, fd = %d",
m_sIP, m_iFd);
return 0;
}
void RegisterCommand::watcher()
{
gg_pubdir* pubDir;
if ( state == RegisterStateWaitingForToken ) {
disableNotifiers();
if ( gg_token_watch_fd( session_ ) == -1 ) {
deleteNotifiers();
emit error( i18n( "Gadu-Gadu" ), i18n( "Unknown connection error while retrieving token." ) );
gg_token_free( session_ );
session_ = NULL;
state = RegisterStateNoToken;
return;
}
pubDir = (struct gg_pubdir *)session_->data;
emit operationStatus( i18n( "Token retrieving status: %1", GaduSession::stateDescription( session_->state ) ) );
switch ( session_->state ) {
case GG_STATE_CONNECTING:
kDebug( 14100 ) << "Recreating notifiers ";
deleteNotifiers();
checkSocket( session_->fd, 0);
break;
case GG_STATE_ERROR:
deleteNotifiers();
emit error( i18n( "Gadu-Gadu token retrieve problem" ), GaduSession::errorDescription( session_->error ) );
gg_token_free( session_ );
session_ = NULL;
state = RegisterStateNoToken;
return;
break;
case GG_STATE_DONE:
struct gg_token* sp = ( struct gg_token* )session_->data;
tokenId = (char *)sp->tokenid;
kDebug( 14100 ) << "got Token!, ID: " << tokenId;
deleteNotifiers();
if ( pubDir->success ) {
QPixmap tokenImg;
tokenImg.loadFromData( (const unsigned char *)session_->body, session_->body_size );
state = RegisterStateGotToken;
emit tokenRecieved( tokenImg, tokenId );
}
else {
emit error( i18n( "Gadu-Gadu" ), i18n( "Unable to retrieve token." ) );
state = RegisterStateNoToken;
deleteLater();
}
gg_token_free( session_ );
session_ = NULL;
disconnect( this, SLOT(watcher()) );
return;
break;
}
enableNotifiers( session_->check );
}
if ( state == RegisterStateWaitingForNumber ) {
disableNotifiers();
if ( gg_register_watch_fd( session_ ) == -1 ) {
deleteNotifiers();
emit error( i18n( "Gadu-Gadu" ), i18n( "Unknown connection error while registering." ) );
gg_free_register( session_ );
session_ = NULL;
state = RegisterStateGotToken;
return;
}
pubDir = (gg_pubdir*) session_->data;
emit operationStatus( i18n( "Registration status: %1", GaduSession::stateDescription( session_->state ) ) );
switch ( session_->state ) {
case GG_STATE_CONNECTING:
kDebug( 14100 ) << "Recreating notifiers ";
deleteNotifiers();
checkSocket( session_->fd, 0);
break;
case GG_STATE_ERROR:
deleteNotifiers();
emit error( i18n( "Gadu-Gadu Registration Error" ), GaduSession::errorDescription( session_->error ) );
gg_free_register( session_ );
session_ = NULL;
state = RegisterStateGotToken;
return;
break;
case GG_STATE_DONE:
deleteNotifiers();
if ( pubDir->success && pubDir->uin ) {
uin= pubDir->uin;
state = RegisterStateDone;
emit done( i18n( "Registration Finished" ), i18n( "Registration has been completed successfully." ) );
}
else {
emit error( i18n( "Registration Error" ), i18n( "Incorrect data sent to server." ) );
state = RegisterStateGotToken;
}
gg_free_register( session_ );
session_ = NULL;
disconnect( this, SLOT(watcher()) );
deleteLater();
return;
break;
}
enableNotifiers( session_->check );
return;
}
}
int CTCPSocket::receiveMsg(char* pBuffer, int iLen, int iTimeout)
{
g_insLogMng.debug("socket", CLogMng::LogMode3, "Begin to Recv message block.");
char *pTemp = pBuffer;
int iRemainSize = iLen;
int iRecvSize;
int iRemainTime = iTimeout;
if (0 >= iRemainTime)
{
iRemainTime = DefaultSelectTimeOut;
}
int iWaitTime;
int iRetry = 0;
while(iRemainSize > 0)
{
iWaitTime = checkSocket(iRemainTime, ReadMode);
if(iWaitTime == -1)
{
g_insLogMng.error( "Recv message failed because check socket timeout.");
return -1; //错误
}
iRemainTime = iRemainTime - iWaitTime;
if(iRemainTime <= 0)
{
// if has received some data
if(iRemainSize != iLen)
{
g_insLogMng.error( "Recv message failed because no time left and some data finnished(All=%d, Remain=%d).",
iLen, iRemainSize);
return -2; // 收了一部分数据
}
else
{
g_insLogMng.error( "Recv message failed because no time left.");
return -2;
}
}
while(1)
{
iRecvSize = recv(m_iFd, pTemp, iRemainSize, 0);
if(iRecvSize <= 0)
{
/* ignore signal */
if(errno == EINTR && iRetry < MaxIgnoreSignal && iRecvSize < 0)
{
iRetry++;
CComFun::sleep_msec(0, 10);
continue;
}
if (0 == iRecvSize)
{
g_insLogMng.normal( "Opposite side of socket itself closed this connection.");
return 1; //接收到了一部分数据
}
if(iRemainSize != iLen)
{
g_insLogMng.error( "Recv message failed because recv error but some data finnished(All=%d, Remain=%d).",
iLen, iRemainSize);
return -3; //接收到了一部分数据
}
else
{
g_insLogMng.error( "Recv message failed because recv error(recv size=%d).", iRecvSize);
return -3;
}
}
break;
}
iRemainSize = iRemainSize - iRecvSize;
if(iRemainSize > 0)
{
pTemp = pTemp + iRecvSize;
}
}
// code stream
g_insLogMng.bin("socket", CLogMng::LogMode3, pBuffer, iLen);
g_insLogMng.debug("socket", CLogMng::LogMode3, "End to Recv message block.");
return 0;
}
