socket編程五種模型

若是你想在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;
}app

客戶端所作的事情至關簡單，建立套接字，鏈接服務器，而後不停的發送和接收數據。
比較容易想到的一種服務器模型就是採用一個主線程，負責監聽客戶端的鏈接請求，當接收到某個客戶端的鏈接請求後，建立一個專門
用於和該客戶端通訊的套接字和一個輔助線程。之後該客戶端和服務器的交互都在這個輔助線程內完成。這種方法比較直觀，程序很是簡單
並且可移植性好，可是不能利用平臺相關的特性。例如，若是鏈接數增多的時候（成千上萬的鏈接），那麼線程數成倍增加，操做系統忙於
頻繁的線程間切換，並且大部分線程在其生命週期內都是處於非活動狀態的，這大大浪費了系統的資源。因此，若是你已經知道你的代碼只
會運行在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[i], &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[i], &fdread))
      {
        // A read event happened on g_CliSocketArr[i]
        ret = recv(g_CliSocketArr[i], szMessage, MSGSIZE, 0);
    if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
    {
     // Client socket closed
          printf("Client socket %d closed.\n", g_CliSocketArr[i]);
     closesocket(g_CliSocketArr[i]);
     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[i], 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%。

Winsock提供了一個有用的異步I/O模型。利用這個模型，應用程序可在一個套接字上，接收以Windows
(這篇文章是本人轉載的，但我不認爲WSAAsyncSelect屬於AIO，由於IO操做仍是你本身作了，操做系統只是用了消息通知你而已)
消息爲基礎的網絡事件通知。具體的作法是在建好一個套接字後，調用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模型相似的是，它也容許應用程序在一個
(這篇文章是本人轉載的，但我不認爲WSAEventSelect屬於AIO，由於IO操做仍是你本身作了，操做系統只是用了事件通知你而已)
或多個套接字上，接收以事件爲基礎的網絡事件通知。對於表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];
}

事件選擇模型也比較簡單，實現起來也不是太複雜，它的基本思想是將每一個套接字都和一個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%。

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

#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。因爲下面這個語句

使得與該套接字相關聯的WSAEVENT對象也被Signaled，因此WSAWaitForMultipleEvents的調用操做成功返回。咱們如今應該作的就是用
與調用WSARecv相同的WSAOVERLAPPED結構爲參數調用WSAGetOverlappedResult，從而獲得本次I/O傳送的字節數等相關信息。在取得接收的數據
後，把數據原封不動的發送到客戶端，而後從新激活一個WSARecv異步操做。

#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異步操做

若是在選擇模型中沒有從新定義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，感受效率差很少；至於異步選擇，很差比較。

winsock協議錯誤編碼解析

Windows協議能夠應用到不少通用環境。例如，要檢查網絡，可使用Windows套接字（WinSock）腳原本查看緩衝區發送和接收到的實際數據。WinSock類型還能夠用於錄製其餘低級通訊會話。經過他能夠錄製回放Vuser類型不支持的應用協議。使用VuGen，您能夠錄製應用程序對 Winsock.dll或Wsock32.dll的API調用，可是這種協議的錯誤提示表明是什麼呢！其實每次winsock報的錯誤，有不少都是 winsock協議的錯誤編號！loadrunner把這寫錯誤編號在調試信息中顯示出來。下邊我把一些winsock協議的錯誤編號都是什麼意思給你們列舉如下，但願對你們有幫助！

10004—WSAEINTR函數調用中斷。該錯誤代表因爲對WSACancelBlockingCall的調用，形成了一次調用被強行中斷。
10009—WSAEBADF文件句柄錯誤。該錯誤代表提供的文件句柄無效。在MicrosoftWindowsCE下，socket函數可能返回這個錯誤，代表共享串口處於「忙」狀態。
10013—WSAEACCES權限被拒。嘗試對套接字進行操做，但被禁止。若試圖在sendto或WSASendTo中使用一個廣播地址，可是還沒有用setsockopt和SO_BROADCAST這兩個選項設置廣播權限，便會產生這類錯誤。
10014—WSAEFAULT地址無效。傳給Winsock函數的指針地址無效。若指定的緩衝區過小，也會產生這個錯誤。
10022 —WSAEINVAL參數無效。指定了一個無效參數。例如，假如爲WSAIoctl調用指定了一個無效控制代碼，便會產生這個錯誤。另外，它也可能代表套接字當前的狀態有錯，例如在一個目前沒有監聽的套接字上調用accept或WSAAccept.10024—WSAEMFILE打開文件過多。提示打開的套接字太多了。一般，Microsoft提供者只受到系統內可用資源數量的限制。
10035—WSAEWOULDBLOCK資源暫時不可用。對非鎖定套接字來講，若是請求操做不能當即執行的話，一般會返回這個錯誤。好比說，在一個非暫停套接字上調用connect，就會返回這個錯誤。由於鏈接請求不能當即執行。
10036—WSAEINPROGRESS操做正在進行中。當前正在執行非鎖定操做。通常來講不會出現這個錯誤，除非正在開發16位Winsock應用程序。
10037 —WSAEALREADY操做已完成。通常來講，在非鎖定套接字上嘗試已處於進程中的操做時，會產生這個錯誤。好比，在一個已處於鏈接進程的非鎖定套接字上，再一次調用connect或WSAConnect.另外，服務提供者處於執行回調函數（針對支持回調例程的Winsock函數）的進程中時，也會出現這個錯誤。
10038—WSAENOTSOCK無效套接字上的套接字操做。任何一個把SOCKET句柄看成參數的Winsock函數都會返回這個錯誤。它代表提供的套接字句柄無效。
10039—WSAEDESTADDRREQ須要目標地址。這個錯誤代表沒有提供具體地址。比方說，假如在調用sendto時，將目標地址設爲INADDR_ANY（任意地址），便會返回這個錯誤。
10040 —WSAEMSGSIZE消息過長。這個錯誤的含義不少。若是在一個數據報套接字上發送一條消息，這條消息對內部緩衝區而言太大的話，就會產生這個錯誤。再好比，因爲網絡自己的限制，使一條消息過長，也會產生這個錯誤。最後，若是收到數據報以後，緩衝區過小，不能接收消息時，也會產生這個錯誤。
10041—WSAEPROTOTYPE套接字協議類型有誤。在socket或WSASocket調用中指定的協議不支持指定的套接字類型。
好比，要求創建SOCK_STREAM類型的一個IP套接字，同時指定協議爲IPPROTO_UDP，便會產生這樣的錯誤。
10042—WSAENOPROTOOPT協議選項錯誤。代表在getsockopt或setsockopt調用中，指定的套接字選項或級別不明、未獲支持或者無效。
10043——WSAEPROTONOSUPPORT不支持的協議。系統中沒有安裝請求的協議或沒有相應的實施方案。好比，若是系統中沒有安裝TCP/IP，而試着創建TCP或UDP套接字時，就會產生這個錯誤。
10044—WSAESOCKTNOSUPPORT不支持的套接字類型。對指定的地址家族來講，沒有相應的具體套接字類型支持。好比，在向一個不支持原始套接字的協議請求創建一個SOCK_RAW套接字類型時，就會產生這個錯誤。
10045 —WSAEOPNOTSUPP不支持的操做。代表針對指定的對象，試圖採起的操做未獲支持。一般，若是試着在一個不支持調用Winsock函數的套接字上調用了Winsock時，就會產生這個錯誤。好比，在一個數據報套接字上調用accept或WSAAccept函數時，就會產生這樣的錯誤。
10046—WSAEPFNOSUPPORT不支持的協議家族。請求的協議家族不存在，或系統內還沒有安裝。多數狀況下，這個錯誤可與WSAEAFNOSUPPORT互換（二者等價）；後者出現得更爲頻繁。
10047 —WSAEAFNOSUPPORT地址家族不支持請求的操做。對套接字類型不支持的操做來講，在試着執行它時，就會出現這個錯誤。好比，在類型爲 SOCK_STREAM的一個套接字上調用sendto或WSASendTo函數時，就會產生這個錯誤。另外，在調用socket或WSASocket函數的時候，若同時請求了一個無效的地址家族、套接字類型及協議組合，也會產生這個錯誤。
10048—WSAEADDRINUSE地址正在使用。正常狀況下，每一個套接字只容許使用一個套接字地址（例如，一個IP套接字地址由本地IP地址及端口號組成）。這個錯誤通常和bind、connect和 WSAConnect這三個函數有關。可在setsockopt函數中設置套接字選項SO_REUSEADDR，容許多個套接字訪問同一個本地IP地址及端口號（詳情見第9章）。
10049—WSAEADDRNOTAVAIL不能分配請求的地址。API調用中指定的地址對那個函數來講無效時，就會產生這樣的錯誤。例如，若在bind調用中指定一個IP地址，但卻沒有對應的本地IP接口，便會產生這樣的錯誤。另外，經過connect、 WSAConnect、sendto、WSASendTo和WSAJoinLeaf這四個函數爲準備鏈接的遠程計算機指定端口0時，也會產生這樣的錯誤。
10050—WSAENETDOWN網絡斷開。試圖採起一項操做時，卻發現網絡鏈接中斷。這多是因爲網絡堆棧的錯誤，網絡接口的故障，或者本地網絡的問題形成的。
10051—WSAENETUNREACH網絡不可抵達。試圖採起一項操做時，卻發現目標網絡不可抵達（不可訪問）。這意味着本地主機不知道如何抵達一個遠程主機。換言之，目前沒有已知的路由可抵達那個目標主機。
10052—WSAENETRESET網絡重設時斷開了鏈接。因爲「保持活動」操做檢測到一個錯誤，形成網絡鏈接的中斷。
若在一個已經無效的鏈接之上，經過setsockopt函數設置SO_KEEPALIVE選項，也會出現這樣的錯誤。
10053—WSAECONNABORTED軟件形成鏈接取消。因爲軟件錯誤，形成一個已經創建的鏈接被取消。典型狀況下，這意味着鏈接是因爲協議或超時錯誤而被取消的。
10054 —WSAECONNRESET鏈接被對方重設。一個已經創建的鏈接被遠程主機強行關閉。若遠程主機上的進程異常停止運行（因爲內存衝突或硬件故障），或者針對套接字執行了一次強行關閉，便會產生這樣的錯誤。針對強行關閉的狀況，可用SO_LINGER套接字選項和setsockopt來配置一個套接字（欲知詳情，請參閱第9章）。
10055—WSAENOBUFS沒有緩衝區空間。因爲系統缺乏足夠的緩衝區空間，請求的操做不能執行。
10056 —WSAEISCONN套接字已經鏈接。代表在一個已創建鏈接的套接字上，試圖再創建一個鏈接。要注意的是，數據報和數據流套接字均有可能出現這樣的錯誤。使用數據報套接字時，假如事先已經過connect或WSAConnect調用，爲數據報通訊關聯了一個端點的地址，那麼之後試圖再次調用 sendto或WSASendTo，便會產生這樣的錯誤。
10057—WSAENOTCONN套接字還沒有鏈接。若在一個還沒有創建鏈接的「面向鏈接」套接字上發出數據收發請求，便會產生這樣的錯誤。
10058 —WSAESHUTDOWN套接字關閉後不能發送。代表已經過對shutdown的一次調用，部分關閉了套接字，但過後又請求進行數據的收發操做。要注意的是，這種錯誤只會在已經關閉的那個數據流動方向上纔會發生。舉個例子來講，完成數據發送後，若調用shutdown，那麼之後任何數據發送調用都會產生這樣的錯誤。
10060—WSAETIMEDOUT鏈接超時。若發出了一個鏈接請求，但通過規定的時間，遠程計算機仍未做出正確的響應（或根本沒有任何響應），便會發生這樣的錯誤。要想收到這樣的錯誤，一般須要先在套接字上設置好SO_SNDTIMEO和SO_RCVTIMEO選項，而後調用 connect及WSAConnect函數。
要想了解在套接字上設置SO_SNDTIMEO和SO_RCVTIMEO選項的詳情，可參考第9章。
10061—WSAECONNREFUSED鏈接被拒。因爲被目標機器拒絕，鏈接沒法創建。這一般是因爲在遠程機器上，沒有任何應用程序可在那個地址之上，爲鏈接提供服務。
10064 —WSAEHOSTDOWN主機關閉。這個錯誤指出因爲目標主機關閉，形成操做失敗。然而，應用程序此時更有可能收到的是一條 WSAETIMEDOUT（鏈接超時）錯誤，由於對方關機的狀況一般是在試圖創建一個鏈接的時候發生的。10065—WSAEHOSTUNREACH沒有到主機的路由。應用程序試圖訪問一個不可抵達的主機。該錯誤相似於WSAENETUNREACH.10067—WSAEPROCLIM進程過多。有些 Winsock服務提供者對可以同時訪問它們的進程數量進行了限制。
10091—WSASYSNOTREADY網絡子系統不可用。調用WSAStartup時，若提供者不能正常工做（因爲提供服務的基層系統不可用），便會返回這種錯誤。
10092—WSAVERNOTSUPPORTEDWinsock.dll版本有誤。代表不支持請求的Winsock提供者版本。
10093—WSANOTINITIALISEDWinsock還沒有初始化。還沒有成功完成對WSAStartup的一次調用。
10101—WSAEDISCON正在從容關閉。這個錯誤是由WSARecv和WSARecvFrom返回的，指出遠程主機已初始化了一次從容關閉操做。該錯誤是在像ATM這樣的「面向消息」協議上發生的。
10102 —WSAENOMORE找不到更多的記錄。這個錯誤自WSALookupServiceNext函數返回，指出已經沒有留下更多的記錄。這個錯誤一般可與 WSA_E_NO_MORE互換使用。在應用程序中，應同時檢查這個錯誤以及WSA_E_NO_MORE.10103—WSAECANCELLED操做被取消。這個錯誤指出當WSALookupServiceNext調用仍在處理期間，發出了對WSALookupServiceEnd（服務停止）的一個調用。此時，WSALookupServiceNext便會返回這個錯誤。這個錯誤代碼可與WSA_E_CANCELLED互換使用。做爲應用程序，應同時檢查這個錯誤以及WSA_E_CANCELLED.10104—WSAEINVALIDPROCTABLE進程調用表無效。該錯誤一般是在進程表包含了無效條目的狀況下，由一個服務提供者返回的。欲知服務提供者的詳情，可參考第14章。
10105—WSAEINVALIDPROVIDER無效的服務提供者。這個錯誤同服務提供者關聯在一塊兒，在提供者不能創建正確的Winsock版本，從而沒法正常工做的前提下產生。
10106—WSAEPROVIDERFAILEDINIT提供者初始化失敗。這個錯誤同服務提供者關聯在一塊兒，一般見於提供者不能載入須要的DLL時。
10107—WSASYSCALLFAILURE系統調用失敗。代表絕對不該失敗的一個系統調用卻使人遺憾地失敗了。
10108—WSASERVICE_NOT_FOUND找不到這樣的服務。這個錯誤一般與註冊和名字解析函數相關，在查詢服務時產生（第10章對這些函數進行了詳盡解釋）。該錯誤代表，在給定的名字空間內，找不到請求的服務。
10109—WSATYPE_NOT_FOUND找不到類的類型。該錯誤也與註冊及名字解析函數關聯在一塊兒，在處理服務類（ServiceClass）時發生。若註冊好一個服務的實例，它必須引用一個之前經過WSAInstallServiceClass安裝好的服務。
10110 —WSA_E_NO_MORE找不到更多的記錄。這個錯誤是自WSALookupServiceNext調用返回的，指出已經沒有剩下的記錄。該錯誤一般可與WSAENOMORE互換使用。做爲一個應用程序，應同時檢查這個錯誤以及WSAENOMORE.10111—WSA_E_CANCELLED操做被取消。該錯誤指出在對WSALookupServiceNext的調用還沒有完成的時候，又發出了對WSALookupServiceEnd（停止服務）的一個調用。這樣，WSALookupServiceNext就會返回該錯誤。這個錯誤代碼可與WSAECANCELLED互換使用。做爲一個應用程序，應同時檢查這個錯誤以及WSAECANCELLED.10112—WSAEREFUSED查詢被拒。因爲被主動拒絕，因此一個數據庫查詢操做失敗。
11001—WSAHOST_NOT_FOUND主機沒有找到。這個錯誤是在調用gethostbyname和gethostbyaddr時產生的，代表沒有找到一個受權應答主機（AuthoritativeAnswerHost）。
11002—WSATRY_AGAIN非受權主機沒有找到。這個錯誤也是在調用gethostbyname和gethostbyaddr時產生的，代表沒有找到一個非受權主機，或者遇到了服務器故障。
11003—WSANO_RECOVERY遇到一個不可恢復的錯誤。這個錯誤也是在調用gethostbyname和gethostbyaddr時產生的，指出遇到一個不可恢復的錯誤，應再次嘗試操做。
11004—WSANO_DATA沒有找到請求類型的數據記錄。這個錯誤也是在調用gethostbyname和gethostbyaddr時產生的，指出儘管提供的名字有效，但卻沒有找到與請求類型對應的數據記錄。
11005—WSA_QOS_RECEIVERS至少有一條預定消息抵達。這個值同IP服務質量（QoS）有着密切的關係，其實並非一個真正的「錯誤」（QoS的詳情見第12章）。它指出網絡上至少有一個進程但願接收QoS通訊。
11006—WSA_QOS_SENDERS至少有一條路徑消息抵達。這個值同QoS關聯在一塊兒，其實更像一種狀態報告消息。它指出在網絡上，至少有一個進程但願進行QoS數據的發送。
11007—WSA_QOS_NO_SENDERS沒有QoS發送者。這個值同QoS關聯在一塊兒，指出再也不有任何進程對QoS數據的發送有興趣。請參閱第12章，瞭解在發生這樣的錯誤時，對所發生狀況的一系列完整說明。
11008—WSA_QOS_NO_RECEIVERS沒有QoS接收者。這個值同QoS關聯在一塊兒，指出再也不有任何進程對QoS數據的接收有興趣。請參閱第12章，查閱對這個錯誤的完整說明。
11009—WSA_QOS_REQUEST_CONFIRMED預定請求已被確認。QoS應用可事先發出請求，但願在批准了本身對網絡帶寬的預定請求後，收到通知。若發出了這樣的請求，一旦批准，便會收到這樣的消息。請參閱第12章，瞭解對此消息的詳細說明。
11010—WSA_QOS_ADMISSION_FAILURE缺少資源致錯。資源不夠，以致於沒法知足QoS帶寬請求。
11011—WSA_QOS_POLICY_FAILURE證書無效。代表發出QoS預定請求的時候，要麼用戶並不具有正確的權限，要麼提供的證書無效。
11012—WSA_QOS_BAD_STYLE未知或衝突的樣式。QoS應用程序可針對一個指定的會話，創建不一樣的過濾器樣式。若出現這一錯誤，代表指定的樣式類型要麼未知，要麼存在衝突。請參閱第12章，瞭解對過濾器樣式的詳細說明。
11013—WSA_QOS_BAD_OBJECT無效的FILTERSPEC結構或者提供者特有對象。假如爲QoS對象提供的FILTERSPEC結構無效，或者提供者特有的緩衝區無效，便會返回這樣的錯誤，詳見第12章。
11014—WSA_QOS_TRAFFIC_CTRL_ERRORFLOWSPEC有問題。假如通訊控制組件發現指定的FLOWSPEC參數存在問題（做爲QoS對象的一個成員傳遞），便會返回這樣的錯誤。
11015—WSA_QOS_GENERIC_ERROR常規QoS錯誤。這是一個比較泛泛的錯誤；假如其餘QoS錯誤都不適合，便返回這個錯誤。
6—WSA_INVALID_HANDLE指定的事件對象無效。若使用與Win32函數對應的Winsock函數，便有可能產生這樣的Win32錯誤。它代表傳遞給WSAWaitForMultipleEvents的一個句柄是無效的。
8—WSA_NOT_ENOUGH_MEMORY內存不夠。這個Win32錯誤指出內存數量不足，沒法完成指定的操做。
87—WSA_INVALID_PARAMETER一個或多個參數無效。這個Win32錯誤代表傳遞到函數內部的參數無效。倘若事件計數參數無效，那麼在執行WSAWaitForMultipleEvents的時候，也會發生這樣的錯誤。
258—WSA_WAIT_TIMEOUT操做超時。這個Win32錯誤指出重疊I/O操做未在規定的時間內完成。
995—WSA_OPERATION_ABORTED重疊操做被取消。這個Win32錯誤指出因爲套接字的關閉，形成一次重疊I/O操做的取消。
除此之外，該錯誤也可能在執行SIO_FLUSH這個I/O控制命令時出現。
996—WSA_IO_INCOMPLETE重疊I/O事件對象未處於傳信狀態。這個Win32錯誤也和重疊I/O操做密切相關，在調用WSAGetOverlappedResults函數的時候產生，指出重疊I/O操做還沒有完成。
997—WSA_IO_PENDING重疊操做將在之後完成。用Winsock函數發出一次重疊I/O操做時，若出現這樣的Win32錯誤，便代表操做還沒有完成，並且會在之後的某個時間完成。