[求助]帮写一个通信接受函数，只要有数据就返回，没数据时超时5秒继续往下走

Question

通信接受函数为 int ReadData(char* RecvBuf)
返回值为接受数据大小  没有数据时一直为0 
主要功能就使得可以实时的接受到数据，没有则超时5秒后继续往下走

Answer 1

一般情况都是在send后 sleep一会在接受，但现在就是想更加实时的接受到数据
拜托了  各位大神

Answer 2

看上去更像应该做成Callback函数

Answer 3

简单示例#include <Winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <vector>
#include <process.h>
using namespace std;#pragma comment(lib, "Ws2_32.lib")typedef struct _thread_iocp_overlap
{
OVERLAPPED m_ol;
vector<char> m_vtBuffer;
WSABUF m_wsabuf;
int m_nIoSize;
int m_nType;
SOCKET socket_client;
}thread_iocp_overlap, *pthread_iocp_overlap;enum IOType 
{
IOConnected,
IOAccepted,
IORecved,
IOSent,
IOWriteCompleted,
IOFileTransmitted,
IOFailed,
};HANDLE g_hCompletionPort = NULL;
thread_iocp_overlap g_thread_iocp_overlap;
void thread_io_worker(void* args);
void ProcessIoMsg(pthread_iocp_overlap pOverlapBuff);void main()
{
g_hCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, NULL ); if( NULL == g_hCompletionPort )
{
printf("failed to create completionport!\n");
return;
}
SYSTEM_INFO SysInfo;
GetSystemInfo(&SysInfo);
int nThreadInfo = SysInfo.dwNumberOfProcessors*2+2; for( int i = 0; i < nThreadInfo; i++ )
{
_beginthread(thread_io_worker, NULL, NULL);
}
WSADATA wsdata;
WSAStartup(MAKEWORD(2, 2), &wsdata);
SOCKET sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED);
if( sock == INVALID_SOCKET )
{
printf("Failed to create SOCKET!\n");
return;
} sockaddr_in addr;
addr.sin_port = htons(80);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY); if( SOCKET_ERROR == bind(sock, (const sockaddr*)&addr, sizeof(sockaddr)) )
{
printf("The socket binding port failed!\n");
return;
} if( SOCKET_ERROR  == listen(sock, SOMAXCONN) )
{
printf("failed to listen socket!\n");
return;
} printf("http server is running!\n"); while(1)
{
vector<char> vecBuffer;
sockaddr_in addr_client;
int nSize = sizeof(sockaddr_in);
SOCKET socket_client = accept(sock, (sockaddr*)&addr_client, &nSize);
if( INVALID_SOCKET  == socket_client )
{
Sleep(100);
continue;
} if( g_hCompletionPort != CreateIoCompletionPort((HANDLE)socket_client, g_hCompletionPort, NULL, 0) )
{
printf("failed to CreateIoCompletionPort bind socket");
break;
}
DWORD dwIoSize=0;
ULONG ulFlags = MSG_PARTIAL;
g_thread_iocp_overlap.m_nType = IORecved;
g_thread_iocp_overlap.socket_client = socket_client;
g_thread_iocp_overlap.m_vtBuffer.reserve(4096);
g_thread_iocp_overlap.m_vtBuffer.push_back('\0');
g_thread_iocp_overlap.m_wsabuf.buf = &g_thread_iocp_overlap.m_vtBuffer[0]; int nRet = WSARecv(socket_client,
&g_thread_iocp_overlap.m_wsabuf,
1,
&dwIoSize,
&ulFlags,
&g_thread_iocp_overlap.m_ol, 
NULL); if(nRet!=0 && WSAGetLastError() != WSA_IO_PENDING) 
{
printf("failed to WSARecv!\n");
break;
}
} WSACleanup();
}void ProcessIoMsg(pthread_iocp_overlap pOverlapBuff)
{
switch(pOverlapBuff->m_nType)
{
case IORecved:
{
char szBufer[1024] = {0};
int nRead = recv(pOverlapBuff->socket_client, szBufer, sizeof(szBufer), 0); if( SOCKET_ERROR == nRead )
{
printf("Socket failed to receive data! error code = %d\n", WSAGetLastError());
} if( strlen(szBufer) > 0 )
{
pOverlapBuff->m_vtBuffer.reserve(pOverlapBuff->m_vtBuffer.size() + strlen(szBufer));
if( pOverlapBuff->m_vtBuffer.size() == 1 )
{
pOverlapBuff->m_vtBuffer.insert(pOverlapBuff->m_vtBuffer.begin(), &szBufer[0], &szBufer[0] + nRead);
}
else
{
pOverlapBuff->m_vtBuffer.insert(pOverlapBuff->m_vtBuffer.end(), &szBufer[0], &szBufer[0] + nRead);
}

} if( strstr(szBufer, "\r\n\r\n") )
{
printf("Has received the HTTP head!\n"); char* pHttpBuffer = &pOverlapBuff->m_vtBuffer[0];
printf("%s\n", pHttpBuffer);
if( strnicmp(pHttpBuffer, "GET ", 4) == 0 )
{
char szResponse[512] = {0};

sprintf(szResponse, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: %d\r\n\r\nhello world!", 
strlen("hello world!"));
if( SOCKET_ERROR == send(pOverlapBuff->socket_client, szResponse, strlen(szResponse), 0) )
{
printf("failed to response data! error code = %d\n",  WSAGetLastError());
}
} shutdown(pOverlapBuff->socket_client, SD_BOTH);
closesocket(pOverlapBuff->socket_client); break;
}
}
}
}void thread_io_worker(void* args)
{
BOOL bIORet;
DWORD dwIoSize;
LPOVERLAPPED lpOverlapped;
pthread_iocp_overlap pOverlapBuff;
void* pthread_param; while(1)
{
bIORet = GetQueuedCompletionStatus(
g_hCompletionPort,
&dwIoSize,
(LPDWORD) &pthread_param, 
&lpOverlapped, INFINITE); if(bIORet)
{
pOverlapBuff = CONTAINING_RECORD(lpOverlapped, thread_iocp_overlap, m_ol);
pOverlapBuff->m_nIoSize = dwIoSize;
ProcessIoMsg(pOverlapBuff);
}
else if(!bIORet)
{
pOverlapBuff = CONTAINING_RECORD(lpOverlapped, thread_iocp_overlap, m_ol);
shutdown(pOverlapBuff->socket_client, SD_BOTH);
closesocket(pOverlapBuff->socket_client);
}
else
{
break;
}
}}

Answer 4

可以使用waitforsingleobject函数判断吗