封装WSAEventSelect模型

{
WSANETWORKEVENTS Events;
WSAEVENT hWaitAll[WSA_MAXIMUM_WAIT_EVENTS] = { INVALID_HANDLE_VALUE };
hWaitAll[0] = m_hExitThread;
hWaitAll[1] = WSACreateEvent();
m_hListenSocket,
hWaitAll[1],
&Events);
if( 0 == nResult )
{
//接受
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 )
_beginthreadex(
NULL,
0,
AcceptThread,
this,
0,
0 );
return 0;
}
int CAsynch_Event_Handler::Stop(void)
WSAEventSelect(
m_hListenSocket,
hWaitAll[1],
FD_ACCEPT );
int nWaitCounts = 2;
while( TRUE )
{
DWORD wt = WSAWaitForMultipleEvents(
SetEvent( m_hExitThread );
if( WAIT_TIMEOUT == WaitForSingleObject( m_hIOThread, 10000 ) )
{
TerminateThread( m_hIOThread, 1 );
}
};
};
///*************** CPP*****************//
#include "StdAfx.h"
#include "Asynch_Event_Handler.h"
#include <iostream>
using namespace std;
CAsynch_Event_Handler::CAsynch_Event_Handler(void)
HIBYTE( wsaData.wVersion ) != 2 )
{
/* Tell the user that we could not find a usable */
/* WinSock DLL. */
protected:
static unsigned int __stdcall AcceptThread(void * lpParam);
unsigned int AcceptThreadProc();
private:
SOCKET m_hListenSocket;
int err;
m_hListenSocket = socket(AF_INET, SOCK_STREAM, 0);
if( INVALID_SOCKET == m_hListenSocket )
{
err = WSAGetLastError();
WSACleanup( );
return FALSE;
}
return TRUE;
};
BOOL ClearSocket()
{
WSACleanup( );
return TRUE;
{
if( m_hListenSocket != INVALID_SOCKET )
{
return 0;
}
InitSocket();
m_pEventHandler = phEvent;
struct sockaddr_in serverAddress;
nWaitCounts,
hWaitAll,
FALSE,
INFINITE,
TRUE );
if( wt == WAIT_OBJECT_0 )
{
return err;
}
memset(&serverAddress, 0, sizeof(serverAddress));
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = 0;
{
continue;
{
/* Tell the user that we could not find a usable */
/* WinSock DLL.
*/
return FALSE;
}
#include <winsock2.h>
#include <process.h>
#pragma comment(lib,"ws2_32.lib")
#pragma once
class CAsyncHandler
{
public:
CAsyncHandler()
{
}
return err;
}
err = listen( m_hListenSocket, SOMAXCONN );
if( err == SOCKET_ERROR )
{
err = WSAGetLastError();
closesocket( m_hListenSocket );
//退出线程
break;
}
DWORD index = wt - WSA_WAIT_EVENT_0;
if( index == 1 )
{
int nResult = WSAEnumNetworkEvents(
/* 2.2 in wVersion since that is the version we */
/* requested. */
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HANDLE m_hIOThread;
HANDLE m_hExitThread;
CAsyncHandler *m_pEventHandler;
private:
int OnAccept();
BOOL InitSocket()
{
WORD wVersionRequested;
{
if( INVALID_SOCKET == m_hListenSocket )
{
return 0;
}
closesocket( m_hListenSocket );
m_hListenSocket = INVALID_SOCKET;
);
if( err == SOCKET_ERROR )
{
err = WSAGetLastError();
closesocket( m_hListenSocket );
m_hListenSocket = INVALID_SOCKET;
virtual ~CAsyncHandler()
{
}
virtual int AcceptNotify( SOCKET hSocket, const char *strClientIP, unsigned short usClientPort )= 0;
};
class CAsynch_Event_Handler
m_hListenSocket = INVALID_SOCKET;
return err;
}
m_hExitThread = CreateEvent( NULL, TRUE, FALSE, NULL );
m_hIOThread = (HANDLE)
{
m_hListenSocket = INVALID_SOCKET;
}
CAsynch_Event_Handler::~CAsynch_Event_Handler(void)
{
}
int CAsynch_Event_Handler::Start(CAsyncHandler * phEvent, UINT unPort)
if( Events.lNetworkEvents & FD_ACCEPT )
{
if( SOCKET_ERROR == Events.iErrorCode[FD_ACCEPT_BIT] )
serverAddress.sin_port = htons( unPort );
err = bind(m_hListenSocket,
(struct sockaddr *)&serverAddress,
sizeof(serverAddress)
{
public:
CAsynch_Event_Handler(void);
~CAsynch_Event_Handler(void);
int Start(CAsyncHandler * phEvent, UINT unPort);
int Stop(void);
CloseHandle( m_hExitThread );
CloseHandle( m_hIOThread );
ClearSocket();