IOCP基础封装

最新推荐文章于 2020-12-10 23:48:14 发布
最新推荐文章于 2020-12-10 23:48:14 发布
阅读量110 收藏
点赞数
文章标签： epoll 操作系统

前几篇文章介绍了集中linux epoll的封装方式，本篇回归windows，介绍一个IOCP的封装。

首先介绍要达到的目的:

1) 导出基本接口，作为一个更高层跨平台网络库的基础组件

2) 导出的接口用法与epoll版本大致相当，以方便日后的跨平台封装

3) 默认的使用方式是单线程的，与epoll一致。

 

下面是接口文件:

/*    
    Copyright (C) <2012>  <huangweilook@21cn.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/    
#ifndef _KENDYNET_H
#define _KENDYNET_H

//重叠结构
struct OverLapContext
{
    OVERLAPPED    m_overLapped;
    WSABUF*       wbuf;
    DWORD         buf_count;
    unsigned char m_Type;
};
struct Socket;

//socket的简单封装
typedef struct Socket
{
    SOCKET sock;
    HANDLE complete_port;
    void (*RecvFinish)(struct Socket*,struct OverLapContext*,DWORD);
    void (*SendFinish)(struct Socket*,struct OverLapContext*,DWORD);
}*Socket_t;

int    InitNetSystem();
void   CleanNetSystem();

HANDLE CreateNetEngine(DWORD NumberOfConcurrentThreads);
void   CloseNetEngine(HANDLE);
int    RunEngine(HANDLE,DWORD timeout);
int    Bind2Engine(HANDLE,Socket_t);

//now表示是否立即发起操作
int    WSA_Send(Socket_t,struct OverLapContext*,int now,DWORD *lastErrno);
int    WSA_Recv(Socket_t,struct OverLapContext*,int now,DWORD *lastErrno);



#endif

 

其中的Engine就是IOCP,使用方式就是RunEngine,在函数内部调用GetQueuedCompletionStatus以处理事件.事件处理完成后，

回调RecvFinish/SendFinish.在简单的单线程程序中，只需要创建一个engine,并在主线程调用RunEngine即可.当然，因为完成

队列其实是线程安全的，所以多个线程同时对一个IOCP调用engine也是可以的。但我不建议这么做，如果需要多线程，可以创建

N个engine和工作线程，各工作线程在自己的engine上执行RunEngine即可(与epoll版本一致).

下面贴出实现:

#include <winsock2.h>
#include <WinBase.h>
#include <Winerror.h>
#include "KendyNet.h"
#include "stdio.h"
enum
{
    IO_RECVREQUEST = 1<<1,   //应用层接收请求
    IO_SENDREQUEST = 1<<3,   //应用层发送请求
    IO_RECVFINISH =  1<<2,//接收完成
    IO_SENDFINISH =  1<<4,   //发送完成
};


enum
{
    IO_RECV = (1<<1) + (1<<2),
    IO_SEND = (1<<3) + (1<<4),
    IO_REQUEST = (1<<1) + (1<<3),
};

int    InitNetSystem()
{
    int nResult;
    WSADATA wsaData;
    nResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (NO_ERROR != nResult)
    {
        printf("\nError occurred while executing WSAStartup().");
        return -1; //error
    }
    return 0;
}
void   CleanNetSystem()
{
     WSACleanup();
}


HANDLE CreateNetEngine(DWORD NumberOfConcurrentThreads)
{
    HANDLE CompletePort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, NumberOfConcurrentThreads);
    if(NULL == CompletePort)
    {
        printf("\nError occurred while creating IOCP: %d.", WSAGetLastError());
    }
    return CompletePort;
}

void   CloseNetEngine(HANDLE CompletePort)
{
    CloseHandle(CompletePort);
}

static int raw_Send(Socket_t s,struct OverLapContext *overLapped,DWORD *lastErrno)
{
    DWORD dwFlags = 0;
    DWORD dwBytes = 0;
    int nBytesSend = WSASend(s->sock, overLapped->wbuf, overLapped->buf_count, 
        &dwBytes, dwFlags, (OVERLAPPED*)overLapped, NULL);

    if(SOCKET_ERROR == nBytesSend)
        *lastErrno = WSAGetLastError();
    return dwBytes;
}

static int raw_Recv(Socket_t s,struct OverLapContext *overLapped,DWORD *lastErrno)
{
    DWORD dwFlags = 0;
    DWORD dwBytes = 0;
    int nBytesSend = WSARecv(s->sock, overLapped->wbuf, overLapped->buf_count, 
        &dwBytes, &dwFlags, (OVERLAPPED*)overLapped, NULL);

    if(SOCKET_ERROR == nBytesSend)
        *lastErrno = WSAGetLastError();
    return dwBytes;
}


typedef void (*CallBack)(struct Socket*,struct OverLapContext*,DWORD);

int    RunEngine(HANDLE CompletePort,DWORD timeout)
{
    DWORD bytesTransfer;
    Socket_t       socket;
    struct OverLapContext *overLapped = 0;
    DWORD lastErrno = 0;
    BOOL bReturn;
    CallBack call_back;
    for( ; ; )
    {
        call_back = 0;
        bReturn = GetQueuedCompletionStatus(
            CompletePort,&bytesTransfer,
            (LPDWORD)&socket,
            (OVERLAPPED**)&overLapped,timeout);
        
        if(FALSE == bReturn || socket == NULL || overLapped == NULL)
        {
            break;
        }
        if(0 == bytesTransfer)
        {
            //连接中断
            if(overLapped->m_Type & IO_RECV)
                call_back = socket->RecvFinish;    
            else
                call_back = socket->SendFinish;
            bytesTransfer = 0;
        }
        else
        {
            if(overLapped->m_Type & IO_REQUEST)
            {
                overLapped->m_Type = overLapped->m_Type << 1;
                if(overLapped->m_Type  & IO_RECVFINISH)
                    bytesTransfer = raw_Recv(socket,overLapped,&lastErrno);
                else if(overLapped->m_Type  & IO_SENDFINISH)
                    bytesTransfer = raw_Send(socket,overLapped,&lastErrno);
                else
                {
                    //出错
                    continue;
                }

                if(bytesTransfer <= 0 && lastErrno != 0 && lastErrno != WSA_IO_PENDING)
                    bytesTransfer = 0;
                else
                    continue;
            }
        
            if(overLapped->m_Type & IO_RECVFINISH)
                call_back = socket->RecvFinish;
            else if(overLapped->m_Type & IO_SENDFINISH)
                call_back = socket->SendFinish;
            else
            {
                //出错
                continue;
            }
        }

        if(call_back)
            call_back(socket,overLapped,bytesTransfer);
    }
    return 0;
}

int    Bind2Engine(HANDLE CompletePort,Socket_t socket)
{
    HANDLE hTemp;
    if(!socket->RecvFinish || !socket->SendFinish)
        return -1;
    hTemp = CreateIoCompletionPort((HANDLE)socket->sock, CompletePort,(ULONG_PTR)socket, 0);
    if (NULL == hTemp)
        return -1;
    socket->complete_port = CompletePort;
    return 0;
}

int    WSA_Send(Socket_t socket,struct OverLapContext *OverLap,int now,DWORD *lastErrno)
{
    if(!socket->complete_port)
        return -1;
    ZeroMemory(&OverLap->m_overLapped, sizeof(OVERLAPPED));
    if(!now)
    {
        OverLap->m_Type = IO_SENDREQUEST;
        PostQueuedCompletionStatus(socket->complete_port,1,(ULONG_PTR)socket,(OVERLAPPED*)OverLap);
    }
    else
    {
        OverLap->m_Type = IO_SENDFINISH;
        return raw_Send(socket,overLapped,lastErrno);
    }
    return 0;
}

int    WSA_Recv(Socket_t socket,struct OverLapContext *OverLap,int now,DWORD *lastErrno)
{
    if(!socket->complete_port)
        return -1;
    ZeroMemory(&OverLap->m_overLapped, sizeof(OVERLAPPED));
    if(!now)
    {
        OverLap->m_Type = IO_RECVREQUEST;
        PostQueuedCompletionStatus(socket->complete_port,1,(ULONG_PTR)socket,(OVERLAPPED*)OverLap);
        return 0;
    }
    else
    {    
        OverLap->m_Type = IO_RECVFINISH;
        return raw_Recv(socket,overLapped,lastErrno);
    }
}

 

代码一点点，不做介绍了，下面是一个简单的echo测试

#include <stdio.h>
#include <winsock2.h>
#include <WinBase.h>
#include <Winerror.h>
#include "KendyNet.h"

struct connection
{
    struct Socket socket;
    WSABUF wsendbuf;
    WSABUF wrecvbuf;
    char   sendbuf[128];
    char   recvbuf[128];
    struct OverLapContext send_overlap;
    struct OverLapContext recv_overlap;
};

void RecvFinish(struct Socket *s,struct OverLapContext *overLap,DWORD bytestransfer)
{
    struct connection *c = (struct connection*)s;
    if(bytestransfer <= 0)
        free(c);
    else
    {
        DWORD lastErrno = 0;
        memcpy(c->sendbuf,c->recvbuf,bytestransfer);
        c->wsendbuf.len = bytestransfer;
        WSA_Send(s,&c->send_overlap,1,&lastErrno);
    }

}

void SendFinish(struct Socket *s,struct OverLapContext *overLap,DWORD bytestransfer)
{
    struct connection *c = (struct connection*)s;
    if(bytestransfer <= 0)
        free(c);
    else
    {
        DWORD lastErrno = 0;
        WSA_Recv((Socket_t)c,&c->recv_overlap,1,&lastErrno);
    }
}

struct connection* CreateConnection(SOCKET s)
{
    struct connection *c;
    c = malloc(sizeof(*c));
    ZeroMemory(c, sizeof(*c));
    c->socket.sock = s;
    c->socket.RecvFinish = &RecvFinish;
    c->socket.SendFinish = &SendFinish;
    c->wrecvbuf.buf = c->recvbuf;
    c->wrecvbuf.len = 128;
    c->recv_overlap.buf_count = 1;
    c->recv_overlap.wbuf = &c->wrecvbuf;

    c->wsendbuf.buf = c->sendbuf;
    c->wsendbuf.len = 0;
    c->send_overlap.buf_count = 1;
    c->send_overlap.wbuf = &c->wsendbuf;
    return c;
}


DWORD WINAPI Listen(void *arg)
{

    HANDLE *iocp = (HANDLE*)arg;
    HANDLE complete_port = *iocp;

    struct sockaddr_in    addr;
    int                         optval=1;                        //Socket属性值
    unsigned long               ul=1;
    struct linger lng;
    struct sockaddr_in ClientAddress;
    int nClientLength = sizeof(ClientAddress);
    struct connection *c;
    
    
    SOCKET ListenSocket;
    ListenSocket = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
    
    if (INVALID_SOCKET == ListenSocket) 
    {
        printf("\nError occurred while opening socket: %d.", WSAGetLastError());
        return 0;
    }
    
    addr.sin_family        = AF_INET;
    addr.sin_port        = htons(8010);
    addr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");


    setsockopt(ListenSocket,SOL_SOCKET,SO_EXCLUSIVEADDRUSE,(char*)&optval,sizeof(optval));  //禁止端口多用
    setsockopt(ListenSocket,IPPROTO_TCP,TCP_NODELAY,(char*)&optval,sizeof(optval));         //不采用延时算法 
    setsockopt(ListenSocket,SOL_SOCKET,SO_DONTLINGER,(char*)&optval,sizeof(optval));        //执行立即关闭
    
    lng.l_linger=0;
    lng.l_onoff=1;
    setsockopt(ListenSocket,SOL_SOCKET,SO_LINGER,(char*)&lng,sizeof(lng));
    //禁止重用本地端口
    if ((bind(ListenSocket, (struct sockaddr *)&addr, sizeof( struct sockaddr_in))) == SOCKET_ERROR)
    {
        closesocket(ListenSocket);
        return 0;
    }

    if((listen(ListenSocket, 5)) == SOCKET_ERROR)
    {
        closesocket(ListenSocket);
        return 0;
    }

    printf("listener 启动\n");

    while(1)
    {
        SOCKET client = accept(ListenSocket, (struct sockaddr*)&ClientAddress, &nClientLength);
        if (INVALID_SOCKET == client)
        {
            continue;
        }
        if(ioctlsocket(client,FIONBIO,(unsigned long*)&ul)==SOCKET_ERROR)
        {
            closesocket(client);
            continue;
        }

        c = CreateConnection(client);
        Bind2Engine(complete_port,(Socket_t)c);
        //发出第一个读请求
        WSA_Recv((Socket_t)c,&c->recv_overlap,0,0);

    }

    return 0;
}

int main()
{
    HANDLE iocp;
    DWORD dwThread;
    InitNetSystem();
    iocp = CreateNetEngine(0);
    
    
    CreateThread(NULL,0,Listen,&iocp,0,&dwThread);
    
    while(1)
        RunEngine(iocp,10);
    return 0;
}
weixin_34189116
关注
iocp封装类
03-09
iocp完成端口的封装，使用TCP的IOCP实现,可以传送大消息包、文件,同一客户端可以同时发送多个文件 // 1、用TClients创建一个对象，pClients // 2、调用pClients->CreateClient(...)函数，参数1、2是要连接的服务端IP和端口， // 3服务端返回消息的事件回调处理函数，4是服务端断开连接的事件回调处理函数 // 3、调用pClients->SendMsg(...)给对端发消息 // 4、调用pClients->SendFile(...)给对端发文件 // 5、调用pClients->Disconnet(...)主动断开连接 // 6、销毁pClients对象
windows iocp网络通讯库封装
11-24
windows iocp网络通讯库封装
最精简的IOCP封装
weixin_30621959的博客
07-23 152
最精简的IOCP封装，DELPHI XE8直接编译通过。Winsock2.pas即使用DELPHI自带的，相信XE7也能编译，或者XE6,XE5也能。 单说Winsock2.pas，我见过无数种版本的了，各版本WINSOCK 2的API的方法的参数的数据类型居然都有出入，使用不同人封装的Winsock2.pas源码都要进行相应的调整， 否则无法编译通过，我认为还是使用DELPHI官方的最为靠谱...
游戏服务端IOCP模型，自己封装的一个类，3行代码搞定服务端。
记事本
11-26 2010
#pragma once #include #define IP_SIZE 32 //ip地址长度 #define BUFFER_SIZE 1024 #include #include enum SOCKET_STATE { ACCEPT = 1, SEND, RECV }; /*传送给处理函数的参数*/ typedef struct tagPleData { SOCK
65000个有效连接的IOCP封装类
pud_zha的专栏
12-26 869
关于这个类的几点总结： 1.发送数据最大限制在MTU之类 2.使用PreAllocate,分配内存时，同时为每片内存附加一个小结构体，指明该内存是否被使用，在析构时，只是设定为未使用，以使内存复用 3.在Server端启动之前，先准备内存，并使用AcceptEx,缓冲大小设为0 4.将数据的接收和处理分开在不同的线程处理 5. DWORD WINAPI WorkerThreadDumm
ACE IOCP封装
07-28
`iocp_server`类是ACE对IOCP模型的抽象，它为开发者提供了一个基础框架，只需通过继承并实现特定接口，就能快速构建出自己的服务器应用。 在`iocp_server.cpp`和`iocp_server.h`这两个文件中，我们可以看到`iocp_...
iocp服务器封装
04-11
1. 创建IOCP：使用`CreateIoCompletionPort`函数创建IOCP对象，这是整个IOCP机制的基础。 2. 关联设备句柄：将网络套接字或其他设备句柄与IOCP关联，使得设备的I/O操作完成后能够通知IOCP。 3. 启动工作线程：创建一...
IOCP 完成端口模型简单封装
11-04
综上所述，IOCP完成端口模型的简单封装提供了一个基础框架，开发者可以根据具体需求进行扩展和完善，以实现更高效的网络服务。通过理解并熟练掌握IOCP模型，开发者可以构建出能够处理海量并发请求的高性能服务器。
vc以IOCP完成端口方式实现网络数据传输 iocp服务器+客户端.zip
04-18
1. IOCP基础： IOCP是Windows系统提供的一个机制，它允许多个线程共享一个I/O端口，处理来自多个I/O操作的完成通知。这种模型提高了系统资源利用率，减少了上下文切换的开销，特别适合于处理大量并发连接的网络...
IOCP.rar_IOCP_IOCP C++类_IOCP类 c++
09-14
在IOCP的基础上，开发者可以构建出复用性高的通信框架，如标题中的"IOCP C++类"。这种框架通常包括客户端和服务端两部分，通过TCP/IP协议进行通信。客户端用于发起连接请求和发送数据，服务端则负责接收连接和处理...
公认不错的IOCP封装类
11-12
我们的一个项目的服务器端通信层，IOCP类是在此基础上写的，使用了近半年，并发量不大，1k上下，（不过曾做过压力测试，10k的并发量没有问题）还算比较稳定，基本上满足需求。
使用IOCP完成端口和SOCKET封装的成熟异步TCP类
01-18
使用IOCP完成端口和SOCKET封装的异步TCP类。 支持客户端和服务器的常用TCP接口：绑定Bind、监听Listen、接收Recv、连接Conn、发送Send、关闭Close。所有接口均使用异步回调的方式处理，内部实现使用Windows下性能最高的IOCP完成端口网络模型，并很好地处理了多线程安全和同步问题。 线程创建和事件信号量等地方用到了MFC的类，如果项目不支持MFC，可以把这些地方替换成WindowsAPI的方式。 代码是从成熟项目中分离出来的，能达到很高的性能和网络吞吐量，并且稳定无BUG。
高度封装的 IOCP库
06-13
决定写一个IOCP，封装的很好的，这是一个库，请在VC2010下编译。 客户端和服务器都适用，但是只完成了TCP的部分，没有完成UDP的部分。 面向对象的方式编写。 包含连接器，内存管理，等模块。 无协议模块
Iocp_V7,IOCP封装类(DLL)第七次改版.
07-09
由于兼容问题,不再使用Lib形式的封装,使用DLL 去掉0缓冲,接收数据大小有限制 IOCP只负责接收前256字节,剩下的根据自定义协议(肯定知道包的大小)再recv 添加Connect函数,所以此IOCP不仅可以作为服务端,同时也可以作为客户端 VC++可以直接使用Lib使用函数,其他版本请动态调用。
大宝版本IOCP封装类
07-07
很不容易找到的大宝的IOCP服务器代码，庆祝自己资源分过1000.贡献给大家。
python iocp_Python封装IOCP | 学步园
weixin_39936388的博客
12-10 212
2011-07-22：源码下载：http://blog.csdn.net/jgood/article/details/6626872Python是一门简洁而优雅的语言，她的高生产率使我们能用最少的人力、物力、时间、财力代价解决眼前的问题。但是当解决了眼前的问题，一些更长远的问题就不得不考虑。利用Python自带的socket模块写网络服务器程序，很难能够承受上千个连接。我曾经参考赖勇浩同学的Net...
一 个 封 装 了 IOCP 的 DLL
赖建全
05-06 2241
======================= 一 个 封 装 了 IOCP 的 DLL ====================================设计想法： 1、IOCP的DLL实现内存自制，既内存DLL自我管理，用户申请内存，用户释放，DLL的内存，用户不得释放 2、用户至少需要提供三个LPTHREAD_START_ROUTINE类型的指针，用户处理接收数据、接受客户端连接、
IOCP的封装和使用
zhangqizeng的专栏
07-02 2863
最近在codeproject上面闲逛，看到一篇关于他自己封装的IOCP类的讲解的文章，感觉挺通俗易懂的， 不得不感叹，外国人的无私奉献精神，这是我们缺少的呀，闲话少说，特此翻译一下，再次感谢文章的贡献者， sleepyrea，以及codeproject上面的地址附上http://www.codeproject.com/Articles/11419/IOCPNet-Ultimate-IOCP
再次封装IOCP的收获
01-17 4680
    以前写过一篇用python封装IOCP的文章，这几天因朋友需要，再一次封装了iocp接口。这一次我并不是简单的把原有代码拿过来简单的修修改改，基本上是推到重来。改正第一次封装时的许多缺点，同时修正了许多bug，再回首看以前的代码，感觉自己在进步。这次封装iocp，收获了以下几点知识： 1. 数据的重复投递。一般情况下，一个Socket句柄在同一时刻最多只能有一次WSASend与SWARe
基于IOCP的C++ Socket类封装与应用
资源摘要信息: "本资源提供了一个基于C++语言实现的封装了Socket完成端口（IOCP，Input/Output Completion Ports）模型的类库，便于开发者在Windows平台上开发高性能的网络服务程序和客户端应用。IOCP模型是Windows...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值