serverlink.cpp

一个短信smpp协议开发包源码

// ServerLink.cpp: implementation of the CServerLink class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
//#include "SMPPAPI.h"
#include "ServerLink.h"
#include "common.h"
#include "smpp.h"
#include "smpppacket.h"

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

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


CServerLink::CServerLink() : m_bConnected(false), m_nSocket(INVALID_SOCKET),
	m_hEvent(WSA_INVALID_EVENT), m_bReadHeader(true)
{
	m_nSocket = NULL;
	m_hEvent = NULL;
	m_hThread = NULL;

	m_pIOWinThread = NULL;

	//manual reset Kill event with intial signal state to false
	m_hKillEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hDisconnectEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	//callback
	m_Param = NULL;
	m_pProcessPacket = NULL;

	InitializeCriticalSection(&m_cs);
}

CServerLink::CServerLink(CString svrip) : m_bConnected(false), m_nSocket(INVALID_SOCKET),
	m_hEvent(WSA_INVALID_EVENT), m_bReadHeader(true)
{
	m_ServerIP = svrip;
	m_ServerPort = DEFAULT_PORT;

	m_nSocket = NULL;
	m_hEvent = NULL;
	m_hThread = NULL;

	m_pIOWinThread = NULL;

	//manual reset Kill event with intial signal state to false
	m_hKillEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hDisconnectEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	//callback
	m_Param = NULL;
	m_pProcessPacket = NULL;

	InitializeCriticalSection(&m_cs);
}

CServerLink::CServerLink(CString svrip, int port) : m_bConnected(false), m_nSocket(INVALID_SOCKET),
	m_hEvent(WSA_INVALID_EVENT), m_bReadHeader(true)
{

	m_ServerIP = svrip;
	m_ServerPort = port;

	m_nSocket = NULL;
	m_hEvent = NULL;
	m_hThread = NULL;

	m_pIOWinThread = NULL;

	//manual reset Kill event with intial signal state to false
	m_hKillEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	m_hDisconnectEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	//callback
	m_Param = NULL;
	m_pProcessPacket = NULL;

	InitializeCriticalSection(&m_cs);
}

CServerLink::~CServerLink()
{
	SetEvent(m_hKillEvent);
	WaitForSingleObject(m_hThread, 500);

	CloseHandle(m_hKillEvent);
	WSACloseEvent(m_hEvent);

	CloseHandle(m_hDisconnectEvent);

	DeleteCriticalSection(&m_cs);
}

void CServerLink::init(CString svrip, int port)
{
	m_ServerIP = svrip;
	m_ServerPort = port;
}

bool CServerLink::open()
{

	EnterCriticalSection(&m_cs);
	bool bConnected = m_bConnected;
	LeaveCriticalSection(&m_cs);

	if (bConnected)
		return true;

	SOCKADDR_IN		saServer;		

	saServer.sin_port = htons(m_ServerPort);
	saServer.sin_family = AF_INET;
	saServer.sin_addr.s_addr = inet_addr(m_ServerIP);

	m_nSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	if (m_nSocket == INVALID_SOCKET)
	{
        return FALSE;	
	}

	int nRet = connect(m_nSocket,(sockaddr*)&saServer, sizeof(saServer));

	if (nRet == SOCKET_ERROR)
	{
		TCHAR buf[100];
		sprintf(buf, "connect error %ld",WSAGetLastError());

		closesocket(m_nSocket);
		return FALSE;
	}

	ResetEvent(m_hDisconnectEvent);
	m_bConnected = TRUE;

	TRACE("Connected to Server");


	//listen to event
	m_hEvent = WSACreateEvent();

	//first, we tell the system what event we are interested
	nRet = WSAEventSelect(m_nSocket,
						  m_hEvent,
						  FD_CLOSE | FD_READ);

	//create the thread to listen for events
	m_pIOWinThread = AfxBeginThread(IOThreadProc,		//thread proc
					(void*) this,					//parameter
					THREAD_PRIORITY_NORMAL,			//thread priority
					0,								//stack size
					CREATE_SUSPENDED,				//create thread
					NULL);							//security attribute

	m_dwThreadId = m_pIOWinThread->m_nThreadID;
	m_hThread = m_pIOWinThread->m_hThread;
	m_pIOWinThread->ResumeThread();

	TRACE("Listen TID=%ld\n",m_dwThreadId);

	return TRUE;
}

void CServerLink::close()
{
	EnterCriticalSection(&m_cs);

	if (m_bConnected)
	{
		SetEvent(m_hKillEvent);
		WaitForSingleObject(m_hThread, 2000);

		closesocket(m_nSocket);
		SetEvent(m_hDisconnectEvent);
		m_bConnected = FALSE;
	}

	LeaveCriticalSection(&m_cs);
}

bool CServerLink::isConnected()
{
	return m_bConnected;
}

CString CServerLink::getServerIP()
{
	return m_ServerIP;
}

int CServerLink::getServerPort()
{
	return m_ServerPort;
}

UINT CServerLink::IOThreadProc(LPVOID pParam)
{
	return ((CServerLink *) pParam)->IOThreadRun();
}

unsigned CServerLink::IOThreadRun()
{
	bool bRunning = false;
	bool bConnected;

	TRACE("Going to run the IO Thread\n");

	while (!bRunning)
	{
		EnterCriticalSection(&m_cs);
		bConnected = m_bConnected;
		LeaveCriticalSection(&m_cs);

		//if it's not connected exit the IO thread
		if(!m_bConnected)
			break;
		
		//going to shutdown, exit the loop
        if (WaitForSingleObject(m_hKillEvent, 0) == WAIT_OBJECT_0)
		{
			TRACE("Existing IO Thread coz of kill event\n");
            break;
		}

		DWORD ret = ::WSAWaitForMultipleEvents(1, &m_hEvent, FALSE, 100, FALSE);

		if (ret == WSA_WAIT_EVENT_0 )	//an event is signalled
		{
			WSANETWORKEVENTS hNetworkEvent;

			//evaluate what's happend, read or close ?
			int ret1 = ::WSAEnumNetworkEvents(m_nSocket, m_hEvent, &hNetworkEvent);

			if (hNetworkEvent.lNetworkEvents & FD_CLOSE)
			{
				TRACE("Network event is Close\n");
				OnClose();
				break;
			}

			if (hNetworkEvent.lNetworkEvents & FD_READ)		//we got something to read
			{
				TRACE("Network event is Read\n");
				OnRead();
			}

		}	//wait_object_0

	}	//while bRunning

	TRACE("Exiting IO Thread\n");
	return 0;	//thread exit normally

}

bool CServerLink::OnRead()
{

	TRACE("OnRead - CServerLink\n");
	int ret;

	if (m_bReadHeader)	
	{
		m_nTotalRead = 0;
		DWORD dwRead = 0;

		//check how many bytes we could read
		ioctlsocket(m_nSocket, FIONREAD, &dwRead);

		//can we get the preliminary header ?
		//we know the packet size after reading it
		if (dwRead < 4)
			return false;
		
		BYTE pkt_hdr[4];
	
		ret = recv(m_nSocket, (char *) pkt_hdr, 4,0);

		m_nTotalRead = 4;		//CommandLen is included in the length
		m_nBlockSize = readInt(pkt_hdr);

		TCHAR buff[100];
		sprintf(buff, "CommandLen is : %d\n", m_nBlockSize);
		TRACE(buff);

		m_bReadHeader = FALSE;	//we don't have to read header later

	}
	else
	{
		//we have already read the 4-byte preliminary header
		DWORD dwRead = 0;

		//check that how many bytes we can read
		ioctlsocket(m_nSocket, FIONREAD, &dwRead);

		if (dwRead == 0)
			return false;

		//we should only read the socket up to packet size as in the header
		if (dwRead > (m_nBlockSize - m_nTotalRead))
			dwRead = m_nBlockSize - m_nTotalRead;

		BYTE* pBlock = new BYTE[dwRead+1];
		ZeroMemory(pBlock, dwRead+1);

		int nrec = recv(m_nSocket, (char*) pBlock, dwRead, 0);

		pBlock[dwRead] = NULL;
		m_nTotalRead+=nrec;

		if (m_nTotalRead == m_nBlockSize)
		{
			//we get the whole packet in pBlock

			parse_packet(pBlock, m_nTotalRead);

			//resetting
			m_bReadHeader = TRUE;
		}

		delete [] pBlock;
	}

	return false;
}

bool CServerLink::OnClose()
{
	close();

	CLinkClose *ppak = new CLinkClose();

	//call back
	if (m_pProcessPacket != NULL)
	{
		m_pProcessPacket(ppak, m_Param);
	}

	delete ppak;

	return true;
}

int CServerLink::send(PBYTE data, uint32 datalen)
{
	WSABUF sbuffer;
    ULONG cb_written, retcode = 0;
    int ret;

	if (!m_bConnected)
		return 0;

	sbuffer.len = datalen;
	sbuffer.buf = (char *) data;

retry:
	//send
	ret = WSASend (m_nSocket, (LPWSABUF)&sbuffer, 1, &cb_written, 0, NULL, NULL);
	if (ret != 0) {
		ret = WSAGetLastError();
		if (ret == WSAEWOULDBLOCK) {
			Sleep(100);
			goto retry;
		}
		return ret;
	}
	if (datalen != cb_written) {
		// not all data send!
		return -1;
	}
	return 0;
}

bool CServerLink::sendPacket(CPacketBase &pak)
{
	bool ret;

	PBYTE pby;
	int nsz;

	pak.encodeBody(pby, nsz);
	if(	send(pby, nsz) > 0)
		ret = true;
	else
		ret = false;

	delete [] pby;

	return ret;
}

void CServerLink::registerProcessPacket(void(__stdcall *start_address)(CPacketBase *pak, LPVOID param), LPVOID param)
{
	m_pProcessPacket = start_address;
	m_Param = param;
}