windows—IOCP

一、重叠I/O回声服务器端

服务端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <WinSock2.h>

 #define BUF_SIZE 1024
 void ErrorHandling(char *message);
 void CALLBACK ReadCompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);
 void CALLBACK WriteCompRoutine(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);

 typedef struct
 {
     SOCKET hClntSock;
     char buf[BUF_SIZE];
     WSABUF wsaBuf;
 }PER_IO_DATA, *LPPER_IO_DATA;

 int main(int argc, char *argv[])
 {
     if (argc != ) {
         printf("Usage : %s <port>\n", argv[]);
         exit();
     }

     WSADATA wsaData;
     SOCKET hLinSock, hRecvSock;
     SOCKADDR_IN lisnAdr, recvAdr;
     LPWSAOVERLAPPED lpOvLp;
     DWORD recvBytes;
     LPPER_IO_DATA hbInfo;
     int mode = , recvAdrSz, flagInfo = ;

     if (WSAStartup(MAKEWORD(, ), &wsaData) != )
         ErrorHandling("WSAStartup() error.");

     hLinSock = WSASocket(PF_INET, SOCK_STREAM, , NULL, , WSA_FLAG_OVERLAPPED);
     ioctlsocket(hLinSock, FIONBIO, (u_long*)&mode); // 套接字改成非阻塞的

     memset(&lisnAdr, , sizeof(lisnAdr));
     lisnAdr.sin_family = AF_INET;
     lisnAdr.sin_addr.s_addr = htonl(INADDR_ANY);
     lisnAdr.sin_port = htons(atoi(argv[]));

     if (bind(hLinSock, (SOCKADDR*)&lisnAdr, sizeof(lisnAdr)) == SOCKET_ERROR)
         ErrorHandling("bind() error.");
     if (listen(hLinSock, ) == SOCKET_ERROR)
         ErrorHandling("listen() error.");
     printf("Server start...\n");
     recvAdrSz = sizeof(recvAdr);
     while ()
     {
         SleepEx(, TRUE); // 让线程处于等待接收操作系统消息的线程状态
         hRecvSock = accept(hLinSock, (SOCKADDR*)&recvAdr, &recvAdrSz);
         if (hRecvSock == INVALID_SOCKET){
             if (WSAGetLastError() == WSAEWOULDBLOCK)
                 continue;
             else
                 ErrorHandling("accept() error");
         }
         puts("Client connected...");

         lpOvLp = (LPWSAOVERLAPPED)malloc(sizeof(WSAOVERLAPPED));
         memset(lpOvLp, , sizeof(lpOvLp));

         hbInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
         hbInfo->hClntSock = (DWORD)hRecvSock;
         (hbInfo->wsaBuf).buf = hbInfo->buf;
         (hbInfo->wsaBuf).len = BUF_SIZE;

         lpOvLp->hEvent = (HANDLE)hbInfo;
         WSARecv(hRecvSock, &(hbInfo->wsaBuf), , &recvBytes, (LPDWORD)&flagInfo, lpOvLp, ReadCompRoutine);
     }
     closesocket(hRecvSock);
     closesocket(hLinSock);
     WSACleanup();
     return ;
 }

 void CALLBACK ReadCompRoutine(DWORD dwError, DWORD szRecvBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags)
 {
     LPPER_IO_DATA hbInfo = (LPPER_IO_DATA)(lpOverlapped->hEvent);
     SOCKET hSock = hbInfo->hClntSock;
     LPWSABUF bufInfo = &(hbInfo->wsaBuf);
     DWORD sentBytes;

     if (szRecvBytes == )
     {
         closesocket(hSock);
         free(hbInfo);
         free(lpOverlapped);
         puts("Client disconnected...");
     }
     else
     {
         bufInfo->len = szRecvBytes;
         WSASend(hSock, bufInfo, , &sentBytes, , lpOverlapped, WriteCompRoutine);
     }
 }

 void CALLBACK WriteCompRoutine(DWORD dwError, DWORD szSendBytes, LPWSAOVERLAPPED lpOverlapped, DWORD flags)
 {
     LPPER_IO_DATA hbInfo = (LPPER_IO_DATA)(lpOverlapped->hEvent);
     SOCKET hSock = hbInfo->hClntSock;
     LPWSABUF bufInfo = &(hbInfo->wsaBuf);
     DWORD recvBytes;
     int flagInfo = ;
     WSARecv(hSock, bufInfo, , &recvBytes, (LPDWORD)&flagInfo, lpOverlapped, ReadCompRoutine);
 }

 void ErrorHandling(char *message) {
     fputs(message, stderr);
     fputc('\n', stderr);
 }

二、IOCP回声服务端

服务端：

 #include <stdio.h>
 #include <stdlib.h>
 #include <process.h>
 #include <WinSock2.h>
 #include <windows.h>

 #define BUF_SIZE 128
 #define READ 3
 #define WRITE 5
 void ErrorHandling(char *message);
 unsigned int WINAPI EchoThreadMain(LPVOID pComPort);

 typedef struct // socket info
 {
     SOCKET hClntSock;
     SOCKADDR_IN clntAdr;
 }PER_HANDLE_DATA, *LPPER_HANDLE_DATA;

 typedef struct // buffer info
 {
     OVERLAPPED overlapped;
     WSABUF wsaBuf;
     char buffer[BUF_SIZE];
     int rwMode; // read or write
 }PER_IO_DATA, *LPPER_IO_DATA;

 int main(int argc, char *argv[])
 {
     if (argc != ) {
         printf("Usage : %s <port>\n", argv[]);
         exit();
     }

     WSADATA wsaData;
     HANDLE hComPort;
     SYSTEM_INFO sysInfo;
     LPPER_IO_DATA ioInfo;
     LPPER_HANDLE_DATA handleInfo;

     SOCKET hServSock;
     SOCKADDR_IN servAdr;
     int recvBytes, i, flags = ;

     if (WSAStartup(MAKEWORD(, ), &wsaData) != )
         ErrorHandling("WSAStartup() error.");

     hComPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, , );
     GetSystemInfo(&sysInfo);
     for (int i = ; i < (int)sysInfo.dwNumberOfProcessors; i++)
         _beginthreadex(NULL, , EchoThreadMain, (LPVOID)hComPort, , NULL);

     hServSock = WSASocket(AF_INET, SOCK_STREAM, , NULL, , WSA_FLAG_OVERLAPPED);
     memset(&servAdr, , sizeof(servAdr));
     servAdr.sin_family = AF_INET;
     servAdr.sin_addr.s_addr = htonl(INADDR_ANY);
     servAdr.sin_port = htons(atoi(argv[]));

     bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr));
     listen(hServSock, );

     puts("Server start...");
     while (){
         SOCKET hClntSock;
         SOCKADDR_IN clntAdr;
         int addrLen = sizeof(clntAdr);

         hClntSock = accept(hServSock, (SOCKADDR*)&clntAdr, &addrLen);
         handleInfo = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));
         handleInfo->hClntSock = hClntSock;
         memcpy(&(handleInfo->clntAdr), &clntAdr, addrLen);

         CreateIoCompletionPort((HANDLE)hClntSock, hComPort, (DWORD)handleInfo, );

         ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
         memset(&(ioInfo->overlapped), , sizeof(OVERLAPPED));
         ioInfo->wsaBuf.len = BUF_SIZE;
         ioInfo->wsaBuf.buf = ioInfo->buffer;
         ioInfo->rwMode = READ;
         WSARecv(handleInfo->hClntSock, &(ioInfo->wsaBuf), , (LPDWORD)&recvBytes, (LPDWORD)&flags, &(ioInfo->overlapped), NULL);
     }

     WSACleanup();
     return ;
 }

 unsigned int WINAPI EchoThreadMain(LPVOID pComPort)
 {
     HANDLE hComPort = (HANDLE)pComPort;
     SOCKET sock;
     DWORD bytesTrans;
     LPPER_HANDLE_DATA handleInfo;
     LPPER_IO_DATA ioInfo;
     DWORD flags = ;
     while ()
     {
         GetQueuedCompletionStatus(hComPort, &bytesTrans, (LPDWORD)&handleInfo, (LPOVERLAPPED*)&ioInfo, INFINITE);
         sock = handleInfo->hClntSock;
         if (ioInfo->rwMode == READ)
         {
             puts("message received!");
             if (bytesTrans == ) // 传输EOF
             {
                 closesocket(sock);
                 free(handleInfo);
                 free(ioInfo);
                 continue;
             }
             memset(&(ioInfo->overlapped), , sizeof(OVERLAPPED));
             ioInfo->wsaBuf.len = bytesTrans;
             ioInfo->rwMode = WRITE;
             WSASend(sock, &(ioInfo->wsaBuf), , NULL, , &(ioInfo->overlapped), NULL);
             ioInfo = (LPPER_IO_DATA)malloc(sizeof(PER_IO_DATA));
             memset(&(ioInfo->overlapped), , sizeof(OVERLAPPED));
             ioInfo->wsaBuf.len = BUF_SIZE;
             ioInfo->wsaBuf.buf = ioInfo->buffer;
             ioInfo->rwMode = READ;
             WSARecv(sock, &(ioInfo->wsaBuf), , NULL, &flags, &(ioInfo->overlapped), NULL);
         }
         else{
             puts("message sent");
             free(ioInfo);
         }
     }
 }

 void ErrorHandling(char *message) {
     fputs(message, stderr);
     fputc('\n', stderr);
 }