CRITICAL_SECTION g_data;
HANDLE　　　　　　　　　　g_hEvent;
TCHAR　　　　　　　　　　　g_szBuffer[MAX_BUFFER_SIZE];
int　　　　　　　　　　　　　　　g_nBytes;

void ReadThread(void)
{
 　　 int nTotle = nRead = nLeft = nBytes = 0;

    　　 while(!done)
    　　{
    　　　 nTotal = 0;
     　　　 nLeft = NUM_BYTES_REQUIRED; //要读多少的Bytes

      　　　 while( nTotal != NUM_BYTE_REQUIRED)
       　　　{
           　　　　 // 因为涉及线程和全局变量所以说需要用到关键代码段(Critical Section)
           　　　　 EnterCriticalSection(&g_data);

          　　　　 nRead = recv(sock,&(g_szBuffer[MAX_BUFFER_SIZE] - nBytes),nLeft);

            　　　　 if( -1 == nread )
              　　　　{
                　　　　　　printf("socket %d error.\n",WSAGetLasError());
                　　　　　　ExitThread();
               　　　　 }

               　　　　　nTotal += nRead;
                 　　　　　nLeft -= nRead;

                　　　　　nBytes += nRead;

                  　　　　　LeaveCriticalSelection(&g_data);
          　　 }

          　　// 从网络接收完指定的(NUM_BYTES_REQUIRED)Bytes之后通知WorkThread启动
          　　 SetEvent(g_hEvent);
   　 }
}

void WorkThread(void)
{
 　　WaitForSingleObject(g_hEvent);

   　　EnterCriticalSection(&g_data);

  　　// 主要的处理工作...
  　　DoSomeWorkOnData(g_szBuffer);

    　 g_nBytes -= NUM_BYTE_REQUIRED;

   　 LeaveCriticalSelection(&g_data);
}

　　这种方式的一个缺点是:应用程序很难同时通过多个建立好连接的socket通信.当然话说回来我们可以为每一个连接好的socket都开一个Reading Thread and WorkThread,但是呢这会带来很大的开销,而且扩展性很差,试想:如果用这样的模型建立一个服务器端来一个连接开至少两个线程...天..要是业务负担很大/连接的socket很多的话怎么办??所以说别多想了...
   这样的方式是很不适合做服务器端的.(注意:我说的服务器端是指C/S中的S端逻辑).

   从编写代码的角度解读一下IO中最复杂的IOCP模型

   下面的一段代码是Microsoft Win32 SDK里面的例子,这是一个Echo服务器程序:

  //
  // 这就不说了,为了使用Winsock2必须包含的头文件...
  //
#include
#include
#include

#define PORT 5150 // 这个服务器选择5150端口
#define DATA_BUFSIZE 8192 // 把Buffer定义为8K是一个比较被Microsoft推荐的大小

  //
  // 这个结构体很重要,请一定看清楚,到后面用到的时候别糊涂了
  // 特别注意:把Overlapped放最开头是有原因的,你应该明确的是
  // 如果有:
  // PER_IO_OPERATION_DATA PerIoData;
  // &PerIoData->Overlapped 和 &PerIoData是一样的/等价的/
  // 指向同一块内存区域的.
  //
  typedef struct
  {
   OVERLAPPED Overlapped;
   WSABUF DataBuf;
   CHAR Buffer[DATA_BUFSIZE];
   DWORD BytesSEND; // 下面两个参数是用来记录每个connected socket上面的收发的Bytes的
   DWORD BytesRECV;
  } PER_IO_OPERATION_DATA, * LPPER_IO_OPERATION_DATA;

  // 别把这个结构体和上面的结构体混淆了,名字很像的...其实它在这个程序中就相当于是那个和Client端连接的socket
  typedef struct
  {
   SOCKET Socket;
  } PER_HANDLE_DATA, * LPPER_HANDLE_DATA;

  DWORD WINAPI ServerWorkerThread(LPVOID CompletionPortID);

  void main(void)
  {
   SOCKADDR_IN InternetAddr;
   //
   // 一个listen和一个Accept socket是服务器程序的老套路了...
   //
   SOCKET Listen;
   SOCKET Accept;

   //
   // IO完成端口映射到程序就是一个HANDLE
   //
   HANDLE CompletionPort;
   SYSTEM_INFO SystemInfo;

   //
   // 看清楚,这是指针...不怕你笑话我们处还真有分不清和指针相关的一切概念的人,比如下面的代码:
   // 我写了一个DLL,里面有一个这样的函数:
   // BOOL GetPlayingPosition(DWORD * dwPos);
   // 结果大虾调用的时候是这样的....
   // DWORD * p;
   // GetPlayingPostion(p);
   // 它是调用爽了...我呢...:-(
   // 当然了,也不好定义说它就是分不清指针,也许人家就不会写程序呢..对吧..
   //
   LPPER_HANDLE_DATA PerHandleData;
   LPPER_IO_OPERATION_DATA PerIoData;

   int i;
   DWORD RecvBytes;
   DWORD Flags;
   DWORD ThreadID;
   WSADATA wsaData;
   DWORD Ret;

   // 就像CoInitialize()一样的把Winsock 2.2服务启动起来...
   if ((Ret = WSAStartup(0x0202, &wsaData)) != 0)
   {
    printf("WSAStartup failed with error %d\n", Ret);
    return;
   }

   // CreateIoCompletionPort有两个不同的用途:1.创建完成端口;2.把已经创建好的完成端口和一个Socket关联/绑定起来.
   // 下面这句话是它的第一个用途:创建完成端口
   if ((CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0)) == NULL)
   {
    printf( "CreateIoCompletionPort failed with error: %d\n", GetLastError());
    return;
   }

   //
   // 下面这一些代码说得是:根据该服务器跑的机器上有几个CPU建立2*CPU数量的Thread.
   // 这涉及到完成端口工作线程应该创建多少个的问题,在早期(MSDN 2000)Microsoft说
   // 是WorkThreadNums = 2 * CPU + 2,现在的MSDN 2003说是WorkThreadNums = 2 * CPU;
   //
   GetSystemInfo(&SystemInfo);

   for(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\n", GetLastError());
     return;
    }

    // 这个风格我喜欢,创建完Thread就把人家的Handle给release,省得要是线程异常退出搞得资源泄漏之类的麻烦事情.
    CloseHandle(ThreadHandle);
   }

   // 开始创建监听Socket...
   if ((Listen = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0,WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)
   {
    printf("WSASocket() failed with error %d\n", WSAGetLastError());
    return;
   }

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

   // 把监听socket和绑定TCP/IP协议栈做一个绑定...
   if (bind(Listen, (PSOCKADDR) &InternetAddr, sizeof(InternetAddr)) == SOCKET_ERROR)
   {
    printf("bind() failed with error %d\n", WSAGetLastError());
    return;
   }

   // 设置一次能接受5个连接
   if (listen(Listen, 5) == SOCKET_ERROR)
   {
    printf("listen() failed with error %d\n", WSAGetLastError());
    return;
   }

   //
   // 下面是服务器程序标准的循环了...
   //
   while(TRUE)
   {
    if ((Accept = WSAAccept(Listen, NULL, NULL, NULL, 0)) == SOCKET_ERROR)
    {
     printf("WSAAccept() failed with error %d\n", WSAGetLastError());
     return;
    }

    //
    // 接收到一个连接就new一个新的socket并承揽下连接进来的socket的接下来的接待/处理工作
    // 为什么不用new呢?我想是因为用Windows提供的内存管理函数,这样的话在业务量大的情况下
    // 出现内存匮乏的情况下不至于直接就异常了,怎么着也就是该次的内存分配失败...
    //
    if ((PerHandleData = (LPPER_HANDLE_DATA) GlobalAlloc(GPTR, sizeof(PER_HANDLE_DATA))) == NULL)
    {
     printf("GlobalAlloc() failed with error %d\n", GetLastError());
     return;
    }

    // Associate the accepted socket with the original completion port.

    printf("Socket number %d connected\n", Accept);
    PerHandleData->Socket = Accept;

    //
    // 把accept socket和IO完成端口关联/绑定起来,并把accept socket传给IOCP机制这样的话
    // 当调用GetQueuedCompletionStatus的时候就可以得到该值.
    //
    if (CreateIoCompletionPort((HANDLE) Accept, CompletionPort, (DWORD) PerHandleData,
     0) == NULL)
    {
     printf("CreateIoCompletionPort failed with error %d\n", GetLastError());
     return;
    }

    // 下面这个结构体也是会被传到工作线程中去的,怎么传呢?注意看下面红色部分
    if ((PerIoData = (LPPER_IO_OPERATION_DATA) GlobalAlloc(GPTR,sizeof(PER_IO_OPERATION_DATA))) == NULL)
    {
     printf("GlobalAlloc() failed with error %d\n", GetLastError());
     return;
    }

    ZeroMemory(&(PerIoData->Overlapped), sizeof(OVERLAPPED));
    PerIoData->BytesSEND = 0;
    PerIoData->BytesRECV = 0;
    PerIoData->DataBuf.len = DATA_BUFSIZE;
    PerIoData->DataBuf.buf = PerIoData->Buffer;

    Flags = 0;

    //
    // 在accept socket上面发起IO请求:WSARecv()以此激发IOCP工作机制..
    // 注意WSARecv的第五个参数,也就是说我这时候告诉WSARecv的不仅仅是
    // PerIoData->Overlapped的地址同时也是PerIoData的地址...
    //
    if (WSARecv(Accept, &(PerIoData->DataBuf), 1, &RecvBytes, &Flags,
     &(PerIoData->Overlapped), NULL) == SOCKET_ERROR)
    {
     if (WSAGetLastError() != ERROR_IO_PENDING)
     {
      printf("WSARecv() failed with error %d\n", WSAGetLastError());
      return;
     }
    }
   }
  }

  //
  // 工作线程
  //
  DWORD WINAPI ServerWorkerThread(LPVOID CompletionPortID)
  {
   HANDLE CompletionPort = (HANDLE) CompletionPortID;
   DWORD BytesTransferred;
   LPOVERLAPPED Overlapped;
   LPPER_HANDLE_DATA PerHandleData;
   LPPER_IO_OPERATION_DATA PerIoData;
   DWORD SendBytes, RecvBytes;
   DWORD Flags;

   while(TRUE)
   {

    //
    // 这个函数解释清楚了整个机制也就明白了...
    // 首先我们看CompletionPort应该没有问题,是从创建线程的主线程传过来的.
    // BytesTransferred指明了这次IO传输了多少Bytes...
    // PerHandleData是CreateIoCompletionPort的时候穿过来的,MSDN里面叫CompletionKey.
    // 请注意PerIoData这个参数,本来按照MSDN的解释如下:
    // "Pointer to a variable that receives the address of the OVERLAPPED structure that was
    // specified when the completed I/O operation was started."
    // 其实在这这个lpOverlapped传过来的就是上面WSARecv传入的overlapped的地址...
    // 这下明白了吧:主线程借着overlapped的名声传了一个结构体指针过来..:-)
    //
    if (GetQueuedCompletionStatus(CompletionPort, &BytesTransferred,
     (LPDWORD)&PerHandleData, (LPOVERLAPPED *) &PerIoData, INFINITE) == 0)
    {
     printf("GetQueuedCompletionStatus failed with error %d\n", GetLastError());
     return 0;
    }

    //
    // First check to see if an error has occured on the socket and if so
    // then close the socket and cleanup the SOCKET_INFORMATION structure
    // associated with the socket.
    //

    if (BytesTransferred == 0)
    {
     printf("Closing socket %d\n", PerHandleData->Socket);

     if (closesocket(PerHandleData->Socket) == SOCKET_ERROR)
     {
      printf("closesocket() failed with error %d\n", WSAGetLastError());
      return 0;
     }

     GlobalFree(PerHandleData);
     GlobalFree(PerIoData);
     continue;
    }

    //
    // Check to see if the BytesRECV field equals zero. If this is so, then
    // this means a WSARecv call just completed so update the BytesRECV field
    // with the BytesTransferred value from the completed WSARecv() call.
    //

    if (PerIoData->BytesRECV == 0)
    {
     PerIoData->BytesRECV = BytesTransferred;
     PerIoData->BytesSEND = 0;
    }
    else
    {
     PerIoData->BytesSEND += BytesTransferred;
    }

    if (PerIoData->BytesRECV > PerIoData->BytesSEND)
    {

     //
     // Post another WSASend() request.
     // Since WSASend() is not gauranteed to send all of the bytes requested,
     // continue posting WSASend() calls until all received bytes are sent.
     //
     ZeroMemory(&(PerIoData->Overlapped), sizeof(OVERLAPPED));

     PerIoData->DataBuf.buf = PerIoData->Buffer + PerIoData->BytesSEND;
     PerIoData->DataBuf.len = PerIoData->BytesRECV - PerIoData->BytesSEND;

     if (WSASend(PerHandleData->Socket, &(PerIoData->DataBuf), 1, &SendBytes, 0,
      &(PerIoData->Overlapped), NULL) == SOCKET_ERROR)
     {
      if (WSAGetLastError() != ERROR_IO_PENDING)
      {
       printf("WSASend() failed with error %d\n", WSAGetLastError());
       return 0;
      }
     }
    }
    else
    {
     PerIoData->BytesRECV = 0;

     // Now that there are no more bytes to send post another WSARecv() request.
     Flags = 0;
     ZeroMemory(&(PerIoData->Overlapped), sizeof(OVERLAPPED));

     PerIoData->DataBuf.len = DATA_BUFSIZE;
     PerIoData->DataBuf.buf = PerIoData->Buffer;

     if (WSARecv(PerHandleData->Socket, &(PerIoData->DataBuf), 1, &RecvBytes, &Flags,
      &(PerIoData->Overlapped), NULL) == SOCKET_ERROR)
     {
      if (WSAGetLastError() != ERROR_IO_PENDING)
      {
       printf("WSARecv() failed with error %d\n", WSAGetLastError());
       return 0;
      }
     }
    }
   }
  }

Socket（套接字）是通过标准的UNIX文件描述符和其它程序通讯的一个方法。每一个套接字都用一个半相关描述：{协议，本地地址、本地端口}来表示；一个完整的套接字则用一个相关描述：{协议，本地地址、本地端口、远程地址、远程端口}，每一个套接字都有一个本地的由操作系统分配的唯一的套接字号。

3、 Socket的三种类型

（1） 流式Socket（SOCK_STREAM）

流式套接字提供可靠的、面向连接的通信流；它使用TCP协议，从而保证了数据传输的正确性和顺序的。

（2） 数据报Socket（SOCK_DGRAM）

数据报套接字定义了一种无连接的服务，数据通过相互独立的报文进行传输，是无序的，并且不保证可靠、无差错。它使用数据报协议UDP

（3） 原始Socket

原始套接字允许对底层协议如IP或ICMP直接访问，它功能强大但使用较为不便，主要用于一些协议的开发。

4、 利用套接字发送数据

1、 对于流式套接字用系统调用send（）来发送数据。

2、对于数据报套接字，则需要自己先加一个信息头，然后调用sendto（）函数把数据发送出去。

5、 Linux中Socket的数据结构

（1） struct sockaddr { //用于存储套接字地址

unsigned short sa_family；//地址类型

char sa_data[14]； //14字节的协议地址

}；

（2） struct sockaddr_in{ //in 代表internet

short int sin_family； //internet协议族

unsigned short int sin_port；//端口号，必须是网络字节顺序

struct in_addr sin_addr；//internet地址，必须是网络字节顺序

unsigned char sin_zero；//添0（和struct sockaddr一样大小

}；

（3） struct in_addr{

unsigned long s_addr；

}；

6、 网络字节顺序及其转换函数

（1） 网络字节顺序

每一台机器内部对变量的字节存储顺序不同，而网络传输的数据是一定要统一顺序的。所以对内部字节表示顺序与网络字节顺序不同的机器，一定要对数据进行转换，从程序的可移植性要求来讲，就算本机的内部字节表示顺序与网络字节顺序相同也应该在传输数据以前先调用数据转换函数，以便程序移植到其它机器上后能正确执行。真正转换还是不转换是由系统函数自己来决定的。

（2） 有关的转换函数

* unsigned short int htons（unsigned short int hostshort）：

主机字节顺序转换成网络字节顺序，对无符号短型进行操作4bytes

* unsigned long int htonl（unsigned long int hostlong）：

主机字节顺序转换成网络字节顺序，对无符号长型进行操作8bytes

* unsigned short int ntohs（unsigned short int netshort）：

网络字节顺序转换成主机字节顺序，对无符号短型进行操作4bytes

* unsigned long int ntohl（unsigned long int netlong）：

网络字节顺序转换成主机字节顺序，对无符号长型进行操作8bytes

注：以上函数原型定义在netinet/in.h里

7、 IP地址转换

有三个函数将数字点形式表示的字符串IP地址与32位网络字节顺序的二进制形式的IP地址进行转换

（1） unsigned long int inet_addr(const char * cp)：该函数把一个用数字和点表示的IP地址的字符串转换成一个无符号长整型，如：struct sockaddr_in ina

ina.sin_addr.s_addr=inet_addr("202.206.17.101")

该函数成功时：返回转换结果；失败时返回常量INADDR_NONE，该常量=-1，二进制的无符号整数-1相当于255.255.255.255，这是一个广播地址，所以在程序中调用iner_addr（）时，一定要人为地对调用失败进行处理。由于该函数不能处理广播地址，所以在程序中应该使用函数inet_aton（）。

（2）int inet_aton（const char * cp,struct in_addr * inp）：此函数将字符串形式的IP地址转换成二进制形式的IP地址；成功时返回1，否则返回0，转换后的IP地址存储在参数inp中。

（3） char * inet_ntoa（struct in-addr in）：将32位二进制形式的IP地址转换为数字点形式的IP地址，结果在函数返回值中返回，返回的是一个指向字符串的指针。

8、 字节处理函数

Socket地址是多字节数据，不是以空字符结尾的，这和C语言中的字符串是不同的。Linux提供了两组函数来处理多字节数据，一组以b（byte）开头，是和BSD系统兼容的函数，另一组以mem（内存）开头，是ANSI C提供的函数。

以b开头的函数有：

（1） void bzero（void * s,int n）：将参数s指定的内存的前n个字节设置为0，通常它用来将套接字地址清0。

（2） void bcopy（const void * src，void * dest，int n）：从参数src指定的内存区域拷贝指定数目的字节内容到参数dest指定的内存区域。

（3） int bcmp（const void * s1，const void * s2，int n）：比较参数s1指定的内存区域和参数s2指定的内存区域的前n个字节内容，如果相同则返回0，否则返回非0。

注：以上函数的原型定义在strings.h中。

以mem开头的函数有：

（1） void * memset（void * s，int c，size_t n）：将参数s指定的内存区域的前n个字节设置为参数c的内容。

（2） void * memcpy（void * dest，const void * src，size_t n）：功能同bcopy（），区别：函数bcopy（）能处理参数src和参数dest所指定的区域有重叠的情况，memcpy（）则不能。

（4） int memcmp（const void * s1，const void * s2，size_t n）：比较参数s1和参数s2指定区域的前n个字节内容，如果相同则返回0，否则返回非0。

注：以上函数的原型定义在string.h中。

9、 基本套接字函数

（1） socket（）

#include<sys/types.h>

#include<sys/socket.h>

int socket(int domain，int type，int protocol)

参数domain指定要创建的套接字的协议族，可以是如下值：

AF_UNIX //UNIX域协议族，本机的进程间通讯时使用

AF_INET //Internet协议族（TCP/IP）

AF_ISO //ISO协议族

参数type指定套接字类型，可以是如下值：

SOCK_STREAM //流套接字，面向连接的和可靠的通信类型

SOCK_DGRAM //数据报套接字，非面向连接的和不可靠的通信类型

SOCK_RAW //原始套接字，只对Internet协议有效，可以用来直接访问IP协议

参数protocol通常设置成0，表示使用默认协议，如Internet协议族的流套接字使用TCP协议，而数据报套接字使用UDP协议。当套接字是原始套接字类型时，需要指定参数protocol，因为原始套接字对多种协议有效，如ICMP和IGMP等。

Linux系统中创建一个套接字的操作主要是：在内核中创建一个套接字数据结构，然后返回一个套接字描述符标识这个套接字数据结构。这个套接字数据结构包含连接的各种信息，如对方地址、TCP状态以及发送和接收缓冲区等等，TCP协议根据这个套接字数据结构的内容来控制这条连接。

（2） 函数connect（）

#include<sys/types.h>

#include<sys/socket.h>

int connect（int sockfd，struct sockaddr * servaddr，int addrlen）

参数sockfd是函数socket返回的套接字描述符；参数servaddr指定远程服务器的套接字地址，包括服务器的IP地址和端口号；参数addrlen指定这个套接字地址的长度。成功时返回0，否则返回-1，并设置全局变量为以下任何一种错误类型：ETIMEOUT、ECONNREFUSED、EHOSTUNREACH或ENETUNREACH。

在调用函数connect之前，客户机需要指定服务器进程的套接字地址。客户机一般不需要指定自己的套接字地址（IP地址和端口号），系统会自动从1024至5000的端口号范围内为它选择一个未用的端口号，然后以这个端口号和本机的IP地址填充这个套接字地址。

客户机调用函数connect来主动建立连接。这个函数将启动TCP协议的3次握手过程。在建立连接之后或发生错误时函数返回。连接过程可能出现的错误情况有：

（1）如果客户机TCP协议没有接收到对它的SYN数据段的确认，函数以错误返回，错误类型为ETIMEOUT。通常TCP协议在发送SYN数据段失败之后，会多次发送SYN数据段，在所有的发送都高中失败之后，函数以错误返回。

注：SYN（synchronize）位：请求连接。TCP用这种数据段向对方TCP协议请求建立连接。在这个数据段中，TCP协议将它选择的初始序列号通知对方，并且与对方协议协商最大数据段大小。SYN数据段的序列号为初始序列号，这个SYN数据段能够被确认。当协议接收到对这个数据段的确认之后，建立TCP连接。

（2）如果远程TCP协议返回一个RST数据段，函数立即以错误返回，错误类型为ECONNREFUSED。当远程机器在SYN数据段指定的目的端口号处没有服务进程在等待连接时，远程机器的TCP协议将发送一个RST数据段，向客户机报告这个错误。客户机的TCP协议在接收到RST数据段后不再继续发送SYN数据段，函数立即以错误返回。

注：RST（reset）位：表示请求重置连接。当TCP协议接收到一个不能处理的数据段时，向对方TCP协议发送这种数据段，表示这个数据段所标识的连接出现了某种错误，请求TCP协议将这个连接清除。有3种情况可能导致TCP协议发送RST数据段：（1）SYN数据段指定的目的端口处没有接收进程在等待；（2）TCP协议想放弃一个已经存在的连接；（3）TCP接收到一个数据段，但是这个数据段所标识的连接不存在。接收到RST数据段的TCP协议立即将这条连接非正常地断开，并向应用程序报告错误。

（3）如果客户机的SYN数据段导致某个路由器产生“目的地不可到达”类型的ICMP消息，函数以错误返回，错误类型为EHOSTUNREACH或ENETUNREACH。通常TCP协议在接收到这个ICMP消息之后，记录这个消息，然后继续几次发送SYN数据段，在所有的发送都告失败之后，TCP协议检查这个ICMP消息，函数以错误返回。

注：ICMP：Internet 消息控制协议。Internet的运行主要是由Internet的路由器来控制，路由器完成IP数据包的发送和接收，如果发送数据包时发生错误，路由器使用ICMP协议来报告这些错误。ICMP数据包是封装在IP数据包的数据部分中进行传输的，其格式如下：

类型

码

校验和

数据

0 8 16 24 31

类型：指出ICMP数据包的类型。

代码：提供ICMP数据包的进一步信息。

校验和：提供了对整个ICMP数据包内容的校验和。

ICMP数据包主要有以下类型：

（1）目的地不可到达：A、目的主机未运行；B、目的地址不存在；C、路由表中没有目的地址对应的条目，因而路由器无法找到去往目的主机的路由。

（2）超时：路由器将接收到的IP数据包的生存时间（TTL）域减1，如果这个域的值变为0，路由器丢弃这个IP数据包，并且发送这种ICMP消息。

（3） 参数出错：当IP数据包中有无效域时发送。

（4） 重定向：将一条新的路径通知主机。

（5） ECHO请求、ECHO回答：这两条消息用语测试目的主机是否可以到达。请求者向目的主机发送ECHO请求ICMP数据包，目的主机在接收到这个ICMP数据包之后，返回ECHO回答ICMP数据包。

（6）时戳请求、时戳回答：ICMP协议使用这两种消息从其他机器处获得其时钟的当前时间。

调用函数connect的过程中，当客户机TCP协议发送了SYN数据段的确认之后，TCP状态由CLOSED状态转为SYN_SENT状态，在接收到对SYN数据段的确认之后，TCP状态转换成ESTABLISHED状态，函数成功返回。如果调用函数connect失败，应该用close关闭这个套接字描述符，不能再次使用这个套接字描述符来调用函数connect。

注：TCP协议状态转换图：

被动OPEN CLOSE 主动OPEN

（建立TCB） （删除TCB） （建立TCB，

发送SYN）

接收SYN SEND

（发送SYN，ACK） （发送SYN）

接收SYN的ACK（无动作）

接收SYN的ACK 接收SYN，ACK

（无动作） （发送ACK）

CLOSE

（发送FIN） CLOSE 接收FIN

（发送FIN） （发送FIN）

接收FIN

接收FIN的ACK（无动作） （发送ACK） CLOSE（发送FIN）

接收FIN 接收FIN的ACK 接收FIN的ACK

（发送ACK） （无动作） （无动作）

2MSL超时（删除TCB）

（3） 函数bind（）

函数bind将本地地址与套接字绑定在一起，其定义如下：

#include<sys/types.h>

#include<sys/socket.h>

int bind(int sockfd,struct sockaddr * myaddr,int addrlen)；

参数sockfd是函数sockt返回的套接字描述符；参数myaddr是本地地址；参数addrlen是套接字地址结构的长度。执行成功时返回0，否则，返回-1，并设置全局变量errno为错误类型EADDRINUSER。

服务器和客户机都可以调用函数bind来绑定套接字地址，但一般是服务器调用函数bind来绑定自己的公认端口号。绑定操作一般有如下几种组合方式：

表1

程序类型

IP地址

端口号

说明

服务器

INADDR_ANY

非零值

指定服务器的公认端口号

服务器

本地IP地址

非零值

指定服务器的IP地址和公认端口号

客户机

INADDR_ANY

非零值

指定客户机的连接端口号

客户机

本地IP地址

非零值

指定客户机的IP地址连接端口号

客户机

本地IP地址

零

指定客户机的IP地址

分别说明如下：

（1）服务器指定套接字地址的公认端口号，不指定IP地址：即服务器调用bind时，设置套接字的IP地址为特殊的INADDE-ANY，表示它愿意接收来自任何网络设备接口的客户机连接。这是服务器最常用的绑定方式。

（2）服务器指定套接字地址的公认端口号和IP地址：服务器调用bind时，如果设置套接字的IP地址为某个本地IP地址，这表示这台机器只接收来自对应于这个IP地址的特定网络设备接口的客户机连接。当服务器有多块网卡时，可以用这种方式来限制服务器的接收范围。

（3）客户机指定套接字地址的连接端口号：一般情况下，客户机调用connect函数时不用指定自己的套接字地址的端口号。系统会自动为它选择一个未用的端口号，并且用本地的IP地址来填充套接字地址中的相应项。但有时客户机需要使用一个特定的端口号（比如保留端口号），而系统不会未客户机自动分配一个保留端口号，所以需要调用函数bind来和一个未用的保留端口号绑定。

（4）指定客户机的IP地址和连接端口号：表示客户机使用指定的网络设备接口和端口号进行通信。

（5）指定客户机的IP地址：表示客户机使用指定的网络设备接口和端口号进行通信，系统自动为客户机选一个未用的端口号。一般只有在主机有多个网络设备接口时使用。

我们一般不在客户机上使用固定的客户机端口号，除非是必须使用的情况。在客户机上使用固定的端口号有以下不利：

（1）服务器执行主动关闭操作：服务器最后进入TIME_WAIT状态。当客户机再次与这个服务器进行连接时，仍使用相同的客户机端口号，于是这个连接与前次连接的套接字对完全一样，但是一呢、为前次连接处于TIME_WAIT状态，并未消失，所以这次连接请求被拒绝，函connect以错误返回，错误类型为ECONNREFUSED

（2）客户机执行主动关闭操作：客户机最后进入TIME_WAIT状态。当马上再次执行这个客户机程序时，客户机将继续与这个固定客户机端口号绑定，但因为前次连接处于TIME_WAIT状态，并未消失，系统会发现这个端口号仍被占用，所以这次绑定操作失败，函数bind以错误返回，错误类型为EADDRINUSE。

（4） 函数listen（）

函数listen将一个套接字转换为征听套接字，定义如下；

#include<sys/socket,h>

int listen(int sockfd，int backlog)

参数sockfd指定要转换的套接字描述符；参数backlog设置请求队列的最大长度；执行成功时返回0，否则返回-1。函数listen功能有两个：

（1）将一个尚未连接的主动套接字（函数socket创建的可以用来进行主动连接但不能接受连接请求的套接字）转换成一个被动连接套接字。执行listen之后，服务器的TCP状态由CLOSED转为LISTEN状态。

（2） TCP协议将到达的连接请求队列，函数listen的第二个参数指定这个队列的最大长度。

注：参数backlog的作用：

TCP协议为每一个征听套接字维护两个队列：

（1）未完成连接队列：每个尚未完成3次握手操作的TCP连接在这个队列中占有一项。TCP希望仪在接收到一个客户机SYN数据段之后，在这个队列中创建一个新条目，然后发送对客户机SYN数据段的确认和自己的SYN数据段（ACK+SYN数据段），等待客户机对自己的SYN数据段的确认。此时，套接字处于SYN_RCVD状态。这个条目将保存在这个队列中，直到客户机返回对SYN数据段的确认或者连接超时。

（2）完成连接队列：每个已经完成3次握手操作，但尚未被应用程序接收（调用函数accept）的TCP连接在这个队列中占有一项。当一个在未完成连接队列中的连接接收到对SYN数据段的确认之后，完成3次握手操作，TCP协议将它从未完成连接队列移到完成连接队列中。此时，套接字处于ESTABLISHED状态。这个条目将保存在这个队列中，直到应用程序调用函数accept来接收它。

参数backlog指定某个征听套接字的完成连接队列的最大长度，表示这个套接字能够接收的最大数目的未接收连接。如果当一个客户机的SYN数据段到达时，征听套接字的完成队列已经满了，那么TCP协议将忽略这个SYN数据段。对于不能接收的SYN数据段，TCP协议不发送RST数据段，

（5） 函数accept（）

函数accept从征听套接字的完成队列中接收一个已经建立起来的TCP连接。如果完成连接队列为空，那么这个进程睡眠。

#include<sys/socket.h>

int accept(int sockfd，struct sockaddr * addr，int * addrlen)

参数sockfd指定征听套接字描述符；参数addr为指向一个Internet套接字地址结构的指针；参数addrlen为指向一个整型变量的指针。执行成功时，返回3个结果：函数返回值为一个新的套接字描述符，标识这个接收的连接；参数addr指向的结构变量中存储客户机地址；参数addrlen指向的整型变量中存储客户机地址的长度。失败时返回-1。

征听套接字专为接收客户机连接请求，完成3次握手操作而用的，所以TCP协议不能使用征听套接字描述符来标识这个连接，于是TCP协议创建一个新的套接字来标识这个要接收的连接，并将它的描述符发挥给应用程序。现在有两个套接字，一个是调用函数accept时使用的征听套接字，另一个是函数accept返回的连接套接字（connected socket）。一个服务器通常只需创建一个征听套接字，在服务器进程的整个活动期间，用它来接收所有客户机的连接请求，在服务器进程终止前关闭这个征听套接字；对于没一个接收的（accepted）连接，TCP协议都创建一个新的连接套接字来标识这个连接，服务器使用这个连接套接字与客户机进行通信操作，当服务器处理完这个客户机请求时，关闭这个连接套接字。

当函数accept阻塞等待已经建立的连接时，如果进程捕获到信号，函数将以错误返回，错误类型为EINTR。对于这种错误，一般重新调用函数accept来接收连接。

（6） 函数close（）

函数close关闭一个套接字描述符。定义如下：

#include<unistd.h>

int close(int sockfd)；

执行成功时返回0，否则返回-1。与操作文件描述符的close一样，函数close将套接字描述符的引用计数器减1，如果描述符的引用计数大于0，则表示还有进程引用这个描述符，函数close正常返回；如果为0，则启动清除套接字描述符的操作，函数close立即正常返回。

调用close之后，进程将不再能够访问这个套接字，但TCP协议将继续使用这个套接字，将尚未发送的数据传递到对方，然后发送FIN数据段，执行关闭操作，一直等到这个TCP连接完全关闭之后，TCP协议才删除该套接字。

（7） 函数read（）和write（）

用于从套接字读写数据。定义如下：

int read(int fd，char * buf，int len)

int write(int fd，char * buf，int len)

函数执行成功时，返回读或写的数据量的大小，失败时返回-1。

每个TCP套接字都有两个缓冲区：套接字发送缓冲区、套接字接收缓冲区，分别处理发送和接收任务。从网络读、写数据的操作是由TCP协议在内核中完成的：TCP协议将从网络上接收到的数据保存在相应套接字的接收缓冲区中，等待用户调用函数将它们从接收缓冲区拷贝到用户缓冲区；用户将要发送的数据拷贝到相应套接字的发送缓冲区中，然后由TCP协议按照一定的算法处理这些数据。

读写连接套接字的操作与读写文件的操作类似，也可以使用函数read和write。函数read完成将数据从套接字接收缓冲区拷贝到用户缓冲区：当套接字接收缓冲区有数据可读时，1：可读数据量大于函数read指定值，返回函数参数len指定的数据量；2：了度数据量小于函数read指定值，函数read不等待请求的所有数据都到达，而是立即返回实际读到的数据量；当无数据可读时，函数read将阻塞不返回，等待数据到达。

当TCP协议接收到FIN数据段，相当于给读操作一个文件结束符，此时read函数返回0，并且以后所有在这个套接字上的读操作均返回0，这和普通文件中遇到文件结束符是一样的。

当TCP协议接收到RST数据段，表示连接出现了某种错误，函数read将以错误返回，错误类型为ECONNERESET。并且以后所有在这个套接字上的读操作均返回错误。错误返回时返回值小于0。

函数write完成将数据从用户缓冲区拷贝到套接字发送缓冲区的任务：到套接字发送缓冲区有足够拷贝所有用户数据的空间时，函数write将数据拷贝到这个缓冲区中，并返回老辈的数量大小，如果可用空间小于write参数len指定的大小时，函数write将阻塞不返回，等待缓冲区有足够的空间。

当TCP协议接收到RST数据段（当对方已经关闭了这条连接之后，继续向这个套接字发送数据将导致对方TCP协议返回RST数据段），TCP协议接收到RST数据段时，函数write将以错误返回，错误类型为EINTR。以后可以继续在这个套接字上写数据。

（8） 函数getsockname（）和getpeername（）

函数getsockname返回套接字的本地地址；函数getpeername返回套接字对应的远程地址。

10、 结束语

网络程序设计全靠套接字接收和发送信息。上文主要讲述了Linux 下Socket的基本概念、Sockets API以及Socket所涉及到的TCP常识。

I have been writing server applications on Windows server platforms for quite sometime. We all know that I/O completion port is one of the nicest things available for writing server applications (or even in clients where you can apply Worker-Boss pattern). There are tons of articles and samples to show how I/O completion port can be used with TCP/IP. Surprisingly enough, I did not find any source code examples to demonstrate the use of I/O completion ports with UDP.

To spice up things a little, I took the multicast topic to demonstrate the code. Most of the multicast code is borrowed from Mr. Bob Quinn's article.

This sample consists of two projects (Client and Server). In order to test this application as it is, routers in your network should be enabled for multicast routing. If not, modify samples appropriately to act just UDP server and client.

Since there is so much written about I/O completion port and multicast, I won't go into all the details in this article.

Server application design and implementation is an art. You can put so many bells and whistles. Typical server application should have the following:

1. Object Pooling

   If any of the object is to be created and destroyed often, consider making a pool of such objects. Typical example would be your sockets, user context objects, database connections.

2. Ease of configuration

   Do not hardcode configuration information in the code. Try to use XML configuration files. Let the application read these vales during the startup. Typical examples would be, IP address of other servers, Oracle TNS names, user ids and passwords (!!!), number of worker threads, email addresses etc.

   Besides, there should be some mechanism to change these parameters while the server is running.

3. Monitoring and logging

   Since most of these servers will be running somewhere in the data center, it is nice to have a small component sitting in your server application which will send log messages to central server from where you multicast those messages to other client applications. Make sure you have very good filtering mechanism so that you can control the number of messages being logged during the run time.

4. Error handling

   Your servers have to be running nonstop (four nines most of the time). That means you should have proper error handling mechanism. Make use of SEH in a responsible manner. Besides keep track of number of TCP connections (using SNMP) and CPU usage, memory usage (Microsoft provides a library by which you can query all these parameters from within your program).

5. Thread Synchronization

   Make sure you thread protects the shared data.

6. Load balancing.

   You can not serve infinite number of clients from one server box. Always keep the 'scale-out' factor in mind. Do proper capacity planning to quantify your server hardware requirement. 80-20 rule is quite effective.

Source Code

Collapse

//NOTE
// 
//This code taken from Mr. Bob Quinn's article 
//titled 'Internet Multicasting'
//published in Dr. Dobb's Journal dated Oct 1997
//I have modified the original code to illustrate 
//the use I/O completion ports with UDP.
//If you have any comments email me : shapall@hotmail.com
#include "StdAfx.h"
#include <winsock2.h>
#include <ws2tcpip.h>
#include "Stdio.h"
#define BUFSIZE 1024 //max size of incoming data buffer
#define MAXADDRSTR 16
#define DEFAULT_GROUP_ADDRESS "239.254.1.2"
#define DEFAULT_PORT 7125 
LONG nCount = 0;
HANDLE g_hCompletionPort;
DWORD WINAPI WorkerThread( LPVOID WorkContext );
BOOL HandleIncomingData( UCHAR* pBuf);
BOOL CreateNetConnections( VOID );
BOOL CreateWorkers( UINT );
void InitWinsock2();
void UnInitWinsock2();
HANDLE g_hReadEvent;
SOCKET g_hSocket;
UCHAR achInBuf [BUFSIZE];
char achMCAddr[MAXADDRSTR] = DEFAULT_GROUP_ADDRESS;
u_short nPort = DEFAULT_PORT;
OVERLAPPED Overlapped;
//-----------------------------------------------------------------
void InitWinsock2()
{
WSADATA data;
WORD version;
int ret = 0;
version = (MAKEWORD(2, 2));
ret = WSAStartup(version, &data);
if (ret != 0)
{
ret = WSAGetLastError();
if (ret == WSANOTINITIALISED)
{
printf("not initialised");
}
}
}
//-----------------------------------------------------------------
void UnInitWinsock2()
{
WSACleanup();
}
//-----------------------------------------------------------------
BOOL CreateNetConnections (void)
{
DWORD nbytes;
BOOL b;
BOOL fFlag = TRUE;
int nRet=0;
SOCKADDR_IN stLclAddr;
struct ip_mreq stMreq; // Multicast interface structure  
// Get a datagram socket  
g_hSocket = socket(AF_INET, SOCK_DGRAM,0);
if (g_hSocket == INVALID_SOCKET)
{
printf ("socket() failed, Err: %d\n", WSAGetLastError());
return FALSE;
}
nRet = setsockopt(g_hSocket,SOL_SOCKET,
SO_REUSEADDR, (char *)&fFlag, sizeof(fFlag));
if (nRet == SOCKET_ERROR)
{
printf ("setsockopt() SO_REUSEADDR failed,
Err: %d\n",WSAGetLastError());
}
// Name the socket (assign the local port number to receive on)  
stLclAddr.sin_family = AF_INET;
stLclAddr.sin_addr.s_addr = htonl(INADDR_ANY);
stLclAddr.sin_port = htons(nPort);
nRet = bind(g_hSocket,(struct sockaddr*) &stLclAddr,sizeof(stLclAddr));
if (nRet == SOCKET_ERROR)
{
printf ("bind() port: %d failed, Err: %d\n",
nPort,WSAGetLastError());
}
// Join the multicast group so we can receive from it  
stMreq.imr_multiaddr.s_addr = inet_addr(achMCAddr);
stMreq.imr_interface.s_addr = INADDR_ANY;
nRet = setsockopt(g_hSocket,IPPROTO_IP,
IP_ADD_MEMBERSHIP,(char *)&stMreq,sizeof(stMreq));
if (nRet == SOCKET_ERROR)
{
printf("setsockopt() IP_ADD_MEMBERSHIP address %s failed,
Err: %d\n",achMCAddr,
WSAGetLastError());
}
//
//note the 10 says how many concurrent cpu bound threads to allow thru 
//this should be tunable based on the requests. CPU bound requests will 
// really really honor this. 
// 
g_hCompletionPort = CreateIoCompletionPort (INVALID_HANDLE_VALUE,
NULL,0,3);
if (!g_hCompletionPort)
{
fprintf (stdout, "g_hCompletionPort Create Failed\n");
return FALSE;
}
//Associate this socket to this I/O completion port 
CreateIoCompletionPort((HANDLE)g_hSocket,g_hCompletionPort,
(DWORD)g_hSocket,3);
//
// Start off an asynchronous read on the socket.  
//  
Overlapped.hEvent = g_hReadEvent;
Overlapped.Internal = 0;
Overlapped.InternalHigh = 0;
Overlapped.Offset = 0;
Overlapped.OffsetHigh = 0;
b = ReadFile ((HANDLE)g_hSocket,&achInBuf,
sizeof(achInBuf),&nbytes,&Overlapped);
if (!b && GetLastError () != ERROR_IO_PENDING)
{
fprintf (stdout, "ReadFile Failed\n");
return FALSE;
}
return TRUE;
}
//-----------------------------------------------------------------
BOOL CreateWorkers (UINT dwNumberOfWorkers)
{
DWORD ThreadId;
HANDLE ThreadHandle;
DWORD i;
for (i = 0; i < dwNumberOfWorkers; i++)
{
ThreadHandle = CreateThread (NULL,0,
WorkerThread,NULL,0,&ThreadId);
if (!ThreadHandle)
{
fprintf (stdout, "Create Worker Thread Failed\n");
return FALSE;
}
CloseHandle (ThreadHandle);
}
return TRUE;
}
//-----------------------------------------------------------------
DWORD WINAPI WorkerThread (LPVOID WorkContext)
{
DWORD nSocket;
BOOL b;
OVERLAPPED ovl;
LPOVERLAPPED lpo=&ovl;
DWORD nBytesRead=0;
DWORD nBytesToBeRead;
UCHAR ReadBuffer[BUFSIZE];
LPVOID lpMsgBuf;
memset(&ReadBuffer,0,BUFSIZE);
for (;;)
{
b = GetQueuedCompletionStatus(g_hCompletionPort,
&nBytesToBeRead,&nSocket,&lpo,INFINITE);
if (b || lpo)
{
if (b)
{
// 
// Determine how long a response was desired by the client. 
// 
OVERLAPPED ol;
ol.hEvent = g_hReadEvent;
ol.Offset = 0;
ol.OffsetHigh = 0;
b = ReadFile ((HANDLE)nSocket,&ReadBuffer,
nBytesToBeRead,&nBytesRead,&ol);
if (!b )
{
DWORD dwErrCode = GetLastError();
if( dwErrCode != ERROR_IO_PENDING )
{
// something has gone wrong here... 
printf("Something has gone
wrong:Error code - %d\n",dwErrCode );
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, dwErrCode,
MAKELANGID(LANG_NEUTRAL,
SUBLANG_DEFAULT),// Default language
(LPTSTR) &lpMsgBuf, 0, NULL);
OutputDebugString((LPCTSTR)lpMsgBuf);
//Free the buffer. 
LocalFree(lpMsgBuf );
}
else if( dwErrCode == ERROR_IO_PENDING )
{
// I had to do this for my UDP sample 
//Never did for my TCP servers 
WaitForSingleObject(ol.hEvent,INFINITE);
HandleIncomingData(ReadBuffer);
}
}
else
{
HandleIncomingData(ReadBuffer);
}
continue;
}
else
{
fprintf (stdout, "WorkThread Wait Failed\n");
//exit (1); 
}
}
return 1;
}
}
//-----------------------------------------------------------------
BOOL HandleIncomingData( UCHAR* pBuf)
{
InterlockedIncrement(&nCount);
SYSTEMTIME *lpstSysTime;
lpstSysTime = (SYSTEMTIME *)(pBuf);
printf("[%d]UTC Time %02d:%02d:%02d:%03d on %02d-%02d-%d \n",nCount,
lpstSysTime->wHour, lpstSysTime->wMinute,
lpstSysTime->wSecond, lpstSysTime->wMilliseconds,
lpstSysTime->wMonth, lpstSysTime->wDay, lpstSysTime->wYear);
memset(&pBuf,0,BUFSIZE);
//just making sure that i am not showing stale data 
return TRUE;
}
//-----------------------------------------------------------------
main ()
{
//You can modify your program to take some arguments for port number 
//and multicast group address here 
printf("\n***************************************\n");
printf("Group IP address: %s\n",achMCAddr);
printf("Port number : %d\n",nPort);
printf("\n***************************************\n");
//Initialize winsock 2 
InitWinsock2();
//We want to keep the main thread running 
HANDLE hWait2Exit = CreateEvent(NULL,FALSE,TRUE,"MCLIENT");
ResetEvent(hWait2Exit );
//This OVERLAPPED event 
g_hReadEvent = CreateEvent(NULL,TRUE,TRUE,NULL);
// 
// try to get timing more accurate... Avoid context 
// switch that could occur when threads are released 
// 
SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL);
if (!CreateNetConnections ())
{
printf("Error condition @ CreateNetConnections , exiting\n");
return 1;
}
if (!CreateWorkers (5))
{
printf("Error condition @CreateWorkers, exiting\n");
return 1;
}
WaitForSingleObject(hWait2Exit,INFINITE);
UnInitWinsock2();
return 1;
}

IOCP的三个函数：CreateIoCompletionPort、GetQueuedCompletionStatus、PostQueuedCompletionStatus；一个是用来创建想要的IOCP的HANDLE同时也是用来把我们想要的SOCKET绑定到这个HANDLE上，一个是获取IO这个HANDLE上对应的对列的状态，看有没有事件完成，一个是用来通知所有工作线程退出（这个函数我还没用到，关于这个功用是看资料上说的）。

我在写这个代码的时候，最主要的问题就是当通信完成了之后，是怎么样来判断是哪个SOCKET的哪个状态（SEND还是RECV）完成了。《WINDOWS网络编程》这本书里给的代码不是很全的哦，它的配套光盘又没有，不过好在CSDN里CB那块中有个朋友刚好帖出了这一章的代码。通过比较和一夜的思量，算是搞明白啦。主要的就是以下的数据：

1、在第二次CreateIoCompletionPort中，会传进去一个CompletionKey，这个就是要来关联到我们想要的SOCKET上的一些感兴趣的数据内容，当然最好是要一个SOCKET，也可以是其它，看自己程序的需要了。而通过GetQueueCompletionStatus的通过，就可以获得这些数据的地址了。

typedef struct _PER_HANDLE_DATA
{
    SOCKET sock;
}PER_HANDLE_DATA,* LPPER_HANDLE_DATA;

2、第二个主要的数据结构就是这个了，现在真的是佩服当初设计这个结构的人啊（没办法，自己就是没想到这样利用法）。因为在POST操作（SEND或是RECV）是，都要一个OVERLAPPED，所以就把这个OVERLAPPED和要指明这次POST操作类型的代码OperationType（POST_SEND或POST_RECV）以及其它一些数据（比如接发收的缓冲）。这样子，在GetQueueCompletionStatus的时候，通过获取事件，也同时得到了OperationType和缓冲。这样，知道了通信类型，也得到了缓冲数据的缓冲区。这样就可以控制我们的通信了。

这个例子比较简单，没有复杂的数据处理过程（正在设计中，和大家交流交流）。用的是BCB的平台，不过写法上还是和VC里的一模一样的啊。

typedef struct _PER_IO_OPERATION_DATA
{
    OVERLAPPED Overlapped;
    WSABUF DataBuff[1];
    char Buff[24];
    BOOL OperationType;
}PER_IO_OPERATION_DATA,* LPPER_IO_OPERATION_DATA;

简单的客户端：

//---------------------------------------------------------------------------

#pragma hdrstop
#include <winsock2.h>
#include <stdio.h>
#include <iostream>
using namespace std;
//---------------------------------------------------------------------------

#pragma argsused

SOCKET sockClient;
struct sockaddr_in addrServer;
char buf[24];
int n = 0;
int Init();

int main(int argc, char* argv[])
{
    if(Init() != 0)
        goto theend;

    sockClient = socket(AF_INET,SOCK_STREAM,0);
    if(sockClient == INVALID_SOCKET)
    {
        cout<<"socket 失败"<<endl;
        WSACleanup();
        goto theend;
    }
    memset(&addrServer,0,sizeof(sockaddr_in));
    addrServer.sin_family = AF_INET;
    addrServer.sin_addr.s_addr = inet_addr("127.0.0.1");
    addrServer.sin_port = htons(9090);
    cout<<"连接服务器..."<<endl;
    if(connect(sockClient,(const struct sockaddr *)&addrServer,sizeof(sockaddr)) != 0)
    {
        cout<<"connect 失败"<<endl;
        WSACleanup();
        goto theend;
    }
    cout<<"开始发送测试包"<<endl;
    memset(buf,0,24);
    while(true)
    {
        sprintf(buf,"第%d个包", n);
        cout<<"发送："<<buf<<endl;
        if(send(sockClient,buf,strlen(buf),0) <= 0)
        {
            cout<<"send失败,可能连接断开"<<endl;
            //break;
            goto theend;
        }
        memset(buf,0,24);

        //接收服务端应答
        if(recv(sockClient,buf,24,0) <= 0)
        {
            cout<<"recv失败,可能连接断开"<<endl;
           //break;
           goto theend;
        }
        cout<<"服务器应答："<<buf<<endl;
        memset(buf,0,24);

        Sleep(200);
        n++;
    }

   
theend:
    WSACleanup();
    getchar();
    return 0;
}
//---------------------------------------------------------------------------
int Init()
{
    WSAData wsaData;
    if(WSAStartup(MAKEWORD(2,2),&wsaData) != 0)
    {
        cout<<"WSAStartup失败"<<endl;
        return -1;
    }

    if(LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
    {
        cout<<"SOCKET版本不对"<<endl;
        WSACleanup();
        return -1;
    }
    return 0;
}

服务端。

//---------------------------------------------------------------------------

#pragma hdrstop

//---------------------------------------------------------------------------
#pragma argsused
#pragma comment(lib,"ws2_32.lib")
#include <stdio.h>
#include <memory.h>
#include <winsock2.h>
#include <iostream>
using namespace std;

#define RECV_POSTED 1001
#define SEND_POSTED 1002

int Init();

HANDLE hCompletionPort;
typedef struct _PER_HANDLE_DATA
{
    SOCKET sock;
}PER_HANDLE_DATA,* LPPER_HANDLE_DATA;

typedef struct _PER_IO_OPERATION_DATA
{
    OVERLAPPED Overlapped;
    WSABUF DataBuff[1];
    char Buff[24];
    BOOL OperationType;
}PER_IO_OPERATION_DATA,* LPPER_IO_OPERATION_DATA;

DWORD WINAPI ServerWorkerThread(LPVOID CompletionPort);

int main(int argc, char* argv[])
{
    LPPER_HANDLE_DATA perHandleData;
    LPPER_IO_OPERATION_DATA ioperdata;
    SYSTEM_INFO siSys;
    SOCKET sockListen;
    struct sockaddr_in addrLocal;
    char buf[24];
    int nRet = 0;
    DWORD nThreadID;
    SOCKET sockAccept;
    DWORD dwFlags;
    DWORD dwRecvBytes;
    int nReuseAddr = 1;

    cout<<"初始环境..."<<endl;
    if(Init() != 0)
        goto theend;

    //创建一个IO完成端口
    cout<<"创建一个IO完成端口"<<endl;
    hCompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,0);
    if(hCompletionPort == INVALID_HANDLE_VALUE)
    {
        cout<<"创建IO完成端口失败"<<endl;
        goto theend;
    }
    //获取CPU数目
    GetSystemInfo(&siSys);
    //创建一定数目的工作者线程，本例中以一个处理器一个线程搭配
    for(int i = 0;i<(int)siSys.dwNumberOfProcessors*2;i++)//NumberOfProcessors
    {
        HANDLE hThread;
        hThread = CreateThread(NULL,0,ServerWorkerThread,(LPVOID)hCompletionPort,0,&nThreadID);
        cout<<"创建工作者线程"<<i<<endl;
        CloseHandle(hThread);
    }
    //创建监听SOCKET
    cout<<"创建监听SOCKET"<<endl;
    sockListen = WSASocket(AF_INET,SOCK_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED);
    if(sockListen == SOCKET_ERROR)
    {
        cout<<"WSASocket错误"<<endl;
        goto theend;
    }

    if(setsockopt(sockListen,SOL_SOCKET,SO_REUSEADDR,(const char *)&nReuseAddr,sizeof(int)) != 0)
    {
        cout<<"setsockopt错误"<<endl;
        goto theend;
    }
    addrLocal.sin_family = AF_INET;
    addrLocal.sin_addr.s_addr = htonl(INADDR_ANY);
    addrLocal.sin_port = htons(9090);
    if(bind(sockListen,(struct sockaddr *)&addrLocal,sizeof(sockaddr_in)) != 0)
    {
        cout<<"bind错误"<<endl;
        int n = WSAGetLastError();
        goto theend;
    }
    //准备监听
    cout<<"准备监听"<<endl;
    if(listen(sockListen,5)!=0)
    {
        cout<<"listen错误"<<endl;
        goto theend;
    }
    while(true)
    {
        //接收用户连接，被和完成端口关联
        sockAccept = WSAAccept(sockListen,NULL,NULL,NULL,0);
        perHandleData = (LPPER_HANDLE_DATA)malloc(sizeof(PER_HANDLE_DATA));
        if(perHandleData == NULL)
            continue;
        cout<<"socket number "<<sockAccept<<"接入"<<endl;
        perHandleData->sock = sockAccept;

        ioperdata = (LPPER_IO_OPERATION_DATA)malloc(sizeof(PER_IO_OPERATION_DATA));
        memset(&(ioperdata->Overlapped),0,sizeof(OVERLAPPED));
        (ioperdata->DataBuff[0]).len = 24;
        (ioperdata->DataBuff[0]).buf = ioperdata->Buff;
        ioperdata->OperationType = RECV_POSTED;
        if( ioperdata == NULL)
        {
            free(perHandleData);
            continue;
        }
        //关联
        cout<<"关联SOCKET和完成端口"<<endl;
        if(CreateIoCompletionPort((HANDLE)sockAccept,hCompletionPort,(DWORD)perHandleData,1) == NULL)
        {
            cout<<sockAccept<<"createiocompletionport错误"<<endl;
            free(perHandleData);
            free(ioperdata);
            continue;
        }
        //投递接收操作
        cout<<"投递接收操作"<<endl;
        WSARecv(perHandleData->sock,ioperdata->DataBuff,1,&dwRecvBytes,&dwFlags,&(ioperdata->Overlapped),NULL);
    }
theend:
    getchar();
    return 0;
}
//---------------------------------------------------------------------------
int Init()
{
    WSAData wsaData;
    if(WSAStartup(MAKEWORD(2,2),&wsaData) != 0)
    {
        cout<<"WSAStartup失败"<<endl;
        return -1;
    }

    if(LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
    {
        cout<<"SOCKET版本不对"<<endl;
        WSACleanup();
        return -1;
    }
    return 0;
}

DWORD WINAPI ServerWorkerThread(LPVOID CompletionPort)
{
    HANDLE ComPort = (HANDLE)CompletionPort;
    DWORD BytesTransferred;
    LPOVERLAPPED Overlapped;
    LPPER_HANDLE_DATA PerHandleData;
    LPPER_IO_OPERATION_DATA PerIoData;
    DWORD SendBytes,RecvBytes;
    DWORD Flags;
    BOOL bT;

    while(TRUE)
    {
        //等待完成端口上SOCKET的完成
        cout<<"等待完成端口上SOCKET的完成"<<endl;
        bT = GetQueuedCompletionStatus(ComPort,
            &BytesTransferred,(LPDWORD)&PerHandleData,
            (LPOVERLAPPED *)&PerIoData,INFINITE);

        //检查是否有错误产生
        if(BytesTransferred == 0 &&
            (PerIoData->OperationType == RECV_POSTED ||
            PerIoData->OperationType == SEND_POSTED))
        {
            //关闭SOCKET
            cout<<PerHandleData->sock<<"SOCKET关闭"<<endl;
            closesocket(PerHandleData->sock);
            free(PerHandleData);
            free(PerIoData);
            continue;
        }

        //为请求服务
       
        if(PerIoData->OperationType == RECV_POSTED)
        {
            //处理
            cout<<"接收处理"<<endl;
            cout<<PerHandleData->sock<<"SOCKET :"<<PerIoData->Buff<<endl;
            //回应客户端
            ZeroMemory(PerIoData->Buff,24);
            strcpy(PerIoData->Buff,"OK");
            Flags = 0;
            ZeroMemory((LPVOID)&(PerIoData->Overlapped),sizeof(OVERLAPPED));
            PerIoData->DataBuff[0].len = 2;
            PerIoData->DataBuff[0].buf = PerIoData->Buff;
            PerIoData->OperationType = SEND_POSTED;
            WSASend(PerHandleData->sock,PerIoData->DataBuff,
                1,&SendBytes,0,&(PerIoData->Overlapped),NULL);
        }
        else //if(PerIoData->OperationType == SEND_POSTED)
        {
            //发送时的处理
            cout<<"发送处理"<<endl;
            Flags = 0;
            ZeroMemory((LPVOID)&(PerIoData->Overlapped),sizeof(OVERLAPPED));
            ZeroMemory(PerIoData->Buff,24);
            PerIoData->DataBuff[0].len = 24;
            PerIoData->DataBuff[0].buf = PerIoData->Buff;
            PerIoData->OperationType = RECV_POSTED;
            WSARecv(PerHandleData->sock,PerIoData->DataBuff,
                1,&RecvBytes,&Flags,&(PerIoData->Overlapped),NULL);
        }
    }
}

API与响应规模

通过Win32的重叠I/O机制，应用程序可以提请一项I/O操作，重叠的操作请求在后台完成，而同一时间提请操作的线程去做其他的事情。等重叠操作完成后线程收到有关的通知。这种机制对那些耗时的操作而言特别有用。不过，像Windows 3.1上的WSAAsyncSelect()及Unix下的select()那样的函数虽然易于使用，但是它们不能满足响应规模的需要。而完成端口机制是针对操作系统内部进行了优化，在Windows NT 和 Windows 2000上，使用了完成端口的重叠I/O机制才能够真正扩大系统的响应规模。

完成端口

一个完成端口其实就是一个通知队列，由操作系统把已经完成的重叠I/O请求的通知放入其中。当某项I/O操作一旦完成，某个可以对该操作结果进行处理的工作者线程就会收到一则通知。而套接字在被创建后，可以在任何时候与某个完成端口进行关联。

通常情况下，我们会在应用程序中创建一定数量的工作者线程来处理这些通知。线程数量取决于应用程序的特定需要。理想的情况是，线程数量等于处理器的数量，不过这也要求任何线程都不应该执行诸如同步读写、等待事件通知等阻塞型的操作，以免线程阻塞。每个线程都将分到一定的CPU时间，在此期间该线程可以运行，然后另一个线程将分到一个时间片并开始执行。如果某个线程执行了阻塞型的操作，操作系统将剥夺其未使用的剩余时间片并让其它线程开始执行。也就是说，前一个线程没有充分使用其时间片，当发生这样的情况时，应用程序应该准备其它线程来充分利用这些时间片。

完成端口的使用分为两步。首先创建完成端口，如以下代码所示：

HANDLE    hIocp;
hIocp = CreateIoCompletionPort(
INVALID_HANDLE_VALUE,
NULL,
(ULONG_PTR)0,
0);
if (hIocp == NULL) {
// Error
}

完成端口创建后，要把将使用该完成端口的套接字与之关联起来。方法是再次调用CreateIoCompletionPort ()函数，第一个参数FileHandle设为套接字的句柄，第二个参数ExistingCompletionPort 设为刚刚创建的那个完成端口的句柄。
以下代码创建了一个套接字，并把它和前面创建的完成端口关联起来：

SOCKET    s;
s = socket(AF_INET, SOCK_STREAM, 0);
if (s == INVALID_SOCKET) {
// Error
if (CreateIoCompletionPort((HANDLE)s,
hIocp,
(ULONG_PTR)0,
0) == NULL)
{
// Error
}
...
}

这时就完成了套接字与完成端口的关联操作。在这个套接字上进行的任何重叠操作都将通过完成端口发出完成通知。注意，CreateIoCompletionPort()函数中的第三个参数用来设置一个与该套接字相关的“完成键(completion key)”(译者注：完成键可以是任何数据类型)。每当完成通知到来时，应用程序可以读取相应的完成键，因此，完成键可用来给套接字传递一些背景信息。

在创建了完成端口、将一个或多个套接字与之相关联之后，我们就要创建若干个线程来处理完成通知。这些线程不断循环调用GetQueuedCompletionStatus ()函数并返回完成通知。

下面，我们先来看看应用程序如何跟踪这些重叠操作。当应用程序调用一个重叠操作函数时，要把指向一个overlapped结构的指针包括在其参数中。当操作完成后，我们可以通过GetQueuedCompletionStatus()函数中拿回这个指针。不过，单是根据这个指针所指向的overlapped结构，应用程序并不能分辨究竟完成的是哪个操作。要实现对操作的跟踪，你可以自己定义一个OVERLAPPED结构，在其中加入所需的跟踪信息。

无论何时调用重叠操作函数时，总是会通过其lpOverlapped参数传递一个OVERLAPPEDPLUS结构(例如WSASend、 WSARecv等函数)。这就允许你为每一个重叠调用操作设置某些操作状态信息，当操作结束后，你可以通过GetQueuedCompletionStatus()函数获得你自定义结构的指针。注意OVERLAPPED字段不要求一定是这个扩展后的结构的第一个字段。当得到了指向OVERLAPPED结构的指针以后，可以用CONTAINING_RECORD宏取出其中指向扩展结构的指针。

OVERLAPPED 结构的定义如下：

typedef struct _OVERLAPPEDPLUS {
OVERLAPPED        ol;
SOCKET            s, sclient;
int               OpCode;
WSABUF            wbuf;
DWORD             dwBytes, dwFlags;
// 其它有用的信息
} OVERLAPPEDPLUS;
#define OP_READ     0
#define OP_WRITE    1
#define OP_ACCEPT   2

下面让我们来看看工作者线程的情况。

工作线程WorkerThread代码：

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
ULONG_PTR       *PerHandleKey;
OVERLAPPED      *Overlap;
OVERLAPPEDPLUS  *OverlapPlus,
*newolp;
DWORD           dwBytesXfered;
while (1)
{
ret = GetQueuedCompletionStatus(
hIocp,
&dwBytesXfered,
(PULONG_PTR)&PerHandleKey,
&Overlap,
INFINITE);
if (ret == 0)
{
// Operation failed
continue;
}
OverlapPlus = CONTAINING_RECORD(Overlap, OVERLAPPEDPLUS, ol);
switch (OverlapPlus->OpCode)
{
case OP_ACCEPT:
// Client socket is contained in OverlapPlus.sclient
// Add client to completion port
CreateIoCompletionPort(
(HANDLE)OverlapPlus->sclient,
hIocp,
(ULONG_PTR)0,
0);
//  Need a new OVERLAPPEDPLUS structure
//  for the newly accepted socket. Perhaps
//  keep a look aside list of free structures.
newolp = AllocateOverlappedPlus();
if (!newolp)
{
// Error
}
newolp->s = OverlapPlus->sclient;
newolp->OpCode = OP_READ;
// This function prepares the data to be sent
PrepareSendBuffer(&newolp->wbuf);
ret = WSASend(
newolp->s,
&newolp->wbuf,
1,
&newolp->dwBytes,
0,
&newolp.ol,
NULL);
if (ret == SOCKET_ERROR)
{
if (WSAGetLastError() != WSA_IO_PENDING)
{
// Error
}
}
// Put structure in look aside list for later use
FreeOverlappedPlus(OverlapPlus);
// Signal accept thread to issue another AcceptEx
SetEvent(hAcceptThread);
break;
case OP_READ:
// Process the data read
// ...
// Repost the read if necessary, reusing the same
// receive buffer as before
memset(&OverlapPlus->ol, 0, sizeof(OVERLAPPED));
ret = WSARecv(
OverlapPlus->s,
&OverlapPlus->wbuf,
1,
&OverlapPlus->dwBytes,
&OverlapPlus->dwFlags,
&OverlapPlus->ol,
NULL);
if (ret == SOCKET_ERROR)
{
if (WSAGetLastError() != WSA_IO_PENDING)
{
// Error
}
}
break;
case OP_WRITE:
// Process the data sent, etc.
break;
} // switch
} // while
}  // WorkerThread

其中每句柄键(PerHandleKey)变量的内容，是在把完成端口与套接字进行关联时所设置的完成键参数；Overlap参数返回的是一个指向发出重叠操作时所使用的那个OVERLAPPEDPLUS结构的指针。

要记住，如果重叠操作调用失败时(也就是说，返回值是SOCKET_ERROR，并且错误原因不是WSA_IO_PENDING)，那么完成端口将不会收到任何完成通知。如果重叠操作调用成功，或者发生原因是WSA_IO_PENDING的错误时，完成端口将总是能够收到完成通知。

Windows NT和Windows 2000的套接字架构

对于开发大响应规模的Winsock应用程序而言，对Windows NT和Windows 2000的套接字架构有基本的了解是很有帮助的。下图是Windows 2000中的Winsock架构：

与其它类型操作系统不同，Windows NT和Windows 2000的传输协议没有一种风格像套接字那样的、可以和应用程序直接交谈的界面，而是采用了一种更为底层的API，叫做传输驱动程序界面(Transport Driver Interface,TDI)。Winsock的核心模式驱动程序负责连接和缓冲区管理，以便向应用程序提供套接字仿真(在AFD.SYS文件中实现)，同时负责与底层传输驱动程序对话。

谁来负责管理缓冲区？

正如上面所说的，应用程序通过Winsock来和传输协议驱动程序交谈，而AFD.SYS负责为应用程序进行缓冲区管理。也就是说，当应用程序调用send()或WSASend()函数来发送数据时，AFD.SYS将把数据拷贝进它自己的内部缓冲区(取决于SO_SNDBUF设定值)，然后send()或WSASend()函数立即返回。也可以这么说，AFD.SYS在后台负责把数据发送出去。不过，如果应用程序要求发出的数据超过了SO_SNDBUF设定的缓冲区大小，那么WSASend()函数会阻塞，直至所有数据发送完毕。

从远程客户端接收数据的情况也类似。只要不用从应用程序那里接收大量的数据，而且没有超出SO_RCVBUF设定的值，AFD.SYS将把数据先拷贝到其内部缓冲区中。当应用程序调用recv()或WSARecv()函数时，数据将从内部缓冲拷贝到应用程序提供的缓冲区。

多数情况下，这样的架构运行良好，特别在是应用程序采用传统的套接字下非重叠的send()和receive()模式编写的时候。不过程序员要小心的是，尽管可以通过setsockopt()这个API来把SO_SNDBUF和SO_RCVBUF选项值设成0(关闭内部缓冲区)，但是程序员必须十分清楚把AFD.SYS的内部缓冲区关掉会造成什么后果，避免收发数据时有关的缓冲区拷贝可能引起的系统崩溃。

举例来说，一个应用程序通过设定SO_SNDBUF为0把缓冲区关闭，然后发出一个阻塞send()调用。在这样的情况下，系统内核会把应用程序的缓冲区锁定，直到接收方确认收到了整个缓冲区后send()调用才返回。似乎这是一种判定你的数据是否已经为对方全部收到的简洁的方法，实际上却并非如此。想想看，即使远端TCP通知数据已经收到，其实也根本不代表数据已经成功送给客户端应用程序，比如对方可能发生资源不足的情况，导致AFD.SYS不能把数据拷贝给应用程序。另一个更要紧的问题是，在每个线程中每次只能进行一次发送调用，效率极其低下。

把SO_RCVBUF设为0，关闭AFD.SYS的接收缓冲区也不能让性能得到提升，这只会迫使接收到的数据在比Winsock更低的层次进行缓冲，当你发出receive调用时，同样要进行缓冲区拷贝，因此你本来想避免缓冲区拷贝的阴谋不会得逞。

现在我们应该清楚了，关闭缓冲区对于多数应用程序而言并不是什么好主意。只要要应用程序注意随时在某个连接上保持几个WSARecvs重叠调用，那么通常没有必要关闭接收缓冲区。如果AFD.SYS总是有由应用程序提供的缓冲区可用，那么它将没有必要使用内部缓冲区。

高性能的服务器应用程序可以关闭发送缓冲区，同时不会损失性能。不过，这样的应用程序必须十分小心，保证它总是发出多个重叠发送调用，而不是等待某个重叠发送结束了才发出下一个。如果应用程序是按一个发完再发下一个的顺序来操作，那浪费掉两次发送中间的空档时间，总之是要保证传输驱动程序在发送完一个缓冲区后，立刻可以转向另一个缓冲区。

资源的限制条件

在设计任何服务器应用程序时，其强健性是主要的目标。也就是说，

你的应用程序要能够应对任何突发的问题，例如并发客户请求数达到峰值、可用内存临时出现不足、以及其它短时间的现象。这就要求程序的设计者注意Windows NT和2000系统下的资源限制条件的问题，从容地处理突发性事件。

你可以直接控制的、最基本的资源就是网络带宽。通常，使用用户数据报协议(UDP)的应用程序都可能会比较注意带宽方面的限制，以最大限度地减少包的丢失。然而，在使用TCP连接时，服务器必须十分小心地控制好，防止网络带宽过载超过一定的时间，否则将需要重发大量的包或造成大量连接中断。关于带宽管理的方法应根据不同的应用程序而定，这超出了本文讨论的范围。

虚拟内存的使用也必须很小心地管理。通过谨慎地申请和释放内存，或者应用lookaside lists(一种高速缓存)技术来重新使用已分配的内存，将有助于控制服务器应用程序的内存开销(原文为“让服务器应用程序留下的脚印小一点”)，避免操作系统频繁地将应用程序申请的物理内存交换到虚拟内存中(原文为“让操作系统能够总是把更多的应用程序地址空间更多地保留在内存中”)。你也可以通过SetWorkingSetSize()这个Win32 API让操作系统分配给你的应用程序更多的物理内存。

在使用Winsock时还可能碰到另外两个非直接的资源不足情况。一个是被锁定的内存页面的极限。如果你把AFD.SYS的缓冲关闭，当应用程序收发数据时，应用程序缓冲区的所有页面将被锁定到物理内存中。这是因为内核驱动程序需要访问这些内存，在此期间这些页面不能交换出去。如果操作系统需要给其它应用程序分配一些可分页的物理内存，而又没有足够的内存时就会发生问题。我们的目标是要防止写出一个病态的、锁定所有物理内存、让系统崩溃的程序。也就是说，你的程序锁定内存时，不要超出系统规定的内存分页极限。

在Windows NT和2000系统上，所有应用程序总共可以锁定的内存大约是物理内存的1/8(不过这只是一个大概的估计，不是你计算内存的依据)。如果你的应用程序不注意这一点，当你的发出太多的重叠收发调用，而且I/O没来得及完成时，就可能偶尔发生ERROR_INSUFFICIENT_RESOURCES的错误。在这种情况下你要避免过度锁定内存。同时要注意，系统会锁定包含你的缓冲区所在的整个内存页面，因此缓冲区靠近页边界时是有代价的(译者理解，缓冲区如果正好超过页面边界，那怕是1个字节，超出的这个字节所在的页面也会被锁定)。

另外一个限制是你的程序可能会遇到系统未分页池资源不足的情况。所谓未分页池是一块永远不被交换出去的内存区域，这块内存用来存储一些供各种内核组件访问的数据，其中有的内核组件是不能访问那些被交换出去的页面空间的。Windows NT和2000的驱动程序能够从这个特定的未分页池分配内存。

当应用程序创建一个套接字(或者是类似的打开某个文件)时，内核会从未分页池中分配一定数量的内存，而且在绑定、连接套接字时，内核又会从未分页池中再分配一些内存。当你注意观察这种行为时你将发现，如果你发出某些I/O请求时(例如收发数据)，你会从未分页池里再分配多一些内存(比如要追踪某个待决的I/O操作，你可能需要给这个操作添加一个自定义结构，如前文所提及的)。最后这就可能会造成一定的问题，操作系统会限制未分页内存的用量。

在Windows NT和2000这两种操作系统上，给每个连接分配的未分页内存的具体数量是不同的，未来版本的Windows很可能也不同。为了使应用程序的生命期更长，你就不应该计算对未分页池内存的具体需求量。

你的程序必须防止消耗到未分页池的极限。当系统中未分页池剩余空间太小时，某些与你的应用程序毫无关系的内核驱动就会发疯，甚至造成系统崩溃，特别是当系统中有第三方设备或驱动程序时，更容易发生这样的惨剧(而且无法预测)。同时你还要记住，同一台电脑上还可能运行有其它同样消耗未分页池的其它应用程序，因此在设计你的应用程序时，对资源量的预估要特别保守和谨慎。

处理资源不足的问题是十分复杂的，因为发生上述情况时你不会收到特别的错误代码，通常你只能收到一般性的WSAENOBUFS或者ERROR_INSUFFICIENT_RESOURCES 错误。要处理这些错误，首先，把你的应用程序工作配置调整到合理的最大值(译者注：所谓工作配置，是指应用程序各部分运行中所需的内存用量，请参考 http://msdn.microsoft.com/msdnmag/issues/1000/Bugslayer/Bugslayer1000.asp ，关于内存优化，译者另有译文)，如果错误继续出现，那么注意检查是否是网络带宽不足的问题。之后，请确认你没有同时发出太多的收发调用。最后，如果还是收到资源不足的错误，那就很可能是遇到了未分页内存池不足的问题了。要释放未分页内存池空间，请关闭应用程序中相当部分的连接，等待系统自行渡过和修正这个瞬时的错误。

接受连接请求

服务器要做的最普通的事情之一就是接受来自客户端的连接请求。在套接字上使用重叠I/O接受连接的惟一API就是AcceptEx()函数。有趣的是，通常的同步接受函数accept()的返回值是一个新的套接字，而AcceptEx()函数则需要另外一个套接字作为它的参数之一。这是因为AcceptEx()是一个重叠操作，所以你需要事先创建一个套接字(但不要绑定或连接它)，并把这个套接字通过参数传给AcceptEx()。以下是一小段典型的使用AcceptEx()的伪代码：

do {
-等待上一个 AcceptEx 完成
-创建一个新套接字并与完成端口进行关联
-设置背景结构等等
-发出一个 AcceptEx 请求
}while(TRUE);

作为一个高响应能力的服务器，它必须发出足够的AcceptEx调用，守候着，一旦出现客户端连接请求就立刻响应。至于发出多少个AcceptEx才够，就取决于你的服务器程序所期待的通信交通类型。比如，如果进入连接率高的情况(因为连接持续时间较短，或者出现交通高峰)，那么所需要守候的AcceptEx当然要比那些偶尔进入的客户端连接的情况要多。聪明的做法是，由应用程序来分析交通状况，并调整AcceptEx守候的数量，而不是固定在某个数量上。

对于Windows2000，Winsock提供了一些机制，帮助你判定AcceptEx的数量是否足够。这就是，在创建监听套接字时创建一个事件，通过WSAEventSelect()这个API并注册FD_ACCEPT事件通知来把套接字和这个事件关联起来。一旦系统收到一个连接请求，如果系统中没有AcceptEx()正在等待接受连接，那么上面的事件将收到一个信号。通过这个事件，你就可以判断你有没有发出足够的AcceptEx()，或者检测出一个非正常的客户请求(下文述)。这种机制对Windows NT 4.0不适用。

使用AcceptEx()的一大好处是，你可以通过一次调用就完成接受客户端连接请求和接受数据(通过传送lpOutputBuffer参数)两件事情。也就是说，如果客户端在发出连接的同时传输数据，你的AcceptEx()调用在连接创建并接收了客户端数据后就可以立刻返回。这样可能是很有用的，但是也可能会引发问题，因为AcceptEx()必须等全部客户端数据都收到了才返回。具体来说，如果你在发出AcceptEx()调用的同时传递了lpOutputBuffer参数，那么AcceptEx()不再是一项原子型的操作，而是分成了两步：接受客户连接，等待接收数据。当缺少一种机制来通知你的应用程序所发生的这种情况：“连接已经建立了，正在等待客户端数据”，这将意味着有可能出现客户端只发出连接请求，但是不发送数据。如果你的服务器收到太多这种类型的连接时，它将拒绝连接更多的合法客户端请求。这就是黑客进行“拒绝服务”攻击的常见手法。

要预防此类攻击，接受连接的线程应该不时地通过调用getsockopt()函数(选项参数为SO_CONNECT_TIME)来检查AcceptEx()里守候的套接字。getsockopt()函数的选项值将被设置为套接字被连接的时间，或者设置为-1(代表套接字尚未建立连接)。这时，WSAEventSelect()的特性就可以很好地利用来做这种检查。如果发现连接已经建立，但是很久都没有收到数据的情况，那么就应该终止连接，方法就是关闭作为参数提供给AcceptEx()的那个套接字。注意，在多数非紧急情况下，如果套接字已经传递给AcceptEx()并开始守候，但还未建立连接，那么你的应用程序不应该关闭它们。这是因为即使关闭了这些套接字，出于提高系统性能的考虑，在连接进入之前，或者监听套接字自身被关闭之前，相应的内核模式的数据结构也不会被干净地清除。

发出AcceptEx()调用的线程，似乎与那个进行完成端口关联操作、处理其它I/O完成通知的线程是同一个，但是，别忘记线程里应该尽力避免执行阻塞型的操作。Winsock2分层结构的一个副作用是调用socket()或WSASocket() API的上层架构可能很重要(译者不太明白原文意思，抱歉)。每个AcceptEx()调用都需要创建一个新套接字，所以最好有一个独立的线程专门调用AcceptEx()，而不参与其它I/O处理。你也可以利用这个线程来执行其它任务，比如事件记录。

有关AcceptEx()的最后一个注意事项：要实现这些API，并不需要其它提供商提供的Winsock2实现。这一点对微软特有的其它API也同样适用，比如TransmitFile()和GetAcceptExSockAddrs()，以及其它可能会被加入到新版Windows的API. 在Windows NT和2000上，这些API是在微软的底层提供者DLL(mswsock.dll)中实现的，可通过与mswsock.lib编译连接进行调用，或者通过WSAIoctl() (选项参数为SIO_GET_EXTENSION_FUNCTION_POINTER)动态获得函数的指针。

如果在没有事先获得函数指针的情况下直接调用函数(也就是说，编译时静态连接mswsock.lib，在程序中直接调用函数)，那么性能将很受影响。因为AcceptEx()被置于Winsock2架构之外，每次调用时它都被迫通过WSAIoctl()取得函数指针。要避免这种性能损失，需要使用这些API的应用程序应该通过调用WSAIoctl()直接从底层的提供者那里取得函数的指针。

参见下图套接字架构：



TransmitFile 和 TransmitPackets

Winsock 提供两个专门为文件和内存数据传输进行了优化的函数。其中TransmitFile()这个API函数在Windows NT 4.0 和 Windows 2000上都可以使用，而TransmitPackets()则将在未来版本的Windows中实现。

TransmitFile()用来把文件内容通过Winsock进行传输。通常发送文件的做法是，先调用CreateFile()打开一个文件，然后不断循环调用ReadFile() 和WSASend ()直至数据发送完毕。但是这种方法很没有效率，因为每次调用ReadFile() 和 WSASend ()都会涉及一次从用户模式到内核模式的转换。如果换成TransmitFile()，那么只需要给它一个已打开文件的句柄和要发送的字节数，而所涉及的模式转换操作将只在调用CreateFile()打开文件时发生一次，然后TransmitFile()时再发生一次。这样效率就高多了。

TransmitPackets()比TransmitFile()更进一步，它允许用户只调用一次就可以发送指定的多个文件和内存缓冲区。函数原型如下：

BOOL TransmitPackets(
SOCKET hSocket,
LPTRANSMIT_PACKET_ELEMENT lpPacketArray,
DWORD nElementCount,
DWORD nSendSize,
LPOVERLAPPED lpOverlapped,
DWORD dwFlags
); 

其中，lpPacketArray是一个结构的数组，其中的每个元素既可以是一个文件句柄或者内存缓冲区，该结构定义如下：

typedef struct _TRANSMIT_PACKETS_ELEMENT {
DWORD dwElFlags;
DWORD cLength;
union {
struct {
LARGE_INTEGER     nFileOffset;
HANDLE            hFile;
};
PVOID             pBuffer;
};
} TRANSMIT_FILE_BUFFERS;

其中各字段是自描述型的(self explanatory)。
dwElFlags字段：指定当前元素是一个文件句柄还是内存缓冲区(分别通过常量TF_ELEMENT_FILE 和TF_ELEMENT_MEMORY指定)；
cLength字段：指定将从数据源发送的字节数(如果是文件，这个字段值为0表示发送整个文件)；
结构中的无名联合体：包含文件句柄的内存缓冲区(以及可能的偏移量)。

使用这两个API的另一个好处，是可以通过指定TF_REUSE_SOCKET和TF_DISCONNECT标志来重用套接字句柄。每当API完成数据的传输工作后，就会在传输层级别断开连接，这样这个套接字就又可以重新提供给AcceptEx()使用。采用这种优化的方法编程，将减轻那个专门做接受操作的线程创建套接字的压力(前文述及)。

这两个API也都有一个共同的弱点：Windows NT Workstation 或 Windows 2000 专业版中，函数每次只能处理两个调用请求，只有在Windows NT、Windows 2000服务器版、Windows 2000高级服务器版或 Windows 2000 Data Center中才获得完全支持。

放在一起看看

以上各节中，我们讨论了开发高性能的、大响应规模的应用程序所需的函数、方法和可能遇到的资源瓶颈问题。这些对你意味着什么呢？其实，这取决于你如何构造你的服务器和客户端。当你能够在服务器和客户端设计上进行更好地控制时，那么你越能够避开瓶颈问题。

来看一个示范的环境。我们要设计一个服务器来响应客户端的连接、发送请求、接收数据以及断开连接。那么，服务器将需要创建一个监听套接字，把它与某个完成端口进行关联，为每颗CPU创建一个工作线程。再创建一个线程专门用来发出AcceptEx()。我们知道客户端会在发出连接请求后立刻传送数据，所以如果我们准备好接收缓冲区会使事情变得更为容易。当然，不要忘记不时地轮询AcceptEx()调用中使用的套接字(使用SO_CONNECT_TIME选项参数)来确保没有恶意超时的连接。

该设计中有一个重要的问题要考虑，我们应该允许多少个AcceptEx()进行守候。这是因为，每发出一个AcceptEx()时我们都同时需要为它提供一个接收缓冲区，那么内存中将会出现很多被锁定的页面(前文说过了，每个重叠操作都会消耗一小部分未分页内存池，同时还会锁定所有涉及的缓冲区)。这个问题很难回答，没有一个确切的答案。最好的方法是把这个值做成可以调整的，通过反复做性能测试，你就可以得出在典型应用环境中最佳的值。

好了，当你测算清楚后，下面就是发送数据的问题了，考虑的重点是你希望服务器同时处理多少个并发的连接。通常情况下，服务器应该限制并发连接的数量以及等候处理的发送调用。因为并发连接数量越多，所消耗的未分页内存池也越多；等候处理的发送调用越多，被锁定的内存页面也越多(小心别超过了极限)。这同样也需要反复测试才知道答案。

对于上述环境，通常不需要关闭单个套接字的缓冲区，因为只在AcceptEx()中有一次接收数据的操作，而要保证给每个到来的连接提供接收缓冲区并不是太难的事情。但是，如果客户机与服务器交互的方式变一变，客户机在发送了一次数据之后，还需要发送更多的数据，在这种情况下关闭接收缓冲就不太妙了，除非你想办法保证在每个连接上都发出了重叠接收调用来接收更多的数据。

结论

开发大响应规模的Winsock服务器并不是很可怕，其实也就是设置一个监听套接字、接受连接请求和进行重叠收发调用。通过设置合理的进行守候的重叠调用的数量，防止出现未分页内存池被耗尽，这才是最主要的挑战。按照我们前面讨论的一些原则，你就可以开发出大响应规模的服务器应用程序。

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

//   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;

}