c++-编程模型

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模型。 我们假设客户端的代码如下(为代码直观,省去所有错误检查,以下同):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#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, 0sizeof(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服务器的代码(已经不能再精简了):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#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(NULL0, WorkerThread, NULL0, &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 = {10};
  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, NULLNULL, &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。如下所示:

1
2
3
4
5
6
7
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网络编程》第八章) 我还是先贴出代码,然后做详细解释:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
#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, NULL00))
  {
    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网络编程》第八章) 还是让我们先看代码然后进行分析:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#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(NULL0, WorkerThread, NULL0, &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模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
#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(NULL0, WorkerThread, NULL0, &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模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#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(NULL0, WorkerThread, NULL0, &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, 0sizeof(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公司的时候曾经帮同事写过一个邮件服务器的性能测试程序,用 的就是完成端口模型。结果表明,完成端口模型在多连接(成千上万)的情况下,仅仅依靠一两个辅助线程,就可以达到非常高的吞吐量。下面我还是从代码说起:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#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, NULL00);

  // Create worker thread
  GetSystemInfo(&systeminfo);
  for (i = 0; i < systeminfo.dwNumberOfProcessors; i++)
  {
    CreateThread(NULL0, 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, 0xFFFFFFFF0NULL);
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, 0sizeof(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字节的联合:

1
2
3
4
5
6
7
8
9
10
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、 主机地址: 先看定义:

1
2
3
4
5
6
7
8
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为地址结构的长度。 用法:

1
2
3
4
5
6
7
8
9
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为网络地址的长度。 用法:

1
2
3
4
5
6
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地址的结构的长度。 用法:

1
2
3
4
5
6
7
8
9
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表示不要将包路由出去。 用法:

1
2
3
4
5
6
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为数据接收标记。 返回值为接收的数据的字符数。 用法:

1
2
3
4
5
6
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); <

  • 版权声明: 本博客所有文章,未经许可,任何单位及个人不得做营利性使用!转载请标明出处!如有侵权请联系作者。
  • Copyrights © 2015-2020 翟天野

请我喝杯咖啡吧~