Socket编程5种模型——以代码说明一切,hhhhh

  我会以一个回应反射式服务器(与《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] = '';
    printf("Received [%d bytes]: '%s'
", 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
", 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.
", 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] = '';
     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] = '';
                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
", 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)
    {
        /*
        WINSOCK_API_LINKAGE
        DWORD
        WSAAPI
        WSAWaitForMultipleEvents(
            _In_ DWORD cEvents,
            _In_reads_(cEvents) const WSAEVENT FAR * lphEvents,
            _In_ BOOL fWaitAll,
            _In_ DWORD dwTimeout,
            _In_ BOOL fAlertable
        );
        */
        // 当链接数为0时,那么就不等待呗,也就是说直接返回,要等待的个数为0
        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);
        /*
            typedef struct _WSANETWORKEVENTS {
                long lNetworkEvents;            //指向已经发生的网络事件 ,FD_ACCEPT,FD_READ
                int iErrorCode[FD_MAX_EVENTS];
            } WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;
        */
        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] = '';
                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
", 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] = '';
            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
", 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] = '';
        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异步操作的代码在同一个线程之内)。

线程可警告状态的真实含义
1、通过另一些方法让线程”暂停”(非SuspendThread方法,比如SleepEx,wait函数族等),并可以进入一种称之为Alterable的状态(可警告状态)
2、这种状态本质上其实是高速系统调度程序:当前现成的函数调用栈以及对应的寄存器状态可以直接被用来调用别的一些函数,一般这种函数都被称为异步函数
3、通常系统会用此线程环境(理解为函数调用器)来调用一些其他的回调函数(比如:IO完成通知,线程的异步调用队列等)
4、这样借用线程的好处是,系统不必为一些回调函数大费周折的创建一些新的专用线程,既可以达到节约系统资源的目的,还可以充分发挥系统性能
5、通常异步函数最好能够很快执行完,不要做太耗时的操作,不然真正的线程函数需要执行时,会无法立即执行

  完成例程内的实现代码比较简单,它取出接收到的数据,然后将数据原封不动的发送给客户端,最后重新激活另一个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
", 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,
            (PULONG_PTR)&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] = '';
                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,感觉效率差不多;至于异步选择,不好比较。

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.
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
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(连接超时)错误,因为对方关机的情况通常是在试图建立一个连接的时候发生的。
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
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
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错误,便表明操作尚未完成,而且会在以后的某个时间完成。
原文地址:https://www.cnblogs.com/laohaozi/p/12538088.html