cudpmanager.cpp

陆其明的实务精选中附带光盘中的视频聊天源代码

//
// CUDPManager.cpp
// 

/*-----------------------------------------------------*\
			HQ Tech, Make Technology Easy!       
 More information, please go to http://hqtech.nease.net.
/*-----------------------------------------------------*/

#include "stdafx.h"
#include "CUDPManager.h"
#include "UNetwork.h"
#include "GlobalDefs.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
CUDPManager::CUDPManager()
{
	mSckReceiver = INVALID_SOCKET;
	mSckSender   = INVALID_SOCKET;
	mTargetIP    = 0x7f000001; // 127.0.0.1
	mTargetPort  = 10080;
	mLocalPort   = 10080;

	mIsReceiving = FALSE;
	mRcvThread   = NULL;
}

CUDPManager::~CUDPManager()
{
	DeleteSender();
	DeleteReceiver();
	StopReceiving();
}

void CUDPManager::SetTargetIP(DWORD inIP)
{
	mTargetIP = inIP;
}

DWORD CUDPManager::GetTargetIP(void)
{
	return mTargetIP;
}

void CUDPManager::SetTargetIP(const char * inIP)
{
	mTargetIP = ntohl(inet_addr(inIP));
}

void CUDPManager::GetTargetIP(char * outIP)
{
	if (outIP)
	{
		struct in_addr   in;
		in.S_un.S_addr = htonl(mTargetIP);
		char * pStr = inet_ntoa(in);
		strcpy(outIP, pStr);
	}
}

void CUDPManager::SetTargetPort(WORD inPort)
{
	mTargetPort = inPort;
}

WORD CUDPManager::GetTargetPort(void)
{
	return mTargetPort;
}

void CUDPManager::SetLocalPort(WORD inPort)
{
	mLocalPort = inPort;
}

WORD CUDPManager::GetLocalPort(void)
{
	return mLocalPort;
}

BOOL CUDPManager::CreateSender(void)
{
	DeleteSender();

	mSckSender = socket(AF_INET, SOCK_DGRAM, 0);
	if (mSckSender != INVALID_SOCKET)
	{
		return TRUE;
	}
	return FALSE;
}

void CUDPManager::DeleteSender(void)
{
	if (mSckSender != INVALID_SOCKET)
	{
		closesocket(mSckSender);
		mSckSender = INVALID_SOCKET;
	}
}

BOOL CUDPManager::CreateReceiver(void)
{
	DeleteReceiver();

	mSckReceiver = socket(AF_INET, SOCK_DGRAM, 0);
	if (mSckReceiver != INVALID_SOCKET)
	{
		BOOL flag = TRUE;
		int ret = setsockopt(mSckReceiver, SOL_SOCKET, SO_REUSEADDR, 
			(char *) &flag, sizeof(flag));
		if (ret == SOCKET_ERROR) 
		{
			DeleteReceiver();
			return FALSE;
		}

		SOCKADDR_IN  addr;
		addr.sin_family      = AF_INET;
		addr.sin_addr.s_addr = htonl(INADDR_ANY);
		addr.sin_port        = htons(mLocalPort);
		ret = bind(mSckReceiver, (struct sockaddr*) &addr, sizeof(addr));
		if (ret == SOCKET_ERROR) 
		{
			DeleteReceiver();
			return FALSE;
		}
		return TRUE;
	}

	return FALSE;
}

void CUDPManager::DeleteReceiver(void)
{
	if (mSckReceiver != INVALID_SOCKET)
	{
		closesocket(mSckReceiver);
		mSckReceiver = INVALID_SOCKET;
	}
}

// Sending methods
BOOL CUDPManager::Send(const char * inBuffer, long inLength)
{
	SOCKADDR_IN  addr;
	memset((char *) &addr, 0, sizeof(addr));  
	addr.sin_family      = AF_INET;
	addr.sin_addr.s_addr = htonl(mTargetIP);
	addr.sin_port        = htons(mTargetPort);

	int val = sendto(mSckSender, inBuffer, inLength, 0, 
		(sockaddr *) &addr, sizeof(addr));
	return (val != SOCKET_ERROR);
}

BOOL CUDPManager::SendTo(const char * inBuffer, long inLength, 
						 DWORD inIP, WORD inPort)
{
	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
	if (sock != INVALID_SOCKET)
	{
		SOCKADDR_IN  addr;
		memset((char *) &addr, 0, sizeof(addr));  
		addr.sin_family      = AF_INET;
		addr.sin_addr.s_addr = htonl(inIP);
		addr.sin_port        = htons(inPort);

		int val = sendto(sock, inBuffer, inLength, 0, 
			(sockaddr *) &addr, sizeof(addr));
		if (val == SOCKET_ERROR)
		{
#ifdef _DEBUG
			UNetwork::DumpSocketError();
#endif
		}
		closesocket(sock);
		return (val != SOCKET_ERROR);
	}
	return FALSE;
}

// Receiving methods
BOOL CUDPManager::StartReceiving(void)
{
	// Create socket if necessary
	if (mSckReceiver == INVALID_SOCKET)
	{
		CreateReceiver();
	}

	if (mSckReceiver != INVALID_SOCKET)
	{
		if (mIsReceiving)
		{
			return TRUE;
		}
		
		DWORD threadID = 0;
		mRcvThread = CreateThread(NULL, 0, ReceivingThrd, 
			this, 0, &threadID);
		return (mRcvThread != NULL);
	}
	return FALSE;
}

void CUDPManager::StopReceiving(void)
{
	if (mIsReceiving)
	{
		DeleteReceiver();
		// Make sure the receiving thread has been terminated 
		if (mRcvThread != NULL) 
		{
            WaitForSingleObject(mRcvThread, INFINITE);
			mRcvThread = NULL;
		}
	}
}

DWORD WINAPI CUDPManager::ReceivingThrd(void * pParam)
{
	ASSERT(pParam);
	CUDPManager * pController = (CUDPManager*) pParam;
	pController->ReceivingLoop();
	return 0;
}

void CUDPManager::ReceivingLoop(void)
{
	// Init COM server!
//	CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);

	struct sockaddr_in  addr_cli;
	int  addr_cli_len = sizeof(addr_cli);
	char buffer[MAX_COMMAND_SIZE];
	long bytes = 0;

	mIsReceiving = TRUE;
	while (mIsReceiving)
	{				
		int addr_cli_len = sizeof(addr_cli);
		bytes = recvfrom(mSckReceiver, (char *)buffer, MAX_COMMAND_SIZE, 0,
			(LPSOCKADDR) &addr_cli, (int *) &addr_cli_len);
		if (bytes == SOCKET_ERROR || bytes == 0)
		{
			mIsReceiving = FALSE;
		}
		else
		{
			char *  pStr  = inet_ntoa(addr_cli.sin_addr);
		//	DWORD peerIP  = ntohl(inet_addr(pStr));
			// Notify the controller
			Broadcast(msg_UDPCommandReceived, buffer, pStr);
		}
	}

//	CoUninitialize();
}