// TCPSocket.cpp: implementation of the CTCPSocket class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "TCPNetKit.h"
#include "TCPSocket.h"

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

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

CTCPSocket::CTCPSocket(int nType)
{
	m_nType=nType;
	m_sSocket=NULL;
	m_bAvailable=Initwinsock();
	m_bCreated=FALSE;
	m_bAuto=FALSE;
	m_dwUserData=0;
	error=0;

	m_nPort=-1;
	m_hServerThread=NULL;
	for(int i=0;i<MAX_CONNECTION;i++)
	{
		m_hServerDataThread[i]=NULL;
		m_sServer[i]=NULL;
		ZeroMemory(m_cIp[i],16);
		m_bConnected[i]=FALSE;
	}
	m_nConnections=0;
	m_nCurrent=0;
	m_lpServerStatusProc=NULL;
	m_lpServerDataArriveProc=NULL;

	m_hClientThread=NULL;
	m_lpClientDataArriveProc=NULL;
	m_lpClientStatusProc=NULL;
}

CTCPSocket::~CTCPSocket()
{
	Close();
}

int CTCPSocket::GetError()
{
	return error;
}

SOCKET CTCPSocket::GetSocket()
{
	return m_sSocket;
}

int CTCPSocket::GetType()
{
	return m_nType;
}

BOOL CTCPSocket::IsConnected(SOCKET s)
{
	int nRet=0;
	struct fd_set Fd_Recv;
	struct timeval Time_Recv;

	memset(&Fd_Recv,0,sizeof(struct fd_set));
	FD_CLR(s,&Fd_Recv);
	FD_SET(s,&Fd_Recv);
	Time_Recv.tv_sec=0;
	Time_Recv.tv_usec=0;

	nRet=select(s,&Fd_Recv,NULL,NULL,&Time_Recv);

	return (nRet==0);
}

BOOL CTCPSocket::CreateServer(int nPort,int backlog)
{
	m_bAvailable=Initwinsock();
	if(!m_bAvailable)
	{
		return FALSE;
	}
	if(m_nType!=TCP_SOCKET_SERVER)
	{
		return FALSE;
	}
	if(m_bCreated)
	{
		return FALSE;
	}

	struct sockaddr_in local;

	m_sSocket=socket(AF_INET,SOCK_STREAM,IPPROTO_IP);
	if(m_sSocket==SOCKET_ERROR)
	{
		error=WSAGetLastError();
		return FALSE;
	}

	local.sin_addr.s_addr=htonl(INADDR_ANY);
	local.sin_family=AF_INET;
	local.sin_port=htons(nPort);

	if(bind(m_sSocket,(struct sockaddr*)&local,sizeof(local))==SOCKET_ERROR)
	{
		error=WSAGetLastError();
		closesocket(m_sSocket);
		return FALSE;
	}

	if(listen(m_sSocket,backlog)!=0)
	{
		error=WSAGetLastError();
		closesocket(m_sSocket);
		return FALSE;
	}

	m_nPort=nPort;
	m_bCreated=TRUE;

	return TRUE;
}

BOOL CTCPSocket::StartServer(LPStatusProc proc1,LPDataArriveProc proc2,DWORD userdata)
{
	if(!m_bAvailable)
	{
		return FALSE;
	}
	if(m_nType!=TCP_SOCKET_SERVER)
	{
		return FALSE;
	}
	if(!m_bCreated)
	{
		return FALSE;
	}
	if(m_bAuto)
	{
		return FALSE;
	}

	m_lpServerStatusProc=proc1;
	m_lpServerDataArriveProc=proc2;
	m_dwUserData=userdata;

	DWORD dwThreadId;

	m_bAuto=TRUE;
	m_hServerThread=CreateThread(NULL,0,ServerThread,this,0,&dwThreadId);

	if(m_hServerThread==NULL)
	{
		m_bAuto=FALSE;
		error=WSAGetLastError();
		return FALSE;
	}
	
	return TRUE;
}

BOOL CTCPSocket::StopServer()
{
	if(!m_bAvailable)
	{
		return FALSE;
	}
	if(m_nType!=TCP_SOCKET_SERVER)
	{
		return FALSE;
	}
	if(!m_bCreated)
	{
		return FALSE;
	}
	if(!m_bAuto)
	{
		return FALSE;
	}

	DWORD exitcode;
	m_bAuto=FALSE;
	//停止監聽線程
	WaitForSingleObject(m_hServerThread,500);
	if(!GetExitCodeThread(m_hServerThread,&exitcode))
	{
		TerminateThread(m_hServerThread,exitcode);
	}
	CloseHandle(m_hServerThread);
	m_hServerThread=NULL;
	shutdown(m_sSocket,SD_RECEIVE);
	closesocket(m_sSocket);
	m_sSocket=NULL;

	//停止所有收發數據線程
	int i;
		
	for(i=0;i<MAX_CONNECTION;i++)
	{
		if(m_bConnected[i])
		{
			m_bConnected[i]=FALSE;
			WaitForSingleObject(m_hServerDataThread[i],50);
			if(!GetExitCodeThread(m_hServerDataThread[i],&exitcode))
			{
				TerminateThread(m_hServerDataThread[i],exitcode);
			}
			shutdown(m_sServer[i],SD_RECEIVE);
			closesocket(m_sServer[i]);
			m_sServer[i]=NULL;
			CloseHandle(m_hServerDataThread[i]);
			m_hServerDataThread[i]=NULL;
		}
	}
	m_nConnections=0;
	
	return TRUE;
}

SOCKET CTCPSocket::Listen(char* ClientIP)
{
	if(!m_bAvailable)
	{
		return -1;
	}
	if(m_nType!=TCP_SOCKET_SERVER)
	{
		return -1;
	}
	if(!m_bCreated)
	{
		return -1;
	}

	SOCKET sClient;
	int iAddrSize;
	struct sockaddr_in addr;

	iAddrSize=sizeof(addr);

	sClient=accept(m_sSocket,(struct sockaddr*)&addr,&iAddrSize);

	if(sClient==SOCKET_ERROR)
	{
		error=WSAGetLastError();
		closesocket(sClient);
		return SOCKET_ERROR;
	}

	if(ClientIP!=NULL)
	{
		sprintf(ClientIP,"%3d.%3d.%3d.%3d",addr.sin_addr.S_un.S_un_b.s_b1,addr.sin_addr.S_un.S_un_b.s_b2,addr.sin_addr.S_un.S_un_b.s_b3,addr.sin_addr.S_un.S_un_b.s_b4);
	}

	return sClient;
}

int CTCPSocket::ReceiveServer(int nNo,char* data,int length,int timeout)
{
	if(!m_bConnected[nNo])
	{
		return -2;
	}

	HANDLE hThread;
	DWORD dwThreadId;

	TimeOutParameter TimeOut;

	TimeOut.bExit=FALSE;
	TimeOut.bFinished=FALSE;
	TimeOut.EndTime=timeout;
	TimeOut.nNo=nNo;
	TimeOut.pbConnected=&(m_bConnected[nNo]);
	TimeOut.phDataThread=&(m_hServerDataThread[nNo]);
	TimeOut.pnConnections=&m_nConnections;
	TimeOut.s=m_sServer[nNo];

	hThread=CreateThread(NULL,0,TimeOutControl,(LPVOID)&TimeOut,0,&dwThreadId);

	if(hThread==NULL)
	{
		return -3;
	}

	int nRet=recv(m_sServer[nNo],data,length,0);
	if(nRet==SOCKET_ERROR)
	{
		error=WSAGetLastError();
	}
	TimeOut.bFinished=TRUE;

	while(!TimeOut.bExit)
	{
		Sleep(1);
	}

	return nRet;
}

int CTCPSocket::SendServer(int nNo,char *data,int length)
{
	if(!m_bConnected[nNo])
	{
		return -2;
	}

	int nRet=send(m_sServer[nNo],data,length,0);
	if(nRet==SOCKET_ERROR)
	{
		error=WSAGetLastError();
	}

	return nRet;
}

void CTCPSocket::Disconnect(int nNo)
{
	if(!m_bConnected[nNo])
	{
		return;
	}

	//斷開服務器上第nNo個連接
	DWORD exitcode;
	m_bConnected[nNo]=FALSE;
	WaitForSingleObject(m_hServerDataThread[nNo],50);
	if(!GetExitCodeThread(m_hServerDataThread[nNo],&exitcode))
	{
		TerminateThread(m_hServerDataThread[nNo],exitcode);
	}
	shutdown(m_sServer[nNo],SD_RECEIVE);
	closesocket(m_sServer[nNo]);
	m_sServer[nNo]=NULL;
	CloseHandle(m_hServerDataThread[nNo]);
	m_hServerDataThread[nNo]=NULL;
	m_nConnections--;

}

BOOL CTCPSocket::Connect(LPCTSTR pstrHost,int nPort)
{
	m_bAvailable=Initwinsock();
	if(!m_bAvailable)
	{
		return FALSE;
	}
	if(m_nType==TCP_SOCKET_SERVER)
	{
		return FALSE;
	}
	if(m_bCreated)
	{
		return FALSE;
	}

	LPHOSTENT lpHost;
	struct sockaddr_in server;

	//查找主機
	lpHost=gethostbyname(pstrHost);
	if(lpHost==NULL)
	{
		return FALSE;
	}

	server.sin_family=AF_INET;
	server.sin_addr.s_addr=*((u_long FAR*)(lpHost->h_addr));
	server.sin_port=htons(nPort);

	m_sSocket=socket(AF_INET,SOCK_STREAM,0);

	if(m_sSocket<=0)
	{
		error=WSAGetLastError();
		return FALSE;
	}
	
	if(connect(m_sSocket,(LPSOCKADDR)&server,sizeof(SOCKADDR))==SOCKET_ERROR) 
	{
		error=WSAGetLastError();
		closesocket(m_sSocket);
		m_sSocket=NULL;
		return FALSE;
	}

	m_bCreated=TRUE;

	return TRUE;
}

BOOL CTCPSocket::StartReceiving(LPStatusProc proc1,LPDataArriveProc proc2,DWORD userdata)
{
	if(!m_bAvailable)
	{
		return FALSE;
	}
	if(m_nType==TCP_SOCKET_SERVER)
	{
		return FALSE;
	}
	if(!m_bCreated)
	{
		return FALSE;
	}
	if(m_bAuto)
	{
		return FALSE;
	}

	//開始自動接收
	m_lpClientStatusProc=proc1;
	m_lpClientDataArriveProc=proc2;
	m_dwUserData=userdata;
	m_bAuto=TRUE;

	DWORD dwThreadId;

	m_hServerThread=CreateThread(NULL,0,ClientThread,this,0,&dwThreadId);

	if(m_hServerThread==NULL)
	{
		m_bAuto=FALSE;
		error=WSAGetLastError();
		return FALSE;
	}
	
	return TRUE;
}

BOOL CTCPSocket::StopReceiving()
{
	if(!m_bAvailable)
	{
		return FALSE;
	}
	if(m_nType==TCP_SOCKET_SERVER)
	{
		return FALSE;