#include "StdAfx.h"
#include "IClientImpl.h"
#include <comdef.h>
#include <atlbase.h>
#include "crc32.h"
#include "ThreadPool.hpp"
#include "lzari.h"


const int AF_IPV4   = 0;
const int AF_IPV6   = 1;
const int SOCK_TCP  = SOCK_STREAM-1;
const int SOCK_UDP  = SOCK_DGRAM-1;

//DWORD	g_dwLeng = 0;
//BYTE	*g_pData = NULL;

DWORD	g_dwLeng2 = 0;
BYTE	*g_pData2 = NULL;

DWORD	g_dwcount;

BOOL g_bConnLYFZ = 0;

int g_conntype = 0;//正常


void IClientImpl::DataToArray(IN BYTE *pData, IN CONST DWORD &dwLength, IN CArray<CStringArray, CStringArray>*List1array)
{
	List1array->RemoveAll();
	if (dwLength == 0)return;
	if (m_tSendhead.code[0])
	{
		BYTE *lpszOut = NULL;
		int nOutSize = 0;
		LZARI Lzari;
		Lzari.UnCompress(pData, dwLength, (const BYTE*&)lpszOut, nOutSize);
		CMemFile memfile;
		memfile.Attach(lpszOut, nOutSize);
		Lzari.Release();

		try
		{
			CArchive ar(&memfile, CArchive::load);
			List1array->SetSize(m_tSendhead.count[0]);
			for (int i = 0; i < List1array->GetSize(); i++)
			{
				List1array->ElementAt(i).Serialize(ar);
			}
			ar.Close();
			memfile.Detach();
		}
		catch (CException* e)
		{
			e->ReportError();
		}
	}
	else
	{
		CMemFile memfile;
		memfile.Attach(pData, dwLength);
		CArchive ar(&memfile, CArchive::load);
		List1array->SetSize(m_tSendhead.count[0]);
		for (int ii = 0; ii < List1array->GetSize(); ii++)
		{
			List1array->ElementAt(ii).Serialize(ar);
		}
		ar.Close();
		memfile.Detach();
	}
}

//IClientImpl* IClientImpl::m_pTcpClient[TCPCLIENTNUM] = {NULL};
void GetFileName(IN const TCHAR *pFullName,OUT TCHAR *pFileName)
{
	TCHAR szExt[_MAX_EXT];
	_tsplitpath(pFullName, NULL, NULL, pFileName, szExt);
	_tcscat(pFileName, szExt);
}

unsigned int VerifyIntegrityPacket(IN void *pIntegrityPacket,IN unsigned int nPacketSize)
{
	unsigned int checksum = 0;
	//if ( nPacketSize <= sizeof(STProtocolheader) )
	//{
	//	return 0;
	//}
	unsigned char *pBody = &((unsigned char*)pIntegrityPacket)[sizeof(STProtocolheader)];

	if( pBody )
		checksum = crc32( 0, pBody, nPacketSize-sizeof(STProtocolheader) );

	return checksum;
}

IClientImpl::IClientImpl():m_nMode(AF_IPV4),m_nSockType(SOCK_TCP) 
{
	m_bSocket = FALSE;
	m_bStopbeat = FALSE;
	m_hRunObject = NULL;
	m_bRecevie = TRUE;
	m_hReConnectSrvThreadHandle = NULL;
	m_dwSumRecive = 0;
	m_dwCurRecive = 0;
	m_pRecivebuf = NULL;
	ZeroMemory(&m_tSendhead, sizeof(SENDHEAD));
	m_SocketClient.SetInterface(this);
}

IClientImpl::~IClientImpl()
{
	//m_SocketClient.Terminate();
	DisConnectServer();
}

BOOL IClientImpl::SolveDBError()
{
	DWORD dwWSAError = WSAGetLastError();

	if ( dwWSAError != 0 )
	{
		LOG4C_NO_FILENUM((LOG_NOTICE,"dwWSAError = %d~",dwWSAError));
	}
	
	switch(dwWSAError)
	{
	case WSAENOTSOCK:
	case WSAENETDOWN:
	case WSAENETUNREACH:
	case WSAENETRESET:
	case WSAECONNABORTED:
	case WSAECONNRESET:
	case WSAESHUTDOWN:
	case WSAEHOSTDOWN:
	case WSAEHOSTUNREACH:
		TRACE("-----------------WSAError = %d\n",dwWSAError);
		LOG4C_NO_FILENUM((LOG_NOTICE,"dwWSAError = %d~",dwWSAError));
		m_bSocket = FALSE;
		break;
	default:
		break;
	}

	return TRUE;
}

void IClientImpl::GetAddress(const SockAddrIn& addrIn, CString& rString) const
{
	TCHAR szIPAddr[MAX_PATH] = { 0 };
	CSocketHandle::FormatIP(szIPAddr, MAX_PATH, addrIn);
	rString.Format(_T("%s : %d"), szIPAddr, static_cast<int>(static_cast<UINT>(ntohs(addrIn.GetPort()))) );
}

void IClientImpl::AppendText(LPCTSTR lpszFormat, ...)
{
	//	if ( !::IsWindow(m_ctlMsgList.GetSafeHwnd()) ) return;
	//	TCHAR szBuffer[512];
	//	HWND hWnd = m_ctlMsgList.GetSafeHwnd();
	//	DWORD dwResult = 0;
	//	if (SendMessageTimeout(hWnd, WM_GETTEXTLENGTH, 0, 0, SMTO_NORMAL, 500L, &dwResult) != 0)
	//	{
	//		int nLen = (int) dwResult;
	//		if (SendMessageTimeout(hWnd, EM_SETSEL, nLen, nLen, SMTO_NORMAL, 500L, &dwResult) != 0)
	//		{
	//			size_t cb = 0;
	//			va_list args;
	//			va_start(args, lpszFormat);
	//			::StringCchVPrintfEx(szBuffer, 512, NULL, &cb, 0, lpszFormat, args);
	//			va_end(args);
	//			SendMessageTimeout(hWnd, EM_REPLACESEL, FALSE, reinterpret_cast<LPARAM>(szBuffer), SMTO_NORMAL, 500L, &dwResult);
	//		}
	//	}
}

bool IClientImpl::GetDestination(SockAddrIn& addrIn) const
{
	CString strPort;
	int nFamily = (m_nMode == AF_IPV4) ? AF_INET : AF_INET6;
	return addrIn.CreateFrom(NULL, strPort, nFamily);
}

bool IClientImpl::SetupMCAST()
{
	const TCHAR szIPv4MCAST[] = TEXT("239.121.1.2");
	const TCHAR szIPv6MCAST[] = TEXT("FF02:0:0:0:0:0:0:1"); // All Nodes local address
	bool result = false;
	if ( m_nSockType == SOCK_UDP )
	{
		if ( m_nMode == AF_IPV4 ) {
			result = m_SocketClient->AddMembership(szIPv4MCAST, NULL);
		} else {
			result = m_SocketClient->AddMembership(szIPv6MCAST, NULL);
			HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
			hr = hr;
		}
	}
	return result;
}

///////////////////////////////////////////////////////////////////////////////

void IClientImpl::OnThreadBegin(CSocketHandle* pSH)
{
	ASSERT( pSH == m_SocketClient );
	(pSH);
	CString strAddr;
	SockAddrIn sockAddr;
	m_SocketClient->GetSockName(sockAddr);
	GetAddress( sockAddr, strAddr );
	InitializeCriticalSection(&pSH->m_hClient2SrvSection);
}

void IClientImpl::OnThreadExit(CSocketHandle* pSH)
{
	ASSERT( pSH == m_SocketClient );
	DeleteCriticalSection( &pSH->m_hClient2SrvSection );
	(pSH);
}

void IClientImpl::OnConnectionDropped(CSocketHandle* pSH)
{
	ASSERT( pSH == m_SocketClient );
	m_bSocket = FALSE;
	if (_tcscmp(RemoteSvr,m_SvrAddr) == 0)
	{
		OutputDebugString(_T("\t\n远程服务器连接丢失\t\n"));
		LOG4C_NO_FILENUM((LOG_NOTICE,"【远程服务器】连接丢失"));
	}
	else
	{
		OutputDebugString(_T("\t\n本地服务器连接丢失\t\n"));
		LOG4C_NO_FILENUM((LOG_NOTICE,"【本地服务器】连接丢失"));
	}
	
	(pSH);
	AppendText( _T("Connection lost with client.\r\n") );
}

void IClientImpl::OnConnectionError(CSocketHandle* pSH, DWORD dwError)
{
	ASSERT( pSH == m_SocketClient );
	(pSH);
	_com_error err(dwError);
	AppendText( _T("Communication Error:\r\n%s\r\n"), err.ErrorMessage() );
}

/************************************************************************/
/*  函数：OnDataReceived[3/21/2016 IT];
/*  描述：;
/*  参数：;
/*  	[IN] pSH：		客户端实例对象;
/*  	[IN] pbData：	客户端本次接收到的数据;
/*  	[IN] dwCount：	客户端本次接收到的数据长度;
/*		[IN] addr：		服务端地址;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
void IClientImpl::OnDataReceived(CSocketHandle* pSH, const BYTE* pbData, DWORD dwCount, const SockAddrIn& addr)
{
	OutputDebugString(_T("\n\t 接收服务端数据 \t\n"));
	ASSERT( pSH == m_SocketClient );

	if( !m_SocketClient->IsOpen() ) return;


	if (NULL == pbData) return;

#if 1
	if ( m_pRecivebuf )
	{
		OutputDebugString(_T("\n\t接收\t\n"));
		memcpy(m_pRecivebuf+m_dwCurRecive, pbData, dwCount);
		m_dwCurRecive += dwCount;

		if ( m_dwCurRecive == m_dwSumRecive )
		{
			TMessageHeader *pMSGHeader = (TMessageHeader*)m_pRecivebuf;
			BYTE *pRecivebuf = (BYTE*)m_pRecivebuf + MESSAGE_HEADER_LEN;

			WORD dwMSGID = pMSGHeader->wMessageId;
			switch( dwMSGID )
			{
			case MSG_CHATMESSAGE_RESP:
			case (MSG_CHATMESSAGE_RESP + 0X4FFF) :
				{
					TCHAT_MESSAGE_STRU *pChatMessage = (TCHAT_MESSAGE_STRU *)pRecivebuf;

					if ( _tcscmp(m_SvrAddr, RemoteSvr) == 0 )
						ChatRemoteSvrMessageResponse((void *)(pRecivebuf));
					else
						ChatLocalSvrMessageResponse((void *)(pRecivebuf));

					if ( m_pRecivebuf )
						delete []m_pRecivebuf;
					m_pRecivebuf = NULL;

					m_dwCurRecive = m_dwSumRecive = 0;
				}
				break;
			default:
				break;
			}
		}
		else if (m_dwCurRecive > m_dwSumRecive)
		{// 接收的数据大于包大小,丢弃;
			OutputDebugString(_T("\t\n包数据过大\t\n"));
			if ( m_pRecivebuf )
				delete []m_pRecivebuf;
			m_pRecivebuf = NULL;

			m_dwCurRecive = m_dwSumRecive = 0;

			m_bRecevie = TRUE;
		}

		return;
	}

	TMessageHeader* pHeader = (TMessageHeader *)pbData;

	/*网络字节顺序的转换*/
	ntohs(pHeader->wHeaderFlag);
	ntohs(pHeader->wMessageId);
	ntohs(pHeader->wMessageSubId);
	ntohl(pHeader->dwDataLen);
	ntohs(pHeader->wCheckSum);
	ntohl(pHeader->wReserve);

	char *pDataBuf = (char *)pbData + MESSAGE_HEADER_LEN;

	WORD dwMessageID = pHeader->wMessageId;
	switch (dwMessageID)
	{
	case MSG_LOGIN_RESP:
	case (MSG_LOGIN_RESP + 0X2FFF) :
		{
			LOGIN_RESULT_STRU tLoginResult = { 0 };
			memcpy(&tLoginResult, pDataBuf, sizeof(LOGIN_RESULT_STRU));


			if ( _tcscmp(m_SvrAddr, RemoteSvr) == 0 )
				LoginRemoteSvrResponse(&tLoginResult);
			else
				LoginLocalSvrResponse(&tLoginResult);

			break;
		}
	case MSG_USERINFO_RESP:
		{
			TUSERLIST_INFO_STRU tUserListInfo = { 0 };
			memcpy(&tUserListInfo, pDataBuf, sizeof(TUSERLIST_INFO_STRU));
			//	ProcessUserListInfoResponse(&tUserListInfo);
			break;
		}
	case MSG_LOGOUT_RESP:
		{
			TUSERLIST_INFO_STRU tUserListInfo = { 0 };
			memcpy(&tUserListInfo, pDataBuf, sizeof(TUSERLIST_INFO_STRU));
			//	ProcessLogoutResponse(&tUserListInfo);
			break;
		}
	case MSG_CHATMESSAGE_RESP:
	case (MSG_CHATMESSAGE_RESP + 0X4FFF) :
		{
			TCHAT_MESSAGE_STRU *pChatMessage = (TCHAT_MESSAGE_STRU *)pDataBuf;
			if ( m_dwSumRecive == 0 )
			{
				m_dwSumRecive = pChatMessage->wMessageLen + MESSAGE_HEADER_LEN + sizeof(TCHAT_MESSAGE_STRU);

				if (m_pRecivebuf == NULL )
				{
					m_pRecivebuf = new BYTE[m_dwSumRecive];

					memcpy(m_pRecivebuf+m_dwCurRecive, pbData, dwCount);
					m_dwCurRecive += dwCount;

					if ( m_dwCurRecive == m_dwSumRecive )
					{
						TMessageHeader *pMSGHeader = (TMessageHeader*)m_pRecivebuf;
						BYTE *pRecivebuf = (BYTE*)m_pRecivebuf + MESSAGE_HEADER_LEN;

						WORD dwMSGID = pMSGHeader->wMessageId;
						switch( dwMSGID )
						{
						case MSG_CHATMESSAGE_RESP:
						case (MSG_CHATMESSAGE_RESP + 0X4FFF) :
							{
								TCHAT_MESSAGE_STRU *pChatMessage = (TCHAT_MESSAGE_STRU *)pRecivebuf;

								if ( _tcscmp(m_SvrAddr, RemoteSvr) == 0 )
									ChatRemoteSvrMessageResponse((void *)(pRecivebuf));
								else
									ChatLocalSvrMessageResponse((void *)(pRecivebuf));

								if ( m_pRecivebuf )
									delete []m_pRecivebuf;
								m_pRecivebuf = NULL;

								m_dwCurRecive = m_dwSumRecive = 0;
							}
							break;
						default:
							break;
						}
					}
					else if ( m_dwCurRecive > m_dwSumRecive )
					{// 接收的数据大于包大小,丢弃;
					}
				}
			}
			
			break;
		}
	default:
		break;
	}
#else
#endif
}

BOOL IClientImpl::LoginRemoteSvrRequest()
{
	m_bRecevie = FALSE;
	// 1.设置通信类型MSG_LOGIN_REQ,为登陆请求;
	WORD wMessageId = 0;
	wMessageId = MSG_LOGIN_REQ;

	BYTE *bySend = NULL;
	INT nDataLen = sizeof(TMessageHeader) + sizeof(TLOGIN_STRU);
	bySend = new BYTE[nDataLen];
	memset(bySend, 0, nDataLen);

	DWORD dwDataLen = sizeof(TLOGIN_STRU);
	TMessageHeader *pHeader = (TMessageHeader*)bySend;
	pHeader->wMessageId = wMessageId;
	pHeader->dwDataLen = sizeof(TLOGIN_STRU);
	pHeader->byVersion = 101;
	pHeader->wHeaderFlag = MESSAGE_HEADER_FLAG;

	TLOGIN_STRU *pLogonInfo = (TLOGIN_STRU*)(bySend + sizeof(TMessageHeader));
	pLogonInfo->tCommonMsg.dwConnectionID = 0;
	pLogonInfo->tCommonMsg.wMessageId = wMessageId;

	CHAR szHostName[MAX_PATH];
	gethostname(szHostName,MAX_PATH);

	strcpy_s(pLogonInfo->tUserInfo.szUserName, szHostName);

	unsigned long ulSendLen = m_SocketClient.Write(bySend, nDataLen, NULL, 30000);
	SolveDBError();
	delete []bySend;
	bySend = NULL;

	if (ulSendLen == SOCKET_ERROR)
	{
		OutputDebugString(_T("验证【远程服务器】失败~\n"));
		LOG4C_NO_FILENUM((LOG_NOTICE,"验证【远程服务器】失败~"));
		return 0;
	}

	OutputDebugString(_T("验证【远程服务器】成功~\n"));
	LOG4C_NO_FILENUM((LOG_NOTICE,"验证【远程服务器】成功~"));

	return 1;
}

BOOL IClientImpl::LoginLocalSvrRequest()
{
	m_bRecevie = FALSE;
	// 1.设置通信类型MSG_LOGIN_REQ,为登陆请求;
	WORD wMessageId = 0;
	wMessageId = MSG_LOGIN_REQ + 0X1FFF;

	BYTE *bySend = NULL;
	INT nDataLen = sizeof(TMessageHeader) + sizeof(TLOGIN_STRU);
	bySend = new BYTE[nDataLen];
	memset(bySend, 0, nDataLen);

	DWORD dwDataLen = sizeof(TLOGIN_STRU);
	TMessageHeader *pHeader = (TMessageHeader*)bySend;
	pHeader->wMessageId = wMessageId;
	pHeader->dwDataLen = sizeof(TLOGIN_STRU);
	pHeader->byVersion = 101;
	pHeader->wHeaderFlag = MESSAGE_HEADER_FLAG;

	TLOGIN_STRU *pLogonInfo = (TLOGIN_STRU*)(bySend + sizeof(TMessageHeader));
	pLogonInfo->tCommonMsg.dwConnectionID = 0;
	pLogonInfo->tCommonMsg.wMessageId = wMessageId;

	CHAR szHostName[MAX_PATH];
	gethostname(szHostName,MAX_PATH);

	strcpy_s(pLogonInfo->tUserInfo.szUserName, szHostName);

	unsigned long ulSendLen = m_SocketClient.Write(bySend, nDataLen, NULL, 30000);

	SolveDBError();
	delete []bySend;
	bySend = NULL;

	if (ulSendLen == SOCKET_ERROR)
	{
		OutputDebugString(_T("验证【本地服务器】失败~\n"));
		LOG4C_NO_FILENUM((LOG_NOTICE,"验证验证【本地服务器】失败~"));
		return 0;
	}

	OutputDebugString(_T("验证【本地服务器】成功~\n"));
	LOG4C_NO_FILENUM((LOG_NOTICE,"验证【本地服务器】成功~"));

	return 1;
}


void IClientImpl::LoginRemoteSvrResponse(void *pLoginResult)
{
	m_bRecevie = TRUE;
	if (NULL == pLoginResult) return;

	LOGIN_RESULT_STRU *ptLoginResult = (LOGIN_RESULT_STRU *)pLoginResult;

	DWORD dwConnectionID = ptLoginResult->tCommonMsg.dwConnectionID;

	if (LOGIN_RESULT_SUC == ptLoginResult->byResult)
	{
		OutputDebugString(_T("登陆【远程服务器】成功\n"));
		LOG4C_NO_FILENUM((LOG_NOTICE,"登陆【远程服务器】成功"));
	}
}

void IClientImpl::LoginLocalSvrResponse(void *pLoginResult)
{
	m_bRecevie = TRUE;
	if (NULL == pLoginResult) return;

	LOGIN_RESULT_STRU *ptLoginResult = (LOGIN_RESULT_STRU *)pLoginResult;

	DWORD dwConnectionID = ptLoginResult->tCommonMsg.dwConnectionID;

	if (LOGIN_RESULT_SUC == ptLoginResult->byResult)
	{
		OutputDebugString(_T("登陆【本地服务器】成功~\n"));
		LOG4C_NO_FILENUM((LOG_NOTICE,"登陆【本地服务器】成功"));
	}
}

BOOL IClientImpl::ChatRemoteSvrMessageRequest(void *szDataBuf, int nDataLen)
{
	m_bRecevie = FALSE;
	memset(&m_tSendhead,0,sizeof(SENDHEAD));
	DWORD dwFromUserID = 0;

	WORD wMessageId = MSG_CHATMESSAGE_REQ;

	DWORD dwDataLen = sizeof(TCHAT_MESSAGE_STRU) + sizeof(TMessageHeader) + nDataLen;

	BYTE *pSendData = NULL;
	pSendData = new BYTE[dwDataLen];
	memset(pSendData, 0, dwDataLen);

	TMessageHeader* ptHeader = (TMessageHeader*)pSendData;
	ptHeader->wMessageId = wMessageId;
	ptHeader->dwDataLen =  sizeof(TCHAT_MESSAGE_STRU) + nDataLen;
	ptHeader->byVersion = 101;
	ptHeader->wHeaderFlag = MESSAGE_HEADER_FLAG;
	ptHeader->wReserve = 0;

	TCHAT_MESSAGE_STRU *pChatMessage = (TCHAT_MESSAGE_STRU*)(pSendData + sizeof(TMessageHeader));
	m_tSendhead.length[98] = 987123768;
	memcpy(pChatMessage, &m_tSendhead, sizeof(m_tSendhead));

	pChatMessage->tCommonMsg.dwConnectionID = dwFromUserID;
	pChatMessage->tCommonMsg.wMessageId = wMessageId;
	pChatMessage->dwFromUserID = dwFromUserID;
	pChatMessage->dwToUserID = m_dwSendCode;

	pChatMessage->wMessageLen = nDataLen;
	memcpy(pChatMessage->byFileContent, szDataBuf, nDataLen);

	BOOL bRet = FALSE;
	unsigned long ulSendLen = m_SocketClient->Write(pSendData, dwDataLen,NULL, 1000);
	SolveDBError();
	if (ulSendLen != SOCKET_ERROR)
	{
		m_SocketClient.SetReadTimeout(2*60*1000);
		bRet = TRUE;
	}
	else
	{
		m_bRecevie = TRUE;
		OutputDebugString(_T("请求信息失败~\n"));
		LOG4C_NO_FILENUM((LOG_NOTICE,"请求信息失败~"));
	}
	delete[] pSendData;
	pSendData = NULL;

	return bRet;
}


BOOL IClientImpl::ChatLocalSvrMessageRequest(void *szDataBuf, int nDataLen)
{
	m_bRecevie = FALSE;
	DWORD dwFromUserID = 0;
	
	WORD wMessageId = MSG_CHATMESSAGE_REQ + 0X3FFF;

	DWORD dwDataLen = sizeof(TCHAT_MESSAGE_STRU) + sizeof(TMessageHeader) + nDataLen;

	BYTE *pSendData = NULL;
	pSendData = new BYTE[dwDataLen];
	memset(pSendData, 0, dwDataLen);

	TMessageHeader* ptHeader = (TMessageHeader*)pSendData;
	ptHeader->wMessageId = wMessageId;
	ptHeader->dwDataLen =  sizeof(TCHAT_MESSAGE_STRU) + nDataLen;
	ptHeader->byVersion = 101;
	ptHeader->wHeaderFlag = MESSAGE_HEADER_FLAG;
	ptHeader->wReserve = 0;

	TCHAT_MESSAGE_STRU *pChatMessage = (TCHAT_MESSAGE_STRU*)(pSendData + sizeof(TMessageHeader));
	m_tSendhead.length[98] = 987123768;
	memcpy(pChatMessage, &m_tSendhead, sizeof(m_tSendhead));

	pChatMessage->tCommonMsg.dwConnectionID = dwFromUserID;
	pChatMessage->tCommonMsg.wMessageId = wMessageId;
	pChatMessage->dwFromUserID = dwFromUserID;
	pChatMessage->dwToUserID = 15;

	pChatMessage->wMessageLen = nDataLen;
	memcpy(pChatMessage->byFileContent, szDataBuf, nDataLen);

	BOOL bRet = FALSE;
	unsigned long ulSendLen = m_SocketClient->Write(pSendData, dwDataLen, NULL, 1000);
	SolveDBError();
	if (ulSendLen != SOCKET_ERROR)
	{
		bRet = TRUE;
	}
	else
	{
		m_bRecevie = TRUE;
		OutputDebugString(_T("请求信息失败~\n"));
		LOG4C_NO_FILENUM((LOG_NOTICE,"请求信息失败~"));
	}
	delete[] pSendData;
	pSendData = NULL;

	return bRet;
}

void IClientImpl::ChatRemoteSvrMessageResponse(void *pResponse)
{
	if (NULL == pResponse) return;

	TCHAT_MESSAGE_STRU *pChatMessage = (TCHAT_MESSAGE_STRU *)pResponse;
	int nMessageLen = pChatMessage->wMessageLen;
	DWORD dwToUserID = pChatMessage->dwToUserID;
	char *pStr = new char[nMessageLen + 1];
	memset(pStr, 0, nMessageLen + 1);
	memcpy(pStr, pChatMessage->byFileContent, nMessageLen);

	CString str = pStr;
	delete[]pStr;
	if (str == _T("账户或密码错误!"))
	{
		//g_bSendOK = 0;
	}
	else
	{
		if (dwToUserID == 0 && str != _T("发送信息成功!"))
			;//g_bSendOK = 0;
		else
			;//g_bSendOK = 1;
	}

	//OutputDebugString(str + _T("\n"));
	//LOG4C_NO_FILENUM((LOG_NOTICE,"%s~",str));

#if 1
	int pos = str.Find(_T("authcodexiao"));
	if (pos != -1)
	{
		CString authcode = str.Right(str.GetLength() - pos - 12);
		str = str.Left(pos);
		char path[MAX_PATH];
		::GetSystemDirectory(path, MAX_PATH);
		CString sysdir = path;
		sysdir += _T("\\authcode.txt");
		CStdioFile fp;
		if (fp.Open(sysdir, CFile::modeWrite | CFile::modeCreate))
		{
			fp.WriteString(authcode);
			fp.Close();
		}
	}

	if (str.Find(".") != -1)
	{
		CStdioFile fp;
		if (fp.Open(_T("\\ip.txt"), CFile::modeWrite | CFile::modeCreate))
		{
			fp.WriteString(str.GetString());
			fp.Close();
		}
	}
#endif
	m_bRecevie = TRUE;
}

void IClientImpl::ChatLocalSvrMessageResponse(void *pResponse)
{
	if (NULL == pResponse) return;

	TCHAT_MESSAGE_STRU *pChatMessage = (TCHAT_MESSAGE_STRU *)pResponse;
	int nMessageLen = pChatMessage->wMessageLen;

	DWORD dwLength = 0;
	BYTE *pData = new BYTE[nMessageLen];
	memcpy(pData, pChatMessage->byFileContent, nMessageLen);
	memcpy(&m_tSendhead, pChatMessage, sizeof(m_tSendhead));

	if ( nMessageLen <= sizeof(DWORD) )
	{
		memcpy(&g_dwLeng2, pChatMessage->byFileContent, sizeof(DWORD));
	}

	CArray<CStringArray,CStringArray> AryList;
	DataToArray( pData, nMessageLen, &AryList);

	if ( pData )
		delete []pData;
	pData = NULL;

#if 0 // 测试;
	INT nSize = AryList.GetSize();
	for ( int i = 0; i < nSize; i++ )
	{
		CStringArray &strAry = AryList.ElementAt(i);
		for ( int n = 0; n < strAry.GetSize(); n++ )
		{
			OutputDebugString(_T("\n"));
			OutputDebugString(strAry.ElementAt(n));
			LOG4C_NO_FILENUM((LOG_NOTICE,"[%d][%d]：%s",i,n, strAry.ElementAt(n)));
			OutputDebugString(_T("\n"));
		}
	}
#endif

	m_bRecevie = TRUE;
}

BOOL IClientImpl::Initialize()
{
	TCHAR szIPAddr[MAX_PATH] = { 0 };
	CSocketHandle::GetLocalAddress(szIPAddr, MAX_PATH, AF_INET);
	AppendText(_T("Local Address (IPv4): %s\r\n"), szIPAddr);
	CSocketHandle::GetLocalAddress(szIPAddr, MAX_PATH, AF_INET6);
	AppendText(_T("Local Address (IPv6): %s\r\n"), szIPAddr);

	return TRUE;
}

void IClientImpl::StartReConnectSrvThread()
{
	// Jeff.启用重连服务端线程.-------------------
	m_hRunObject = CreateEvent( NULL, TRUE, FALSE, _T("ClientThreadRun") );
	if ( m_hRunObject == NULL )	
	{
		//LOG4C((LOG_NOTICE,"创建事件失败"));
	}

	m_hReConnectSrvThreadHandle = CreateThread(NULL,0,ReConnectSrvThread,this,0,NULL);
	if ( m_hReConnectSrvThreadHandle == NULL )	
	{
		//LOG4C((LOG_NOTICE,"创建线程失败"));
	}
}

BOOL IClientImpl::ConnectServer(LPCTSTR strAddr, LPCTSTR strPort)
{
	_stprintf_s(m_SvrAddr,_T("%s"),strAddr);
	_stprintf_s(m_SvrPort,_T("%s"),strPort);
	int nFamily = (m_nMode == AF_IPV4) ? AF_INET : AF_INET6;
	if ( !m_SocketClient.StartClient(NULL, strAddr, strPort, nFamily, (m_nSockType+1) ) )
	{
		m_bSocket = FALSE;
		if (_tcscmp(RemoteSvr,m_SvrAddr) == 0)
		{
			OutputDebugString(_T("连接【远程服务器】失败\n"));
			LOG4C_NO_FILENUM((LOG_NOTICE,"连接【远程服务器】失败"));
		}
		else
		{
			OutputDebugString(_T("连接【本地服务器】失败\n"));
			LOG4C_NO_FILENUM((LOG_NOTICE,"连接【本地服务器】失败"));
		}
		
		return FALSE;
	}
	else
	{
		m_bSocket = TRUE;
		CSocketHandle* pSH = (CSocketHandle *)m_SocketClient;

		pSH->m_npendingSize = 0;
		memset(pSH->m_szpendingbuf, 0, SOCKET_BUFFSIZE);
		SetupMCAST();
		if (_tcscmp(RemoteSvr,m_SvrAddr) == 0)
		{
			OutputDebugString(_T("连接【远程服务器】成功\n"));
			LOG4C_NO_FILENUM((LOG_NOTICE,"连接【远程服务器】成功"));
		}
		else
		{
			OutputDebugString(_T("连接【本地服务器】成功\n"));
			LOG4C_NO_FILENUM((LOG_NOTICE,"连接【本地服务器】成功"));
		}
		return TRUE;
	}
}

void IClientImpl::DisConnectServer()
{
	if(m_hRunObject) 
		SetEvent(m_hRunObject);

	if( m_hReConnectSrvThreadHandle )
	{
		if (WaitForSingleObject(m_hReConnectSrvThreadHandle,INFINITE) != WAIT_FAILED)
		{
			CloseHandle(m_hReConnectSrvThreadHandle);
			m_hReConnectSrvThreadHandle = NULL;
		}
	}

	if(m_hRunObject) 
		CloseHandle( m_hRunObject );
	m_hRunObject = NULL;

	m_SocketClient.Terminate();
}

void IClientImpl::SendMsg(void *pMsg,const int nLen)
{
	if ( m_SocketClient.IsOpen() )
	{
		USES_CONVERSION;
		if (m_nSockType == SOCK_TCP)
		{
			m_SocketClient.Write((const LPBYTE)(pMsg), nLen, NULL, 30000);
		}
		else
		{
			SockAddrIn sockAddr;
			GetDestination(sockAddr);
			m_SocketClient.Write((const LPBYTE)(pMsg), nLen, sockAddr, 30000);
		}
	}
	else
	{
		AfxMessageBox(_T("Socket is not connected"));
	}
}

DWORD WINAPI IClientImpl::ReConnectSrvThread(LPVOID pInstance)
{
	IClientImpl *pClientImpl = (IClientImpl*)pInstance;

	do 
	{
		// 检测连接状态;
		if ( pClientImpl->m_bSocket == FALSE )
		{
			if ( pClientImpl->m_SocketClient->IsOpen() == TRUE )
			{
				pClientImpl->m_SocketClient.Terminate();
			}

			if ( FALSE == pClientImpl->ConnectServer(pClientImpl->m_SvrAddr,pClientImpl->m_SvrPort))
			{
				pClientImpl->m_bSocket = FALSE;
			}
			else
			{
				pClientImpl->m_bSocket = TRUE;

				// 同时验证登陆;
				if (_tcscmp(RemoteSvr,pClientImpl->m_SvrAddr) == 0)
				{
					OutputDebugString(_T("重连【远程服务器】成功！\n"));
					LOG4C_NO_FILENUM((LOG_NOTICE,"重连【远程服务器】成功~"));
					pClientImpl->LoginRemoteSvrRequest();
				}
				else
				{
					OutputDebugString(_T("重连【本地服务器】成功！\n"));
					LOG4C_NO_FILENUM((LOG_NOTICE,"重连【本地服务器】成功~"));
					pClientImpl->LoginLocalSvrRequest();
				}
			}
		}

	} while( WaitForSingleObject(pClientImpl->m_hRunObject,200L) == WAIT_TIMEOUT );

	LOG4C_NO_FILENUM((LOG_NOTICE,"重连服务器线程退出"));

	return 0;
}