int TcpPPRecv (SOCKET s, LPSTR szBuf, unsigned uBufSize, int uTimeOut, HANDLE hLogFile)
{
unsigned short usToBeReceived=0;
int usUpRc, usReceived;
int Rc;
usReceived = 0;
usUpRc=1;
// get number of byte to be expected
Rc = TcpRecv (s, (LPSTR) & usToBeReceived, sizeof usToBeReceived, uTimeOut, hLogFile);
if (Rc!=sizeof usToBeReceived) return Rc;
// put in machine ordrer
usToBeReceived = ntohs (usToBeReceived);
if (usToBeReceived > 0x7FFF) return TCP4U_OVERFLOW;
// loop while msg is shorter than expected or timeout
while (usUpRc>0 && usReceived < usToBeReceived )
{
usUpRc = TcpRecv (s, szBuf, usToBeReceived - usReceived, uTimeOut, hLogFile);
usReceived += usUpRc;
szBuf += usUpRc;
}
return usUpRc>0 ? usReceived : usUpRc ;
} /* TcpPPRecv */
int main()
{
int sockfd, rc;
int port = 9997;
sockfd = TcpListenX("127.0.0.1", port);
printf("sockfd:%d\n", sockfd);
int sport;
char buf[1025];
char sip[100];
while(1) {
rc = TcpAccept(sockfd, sip, &sport);
printf("rc : %d\n", rc);
printf("sip:%s, sport:%d\n", sip, sport);
int sx = 0;
rc = TcpRecv(rc, buf, 1024, sx);
}
return 0;
}
// ------------------------------------------------------------------------------------------------
static void TcpInput(NetBuf *pkt)
{
TcpHeader *tcpHdr = (TcpHeader *)pkt->start;
TcpSwap(tcpHdr);
// Data
pkt->end = pkt->start + sizeof(TcpHeader);
// Pseudo Header
ChecksumHeader *phdr = (ChecksumHeader *)(pkt->start - sizeof(ChecksumHeader));
phdr->src = s_ipAddr;
phdr->dst = s_ipAddr;
phdr->reserved = 0;
phdr->protocol = IP_PROTOCOL_TCP;
phdr->len = NetSwap16(pkt->end - pkt->start);
// Checksum
u16 checksum = NetChecksum(pkt->start - sizeof(ChecksumHeader), pkt->end);
tcpHdr->checksum = NetSwap16(checksum);
// IP Header
Ipv4Header *ipHdr = (Ipv4Header *)(pkt->start - sizeof(Ipv4Header));
ipHdr->verIhl = (4 << 4) | 5;
ipHdr->tos = 0;
ipHdr->len = NetSwap16(pkt->end - pkt->start);
ipHdr->id = NetSwap16(0);
ipHdr->offset = NetSwap16(0);
ipHdr->ttl = 64;
ipHdr->protocol = IP_PROTOCOL_TCP;
ipHdr->checksum = 0;
ipHdr->src = s_ipAddr;
ipHdr->dst = s_ipAddr;
// Receive
TcpRecv(s_intf, ipHdr, pkt);
NetReleaseBuf(pkt);
}
void *tcp_rcvTask(void *argc)
{
int ret, i;
int numEvents;
unsigned char buf[MAX_DATA_LENGTH*1000]; /* NEXT_CHECK by icecom 110823 */
ThreadAlive[PTASK0] = TRUE;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
pthread_cleanup_push(ThreadCleanUp, (void *)NULL);
memset(buf, 0x0, sizeof(buf));
FD_ZERO(&allset);
tlink.ListenFD = TcpOpen(&tlink);
if (tlink.ListenFD <= 0) {
if (tlink.mode == LINK_MODE_SERVER) {
xprint(FMS_HST | FMS_ERROR, "%s : S-TCP TcpOpen failed\n", __func__);
} else if (tlink.mode == LINK_MODE_CLIENT) {
xprint(FMS_HST | FMS_ERROR, "%s : client mode\n", __func__);
} else {
xprint(FMS_HST | FMS_ERROR, "%s : unknown socket mode\n", __func__);
}
/* NEXT_CHECK error processing, by icecom */
} else {
FD_SET(tlink.ListenFD, &allset);
compareMaxfd(tlink.ListenFD);
if (tlink.mode == LINK_MODE_CLIENT) {
} else {
TcpInfo();
}
}
for (;;) {
if (ThreadAlive[PTASK0] != TRUE) {
break;
}
rset = allset;
if (0 > (numEvents = recv_extendedPoll(200, &rset))) {
xprint(FMS_HST | FMS_ERROR, "%s(%d) : recv_extendedPoll (reason=%s)\n",
__func__, __LINE__, strerror(errno));
if (errno == EINTR) {
continue;
} else if (errno == EBADF || errno == EPIPE || errno == EIO) {
xprint(FMS_HST | FMS_ERROR, "select at ProcessEvent(%s) EXIT !!\n", strerror(errno));
} else {
xprint(FMS_HST | FMS_ERROR, "select at ProcessEvent(%s) EXIT !!\n", strerror(errno));
}
} else if (numEvents == 0) {
/* Time out 인 경우 정상처리 한다. */
continue;
} else {
if (tlink.mode == LINK_MODE_SERVER) {
if (tlink.ListenFD > 0) {
if (FD_ISSET(tlink.ListenFD, &rset)) {
xprint(FMS_HST | FMS_INFO1, "%s(%d) :: TcpAccept Start\n", __func__, __LINE__);
pthread_mutex_lock(&TcpMutex);
i = TcpAccept(tlink.ListenFD);
pthread_mutex_unlock(&TcpMutex);
if (i == MAX_LISTENQ) {
xprint(FMS_HST | FMS_ERROR, "%s(%d) :: TcpAccept error\n", __func__, __LINE__);
continue;
} else {
pthread_mutex_lock(&TcpMutex);
if (alist[i].AcceptFD > 0) {
FD_SET(alist[i].AcceptFD, &allset);
compareMaxfd(alist[i].AcceptFD);
#if 0
/* 20140723, by jeon */
TcpInfo();
#endif
} else {
xprint(FMS_HST | FMS_ERROR, "TcpAccept fail(fd=%d)\n", alist[i].AcceptFD);
pthread_mutex_unlock(&TcpMutex);
continue;
}
pthread_mutex_unlock(&TcpMutex);
}
}
}
pthread_mutex_lock(&TcpMutex);
for (i = 0; i < MAX_LISTENQ; i++) {
if (alist[i].AcceptFD > 0) {
if (FD_ISSET(alist[i].AcceptFD, &rset)) {
if ((ret = TcpRecv(i, alist[i].AcceptFD, buf)) > 0) {
/* 20140723, by jeon */
if (hostConf.vmc_system[i].systemport == 0) {
vm_proc_state_msg *hb = (vm_proc_state_msg *)&buf[DEFAULT_TCP_COMHDR_LENGTH];
alist[i].sysinfo.systemaddr = NBO_NTOHL(hb->vm_ipaddress);
sprintf(alist[i].sysinfo.systemname, "VM-%s", addr2ntoa(alist[i].sysinfo.systemaddr));
hostConf.vmc_system[i].systemaddr = alist[i].sysinfo.systemaddr;
sprintf(hostConf.vmc_system[i].systemname, "%s", alist[i].sysinfo.systemname);
hostConf.vmc_system[i].systemport = alist[i].sysinfo.port;
TcpInfo();
}
TcpdSock_Event(i, buf);
}
}
}
}
pthread_mutex_unlock(&TcpMutex);
} else if (tlink.mode == LINK_MODE_CLIENT) {
}
}
}
ThreadAlive[PTASK0] = FALSE;
ThreadFlags[PTASK0] = FALSE;
/* pthread mgnt */
pthread_cleanup_pop(1);
return(NULL);
}
/**
* @ingroup SnmpStack
* @brief SNMP 요청 메시지를 전송한 후, 이에 대한 응답 메시지를 수신한다.
* @param pclsRequest SNMP 요청 메시지
* @param pclsResponse SNMP 응답 메시지
* @returns 성공하면 true 를 리턴하고 실패하면 false 를 리턴한다.
*/
bool CSnmpSession::SendRecv( CSnmpMessage * pclsRequest, CSnmpMessage * pclsResponse )
{
int iSendLen, iRecvLen = 0, n;
bool bRes = false;
if( m_hSocket == INVALID_SOCKET )
{
if( Open() == false ) return false;
}
if( m_bTcp )
{
char szSend[SNMP_MAX_PACKET_SIZE], szRecv[SNMP_MAX_PACKET_SIZE];
int iWantRecvLen = 0;
iSendLen = pclsRequest->MakePacket( szSend, sizeof(szSend) );
if( iSendLen == -1 )
{
CLog::Print( LOG_ERROR, "%s MakePacket error", __FUNCTION__ );
return false;
}
if( TcpSend( m_hSocket, szSend, iSendLen ) == false )
{
CLog::Print( LOG_ERROR, "%s TcpSend error", __FUNCTION__ );
return false;
}
while( 1 )
{
n = TcpRecv( m_hSocket, szRecv + iRecvLen, sizeof(szRecv) - iRecvLen, m_iMiliTimeout / 1000 );
if( n <= 0 )
{
CLog::Print( LOG_ERROR, "%s recv error(%d)", __FUNCTION__, GetError() );
return false;
}
iRecvLen += n;
if( iWantRecvLen <= 0 )
{
iWantRecvLen = pclsResponse->GetPacketLen( szRecv, iRecvLen );
}
if( iWantRecvLen > 0 )
{
if( iRecvLen == iWantRecvLen ) break;
}
}
if( pclsResponse->ParsePacket( szRecv, iRecvLen ) > 0 )
{
if( m_bDebug )
{
LogPacket( szRecv, iRecvLen );
}
if( pclsRequest->m_iRequestId == pclsResponse->m_iRequestId ||
( pclsRequest->m_iMsgId > 0 && pclsRequest->m_iMsgId == pclsResponse->m_iMsgId ) )
{
bRes = true;
}
}
}
else
{
char szSend[SNMP_MAX_PACKET_SIZE], szRecv[SNMP_MAX_PACKET_SIZE];
struct pollfd arrPoll[1];
uint32_t iIp;
uint16_t sPort;
iSendLen = pclsRequest->MakePacket( szSend, sizeof(szSend) );
if( iSendLen == -1 )
{
CLog::Print( LOG_ERROR, "%s MakePacket error", __FUNCTION__ );
return false;
}
for( int iSend = 0; iSend <= m_iReSendCount; ++iSend )
{
if( UdpSend( m_hSocket, szSend, iSendLen, m_iIp, m_sPort ) == false )
{
CLog::Print( LOG_ERROR, "%s UdpSend error", __FUNCTION__ );
return false;
}
TcpSetPollIn( arrPoll[0], m_hSocket );
POLL_START:
n = poll( arrPoll, 1, m_iMiliTimeout );
if( n > 0 )
{
iRecvLen = sizeof(szRecv);
if( UdpRecv( m_hSocket, szRecv, &iRecvLen, &iIp, &sPort ) )
{
if( pclsResponse->ParsePacket( szRecv, iRecvLen ) > 0 )
{
if( m_bDebug )
{
LogPacket( szRecv, iRecvLen );
}
if( pclsRequest->m_iRequestId == pclsResponse->m_iRequestId ||
( pclsRequest->m_iMsgId > 0 && pclsRequest->m_iMsgId == pclsResponse->m_iMsgId ) )
{
bRes = true;
break;
}
}
// 원하는 응답이 수신되지 않으면 다시 수신 대기로 진입한다.
goto POLL_START;
}
}
}
}
return bRes;
}
/*######################################################################
*##
*## NAME: TCPRecvUntilClosedEx
*##
*## PURPOSE: Receive Tcp data until socket connection closed by server
*##
*####################################################################*/
int API4U TcpRecvUntilClosedEx
(SOCKET far *pCSock, /* socket comm.*/
LPCSTR szLocalFile, /* local file transfer */
TRANSFER_CBK CbkTransmit, /* callback transfer */
unsigned uTimeout, /* timeout */
unsigned int uBufSize, /* buffer transfer size */
long lUserValue, /* user value */
long lTotalBytes) /* */
{
int Rc;
long lBytesTransferred = 0;
HFILE hFile = HFILE_ERROR;
LPSTR sBufRead = NULL;
#define XX_RETURN(a) {\
if (hFile != HFILE_ERROR) Close(hFile);\
if (sBufRead != NULL) Free(sBufRead);\
Tcp4uLog (LOG4U_EXIT, "TcpRecvUntilClosedEx, return code %d", a); \
return a;\
}
Tcp4uLog (LOG4U_PROC, "TcpRecvUntilClosedEx");
/* open user local file */
if (szLocalFile!=NULL && (hFile=Open(szLocalFile, WRITE_CR)) == HFILE_ERROR)
{
/* open failed */
XX_RETURN (TCP4U_FILE_ERROR);
}
/* allocate buffer */
if ( (sBufRead = Calloc(uBufSize<128 ? 128 : uBufSize,1)) == NULL)
{
XX_RETURN(TCP4U_INSMEMORY);
}
/* first call to user callback */
if (CbkTransmit != NULL && (*CbkTransmit)(lBytesTransferred,
lTotalBytes,
lUserValue,
sBufRead,
0) == FALSE)
{
/* user stop order */
XX_RETURN (TCP4U_CANCELLED);
}
/* read data from http server */
do
{
/* read one data frame */
Rc=TcpRecv(*pCSock,
sBufRead, /* adress */
uBufSize,
uTimeout,
HFILE_ERROR);
if (Rc >= TCP4U_SUCCESS)
{
/* write to the user local file --> Warning signed/unsigned mismatch */
if (hFile != HFILE_ERROR && Write(hFile, sBufRead, Rc) != Rc)
{
XX_RETURN(TCP4U_FILE_ERROR);
}
lBytesTransferred += (long) Rc;
/* appel du callback */
if (CbkTransmit != NULL && (*CbkTransmit)(lBytesTransferred,
lTotalBytes,
lUserValue,
sBufRead,
Rc) == FALSE) {
XX_RETURN (TCP4U_CANCELLED);
}
}
} while (Rc >= TCP4U_SUCCESS); /* END do while */
/* close all files and free allocated buffers */
XX_RETURN(Rc == TCP4U_SOCKETCLOSED ? TCP4U_SUCCESS : Rc);
#undef XX_RETURN
} /* END TcpRecvUntilClosedEx */
