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常识。