用完成端口写的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();
}