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; }