用完成端口写的echo server

完成端口网上的例子很多，但觉得都挺复杂的

写了一个简化版的，方便学习，也加了注释。

有任何问题，欢迎跟我讨论。

========代码来了=========

#include <winsock2.h>
#include <mswsock.h>
#include <windows.h>

#include <iostream>
using namespace std;

int g_ThreadCount;
HANDLE g_hIOCP = INVALID_HANDLE_VALUE;
SOCKET g_ServerSocket = INVALID_SOCKET;

// Maximum Buffer Size
#define MAX_BUFF_SIZE                8192

enum IO_OPERATION{IO_READ,IO_WRITE};

struct IO_DATA{
    WSAOVERLAPPED               Overlapped;
    char                        Buffer[MAX_BUFF_SIZE];
    WSABUF                      wsabuf;
    int                         nTotalBytes;
    int                         nSentBytes;
    IO_OPERATION                opCode;
    SOCKET                      activeSocket;
};

DWORD WINAPI WorkerThread (LPVOID WorkThreadContext) {
    LPWSAOVERLAPPED lpOverlapped = NULL;
    IO_DATA *lpIOContext = NULL; 
    WSABUF buffSend;
    DWORD dwRecvNumBytes = 0;
    DWORD dwSendNumBytes = 0;
    DWORD dwFlags = 0;
    DWORD dwIoSize = 0;
       BOOL bSuccess = FALSE;
    int nRet = 0;

       while( 1 ) {
         void * lpCompletionKey = NULL;
         bSuccess = GetQueuedCompletionStatus(g_hIOCP, &dwIoSize,
                                             (LPDWORD)&lpCompletionKey,
                                             (LPOVERLAPPED *)&lpOverlapped, 
                                             INFINITE);
         if( !bSuccess )
         {
            cout << "GetQueuedCompletionStatus() failed:"<<GetLastError()<<endl;
            break;
         }

         lpIOContext = (IO_DATA *)lpOverlapped;

         if(dwIoSize == 0) //socket closed?
         {
             cout << "Client disconnect" << endl;
             closesocket(lpIOContext->activeSocket);
             delete lpIOContext;
             continue;
         }

         if(lpIOContext->opCode == IO_READ) // a read operation complete
         {
                lpIOContext->nTotalBytes  = lpIOContext->wsabuf.len;
                lpIOContext->nSentBytes   = 0;
                lpIOContext->opCode = IO_WRITE;
                dwFlags = 0;
                nRet = WSASend(
                              lpIOContext->activeSocket,
                              &lpIOContext->wsabuf, 1, &dwSendNumBytes,
                              dwFlags,
                              &(lpIOContext->Overlapped), NULL);
                if( nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()) ) {
                        cout << "WASSend Failed::Reason Code::"<< WSAGetLastError() << endl;
                        closesocket(lpIOContext->activeSocket);
                        delete lpIOContext;
                        continue;
                }
         }
         else if(lpIOContext->opCode == IO_WRITE) //a write operation complete
         {
                lpIOContext->nSentBytes  += dwIoSize;
                dwFlags = 0;
                if( lpIOContext->nSentBytes < lpIOContext->nTotalBytes ) {
                    lpIOContext->opCode = IO_WRITE;
                    // A Write operation has not completed yet, so post another
                    // Write operation to post remaining data.
                    buffSend.buf = lpIOContext->Buffer + lpIOContext->nSentBytes;
                    buffSend.len = lpIOContext->nTotalBytes - lpIOContext->nSentBytes;
                    nRet = WSASend (
                                   lpIOContext->activeSocket,
                                   &buffSend, 1, &dwSendNumBytes,
                                   dwFlags,
                                   &(lpIOContext->Overlapped), NULL);

                    if( nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()) ) {
                        cout << "WASSend Failed::Reason Code::"<< WSAGetLastError() << endl;
                        closesocket(lpIOContext->activeSocket);
                        delete lpIOContext;
                        continue;
                    }
                } else {
                    // Write operation completed, so post Read operation.
                    lpIOContext->opCode = IO_READ; 
                    dwRecvNumBytes = 0;
                    dwFlags = 0;
                    lpIOContext->wsabuf.buf = lpIOContext->Buffer,
                    ZeroMemory(lpIOContext->wsabuf.buf,MAX_BUFF_SIZE);
                    lpIOContext->Overlapped.Internal = 0;
                    lpIOContext->Overlapped.InternalHigh = 0;
                    lpIOContext->Overlapped.Offset = 0;
                    lpIOContext->Overlapped.OffsetHigh = 0;
                    lpIOContext->Overlapped.hEvent = NULL;
                    lpIOContext->wsabuf.len = MAX_BUFF_SIZE;
                    nRet = WSARecv(
                                  lpIOContext->activeSocket,
                                  &lpIOContext->wsabuf, 1, &dwRecvNumBytes,
                                  &dwFlags,
                                  &lpIOContext->Overlapped, NULL);
                    if( nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()) ) {
                        cout << "WASRecv Failed::Reason Code::"<< WSAGetLastError() << endl;
                        closesocket(lpIOContext->activeSocket);
                        delete lpIOContext;
                        continue;
                    } 
                }
         }
    }
    return 0;
}

void main (int argc, char * argv[])
{
    { // Init winsock2
        WSADATA wsaData;
        ZeroMemory(&wsaData,sizeof(WSADATA));
        int retVal = -1;
        if( (retVal = WSAStartup(MAKEWORD(2,2), &wsaData)) != 0 ) {
            cout << "WSAStartup Failed::Reason Code::"<< retVal << endl;
            return;
        }
    }

    {  //Create socket
        g_ServerSocket = WSASocket(AF_INET,SOCK_STREAM, IPPROTO_TCP, NULL,0,WSA_FLAG_OVERLAPPED);

        if( g_ServerSocket == INVALID_SOCKET ) {
            cout << "Server Socket Creation Failed::Reason Code::" << WSAGetLastError() << endl;
            return;
        }
    }

    {   //bind
        sockaddr_in service;
        service.sin_family = AF_INET;
        service.sin_addr.s_addr = htonl(INADDR_ANY);
        service.sin_port = htons(5000);
        int retVal = bind(g_ServerSocket,(SOCKADDR *)&service,sizeof(service));
        if( retVal == SOCKET_ERROR ) {
            cout << "Server Soket Bind Failed::Reason Code::"<< WSAGetLastError() << endl;
            return;
        }
    }

    {   //listen
        int retVal = listen(g_ServerSocket, 8);
        if( retVal == SOCKET_ERROR ) {
            cout << "Server Socket Listen Failed::Reason Code::"<< WSAGetLastError() << endl;
            return;
        }
    }

    {   // Create IOCP
        SYSTEM_INFO sysInfo;
        ZeroMemory(&sysInfo,sizeof(SYSTEM_INFO));
        GetSystemInfo(&sysInfo);
        g_ThreadCount = sysInfo.dwNumberOfProcessors * 1;
        g_hIOCP = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,g_ThreadCount);
        if (g_hIOCP == NULL) {
            cout << "CreateIoCompletionPort() Failed::Reason::"<< GetLastError() << endl;
            return;            
        }

           if (CreateIoCompletionPort((HANDLE)g_ServerSocket,g_hIOCP,0,0) == NULL){
            cout << "Binding Server Socket to IO Completion Port Failed::Reason Code::"<< GetLastError() << endl;
            return ;    
        }
    }

    {  //Create worker threads
        for( DWORD dwThread=0; dwThread < g_ThreadCount; dwThread++ )
        {
            HANDLE  hThread;
            DWORD   dwThreadId;

            hThread = CreateThread(NULL, 0, WorkerThread, 0, 0, &dwThreadId);
            CloseHandle(hThread);
        }
    }

    { //accept new connection
        while(1)
        {
            SOCKET ls = accept( g_ServerSocket, NULL, NULL );
            if(ls == SOCKET_ERROR)  break;
            cout << "Client connected." << endl;

            { //diable buffer to improve performance
                int nZero = 0;
                setsockopt(ls, SOL_SOCKET, SO_SNDBUF, (char *)&nZero, sizeof(nZero));
            }

            if (CreateIoCompletionPort((HANDLE)ls,g_hIOCP,0,0) == NULL){
                cout << "Binding Client Socket to IO Completion Port Failed::Reason Code::"<< GetLastError() << endl;
                closesocket(ls);
            }
            else { //post a recv request
                IO_DATA * data = new IO_DATA;
                ZeroMemory(&data->Overlapped,sizeof(data->Overlapped));
                ZeroMemory(data->Buffer,sizeof(data->Buffer));
                data->opCode = IO_READ;
                data->nTotalBytes = 0;
                data->nSentBytes  = 0;
                data->wsabuf.buf  = data->Buffer;
                data->wsabuf.len  = sizeof(data->Buffer);
                data->activeSocket = ls;
                DWORD dwRecvNumBytes=0,dwFlags=0;
                int nRet = WSARecv(ls,&data->wsabuf, 1, &dwRecvNumBytes,
                                  &dwFlags,
                                  &data->Overlapped, NULL);
                if(nRet == SOCKET_ERROR  && (ERROR_IO_PENDING != WSAGetLastError())){
                    cout << "WASRecv Failed::Reason Code::"<< WSAGetLastError() << endl;
                    closesocket(ls);
                    delete data;
                }
            }
        }
    }

    closesocket(g_ServerSocket);
    WSACleanup();
}