c++ 网络编程（十）TCP/IP LINUX/windows 异步通知I/O模型与重叠I/O模型 附带示例代码

WSAEVENT WSACreateEvent(void); //返回一个手工重置的事件对象句柄

int WSAEventSelect(    
  SOCKET s,                 //套接字  
  WSAEVENT hEventObject,    //网络事件对象  
  long lNetworkEvents       //需要关注的事件  
); 

DWORD WSAWaitForMultipleEvents(    
  DWORD cEvents,                  //指定了事件对象数组里边的个数，最大值为64  
  const WSAEVENT FAR *lphEvents,  //事件对象数组  
  BOOL fWaitAll,                  //等待类型，TRUE表示要数组里全部有信号才返回，FALSE表示至少有一个就返回，这里必须为FALSE  
  DWORD dwTimeout,                //等待的超时时间  
  BOOL fAlertable                 //当系统的执行队列有I/O例程要执行时，是否返回，TRUE执行例程返回，FALSE不返回不执行，这里为FALSE  
);  

int WSAEnumNetworkEvents  
(    
  SOCKET s,                             //指定的socket  
  WSAEVENT hEventObject,                //事件对象  
  LPWSANETWORKEVENTS lpNetworkEvents    //WSANETWORKEVENTS<span style="font-family:Arial, Helvetica, sans-serif;">结构地址</span>  
);  

#include <WinSock2.h>
#include <process.h>
#include <stdio.h>
#pragma comment(lib,"ws2_32.lib")

SOCKET g_sClient[WSA_MAXIMUM_WAIT_EVENTS] = {INVALID_SOCKET};  //client socket数组
WSAEVENT g_event[WSA_MAXIMUM_WAIT_EVENTS];                     //网络事件对象数组
SOCKET g_sServer = INVALID_SOCKET;                             //server socket 
WSAEVENT g_hServerEvent;                                       //server 网络事件对象
int iTotal = 0;                                                //client个数
/*
@function OpenTCPServer             打开TCP服务器
@param _In_ unsigned short Port     服务器端口
@param  _Out_ DWORD* dwError        错误代码
@return  成功返回TRUE 失败返回FALSE
*/
BOOL OpenTCPServer( _In_ unsigned short Port, _Out_ DWORD* dwError)
{
    BOOL bRet = FALSE;
    WSADATA wsaData = { 0 };
    SOCKADDR_IN ServerAddr = { 0 };
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(Port);
    ServerAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    do
    {
        if (!WSAStartup(MAKEWORD(2, 2), &wsaData))
        {
            if (LOBYTE(wsaData.wVersion) == 2 || HIBYTE(wsaData.wVersion) == 2)
            {
                g_sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
                g_hServerEvent = WSACreateEvent();                    //创建网络事件对象
                WSAEventSelect(g_sServer, g_hServerEvent, FD_ACCEPT);//为server socket注册网络事件 
                if (g_sServer != INVALID_SOCKET)
                {
                    if (SOCKET_ERROR != bind(g_sServer, (SOCKADDR*)&ServerAddr, sizeof(ServerAddr)))
                    {
                        if (SOCKET_ERROR != listen(g_sServer, SOMAXCONN))
                        {
                            bRet = TRUE;
                            break;
                        }
                        *dwError = WSAGetLastError();
                        closesocket(g_sServer);
                    }
                    *dwError = WSAGetLastError();
                    closesocket(g_sServer);
                }
                *dwError = WSAGetLastError();
            }
            *dwError = WSAGetLastError();

        }
        *dwError = WSAGetLastError();
    } while (FALSE);
    return bRet;
}

//接受client请求线程
unsigned int __stdcall ThreadAccept(void* lparam)
{
    WSANETWORKEVENTS networkEvents; //网络事件结构
    while (iTotal < WSA_MAXIMUM_WAIT_EVENTS)  //这个值是64
    {
        if (0 == WSAEnumNetworkEvents(g_sServer, g_hServerEvent, &networkEvents))
        {
            if (networkEvents.lNetworkEvents & FD_ACCEPT) //如果等于FD_ACCEPT，相与就为1
            {
                if (0 == networkEvents.iErrorCode[FD_ACCEPT_BIT])  //检查有无网络错误
                {
                    //接受请求
                    SOCKADDR_IN addrServer = { 0 };
                    int iaddrLen = sizeof(addrServer);
                    g_sClient[iTotal] = accept(g_sServer, (SOCKADDR*)&addrServer, &iaddrLen);
                    if (g_sClient[iTotal] == INVALID_SOCKET)
                    {
                        printf("accept failed with error code: %d\n", WSAGetLastError());
                        return 1;
                    }
                    //为新的client注册网络事件
                    g_event[iTotal] = WSACreateEvent();
                    WSAEventSelect(g_sClient[iTotal], g_event[iTotal], FD_READ | FD_WRITE | FD_CLOSE);
                    iTotal++;
                    printf("accept a connection from IP: %s,Port: %d\n", inet_ntoa(addrServer.sin_addr), htons(addrServer.sin_port));
                }
                else  //错误处理
                {
                    int iError = networkEvents.iErrorCode[FD_ACCEPT_BIT];
                    printf("WSAEnumNetworkEvents failed with error code: %d\n", iError);
                    return 1;
                }
            }
        }
        Sleep(100);
    }
    return 0;
}

//接收数据
unsigned int __stdcall ThreadRecv(void* lparam)
{
    char* buf = (char*)malloc(sizeof(char) * 128);
    while (1)
    {
        if (iTotal == 0)
        {
            Sleep(100);
            continue;
        }
        //等待网络事件
        DWORD dwIndex = WSAWaitForMultipleEvents(iTotal, g_event, FALSE, 1000, FALSE); 
        //当前的事件对象
        WSAEVENT curEvent = g_event[dwIndex];
        //当前的套接字
        SOCKET sCur = g_sClient[dwIndex];
        //网络事件结构
        WSANETWORKEVENTS networkEvents;
        if (0 == WSAEnumNetworkEvents(sCur, curEvent, &networkEvents))
        {
            if (networkEvents.lNetworkEvents & FD_READ)  //有数据可读
            {
                if (0 == networkEvents.iErrorCode[FD_READ_BIT])
                {
                    memset(buf, 0, sizeof(buf));
                    int iRet = recv(sCur, buf, sizeof(buf), 0);  //接收数据
                    if (iRet != SOCKET_ERROR)
                    {
                        if (strlen(buf) != 0)
                            printf("Recv: %s\n", buf);
                    }
                }
                else //错误处理
                {
                    int iError = networkEvents.iErrorCode[FD_ACCEPT_BIT];
                    printf("WSAEnumNetworkEvents failed with error code: %d\n", iError);
                    break;
                }
            }
            else if (networkEvents.lNetworkEvents & FD_CLOSE)  //client关闭
                printf("%d downline\n", sCur);
        }
        Sleep(100);
    }
    if (buf)
        free(buf);
    return 0;
}

int main()
{
    DWORD dwError = 0;
    if (OpenTCPServer(18000, &dwError))
    {
        _beginthreadex(NULL, 0, ThreadAccept, NULL, 0, NULL);
        _beginthreadex(NULL, 0, ThreadRecv, NULL, 0, NULL);
    }
    Sleep(100000000);
    closesocket(g_sServer);
    WSACleanup();
    return 0;
}

AcceptEX函数将几个套接字函数的功能集合在一起。如果它投递的请求成功完成，则执行了如下3个操作：

  AcceptEX函数是从Mswsock.lib库中导出的，为了能够直接调用它，而不用链接到Mswsock.lib库，需要使用WSAIoctl函数将AcceptEX函数加载到内存，WSAIoctl函数是ioctlsocket函数的扩展，它可以使用重叠I/O。函数的第3个到第6个参数是输入和输出缓冲区，在这里传递AcceptEX函数的指针


（4）接收传输结果

当重叠I/O请求最终完成以后，以之关联的事件对象受信，等待函数返回，应用程序可以使用WSAGetOverlappedResult函数取得重叠操作的结果，函数用法如下：

参数：

4-重叠模型的实例代码：

//完成例程实现重叠io模型伪代码
SOCKET acceptSock;
WSABUF dataBuf;

void main()
{
    WSAOVERLAPPED overlapped;
    //1.初始化
    //...

    //2.接收连接请求
    acceptSock=accept(listenSock,NULL,NULL);

    //3.初始化重叠结构
    UINT flag=0;
    ZeroMemory(&overlapped,sizeof(WSAOVERLAPPED));
    dataBuf.len=DATA_BUFSIZE;
    dataBuf.buf=buf;

    if (WSARecv(acceptSock,&dataBuf,1,&recvBytes,&flag,&overlapped,workroutine)==SOCKET_ERROR)//最后一个参数时回调函数地址
    {
        if(WSAGetLastError()!=WSA_IO_PENDING)
        {
            printf("WSARecv() failed with error %d\n",WSAGetLastError());
            return;
        }
    }
    
    //创建事件
    eventArray[0]=WSACreateEvent();
    while (true)
    {
        int index=WSAWaitForMultipleEvents(1,eventArray,FALSE,WSA_INFINITE,TRUE);//最后一个参数最好为true
        if (index==WAIT_IO_COMPLETION)//io请求完成
        {
            break;
        }
        else//io请求出错
        {
            return;
        }
    }
    //调用回调函开始进行处理
}

void CALLBACK WorkRoutine(DWORD error,DWORD bytesTransferred,LPWSAOVERLAPPED overlapped,DWORD inflag)
{
    DWORD sendBytes,recvBytes;
    DWORD flags;

    if(error!=0||bytesTransferred==0)
    {
        closesocket(acceptSock);
        return;
    }

    flags=0;

    ZeroMemory(&overlapped,sizeof(WSAOVERLAPPED));
    dataBuf.len=DATA_BUFSIZE;
    dataBuf.data=buf;

    if (WSARecv(acceptSock,&dataBuf,1,&recvBytes,&flag,&overlapped,workroutine)==SOCKET_ERROR)//最后一个参数时回调函数地址
    {
        if(WSAGetLastError()!=WSA_IO_PENDING)
        {
            printf("WSARecv() failed with error %d\n",WSAGetLastError());
            return;
        }
    }
}

 最后说一句啦。本网络编程入门系列博客是连载学习的，有兴趣的可以看我博客其他篇。。。。


参考博客：https://www.cnblogs.com/Dreamcaihao/archive/2012/11/14/2770293.html
参考博客：https://www.cnblogs.com/tanguoying/p/8506821.html
参考博客：https://blog.csdn.net/wxf2012301351/article/details/73332588
参考书籍：《TCP/IP网络编程 ---尹圣雨》