最新版IOCP_API来袭，你准备好了吗？

最新推荐文章于 2021-06-03 17:40:38 发布
最新推荐文章于 2021-06-03 17:40:38 发布
阅读量1.4k 收藏
点赞数
分类专栏： windows 网络编程 文章标签： api iocp socket windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shenyi0106/article/details/47748453
版权
经历了两三年的沉寂之后，最新版IOCP_API网络编程库终于要来了。它沿袭了1.X版本的简洁设计和简单接口，并且提供更高的效率和更多的扩展功能。
最为关键的是——开源，我会毫无保留的奉送全部源码，coder们可以任意修改发布，而不需要支付一毛钱的版权。
你还在等什么，赶快来下载试用吧。


最新版IOCP_API为2.4版，相比较前面的版本（1.X版本），新版带来了如下好处：
1. 最新的API，数量只有十几个，涵盖了所有应用；也就是说，你仅仅通过这几个API，即可完成整个网络编程框架的搭建。简洁，方便是它与众不同之处。
2. 更高的效率；2.4版IOCP_API库经过优良的设计，使用一个IOCP核心（工作者线程组+内存池+业务线程池）即可完成所有的网络传输应用。
   你可以再这个核心上，跑任意数量的TCP服务器，跑任意数量数量的TCP客户端，还可以跑任意数量的UDP服务，甚至你还可以将他们混合来使用。
   这些都是在一个核心上完成的。不要羡慕，你已经拥有它了。
3. 更多的扩展功能； 除了传统的TCP和UDP外，2.4版IOCP_API库更是提供了Channel服务，让你无需担心大数据的拆包和组包业务，它完美的帮您处理了。
   你认为只有这些？不！还有更多的扩展功能——P2P、UDT和RPC，你是不是已经迫不及待了？
4. 一定的可扩展性；相比1.X版，2.4版提供可一个可编程的内存池接口，您如果觉得我提供的缺省内存池不够完美，您大可以自己实现一个，是不是很棒？！
5. 更简单的数据处理接口；所有的数据都是通过一个接口通知您来处理，不管是传统的TCP和UDP数据包，还是扩展的Channel数据包，您只要关心您注册
   的数据处理接口即可，其他的都交给2.4吧。去喝杯咖啡如何？
6. 更人性化和实用化的设计；您一定有过这样的经历，在一个异步网络架构的应用中，您因为一些特殊原因，需要一个同步接口，那是一件多么烦人的事情啊！
   现在好了，有了2.4，这一切都解决了，它提供了RPC接口，可以满足您的这个要求。同时由于它是用的异步模拟的同步的方式，所以也无需担心它的效率问题。
7. 更多的实用工具；除了提供便捷的网络编程接口外，2.4还提供很多实用工具，比如一个DBPool（基于ADO组件）——让你随心所欲的使用数据库；
   一个zlib压缩组件，一个FIFO队列等等，都是您编写网络程序必不可少的。


是不是很期待了？下面，我们来解开庐山真面路，走进IOCP_API。

在IOCP_API.h中定义的所有的编程库所提供接口API，下面是接口API列表：

IOCP_API HANDLE       IOCPStartup(INT iWorkThread, INT iThreadPool);
IOCP_API RetCode      IOCPCleanup(HANDLE hIocp);

IOCP_API ICache*      IOCPCreateCache(INT iMinNum, INT iMaxNum);
IOCP_API RetCode      IOCPDestroyCache(ICache *pCache);

IOCP_API TCPListener* IOCPCreateListener(HANDLE hIocp, INT iBindPort);
IOCP_API TCPSocket*   IOCPCreateClient(HANDLE hIocp, INT iBindPort);
IOCP_API UDPSocket*   IOCPCreateSocket(HANDLE hIocp, INT iBindPort);
IOCP_API RetCode      IOCPDestorySocket(Socket* pSocket, SocketType sockType);

IOCP_API ADOPool*     IOCPCreatePool(INT nMinPoolSize, INT nMaxPoolSize, const CHAR *pszConnStr);
IOCP_API RetCode      IOCPDestoryPool(ADOPool *pAdoPool);

IOCP_API RetCode      IOCPUnhandledException(IExceptionHandle *exception);

IOCP_API ILogger*     IOCPCreateLogger(const CHAR *pszLogPath);
IOCP_API RetCode      IOCPDestoryLogger(ILogger *pLogger);

IOCP_API IBuffer*     IOCPCreateQueue(INT nCapacity);
IOCP_API RetCode      IOCPDestoryQueue(IBuffer *pBuffer);
看到这些接口，是不是觉得如此高效的网络编程接口竟然如此简单？答案却是如此，就是如此简单。您不需要了解IOCP的原理，甚至都不需要了解
网络通讯的原理，通过这些接口，您只要关心您的业务逻辑即可，其他的，都交给2.4吧。


与这些API相对应，在ISocket.h文件中，定义了相关的接口类，把相关功能都进行了封装，完全面向对象的编程方式，更适合传统的C++ coder们。 

//
// 返回值
//
enum RetCode
{
	RET_ESUC     =  0,  //成功
	RET_EFAILED  = -1,  //失败
	RET_EEXIST   = -2,  //已存在
	RET_ENOEXIST = -3,  //不存在
	RET_EARGS    = -4,  //参数错误
	RET_ECALLAPI = -5,  //函数调用错误
	RET_ENOINIT  = -6,  //未初始化
	RET_ENOMEM   = -7,  //内存不足
	RET_ENOBUF   = -8,  //缓冲区不足
	RET_ECHKSUM  = -9,  //效验和错误
	RET_EUNFIN   = -10, //未完成
	RET_ECLOSE   = -11, //已关闭
	RET_ETIMEOUT = -12, //超时
	RET_EDISCONN = -13, //断线
};

//
// Socket类型
//
enum SocketType
{
	ST_NONE   = 0,
	ST_TCP    = 1, //SOCK_STREAM
	ST_UDP    = 2, //SOCK_DGRAM
	ST_LISTEN = 3, //TCP SERVER
};

//
// Socket基础类，TCPListener,TCPSocket和UDPSocket的的父类
//
class Socket
{
public:
	Socket()
	{
		m_pSocketListener = NULL;
		m_pCache = NULL;
		m_hIocp = NULL;
		m_socketType = ST_NONE;
		m_hSocket = INVALID_SOCKET;
		m_pLogger = NULL;
	}

	~Socket()
	{
		CloseSocket();
	}

public:
	//
	// 根据指定类型创建TCP或者UDP Socket
	//
	RetCode CreateSocket(SocketType socketType)
	{
		INT opt = 0;

		if (m_hSocket != INVALID_SOCKET)
		{
			return RET_EEXIST;
		}

		m_socketType = socketType;
		if (m_socketType == ST_NONE) 
		{
			return RET_EARGS;
		}

		if (m_socketType == ST_TCP)
		{	
			opt = 0;
			m_hSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);

			setsockopt(m_hSocket, SOL_SOCKET, SO_SNDBUF, (CHAR*)&opt, sizeof(INT));
			setsockopt(m_hSocket, SOL_SOCKET, SO_RCVBUF, (CHAR*)&opt, sizeof(INT));
		}
		else
		{
			m_hSocket = WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, WSA_FLAG_OVERLAPPED);

			opt = 1;
			setsockopt(m_hSocket, SOL_SOCKET, SO_BROADCAST, (CHAR*)&opt, sizeof(INT));

			opt = 64 * 1024;
			setsockopt(m_hSocket, SOL_SOCKET, SO_SNDBUF, (CHAR*)&opt, sizeof(INT));
			setsockopt(m_hSocket, SOL_SOCKET, SO_RCVBUF, (CHAR*)&opt, sizeof(INT));
		}

		return (m_hSocket != INVALID_SOCKET) ? RET_ESUC : RET_EFAILED;
	}

    //
	//关闭Socket
	//
	RetCode CloseSocket(VOID)
	{
		if (m_hSocket != INVALID_SOCKET)
		{
			CancelIo((HANDLE)m_hSocket);
			Sleep(500);
			closesocket(m_hSocket);
			Sleep(500);
			m_socketType = ST_NONE;
			m_hSocket = INVALID_SOCKET;
		}
		return RET_ESUC;
	}

	//
	//将Socket绑定到指定端口
	//
	RetCode Bind(INT iPort)
	{
		SOCKADDR_IN bindAddr;

		if (m_hSocket == INVALID_SOCKET)
		{
			return RET_ENOINIT;
		}
		//绑定本地端口
		memset(&bindAddr,0,sizeof(SOCKADDR_IN));
		bindAddr.sin_family = AF_INET;
		bindAddr.sin_addr.s_addr = htonl(INADDR_ANY);
		bindAddr.sin_port = htons(iPort);
		if (bind(m_hSocket, (PSOCKADDR)&bindAddr, sizeof(bindAddr)) == SOCKET_ERROR)
		{
			CloseSocket();
			return RET_ECALLAPI;
		}
		return RET_ESUC;
	}

	//
	//开始监听客户端连接
	//
    RetCode Listen(VOID)
	{
		if (IsValidSocket() == FALSE)
		{
			return RET_ENOINIT;
		}

		if (m_socketType != ST_TCP)
		{
			return RET_EARGS;
		}

		if (listen(m_hSocket, SOMAXCONN) == SOCKET_ERROR)
		{
			CloseSocket();
			return RET_ECALLAPI;
		}

		return RET_ESUC;
	}

	//
	// 设置端口重用
	//
	RetCode ReUseAddr(BOOL bReUse)
	{
		if (IsValidSocket() == FALSE)
		{
			return RET_ENOINIT;
		}

		if (m_socketType != ST_TCP)
		{
			return RET_EARGS;
		}

        return 
			(setsockopt(Handle(), SOL_SOCKET, SO_REUSEADDR, (const char*)&bReUse, sizeof(BOOL)) != SOCKET_ERROR) ? RET_ESUC : RET_ECALLAPI;
	}

	//
	// 设置Socket属性
	//
	RetCode SetSockOpt(INT nLevel, INT nOptName, const CHAR *pszOptVal, INT nOptLen)
	{
		INT nRet = 0;

		if (IsValidSocket() == FALSE)
		{
			return RET_ENOINIT;
		}
		
	    nRet = setsockopt(Handle(), nLevel, nOptName, pszOptVal, nOptLen);
		return (nRet != SOCKET_ERROR) ? RET_ESUC : RET_ECALLAPI;
	}

	//
	//获得Socket的句柄
	//
	SOCKET Handle(VOID) { return m_hSocket; }

	//
	//判断Socket是否有效
	//
	BOOL IsValidSocket(VOID) { return (m_hSocket != INVALID_SOCKET); }

	//
	//设置完成端口句柄
	//
	VOID IOCP(HANDLE hIocp) { m_hIocp = hIocp;}

	//
	//获取完成端口句柄
	//
	HANDLE IOCP() { return m_hIocp; }

	//
	//获取当前Socket的类型(TCP或者UDP)
	//
    SocketType ClientType(VOID) { return m_socketType;}

	//
	//设置内存池对象,用来为Socket内部分配内存
	//
	VOID Cache(ICache *pCache) { m_pCache = pCache; }

	//
	//获取内存池对象
	//
	ICache* Cache() {return m_pCache; }

	//
	//设置事件监听器
	//
	VOID SocketListener(ISocketListener *pSocketListener) { m_pSocketListener = pSocketListener; }

	//
	//获取事件监听器
	//
    ISocketListener* SocketListener(VOID) { return m_pSocketListener; }

	//
	// 设置日志对象
	//
	VOID Logger(ILogger *pLogger) { m_pLogger = pLogger; }

	//
	// 获取日志对象
	//
	ILogger* Logger(VOID) { return m_pLogger; }

protected:
    ISocketListener    *m_pSocketListener;    //事件监听器对象
	ICache             *m_pCache;             //内存池对象
	HANDLE              m_hIocp;              //完成端口句柄
    SocketType          m_socketType;         //当前Socket的类型
	SOCKET              m_hSocket;            //当前Socket的句柄
	ILogger            *m_pLogger;            //日志输出接口
};


//
// Socket操作选项
// 在ISocket的OnError时，提供当前Socket的什么操作
// 导致的错误发生
//
enum SocketOption
{
	SO_ACCEPT	= 1,	// Acccept
	SO_CONNECT	= 2,	// Connnect
	SO_SEND		= 3,	// Send
	SO_SENDTO   = 4,    // SendTo
	SO_RECEIVE	= 5,	// Receive
	SO_RECVFROM = 6,    // ReceiveFrom
	SO_UNKNOWN	= 7,	// Unknown
};

//
// 事件监听器接口类
//
class ISocketListener
{
public:
	virtual ~ISocketListener() {}

public:
	//
	//当发生错误后,它会被调用;pClient是发生错的的Socket对象
	//
	//注意:
	//底层框架会自动管理这个对象,并处理对应错误,
	//这里通知调用者的目的是希望调用者去处理自己业务逻辑相关的变更
	//
	virtual RetCode OnError(Socket *pClient, SocketOption SockOpt, DWORD iErrorCode) = 0;

	//
	//当连接关闭后,它会被调用;pClient是关闭的Socket对象
	//
	//注意:
	//底层框架会自动管理这个对象,
	//这里通知调用者的目的是希望调用者去处理自己业务逻辑相关的变更
	//
	virtual RetCode OnClose(Socket *pClient) = 0;

	//
	//当连接成功后,它会被调用;pClient是连接成功的Socket对象
	//
	//注意:
	//底层框架会自动管理这个对象,
	//这里通知调用者的目的是希望调用者去处理自己业务逻辑相关的变更
	//
	virtual RetCode OnConnect(Socket *pClient) = 0;

	//
	//当数据发送成功后(TCP),它会被调用;pClient是发送数据的Socket对象
	//iTotalLen要发送的长度, iLeftLen还剩下多少数据没发送
	//
	//注意:
	//底层框架会自动管理这个对象,
	//这里通知调用者的目的是希望调用者去处理自己业务逻辑相关的变更
	//
	//当连接上服务器(客户端)或者有客户端连接成功(服务器)时，此函数会被调用，
	//或者每次发送完成后，此函数也会被触发；它表示缓冲区已空，可以发送数据；
	//您可以忽略此函数的调用，直接调用Send去发送数据
	//
	virtual RetCode OnSend(Socket *pClient) = 0;

	//
	//当收到数据后(TCP),它会被调用;pClient是收到数据的Socket对象
	//pData是收到的数据缓冲区, iLength收到的数据长度
	//
	//注意:
	//底层框架会自动管理这个对象,
	//这里通知调用者的目的是希望调用者去处理自己业务逻辑相关的变更
	//
	virtual RetCode OnReceive(Socket *pClient, const BYTE* pData, INT iLength) = 0;

	//
	//当数据发送成功后(UDP),它会被调用;pClient是发送数据的Socket对象
	//iTotalLen要发送的长度, iLeftLen还剩下多少数据没发送, pToHost接收端地址
	//
	//注意:
	//底层框架会自动管理这个对象,
	//这里通知调用者的目的是希望调用者去处理自己业务逻辑相关的变更
	//
	//当UDP Socket创建成功后，此函数会被调用；或者SendTo成功后，也会调用此函数。
	//它表示缓冲区已空，可以发送数据；
	//您可以忽略此函数的调用，直接调用SendTo去发送数据
	//
	virtual RetCode OnSendTo(Socket *pClient) = 0;

	//
	//当收到数据后(UDP),它会被调用;pClient是收到数据的Socket对象
	//pData是收到的数据缓冲区, iLength收到的数据长度, pFromHost数据的来源地址
	//
	//注意:
	//底层框架会自动管理这个对象,
	//这里通知调用者的目的是希望调用者去处理自己业务逻辑相关的变更
	//
	virtual RetCode OnReceiveFrom(Socket *pClient, const BYTE* pData, INT iLength, SOCKADDR *pFromHost) = 0;
};


//
//服务器事件监听器接口
//
class IServerListener : public ISocketListener
{
public:
	virtual ~IServerListener() {}
	
public:
	//
	//有连接发生时,它会被调用;pListener是TCPListener对象,pAcceptSocket是连接的客户端对象
	//
	//注意:
	//当返回值是RET_ESUC时,表示允许底层框架接受此连接,否则表示不允许.
	//
	//注意:
	//底层框架会自动管理这个对象,
	//这里通知调用者的目的是希望调用者去处理自己业务逻辑相关的变更
	//
	virtual RetCode OnAccept(Socket *pListener, Socket *pAcceptSocket) = 0;

public:
	//针对于TcpListener，它是负责Accept客户端的
	virtual RetCode OnConnect(Socket *pClient) { return RET_ESUC; }
	virtual RetCode OnReceive(Socket *pClient, const BYTE* pData, INT iLength) { return RET_ESUC; }
	virtual RetCode OnSend(Socket *pClient) { return RET_ESUC; }
	virtual RetCode OnSendTo(Socket *pClient) { return RET_ESUC; }
	virtual RetCode OnReceiveFrom(Socket *pClient, const BYTE* pData, INT iLength, SOCKADDR *pFromHost) { return RET_ESUC; }
};

//
// 内存池接口类
//
class ICache
{
public:
	//
	//创建内存池
	//
	virtual RetCode CreateCache(INT iMinVal, INT iMaxVal) = 0;
	//
	//销毁内存池
	//
	virtual RetCode DestoryCache(VOID) = 0;

	//
	//从内存池中分配内存
	//iSize 要分配的内存大小(此参数保留,没有使用)
	//
	virtual PVOID CacheAlloc(INT iSize) = 0;

	//
	//将内存释放到内存池中
	//pCache 内存指针, iSize 要分配的内存大小(此参数保留,没有使用)
	//
	virtual VOID  CacheFree(PVOID pCache, INT iSize) = 0;
};


//
// TCP服务器类接口
//
class TCPListener : public Socket
{
public:
	//
	//启动TCP服务器对象
	//
	virtual RetCode StartListener(VOID) = 0;
	//
	//停止TCP服务器对象
	//
	virtual RetCode StopListener(VOID) = 0;
	//
	//获得当前所有活动客户端数量
	//
	virtual INT     GetClientCount(VOID) = 0;
	//
	//枚举所有当前获得客户端对象
	//
	virtual RetCode EnumSockets(IEnumSocket *pEnumSocket, VOID *pArg) = 0;

public:
	//
	//设置服务器事件监听器
	//
	VOID ServerListener(IServerListener *pServerListener){ m_pServerListener = pServerListener; }
	//
	//获取服务器事件监听器
	//
    IServerListener* ServerListener(VOID) { return m_pServerListener;}
	//
	//设置最大可接入客户端数
	//
	VOID MaxAccept(INT iMaxAccept){ m_iMaxAccept = iMaxAccept; }
	//
	//获得当前最大可接入客户端数
	//
	INT MaxAccept(VOID) { return m_iMaxAccept; }
	//
	//设置客户端超时检测机制的检查间隔时间
	//
	VOID Timeout(INT iTimeout) { m_iTimeout = iTimeout; }
	//
	//获取客户端超时检测机制的检查间隔时间
	INT Timeout(VOID) { return m_iTimeout; }

protected:
    IServerListener    *m_pServerListener;             //服务器事件监听器
    INT                 m_iMaxAccept, m_iTimeout;      //可接入最大客户端数量和超时检查时间间隔
};

//
// TCPSocket类接口
//
class TCPSocket : public Socket
{
public:
	//
	//发送数据
	//
	virtual INT     Send(const BYTE* pData, INT iLength) = 0;
	//
	//获取本地套接字信息
	//pszIp为输出参数, 格式: IP:端口
	//
	virtual RetCode GetSocketName(CHAR *pszIp, INT nSize) = 0;
	//
	//获取对端套接字信息
	//pszIp为输出参数, 格式: IP:端口
	//
	virtual RetCode GetPeerName(CHAR *pszIp, INT nSize) = 0;
	//
	//设置连接扩展(自定义)数据
	//
	virtual VOID    SetExtData(PVOID pExtData) = 0;
	//
	//获取连接扩展(自定义)数据
	//
	virtual PVOID   GetExtData(VOID) = 0;
	//
	//关闭连接(可重用关闭)
	//
    virtual RetCode Disconnect(VOID) = 0;
	//
	//连接服务器
	//
	virtual RetCode Connect(const CHAR *pszIp, INT iPort) = 0;
	//
	//获得会话数据指针
	//
    virtual PVOID   GetSession(VOID) = 0;
	//
	//获取会话通道
	//
	virtual TCPChannel*  GetChannel(VOID) = 0;
	//
	//获得链接关联的管理对象
	//
	virtual TCPListener* GetListener(VOID) = 0;
};

//
// 缓冲区
//
class DataBuf
{
public:
	DataBuf(){ m_pData = NULL; m_nLen = 0; m_nSize = 0; }

public:
	BYTE *m_pData; // 数据缓冲区指针
	INT   m_nLen;  // 数据大小
	INT   m_nSize; // m_pData缓冲区大小
};

//
// IChannel接口(需要用户实现)
//
class IChannel
{
public:
	//
	// 创建一个IChannel缓冲区
	//
	virtual DataBuf* AllocBuffer(INT nSize) = 0;
	//
	// 销毁IChannel缓冲区
	// RPC处理结束后，将自动调用此函数来释放使用的缓冲区
	//
	virtual VOID     OnFreeBuffer(DataBuf *pData) = 0;
	//
	// 处理IChannel请求数据
	// 当系统接收到RPC请求时，系统会自动调用此接口通知你去处理，pData是接收到的RPC数据， iLength是接收到的数据长度。
	// 在此接口的实现中，完成你的处理逻辑；
	// 1. 若你需要返回数据给IChannel请求者，请使用AllocBuffer函数来创建数据缓冲区,并且给你的缓冲区填充上数据，然后返回此缓冲区,系统会帮你完成发送数据的请求；
	// 2. 若你仅仅是希望处理这个请求，但是没有要返回的数据，那么请直接返回NULL,系统会认为你不需要返回数据。
	//
	virtual DataBuf* OnHandle(const BYTE* pData, INT iLength) = 0;
};

//
// TCPChannel类是TCPSocket的扩展类,
// 提供TCP通道的扩展功能;
//
class TCPChannel
{
public:
	//
	// 扩展发送数据接口:可以发送带扩展头的数据包,最大可以一次性发送4M字节的数据
	//
	virtual INT  SendEx(const BYTE* pData, INT iLength) = 0;

	//
	// 绑定IChannel接口
	// 例如：客户端希望通过CallEx函数获取数据的话，那么服务器端的处理对象就需要实现IChannel接口，并且绑定到TCPChannel对象上
	//
	virtual BOOL BindEx(IChannel *pCallBack) = 0;
	//
	// RPC调用接口
	// 该接口将同步等待对方返回或者超时；处理此调用的对象必须实现IChannel接口，并且通过Bind函数绑定到TCPChannel对象上
	// iTimeout 等待超时时间,单位为毫秒；pOutData 输出缓冲区，需要用户指定；iOutLen 输入输出参数，表示缓冲区大小和接收到的数据大小
	//
	virtual INT  CallEx(const BYTE* pInData, INT iInLen, INT iTimeout, BYTE *pOutData, INT *iOutLen) = 0;
};

//
// UDPSocket类接口
//
class UDPSocket : public Socket
{
public:
	//
	//初始化UDP套接字,并关联完成端口
	//
	virtual RetCode     BindIo(VOID) = 0;
	//
	//发送数据
	//
	virtual INT         SendTo(const BYTE* pData, INT iLength, const CHAR *pszIp, INT iPort) = 0;
	virtual INT         SendTo(const BYTE* pData, INT iLength, SOCKADDR_IN *pSockAddr) = 0;
	//
	//获取会话通道
	//
	virtual UDPChannel* GetChannel(VOID) = 0;
};

//
// UDT句柄
//
typedef UINT64 UDT_HANDLE;
//
// UDT无效句柄
//
#define UDT_INVALID_HANDLE ((UINT64)-1)

//
// UDPChannel类是UDPSocket的扩展类,
// 提供UDP通道的扩展功能;
// 该扩展类实现了UDT的部分功能，通过它你可以将UDP变身为可靠传输工具，
// 该扩展类和本通讯库中的的数据处理高度统一，收到可靠的数据后，仍将通过
// UDP相关的数据回调来通知调用者。
class UDPChannel
{
public:
	//
	// 阻塞发送一个P2P连接请求,直到对方响应或者超时
	// 如果成功连接到对端,则返回一个UDTSocket句柄，否则返回-1
	// iTimeout 单位是毫秒
	//
	virtual UDT_HANDLE Connect(const CHAR *pszDstIp, INT iDstPort, INT iTimeout) = 0;
	//
	// 当创建的对象不用时，需要调用此接口函数删除UDT对象
	//
	virtual RetCode    CloseSocket(UDT_HANDLE hSocket) = 0;
	//
	// 发送UDT数据(可靠传输，通过超时重传的方式实现)
	// 将数据拷贝到发送缓冲区中，直接返回。如果拷贝成功，则返回拷贝进去的字节数，否则返回错误码(RetCode)
	//
	virtual INT        Send(UDT_HANDLE hSocket, const VOID *pData, INT nLen) = 0;
	//
	// 发送UDT数据(可靠传输，通过超时重传的方式实现)
	// 将数据拷贝到发送缓冲区中,直到拷贝成功或者时间超时。如果拷贝成功，则返回拷贝进去的字节数，否则返回错误码(RetCode)
	// nTimeout  : 超时时间，单位为ms; -1表示直到拷贝成功或者断线
	//
	virtual INT        Send(UDT_HANDLE hSocket, const VOID *pData, INT nLen, INT nTimeout) = 0;
	//
	// 获得UDT句柄属性(对端IP和端口)
	//
	virtual CHAR*      GetSockAddr(UDT_HANDLE hSocket) = 0;
	virtual INT        GetSockPort(UDT_HANDLE hSocket) = 0;
};

//
// SEH异常处理回调接口
//
class IExceptionHandle
{
public:
	//
	//是否需要写Dump文件
	//
	virtual BOOL  IsWriteDump(VOID) = 0;
	//
	//获得Dump文件的全路径名称
	//
	virtual CHAR* GetFileName(VOID) = 0;
	//
	//在Dump完成后,通知调用者需要做什么处理,并且需要返回值,具体返回值参数请看下面:
	//EXCEPTION_EXECUTE_HANDLER = 1 表示我已经处理了异常,可以优雅地结束了  
    //EXCEPTION_CONTINUE_SEARCH = 0 表示我不处理,其他人来吧,于是windows调用默认的处理程序显示一个错误框,并结束  
    //EXCEPTION_CONTINUE_EXECUTION = -1 表示错误已经被修复,请从异常发生处继续执行 
	virtual LONG  OnDumpComplete(VOID) = 0;
};


//
// 日志级别
//
enum LOG_LEVEL
{
	LOG_NONE  = 0,
	LOG_INFO  = 1,
	LOG_WARN  = 2,
	LOG_ERROR = 3,
	LOG_FETAL = 4,
};

//
// 日志输出选项
//
enum LOG_OPT
{
	LOG_OPT_NONE    = 0,
	LOG_OPT_CONSOLE = 1,
	LOG_OPT_FILE    = 2,
	LOG_OPT_ALL     = 3,
};

//
// 一个日志输出类
//
class ILogger
{
public:
	//
	// 设置输出日志级别
	//
	virtual VOID SetLevel(LOG_LEVEL eLevel) = 0;
	//
	// 设置日志输出选项
	//
	virtual VOID SetOpt(LOG_OPT eOpt) = 0;
	//
	// 设置日志缓存队列的最大值
	//
	virtual VOID SetMaxCount(INT nMax) = 0;
	//
	// 输出Info级别的日志
	//
	virtual RetCode LogI(const char* format, ...) = 0;
	//
	// 输出Warn级别的日志
	//
	virtual RetCode LogW(const char* format, ...) = 0;
	//
	// 输出Error级别的日志
	//
	virtual RetCode LogE(const char* format, ...) = 0;
	//
	// 输出Fetal级别的日志
	//
	virtual RetCode LogF(const char* format, ...) = 0;
};

//
// 一个缓冲区接口
// 采用先进先出的方式
//
class IBuffer
{
public:
	//
	// 缓冲区是否已空
	//
	virtual BOOL IsEmpty(VOID) = 0;
	//
	// 缓冲区是否已满
	//
	virtual BOOL IsFull(VOID)  = 0;

	//
	// 获取缓冲区中数据的长度
	//
	virtual INT Length(VOID) = 0;
	//
	// 获取缓冲区的容量
	//
	virtual INT Capacity(VOID) = 0;

	//
	// 将数据存入缓冲区中(同步)
	// 返回已经写入的长度
	//
	virtual INT PutData(VOID *data, INT nLen) = 0;
	//
	// 从缓冲区中读取指定长度的内容到data中
	// 不改变缓冲区数据内容
	// 返回读取的长度
	//
	virtual INT FetchData(VOID *data, INT nSize) = 0;
	//
	// 从缓冲区中读取指定长度的内容到data中
	// 清空已读取部分的内容
	// 返回读取的长度
	//
	virtual INT GetData(VOID *data, INT nSize) = 0;
};
为了进一步方便c++ coder们的使用，我特意封装了一个C++调用类，在IOCP_API.hpp文件中： 

#define CHECK_POINTE_RETURN(ptr, ret)  if (ptr == NULL) return ret;

/*
    类说明：
	功能 ： 一个简单包装IOCP_API函数的C++类,提供IOCP_API的所有功能的封装
	备注 ：
		   如果需要在C++环境中使用的话,可以包括这个头文件,并定义或者继承此类
	作者 ：沈毅(shenyi0106@163.com)
	时间 ：2014/01/26
*/
class XSocket
{
public:
	XSocket()
	{
		m_hIocp = NULL;
		m_pCache = NULL;
	}

	~XSocket()
	{
		UnInitialize();
	}

public:
	RetCode Initialize(INT iWorkerThread = 8, INT iThreadPool = 8, INT iMinCacheSize = 2000, INT iMaxCacheSize = 10000)
	{
		m_hIocp = IOCPStartup(iWorkerThread, iThreadPool);
		CHECK_POINTE_RETURN(m_hIocp, RET_EFAILED);

	    m_pCache = IOCPCreateCache(iMinCacheSize, iMaxCacheSize);
		CHECK_POINTE_RETURN(m_pCache, RET_EFAILED);

		return RET_ESUC;
	}

	RetCode UnInitialize()
	{
		IOCPCleanup(m_hIocp);
		IOCPDestroyCache(m_pCache);

		return RET_ESUC;
	}

	TCPListener* CreateListener(INT iBindPort)
	{
		TCPListener *pListener = NULL;

		CHECK_POINTE_RETURN(m_hIocp, NULL);
		pListener = IOCPCreateListener(m_hIocp, iBindPort);
		InitSocket(pListener);

		return pListener;
	}

	TCPSocket* CreateClient(INT iBindPort = 0)
	{
		TCPSocket *pClient = NULL;

		CHECK_POINTE_RETURN(m_hIocp, NULL);
		pClient = IOCPCreateClient(m_hIocp, iBindPort);
		InitSocket(pClient);

		return pClient;
	}

	UDPSocket* CreateSocket(INT iBindPort)
	{
		UDPSocket *pSocket = NULL;

		CHECK_POINTE_RETURN(m_hIocp, NULL);
		pSocket = IOCPCreateSocket(m_hIocp, iBindPort);
		InitSocket(pSocket);

		return pSocket;
	}

    RetCode DestorySocket(Socket* pSocket, SocketType sockType)
	{
		CHECK_POINTE_RETURN(pSocket, RET_EFAILED);

		return IOCPDestorySocket(pSocket, sockType);
	}

private:
	VOID InitSocket(Socket *pSocket)
	{
		if (pSocket != NULL)
		{
			pSocket->IOCP(m_hIocp);
			pSocket->Cache(m_pCache);
		}
	}

public:
	HANDLE   m_hIocp;
	ICache  *m_pCache;
};

/*
    类说明：
	功能 ： 一个简单工具集包装类
	备注 ：
		   如果需要在C++环境中使用的话,可以包括这个头文件,并定义或者继承此类
	作者 ：沈毅(shenyi0106@163.com)
	时间 ：2014/02/09
*/
class XUtil
{
public:
	//
	// 以下是几个两个示例数据库的连接字符串:
	// MySQL    : DRIVER={MySQL ODBC 5.1 Driver};SERVER=127.0.0.1;DATABASE=ckdz;UID=%s;PWD=%s;PORT=3306;OPTION=0;stmt=SET NAMES GBK
	// Oracle   : Provider=OraOLEDB.Oracle.1;Data Source=EQUANT;User ID=nyg;Password=nyg
	// SQLServer: Provider=SQLOLEDB.1;Persist Security Info=true;User ID=sa;Password=123456;Initial Catalog=tempdb;Data Source=127.0.0.1
	static ADOPool* CreatePool(INT nMinPoolSize, INT nMaxPoolSize, const CHAR *pszConnStr)
	{
		CHECK_POINTE_RETURN(pszConnStr, NULL);

		return IOCPCreatePool(nMinPoolSize, nMaxPoolSize, pszConnStr);
	}

	static RetCode DestoryPool(ADOPool *pAdoPool)
	{
		CHECK_POINTE_RETURN(pAdoPool, RET_EARGS);

		return IOCPDestoryPool(pAdoPool);
	}

	static BOOL Compress(CHAR *pInBuf, INT inLen, CHAR *pOutBuf, INT *outLen)
	{
		CHECK_POINTE_RETURN(pInBuf, RET_EARGS);
		CHECK_POINTE_RETURN(pOutBuf, RET_EARGS);

		return ZLIB_Compress(pInBuf, inLen, pOutBuf, outLen);
	}

	static BOOL Uncompress(CHAR *pInBuf, INT inLen, CHAR *pOutBuf, INT *outLen)
	{
		CHECK_POINTE_RETURN(pInBuf, RET_EARGS);

		return ZLIB_UnCompress(pInBuf,inLen, pOutBuf, outLen);
	}

	static BOOL BaseEncode64(char * pInBuf,int nBufLen,char * pOutBuf)
	{
		CHECK_POINTE_RETURN(pInBuf, RET_EARGS);
		CHECK_POINTE_RETURN(pOutBuf, RET_EARGS);

		return Base64Encode(pInBuf, nBufLen, pOutBuf);
	}

	static BOOL BaseDencode64(char * pInBuf,int nBufLen,char * pOutBuf)
	{
		CHECK_POINTE_RETURN(pInBuf, RET_EARGS);
		CHECK_POINTE_RETURN(pOutBuf, RET_EARGS);

		return Base64Dencode(pInBuf, nBufLen, pOutBuf);
	}

	static RetCode UnhandledException(IExceptionHandle *exception)
	{
		CHECK_POINTE_RETURN(exception, RET_EARGS);

		return IOCPUnhandledException(exception);
	}

	static ILogger* CreateLogger(char *pszFilePath)
	{
		CHECK_POINTE_RETURN(pszFilePath, NULL);

		return IOCPCreateLogger(pszFilePath);
	}

	static RetCode DestoryLogger(ILogger *pLogger)
	{
		CHECK_POINTE_RETURN(pLogger, RET_EARGS);

		return IOCPDestoryLogger(pLogger);
	}

	static IBuffer* CreateBuffer(INT nCapacity)
	{
		return IOCPCreateQueue(nCapacity);
	}

	static RetCode DestoryBuffer(IBuffer *pBuffer)
	{
		CHECK_POINTE_RETURN(pBuffer, RET_EARGS);
		return IOCPDestoryQueue(pBuffer);
	}
};
当您阅读完以上内容后，我们就等于是预览了IOCP_API 2.4版，下面您就可以开始使用此编程库编写您的"Hello World"了。
为了使您能够更加准确的了解此编程库的用法，在我提供的源码工程中，我还提供了一个Demo工程，它包含了这个编程库的所有主要功能，
当您需要问题时，可以查看并阅读此Demo，以便了解API的用法。




写在最后：
虽然IOCP_API经历了很多版本的演化，功能和稳定性都有了很不错的表现，但是我一个人的力量毕竟是有限的，设计场景也相对固定，测试环境也很简单，
难免会存在很多BUG，甚至在核心系统中。所以，在此我希望也恳请所有的coder们，在发现和（或者）修改一个BUG后，
能及时的通知我（email:shenyi0106@163.com, qq:52851771）,以便让我能够及时更新最新到最新的代码中，感谢各位童鞋们。


下载地址： 点这里

shenyi0106
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C++游戏服务器开发入门到掌握》Windows下原生API，用IOCP编写一个简易的服务器模型
风铃飞弦的博客
07-10 575
77、1 系统对比： 对于Unix来说一切皆文件，对于Windows来说一切皆handle。但概念不完全相等。 WSADATA： 由于Windows一开始不支持TCPIP，以致于后来加入使用总是要加载一个dll来构造网络环境。 WSADATA data; auto result = WSAStartup(MAKEWORD(2,2), &data); if(result != NO...
IOCP_API(2.4)
01-01
1. 连接oracle时,目录中不能有()字符,否则ADO是无法连接数据库的 修改: 2.1 去掉TCPChannel的BuildPacket函数，改成直接由OnRecv回调函数返回实际数据 去掉UDPChannel的Response函数，改成直接由内部处理 2.2 修改TCPChannel类，实现同步调用接口 定义IRPC接口用来处理同步调用的被调用端 定义Bind函数用来绑定IRPC接口的实例 定义CallEx函数用来实现用户同步调用 2.3 添加bInit变量，用于设置初始化和关闭状态。 设置此变量的目的主要是用来控制，在关闭了socket之后，后续的任何投递都不执行。 修改了IRPC接口名称为IRemoteProcCall，并且调整了部分结构体名称，如RPC相关的结构体， 组合包相关的结构体，以及P2P相关的结构体。 修改TCPChannel类的接口函数Bind成BindEx，使之与TCPChannel的其他接口统一命名。 修改测试Demo，添加多发选项 修改DataType.h中的内存块大小定义 封装临界区类，信号量类 修改TCPListener接口类中的EnumSockets接口，添加pArg参数 Socket类添加ReUseAddr函数，用来设置端口重用 TCPSocket接口类添加GetListener接口用来获得链接管理对象 修改Demo实例中的TCP客户端部分，增加可更改客户端连接数 2.4 添加UDT支持 修改UDPChannel接口类，添加UDT支持接口函数 添加日志支持 添加接口类ILogger，用来实现对日志的输出 添加x64的编译环境 添加部分WARN级别的日志输出 添加C接口，方便非C++语言应用 UDT添加特性，关闭UDT时，给对端发送断线信息，通知对端断线 UDT提高效率，UDT句柄部分改用读写锁来控制，以提高效率 修改OnSend和OnSendTo的行为 修改过的BUG： 1. 数据发送时，如果数据大小正好是MAX_PACKET_SIZE个字节的话，数据发送不出去，在计算包大小时，边界值没处理好。 2. IOCPUnhandledException函数内部逻辑错误，没有关联到自己的异常处理函数中，导致即使调用成功，程序异常了，也无法写dump文件。 3. 修复IOCP UDP Release模式下不能正常运行的BUG。由于传递的输出参数使用了局部变量导致的问题 4. 修复UDT发送时，计算尾包大小错误 5. 修复UDT快速发送错误 6. 修改Queue关闭时，如果有线程正在等待信号，会导致线程死等
IOCP_API组件来搭建TCP服务器
踏雪无痕
12-17 1877
转自论坛：http://topic.csdn.net/u/20110127/16/e4da4738-9be3-45bb-bf9c-9e46ebce98e7.html?42267 本文基于沈毅(shenyi0106@163.com qq:52851771)所提供的IOCP_API组件来搭建TCP服务器。 下载地址：http://download.csdn.net/source/2960211
IOCP_API(2009/7/14)
07-14
1.修改了IOCPServer中扫描线程会使服务器崩溃的BUG；2.修改了IOCPServer和IOCPClient中的Send函数，以及接收处理流程，可以收发大数据包（具体查看函数说明）；3.增加了实现RUDP协议的函数（只实现了可靠传输，没有实现流控和拥控）；4.修改完成时间2009年7月14日
IOCP_API测试程序
06-25
一个IOCP_API库的测试程序，测试采用echo测试方法
77-Windows下原生ＡＰＩ 用IOCP编写一个简易的服务器模型 １_recv
谢白羽
06-03 161
文章目录1.main.cpp2.server.cpp3.server.h 1.main.cpp #include <cassert> #include <signal.h> #include <thread> //这个服务器是多线程版本 #include <map> #include <time.h> #include <string> #include "Server.h" #pragma comment(lib,"Ws2_32
2.4
weixin_30501857的博客
04-25 47
#include<stdio.h>int main(){int a;double rate,tax,profit;scanf("%d",&a);if(a<500){ printf("a=%d,rate=0,tax=0,profit=%f",a,a);}else if((a>=500)&&(a<100...
Delphi下IOCP开源框架：DIOCP 成功应用案例分享
10-12 499
首先说明，该项目不是本人的项目，本文转自盒子。 该项目使用的DIOCP版本为1.0，目前diocp为3.5 以下是盒子的原文 ------------------------------------------------------------------------------ DIOCP是Delphi下进行IOCP服务端通讯开发的一个非常好的开源框架，稳定、高效并且使...
In-IOCP服务组件库及例子（开源，v1.5.8.946）
01-03
In-IOCP 是一套基于 IOCP（Delphi 版）的开源框架组件，内部作了消息封装，集成用户、消息、文件和数据库管理，支持自定义消息和远程函数，支持 HTTP 基本服务，帮助快速实现网络开发，欢迎大家测试、使用和交流！
c#_udp协议拆包封包
01-19
c#_udp协议拆包封包
IOCP 粘包 分包
03-10
IOCP 高效率粘包 分包，很好的代码，可以下载测试
WINDOWS完成端口编程IOCP&&THREADPOOL
04-27
WINDOWS完成端口编程 1、基本概念 2、WINDOWS完成端口的特点 3、完成端口（Completion Ports ）相关数据结构和创建 4、完成端口线程的工作原理 5、Windows完成端口的实例代码
开源Molnet网络引擎 - 一个基于IOCP的高效率的网络引擎
akinggw的专栏
10-28 1885
使用IOCP搭建的网络引擎，支持内存池，线程池，数据库连接池，实时加密等等。简单好用！http://www.oschina.net/code/snippet_102883_1101
NDK发送函数ENOBUFS错误解决办法
Skylar
12-04 2963
调用sendto()函数返回-1，错误代码55 (ENOBUFS)。这个包发送失败，下一个包不一定会失败，所以把这个包当成丢包。一般多任务工程里面，在SCOM_getMsg()之后不要直接调用sendto()之类的发送函数，应该在发送函数之前至少要TSK_sleep(1)(延迟一个ticks)。
C#网络编程系列文章(四)之TcpListener实现同步TCP服务器
超纯的小白兔
03-15 8685
原创性声明 本文作者：小竹zz 本文地址http://blog.csdn.net/zhujunxxxxx/article/details/44258719 转载请注明出处 本文介绍 TcpListener 类提供一些简单方法，用于在阻止同步模式下侦听和接受传入连接请求。 可使用 TcpClient 或 Socket 来连接 TcpListener。 可使用 IPEndPoint、本地 I
我是问你iocp和epoll那个性能好
最新发布
05-16
这个问题的答案并不简单，因为它取决于不同的因素和上下文。以下是一些可能影响性能的因素： 1. 操作系统：IOCP是Windows系统的API，而epoll是Linux系统的API。因此，它们在不同的操作系统上可能会有不同的性能表现。 2. 应用程序的类型和需求：IOCP和epoll都可以用于高性能的网络编程，但它们的适用场景可能有所不同。例如，如果您的应用程序需要处理大量的短连接请求，则IOCP可能会更适合，因为Windows系统在处理短连接时具有更好的性能表现。另一方面，如果您的应用程序需要处理大量的长连接，则epoll可能更适合，因为它可以更好地处理大量的文件描述符。 3. 编程语言和框架：IOCP和epoll都有许多不同的编程语言和框架的实现。因此，它们在不同的环境下可能会有不同的性能表现。 总的来说，如果你在Windows系统上进行编程，IOCP可能会更适合。如果你在Linux系统上进行编程，epoll可能会更适合。但是，具体应该使用哪个API还需要根据你的应用程序的特点和需求来确定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值