//   Iocp 头文件

#pragma once

#include <winsock2.h>

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

const int OP_READ = 0;

const int OP_WRITE = 1;

const int OP_ACCEPT = 2;

/*

     OVERLAPPEDPLUS 结构体设计思路

     OVERLAPPED 是一个固定的用于处理网络消息事件返回值的结构体变量

     在完成端口和重叠I/O模型里用于返回消息事件的结果

     因为在处理网络消息的时候，发送的是一个返回值的结构体指针，只要结构体

     的前面部分满足系统的要求，在系统操作成功的时候也就会把这个结构体指针

     发回给用户，我们只要在系统定义的结构体后面扩展一些自己的东西，就可以

     很轻松的确定该消息是谁发过来的。

     不过好像完成端口在设计的时候也满足了这样的需求，所以在这里我只是放入

     一些与系统连接有关的数据，用户需要存放的数据这里就不在存放

     这里存储与系统相关的数据有：

     socket

     OpCode 本次消息的操作类型（在完成端口的操作里面，是以消息通知系统，

         读数据/写数据，都是要发这样的消息结构体过去的，所以如果系统要同时

         进行读写操作的话，就需要有一个变量来区分操作了）

     WSABUF   wbuf;                  //   读写缓冲区结构体变量

     DWORD    dwBytes, dwFlags; //   一些在读写时用到的标志性变量

     char buf[4096];                  //   自己的缓冲区

     上面的4个变量存放的是一些与消息相关的数据，都是一些操作上用到的，

     这些东西都是固定的，具体作用需要参考一下完成端口相关函数的参数接口

*/

struct OVERLAPPEDPLUS

{

     OVERLAPPED    ol;

     SOCKET        s;

     int OpCode;

     WSABUF   wbuf;

     DWORD    dwBytes, dwFlags;

     char buf[4096];

};

class CIOCP

{

protected:

     HANDLE g_hwThread;     //   工作线程句柄

     DWORD m_wthreadID;

     HANDLE g_haThread;     //   连接线程句柄

     DWORD m_athreadID;

public:

     bool m_workThread;

     bool m_acceptThread;

     HANDLE m_hIocp;             //   完成端口的句柄

     SOCKET m_sSocket;

public:

     CIOCP(void);

     ~CIOCP(void);

     virtual void OnRead(void * p, char *buf, int len){};

     virtual void OnAccept(SOCKET socket);

     virtual void OnClose(void * p){};

     bool SetIoCompletionPort(SOCKET socket, void *p, char *buf = NULL, int len = 0);

         //   把一个socket与一个自定义的结构体关联到完成端口（相当于把socket与一个结构体变量进行绑定），

         //   这样当发送上面3种网络事件的时候，该结构体变量会再传回给程序

         //   这样就可以区分当前网络事件是那个socket发出的

     bool Init(void);

     bool Listen(int port);

     static DWORD __stdcall WorkThread(LPVOID Param);

     static DWORD __stdcall AcceptThread(LPVOID Param);

};

class CIOCPClient: public CIOCP

{

protected:

     SOCKET m_socket;

public:

     bool Connect(char *ip, int port);

     void Send(char *buf, int len);

};

//////////////////////////////////////////////////////////////////////////////////////////

//   Iocp 实现文件

#include "StdAfx.h"

#include "iocp.h"

static bool bInit = false;

DWORD __stdcall CIOCP::WorkThread(LPVOID Param)

{

     CIOCP * pthis = (CIOCP *)Param;

     void * re;

     OVERLAPPED * pOverlap;

     DWORD berByte;

     while(pthis->m_workThread)

     {

         int ret;

         ret = GetQueuedCompletionStatus(pthis->m_hIocp, &berByte, (LPDWORD)&re, (LPOVERLAPPED *)&pOverlap, INFINITE);

         if (ret == ERROR_SUCCESS)

         {

         }

         if (berByte == 0)

         {

              //   客户端断开连接

              pthis->OnClose(re);

              OVERLAPPEDPLUS *olp = (OVERLAPPEDPLUS *)pOverlap;

              closesocket(olp->s);

              delete olp;        //   释放 与socket绑定的结构体变量

              continue;

         }

         if (re == NULL) return 0;

         OVERLAPPEDPLUS *olp = (OVERLAPPEDPLUS *)pOverlap;

         switch(olp->OpCode)

         {

         case OP_READ:

              pthis->OnRead(re, olp->wbuf.buf, berByte);     //   调用 OnRead() 通知应用程序，服务器收到来自客户端的网络数据

              WSARecv(olp->s, &olp->wbuf, 1, &olp->dwBytes, &olp->dwFlags, &olp->ol, NULL); //   继续调用一个接收的 I/O 异步请求

              break;

         default:

              break;

         }

     }

     return 0;

}

DWORD __stdcall CIOCP::AcceptThread(LPVOID Param)

{

     CIOCP * pthis = (CIOCP *)Param;

     while(pthis->m_acceptThread)

     {

         SOCKET client;

         if ((client= accept(pthis->m_sSocket, NULL, NULL)) == INVALID_SOCKET)

         {

              //   错误处理

         }

         pthis->OnAccept(client);    //   调用 OnAccept()通知应用程序有新客户端连接

     }

     return 1;

}

CIOCP::CIOCP(void)

{

}

CIOCP::~CIOCP(void)

{

}

bool CIOCP::Init(void)

{

     if (bInit)

         return true;

     WSADATA wsd;

     if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)

         return false;

     bInit = true;

     return true;

}

bool CIOCP::Listen(int port)

{

     if (!bInit)

         if (!Init())

              return false;

     m_sSocket = socket(AF_INET, SOCK_STREAM, 0);

     if (m_sSocket == INVALID_SOCKET)

         return false;

     //SOCKADDR_IN addr;

     sockaddr_in addr;

     addr.sin_family = AF_INET;

     addr.sin_port = htons(port);

     addr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

     //addr.sin_addr.S_un.S_addr = inet_addr(ip);

     if (bind(m_sSocket, (struct sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR)

         return false;

     if (listen(m_sSocket, 10) == SOCKET_ERROR)

         return false;

     if ((m_hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 0)) == NULL)     //   创建完成端口的句柄

         return false;

     this->m_acceptThread = true;

     g_haThread = CreateThread(NULL, 0, AcceptThread, (LPVOID)this, 0, &m_athreadID);    //   创建连接线程，用来接收客户端的连接

     this->m_workThread = true;

     g_hwThread = CreateThread(NULL, 0, WorkThread, (LPVOID)this, 0, &m_wthreadID); //   创建工作线程，用来处理完成端口消息的

     return true;

}

bool CIOCP::SetIoCompletionPort(SOCKET socket, void *p, char *buf, int len)

{

     if (CreateIoCompletionPort((HANDLE)socket, m_hIocp, (ULONG_PTR)p, 0) == NULL)

         return false;

     OVERLAPPEDPLUS *olp = new OVERLAPPEDPLUS;

     memset(olp, 0, sizeof(OVERLAPPEDPLUS));

     olp->s = socket;

     if (buf)

     {

         //   这里可以使用用户自定义的缓冲区地址，如果用户不想设置，也可以采用默认分配的缓冲区

         olp->wbuf.buf = buf;

         olp->wbuf.len = len;

     }

     else

     {

         olp->wbuf.buf = olp->buf;

         olp->wbuf.len = 4096;

     }

     olp->OpCode = OP_READ;

     int ret = WSARecv(olp->s, &olp->wbuf, 1, &olp->dwBytes, &olp->dwFlags, &olp->ol, NULL);

     if (ret == SOCKET_ERROR)

         if (WSAGetLastError() != ERROR_IO_PENDING)

              return false;

     return true;

}

void CIOCP::OnAccept(SOCKET socket)

{

     this->SetIoCompletionPort(socket, NULL);

}

//===================================================================================

bool CIOCPClient::Connect(char *ip, int port)

{

         //   连接服务器

     if (!bInit)

         if (!Init())

              return false;

     //   初始化连接socket

     m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

     if (m_socket == SOCKET_ERROR)

     {

//       printf("cocket Create fail");

         return false;

     }

     // 填写服务器地址信息

     // 端口为1982

     // IP地址为INADDR_ANY，注意使用htonl将IP地址转换为网络格式ServerAddr.sin_family = AF_INET;

     sockaddr_in ClientAddr;

     ClientAddr.sin_family = AF_INET;

     ClientAddr.sin_port = htons(port);   

     ClientAddr.sin_addr.s_addr = inet_addr(ip);

     // 绑定监听端口

     bind(m_socket, (SOCKADDR *)&ClientAddr, sizeof(ClientAddr));

     if (connect(m_socket, (SOCKADDR *)&ClientAddr, sizeof(ClientAddr)) == SOCKET_ERROR)

     {

         return false;

     }

     if ((m_hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 0)) == NULL)     //   创建完成端口的句柄

         return false;

     this->m_workThread = true;

     g_hwThread = CreateThread(NULL, 0, WorkThread, (LPVOID)this, 0, &m_wthreadID); //   创建工作线程，用来处理完成端口消息的

     this->SetIoCompletionPort(m_socket, &m_socket);    //   设置完成端口监听的socket

     return true;

}

void CIOCPClient::Send(char *buf, int len)

{

     send(m_socket, buf, len, 0);

}

///////////////////////////////////////////////////////////////////////////////////

// IOCPclient 应用代码

#include "stdafx.h"

#include "IOCP.h"

#include "TClientSocket.h"

class Iocp :public CIOCPClient

{

      void OnRead(void * p, char *buf, int len)

      {

          printf(buf);

          Sleep(1000);

          this->Send(buf, len);

      }

};

int _tmain(int argc, _TCHAR* argv[])

{

     Iocp iocp;

     iocp.Init();

     iocp.Connect("127.0.0.1", 4311);

     iocp.Send("test\0", 5);

     gets(new char[1000]);

     return 0;

}

显然，异步要高效一些。在Winsock中实现异步的方法有很多，Winsock工作模型有下面六种
    一：select模型
    二：WSAAsyncSelect模型
    三：WSAEventSelect模型
    四：Overlapped I/O 事件通知模型
    五：Overlapped I/O 完成例程模型
    六：IOCP模型
从一到六越来越高级，越来越高效，实现越来越复杂。曾在网上看到一些比喻用来很好的说明这些模型，在这里引用一下。

    老陈有一个在外地工作的女儿，不能经常回来，老陈和她通过信件联系。他们的信会被邮递员投递到他们的信箱里。
一：select模型

老陈非常想看到女儿的信。以至于他每隔10分钟就下楼检查信箱，看是否有女儿的信~~~~~
在这种情况下，“下楼检查信箱”然后回到楼上耽误了老陈太多的时间，以至于老陈无法做其他工作。

二：WSAAsyncSelect模型

后来，老陈使用了微软公司的新式信箱。这种信箱非常先进，一旦信箱里有新的信件，盖茨就会给老陈打电话：喂，大爷，你有新的信件了！从此，老陈再也不必频繁上下楼检查信箱了，牙也不疼了，你瞅准了，蓝天......不是，微软~~~~~~~~

三：WSAEventSelect模型

后来，微软的信箱非常畅销，购买微软信箱的人以百万计数......以至于盖茨每天24小时给客户打电话，累得腰酸背痛，喝蚁力神都不好使~~~~~~
微软改进了他们的信箱：在客户的家中添加一个附加装置，这个装置会监视客户的信箱，每当新的信件来临，此装置会发出“新信件到达”声，提醒老陈去收信。盖茨终于可以睡觉了。

四：Overlapped I/O 事件通知模型

后来，微软通过调查发现，老陈不喜欢上下楼收发信件，因为上下楼其实很浪费时间。于是微软再次改进他们的信箱。新式的信箱采用了更为先进的技术，只要用户告诉微软自己的家在几楼几号，新式信箱会把信件直接传送到用户的家中，然后告诉用户，你的信件已经放到你的家中了！老陈很高兴，因为他不必再亲自收发信件了！

五：Overlapped I/O 完成例程模型

老陈接收到新的信件后，一般的程序是：打开信封----掏出信纸----阅读信件----回复信件......为了进一步减轻用户负担，微软又开发了一种新的技术：用户只要告诉微软对信件的操作步骤，微软信箱将按照这些步骤去处理信件，不再需要用户亲自拆信/阅读/回复了！老陈终于过上了小资生活！

六：IOCP模型

微软信箱似乎很完美，老陈也很满意。但是在一些大公司情况却完全不同！这些大公司有数以万计的信箱，每秒钟都有数以百计的信件需要处理，以至于微软信箱经常因超负荷运转而崩溃！需要重新启动！微软不得不使出杀手锏......
微软给每个大公司派了一名名叫“Completion Port”的超级机器人，让这个机器人去处理那些信件！

其实，上面每种模型都有优点，要根据程序需求而适当选择合适的模型，前面三种模型效率已经比较高，实现起来难道不大，很多一般的网络程序都采用前三种模型，只有对网络要求特别高的一些服务器才会考虑用后面的那些模型。MFC中的CAsyncSocket类就是用的WSAAsyncSelect模型，电驴中也是用的这种，不过在寻找对应socket的时候进行了优化，查找更快，在GridCast中采用的是WSAEventSelect模型，等待。

BTW：上面所说均在Windows平台下，只用WinSock才有这么多模型，在linux下，好像就只有第一种select模式，我对linux下的socket不是很了解，应该也有很多提高效率的地方。