asyncsocket.cpp

一个可订制ip packet的程序

// AsyncSocket.cpp: implementation of the CAsyncSocket class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "AsyncSocket.h"
#include "SocketThreadManager.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

//Static members
//##ModelId=3B43E6F5021E
BOOL CAsyncSocket::m_Window=FALSE;
//##ModelId=3B43E6F50232
HWND CAsyncSocket::m_WindowHandle=0;
//##ModelId=3B43E6F50246
HINSTANCE CAsyncSocket::m_Instance=0;
//##ModelId=3B43E6F50264
BOOL CAsyncSocket::m_Initialized=0;
//##ModelId=3B43E6F5020B
CAsyncSocket::SocketMap CAsyncSocket::m_SocketMap;
//##ModelId=3B43E6F502D3
CSocketThreadManager* CAsyncSocket::m_pThreadManager=NULL;
//##ModelId=3B43E6F502B4
BOOL CAsyncSocket::m_bShuttingDown=FALSE;

//##ModelId=3B43E6F5010F
CAsyncSocket::CAsyncSocket() : CSpoofBase()
{
	try
	{
		//Initialize memebers
		m_List=FALSE;
		m_Timeout=FALSE;

		//No local controller
		m_pLocalThreadManager=NULL;

		//And no window handle
		m_hLocalWindowHandle=0;

		//Initialize all data
		Initialize();
	}
	ERROR_HANDLER("CAsyncSocket")
}

//##ModelId=3B43E6F50119
CAsyncSocket::~CAsyncSocket()
{
	try
	{
		if (GetThreadManager())
			//Remove from the thread manager
			GetThreadManager()->DecreaseSocketCount(GetWindowHandle());

	}
	ERROR_HANDLER("~CAsyncSocket")
}

//##ModelId=3B43E6F501D9
BOOL CAsyncSocket::SetHandlers()
{
	try
	{
		//First create the window class
		if (!m_Window)
			if (!RegisterWindow())
			{
				//Error
				ReportStaticError(CAsyncSocket_Class,"SetHandlers","Error registering the window, please check API error!");
				return FALSE;
			}
			else
				//Check if we need to register a local window, or a thread manager ?
				if (CSpoofBase::IsMultiThreaded())
					//Initialize as multithreaded
					m_pThreadManager=new CSocketThreadManager(CSpoofBase::GetNumberOfThreads(),m_Instance);
				else
				{
					//Run on main thread
					m_WindowHandle=CreateWindowEx(0,CAsyncSocket_Class,SOCKET_WINDOW_NAME,
												  WS_OVERLAPPED,0,0,0,0,0,NULL,GetInstance(),NULL);
					//Check the value of the window
					if (!m_WindowHandle)
					{
						//Error
						ReportStaticError(CAsyncSocket_Class,"SetHandlers","Error creating the window, please check API error!");
						return FALSE;
					}
					else
						//We have a window
						m_Window=TRUE;
				}

		//Created !!
		//Success
		return TRUE;
	}
	ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"CAsyncSocket",FALSE)
}

//##ModelId=3B43E6F501CE
HINSTANCE CAsyncSocket::GetInstance()
{
	//Returns the instance of the application, must be overided
	return m_Instance;
}

//##ModelId=3B43E6F5019C
void CAsyncSocket::AddSocketToList()
{
	try
	{
		//Allocate our window
		AllocateHandle();

		//Add socket to list
		m_SocketID=GetAsyncHandle();
		m_SocketMap.insert(SocketMap::value_type(m_SocketID,this));

		m_List=TRUE;
	}
	ERROR_HANDLER("AddSocketToList")
}

//##ModelId=3B43E6F50174
int CAsyncSocket::GetSocketID()
{
	return m_SocketID;
}

//##ModelId=3B43E6F501F6
CAsyncSocket* CAsyncSocket::GetSocketByID(int iSockID)
{
	try
	{
		//Find the socket
		SocketMap::iterator aTheIterator;
		aTheIterator=m_SocketMap.find(iSockID);

		//Check if we have it
		if (aTheIterator!=m_SocketMap.end())
			return aTheIterator->second;
		else
			return NULL;
	}
	ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"GetSocketByID",NULL)
}

//##ModelId=3B43E6F501EC
BOOL CAsyncSocket::RegisterWindow()
{
	try
	{
		WNDCLASS wc;

		/* Fill in window class structure with parameters that describe the       */
		/* main window.                                                           */

		wc.style = 0;										  /* Class style(s).                    */
		wc.lpfnWndProc = (WNDPROC)SocketMessageHandler;       /* Function to retrieve messages for  */
											/* windows of this class.             */
		wc.cbClsExtra = 0;                  /* No per-class extra data.           */
		wc.cbWndExtra = 0;                  /* No per-window extra data.          */
		wc.hIcon = NULL;				    /* Icon name from .RC        */
		wc.hInstance = GetInstance();          /* Application that owns the class.   */
		wc.hCursor = NULL;
		wc.hbrBackground = NULL;
		wc.lpszMenuName =  NULL;   /* Name of menu resource in .RC file. */
		wc.lpszClassName = CAsyncSocket_Class ; /* Name used in call to CreateWindow. */

		/* Register the window class and return success/failure code. */

		return (RegisterClass(&wc));
	}
	ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"RegisterWindow",FALSE)
}

//##ModelId=3B43E6F50105
void CAsyncSocket::SetInstance(HINSTANCE hInst)
{
	m_Instance=hInst;
}

//##ModelId=3B43E6F501C4
BOOL CAsyncSocket::RemoveHandlers()
{
	try
	{
		//First shut down the windows
		if (m_Window)
		{
			if (!DestroyWindow(m_WindowHandle))
				return FALSE;

			if (!UnregisterClass(CAsyncSocket_Class,GetInstance()))
				return FALSE;
		}

		m_Window=FALSE;
		m_WindowHandle=NULL;

		return TRUE;
	}
	ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"RemoveHandlers",FALSE)
}

//##ModelId=3B43E6F5017E
HWND CAsyncSocket::GetWindowHandle()
{
	//Check if we are multithreaded ?
	return m_hLocalWindowHandle;
}

//##ModelId=3B43E6F50194
void CAsyncSocket::RemoveSocketFromList()
{
	try
	{
		if (m_List)
			m_SocketMap.erase(GetSocketID());
	}
	ERROR_HANDLER("RemoveSocketFromList")
}

//##ModelId=3B43E6F500FB
BOOL CAsyncSocket::SetTimeout(int iMs)
{
	try
	{
		if (!GetWindowHandle() || m_Timeout)
			return FALSE;

		//Set the timer
		m_Timeout=SetTimer(GetWindowHandle(),GetAsyncHandle(),iMs,NULL);

		return m_Timeout;
	}
	ERROR_HANDLER_RETURN("SetTimeout",FALSE)
}

//##ModelId=3B43E6F500F1
BOOL CAsyncSocket::KillTimer()
{
	try
	{
		if (!GetWindowHandle() || !m_Timeout)
			return FALSE;

		m_Timeout=!::KillTimer(GetWindowHandle(),GetAsyncHandle());

		return !m_Timeout;
	}
	ERROR_HANDLER_RETURN("KillTimer",FALSE)
}

//##ModelId=3B43E6F500E8
void CAsyncSocket::Shutdown()
{
	try
	{
		//Indicate we're shutting down
		m_bShuttingDown=TRUE;

		//Clear the map
		SocketMap::iterator aTheIterator;
		aTheIterator=m_SocketMap.begin();

		//While not end of the map
		while (aTheIterator!=m_SocketMap.end())
		{
			//Delete the socket
			delete aTheIterator->second;

			//Go to the next socket
			++aTheIterator;
		}

		//Wait for clean up
		Sleep(1000);

		//Delete the thread manager
		if (m_pThreadManager)
			delete m_pThreadManager;

		//Remove the handlers
		RemoveHandlers();
	

	}
	ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Shutdown")
}

//##ModelId=3B43E6F5037D
CAsyncSocket::CAsyncShutdown::CAsyncShutdown() : CSpoofBase()
{
	try
	{
		//Register myself
		SetName(CAsyncShutdown_Class);

		//Register for shutdown
		RegisterShutdown(this);
	}
	ERROR_HANDLER("CAsyncShutdown")
}

//##ModelId=3B43E6F50386
CAsyncSocket::CAsyncShutdown::~CAsyncShutdown()
{
}

//##ModelId=3B43E6F50388
void CAsyncSocket::CAsyncShutdown::NotifyShutdown()
{
	try
	{
		//Socket shutdown!
		CAsyncSocket::Shutdown();
	}
	ERROR_HANDLER("NotifyShutdown")
}

//##ModelId=3B43E6F501A6
BOOL CAsyncSocket::IsTimeout()
{
	return m_Timeout;
}

//##ModelId=3B43E6F500DE
void CAsyncSocket::Initialize()
{
	try
	{
		//Initialize all data
		if (!m_Initialized)
		{
			//Create handlers
			if (!SetHandlers())
				ReportStaticError(CAsyncSocket_Class,"CAsyncSocket","Failed to init handlers!");

			//Create a new socket to do the shutdown
			CAsyncShutdown* pShutdown;
			pShutdown=new CAsyncShutdown;

			//The class registers itself
			m_Initialized=TRUE;
		}
	}
	ERROR_HANDLER_STATIC(CAsyncSocket_Class,"Initialize")
}

//Message handler
//##ModelId=3B43E6F50304
LRESULT CALLBACK CAsyncSocket::SocketMessageHandler(HWND hwnd,      // handle to window
							  					    UINT uMsg,      // message identifier
												    WPARAM wParam,  // first message parameter
												    LPARAM lParam)   // second message parameter													
{
	if (m_bShuttingDown)
		return TRUE;

	try
	{
		//first get the socket
		CAsyncSocket* cSock;

		cSock=GetSocketByID((int)wParam);

		if (cSock)
			//Socket exists
			switch (uMsg)
			{
			case WM_SOCKET_GENERAL:
				if (WSAGETSELECTEVENT(lParam) == FD_READ)
					return cSock->OnSocketReceive(WSAGETSELECTERROR(lParam));
				else if (WSAGETSELECTEVENT(lParam) == FD_WRITE)
					return cSock->OnSocketWrite(WSAGETSELECTERROR(lParam));
				else if (WSAGETSELECTEVENT(lParam) == FD_OOB)
					return cSock->OnSocketOOB(WSAGETSELECTERROR(lParam));
				else if (WSAGETSELECTEVENT(lParam) == FD_CLOSE)
					return cSock->OnSocketClose(WSAGETSELECTERROR(lParam));
				break;
			case WM_SOCKET_CONNECT:
				if (WSAGETSELECTEVENT(lParam) == FD_CONNECT)
					return cSock->OnSocketConnect(WSAGETSELECTERROR(lParam));
				break;
			case WM_SOCKET_ACCEPT:
				if (WSAGETSELECTEVENT(lParam) == FD_ACCEPT)
					return cSock->OnSocketAccept(WSAGETSELECTERROR(lParam));
				break;
			case WM_TIMER:
				//Inform the socket
				return cSock->OnSocketTimeout();
			default:                       /* Passes it on if unproccessed    */
				return (int)(DefWindowProc(hwnd, uMsg, wParam, lParam));
			}
		else
			return (int)(DefWindowProc(hwnd, uMsg, wParam, lParam));

		return TRUE;
	}
	ERROR_HANDLER_STATIC_RETURN(CAsyncSocket_Class,"SocketMessageHandler",TRUE)
}

//##ModelId=3B43E6F501BB
CSocketThreadManager* CAsyncSocket::GetThreadManager()
{
	if (!m_pLocalThreadManager)
		return m_pThreadManager;
	else
		return m_pLocalThreadManager;
}

//##ModelId=3B43E6F501BA
void CAsyncSocket::AllocateHandle()
{
	try
	{
		if (GetThreadManager())
			//We are
			m_hLocalWindowHandle=GetThreadManager()->GetWindowHandle();
		else
			//Single threaded
			m_hLocalWindowHandle=m_WindowHandle;	
	}
	ERROR_HANDLER("AllocateHandle")
}

//##ModelId=3B43E6F501B0
void CAsyncSocket::DeAllocateHandle()
{

}