// 
// CStreamSocket.cpp
// 

#include "stdafx.h"
#include <streams.h>
#include "CClientSocket.h"
#include "GlobalDefs.h"

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

//////////////////////////////////////////////////////////////////////////////
CClientSocket::CClientSocket()
{
	mSocket      = INVALID_SOCKET;
	mIsConnected = FALSE;

	mIsReceiving = FALSE;

	mRcvThread   = NULL;

}

CClientSocket::~CClientSocket()
{
	Detach();
	StopReceiving();
}
void CClientSocket::Detach(void)
{
	if (mSocket != INVALID_SOCKET)
	{
		closesocket(mSocket);
		mSocket = INVALID_SOCKET;
		mIsConnected = FALSE;
	}
}

SOCKET CClientSocket::GetSocket(void)
{
	return mSocket;	
}

BOOL CClientSocket::ConnectTo(DWORD inTargetIP, WORD inPort)
{


	mSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (mSocket != INVALID_SOCKET)
	{
		BOOL sopt = TRUE;
		setsockopt(mSocket, IPPROTO_TCP, TCP_NODELAY, 
			(char *)&sopt, sizeof(BOOL));
		setsockopt(mSocket, SOL_SOCKET, SO_DONTLINGER, 
			(char *)&sopt, sizeof(BOOL));

		SOCKADDR_IN   saddr;
		memset(&saddr, 0, sizeof(SOCKADDR_IN));
		saddr.sin_addr.S_un.S_addr = htonl(inTargetIP);
		saddr.sin_family           = AF_INET;
		saddr.sin_port             = htons((WORD)inPort);
		if (connect(mSocket, (SOCKADDR *)&saddr, sizeof(SOCKADDR_IN)) != 0) 
		{
			Detach();
			return FALSE;
		}
		mIsConnected = TRUE;
		return TRUE;
	}
	return FALSE;
}

BOOL CClientSocket::StartReceiving(void)
{
	if (mSocket != INVALID_SOCKET)
	{
		if (mIsReceiving)
		{
			return TRUE;
		}

		DWORD threadID = 0;
		mRcvThread = CreateThread(NULL, 0, ReceivingThrd, 
			this, 0, &threadID);
		return (mRcvThread != NULL);
	}
	return FALSE;
}

void CClientSocket::StopReceiving(void)
{
	if (mIsReceiving)
	{
		Detach();
		if (mRcvThread != NULL) 
		{
            WaitForSingleObject(mRcvThread, INFINITE);
			mRcvThread = NULL;
		}
	}
}

DWORD WINAPI CClientSocket::ReceivingThrd(void * pParam)
{
	CClientSocket * pSock = (CClientSocket *) pParam;
	if (pSock)
	{
		pSock->mIsReceiving = TRUE;
		pSock->ReceivingLoop();
		return 1;
	}	
	return 0;
}
void CClientSocket::ReceivingLoop(void)
{
	char buffer[MAX_COMMAND_SIZE];
	long bytes = 0;
	
	mIsReceiving = TRUE;
	while (mIsReceiving)
	{				
		bytes = recv(mSocket, (char *)buffer, MAX_COMMAND_SIZE, 0);
		if (bytes == SOCKET_ERROR || bytes == 0)
		{
			mIsReceiving = FALSE;
		}
		else
		{
			Broadcast(msg_CommandReceived, buffer);
		}
	}

}
BOOL CClientSocket::Send(const char * inBuffer, long inLength)
{
	if(mSocket)
	{

		int val = send(mSocket, inBuffer, inLength, 0);
		return (val != SOCKET_ERROR);
	}
	else
	{
		return FALSE;
	}
}

void CClientSocket::SetSocket(SOCKET inSocket)
{
	mSocket=inSocket;
	mIsConnected=TRUE;
}