static int TcpClientCommServer(char *pStrIp, unsigned short u16Port,
char *pSendData, unsigned int u32SendDataSize,
unsigned int u32Timeout, bool IsRespond,
char *pRecvData, unsigned int u32RecvDataSize)
{
int ret, sock;
sock = TcpConnect(pStrIp, u16Port, u32Timeout);
if (sock < 0)
{
LOGERR("TcpConnect error\n");
return -1;
}
ret = TcpSend(sock, pSendData, u32SendDataSize);
if (ret != (int)u32SendDataSize)
{
LOGERR("TcpSend error, ret=%d, u32SendDataSize=%d\n", ret, u32SendDataSize);
close(sock);
return -1;
}
if (IsRespond == TRUE)
{
ret = TcpReceive(sock, pRecvData, u32RecvDataSize);
if (ret <= 0)
{
LOGERR("TcpReceive error\n");
close(sock);
return -1;
}
}
return sock;
}
void CTcpHandler::ProcessCmd(CCommand *pCmd)
{
NsqLogPrintf(LOG_DEBUG, "CTcpHandler::ProcessCmd ProcessCmd Type = %d", pCmd->GetCmdType());
switch(pCmd->GetCmdType())
{
case TCP_CONNECT_TYPE:
{
TcpConnect(pCmd);
break;
}
case TCP_ADD_TYPE:
{
TcpAdd(pCmd);
break;
}
case TCP_SEND_TYPE:
{
TcpSend(pCmd);
break;
}
}
delete pCmd;
}
/*
*----------------------------------------------------------------------
*
* TcpAsyncCallback --
*
* Called by the event handler that TcpConnect sets up
* internally for [socket -async] to get notified when the
* asyncronous connection attempt has succeeded or failed.
*
*----------------------------------------------------------------------
*/
static void
TcpAsyncCallback(
ClientData clientData, /* The socket state. */
int mask) /* Events of interest; an OR-ed combination of
* TCL_READABLE, TCL_WRITABLE and
* TCL_EXCEPTION. */
{
TcpConnect(NULL, clientData);
}
static int
WaitForConnect(
TcpState *statePtr, /* State of the socket. */
int *errorCodePtr)
{
int timeout;
/*
* Check if an async connect failed already and error reporting is demanded,
* return the error ENOTCONN
*/
if (errorCodePtr != NULL && (statePtr->flags & TCP_ASYNC_FAILED)) {
*errorCodePtr = ENOTCONN;
return -1;
}
/*
* Check if an async connect is running. If not return ok
*/
if (!(statePtr->flags & TCP_ASYNC_PENDING)) {
return 0;
}
if (errorCodePtr == NULL || (statePtr->flags & TCP_NONBLOCKING)) {
timeout = 0;
} else {
timeout = -1;
}
do {
if (TclUnixWaitForFile(statePtr->fds.fd,
TCL_WRITABLE | TCL_EXCEPTION, timeout) != 0) {
TcpConnect(NULL, statePtr);
}
/* Do this only once in the nonblocking case and repeat it until the
* socket is final when blocking */
} while (timeout == -1 && statePtr->flags & TCP_ASYNC_CONNECT);
if (errorCodePtr != NULL) {
if (statePtr->flags & TCP_ASYNC_PENDING) {
*errorCodePtr = EAGAIN;
return -1;
} else if (statePtr->connectError != 0) {
*errorCodePtr = ENOTCONN;
return -1;
}
}
return 0;
}
bool NetworkClient::StartClient ( char *ip )
{
// Establish a connection to the server at the specified ip
unsigned short portnum = 31337;
int result = TcpConnect ( &socket, ip, NULL, &portnum );
if ( result != TCP4U_SUCCESS )
return false;
else
return true;
}
/*######################################################################
*##
*## NAME: HttpGetHeaders10
*##
*## PURPOSE: Return the header section of the http request
*##
*####################################################################*/
int HttpGetHeaders10( LPCSTR szURL, /* URL target */
LPSTR szResponse, /* user's buffer for HTTP response */
int nResponseSize, /* */
LPSTR szData, /* user's buffer for HTTP headers */
int nDataSize /* */)
{
int Rc;
SOCKET CSock = INVALID_SOCKET;
char szService[SERVICE_LENGTH];
char szHost[HOST_LENGTH];
char szFichier[FILE_LENGTH];
unsigned short usPort;
struct S_HttpStatus saRespStatus;
Tcp4uLog (LOG4U_INTERN, "HttpGetHeaders10");
/* control the URL's validity and receive the URL distinct components */
if (!HttpIsValidURL(szURL,
&usPort,
szService, sizeof szService ,
szHost, sizeof szHost ,
szFichier, sizeof szFichier ))
return HTTP4U_BAD_URL;
/* connect to the http server */
Rc = TcpConnect(&CSock,
szHost,
szService,
&usPort);
switch (Rc)
{
case TCP4U_SUCCESS : break; /* continue */
case TCP4U_HOSTUNKNOWN : return HTTP4U_HOST_UNKNOWN;
default : return HTTP4U_TCP_CONNECT;
}
/* Send request-line method "HEAD" then receive the status-line answer */
/* then receive headers */
(Rc = HttpSendRequest10 (CSock,"HEAD ", szURL)) == HTTP4U_SUCCESS
&& (Rc = HttpRecvRespStatus (CSock, & saRespStatus,
szResponse, nResponseSize)) == HTTP4U_SUCCESS
&& (Rc = HttpRecvHeaders10 (CSock, szData, nDataSize)) == HTTP4U_SUCCESS ;
TcpClose (&CSock);
return Rc;
} /* END HttpGetHeaders10 */
enum MqErrorE
pIoConnect (
struct MqIoS * const io
)
{
switch (io->config->com) {
#if defined(MQ_IS_POSIX)
case MQ_IO_UDS:
MqErrorCheck (UdsConnect (io->iocom.udsSP));
break;
#endif
case MQ_IO_TCP:
MqErrorCheck (TcpConnect (io->iocom.tcpSP));
break;
case MQ_IO_PIPE:
MqErrorCheck (PipeConnect (io->iocom.pipeSP));
break;
}
error:
return MqErrorStack (io->context);
}
/* ----------------------------------------------------------- */
int _export PASCAL FAR FtpOpenConnection (LPCSTR szHost)
{
LPProcData pProcData;
int Rc;
pProcData = ToolsLocateProcData ();
if (pProcData == NULL) return FTPERR_NOTINITIALIZED;
Rc=TcpConnect(& pProcData->ftp.ctrl_socket,
szHost,
pProcData->ftp.nPort==FTP_DEFCTRLPORT?(LPSTR)"ftp":(LPSTR) NULL,
& pProcData->ftp.nPort);
switch (Rc)
{
case TCP4U_SUCCESS : pProcData->ftp.cType = TYPE_A;
return FtpAutomate (_S_CONNECT, NULL);
case TCP4U_HOSTUNKNOWN : return FTPERR_UNKNOWNHOST;
case TCP4U_TIMEOUT : return FTPERR_TIMEOUT;
case TCP4U_CONNECTFAILED : return FTPERR_CONNECTREJECTED;
case TCP4U_NOMORESOCKET : return FTPERR_CANTCREATESOCKET;
case TCP4U_CANCELLED : return FTPERR_CANCELBYUSER;
default : return FTPERR_CANTCONNECT;
} /* return FTP4W error codes */
} /* FtpOpenConnection */
int CTask::CommuWithAgent(MSG_ID id)
{
char sendBuf[2048] = {0};
char rcvBuf[2048] = {0};
char *pSendBuf = sendBuf;
char *pRcvBuf = rcvBuf;
char agentIp[32] = {0};
int agentPort = ATFA_PORT;
int ret = 0;
MsgHead stHead;
MsgHead *pMsgHead = NULL;
int iRcvLen = 0;
/*if(ATF_FAIL == m_pQuoteSvr->GotAgentIp(agentIp))
{
g_log.error("Unknown ATF agent IP !)\n");
return ATF_FAIL;
}*/
strncpy(agentIp,m_agentConf.agentIP,sizeof(agentIp));
agentPort = m_agentConf.agentPort;
m_agentSocket = TcpConnect(agentIp,agentPort);
if(m_agentSocket < 0)
{
g_log.error("Failed to connect ATF agent(ip:%s, port:%d)\n",agentIp,agentPort);
return ATF_FAIL;
}
switch(id)
{
case MSGID_S2C_REQ_TRADE_PROCESS_STATIC_TIME:
{
stHead.iMsgID = htons(MSGID_S2C_REQ_TRADE_PROCESS_STATIC_TIME);
stHead.iMsgBodyLen = htons(0);
pSendBuf = sendBuf;
memcpy(pSendBuf, &stHead, sizeof(stHead));
int iSendLen = sizeof(stHead);
ret = TcpSendData(m_agentSocket,(char*)pSendBuf,iSendLen);
if(iSendLen != ret)
{
g_log.error("Send MSGID_S2C_REQ_TRADE_PROCESS_STATIC_TIME error,expect %dB,actual %dB\n",iSendLen,ret);
return ATF_FAIL;
}
g_log.info("Send MSGID_S2C_REQ_TRADE_PROCESS_STATIC_TIME %dB\n",ret);
//recv msg head
iRcvLen = sizeof(MsgHead);
ret = TcpRecvData(m_agentSocket,pRcvBuf,iRcvLen);
if(ret != iRcvLen)
{
g_log.error("[%s]Recv msg head error,expect %dB, actual %dB!\n",__FUNCTION__,iRcvLen,ret);
return ATF_FAIL;
}
g_log.info("[%s]Recv msg head %dB\n",__FUNCTION__,ret);
pMsgHead = (MsgHead *)pRcvBuf;
if(MSGID_C2S_RSP_TRADE_PROCESS_STATIC_TIME == ntohs(pMsgHead->iMsgID))
{
//rcv msg body
iRcvLen = sizeof(m_stTradeProcTimeStatic);
ret = TcpRecvData(m_agentSocket,pRcvBuf,iRcvLen);
if(ret != iRcvLen)
{
g_log.error("[%s]Recv msg body error,expect %dB, actual %dB!\n",__FUNCTION__,iRcvLen,ret);
return ATF_FAIL;
}
g_log.info("[%s]Recv msg %dB\n",__FUNCTION__,ret);
InfoTradeProcessTime *pInfo = (InfoTradeProcessTime *)pRcvBuf;
m_stTradeProcTimeStatic.avgTimeTradeProcess = pInfo->avgTimeTradeProcess;
m_stTradeProcTimeStatic.maxTimeTradeProcess = pInfo->maxTimeTradeProcess;
m_stTradeProcTimeStatic.mixTimeTradeProcess = pInfo->mixTimeTradeProcess;
m_stTradeProcTimeStatic.tradeNum = pInfo->tradeNum;
return ATF_SUCC;
}
else
{
g_log.error("[%s]Expect msg %d, actual %d!\n",__FUNCTION__,MSGID_C2S_RSP_TRADE_PROCESS_STATIC_TIME,pMsgHead->iMsgID);
return ATF_FAIL;
}
}
break;
case MSGID_S2C_REQ_QUOTE_INTERVAL_STATIC_TIME:
{
stHead.iMsgID = htons(MSGID_S2C_REQ_QUOTE_INTERVAL_STATIC_TIME);
stHead.iMsgBodyLen = htons(0);
pSendBuf = sendBuf;
memcpy(pSendBuf, &stHead, sizeof(stHead));
int iSendLen = sizeof(stHead);
ret = TcpSendData(m_agentSocket,(char*)pSendBuf,iSendLen);
if(iSendLen != ret)
{
g_log.error("Send MSGID_S2C_REQ_QUOTE_INTERVAL_STATIC_TIME error,expect %dB,actual %dB\n",iSendLen,ret);
return ATF_FAIL;
}
g_log.info("Send MSGID_S2C_REQ_QUOTE_INTERVAL_STATIC_TIME %dB\n",ret);
//recv msg head
iRcvLen = sizeof(MsgHead);
ret = TcpRecvData(m_agentSocket,pRcvBuf,iRcvLen);
if(ret != iRcvLen)
{
g_log.error("[%s]Recv msg head error,expect %dB, actual %dB!\n",__FUNCTION__,iRcvLen,ret);
return ATF_FAIL;
}
g_log.info("[%s]Recv msg head %dB\n",__FUNCTION__,ret);
pMsgHead = (MsgHead *)pRcvBuf;
if(MSGID_C2S_RSP_QUOTE_INTERVAL_STATIC_TIME == ntohs(pMsgHead->iMsgID))
{
//rcv msg body
iRcvLen = sizeof(StaticQuoteInterval_t);
ret = TcpRecvData(m_agentSocket,pRcvBuf,iRcvLen);
if(ret != iRcvLen)
{
g_log.error("[%s]Recv msg body error,expect %dB, actual %dB!\n",__FUNCTION__,iRcvLen,ret);
return ATF_FAIL;
}
g_log.info("[%s]Recv msg %dB\n",__FUNCTION__,ret);
StaticQuoteInterval_t *pInfo = (StaticQuoteInterval_t *)pRcvBuf;
m_stQuoteIntervalStatic.avgQuoteInterval = pInfo->avgQuoteInterval;
m_stQuoteIntervalStatic.maxQuoteInterval = pInfo->maxQuoteInterval;
m_stQuoteIntervalStatic.minQuoteInterval = pInfo->minQuoteInterval;
m_stQuoteIntervalStatic.quoteNum = pInfo->quoteNum;
return ATF_SUCC;
}
else
{
g_log.error("[%s]Expect msg %d, actual %d!\n",__FUNCTION__,MSGID_C2S_RSP_QUOTE_INTERVAL_STATIC_TIME,pMsgHead->iMsgID);
return ATF_FAIL;
}
}
break;
case MSGID_S2C_REDDY_FOR_PERFORM_TEST:
{
stHead.iMsgID = htons(MSGID_S2C_REDDY_FOR_PERFORM_TEST);
stHead.iMsgBodyLen = htons(0);
pSendBuf = sendBuf;
memcpy(pSendBuf, &stHead, sizeof(stHead));
int iSendLen = sizeof(stHead);
ret = TcpSendData(m_agentSocket,(char*)pSendBuf,iSendLen);
if(iSendLen != ret)
{
g_log.error("Send MSGID_S2C_REDDY_FOR_PERFORM_TEST error,expect %dB,actual %dB\n",iSendLen,ret);
return ATF_FAIL;
}
g_log.info("Send MSGID_S2C_REDDY_FOR_PERFORM_TEST %dB\n",ret);
return ATF_SUCC;
}
break;
default:
{
}
break;
}
close(m_agentSocket);
return ATF_FAIL;
}
Tcl_Channel
Tcl_OpenTcpClient(
Tcl_Interp *interp, /* For error reporting; can be NULL. */
int port, /* Port number to open. */
const char *host, /* Host on which to open port. */
const char *myaddr, /* Client-side address */
int myport, /* Client-side port */
int async) /* If nonzero, attempt to do an asynchronous
* connect. Otherwise we do a blocking
* connect. */
{
TcpState *statePtr;
const char *errorMsg = NULL;
struct addrinfo *addrlist = NULL, *myaddrlist = NULL;
char channelName[SOCK_CHAN_LENGTH];
/*
* Do the name lookups for the local and remote addresses.
*/
if (!TclCreateSocketAddress(interp, &addrlist, host, port, 0, &errorMsg)
|| !TclCreateSocketAddress(interp, &myaddrlist, myaddr, myport, 1,
&errorMsg)) {
if (addrlist != NULL) {
freeaddrinfo(addrlist);
}
if (interp != NULL) {
Tcl_SetObjResult(interp, Tcl_ObjPrintf(
"couldn't open socket: %s", errorMsg));
}
return NULL;
}
/*
* Allocate a new TcpState for this socket.
*/
statePtr = ckalloc(sizeof(TcpState));
memset(statePtr, 0, sizeof(TcpState));
statePtr->flags = async ? TCP_ASYNC_CONNECT : 0;
statePtr->cachedBlocking = TCL_MODE_BLOCKING;
statePtr->addrlist = addrlist;
statePtr->myaddrlist = myaddrlist;
statePtr->fds.fd = -1;
/*
* Create a new client socket and wrap it in a channel.
*/
if (TcpConnect(interp, statePtr) != TCL_OK) {
TcpCloseProc(statePtr, NULL);
return NULL;
}
sprintf(channelName, SOCK_TEMPLATE, (long) statePtr);
statePtr->channel = Tcl_CreateChannel(&tcpChannelType, channelName, statePtr,
(TCL_READABLE | TCL_WRITABLE));
if (Tcl_SetChannelOption(interp, statePtr->channel, "-translation",
"auto crlf") == TCL_ERROR) {
Tcl_Close(NULL, statePtr->channel);
return NULL;
}
return statePtr->channel;
}
THREAD_API TcpClientThread( LPVOID lpParameter )
{
CTcpClientThreadArg * pclsArg = (CTcpClientThreadArg *)lpParameter;
Socket hConn = TcpConnect( "127.0.0.1", LISTEN_PORT );
if( hConn == INVALID_SOCKET )
{
CLog::Print( LOG_ERROR, "TcpConnect error" );
}
else
{
char szBuf[8192];
int n = 0, iCount = 0;
if( gbUseSelect )
{
struct timeval sttTime;
fd_set wset;
bool bSendReady = false;
while( 1 )
{
bSendReady = false;
for( int i = 0; i < 10; ++i )
{
FD_ZERO( &wset );
FD_SET( hConn, &wset );
sttTime.tv_sec = 1;
sttTime.tv_usec = 0;
n = select( hConn + 1, NULL, &wset, NULL, &sttTime );
if( n > 0 && FD_ISSET( hConn, &wset ) )
{
bSendReady = true;
break;
}
}
if( bSendReady == false )
{
CLog::Print( LOG_DEBUG, "timeout" );
break;
}
++iCount;
CLog::Print( LOG_DEBUG, "before send" );
n = send( hConn, szBuf, sizeof(szBuf), 0 );
CLog::Print( LOG_DEBUG, "after send n(%d) count(%d)", n, iCount );
}
}
else
{
#ifdef WIN32
int iTimeout = 10000;
n = setsockopt( hConn, SOL_SOCKET, SO_SNDTIMEO, (const char*)&iTimeout, sizeof(iTimeout) );
#else
struct timeval sttTime;
sttTime.tv_sec = 10;
sttTime.tv_usec = 0;
n = setsockopt( hConn, SOL_SOCKET, SO_SNDTIMEO, (const char*)&sttTime, sizeof(sttTime) );
#endif
CLog::Print( LOG_DEBUG, "setsockopt n(%d)", n );
while( 1 )
{
++iCount;
CLog::Print( LOG_DEBUG, "before send" );
n = send( hConn, szBuf, sizeof(szBuf), 0 );
CLog::Print( LOG_DEBUG, "after send n(%d) count(%d)", n, iCount );
if( n <= 0 ) break;
}
}
closesocket( hConn );
}
pclsArg->m_bRun = false;
return 0;
}
int API4U SmtpSendMessage (LPCSTR szFrom,
LPCSTR szTo,
LPCSTR szMessage,
LPCSTR szHost,
LPCSTR szLocalDomain)
{
int Rc;
SOCKET CSock=INVALID_SOCKET;
unsigned short usPort = SMTP4U_DEFPORT;
char szBuf[2048]; /* overflow is not handled */
#define XX_RETURN(x) { \
TcpClose (& CSock); \
Tcp4uLog (LOG4U_HIPROC, "exit SmtpSendMessage"); \
return (x); }
Tcp4uLog (LOG4U_HIPROC, "SmtpSendMessage");
/* Ok search for SMTP server */
Rc = TcpConnect(& CSock, szHost, "smtp", & usPort);
if (Rc!=TCP4U_SUCCESS) XX_RETURN (SMTP4U_CANTCONNECT);
/* waits for incoming frame */
Rc = TnProtoExchange (CSock, /* used socket */
NULL, /* no frame to be sent */
szBuf, sizeof szBuf,
TnReadMultiLine, /* recv function */
SmtpProto[_SMTP4U_CONNECT].tAnswer,
SizeOfTab(SmtpProto[_SMTP4U_CONNECT].tAnswer),
TRUE, /* sensitive compare */
SMTP4U_DEFTIMEOUT,
HFILE_ERROR);
if (Rc != SMTP4U_SUCCESS)
XX_RETURN (Rc<TN_SUCCESS ? SMTP4U_DATAERROR : Rc);
/* sends the hello command */
Sprintf (szBuf,
SmtpProto[_SMTP4U_HELO].szCmd,
szLocalDomain==NULL ? "" : szLocalDomain);
Rc = TnProtoExchange (CSock, /* used socket */
szBuf, /* no frame to be sent */
szBuf, sizeof szBuf,
TnReadMultiLine, /* recv function */
SmtpProto[_SMTP4U_HELO].tAnswer,
SizeOfTab(SmtpProto[_SMTP4U_HELO].tAnswer),
TRUE, /* sensitive compare */
SMTP4U_DEFTIMEOUT,
HFILE_ERROR);
if (Rc != SMTP4U_SUCCESS) XX_RETURN (Rc<TN_SUCCESS ? SMTP4U_DATAERROR : Rc);
/* sends the Mail From */
Sprintf (szBuf, SmtpProto[_SMTP4U_MAILFROM].szCmd, szFrom);
Rc = TnProtoExchange (CSock, /* used socket */
szBuf, /* no frame to be sent */
szBuf, sizeof szBuf,
TnReadMultiLine, /* recv function */
SmtpProto[_SMTP4U_MAILFROM].tAnswer,
SizeOfTab(SmtpProto[_SMTP4U_MAILFROM].tAnswer),
TRUE, /* sensitive compare */
SMTP4U_DEFTIMEOUT,
HFILE_ERROR);
if (Rc != SMTP4U_SUCCESS) XX_RETURN (Rc<TN_SUCCESS ? SMTP4U_DATAERROR : Rc);
/* Rcpt command is handled by the SmtpSendRcpt function*/
Rc = SmtpSendRcpt (CSock, szTo, szBuf, sizeof szBuf);
if (Rc!=SMTP4U_SUCCESS) XX_RETURN (Rc);
/* sends the Data command */
Rc = TnProtoExchange (CSock, /* used socket */
SmtpProto[_SMTP4U_DATA].szCmd,
szBuf, sizeof szBuf,
TnReadMultiLine, /* recv function */
SmtpProto[_SMTP4U_DATA].tAnswer,
SizeOfTab(SmtpProto[_SMTP4U_DATA].tAnswer),
TRUE, /* sensitive compare */
SMTP4U_DEFTIMEOUT,
HFILE_ERROR);
if (Rc != SMTP4U_SUCCESS) XX_RETURN (Rc<TN_SUCCESS ? SMTP4U_DATAERROR : Rc);
/* Sends the data using TnSendMultiLine */
TnSendMultiLine (CSock, SMTP4U_STDHEADER, TRUE, HFILE_ERROR);
Rc = TnSendMultiLine (CSock, szMessage, TRUE, HFILE_ERROR);
if (Rc<TN_SUCCESS) XX_RETURN (SMTP4U_DATAERROR);
/* sends the End of Data command */
Rc = TnProtoExchange (CSock, /* used socket */
SmtpProto[_SMTP4U_ENDOFDATA].szCmd,
szBuf, sizeof szBuf,
TnReadMultiLine, /* recv function */
SmtpProto[_SMTP4U_ENDOFDATA].tAnswer,
SizeOfTab(SmtpProto[_SMTP4U_ENDOFDATA].tAnswer),
TRUE, /* sensitive compare */
SMTP4U_DEFTIMEOUT,
HFILE_ERROR);
if (Rc != SMTP4U_SUCCESS) XX_RETURN (Rc<TN_SUCCESS ? SMTP4U_DATAERROR : Rc);
/* and Quit properly */
Rc = TnProtoExchange (CSock, /* used socket */
SmtpProto[_SMTP4U_QUIT].szCmd,
szBuf, sizeof szBuf,
TnReadMultiLine, /* recv function */
SmtpProto[_SMTP4U_QUIT].tAnswer,
SizeOfTab(SmtpProto[_SMTP4U_QUIT].tAnswer),
TRUE, /* sensitive compare */
SMTP4U_DEFTIMEOUT,
HFILE_ERROR);
XX_RETURN (Rc<TN_SUCCESS ? SMTP4U_DATAERROR : Rc);
#undef XX_RETURN
} /* SmtpSendMessage */
// ------------------------------------------------------------------------------------------------
int main(int argc, const char **argv)
{
// Common variables
NetBuf *inPkt;
TcpHeader *inHdr;
Packet *outPkt;
TcpHeader *outHdr;
TcpConn *conn;
TestSetup();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSED, "RST", "segment dropped");
inPkt = NetAllocBuf();
inHdr = (TcpHeader *)inPkt->start;
inHdr->srcPort = 100;
inHdr->dstPort = 101;
inHdr->seq = 1;
inHdr->ack = 2;
inHdr->off = 5 << 4;
inHdr->flags = TCP_RST;
inHdr->windowSize = TCP_WINDOW_SIZE;
inHdr->checksum = 0;
inHdr->urgent = 0;
TcpInput(inPkt);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSED, "ACK", "RST sent");
inPkt = NetAllocBuf();
inHdr = (TcpHeader *)inPkt->start;
inHdr->srcPort = 100;
inHdr->dstPort = 101;
inHdr->seq = 1;
inHdr->ack = 2;
inHdr->off = 5 << 4;
inHdr->flags = TCP_ACK;
inHdr->windowSize = TCP_WINDOW_SIZE;
inHdr->checksum = 0;
inHdr->urgent = 0;
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, 101);
ASSERT_EQ_UINT(outHdr->dstPort, 100);
ASSERT_EQ_UINT(outHdr->seq, 2);
ASSERT_EQ_UINT(outHdr->ack, 0);
ASSERT_EQ_HEX8(outHdr->flags, TCP_RST);
free(outPkt);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSED, "no ACK", "RST/ACK sent");
inPkt = NetAllocBuf();
inHdr = (TcpHeader *)inPkt->start;
inHdr->srcPort = 100;
inHdr->dstPort = 101;
inHdr->seq = 1;
inHdr->ack = 2;
inHdr->off = 5 << 4;
inHdr->flags = 0;
inHdr->windowSize = TCP_WINDOW_SIZE;
inHdr->checksum = 0;
inHdr->urgent = 0;
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, 101);
ASSERT_EQ_UINT(outHdr->dstPort, 100);
ASSERT_EQ_UINT(outHdr->seq, 0);
ASSERT_EQ_UINT(outHdr->ack, 1);
ASSERT_EQ_HEX8(outHdr->flags, TCP_RST | TCP_ACK);
free(outPkt);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSED, "connect", "goto SYN_SENT");
conn = CreateConn();
ASSERT_TRUE(TcpConnect(conn, &s_ipAddr, 80));
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_TRUE(outHdr->srcPort >= 49152);
ASSERT_EQ_UINT(outHdr->dstPort, 80);
ASSERT_EQ_UINT(outHdr->seq, conn->iss);
ASSERT_EQ_UINT(outHdr->ack, 0);
ASSERT_EQ_HEX8(outHdr->flags, TCP_SYN);
ASSERT_EQ_UINT(outHdr->windowSize, TCP_WINDOW_SIZE);
ASSERT_EQ_UINT(outHdr->urgent, 0);
free(outPkt);
ExitState(conn, TCP_SYN_SENT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "Bad ACK, no RST", "RST sent");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss, TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, inHdr->ack);
ASSERT_EQ_UINT(outHdr->ack, 0);
ASSERT_EQ_HEX8(outHdr->flags, TCP_RST);
free(outPkt);
ExitState(conn, TCP_SYN_SENT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "Bad ACK, RST", "segment dropped");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss, TCP_RST | TCP_ACK);
TcpInput(inPkt);
ExitState(conn, TCP_SYN_SENT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "ACK, RST", "conn locally reset");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss + 1, TCP_RST | TCP_ACK);
TcpInput(inPkt);
ExpectError(TCP_CONN_RESET);
ExitState(conn, TCP_CLOSED);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "no ACK, RST", "segment dropped");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss + 1, TCP_RST);
TcpInput(inPkt);
ExitState(conn, TCP_SYN_SENT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "SYN, ACK", "goto ESTABLISHED");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, conn->iss + 1, TCP_SYN | TCP_ACK);
TcpInput(inPkt);
ASSERT_EQ_UINT(conn->irs, 1000);
ASSERT_EQ_UINT(conn->rcvNxt, 1001);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->iss + 1);
ASSERT_EQ_UINT(outHdr->ack, 1001);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ExitState(conn, TCP_ESTABLISHED);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_SENT, "SYN, no ACK", "goto SYN_RECEIVED, resend SYN,ACK");
conn = CreateConn();
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, 0, TCP_SYN);
TcpInput(inPkt);
ASSERT_EQ_UINT(conn->irs, 1000);
ASSERT_EQ_UINT(conn->rcvNxt, 1001);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->iss);
ASSERT_EQ_UINT(outHdr->ack, 1001);
ASSERT_EQ_HEX8(outHdr->flags, TCP_SYN | TCP_ACK);
free(outPkt);
ExitState(conn, TCP_SYN_RECEIVED);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
uint generalStates[] =
{
TCP_SYN_RECEIVED,
TCP_ESTABLISHED,
TCP_FIN_WAIT_1,
TCP_FIN_WAIT_2,
TCP_CLOSE_WAIT,
TCP_CLOSING,
TCP_LAST_ACK,
TCP_TIME_WAIT,
0,
};
for (uint *pState = generalStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "Bad seq, no RST", "resend ACK");
conn = CreateConn();
EnterState(conn, state);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt - 1, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->sndNxt);
ASSERT_EQ_UINT(outHdr->ack, conn->rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ExitState(conn, state);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
for (uint *pState = generalStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "Bad seq, RST", "segment dropped");
conn = CreateConn();
EnterState(conn, state);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt - 1, conn->sndNxt, TCP_RST | TCP_ACK);
TcpInput(inPkt);
ExitState(conn, state);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_RECEIVED, "RST, active", "conn refused");
conn = CreateConn();
EnterState(conn, TCP_SYN_RECEIVED);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, 0, TCP_RST);
TcpInput(inPkt);
ExpectError(TCP_CONN_REFUSED);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
uint rstStates1[] =
{
TCP_ESTABLISHED,
TCP_FIN_WAIT_1,
TCP_FIN_WAIT_2,
TCP_CLOSE_WAIT,
0,
};
for (uint *pState = rstStates1; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "RST", "conn reset");
conn = CreateConn();
EnterState(conn, state);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, 0, TCP_RST);
TcpInput(inPkt);
ExpectError(TCP_CONN_RESET);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
uint rstStates2[] =
{
TCP_CLOSING,
TCP_LAST_ACK,
TCP_TIME_WAIT,
0,
};
for (uint *pState = rstStates2; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "RST", "conn closed");
conn = CreateConn();
EnterState(conn, state);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, 0, TCP_RST);
TcpInput(inPkt);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
for (uint *pState = generalStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "SYN", "conn reset, RST sent");
conn = CreateConn();
EnterState(conn, state);
u16 localPort = conn->localPort;
u16 remotePort = conn->remotePort;
u32 rcvNxt = conn->rcvNxt;
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_SYN);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, localPort);
ASSERT_EQ_UINT(outHdr->dstPort, remotePort);
ASSERT_EQ_UINT(outHdr->seq, 0);
ASSERT_EQ_UINT(outHdr->ack, rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_RST | TCP_ACK);
free(outPkt);
ExpectError(TCP_CONN_RESET);
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_RECEIVED, "bad ACK", "RST sent");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_SYN_RECEIVED, "ACK", "goto ESTABLISHED");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
uint ackStates[] =
{
TCP_ESTABLISHED,
TCP_FIN_WAIT_1,
TCP_FIN_WAIT_2,
TCP_CLOSE_WAIT,
TCP_CLOSING,
0
};
for (uint *pState = ackStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "ACK", "update pointers");
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
for (uint *pState = ackStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "dup ACK", "ignore");
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
for (uint *pState = ackStates; *pState; ++pState)
{
uint state = *pState;
TestCaseBegin(state, "unsent ACK", "resend ACK");
TestCaseEnd();
}
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_FIN_WAIT_1, "ACK, FIN not ACK'd", "ignore");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSING, "ACK, FIN not ACK'd", "ignore");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_FIN_WAIT_1, "ACK, FIN ACK'd", "goto FIN-WAIT-2");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_CLOSING, "ACK, FIN ACK'd", "goto TIME-WAIT");
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_LAST_ACK, "ACK, FIN not ACK'd", "ignore");
conn = CreateConn();
EnterState(conn, TCP_LAST_ACK);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt - 1, TCP_ACK);
TcpInput(inPkt);
ExitState(conn, TCP_LAST_ACK);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_LAST_ACK, "ACK, FIN ACK'd", "goto CLOSED");
conn = CreateConn();
EnterState(conn, TCP_LAST_ACK);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_TIME_WAIT, "ACK, no FIN", "ignore");
conn = CreateConn();
EnterState(conn, TCP_TIME_WAIT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
ExitState(conn, TCP_TIME_WAIT);
TestCaseEnd();
// --------------------------------------------------------------------------------------------
TestCaseBegin(TCP_TIME_WAIT, "FIN", "reset 2MSL timer");
conn = CreateConn();
EnterState(conn, TCP_TIME_WAIT);
g_pitTicks += 1000;
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->sndNxt);
ASSERT_EQ_UINT(outHdr->ack, conn->rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ASSERT_EQ_UINT(conn->mslWait, g_pitTicks + 2 * TCP_MSL);
ExitState(conn, TCP_TIME_WAIT);
TestCaseEnd();
return EXIT_SUCCESS;
}
// ------------------------------------------------------------------------------------------------
static void EnterState(TcpConn *conn, uint state)
{
NetBuf *inPkt;
TcpHeader *inHdr;
Packet *outPkt;
//TcpHeader *outHdr;
switch (state)
{
case TCP_SYN_SENT:
ASSERT_TRUE(TcpConnect(conn, &s_ipAddr, 80));
outPkt = PopPacket();
free(outPkt);
break;
case TCP_SYN_RECEIVED:
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, 0, TCP_SYN);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_ESTABLISHED:
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_SYN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_FIN_WAIT_1:
EnterState(conn, TCP_ESTABLISHED);
TcpClose(conn);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_FIN_WAIT_2:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
break;
case TCP_CLOSE_WAIT:
EnterState(conn, TCP_ESTABLISHED);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_CLOSING:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt - 1, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_LAST_ACK:
EnterState(conn, TCP_CLOSE_WAIT);
TcpClose(conn);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_TIME_WAIT:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
default:
ASSERT_EQ_UINT(state, 0);
break;
}
ASSERT_EQ_UINT(conn->state, state);
ASSERT_TRUE(ListIsEmpty(&s_outPackets));
}
int CUstpFtdcMduserApi::HandleInit()
{
int ret = 0;
char sendBuf[BUFSIZE] = {0};
char rcvBuf[BUFSIZE] = {0};
MsgHead stHead;
int iSendLen = 0;
int iExpectRcvLen = 0;
char * pSendBuf = NULL;
char * pRcvBuf = NULL;
MsgHead *pMsg = NULL;
m_fdConnQuoteSvr = TcpConnect(m_quoteSvrIP,m_shListenPort);
if(m_fdConnQuoteSvr < 0)
{
g_log.error("Failed to connect QUOTE SERVER(ip:%s, port:%d, socket:%d)\n",m_quoteSvrIP,m_shListenPort,m_fdConnQuoteSvr);
sleep(5);//客户端与服务端连接断开后，交易接口会自动尝试重新连接，频率是每5 秒一次。
return ATF_FALSE;
}
g_log.info("Succeed to connect QUOTE SERVER(ip:%s, port:%d, socket:%d)\n",m_quoteSvrIP,m_shListenPort,m_fdConnQuoteSvr);
//send msg to ATF
stHead.iMsgID = htons(MSGID_C2S_QUOTE_REQ_CONN);
stHead.iMsgBodyLen = htons(0);
pSendBuf = sendBuf;
iSendLen = sizeof(stHead);
memcpy(pSendBuf, &stHead, iSendLen);
ret = TcpSendData(m_fdConnQuoteSvr,(char*)pSendBuf,iSendLen);
if(ret != iSendLen)
{
g_log.error("[STATUS_QUOTE_INIT]TCP send error! \n");
return ATF_FAIL;
}
g_log.debug("[STATUS_QUOTE_INIT]TCP send out %d bytes\n",ret);
//receive msg from ATF
iExpectRcvLen = sizeof(MsgHead) + sizeof(RspInfoFromATF);
pRcvBuf = rcvBuf;
ret = TcpRecvData(m_fdConnQuoteSvr,pRcvBuf,iExpectRcvLen);
if(ret != iExpectRcvLen)
{
g_log.error("[STATUS_QUOTE_INIT]TCP receive error! \n");
return ATF_FAIL;
}
g_log.debug("[STATUS_QUOTE_INIT]recv rsp %d bytes\n",ret);
pMsg = (MsgHead *)pRcvBuf;
if(MSGID_S2C_QUOTE_RSP_CONN == ntohs(pMsg->iMsgID))
{
RspInfoFromATF *pRsp = (RspInfoFromATF *)(pRcvBuf + sizeof(MsgHead));
//tell client
if(0 == pRsp->ErrorID)
{
m_FtdcMdSpi_instance->OnFrontConnected();
//if(true == m_autoReconn)
//SetState(STATUS_QUOTE_REQ_LOGIN);
}
else
m_FtdcMdSpi_instance->OnFrontDisconnected(-1);
return ATF_SUCC;
}
else
{
g_log.debug("[STATUS_QUOTE_INIT]msgID error, %d,%d\n",pMsg->iMsgID,ntohs(pMsg->iMsgID));
return ATF_FAIL;
}
}
/*######################################################################
*##
*## NAME: HttpGetFileEx
*##
*## PURPOSE: Return headers and body of a http request
*##
*####################################################################*/
int API4U HttpGetFileEx(
LPCSTR szURL,
LPCSTR szProxyURL,
LPCSTR szLocalFile,
LPCSTR szHeaderFile,
HTTP4U_CALLBACK CbkTransmit,
long lUserValue,
LPSTR szResponse, int nResponseSize,
LPSTR szHeaders, int nHeadersSize
)
{
SOCKET CSock = INVALID_SOCKET;
int Rc;
int hHeaderFile = HFILE_ERROR;
char szService[SERVICE_LENGTH];
char szHost[HOST_LENGTH];
char szFichier[FILE_LENGTH];
LPSTR szData = NULL;
LPSTR p;
LPCSTR szRequest;
long RealBodySize = -1;
struct S_HttpStatus saRespStatus;
unsigned short usPort = 0;
Tcp4uLog (LOG4U_HIPROC, "HttpGetFileEx");
#define XX_RETURN(a) {if (szData!=NULL) Free(szData);\
if (hHeaderFile!=HFILE_ERROR){\
Close(hHeaderFile);\
Unlink(szHeaderFile);\
}\
if (CSock != INVALID_SOCKET) TcpClose(&CSock);\
Tcp4uLog (LOG4U_HIEXIT, "HttpGetFileEx with return code %d", a); \
return a;\
}
#ifdef UNIX
/* use "hidden" env variable in order to send logs to stdout */
if (getenv ("http4u_log")!=NULL) DO_NOT_LOG = fileno(stdout);
#endif
/* control URL's validity and receive URL's components. If a proxy */
/* is used, send the connection components into usPort, szService */
/* and szHost. */
if ( ! HttpIsValidURL( szURL,
& usPort,
szService, sizeof szService ,
szHost, sizeof szHost ,
szFichier, sizeof szFichier )
|| ( szProxyURL!=NULL
&& ! HttpIsValidURL (szProxyURL, & usPort,
szService, sizeof szService,
szHost, sizeof szHost, NULL, 0))
)
{
XX_RETURN (HTTP4U_BAD_URL);
}
/* allocate buffer */
if ( (szData = Calloc(1,s_uHttp4uBufferSize)) == NULL)
{
XX_RETURN (HTTP4U_INSMEMORY);
}
/* connect to http server, or proxy server : we don't care now */
Rc = TcpConnect(& CSock,
szHost,
usPort==0 ? szService : NULL,
& usPort);
switch (Rc)
{
case TCP4U_SUCCESS : break; /* continue */
case TCP4U_HOSTUNKNOWN : XX_RETURN (HTTP4U_HOST_UNKNOWN);
default : XX_RETURN (HTTP4U_TCP_CONNECT);
}
/* send a request-line method "GET", receive reply, receive data */
szRequest= szProxyURL==NULL? szFichier : szURL; /* if no proxy, simple ! */
if ( (Rc=HttpSendRequest10 (CSock, "GET ", szRequest)) != HTTP4U_SUCCESS
|| (Rc=HttpRecvRespStatus (CSock, & saRespStatus,
szResponse,nResponseSize)) != HTTP4U_SUCCESS )
{
XX_RETURN (Rc);
}
/* an answer has been received, let us have a look on it */
switch(saRespStatus.code)
{
case 200: break; /* reason-phrase OK */
case 204: XX_RETURN (HTTP4U_NO_CONTENT);
case 300:
case 301: XX_RETURN (HTTP4U_MOVED);
case 400: XX_RETURN (HTTP4U_BAD_REQUEST);
case 401:
case 403: XX_RETURN (HTTP4U_FORBIDDEN);
case 404: XX_RETURN (HTTP4U_NOT_FOUND);
default: XX_RETURN (HTTP4U_PROTOCOL_ERROR);
}
/* read headers */
Rc = HttpRecvHeaders10(CSock, szData, s_uHttp4uBufferSize);
/* copy headers into user buffer even if return incorrect */
if (szHeaders != NULL)
Strcpyn (szHeaders, szData, min(s_uHttp4uBufferSize, (unsigned) nHeadersSize));
if (Rc!=HTTP4U_SUCCESS) XX_RETURN (Rc);
/* write headers into the user local file */
if (szHeaderFile != NULL )
{
if ((hHeaderFile = Open(szHeaderFile, WRITE_CR)) == HFILE_ERROR)
{
XX_RETURN (HTTP4U_FILE_ERROR);
}
/* write */
if (Write(hHeaderFile, szData, Strlen(szData)) == HFILE_ERROR)
{
XX_RETURN(HTTP4U_FILE_ERROR);
}
Close(hHeaderFile);
hHeaderFile = HFILE_ERROR;
} /* szHeaderFile not NULL */
/* if we do not need something else, just close the connection */
/* not really nice, but HTTP servers are used to deal with it */
if (szLocalFile==NULL && CbkTransmit==NULL)
{
XX_RETURN (HTTP4U_SUCCESS);
}
/* search real length of the body */
RealBodySize = -1; /* can not compute it */
szData[s_uHttp4uBufferSize-1] = '\0';
p = Tcp4uStrIStr (szData, "content-length:");
if (p!=NULL)
{
p += sizeof("Content-Length:");
while (isspace(*p)) p++; /* skip space character */
RealBodySize = Tcp4uAtol (p);
}
/* read Body of the respons */
Rc=TcpRecvUntilClosedEx (& CSock,
szLocalFile,
(FARPROC) CbkTransmit,
s_uHttp4uTimeout,
s_uHttp4uBufferSize,
lUserValue,
RealBodySize);
switch (Rc)
{
case TCP4U_SUCCESS: Rc = HTTP4U_SUCCESS; break;
case TCP4U_TIMEOUT: Rc = HTTP4U_TIMEOUT; break;
case TCP4U_FILE_ERROR : Rc = HTTP4U_FILE_ERROR; break;
case TCP4U_INSMEMORY : Rc = HTTP4U_INSMEMORY; break;
case TCP4U_CANCELLED : Rc = HTTP4U_CANCELLED; break;
default: Rc = HTTP4U_TCP_FAILED; break;
}
XX_RETURN (Rc);
#undef XX_RETURN
} /* HttpGetFileEx */
/**
* @ingroup TcpStack
* @brief TCP 연결 Thread
* @param lpParameter CTcpClientArg 객체
* @returns 0 을 리턴한다.
*/
THREAD_API TcpClientThread( LPVOID lpParameter )
{
CTcpClientArg * pclsArg = (CTcpClientArg *)lpParameter;
CLog::Print( LOG_INFO, "TcpClientThread started (%s:%d)", pclsArg->m_strIp.c_str(), pclsArg->m_iPort );
Socket hConn = TcpConnect( pclsArg->m_strIp.c_str(), pclsArg->m_iPort, pclsArg->m_pclsStack->m_clsSetup.m_iTcpConnectTimeout );
if( hConn == INVALID_SOCKET )
{
CLog::Print( LOG_ERROR, "%s TcpConnect(%s:%d) error(%d)", __FUNCTION__, pclsArg->m_strIp.c_str(), pclsArg->m_iPort, GetError() );
pclsArg->m_pclsStack->m_clsClientMap.Delete( pclsArg->m_strIp.c_str(), pclsArg->m_iPort );
}
else
{
CTcpComm clsTcpComm;
bool bAccept = true;
#ifdef USE_TLS
if( pclsArg->m_pclsStack->m_clsSetup.m_bUseTls )
{
if( SSLConnect( hConn, &clsTcpComm.m_psttSsl ) == false )
{
CLog::Print( LOG_ERROR, "%s SSLConnect(%s:%d) error", __FUNCTION__, pclsArg->m_strIp.c_str(), pclsArg->m_iPort );
closesocket( hConn );
pclsArg->m_pclsStack->m_clsClientMap.Delete( pclsArg->m_strIp.c_str(), pclsArg->m_iPort );
bAccept = false;
}
}
#endif
if( bAccept )
{
if( pclsArg->m_pclsStack->m_clsSetup.m_bUseThreadPipe )
{
clsTcpComm.m_hSocket = hConn;
snprintf( clsTcpComm.m_szIp, sizeof(clsTcpComm.m_szIp), "%s", pclsArg->m_strIp.c_str() );
clsTcpComm.m_iPort = pclsArg->m_iPort;
clsTcpComm.m_bClient = true;
if( pclsArg->m_pclsStack->m_clsThreadList.SendCommand( (char *)&clsTcpComm, sizeof(clsTcpComm) ) == false )
{
CLog::Print( LOG_ERROR, "%s m_clsThreadList.SendCommand error", __FUNCTION__ );
pclsArg->m_pclsStack->m_clsClientMap.Delete( pclsArg->m_strIp.c_str(), pclsArg->m_iPort );
closesocket( hConn );
}
}
else
{
CTcpNoPipeThreadArg * pclsNewArg = new CTcpNoPipeThreadArg();
if( pclsNewArg == NULL )
{
CLog::Print( LOG_ERROR, "%s new error", __FUNCTION__ );
closesocket( hConn );
}
else
{
pclsNewArg->m_hSocket = hConn;
pclsNewArg->m_strIp = pclsArg->m_strIp;
pclsNewArg->m_iPort = pclsArg->m_iPort;
pclsNewArg->m_pclsStack = pclsArg->m_pclsStack;
pclsNewArg->m_bClient = true;
if( StartThread( "TcpNoPipeThread", TcpNoPipeThread, pclsNewArg ) == false )
{
CLog::Print( LOG_ERROR, "%s StartThread error", __FUNCTION__ );
closesocket( hConn );
}
}
pclsArg->m_pclsStack->m_clsClientMap.Delete( pclsArg->m_strIp.c_str(), pclsArg->m_iPort );
}
}
}
CLog::Print( LOG_INFO, "TcpClientThread terminated (%s:%d)", pclsArg->m_strIp.c_str(), pclsArg->m_iPort );
delete pclsArg;
#ifdef USE_TLS
if( pclsArg->m_pclsStack->m_clsSetup.m_bUseTls )
{
ERR_remove_thread_state( NULL );
}
#endif
return 0;
}
