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 */