#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);

 }

 #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);

 }