WSAAsyncSelect模型接收数组包的问题

coolhty

下面是WSAAsyncSelect的处理代码，但是总感觉别扭。
1.如果有无聊的人连接上来不发送数据也不关闭连接就永远不会有FD_CLOSE消息，导致存储lp_client_read_info的信息永远会保存在list里面。
2.用list保存组包缓冲区，这种方式合不合适呢，一般WSAAsyncSelect模式怎么保存SOCKET组包缓冲区的？

1. void DSocketServer::OnMessage(SOCKET sock, LPARAM lParam, HWND hWnd)
   
2. {
   
3.         if (WSAGETSELECTERROR(lParam)) {
   
4.                 closesocket(sock);
   
5.                 return;
   
6.         }
   
7.         switch (WSAGETSELECTEVENT(lParam))
   
8.         {
   
9.         case FD_ACCEPT:
   
10.         {
    
11.                 sockaddr_in clientAddr;
    
12.                 int addr_size = sizeof(sockaddr);
    
13.                 SOCKET clientSock = accept(m_socket_server, (sockaddr*)&clientAddr, &addr_size);
    
14.                 if (INVALID_SOCKET == clientSock)
    
15.                 {
    
16.                         globalUserLog.Error(TEXT("客户端套按字无效！错误码：%ld"), WSAGetLastError());
    
17.                         return;
    
18.                 }
    
19.                 char *clientIp = inet_ntoa(clientAddr.sin_addr);
    
20.                
    
21.                 // 读取数据的结构体，第一次进来先需要读取头信息，描述数据包的大小之类的信息
    
22.                 lp_client_read_info lpReadInfo = new client_read_info{0};
    
23.                 // 保存客户端的IP
    
24.                 _tcscpy_s(lpReadInfo->client_ip, 88, clientIp);
    
25.                 lpReadInfo->client_sock = clientSock;
    
26.                 // 应该接收的数据长度，h_info头信息的结构
    
27.                 lpReadInfo->data_len = sizeof(h_info);
    
28.                 // 接收数据的缓冲
    
29.                 lpReadInfo->data = new TCHAR[lpReadInfo->data_len]{0};
    
30.                 // 将结构体保存到一个list，它是一个类属性
    
31.                 push_client_info(lpReadInfo);
    
32.                 // 绑定READ和CLOSE消息
    
33.                 WSAAsyncSelect(clientSock, hWnd, WM_ASYNC_SOCKET, FD_READ | FD_CLOSE);
    
34.                 break;
    
35.         }
    
36.         case FD_READ:
    
37.         {
    
38.                 WSAAsyncSelect(sock, hWnd, 0, 0);
    
39.                 // 根据SOCKET取出对应的lp_client_read_info结构
    
40.                 lp_client_read_info lpReadInfo = get_client_info(sock);
    
41.                 if (sock != lpReadInfo->client_sock)
    
42.                 {
    
43.                         return;
    
44.                 }
    
45.                
    
46.                 // 计算剩下需要读取的数据
    
47.                 UINT readBufLen = lpReadInfo->data_len - lpReadInfo->readed_len;
    
48.                 // 最多一次读取MAX_READ_BUF个字节
    
49.                 if (readBufLen > MAX_READ_BUF)
    
50.                 {
    
51.                         readBufLen = MAX_READ_BUF;
    
52.                 }
    
53. 
    
54.                 TCHAR tmpBuf[MAX_READ_BUF] = {0};
    
55.                 int recvLen = recv(sock, tmpBuf, readBufLen, 0);
    
56.                 if (SOCKET_ERROR == recvLen)
    
57.                 {
    
58.                         int wsaErrorNo = WSAGetLastError();
    
59.                         if (wsaErrorNo != WSAEWOULDBLOCK && wsaErrorNo != WSAEINTR)
    
60.                         {
    
61.                                 switch (wsaErrorNo)
    
62.                                 {
    
63.                                 case WSAETIMEDOUT:
    
64.                                 {
    
65.                                         globalUserLog.Error(TEXT("读取数据超时，IP:%s"), lpReadInfo->client_ip);
    
66.                                 }
    
67.                                 break;
    
68.                                 case WSAECONNRESET:
    
69.                                 {
    
70.                                         globalUserLog.Error(TEXT("远程主机强制断开连接，IP:%s"), lpReadInfo->client_ip);
    
71.                                 }
    
72.                                 break;
    
73.                                 default:
    
74.                                 {
    
75.                                         globalUserLog.Error(TEXT("读取数据时发生未知网络错误，错误码：%d，IP:%s"), wsaErrorNo, lpReadInfo->client_ip);
    
76.                                 }
    
77.                                 break;
    
78.                                 }
    
79.                                 WSAAsyncSelect(sock, hWnd, WM_ASYNC_SOCKET, FD_CLOSE);
    
80.                         }
    
81.                         else
    
82.                         {
    
83.                                 WSAAsyncSelect(sock, hWnd, WM_ASYNC_SOCKET, FD_READ);
    
84.                         }
    
85.                 }
    
86.                 else if (recvLen > 0 && recvLen + lpReadInfo->readed_len > lpReadInfo->data_len)
    
87.                 {
    
88.                         globalUserLog.Error(TEXT("数据可能被篡改，IP:%s"), lpReadInfo->client_ip);
    
89.                         WSAAsyncSelect(sock, hWnd, WM_ASYNC_SOCKET, FD_CLOSE);
    
90.                 }
    
91.                 else
    
92.                 {
    
93.                         // 读取到数据后保存到缓冲区
    
94.                         if (recvLen > 0)
    
95.                         {
    
96.                                 memcpy_s(lpReadInfo->data + lpReadInfo->readed_len, lpReadInfo->data_len - lpReadInfo->readed_len, tmpBuf, recvLen);
    
97.                                 lpReadInfo->readed_len += recvLen;
    
98.                         }
    
99.                         // 如果数据读取完成开始处理数据
    
100.                         if (lpReadInfo->data_len == lpReadInfo->readed_len)
     
101.                         {
     
102.                        
     
103.                                 // 判断组包后的数据是不是头数据包，如果是头数据包，再继续读实际要用的数据
     
104.                                 if (!lpReadInfo->readed_header)
     
105.                                 {
     
106.                                         h_info header_info = {0};
     
107.                                         memcpy_s(&header_info, sizeof(h_info), lpReadInfo->data, sizeof(h_info));
     
108.                                         delete[] lpReadInfo->data;
     
109.                                         lpReadInfo->data = nullptr;
     
110. 
     
111.                                         // 标识为头数据包已经读完了
     
112.                                         lpReadInfo->readed_header = TRUE;
     
113.                                         lpReadInfo->data_len = ntohl(header_info.data_len);
     
114.                                         lpReadInfo->origin_data_len = ntohl(header_info.origin_data_len);
     
115.                                         lpReadInfo->readed_len = 0;
     
116.                                         try
     
117.                                         {
     
118.                                                 lpReadInfo->data = new TCHAR[lpReadInfo->data_len]{ 0 };
     
119.                                                 if (NULL == lpReadInfo->data)
     
120.                                                 {
     
121.                                                         WSAAsyncSelect(sock, hWnd, WM_ASYNC_SOCKET, FD_CLOSE);
     
122.                                                         globalUserLog.Error(TEXT("内存分配失败，分配大小：%ld"), lpReadInfo->data_len);
     
123.                                                 }
     
124.                                                 else
     
125.                                                 {
     
126.                                                         WSAAsyncSelect(sock, hWnd, WM_ASYNC_SOCKET, FD_READ);
     
127.                                                 }
     
128.                                         }
     
129.                                         catch (const std::bad_alloc &memEx)
     
130.                                         {
     
131.                                                 WSAAsyncSelect(sock, hWnd, WM_ASYNC_SOCKET, FD_CLOSE);
     
132.                                                 globalUserLog.Error(TEXT("内存分配发生异常，分配大小：%ld"), lpReadInfo->data_len);
     
133.                                         }
     
134.                                 }
     
135.                                 else
     
136.                                 {
     
137.                                     // 最后处理数据
     
138.                                         EnterCriticalSection(&m_cs);
     
139.                                         UINT ret = m_dataHandler.Handler(lpReadInfo->data,lpReadInfo->data_len, lpReadInfo->origin_data_len);
     
140.                                         LeaveCriticalSection(&m_cs);
     
141.                                         ret = htonl(ret);
     
142.                                         int sendRet = send(sock, (const char*)&ret, sizeof(UINT), 0);
     
143.                                         if (SOCKET_ERROR == sendRet)
     
144.                                         {
     
145.                                                 globalUserLog.Error(TEXT("返回结果时发生未知网络错误，错误码：%d，IP:%s"), WSAGetLastError(), lpReadInfo->client_ip);
     
146.                                         }
     
147.                                         WSAAsyncSelect(sock, hWnd, WM_ASYNC_SOCKET, FD_CLOSE);
     
148.                                 }
     
149.                         }
     
150.                         else
     
151.                         {
     
152.                                 WSAAsyncSelect(sock, hWnd, WM_ASYNC_SOCKET, FD_READ);
     
153.                         }
     
154.                 }
     
155.         }
     
156.                 break;
     
157.         case FD_CLOSE:
     
158.         {
     
159.                 WSAAsyncSelect(sock, hWnd, 0, 0);
     
160.                 // 移除sock对应的数据结构体
     
161.                 remove_client_info(sock);
     
162.                 closesocket(sock);
     
163.         }
     
164.                 break;
     
165.         }
     
166. }

复制代码

成陌1

前来学习C语言