封装WSAEventSelect模型

 

1. #include <winsock2.h>
2. #include <process.h>
3. #pragma comment(lib,"ws2_32.lib")
5. #pragma once
7. class CAsyncHandler
8. {
9. public:
10.     CAsyncHandler()
11.     {
12.     }
13.     virtual ~CAsyncHandler()
14.     {
15.     }
16.     virtual int AcceptNotify( SOCKET hSocket, const char *strClientIP, unsigned short usClientPort )= 0;
18. };
19. class CAsynch_Event_Handler
20. {
21. public:
22.     CAsynch_Event_Handler(void);
23.     ~CAsynch_Event_Handler(void);
24.     int Start(CAsyncHandler * phEvent, UINT unPort);
25.     int Stop(void);
27. protected:
28.     static unsigned int  __stdcall AcceptThread(void * lpParam);
29.     unsigned int  AcceptThreadProc();
31. private:
32.     SOCKET  m_hListenSocket;
33.     HANDLE  m_hIOThread;
34.     HANDLE  m_hExitThread;
35.     CAsyncHandler *m_pEventHandler;
37. private:
38.     int OnAccept(); 
39.     BOOL InitSocket()
40.     {
41.         WORD wVersionRequested;
42.         WSADATA wsaData;
43.         int err;
45.         wVersionRequested = MAKEWORD( 2, 2 );
47.         err = WSAStartup( wVersionRequested, &wsaData );
48.         if ( err != 0 )
49.         {
50.             /* Tell the user that we could not find a usable */
51.             /* WinSock DLL. 
52.             */
53.             return FALSE;
54.         }
56.         /* Confirm that the WinSock DLL supports 2.2.*/
57.         /* Note that if the DLL supports versions greater    */
58.         /* than 2.2 in addition to 2.2, it will still return */
59.         /* 2.2 in wVersion since that is the version we      */
60.         /* requested.                                        */
62.         if ( LOBYTE( wsaData.wVersion ) != 2 ||
63.             HIBYTE( wsaData.wVersion ) != 2 )
64.         {
65.             /* Tell the user that we could not find a usable */
66.             /* WinSock DLL.                                  */
67.             WSACleanup( );
68.             return FALSE; 
69.         }
71.         return TRUE;
72.     };
74.     BOOL ClearSocket()
75.     {
76.         WSACleanup( );
78.         return TRUE;
79.     };
81. };
84. ///*************** CPP*****************//
85. #include "StdAfx.h"
86. #include "Asynch_Event_Handler.h"
87. #include <iostream>
88. using namespace std;
90. CAsynch_Event_Handler::CAsynch_Event_Handler(void)
91. {
92.     m_hListenSocket = INVALID_SOCKET;
93. }
95. CAsynch_Event_Handler::~CAsynch_Event_Handler(void)
96. {
97. }
99. int CAsynch_Event_Handler::Start(CAsyncHandler * phEvent, UINT unPort)
100. {
101.     if( m_hListenSocket != INVALID_SOCKET )
102.     {
103.         return 0;
104.     }
106.     InitSocket();
108.     m_pEventHandler = phEvent;
110.     struct sockaddr_in serverAddress;
111.     int     err;
114.     m_hListenSocket = socket(AF_INET, SOCK_STREAM, 0);
116.     if( INVALID_SOCKET == m_hListenSocket )
117.     {
118.         err = WSAGetLastError();
119.         return err;
120.     }
123.     memset(&serverAddress, 0, sizeof(serverAddress));
124.     serverAddress.sin_family      = AF_INET;
125.     serverAddress.sin_addr.s_addr = 0;
126.     serverAddress.sin_port   = htons( unPort );
128.     err = bind(m_hListenSocket,
129.         (struct sockaddr *)&serverAddress,
130.         sizeof(serverAddress)
131.         );
133.     if( err == SOCKET_ERROR )
134.     {
135.         err = WSAGetLastError();
136.         closesocket( m_hListenSocket );
137.         m_hListenSocket = INVALID_SOCKET;
139.         return err;
140.     }
142.     err = listen( m_hListenSocket, SOMAXCONN );
144.     if( err == SOCKET_ERROR )
145.     {
146.         err = WSAGetLastError();
147.         closesocket( m_hListenSocket );
148.         m_hListenSocket = INVALID_SOCKET;
150.         return err;
151.     }
153.     m_hExitThread = CreateEvent( NULL, TRUE, FALSE, NULL );
155.     m_hIOThread = (HANDLE) 
156.         _beginthreadex(
157.         NULL,
158.         0,
159.         AcceptThread,
160.         this,
161.         0,
162.         0 );
164.     return 0;
165. }
167. int CAsynch_Event_Handler::Stop(void)
168. {
169.     if(  INVALID_SOCKET == m_hListenSocket )
170.     {
171.         return 0;
172.     }
174.     closesocket( m_hListenSocket );
175.     m_hListenSocket = INVALID_SOCKET;
178.     SetEvent( m_hExitThread );
180.     if( WAIT_TIMEOUT == WaitForSingleObject( m_hIOThread, 10000 ) )
181.     {
182.         TerminateThread( m_hIOThread, 1 );
183.     }
185.     CloseHandle( m_hExitThread );
186.     CloseHandle( m_hIOThread );
188.     ClearSocket();
190.     return 0;
191. }
193. unsigned int  CAsynch_Event_Handler::AcceptThreadProc()
194. {
195.     WSANETWORKEVENTS Events;
197.     WSAEVENT hWaitAll[WSA_MAXIMUM_WAIT_EVENTS] = { INVALID_HANDLE_VALUE };  
199.     hWaitAll[0] = m_hExitThread;
200.     hWaitAll[1] = WSACreateEvent();
202.     WSAEventSelect(
203.         m_hListenSocket,
204.         hWaitAll[1],
205.         FD_ACCEPT );
207.     int nWaitCounts = 2;
209.     while( TRUE )
210.     {
211.         DWORD wt = WSAWaitForMultipleEvents(
212.             nWaitCounts,
213.             hWaitAll,
214.             FALSE,
215.             INFINITE,
216.             TRUE );
218.         if( wt == WAIT_OBJECT_0 )
219.         {
220.             //退出线程
221.             break;
222.         }
224.         DWORD index = wt - WSA_WAIT_EVENT_0;
225.         if( index == 1 )
226.         {
227.             int nResult = WSAEnumNetworkEvents(
228.                 m_hListenSocket,
229.                 hWaitAll[1],
230.                 &Events);
232.             if( 0 == nResult )
233.             {
234.                 //接受
235.                 if( Events.lNetworkEvents & FD_ACCEPT ) 
236.                 {
237.                     if( SOCKET_ERROR == Events.iErrorCode[FD_ACCEPT_BIT] )
238.                     {
239.                         continue;
240.                     }
241.                     else
242.                     {
243.                         //接受连接 
244.                         OnAccept();
245.                     }
246.                 }
247.             }
248.         }
249.         else if( wt == WAIT_IO_COMPLETION )
250.         {
251.             continue;
252.         }
253.         else 
254.         {
255.             break;
256.         }
257.     }
259.     return 0;
260. }
262. unsigned int  __stdcall CAsynch_Event_Handler::AcceptThread(void * lpParam)
263. {
264.     CAsynch_Event_Handler *pAcceptor = (CAsynch_Event_Handler *)lpParam;
266.     return pAcceptor->AcceptThreadProc();
267. }
268.     
269. int CAsynch_Event_Handler::OnAccept()
270. {
271.     SOCKET AcceptSocket;
272.     struct sockaddr_in clientAddress;
273.     int clientAddrLen = sizeof(sockaddr_in);
275.     AcceptSocket = accept( m_hListenSocket, (sockaddr *)&clientAddress, &clientAddrLen );
277.     if( INVALID_SOCKET == AcceptSocket )
278.     {
279.         return WSAGetLastError();
280.     }
281.     else
282.     {
283.         DWORD nValue = 1;
284.         int nLen = sizeof( nValue );
286.         if( SOCKET_ERROR == setsockopt( AcceptSocket, IPPROTO_TCP ,TCP_NODELAY, (char *)&nValue, nLen ) )
287.         {
288.             int err = WSAGetLastError();
289.         }
290.         
292.         nValue = 16384;
293.         if( SOCKET_ERROR == setsockopt( AcceptSocket, SOL_SOCKET ,SO_SNDBUF, (char *)&nValue, nLen ) )
294.         {
295.             int err = WSAGetLastError();
296.         }
298.         if( SOCKET_ERROR == setsockopt( AcceptSocket, SOL_SOCKET ,SO_RCVBUF, (char *)&nValue, nLen ) )
299.         {
300.             int err = WSAGetLastError();
301.         }
303.         m_pEventHandler->AcceptNotify( AcceptSocket, inet_ntoa( clientAddress.sin_addr ), ntohs( clientAddress.sin_port )  );
305.         return 0;
306.     }
307. }