单进程单线程IOCP的实现（含客户端和服务端）

server.cpp

// TestIOCPone.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#define _WINSOCK_DEPRECATED_NO_WARNINGS

#include <iostream>
#include <winsock2.h>
#include <process.h>
#include <MSWSock.h>
#include <assert.h>
#include <vector>

#pragma comment(lib ,"ws2_32.lib")

HANDLE hIocp = 0;
LPFN_ACCEPTEX accept_ex;

SOCKET listen_socket;




enum CPK_TYPE {
    ACCEPT_POST = 1000, //接收请求的完成标识
    RECV_POST,
    SEND_POST,
    CLOSE_POST,
};


class io_context : public OVERLAPPED
{
public:
    io_context() {
        memset(static_cast<OVERLAPPED *>(this), 0, sizeof(OVERLAPPED));
        client_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        buf_ = new char[4096];
        w_buf_.buf = buf_;
        w_buf_.len = 4096;
    }
    virtual ~io_context() {

    }

    int op_code = 0;
    WSABUF w_buf_;
    char* buf_;
    SOCKET client_socket;
};




void init_func(int s) {
    GUID guidAcceptEx = WSAID_ACCEPTEX;
    DWORD bytes = 0;
    if (WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &guidAcceptEx,
        sizeof(GUID), &accept_ex, sizeof(LPFN_ACCEPTEX), &bytes, NULL,
        NULL) == SOCKET_ERROR)
    {
        throw std::exception("get acceptex error:", GetLastError());
    }
}



void post_accept()
{


    io_context* pIoContent = new io_context;

    pIoContent->op_code = ACCEPT_POST;

    DWORD len = 0;

    if (!accept_ex(listen_socket, pIoContent->client_socket, pIoContent->buf_, 0,
        sizeof(sockaddr_in) + 16, sizeof(sockaddr_in) + 16, &len,
        pIoContent)) {
        if (WSA_IO_PENDING != WSAGetLastError())
        {
            throw std::exception("accept_ex error:", GetLastError());
        }
    }
}

void post_recv(io_context* p_io_content)
{
    DWORD recv_len = 0;
    DWORD flags = 0;
    p_io_content->op_code = RECV_POST;

    if (WSARecv(p_io_content->client_socket, &p_io_content->w_buf_,
        1, &recv_len, &flags, p_io_content, NULL) == SOCKET_ERROR) {
        if (WSAGetLastError() != WSA_IO_PENDING)
        {
            throw std::exception("recv error:", GetLastError());
        }
    }
}

void post_send(io_context* p_io_content, const char* data, int len)
{
    DWORD send_len = 0;
    DWORD flags = 0;

    p_io_content->op_code = SEND_POST;
    memcpy(p_io_content->w_buf_.buf, data, len);

    p_io_content->w_buf_.len = len;

    if (WSASend(p_io_content->client_socket, &p_io_content->w_buf_,
        1, &send_len, flags, p_io_content,
        NULL) == SOCKET_ERROR) {
        if (WSAGetLastError() != WSA_IO_PENDING)
        {
            throw std::exception("send error:", GetLastError());
        }
    }
}

void do_something()
{
    //做其他事情
}

unsigned int __stdcall work_thread(void* lParam)
{
    LPOVERLAPPED overlapped = NULL;
    ULONG_PTR cl_key = 0;
    DWORD recv_bytes = 0;
    while (true) {
        do_something();

        BOOL ret = GetQueuedCompletionStatus(hIocp, &recv_bytes, &cl_key,
            &overlapped, 0);



        if (ret) {
            if (CLOSE_POST == cl_key) {
                std::cout << "close & break " << std::endl;
                break;
            }

            std::cout << "recv_bytes=" << recv_bytes << std::endl;
            io_context* p_io_content = (io_context*)overlapped;

            if (p_io_content->op_code == SEND_POST) {
                std::cout << "send data ok" << std::endl;
                PostQueuedCompletionStatus(hIocp, 0, CLOSE_POST, 0);
            }

            if (p_io_content->op_code == RECV_POST) {
                std::cout << p_io_content->buf_ << std::endl;


                const char* data = "hello from server........";
                post_send(p_io_content, data, strlen(data));


            }

            if (ACCEPT_POST == cl_key) {
                std::cout << "1" << std::endl;
                post_accept();

                if (!CreateIoCompletionPort((HANDLE)p_io_content->client_socket, hIocp, NULL,
                    1)) {
                    throw std::exception("bind listen to iocp", GetLastError());
                }

                post_recv(p_io_content);
            }



        }
        else
        {
            Sleep(1);
        }
    }

    return 0;
}

int main()
{
    WSADATA wsa;
    WSAStartup(MAKEWORD(2, 2), &wsa);

    listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    assert(listen_socket != INVALID_SOCKET);
    sockaddr_in addr = { 0 };
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    addr.sin_port = htons(12345);

    if (0 != bind(listen_socket, (struct sockaddr *)&addr, sizeof(sockaddr))) {
        throw std::exception("bind error", GetLastError());
    }
    int work_thread_num_ = 1;
    hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL,
        work_thread_num_);
    if (!hIocp) {
        throw std::exception("create iocp error", GetLastError());
    }
    init_func(listen_socket);
    listen(listen_socket, 0);


    post_accept();

    if (!CreateIoCompletionPort((HANDLE)listen_socket, hIocp, ACCEPT_POST, work_thread_num_)) {
        throw std::exception("bind listen to iocp", GetLastError());
    }

    work_thread(NULL);


    WSACleanup();

}

client.cpp

#define _WINSOCK_DEPRECATED_NO_WARNINGS

#include <iostream>
#include <winsock2.h>

#pragma comment(lib ,"ws2_32.lib")

int main()
{
    WSADATA wsa;
    WSAStartup(MAKEWORD(2, 2), &wsa);

    sockaddr_in client_addr;
    client_addr.sin_family = AF_INET;
    client_addr.sin_port = htons(12345);
    client_addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");

    SOCKET     client_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (0 == connect(client_socket, (const sockaddr*)&client_addr, sizeof(client_addr))) {
        const char* pbuf = "client=> server...";
        char buf[256] = { 0 };
        Sleep(1000);
        int len = ::send(client_socket, pbuf, strlen(pbuf), 0);
        if (len > 0) {
            std::cout << "send len=" << len << std::endl;
            len = ::recv(client_socket, buf, 256, 0);
            if (len > 0) {
                std::cout <<"len=" << len << " data=" << buf << std::endl;
            }
        }

    }
    Sleep(1000);
    closesocket(client_socket);


    WSACleanup();
    return 0;
}