完成端口实现echo tcp server

 

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


#define PORT 5150
#define DATA_BUFSIZE 8192
/*
 *无论何时调用重叠操作函数时，总是会通过其lpOverlapped参数传递一个OVERLAPPEDPLUS结构
 *(例如WSASend、 WSARecv等函数)。这就允许你为每一个重叠调用操作设置某些操作状态信息，
 *当操作结束后，你可以通过GetQueuedCompletionStatus()函数获得你自定义结构的指针。
 */
typedef struct  
{
    OVERLAPPED Overlapped;
    WSABUF     dataBuf;
    char       buffer[DATA_BUFSIZE];
    int        OpCode;//传递操作码
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

#define OP_READ   0
#define OP_WRITE  1
#define OP_ACCEPT 2

//单句柄数据
typedef struct  
{
    SOCKET Socket;
}PER_HANDLE_DATA,* LPPER_HANDLE_DATA;



DWORD WINAPI ServerWorkerThread(void* completionPortID);

int main(int argc, char* argv[])
{
    SOCKADDR_IN serverAddr;
    SOCKET listenSocket;
    SOCKET acceptSocket;
    HANDLE completionPort;
    WSADATA wsaData;
    if(WSAStartup(0x0202, &wsaData) != 0)
    {
      printf("WSAStartup failed with error  ");
      return -1;
    }
    //建立完成端口
    if((completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,0)) == NULL)
    {
        printf( "CreateIoCompletionPort failed with error: %d ", GetLastError());
        return -1;
    }

    SYSTEM_INFO systemInfo;
    GetSystemInfo(&systemInfo);
    DWORD threadID;

    //创建工作者线程
    for(int i = 0; i < systemInfo.dwNumberOfProcessors*2; i++)
    {
        HANDLE threadHandle;
        if((threadHandle = CreateThread(NULL,0,ServerWorkerThread,completionPort,0,&threadID)) == NULL)
        {
            printf("CreateThread() failed with error %d ", GetLastError());
            return -1;
        }
        CloseHandle(threadHandle);
    }
    

    if ((listenSocket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0,
      WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)
    {
      printf("WSASocket() failed with error %d ", WSAGetLastError());
      return -1;
    } 


    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(PORT);

    if(bind(listenSocket,(sockaddr*)&serverAddr,sizeof(serverAddr)) == SOCKET_ERROR)
    {
        printf("bind() failed with error %d ", WSAGetLastError());
        return -1;
    }

    if (listen(listenSocket, 10) == SOCKET_ERROR)
    {
      printf("listen() failed with error %d ", WSAGetLastError());
      return -1;
    }
    
    for(;;)
    {
        
        if((acceptSocket = WSAAccept(listenSocket,NULL,NULL,NULL,0)) == SOCKET_ERROR)
        {
            printf("WSAAccept() failed with error %d ", WSAGetLastError());
            return -1;
        }
    
        LPPER_HANDLE_DATA perHandleData = (LPPER_HANDLE_DATA)GlobalAlloc(GPTR, sizeof(PER_HANDLE_DATA));
        printf("socket number %d connected ",acceptSocket);
        perHandleData->Socket = acceptSocket;

        //新套接字句柄同完成端口关联到一起。
        //通过完成键（CompletionKey）参数，将单句柄数据结构传递给完成端口。
        if(CreateIoCompletionPort((HANDLE)acceptSocket,completionPort,(DWORD)perHandleData,
            0) == NULL)
        {
            printf("CreateIoCompletionPort failed with error %d ", GetLastError());
            return -1 ;
        }
        

        //为重叠调用建立单I/O操作数据
        LPPER_IO_OPERATION_DATA perIoData;
        perIoData = (LPPER_IO_OPERATION_DATA)GlobalAlloc(GPTR,sizeof(PER_IO_OPERATION_DATA));
        memset(&perIoData->Overlapped,0,sizeof(OVERLAPPED));
        perIoData->dataBuf.len = DATA_BUFSIZE;
        perIoData->dataBuf.buf = perIoData->buffer;
        perIoData->OpCode = OP_READ; //读操作

        /* 开始在接受套接字上处理I/O
         * 使用重叠I/O机制，在新建的套接字上投递一个或多个异步
         * WSARecv 或 WSASend请求。这些I/O请求完成后，工作者线程
         * 会为I/O请求提供服务。
         */ 
        DWORD recvBytes;
        DWORD flags = 0;
        WSARecv(acceptSocket,
                &(perIoData->dataBuf),
                1,
                &recvBytes,
                &flags,
                &(perIoData->Overlapped),
                NULL);    
     }
    
    return 0;
}


DWORD WINAPI ServerWorkerThread(void* completionPortID)
{
    HANDLE completionPort = (HANDLE)completionPortID;
    DWORD bytesTransferred;
    //LPOVERLAPPED Overlapped;
    LPPER_HANDLE_DATA perHandleData;
    LPPER_IO_OPERATION_DATA perIoData;
    while(true)
    {
        if(GetQueuedCompletionStatus(completionPort,&bytesTransferred,
            (LPDWORD)&perHandleData,(LPOVERLAPPED*)&perIoData,INFINITE) == 0)
        {
            printf("GetQueuedCompletionStatus failed with error %d ", GetLastError());
            return 0;
        }
        if(bytesTransferred == 0)
        {
            printf("Closing socket %d ",perHandleData->Socket);
            closesocket(perHandleData->Socket);
            GlobalFree(perHandleData);
            GlobalFree(perIoData);
            continue;
        }

        switch (perIoData->OpCode)    
        {   
        case OP_ACCEPT:       
                break;                   
        case OP_WRITE://写完成        
             {            
                // 为下一个重叠调用建立单I/O操作数据
                memset(&perIoData->Overlapped,0,sizeof(OVERLAPPED));
                perIoData->dataBuf.len = DATA_BUFSIZE;
                perIoData->dataBuf.buf = perIoData->buffer;
                perIoData->OpCode = OP_READ; //读操作        
                DWORD recvBytes;
                DWORD flags = 0;
                WSARecv(perHandleData->Socket,
                    &(perIoData->dataBuf),
                    1,
                    &recvBytes,
                    &flags,
                    &(perIoData->Overlapped),
                    NULL);    
                break;
            } 
        case OP_READ://读完成
            {    
                printf("recive socket %d :%s ",perHandleData->Socket,perIoData->buffer);
                //为下一个重叠调用建立单I/O操作数据
                //将接收到的数据echo 回去
                memset(&perIoData->Overlapped,0,sizeof(OVERLAPPED));
                perIoData->dataBuf.buf = perIoData->buffer;
                perIoData->dataBuf.len = bytesTransferred;                
                perIoData->OpCode = OP_WRITE; //写操作        
                DWORD bytesSend;
                DWORD flags = 0;                            
                WSASend(perHandleData->Socket,&(perIoData->dataBuf),1,&bytesSend,
                    0,&(perIoData->Overlapped),0);                
                break;
            }        

        }
    }
    
}