WinSock I/O 模型 -- WSAAsyncSelect 模型

Oct 15, 2021

目录


简介


WSAAsyncSelect 模型也是 WinSock 中常见的异步 I/O 模型。

使用这个模型,网络应用程序通过接收以 Windows 消息为基础的网络事件通知来处理网络请求。

这篇文章我们就来看看如何使用 WSAAsyncSelect api 来实现一个简单的 TCP 服务器.


API 基础


要使用 WSAAsyncSelect 模型,我们必须创建一个窗口, 再为该窗口对象提供一个窗口历程(WinProc). 通过适当的配置之后,当有网络请求到来的时候,windows 会将网络消息投递到我们所创建的窗口对象上,然后我们通过对应的窗口例程来处理该请求.

WinProc

WindowProc 回调函数用来处理 Windows 系统投递到特定窗口的消息。

它的方法签名如下:

1LRESULT CALLBACK WindowProc(
2  _In_ HWND   hwnd,
3  _In_ UINT   uMsg,
4  _In_ WPARAM wParam,
5  _In_ LPARAM lParam
6);
  • hwnd:当前窗口消息关联的窗口句柄
  • uMsg:消息值
  • wParam: 额外的消息信息。 具体含义依赖于 uMsg 的值
  • lParam:额外的消息信息。 具体含义依赖于 uMsg 的值

RegisterClass

RegisterClass 用来注册一个窗口类型,以便在后续的 CreateWindow 或 CreateWindowEx 中使用.

1ATOM RegisterClassA(
2  const WNDCLASSA *lpWndClass
3);

这里不详细介绍该函数的用法,参考 实例 章节。 值得注意的是,我们的窗口例程(WinProc 函数)便需要设置到 lpWndClass 对象上. 同时非常重要的是,这个类型上还需要包含我们需要注册的窗口类型的名称.

CreateWindowEx

CreateWindowEx 用来创建一个窗口对象.

 1HWND CreateWindowExA(
 2  DWORD     dwExStyle,
 3  LPCSTR    lpClassName,
 4  LPCSTR    lpWindowName,
 5  DWORD     dwStyle,
 6  int       X,
 7  int       Y,
 8  int       nWidth,
 9  int       nHeight,
10  HWND      hWndParent,
11  HMENU     hMenu,
12  HINSTANCE hInstance,
13  LPVOID    lpParam
14);

在我们的程序中,我们仅仅需要一个简单的窗口对象,因此在我们的实例中绝大部分参数都是用默认值。 这里也不详细展开,用法参考 实例 章节。

WSAAsyncSelect

WSAAsyncSelect 用于将窗口和 SOCKET 对象绑定起来,可以指定关心的 SOCKET 事件.

1int WSAAsyncSelect(
2  SOCKET s,
3  HWND   hWnd,
4  u_int  wMsg,
5  long   lEvent
6);

wMsg 指定一个消息值,当对应的 SOCKET 上有 SOCKET 事件发生的时候,窗口例程会被调用,这个消息值会被传回来给我们。主要用于区别系统的窗口事件和我们自定义的事件.

GetMessage

GetMessage 从当前线程的消息队列中获取消息。

1BOOL GetMessage(
2  LPMSG lpMsg,
3  HWND  hWnd,
4  UINT  wMsgFilterMin,
5  UINT  wMsgFilterMax
6);
  • lpMsg: 是一个 MSG 结构体,用来接收消息信息
  • hWnd:指定想要获取窗口信息的窗口句柄
  • wMsgFilterMin:略
  • wMsgFilterMax:略

TranslateMessage

TranslateMessage 用于将 virtual-key message 转化为 character message. character mesage。 character message 可以再使用 DispatchMessage 将消息分发到窗口例程(WinProc 函数)。

1BOOL TranslateMessage(
2  const MSG *lpMsg
3);

DispatchMessage

DispatchMessage 用于将窗口消息分发到窗口例程(WinProc 函数)。

1LRESULT DispatchMessage(
2  const MSG *lpMsg
3);

实现思路


  1. 创建一个窗口对象,指定对应窗口的 WinProc 函数
  2. 创建 SOCKET 对象,作为监听的 SOCKET
  3. 使用 WSAAsyncSelect 函数将窗口与 SOCKET 关联起来. 同时指定SOCKET消息的消息值和 关心的 SOCKET 事件
  4. 调用 listen,开始接收客户端连接
  5. 使用 GetMessage 函数来从消息队列中获取可用的消息
  6. 获取到消息后,使用TranslateMessage 处理消息,然后调用 DispatchMessage 来分发 SOCKET 消息到我们步骤1中指定的窗口 WinProc 函数中。
  7. 循环 5-6 步骤
  8. 再 WinProc 函数中使用 WSAGETSELECTEVENT 来判断具体的 SOCKET 消息,并进行处理
  9. 如果有新的SOCKET连接到来,接收它,并再次使用 WSAAsyncSelect 将该客户端 SOCKET 与我们步骤1 中创建的窗口关联起来,并指定关心的 SOCKET 事件

实例


这里我们通过一个实例来看看如何实现:

  1#define WIN32_LEAN_AND_MEAN
  2#define _WINSOCK_DEPRECATED_NO_WARNINGS
  3
  4#include <winsock2.h>
  5#include <windows.h>
  6#include <stdio.h>
  7#include <conio.h>
  8
  9#pragma comment(lib,"ws2_32.lib")
 10
 11#define PORT 8080
 12#define DATA_BUFSIZE 8192
 13
 14typedef struct _SOCKET_CONTEXT {
 15   BOOL   RecvPosted;
 16   CHAR   Buffer[DATA_BUFSIZE];
 17   WSABUF DataBuf;
 18   SOCKET Socket;
 19   DWORD  BytesSEND;
 20   DWORD  BytesRECV;
 21   struct _SOCKET_CONTEXT *Next;
 22} SOCKET_CONTEXT, *LPSOCKET_CONTEXT;
 23
 24// 我们使用 WM_SOCKET 作为 SOCKET 消息的消息值, 这样在 WinProc 中我们可以通过检查
 25// 当前消息的消息值是否是 VM_SOCKET来决定是否处理该消息
 26#define WM_SOCKET (WM_USER + 1)
 27
 28void             CreateSocketContext(SOCKET s);
 29LPSOCKET_CONTEXT GetSocketContext(SOCKET s);
 30void             FreeSocketContext(SOCKET s);
 31HWND             MakeWorkerWindow(void);
 32LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 33LPSOCKET_CONTEXT SocketContexts;
 34
 35int main() {
 36
 37  MSG         msg;
 38  DWORD       Ret;
 39  SOCKET      ListenSocket;
 40  SOCKADDR_IN Addr;
 41  HWND        Window;
 42  WSADATA     wsaData;
 43
 44  // 创建用户接收 SOCKET 事件消息的窗口,将 WinProc 函数指定为 WindowProc
 45  if ((Window = MakeWorkerWindow()) == NULL) {
 46    printf("MakeWorkerWindow() failed!\n");
 47    return 1;
 48  }
 49
 50  // 初始化 Listen Socket 对象
 51  if (WSAStartup(0x0202, &wsaData) != 0) {
 52    printf("WSAStartup() failed with error %d\n", WSAGetLastError());
 53    return 1;
 54  }
 55
 56  if ((ListenSocket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
 57    printf("socket() failed with error %d\n", WSAGetLastError());
 58    return 1;
 59  }
 60
 61  // 将 ListenSocket 与我们创建的 Window 关联起来
 62  // 指定 SOCKET 消息的消息值为 WM_SOCKET
 63  // 我们关心的 ListenSocket 事件为: FD_ACCEPT 和 FD_CLOSE
 64  if(WSAAsyncSelect(ListenSocket, Window, WM_SOCKET, FD_ACCEPT|FD_CLOSE) != 0) {
 65    printf("WSAAsyncSelect() failed with error code %d\n", WSAGetLastError());
 66    return 1;
 67  }
 68
 69  Addr.sin_family      = AF_INET;
 70  Addr.sin_addr.s_addr = htonl(INADDR_ANY);
 71  Addr.sin_port        = htons(PORT);
 72 
 73  if (bind(ListenSocket, (PSOCKADDR) &Addr, sizeof(Addr)) == SOCKET_ERROR) {
 74    printf("bind() failed with error %d\n", WSAGetLastError());
 75    return 1;
 76  }
 77
 78  if (listen(ListenSocket, 10)) {
 79    printf("listen() failed with error %d\n", WSAGetLastError());
 80    return 1;
 81  }
 82
 83  // 循环,处理当前消息队列中的消息
 84  // 当有新的消息可用时,使用 TranslateMessage 转化消息,并将转换后的消息通过 DispatchMessage 分发到我们的 WinProc 函数 
 85  while(Ret = GetMessage(&msg, NULL, 0, 0)) {
 86    if (Ret == -1) {
 87      printf("\nGetMessage() failed with error %d\n", GetLastError());
 88      return 1;
 89    }
 90    TranslateMessage(&msg);
 91    printf("Dispatching a message...\n");
 92    DispatchMessage(&msg);
 93  }
 94}
 95
 96// 当有新的消息可用时,windows 操作系统会回调我们这个函数
 97LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
 98  SOCKET               AcceptSocket;
 99  LPSOCKET_CONTEXT     SocketContext;
100  DWORD                RecvBytes;
101  DWORD                SendBytes;
102  DWORD                Flags;
103  
104  // 我们仅仅关系消息值是 WM_SOCKET 的消息,其他消息值代表系统的消息,我们不处理
105  // 对于其他消息,我们使用 DefWindowProc 函数来调用系统默认窗口例程来处理该消息
106  if (uMsg == WM_SOCKET) {
107    // 使用 WSAGETSELECTERROR 来检查是否发生了 SOCKET 错误
108    if (WSAGETSELECTERROR(lParam)) {
109      printf("Socket failed with error %d\n", WSAGETSELECTERROR(lParam));
110      FreeSocketContext(wParam);
111    } else {
112      // 使用 WSAGETSELECTEVENT 来获取具体的 SOCKET 消息类型
113      switch(WSAGETSELECTEVENT(lParam)) {
114        // 有新的客户端连接请求,接收它
115        case FD_ACCEPT:
116          if ((AcceptSocket = accept(wParam, NULL, NULL)) == INVALID_SOCKET) {
117            printf("accept() failed with error %d\n", WSAGetLastError());
118            break;
119          }
120          CreateSocketContext(AcceptSocket);
121          printf("Socket number %d connected\n", AcceptSocket);
122          // 将新的 SOCKET 与我们的窗口句柄关联,这样我们便能获取到这个 SOCKET 上的所有消息了。 
123          // 对于客户端连接,我们关心的事件类型包括: FD_READ, FD_WRITE, FD_CLOSE
124          WSAAsyncSelect(AcceptSocket, hwnd, WM_SOCKET, FD_READ|FD_WRITE|FD_CLOSE);
125          break;
126        
127        // 客户端链接上有数据到来,读取数据
128        case FD_READ:
129          SocketContext = GetSocketContext(wParam);
130
131          if (SocketContext->BytesRECV != 0) {
132            SocketContext->RecvPosted = TRUE;
133            return 0;
134          } else {
135            SocketContext->DataBuf.buf = SocketContext->Buffer;
136            SocketContext->DataBuf.len = DATA_BUFSIZE;
137
138            Flags = 0;
139            if (WSARecv(SocketContext->Socket, &(SocketContext->DataBuf), 1, &RecvBytes, &Flags, NULL, NULL) == SOCKET_ERROR) {
140
141              if (WSAGetLastError() != WSAEWOULDBLOCK) {
142                printf("WSARecv() failed with error %d\n", WSAGetLastError());
143                FreeSocketContext(wParam);
144                return 0;
145              }
146            } else {
147              printf("WSARecv() is OK!\n");
148              SocketContext->BytesRECV = RecvBytes;
149            }
150          }
151          // 客户端可以写入数据(之前的数据已经全部发送,或者连接刚刚建立)
152        case FD_WRITE:
153          SocketContext = GetSocketContext(wParam);
154          if (SocketContext->BytesRECV > SocketContext->BytesSEND) {
155            SocketContext->DataBuf.buf = SocketContext->Buffer + SocketContext->BytesSEND;
156            SocketContext->DataBuf.len = SocketContext->BytesRECV - SocketContext->BytesSEND;
157
158            if (WSASend(SocketContext->Socket, &(SocketContext->DataBuf), 1, &SendBytes, 0, NULL, NULL) == SOCKET_ERROR) {
159              if (WSAGetLastError() != WSAEWOULDBLOCK) {
160                printf("WSASend() failed with error %d\n", WSAGetLastError());
161                FreeSocketContext(wParam);
162                return 0;
163              }
164            } else { // No error so update the byte count
165              printf("WSASend() is OK!\n");
166              SocketContext->BytesSEND += SendBytes;
167            }
168          }
169
170          if (SocketContext->BytesSEND == SocketContext->BytesRECV) {
171            SocketContext->BytesSEND = 0;
172            SocketContext->BytesRECV = 0;
173            if (SocketContext->RecvPosted == TRUE) {
174              SocketContext->RecvPosted = FALSE;
175              // 这里我们通过 PostMessage 来发送 FD_READ 消息
176              PostMessage(hwnd, WM_SOCKET, wParam, FD_READ);
177            }
178          }
179          break;
180
181        case FD_CLOSE:
182          printf("Closing socket %d\n", wParam);
183          FreeSocketContext(wParam);
184          break;
185       }
186    }
187    return 0;
188  }
189  return DefWindowProc(hwnd, uMsg, wParam, lParam);
190}
191
192// 创建窗口句柄的函数
193HWND MakeWorkerWindow(void) {
194
195  WNDCLASS wndclass;
196  CHAR *ProviderClass = (CHAR*)"AsyncSelect";
197  HWND Window;
198
199  wndclass.style = CS_HREDRAW | CS_VREDRAW;
200  // 这里非常重要:我们的 WindowProc 注册到当前 WNDClass 上
201  // 这样当我们将 SOCKET 和我们这个窗口类型的窗口句柄关联起来后,
202  // 我们便会在 WindowProc 中接受到对应的 SOCKET 消息
203  wndclass.lpfnWndProc = (WNDPROC)WindowProc;
204  wndclass.cbClsExtra = 0;
205  wndclass.cbWndExtra = 0;
206  wndclass.hInstance = NULL;
207  wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
208  wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
209  wndclass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
210  wndclass.lpszMenuName = NULL;
211  wndclass.lpszClassName = (LPCSTR)ProviderClass;
212
213  if (RegisterClass(&wndclass) == 0) {
214    printf("RegisterClass() failed with error %d\n", GetLastError());
215    return NULL;
216  }
217
218  // Create a window
219  Window = CreateWindowEx (
220    0,                              // Optional window styles.
221    (LPCSTR)ProviderClass,          // Window class
222    "TEST",                         // Window text
223    WS_OVERLAPPEDWINDOW,            // Window style
224    CW_USEDEFAULT,
225    CW_USEDEFAULT, 
226    CW_USEDEFAULT, 
227    CW_USEDEFAULT,
228    NULL,  
229    NULL,
230    NULL,
231    NULL
232  );
233
234  if (Window == NULL) {
235    printf("CreateWindow() failed with error %d\n", GetLastError());
236    return NULL;
237  }
238  return Window;
239}
240
241void CreateSocketContext(SOCKET s) {
242  LPSOCKET_CONTEXT SocketContxt;
243
244  if ((SocketContxt = (LPSOCKET_CONTEXT) GlobalAlloc(GPTR, sizeof(SOCKET_CONTEXT))) == NULL) {
245    printf("GlobalAlloc() failed with error %d\n", GetLastError());
246    return;
247  }
248
249  // Prepare SocketInfo structure for use
250  SocketContxt->Socket = s;
251  SocketContxt->RecvPosted = FALSE;
252  SocketContxt->BytesSEND = 0;
253  SocketContxt->BytesRECV = 0;
254  SocketContxt->Next = SocketContexts;
255  SocketContexts = SocketContxt;
256}
257
258LPSOCKET_CONTEXT GetSocketContext(SOCKET s) {
259  SOCKET_CONTEXT *SocketContext = SocketContexts;
260  while(SocketContext) {
261    if (SocketContext->Socket == s) return SocketContext;
262    SocketContext = SocketContext->Next;
263  }
264  return NULL;
265}
266
267void FreeSocketContext(SOCKET s) {
268  SOCKET_CONTEXT *SocketContext = SocketContexts;
269  SOCKET_CONTEXT *PrevSocketContext = NULL;
270
271  while(SocketContext) {
272    if (SocketContext->Socket == s) {
273      if (PrevSocketContext) PrevSocketContext->Next = SocketContext->Next;
274      else                   SocketContexts = SocketContext->Next;
275
276      closesocket(SocketContext->Socket);
277      GlobalFree(SocketContext);
278      return;
279    }
280    PrevSocketContext = SocketContext;
281    SocketContext = SocketContext->Next;
282   }
283}

END ! ! !


Tags