Windows Socket五種I/O模型

Winsock 的I/O操作：

1、 兩種I/O模式 
阻塞模式：執行I/O操作完成前會一直進行等待，不會將控制權交給程序。套接字 默認爲阻塞模式。可以通過多線程技術進行處理。 
非阻塞模式：執行I/O操作時，Winsock函數會返回並交出控制權。這種模式使用 起來比較複雜，因爲函數在沒有運行完成就進行返回，會不斷地返回 WSAEWOULDBLOCK錯誤。但功能強大。
爲了解決這個問題，提出了進行I/O操作的一些I/O模型,下面介紹最常見的三種：

Windows Socket五種I/O模型——代碼全攻略

如果你想在Windows平臺上構建服務器應用，那麼I/O模型是你必須考慮的。Windows操作系統提供了選擇（Select）、異步選擇（WSAAsyncSelect）、事件選擇（WSAEventSelect）、重疊I/O（Overlapped I/O）和完成端口（Completion Port)共五種I/O模型。每一種模型均適用於一種特定的應用場景。程序員應該對自己的應用需求非常明確，而且綜合考慮到程序的擴展性和可移植性等因素，作出自己的選擇。

我會以一個迴應反射式服務器（與《Windows網絡編程》第八章一樣）來介紹這五種I/O模型。
我們假設客戶端的代碼如下（爲代碼直觀，省去所有錯誤檢查，以下同）：

#include <WINSOCK2.H>
#include <stdio.h>

#define SERVER_ADDRESS "137.117.2.148"
#define PORT           5150
#define MSGSIZE        1024

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

int main()
{
  WSADATA     wsaData;
  SOCKET      sClient;
  SOCKADDR_IN server;
  char        szMessage[MSGSIZE];
  int         ret;
  
  // Initialize Windows socket library
  WSAStartup(0x0202, &wsaData);

  // Create client socket
  sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Connect to server
  memset(&server, 0, sizeof(SOCKADDR_IN));
  server.sin_family = AF_INET;
  server.sin_addr.S_un.S_addr = inet_addr(SERVER_ADDRESS);
  server.sin_port = htons(PORT);

  connect(sClient, (struct sockaddr *)&server, sizeof(SOCKADDR_IN));

  while (TRUE)
  {
    printf("Send:");
  gets(szMessage);

    // Send message
    send(sClient, szMessage, strlen(szMessage), 0);

    // Receive message
    ret = recv(sClient, szMessage, MSGSIZE, 0);
    szMessage[ret] = '/0';

    printf("Received [%d bytes]: '%s'/n", ret, szMessage);
  }

  // Clean up
  closesocket(sClient);
  WSACleanup();
  return 0;
}

客戶端所做的事情相當簡單，創建套接字，連接服務器，然後不停的發送和接收數據。

比較容易想到的一種服務器模型就是採用一個主線程，負責監聽客戶端的連接請求，當接收到某個客戶端的連接請求後，創建一個專門用於和該客戶端通信的套接字和一個輔助線程。以後該客戶端和服務器的交互都在這個輔助線程內完成。這種方法比較直觀，程序非常簡單而且可移植性好，但是不能利用平臺相關的特性。例如，如果連接數增多的時候（成千上萬的連接），那麼線程數成倍增長，操作系統忙於頻繁的線程間切換，而且大部分線程在其生命週期內都是處於非活動狀態的，這大大浪費了系統的資源。所以，如果你已經知道你的代碼只會運行在Windows平臺上，建議採用Winsock I/O模型。

一.選擇模型
Select（選擇）模型是Winsock中最常見的I/O模型。之所以稱其爲“Select模型”，是由於它的“中心思想”便是利用select函數，實現對I/O的管理。最初設計該模型時，主要面向的是某些使用UNIX操作系統的計算機，它們採用的是Berkeley套接字方案。Select模型已集成到Winsock 1.1中，它使那些想避免在套接字調用過程中被無辜“鎖定”的應用程序，採取一種有序的方式，同時進行對多個套接字的管理。由於Winsock 1.1向後兼容於Berkeley套接字實施方案，所以假如有一個Berkeley套接字應用使用了select函數，那麼從理論角度講，毋需對其進行任何修改，便可正常運行。（節選自《Windows網絡編程》第八章)
下面的這段程序就是利用選擇模型實現的Echo服務器的代碼（已經不能再精簡了）：

#include <winsock.h>
#include <stdio.h>

#define PORT       5150
#define MSGSIZE    1024

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

int    g_iTotalConn = 0;
SOCKET g_CliSocketArr[FD_SETSIZE];

DWORD WINAPI WorkerThread(LPVOID lpParameter);

int main()
{
  WSADATA     wsaData;
  SOCKET      sListen, sClient;
  SOCKADDR_IN local, client;
  int         iaddrSize = sizeof(SOCKADDR_IN);
  DWORD       dwThreadId;

  // Initialize Windows socket library
  WSAStartup(0x0202, &wsaData);

  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  // Create worker thread
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);  

  while (TRUE)
  {
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d/n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    // Add socket to g_CliSocketArr
    g_CliSocketArr[g_iTotalConn++] = sClient;
  }
  
  return 0;
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
  int            i;
  fd_set         fdread;
  int            ret;
  struct timeval tv = {1, 0};
  char           szMessage[MSGSIZE];
  
  while (TRUE)
  {
    FD_ZERO(&fdread);
    for (i = 0; i < g_iTotalConn; i++)
    {
      FD_SET(g_CliSocketArr, &fdread);
    }

    // We only care read event
    ret = select(0, &fdread, NULL, NULL, &tv);

    if (ret == 0)
    {
      // Time expired
      continue;
    }

    for (i = 0; i < g_iTotalConn; i++)
    {
      if (FD_ISSET(g_CliSocketArr, &fdread))
      {
        // A read event happened on g_CliSocketArr
        ret = recv(g_CliSocketArr, szMessage, MSGSIZE, 0);
    if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
    {
     // Client socket closed
          printf("Client socket %d closed./n", g_CliSocketArr);
     closesocket(g_CliSocketArr);
     if (i < g_iTotalConn - 1)
          {            
            g_CliSocketArr[i--] = g_CliSocketArr[--g_iTotalConn];
          }
        }
    else
    {
     // We received a message from client
          szMessage[ret] = '/0';
     send(g_CliSocketArr, szMessage, strlen(szMessage), 0);
        }
      }
    }
  }
  
  return 0;
}

服務器的幾個主要動作如下：
1.創建監聽套接字，綁定，監聽；
2.創建工作者線程；
3.創建一個套接字數組，用來存放當前所有活動的客戶端套接字，每accept一個連接就更新一次數組；
4.接受客戶端的連接。這裏有一點需要注意的，就是我沒有重新定義FD_SETSIZE宏，所以服務器最多支持的併發連接數爲64。而且，這裏決不能無條件的accept,服務器應該根據當前的連接數來決定是否接受來自某個客戶端的連接。一種比較好的實現方案就是採用WSAAccept函數，而且讓WSAAccept回調自己實現的Condition Function。如下所示：

int CALLBACK ConditionFunc(LPWSABUF lpCallerId,LPWSABUF lpCallerData, LPQOS lpSQOS,LPQOS lpGQOS,LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,GROUP FAR * g,DWORD dwCallbackData)
{
if (當前連接數 < FD_SETSIZE)
  return CF_ACCEPT;
else
  return CF_REJECT;
}

工作者線程裏面是一個死循環，一次循環完成的動作是：
1.將當前所有的客戶端套接字加入到讀集fdread中；
2.調用select函數；
3.查看某個套接字是否仍然處於讀集中，如果是，則接收數據。如果接收的數據長度爲0，或者發生WSAECONNRESET錯誤，則表示客戶端套接字主動關閉，這時需要將服務器中對應的套接字所綁定的資源釋放掉，然後調整我們的套接字數組（將數組中最後一個套接字挪到當前的位置上）

除了需要有條件接受客戶端的連接外，還需要在連接數爲0的情形下做特殊處理，因爲如果讀集中沒有任何套接字，select函數會立刻返回，這將導致工作者線程成爲一個毫無停頓的死循環，CPU的佔用率馬上達到100%。

關係到套接字列表的操作都需要使用循環,在輪詢的時候,需要遍歷一次,再新的一輪開始時,將列表加入隊列又需要遍歷一次.也就是說,Select在工作一次時,需要至少遍歷2次列表,這是它效率較低的原因之一.在大規模的網絡連接方面,還是推薦使用IOCP或EPOLL模型.但是Select模型可以使用在諸如對戰類遊戲上,比如類似星際這種,因爲它小巧易於實現,而且對戰類遊戲的網絡連接量並不大.

對於Select模型想要突破Windows 64個限制的話,可以採取分段輪詢,一次輪詢64個.例如套接字列表爲128個,在第一次輪詢時,將前64個放入隊列中用Select進行狀態查詢,待本次操作全部結束後.將後64個再加入輪詢隊列中進行輪詢處理.這樣處理需要在非阻塞式下工作.以此類推,Select也能支持無限多個.

二.異步選擇
Winsock提供了一個有用的異步I/O模型。利用這個模型，應用程序可在一個套接字上，接收以Windows消息爲基礎的網絡事件通知。具體的做法是在建好一個套接字後，調用WSAAsyncSelect函數。該模型最早出現於Winsock的1.1版本中，用於幫助應用程序開發者面向一些早期的16位Windows平臺（如Windows for Workgroups），適應其“落後”的多任務消息環境。應用程序仍可從這種模型中得到好處，特別是它們用一個標準的Windows例程（常稱爲"WndProc"），對窗口消息進行管理的時候。該模型亦得到了Microsoft Foundation Class（微軟基本類，MFC）對象CSocket的採納。（節選自《Windows網絡編程》第八章)
我還是先貼出代碼，然後做詳細解釋：
#include <winsock.h>
#include <tchar.h>

#define PORT      5150
#define MSGSIZE   1024
#define WM_SOCKET WM_USER+0

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

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)
{
  static TCHAR szAppName[] = _T("AsyncSelect Model");
  HWND         hwnd ;
  MSG          msg ;
  WNDCLASS     wndclass ;

  wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
  wndclass.lpfnWndProc   = WndProc ;
  wndclass.cbClsExtra    = 0 ;
  wndclass.cbWndExtra    = 0 ;
  wndclass.hInstance     = hInstance ;
  wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
  wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
  wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
  wndclass.lpszMenuName  = NULL ;
  wndclass.lpszClassName = szAppName ;

  if (!RegisterClass(&wndclass))
  {
    MessageBox (NULL, TEXT ("This program requires Windows NT!"), szAppName, MB_ICONERROR) ;
    return 0 ;
  }

  hwnd = CreateWindow (szAppName,                  // window class name
                       TEXT ("AsyncSelect Model"), // window caption
                       WS_OVERLAPPEDWINDOW,        // window style
                       CW_USEDEFAULT,              // initial x position
                       CW_USEDEFAULT,              // initial y position
                       CW_USEDEFAULT,              // initial x size
                       CW_USEDEFAULT,              // initial y size
                       NULL,                       // parent window handle
                       NULL,                       // window menu handle
                       hInstance,                  // program instance handle
                       NULL) ;                     // creation parameters

  ShowWindow(hwnd, iCmdShow);
  UpdateWindow(hwnd);

  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg) ;
    DispatchMessage(&msg) ;
  }
  
  return msg.wParam;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  WSADATA       wsd;
  static SOCKET sListen;
  SOCKET        sClient;
  SOCKADDR_IN   local, client;
  int           ret, iAddrSize = sizeof(client);
  char          szMessage[MSGSIZE];

  switch (message)
  {
case WM_CREATE:
    // Initialize Windows Socket library
  WSAStartup(0x0202, &wsd);
  
  // Create listening socket
    sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    
  // Bind
    local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
  local.sin_family = AF_INET;
  local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(local));
  
  // Listen
    listen(sListen, 3);

    // Associate listening socket with FD_ACCEPT event
  WSAAsyncSelect(sListen, hwnd, WM_SOCKET, FD_ACCEPT);
  return 0;

  case WM_DESTROY:
    closesocket(sListen);
    WSACleanup();
    PostQuitMessage(0);
    return 0;
  
  case WM_SOCKET:
    if (WSAGETSELECTERROR(lParam))
    {
      closesocket(wParam);
      break;
    }
    
    switch (WSAGETSELECTEVENT(lParam))
    {
    case FD_ACCEPT:
      // Accept a connection from client
      sClient = accept(wParam, (struct sockaddr *)&client, &iAddrSize);
      
      // Associate client socket with FD_READ and FD_CLOSE event
      WSAAsyncSelect(sClient, hwnd, WM_SOCKET, FD_READ | FD_CLOSE);
      break;

    case FD_READ:
      ret = recv(wParam, szMessage, MSGSIZE, 0);

      if (ret == 0 || ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET)
      {
        closesocket(wParam);
      }
      else
      {
        szMessage[ret] = '/0';
        send(wParam, szMessage, strlen(szMessage), 0);
      }
      break;
      
    case FD_CLOSE:
      closesocket(wParam);      
      break;
    }
    return 0;
  }
  
  return DefWindowProc(hwnd, message, wParam, lParam);
}

在我看來，WSAAsyncSelect是最簡單的一種Winsock I/O模型（之所以說它簡單是因爲一個主線程就搞定了）。使用Raw Windows API寫過窗口類應用程序的人應該都能看得懂。這裏，我們需要做的僅僅是：
1.在WM_CREATE消息處理函數中，初始化Windows Socket library，創建監聽套接字，綁定，監聽，並且調用WSAAsyncSelect函數表示我們關心在監聽套接字上發生的FD_ACCEPT事件；
2.自定義一個消息WM_SOCKET，一旦在我們所關心的套接字（監聽套接字和客戶端套接字）上發生了某個事件，系統就會調用WndProc並且message參數被設置爲WM_SOCKET；
3.在WM_SOCKET的消息處理函數中，分別對FD_ACCEPT、FD_READ和FD_CLOSE事件進行處理；
4.在窗口銷燬消息(WM_DESTROY)的處理函數中，我們關閉監聽套接字，清除Windows Socket library

下面這張用於WSAAsyncSelect函數的網絡事件類型表可以讓你對各個網絡事件有更清楚的認識：
表1

FD_READ 應用程序想要接收有關是否可讀的通知，以便讀入數據 
FD_WRITE 應用程序想要接收有關是否可寫的通知，以便寫入數據 
FD_OOB 應用程序想接收是否有帶外（OOB）數據抵達的通知 
FD_ACCEPT 應用程序想接收與進入連接有關的通知 
FD_CONNECT 應用程序想接收與一次連接或者多點join操作完成的通知 
FD_CLOSE 應用程序想接收與套接字關閉有關的通知 
FD_QOS 應用程序想接收套接字“服務質量”（QoS）發生更改的通知 
FD_GROUP_QOS  應用程序想接收套接字組“服務質量”發生更改的通知（現在沒什麼用處，爲未來套接字組的使用保留） 
FD_ROUTING_INTERFACE_CHANGE 應用程序想接收在指定的方向上，與路由接口發生變化的通知 
FD_ADDRESS_LIST_CHANGE  應用程序想接收針對套接字的協議家族，本地地址列表發生變化的通知 

三.事件選擇
Winsock提供了另一個有用的異步I/O模型。和WSAAsyncSelect模型類似的是，它也允許應用程序在一個或多個套接字上，接收以事件爲基礎的網絡事件通知。對於表1總結的、由WSAAsyncSelect模型採用的網絡事件來說，它們均可原封不動地移植到新模型。在用新模型開發的應用程序中，也能接收和處理所有那些事件。該模型最主要的差別在於網絡事件會投遞至一個事件對象句柄，而非投遞至一個窗口例程。（節選自《Windows網絡編程》第八章)
還是讓我們先看代碼然後進行分析：
#include <winsock2.h>
#include <stdio.h>

#define PORT    5150
#define MSGSIZE 1024

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

int      g_iTotalConn = 0;
SOCKET   g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
WSAEVENT g_CliEventArr[MAXIMUM_WAIT_OBJECTS];

DWORD WINAPI WorkerThread(LPVOID);
void Cleanup(int index);

int main()
{
  WSADATA     wsaData;
  SOCKET      sListen, sClient;
  SOCKADDR_IN local, client;
  DWORD       dwThreadId;
  int         iaddrSize = sizeof(SOCKADDR_IN);

  // Initialize Windows Socket library
  WSAStartup(0x0202, &wsaData);

  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  // Create worker thread
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

  while (TRUE)
  {
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d/n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    // Associate socket with network event
    g_CliSocketArr[g_iTotalConn] = sClient;
    g_CliEventArr[g_iTotalConn] = WSACreateEvent();
    WSAEventSelect(g_CliSocketArr[g_iTotalConn],
                   g_CliEventArr[g_iTotalConn],
                   FD_READ | FD_CLOSE);
    g_iTotalConn++;
  }
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
  int              ret, index;
  WSANETWORKEVENTS NetworkEvents;
  char             szMessage[MSGSIZE];

  while (TRUE)
  {
    ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);
    if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
    {
      continue;
    }

    index = ret - WSA_WAIT_EVENT_0;
    WSAEnumNetworkEvents(g_CliSocketArr[index], g_CliEventArr[index], &NetworkEvents);

    if (NetworkEvents.lNetworkEvents & FD_READ)
    {
      // Receive message from client
      ret = recv(g_CliSocketArr[index], szMessage, MSGSIZE, 0);
      if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
      {
        Cleanup(index);
      }
      else
      {
        szMessage[ret] = '/0';
        send(g_CliSocketArr[index], szMessage, strlen(szMessage), 0);
      }
    }

    if (NetworkEvents.lNetworkEvents & FD_CLOSE)
  {
   Cleanup(index);
  }
  }
  return 0;
}

void Cleanup(int index)
{
  closesocket(g_CliSocketArr[index]);
WSACloseEvent(g_CliEventArr[index]);

if (index < g_iTotalConn - 1)
{
  g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn - 1];
  g_CliEventArr[index] = g_CliEventArr[g_iTotalConn - 1];
}

g_iTotalConn--;
}

事件選擇模型也比較簡單，實現起來也不是太複雜，它的基本思想是將每個套接字都和一個WSAEVENT對象對應起來，並且在關聯的時候指定需要關注的哪些網絡事件。一旦在某個套接字上發生了我們關注的事件（FD_READ和FD_CLOSE），與之相關聯的WSAEVENT對象被Signaled。程序定義了兩個全局數組，一個套接字數組，一個WSAEVENT對象數組，其大小都是MAXIMUM_WAIT_OBJECTS（64），兩個數組中的元素一一對應。
同樣的，這裏的程序沒有考慮兩個問題，一是不能無條件的調用accept，因爲我們支持的併發連接數有限。解決方法是將套接字按MAXIMUM_WAIT_OBJECTS分組，每MAXIMUM_WAIT_OBJECTS個套接字一組，每一組分配一個工作者線程；或者採用WSAAccept代替accept，並回調自己定義的Condition Function。第二個問題是沒有對連接數爲0的情形做特殊處理，程序在連接數爲0的時候CPU佔用率爲100%。

四.重疊I/O模型
Winsock2的發佈使得Socket I/O有了和文件I/O統一的接口。我們可以通過使用Win32文件操縱函數ReadFile和WriteFile來進行Socket I/O。伴隨而來的，用於普通文件I/O的重疊I/O模型和完成端口模型對Socket I/O也適用了。這些模型的優點是可以達到更佳的系統性能，但是實現較爲複雜，裏面涉及較多的C語言技巧。例如我們在完成端口模型中會經常用到所謂的“尾隨數據”。

1.用事件通知方式實現的重疊I/O模型
#include <winsock2.h>
#include <stdio.h>

#define PORT    5150
#define MSGSIZE 1024

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

typedef struct
{
  WSAOVERLAPPED overlap;
  WSABUF        Buffer;
  char          szMessage[MSGSIZE];
  DWORD         NumberOfBytesRecvd;
  DWORD         Flags;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

int                     g_iTotalConn = 0;
SOCKET                  g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
WSAEVENT                g_CliEventArr[MAXIMUM_WAIT_OBJECTS];
LPPER_IO_OPERATION_DATA g_pPerIODataArr[MAXIMUM_WAIT_OBJECTS];

DWORD WINAPI WorkerThread(LPVOID);
void Cleanup(int);

int main()
{
  WSADATA     wsaData;
  SOCKET      sListen, sClient;
  SOCKADDR_IN local, client;
  DWORD       dwThreadId;
  int         iaddrSize = sizeof(SOCKADDR_IN);

  // Initialize Windows Socket library
  WSAStartup(0x0202, &wsaData);

  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  // Create worker thread
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

  while (TRUE)
  {
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d/n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    g_CliSocketArr[g_iTotalConn] = sClient;
    
    // Allocate a PER_IO_OPERATION_DATA structure
    g_pPerIODataArr[g_iTotalConn] = (LPPER_IO_OPERATION_DATA)HeapAlloc(
      GetProcessHeap(),
      HEAP_ZERO_MEMORY,
      sizeof(PER_IO_OPERATION_DATA));
    g_pPerIODataArr[g_iTotalConn]->Buffer.len = MSGSIZE;
    g_pPerIODataArr[g_iTotalConn]->Buffer.buf = g_pPerIODataArr[g_iTotalConn]->szMessage;
    g_CliEventArr[g_iTotalConn] = g_pPerIODataArr[g_iTotalConn]->overlap.hEvent = WSACreateEvent();

    // Launch an asynchronous operation
    WSARecv(
      g_CliSocketArr[g_iTotalConn],
      &g_pPerIODataArr[g_iTotalConn]->Buffer,
      1,
      &g_pPerIODataArr[g_iTotalConn]->NumberOfBytesRecvd,
      &g_pPerIODataArr[g_iTotalConn]->Flags,
      &g_pPerIODataArr[g_iTotalConn]->overlap,
      NULL);
    
    g_iTotalConn++;
  }
  
  closesocket(sListen);
  WSACleanup();
  return 0;
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
  int   ret, index;
  DWORD cbTransferred;

  while (TRUE)
  {
    ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);
    if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
    {
      continue;
    }

    index = ret - WSA_WAIT_EVENT_0;
    WSAResetEvent(g_CliEventArr[index]);

    WSAGetOverlappedResult(
      g_CliSocketArr[index],
      &g_pPerIODataArr[index]->overlap,
      &cbTransferred,
      TRUE,
      &g_pPerIODataArr[g_iTotalConn]->Flags);

    if (cbTransferred == 0)
    {
      // The connection was closed by client
      Cleanup(index);
    }
    else
    {
      // g_pPerIODataArr[index]->szMessage contains the received data
      g_pPerIODataArr[index]->szMessage[cbTransferred] = '/0';
      send(g_CliSocketArr[index], g_pPerIODataArr[index]->szMessage,/
        cbTransferred, 0);

      // Launch another asynchronous operation
      WSARecv(
        g_CliSocketArr[index],
        &g_pPerIODataArr[index]->Buffer,
        1,
        &g_pPerIODataArr[index]->NumberOfBytesRecvd,
        &g_pPerIODataArr[index]->Flags,
        &g_pPerIODataArr[index]->overlap,
        NULL);
    }
  }

  return 0;
}

void Cleanup(int index)
{
  closesocket(g_CliSocketArr[index]);
  WSACloseEvent(g_CliEventArr[index]);
  HeapFree(GetProcessHeap(), 0, g_pPerIODataArr[index]);

  if (index < g_iTotalConn - 1)
  {
    g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn - 1];
    g_CliEventArr[index] = g_CliEventArr[g_iTotalConn - 1];
    g_pPerIODataArr[index] = g_pPerIODataArr[g_iTotalConn - 1];
  }

  g_pPerIODataArr[--g_iTotalConn] = NULL;
}

這個模型與上述其他模型不同的是它使用Winsock2提供的異步I/O函數WSARecv。在調用WSARecv時，指定一個WSAOVERLAPPED結構，這個調用不是阻塞的，也就是說，它會立刻返回。一旦有數據到達的時候，被指定的WSAOVERLAPPED結構中的hEvent被Signaled。由於下面這個語句
g_CliEventArr[g_iTotalConn] = g_pPerIODataArr[g_iTotalConn]->overlap.hEvent；
使得與該套接字相關聯的WSAEVENT對象也被Signaled，所以WSAWaitForMultipleEvents的調用操作成功返回。我們現在應該做的就是用與調用WSARecv相同的WSAOVERLAPPED結構爲參數調用WSAGetOverlappedResult，從而得到本次I/O傳送的字節數等相關信息。在取得接收的數據後，把數據原封不動的發送到客戶端，然後重新激活一個WSARecv異步操作。

2.用完成例程方式實現的重疊I/O模型
#include <WINSOCK2.H>
#include <stdio.h>

#define PORT    5150
#define MSGSIZE 1024

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

typedef struct
{
WSAOVERLAPPED overlap;
WSABUF        Buffer;
  char          szMessage[MSGSIZE];
DWORD         NumberOfBytesRecvd;
DWORD         Flags; 
SOCKET        sClient;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

DWORD WINAPI WorkerThread(LPVOID);
void CALLBACK CompletionROUTINE(DWORD, DWORD, LPWSAOVERLAPPED, DWORD);

SOCKET g_sNewClientConnection;
BOOL   g_bNewConnectionArrived = FALSE;

int main()
{
  WSADATA     wsaData;
  SOCKET      sListen;
  SOCKADDR_IN local, client;
  DWORD       dwThreadId;
  int         iaddrSize = sizeof(SOCKADDR_IN);

  // Initialize Windows Socket library
  WSAStartup(0x0202, &wsaData);

  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  // Create worker thread
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);

  while (TRUE)
  {
    // Accept a connection
    g_sNewClientConnection = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    g_bNewConnectionArrived = TRUE;
    printf("Accepted client:%s:%d/n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
  }
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

  while (TRUE)
  {
    if (g_bNewConnectionArrived)
    {
      // Launch an asynchronous operation for new arrived connection
      lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
        GetProcessHeap(),
        HEAP_ZERO_MEMORY,
        sizeof(PER_IO_OPERATION_DATA));
      lpPerIOData->Buffer.len = MSGSIZE;
      lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
      lpPerIOData->sClient = g_sNewClientConnection;
      
      WSARecv(lpPerIOData->sClient,
        &lpPerIOData->Buffer,
        1,
        &lpPerIOData->NumberOfBytesRecvd,
        &lpPerIOData->Flags,
        &lpPerIOData->overlap,
        CompletionROUTINE);      
      
      g_bNewConnectionArrived = FALSE;
    }

    SleepEx(1000, TRUE);
  }
  return 0;
}

void CALLBACK CompletionROUTINE(DWORD dwError,
                                DWORD cbTransferred,
                                LPWSAOVERLAPPED lpOverlapped,
                                DWORD dwFlags)
{
  LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;
  
  if (dwError != 0 || cbTransferred == 0)
{
    // Connection was closed by client
  closesocket(lpPerIOData->sClient);
  HeapFree(GetProcessHeap(), 0, lpPerIOData);
}
  else
  {
    lpPerIOData->szMessage[cbTransferred] = '/0';
    send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);
    
    // Launch another asynchronous operation
    memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));
    lpPerIOData->Buffer.len = MSGSIZE;
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage;    

    WSARecv(lpPerIOData->sClient,
      &lpPerIOData->Buffer,
      1,
      &lpPerIOData->NumberOfBytesRecvd,
      &lpPerIOData->Flags,
      &lpPerIOData->overlap,
      CompletionROUTINE);
  }
}

用完成例程來實現重疊I/O比用事件通知簡單得多。在這個模型中，主線程只用不停的接受連接即可；輔助線程判斷有沒有新的客戶端連接被建立，如果有，就爲那個客戶端套接字激活一個異步的WSARecv操作，然後調用SleepEx使線程處於一種可警告的等待狀態，以使得I/O完成後CompletionROUTINE可以被內核調用。如果輔助線程不調用SleepEx，則內核在完成一次I/O操作後，無法調用完成例程（因爲完成例程的運行應該和當初激活WSARecv異步操作的代碼在同一個線程之內）。
完成例程內的實現代碼比較簡單，它取出接收到的數據，然後將數據原封不動的發送給客戶端，最後重新激活另一個WSARecv異步操作。注意，在這裏用到了“尾隨數據”。我們在調用WSARecv的時候，參數lpOverlapped實際上指向一個比它大得多的結構PER_IO_OPERATION_DATA，這個結構除了WSAOVERLAPPED以外，還被我們附加了緩衝區的結構信息，另外還包括客戶端套接字等重要的信息。這樣，在完成例程中通過參數lpOverlapped拿到的不僅僅是WSAOVERLAPPED結構，還有後邊尾隨的包含客戶端套接字和接收數據緩衝區等重要信息。這樣的C語言技巧在我後面介紹完成端口的時候還會使用到。

五.完成端口模型
“完成端口”模型是迄今爲止最爲複雜的一種I/O模型。然而，假若一個應用程序同時需要管理爲數衆多的套接字，那麼採用這種模型，往往可以達到最佳的系統性能！但不幸的是，該模型只適用於Windows NT和Windows 2000操作系統。因其設計的複雜性，只有在你的應用程序需要同時管理數百乃至上千個套接字的時候，而且希望隨着系統內安裝的CPU數量的增多，應用程序的性能也可以線性提升，才應考慮採用“完成端口”模型。要記住的一個基本準則是，假如要爲Windows NT或Windows 2000開發高性能的服務器應用，同時希望爲大量套接字I/O請求提供服務（Web服務器便是這方面的典型例子），那麼I/O完成端口模型便是最佳選擇！（節選自《Windows網絡編程》第八章）
完成端口模型是我最喜愛的一種模型。雖然其實現比較複雜（其實我覺得它的實現比用事件通知實現的重疊I/O簡單多了），但其效率是驚人的。我在T公司的時候曾經幫同事寫過一個郵件服務器的性能測試程序，用的就是完成端口模型。結果表明，完成端口模型在多連接（成千上萬）的情況下，僅僅依靠一兩個輔助線程，就可以達到非常高的吞吐量。下面我還是從代碼說起：
#include <WINSOCK2.H>
#include <stdio.h>

#define PORT    5150
#define MSGSIZE 1024

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

typedef enum
{
  RECV_POSTED
}OPERATION_TYPE;

typedef struct
{
WSAOVERLAPPED  overlap;
WSABUF         Buffer;
  char           szMessage[MSGSIZE];
DWORD          NumberOfBytesRecvd;
DWORD          Flags;
OPERATION_TYPE OperationType;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

DWORD WINAPI WorkerThread(LPVOID);

int main()
{
  WSADATA                 wsaData;
  SOCKET                  sListen, sClient;
  SOCKADDR_IN             local, client;
  DWORD                   i, dwThreadId;
  int                     iaddrSize = sizeof(SOCKADDR_IN);
  HANDLE                  CompletionPort = INVALID_HANDLE_VALUE;
  SYSTEM_INFO             systeminfo;
  LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

  // Initialize Windows Socket library
  WSAStartup(0x0202, &wsaData);

  // Create completion port
  CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);

  // Create worker thread
  GetSystemInfo(&systeminfo);
  for (i = 0; i < systeminfo.dwNumberOfProcessors; i++)
  {
    CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId);
  }
  
  // Create listening socket
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  // Bind
  local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
local.sin_family = AF_INET;
local.sin_port = htons(PORT);
  bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));

  // Listen
  listen(sListen, 3);

  while (TRUE)
  {
    // Accept a connection
    sClient = accept(sListen, (struct sockaddr *)&client, &iaddrSize);
    printf("Accepted client:%s:%d/n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));

    // Associate the newly arrived client socket with completion port
    CreateIoCompletionPort((HANDLE)sClient, CompletionPort, (DWORD)sClient, 0);
    
    // Launch an asynchronous operation for new arrived connection
    lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
      GetProcessHeap(),
      HEAP_ZERO_MEMORY,
      sizeof(PER_IO_OPERATION_DATA));
    lpPerIOData->Buffer.len = MSGSIZE;
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
    lpPerIOData->OperationType = RECV_POSTED;
    WSARecv(sClient,
      &lpPerIOData->Buffer,
      1,
      &lpPerIOData->NumberOfBytesRecvd,
      &lpPerIOData->Flags,
      &lpPerIOData->overlap,
      NULL);
  }

  PostQueuedCompletionStatus(CompletionPort, 0xFFFFFFFF, 0, NULL);
CloseHandle(CompletionPort);
closesocket(sListen);
WSACleanup();
return 0;
}

DWORD WINAPI WorkerThread(LPVOID CompletionPortID)
{
  HANDLE                  CompletionPort=(HANDLE)CompletionPortID;
  DWORD                   dwBytesTransferred;
  SOCKET                  sClient;
  LPPER_IO_OPERATION_DATA lpPerIOData = NULL;

  while (TRUE)
  {
    GetQueuedCompletionStatus(
      CompletionPort,
      &dwBytesTransferred,
      &sClient,
      (LPOVERLAPPED *)&lpPerIOData,
      INFINITE);
    if (dwBytesTransferred == 0xFFFFFFFF)
    {
      return 0;
    }
    
    if (lpPerIOData->OperationType == RECV_POSTED)
    {
      if (dwBytesTransferred == 0)
      {
        // Connection was closed by client
        closesocket(sClient);
        HeapFree(GetProcessHeap(), 0, lpPerIOData);        
      }
      else
      {
        lpPerIOData->szMessage[dwBytesTransferred] = '/0';
        send(sClient, lpPerIOData->szMessage, dwBytesTransferred, 0);
        
        // Launch another asynchronous operation for sClient
        memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));
        lpPerIOData->Buffer.len = MSGSIZE;
        lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
        lpPerIOData->OperationType = RECV_POSTED;
        WSARecv(sClient,
          &lpPerIOData->Buffer,
          1,
          &lpPerIOData->NumberOfBytesRecvd,
          &lpPerIOData->Flags,
          &lpPerIOData->overlap,
          NULL);
      }
    }
  }
return 0;
}

首先，說說主線程：
1.創建完成端口對象
2.創建工作者線程（這裏工作者線程的數量是按照CPU的個數來決定的，這樣可以達到最佳性能）
3.創建監聽套接字，綁定，監聽，然後程序進入循環
4.在循環中，我做了以下幾件事情：
(1).接受一個客戶端連接
(2).將該客戶端套接字與完成端口綁定到一起(還是調用CreateIoCompletionPort，但這次的作用不同)，注意，按道理來講，此時傳遞給CreateIoCompletionPort的第三個參數應該是一個完成鍵，一般來講，程序都是傳遞一個單句柄數據結構的地址，該單句柄數據包含了和該客戶端連接有關的信息，由於我們只關心套接字句柄，所以直接將套接字句柄作爲完成鍵傳遞；
(3).觸發一個WSARecv異步調用，這次又用到了“尾隨數據”，使接收數據所用的緩衝區緊跟在WSAOVERLAPPED對象之後，此外，還有操作類型等重要信息。

在工作者線程的循環中，我們
1.調用GetQueuedCompletionStatus取得本次I/O的相關信息（例如套接字句柄、傳送的字節數、單I/O數據結構的地址等等）
2.通過單I/O數據結構找到接收數據緩衝區，然後將數據原封不動的發送到客戶端
3.再次觸發一個WSARecv異步操作

六.五種I/O模型的比較
我會從以下幾個方面來進行比較
*有無每線程64連接數限制
如果在選擇模型中沒有重新定義FD_SETSIZE宏，則每個fd_set默認可以裝下64個SOCKET。同樣的，受MAXIMUM_WAIT_OBJECTS宏的影響，事件選擇、用事件通知實現的重疊I/O都有每線程最大64連接數限制。如果連接數成千上萬，則必須對客戶端套接字進行分組，這樣，勢必增加程序的複雜度。
相反，異步選擇、用完成例程實現的重疊I/O和完成端口不受此限制。

*線程數
除了異步選擇以外，其他模型至少需要2個線程。一個主線程和一個輔助線程。同樣的，如果連接數大於64，則選擇模型、事件選擇和用事件通知實現的重疊I/O的線程數還要增加。

*實現的複雜度
我的個人看法是，在實現難度上，異步選擇<選擇<用完成例程實現的重疊I/O<事件選擇<完成端口<用事件通知實現的重疊I/O

*性能
由於選擇模型中每次都要重設讀集，在select函數返回後還要針對所有套接字進行逐一測試，我的感覺是效率比較差；完成端口和用完成例程實現的重疊I/O基本上不涉及全局數據，效率應該是最高的，而且在多處理器情形下完成端口還要高一些；事件選擇和用事件通知實現的重疊I/O在實現機制上都是採用WSAWaitForMultipleEvents，感覺效率差不多；至於異步選擇，不好比較。所以我的結論是:選擇<用事件通知實現的重疊I/O<事件選擇<用完成例程實現的重疊I/O<完成端口

 

WinSock學習筆記
Socket（套接字）

◆先看定義：
typedef unsigned int u_int;
typedef u_int SOCKET;
◆Socket相當於進行網絡通信兩端的插座，只要對方的Socket和自己的Socket有通信聯接，雙方就可以發送和接收數據了。其定義類似於文件句柄的定義。

◆Socket有五種不同的類型：

1、流式套接字(stream socket)
定義：
#define SOCK_STREAM 1 
流式套接字提供了雙向、有序的、無重複的以及無記錄邊界的數據流服務，適合處理大量數據。它是面向聯結的，必須建立數據傳輸鏈路，同時還必須對傳輸的數據進行驗證，確保數據的準確性。因此，系統開銷較大。

2、 數據報套接字(datagram socket)

定義：
#define SOCK_DGRAM 2 
數據報套接字也支持雙向的數據流，但不保證傳輸數據的準確性，但保留了記錄邊界。由於數據報套接字是無聯接的，例如廣播時的聯接，所以並不保證接收端是否正在偵聽。數據報套接字傳輸效率比較高。

3、原始套接字(raw-protocol interface)

定義：
#define SOCK_RAW 3 
原始套接字保存了數據包中的完整IP頭，前面兩種套接字只能收到用戶數據。因此可以通過原始套接字對數據進行分析。
其它兩種套接字不常用，這裏就不介紹了。

◆Socket開發所必須需要的文件(以WinSock V2.0爲例)：

頭文件：Winsock2.h

庫文件：WS2_32.LIB

動態庫：W32_32.DLL

一些重要的定義

1、數據類型的基本定義：這個大家一看就懂。
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
2、 網絡地址的數據結構，有一個老的和一個新的的，請大家留意，如果想知道爲什麼，
請發郵件給Bill Gate。其實就是計算機的IP地址，不過一般不用用點分開的IP地
址，當然也提供一些轉換函數。

◆ 舊的網絡地址結構的定義，爲一個4字節的聯合：
struct in_addr 
 {
 union 
 {
 struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
 struct { u_short s_w1,s_w2; } S_un_w;
 u_long S_addr;
 } S_un;
 #define s_addr S_un.S_addr /* can be used for most tcp & ip code */
 //下面幾行省略,反正沒什麼用處。
 };
其實完全不用這麼麻煩，請看下面:

◆ 新的網絡地址結構的定義：
非常簡單，就是一個無符號長整數 unsigned long。舉個例子：IP地址爲127.0.0.1的網絡地址是什麼呢？請看定義：
#define INADDR_LOOPBACK 0x7f000001

3、 套接字地址結構

(1)、sockaddr結構：
struct sockaddr {
 u_short sa_family; /* address family */
 char sa_data[14]; /* up to 14 bytes of direct address */
 };
sa_family爲網絡地址類型，一般爲AF_INET，表示該socket在Internet域中進行通信，該地址結構隨選擇的協議的不同而變化，因此一般情況下另一個與該地址結構大小相同的sockaddr_in結構更爲常用，sockaddr_in結構用來標識TCP/IP協議下的地址。換句話說，這個結構是通用socket地址結構，而下面的sockaddr_in是專門針對Internet域的socket地址結構。

(2)、sockaddr_in結構
struct sockaddr_in {
 short sin_family;
 u_short sin_port;
 struct in_addr sin_addr;
 char sin_zero[8];
};
sin _family爲網絡地址類型，必須設定爲AF_INET。sin_port爲服務端口，注意不要使用已固定的服務端口，如HTTP的端口80等。如果端口設置爲0，則系統會自動分配一個唯一端口。sin_addr爲一個unsigned long的IP地址。sin_zero爲填充字段，純粹用來保證結構的大小。

◆ 將常用的用點分開的IP地址轉換爲unsigned long類型的IP地址的函數：
unsigned long inet_addr(const char FAR * cp )
用法：
unsigned long addr=inet_addr("192.1.8.84")

◆ 如果將sin_addr設置爲INADDR_ANY，則表示所有的IP地址，也即所有的計算機。
#define INADDR_ANY (u_long)0x00000000

4、 主機地址：

先看定義：
struct hostent {
 char FAR * h_name; /* official name of host */
 char FAR * FAR * h_aliases; /* alias list */
 short h_addrtype; /* host address type */
 short h_length; /* length of address */
 char FAR * FAR * h_addr_list; /* list of addresses */
 #define h_addr h_addr_list[0] /* address, for backward compat */
 };
h_name爲主機名字。
h_aliases爲主機別名列表。
h_addrtype爲地址類型。
h_length爲地址類型。
h_addr_list爲IP地址，如果該主機有多個網卡，就包括地址的列表。
另外還有幾個類似的結構，這裏就不一一介紹了。

5、 常見TCP/IP協議的定義：
#define IPPROTO_IP 0 
#define IPPROTO_ICMP 1 
#define IPPROTO_IGMP 2 
#define IPPROTO_TCP 6 
#define IPPROTO_UDP 17 
#define IPPROTO_RAW 255 
具體是什麼協議，大家一看就知道了。

套接字的屬性

爲了靈活使用套接字，我們可以對它的屬性進行設定。

1、 屬性內容：
//允許調試輸出
#define SO_DEBUG 0x0001 /* turn on debugging info recording */
//是否監聽模式
#define SO_ACCEPTCONN 0x0002 /* socket has had listen() */
//套接字與其他套接字的地址綁定
#define SO_REUSEADDR 0x0004 /* allow local address reuse */
//保持連接
#define SO_KEEPALIVE 0x0008 /* keep connections alive */
//不要路由出去
#define SO_DONTROUTE 0x0010 /* just use interface addresses */
//設置爲廣播
#define SO_BROADCAST 0x0020 /* permit sending of broadcast msgs */
//使用環回不通過硬件
#define SO_USELOOPBACK 0x0040 /* bypass hardware when possible */
//當前拖延值
#define SO_LINGER 0x0080 /* linger on close if data present */
//是否加入帶外數據
#define SO_OOBINLINE 0x0100 /* leave received OOB data in line */
//禁用LINGER選項
#define SO_DONTLINGER (int)(~SO_LINGER)
//發送緩衝區長度
#define SO_SNDBUF 0x1001 /* send buffer size */
//接收緩衝區長度
#define SO_RCVBUF 0x1002 /* receive buffer size */
//發送超時時間
#define SO_SNDTIMEO 0x1005 /* send timeout */
//接收超時時間
#define SO_RCVTIMEO 0x1006 /* receive timeout */
//錯誤狀態
#define SO_ERROR 0x1007 /* get error status and clear */
//套接字類型
#define SO_TYPE 0x1008 /* get socket type */

2、 讀取socket屬性：
int getsockopt(SOCKET s, int level, int optname, char FAR * optval, int FAR * optlen)
s爲欲讀取屬性的套接字。level爲套接字選項的級別，大多數是特定協議和套接字專有的。如IP協議應爲 IPPROTO_IP。

optname爲讀取選項的名稱
optval爲存放選項值的緩衝區指針。
optlen爲緩衝區的長度
用法：
int ttl=0; //讀取TTL值
int rc = getsockopt( s, IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl));
//來自MS platform SDK 2003

3、 設置socket屬性：
int setsockopt(SOCKET s,int level, int optname,const char FAR * optval, int optlen)
s爲欲設置屬性的套接字。
level爲套接字選項的級別，用法同上。
optname爲設置選項的名稱
optval爲存放選項值的緩衝區指針。
optlen爲緩衝區的長度

用法：
int ttl=32; //設置TTL值
int rc = setsockopt( s, IPPROTO_IP, IP_TTL, (char *)&ttl, sizeof(ttl));

套接字的使用步驟

1、啓動Winsock：對Winsock DLL進行初始化，協商Winsock的版本支持並分配必要的
資源。（服務器端和客戶端）
int WSAStartup( WORD wVersionRequested, LPWSADATA lpWSAData )
wVersionRequested爲打算加載Winsock的版本，一般如下設置：
wVersionRequested=MAKEWORD(2,0)
或者直接賦值：wVersionRequested=2

LPWSADATA爲初始化Socket後加載的版本的信息,定義如下：
typedef struct WSAData {
 WORD wVersion;
 WORD wHighVersion;
 char szDescription[WSADESCRIPTION_LEN+1];
 char szSystemStatus[WSASYS_STATUS_LEN+1];
 unsigned short iMaxSockets;
 unsigned short iMaxUdpDg;
 char FAR * lpVendorInfo;
 } WSADATA, FAR * LPWSADATA;
如果加載成功後數據爲：

wVersion＝2 表示加載版本爲2.0。
wHighVersion＝514 表示當前系統支持socket最高版本爲2.2。
szDescription="WinSock 2.0"
szSystemStatus="Running" 表示正在運行。
iMaxSockets＝0 表示同時打開的socket最大數，爲0表示沒有限制。
iMaxUdpDg＝0 表示同時打開的數據報最大數，爲0表示沒有限制。
lpVendorInfo 沒有使用，爲廠商指定信息預留。

該函數使用方法：
WORD wVersion=MAKEWORD(2,0);
WSADATA wsData;
int nResult= WSAStartup(wVersion,&wsData);
if(nResult !=0)
{
//錯誤處理
}

2、創建套接字：（服務器端和客戶端）
SOCKET socket( int af, int type, int protocol );
af爲網絡地址類型，一般爲AF_INET，表示在Internet域中使用。
type爲套接字類型，前面已經介紹了。
protocol爲指定網絡協議，一般爲IPPROTO_IP。
用法：
SOCKET sock=socket(AF_INET,SOCK_STREAM,IPPROTO_IP);
if(sock==INVALID_SOCKET)
{
//錯誤處理
}

3、套接字的綁定：將本地地址綁定到所創建的套接字上。（服務器端和客戶端）
int bind( SOCKET s, const struct sockaddr FAR * name, int namelen )
s爲已經創建的套接字。
name爲socket地址結構，爲sockaddr結構，如前面討論的，我們一般使用sockaddr_in
結構，在使用再強制轉換爲sockaddr結構。
namelen爲地址結構的長度。

用法：
sockaddr_in addr;
addr. sin_family=AF_INET;
addr. sin_port= htons(0); //保證字節順序
addr. sin_addr.s_addr= inet_addr("192.1.8.84")
int nResult=bind(s,(sockaddr*)&addr,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
{
//錯誤處理
}

4、 套接字的監聽：（服務器端）
int listen(SOCKET s, int backlog )
s爲一個已綁定但未聯接的套接字。
backlog爲指定正在等待聯接的最大隊列長度，這個參數非常重要，因爲服務器一般可
以提供多個連接。
用法：
int nResult=listen(s,5) //最多5個連接
if(nResult==SOCKET_ERROR)
{
//錯誤處理
}

5、套接字等待連接:：（服務器端）
SOCKET accept( SOCKET s, struct sockaddr FAR * addr, int FAR * addrlen )
s爲處於監聽模式的套接字。
sockaddr爲接收成功後返回客戶端的網絡地址。
addrlen爲網絡地址的長度。

用法：
sockaddr_in addr;
SOCKET s_d=accept(s,(sockaddr*)&addr,sizeof(sockaddr));
if(s==INVALID_SOCKET)
{
//錯誤處理
}

6、套接字的連結：將兩個套接字連結起來準備通信。（客戶端）
int connect(SOCKET s, const struct sockaddr FAR * name, int namelen )
s爲欲連結的已創建的套接字。
name爲欲連結的socket地址。
namelen爲socket地址的結構的長度。

用法：
sockaddr_in addr;
addr. sin_family=AF_INET;
addr. sin_port=htons(0); //保證字節順序
addr. sin_addr.s_addr= htonl(INADDR_ANY) //保證字節順序
int nResult=connect(s,(sockaddr*)&addr,sizeof(sockaddr));
if(nResult==SOCKET_ERROR)
{
//錯誤處理
}

7、套接字發送數據：（服務器端和客戶端）
int send(SOCKET s, const char FAR * buf, int len, int flags )
s爲服務器端監聽的套接字。
buf爲欲發送數據緩衝區的指針。
len爲發送數據緩衝區的長度。
flags爲數據發送標記。
返回值爲發送數據的字符數。

◆這裏講一下這個發送標記，下面8中討論的接收標記也一樣：

flag取值必須爲0或者如下定義的組合：0表示沒有特殊行爲。
#define MSG_OOB 0x1 /* process out-of-band data */
#define MSG_PEEK 0x2 /* peek at incoming message */
#define MSG_DONTROUTE 0x4 /* send without using routing tables */
MSG_OOB表示數據應該帶外發送，所謂帶外數據就是TCP緊急數據。
MSG_PEEK表示使有用的數據複製到緩衝區內，但並不從系統緩衝區內刪除。
MSG_DONTROUTE表示不要將包路由出去。

用法：
char buf[]="xiaojin";
int nResult=send(s,buf,strlen(buf));
if(nResult==SOCKET_ERROR)
{
//錯誤處理
}

8、 套接字的數據接收：（客戶端）
int recv( SOCKET s, char FAR * buf, int len, int flags )
s爲準備接收數據的套接字。
buf爲準備接收數據的緩衝區。
len爲準備接收數據緩衝區的大小。
flags爲數據接收標記。
返回值爲接收的數據的字符數。

用法：
char mess[1000];
int nResult =recv(s,mess,1000,0);
if(nResult==SOCKET_ERROR)
{
//錯誤處理
}

9、中斷套接字連接：通知服務器端或客戶端停止接收和發送數據。（服務器端和客戶端）
int shutdown(SOCKET s, int how)
s爲欲中斷連接的套接字。
How爲描述禁止哪些操作，取值爲：SD_RECEIVE、SD_SEND、SD_BOTH。
#define SD_RECEIVE 0x00
#define SD_SEND 0x01
#define SD_BOTH 0x02
用法：
int nResult= shutdown(s,SD_BOTH);
if(nResult==SOCKET_ERROR)
{
//錯誤處理
}

10、 關閉套接字：釋放所佔有的資源。（服務器端和客戶端）
int closesocket( SOCKET s )
s爲欲關閉的套接字。

用法：
int nResult=closesocket(s);
if(nResult==SOCKET_ERROR)
{
//錯誤處理
}

與socket有關的一些函數介紹

1、讀取當前錯誤值：每次發生錯誤時，如果要對具體問題進行處理，那麼就應該調用這個函數取得錯誤代碼。 
 int WSAGetLastError(void );
 #define h_errno WSAGetLastError()
錯誤值請自己閱讀Winsock2.h。

2、將主機的unsigned long值轉換爲網絡字節順序(32位)：爲什麼要這樣做呢？因爲不同的計算機使用不同的字節順序存儲數據。因此任何從Winsock函數對IP地址和端口號的引用和傳給Winsock函數的IP地址和端口號均時按照網絡順序組織的。
 
 u_long htonl(u_long hostlong);
 舉例：htonl(0)=0
 htonl(80)= 1342177280

3、將unsigned long數從網絡字節順序轉換位主機字節順序，是上面函數的逆函數。 
 
 u_long ntohl(u_long netlong);
 舉例：ntohl(0)=0
 ntohl(1342177280)= 80

4、將主機的unsigned short值轉換爲網絡字節順序(16位)：原因同2： 
 
 u_short htons(u_short hostshort);
 舉例：htonl(0)=0
 htonl(80)= 20480

5、將unsigned short數從網絡字節順序轉換位主機字節順序，是上面函數的逆函數。 
 u_short ntohs(u_short netshort);
 舉例：ntohs(0)=0
 ntohsl(20480)= 80

6、將用點分割的IP地址轉換位一個in_addr結構的地址，這個結構的定義見筆記(一)，實際上就是一個unsigned long值。計算機內部處理IP地址可是不認識如192.1.8.84之類的數據。 
 unsigned long inet_addr( const char FAR * cp );
 舉例：inet_addr("192.1.8.84")=1409810880
 inet_addr("127.0.0.1")= 16777343
如果發生錯誤，函數返回INADDR_NONE值。

7、將網絡地址轉換位用點分割的IP地址，是上面函數的逆函數。 
 char FAR * inet_ntoa( struct in_addr in );
 舉例：char * ipaddr=NULL;
 char addr[20];
 in_addr inaddr;
 inaddr. s_addr=16777343;
 ipaddr= inet_ntoa(inaddr);
 strcpy(addr,ipaddr); 
這樣addr的值就變爲127.0.0.1。
注意意不要修改返回值或者進行釋放動作。如果函數失敗就會返回NULL值。

8、獲取套接字的本地地址結構： 
 
 int getsockname(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
s爲套接字
name爲函數調用後獲得的地址值
namelen爲緩衝區的大小。

9、獲取與套接字相連的端地址結構：
 int getpeername(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
s爲套接字
name爲函數調用後獲得的端地址值
namelen爲緩衝區的大小。

10、獲取計算機名：
 int gethostname( char FAR * name, int namelen );
name是存放計算機名的緩衝區
namelen是緩衝區的大小
用法：
 char szName[255];
 memset(szName,0,255);
 if(gethostname(szName,255)==SOCKET_ERROR)
 {
     //錯誤處理
 }
返回值爲：szNmae="xiaojin"

11、根據計算機名獲取主機地址： 
 struct hostent FAR * gethostbyname( const char FAR * name );
name爲計算機名。
用法：
 hostent * host;
 char* ip;
 host= gethostbyname("xiaojin");
 if(host->h_addr_list[0])
 {
   struct in_addr addr;
    memmove(&addr, host->h_addr_list[0]，4);
   //獲得標準IP地址
   ip=inet_ ntoa (addr);
 }

返回值爲：hostent->h_name="xiaojin"
hostent->h_addrtype=2 //AF_INET
hostent->length=4
ip="127.0.0.1"

Winsock 的I/O操作：

1、 兩種I/O模式 
阻塞模式：執行I/O操作完成前會一直進行等待，不會將控制權交給程序。套接字 默認爲阻塞模式。可以通過多線程技術進行處理。 
非阻塞模式：執行I/O操作時，Winsock函數會返回並交出控制權。這種模式使用 起來比較複雜，因爲函數在沒有運行完成就進行返回，會不斷地返回 WSAEWOULDBLOCK錯誤。但功能強大。
爲了解決這個問題，提出了進行I/O操作的一些I/O模型,下面介紹最常見的三種：

2、select模型：

　　通過調用select函數可以確定一個或多個套接字的狀態，判斷套接字上是否有數據，或
者能否向一個套接字寫入數據。 
int select( int nfds, fd_set FAR * readfds, fd_set FAR * writefds, 
 fd_set FAR *exceptfds, const struct timeval FAR * timeout );

◆先來看看涉及到的結構的定義：
a、 d_set結構：
#define FD_SETSIZE 64?
typedef struct fd_set {
 u_int fd_count; /* how many are SET? */
 SOCKET fd_array[FD_SETSIZE]; /* an array of SOCKETs */
 } fd_set;

fd_count爲已設定socket的數量
fd_array爲socket列表，FD_SETSIZE爲最大socket數量，建議不小於64。這是微軟建
議的。

B、timeval結構： 
struct timeval {
 long tv_sec; /* seconds */
 long tv_usec; /* and microseconds */
 };
tv_sec爲時間的秒值。
tv_usec爲時間的毫秒值。
這個結構主要是設置select()函數的等待值，如果將該結構設置爲(0,0)，則select()函數
會立即返回。

◆再來看看select函數各參數的作用： 
nfds：沒有任何用處，主要用來進行系統兼容用，一般設置爲0。

readfds：等待可讀性檢查的套接字組。

writefds；等待可寫性檢查的套接字組。

exceptfds：等待錯誤檢查的套接字組。

timeout：超時時間。

函數失敗的返回值：
調用失敗返回SOCKET_ERROR,超時返回0。
readfds、writefds、exceptfds三個變量至少有一個不爲空，同時這個不爲空的套接字組
種至少有一個socket，道理很簡單，否則要select幹什麼呢。 

舉例：測試一個套接字是否可讀：
fd_set fdread;
//FD_ZERO定義
// #define FD_ZERO(set) (((fd_set FAR *)(set))->fd_count=0)
FD_ZERO(&fdread);
FD_SET(s,&fdread)； //加入套接字，詳細定義請看winsock2.h
if(select(0,%fdread,NULL,NULL,NULL)>0
{
  //成功
  if(FD_ISSET(s,&fread) //是否存在fread中，詳細定義請看winsock2.h
  {
    //是可讀的
  }
}

◆I/O操作函數：主要用於獲取與套接字相關的操作參數。 
 int ioctlsocket(SOCKET s, long cmd, u_long FAR * argp ); 
s爲I/O操作的套接字。
cmd爲對套接字的操作命令。
argp爲命令所帶參數的指針。

常見的命令： //確定套接字自動讀入的數據量
#define FIONREAD _IOR(''''f'''', 127, u_long) /* get # bytes to read */
//允許或禁止套接字的非阻塞模式，允許爲非0，禁止爲0
#define FIONBIO _IOW(''''f'''', 126, u_long) /* set/clear non-blocking i/o */
//確定是否所有帶外數據都已被讀入
#define SIOCATMARK _IOR(''''s'''', 7, u_long) /* at oob mark? */

3、WSAAsynSelect模型：
WSAAsynSelect模型也是一個常用的異步I/O模型。應用程序可以在一個套接字上接收以
WINDOWS消息爲基礎的網絡事件通知。該模型的實現方法是通過調用WSAAsynSelect函
數 自動將套接字設置爲非阻塞模式，並向WINDOWS註冊一個或多個網絡時間，並提供一
個通知時使用的窗口句柄。當註冊的事件發生時，對應的窗口將收到一個基於消息的通知。
 int WSAAsyncSelect( SOCKET s, HWND hWnd, u_int wMsg, long lEvent); 
s爲需要事件通知的套接字
hWnd爲接收消息的窗口句柄
wMsg爲要接收的消息
lEvent爲掩碼，指定應用程序感興趣的網絡事件組合，主要如下： 
#define FD_READ_BIT 0
#define FD_READ (1 << FD_READ_BIT)
#define FD_WRITE_BIT 1
#define FD_WRITE (1 << FD_WRITE_BIT)
#define FD_OOB_BIT 2
#define FD_OOB (1 << FD_OOB_BIT)
#define FD_ACCEPT_BIT 3
#define FD_ACCEPT (1 << FD_ACCEPT_BIT)
#define FD_CONNECT_BIT 4
#define FD_CONNECT (1 << FD_CONNECT_BIT)
#define FD_CLOSE_BIT 5
#define FD_CLOSE (1 << FD_CLOSE_BIT)
用法：要接收讀寫通知：
int nResult= WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE)；
if(nResult==SOCKET_ERROR)
{
  //錯誤處理
}
取消通知：
 int nResult= WSAAsyncSelect(s,hWnd,0，0)； 
當應用程序窗口hWnd收到消息時，wMsg.wParam參數標識了套接字，lParam的低字標明
了網絡事件，高字則包含錯誤代碼。

4、WSAEventSelect模型
WSAEventSelect模型類似WSAAsynSelect模型，但最主要的區別是網絡事件發生時會被髮
送到一個事件對象句柄，而不是發送到一個窗口。

使用步驟如下：
a、 創建事件對象來接收網絡事件：
#define WSAEVENT HANDLE
#define LPWSAEVENT LPHANDLE
WSAEVENT WSACreateEvent( void );
該函數的返回值爲一個事件對象句柄，它具有兩種工作狀態：已傳信(signaled)和未傳信
(nonsignaled)以及兩種工作模式：人工重設(manual reset)和自動重設(auto reset)。默認未
未傳信的工作狀態和人工重設模式。

b、將事件對象與套接字關聯，同時註冊事件，使事件對象的工作狀態從未傳信轉變未
已傳信。
 int WSAEventSelect( SOCKET s,WSAEVENT hEventObject,long lNetworkEvents ); 
s爲套接字
hEventObject爲剛纔創建的事件對象句柄
lNetworkEvents爲掩碼，定義如上面所述

c、I/O處理後，設置事件對象爲未傳信
BOOL WSAResetEvent( WSAEVENT hEvent );
Hevent爲事件對象

成功返回TRUE，失敗返回FALSE。

d、等待網絡事件來觸發事件句柄的工作狀態：
DWORD WSAWaitForMultipleEvents( DWORD cEvents,
const WSAEVENT FAR * lphEvents, BOOL fWaitAll,
DWORD dwTimeout, BOOL fAlertable );
lpEvent爲事件句柄數組的指針
cEvent爲爲事件句柄的數目，其最大值爲WSA_MAXIMUM_WAIT_EVENTS 
fWaitAll指定等待類型：TRUE：當lphEvent數組重所有事件對象同時有信號時返回；
FALSE：任一事件有信號就返回。
dwTimeout爲等待超時（毫秒）
fAlertable爲指定函數返回時是否執行完成例程

對事件數組中的事件進行引用時，應該用WSAWaitForMultipleEvents的返回值，減去
預聲明值WSA_WAIT_EVENT_0，得到具體的引用值。例如：
nIndex=WSAWaitForMultipleEvents(…);
MyEvent=EventArray[Index- WSA_WAIT_EVENT_0];

e、判斷網絡事件類型：
int WSAEnumNetworkEvents( SOCKET s,
WSAEVENT hEventObject, LPWSANETWORKEVENTS lpNetworkEvents );
s爲套接字
hEventObject爲需要重設的事件對象
lpNetworkEvents爲記錄網絡事件和錯誤代碼，其結構定義如下：
typedef struct _WSANETWORKEVENTS {
  long lNetworkEvents;
  int iErrorCode[FD_MAX_EVENTS];
} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;

f、關閉事件對象句柄：
BOOL WSACloseEvent(WSAEVENT hEvent);
調用成功返回TRUE，否則返回FALSE。