udpsocket.cpp

vxworks上的udpsocket的程序

/*****************************************************************

	Description:

		The definition for the class "CUdpSocket".

	Author:		[e-mail]

	Created date:	2002/10/30 14:00 PM


*****************************************************************/

#include "UdpSocket.h"

#include <string.h>

#ifdef WIN32

	#include <windows.h>

#endif

#ifdef VXWORKS 0

	#include <taskLib.h>
	#include <inetLib.h>
	#include <ioLib.h>

#endif

#include <stdlib.h>

#ifdef _DEBUG

	#include <stdio.h>

#endif

#ifdef VXWORKS 0

	#define INVALID_SOCKET ERROR
	#define SOCKET_ERROR ERROR

#endif

CUdpSocket::CUdpSocket()
{

#ifdef WIN32

	WSADATA wsd ;

	// Load the windows socket DLLs and initialize
	// the members.

	WSAStartup(MAKEWORD(2,2),&wsd) ;

	m_hThread = NULL ;

#endif

#ifdef VXWORKS 0

	m_hTask = NULL ;

#endif

	m_wm = user_receive ;
	m_bReady = false ;
	m_sockSender = NULL ;
	m_sockReceiver = NULL ;

	m_tvDelay.tv_sec=0 ;
	m_tvDelay.tv_usec=1 ;

	memset(&m_addrRemote,0,sizeof(SOCKADDR)) ;
}

STATUS CUdpSocket::SetWorkMode(workmode wm)
{
	if (m_bReady) return CANNOT_SETMODE ;

	m_wm = wm ;
	return OK ;
}

STATUS CUdpSocket::Init
	(int localport,const char * targetip,int remoteport)
{
	// Create the socket for data sending

	if ((m_sockSender=socket(AF_INET,SOCK_DGRAM,0))
		==INVALID_SOCKET)
	{

#ifdef _DEBUG

 		printf("run time error:") ;
 		printf("cann't create sender (socket).\n") ;

#endif

		OnInitComplete(SOCKET_CALL_FAILD) ;

		return SOCKET_CALL_FAILD ;
	}

	// Set port and remote host for sender

	m_addrRemote.sin_family=AF_INET ;
	m_addrRemote.sin_port=htons((short)remoteport) ;
	m_addrRemote.sin_addr.s_addr=inet_addr(targetip) ;

	// Create the socket for data sending

	if ((m_sockReceiver=socket(AF_INET,SOCK_DGRAM,0))
		==INVALID_SOCKET)
	{

#ifdef _DEBUG

 		printf("run time error:") ;
 		printf("cann't create receiver (socket).\n") ;

#endif

		OnInitComplete(SOCKET_CALL_FAILD) ;

		return SOCKET_CALL_FAILD ;
	}

	// Set port for receiver

	m_addrLocal.sin_family=AF_INET ;
	m_addrLocal.sin_port=htons((short)localport) ;
	m_addrLocal.sin_addr.s_addr=htonl(INADDR_ANY) ;

	if (bind(m_sockReceiver,(SOCKADDR*)&m_addrLocal,
		sizeof(m_addrLocal))==SOCKET_ERROR)
	{

#ifdef _DEBUG

 		printf("run time error:") ;
 		printf("cann't create receiver (bind).\n") ;

#endif

		OnInitComplete(BIND_CALL_FAILD) ;

		return BIND_CALL_FAILD ;
	}


	if (m_wm==auto_receive)
	{

		// Start the thread(task) for data receiving

#ifdef WIN32

		m_hThread = CreateThread(NULL,NULL,
			(LPTHREAD_START_ROUTINE)recvsrv,this,NULL,NULL) ;

#ifdef _DEBUG

		printf("threadid 0x%x loaded.\n",m_hThread) ;

#endif // _DEBUG

		if (m_hThread==NULL)
		{

#ifdef _DEBUG

 			printf("run time error:") ;
 			printf("cann't start receiver (thread).\n") ;

#endif // _DEBUG

			OnInitComplete(THREAD_CALL_FAILD) ;

			return THREAD_CALL_FAILD ;
		}

#endif // WIN32

#ifdef VXWORKS 0

		m_hTask = taskSpawn("recvsrv1",60,VX_FP_TASK,
			1024*40,(FUNCPTR)recvsrv,(int)this,
			0,0,0,0,0,0,0,0,0
			) ;

		if (m_hTask==ERROR)
		{

#ifdef _DEBUG

 			printf("run time error:") ;
 			printf("cann't start receiver (task).\n") ;

#endif // _DEBUG

			OnInitComplete(THREAD_CALL_FAILD) ;

			return THREAD_CALL_FAILD ;
		}
		else
		{

#ifdef _DEBUG

			printf("taskid 0x%x spawned.\n",m_hTask) ;

#endif // _DEBUG

		}


#endif // VXWORKS

	}

	// All the sockets and threads are loaded

	m_bReady = true ;
	OnInitComplete(OK) ;

	return OK ;
}

unsigned long CUdpSocket::recvsrv(void * pt)
{

	CUdpSocket * pthis = (CUdpSocket *)pt ;
	static char szBuf[4096] ;
	int iSockAddrSize = sizeof(sockaddr_in) ;
	static char szIpAddr[16] ;

	// Receive data form network.

	// When any data arrive, call OnBeforReceive() and
	// OnReceive to dispose the data.

	while (true)
	{
		FD_ZERO(&(pthis->m_fdSel)) ;
		FD_SET((unsigned)pthis->m_sockReceiver,
			&(pthis->m_fdSel)) ;
		
#ifdef _DEBUG

		// printf("waiting for incoming message.\n") ;

#endif // _DEBUG

		if (!select(FD_SETSIZE,&(pthis->m_fdSel),
			NULL,NULL,&(pthis->m_tvDelay)))
		{

#ifdef VXWORKS

			taskDelay(1) ;

#endif // VXWORKS

			continue ;
		}

		memset(szBuf,0,4096) ;
		memset(&(pthis->m_addrRecv),0,
			sizeof(sockaddr_in)) ;

		int iRet=recvfrom
			(pthis->m_sockReceiver,
			szBuf,4096,0,
			(SOCKADDR*)&(pthis->m_addrRecv),
			&iSockAddrSize
			) ;

		strcpy(szIpAddr,inet_ntoa
			(pthis->m_addrRecv.sin_addr)) ;

		if (iRet!=SOCKET_ERROR)
		{
			pthis->OnBeforeReceive
				(iRet,szBuf,&(pthis->m_addrRecv)) ;

			pthis->OnReceive
				(iRet,szBuf,&(pthis->m_addrRecv)) ;
		}
	}

}

void CUdpSocket::SetRemoteAddr(const char * targetip,int port)
{
	// Set port and remote host for sender

	m_addrRemote.sin_port=htons((short)port) ;
	m_addrRemote.sin_addr.s_addr=inet_addr(targetip) ;
}

const char * CUdpSocket::GetRemoteIp()
{
	static char szIp[16] ;

	strcpy(szIp,inet_ntoa(m_addrRemote.sin_addr)) ;

	return szIp ;
}

int CUdpSocket::GetRemotePort()
{
	return m_addrRemote.sin_port ;
}

int CUdpSocket::GetLocalPort()
{
	return m_addrRemote.sin_port ;
}

STATUS CUdpSocket::Send
	(int buflen,void * buf,sockaddr_in * addr)
{
	// The simple version for sendto(...)

	int nBytesSent ;

	if (!m_bReady) return NOT_INITIALIZED ;

	if (addr==NULL)
		addr = &m_addrRemote ;

	OnBeforeSend(buflen,buf) ;

	nBytesSent = sendto
		(m_sockSender,(char *)buf,buflen,0,
		(SOCKADDR*)addr,sizeof(SOCKADDR)
		) ;

	OnSendComplete(nBytesSent) ;

	return nBytesSent ;
}

STATUS CUdpSocket::Recv(int buflen,void * buf,
						int timeout,sockaddr_in * addr)
{
	int iSockAddrSize = sizeof(sockaddr_in) ;
	int iRet = NULL ;
	timeval tv ;

	// Receive data form network.

	if (timeout!=0)
	{

		FD_ZERO(&(m_fdSel)) ;
		FD_SET((unsigned)m_sockReceiver,&m_fdSel) ;

		tv.tv_sec = timeout/1000 ;
		tv.tv_usec = (timeout%1000)*1000 ;
		
#ifdef _DEBUG

		printf("waiting for incoming message.\n") ;

#endif // _DEBUG

		if (!select(FD_SETSIZE,&m_fdSel,
			NULL,NULL,&tv))
			return RECV_TIMEOUT ;

	}

	memset(buf,0,buflen) ;

	if (addr==NULL)
	{
		memset(&m_addrRecv,0,sizeof(sockaddr_in)) ;
		addr = &m_addrRecv ;
	}
	else
	{
		memset(addr,0,sizeof(sockaddr_in)) ;
	}

	iRet = recvfrom // Receive data gram
		(m_sockReceiver,
		(char *)buf,buflen,0,
		(SOCKADDR*)addr,&iSockAddrSize
		) ;

	return iRet ;

}

STATUS CUdpSocket::SetSenderBufferSize(int size)
{
	return setsockopt
		(m_sockSender,SOL_SOCKET,
		SO_SNDBUF,(char *)&size,sizeof(int)
		) ;
}

int CUdpSocket::GetSenderBufferSize()
{
	int size,n ;

	getsockopt
		(m_sockSender,SOL_SOCKET,
		SO_SNDBUF,(char *)&size,&n
		) ;

	return size ;
}

STATUS CUdpSocket::SetReceiverBufferSize(int size)
{
	return setsockopt
		(m_sockReceiver,SOL_SOCKET,
		SO_SNDBUF,(char *)&size,sizeof(int)
		) ;
}

int CUdpSocket::GetReceiverBufferSize()
{
	int size,n ;

	getsockopt
		(m_sockReceiver,SOL_SOCKET,
		SO_SNDBUF,(char *)&size,&n
		) ;

	return size ;
}

int CUdpSocket::GetSenderSocket()
{
	return m_sockSender ;
}

int CUdpSocket::GetReceiverSocket()
{
	return m_sockReceiver ;
}

CUdpSocket::~CUdpSocket()
{

#ifdef WIN32

#ifdef _DEBUG

	BOOL bThreadTerminated = FALSE ;

#endif // _DEBUG

	if (NULL!=m_sockSender&&
		INVALID_SOCKET!=m_sockSender)
		closesocket(m_sockSender) ;

	if (NULL!=m_sockReceiver&&
		INVALID_SOCKET!=m_sockReceiver)
		closesocket(m_sockReceiver) ;

	WSACleanup() ;

	// Terminate the recvsrv thread

#ifdef _DEBUG

	bThreadTerminated = TerminateThread
		((HANDLE)m_hThread,0) ;

	CloseHandle(m_hThread) ;

	if (bThreadTerminated)
		printf("thread 0x%x terminated.\n",m_hThread) ;

#else

	TerminateThread((HANDLE)m_hThread,0) ;

#endif // _DEBUG

#endif // _WIN32

#ifdef VXWORKS

#ifdef _DEBUG

	bool bTaskDeleted = false ;

#endif // _DEBUG

	if (NULL!=m_sockSender&&
		INVALID_SOCKET!=m_sockSender)
	{
		shutdown(m_sockSender,2) ;
		close(m_sockSender) ;
	}

	if (NULL!=m_sockReceiver&&
		INVALID_SOCKET!=m_sockReceiver)
	{
		shutdown(m_sockReceiver,2) ;
		close(m_sockReceiver) ;
	}

#ifdef _DEBUG

	bTaskDeleted = taskDelete(m_hTask) ;

	if (bTaskDeleted!=ERROR)
		printf("task 0x%x deleted.\n",m_hTask) ;

#else

	taskDelete(m_hTask) ;

#endif // _DEBUG

#endif // VXWORKS

}

// Our overridable functions.

// In the base class "CUdpSocket", the functions do nothing

void CUdpSocket::OnInitComplete(STATUS status)
{

#ifdef _DEBUG

	printf("OnInitComplete(%d)\n",status) ;

#endif

}

void CUdpSocket::OnBeforeSend(int buflen,void * buf)
{

#ifdef _DEBUG

	printf("OnBeforeSend(%d,...)\n",buflen) ;

#endif

}

void CUdpSocket::OnSendComplete(STATUS status)
{

#ifdef _DEBUG

	printf("OnSendComplete(%d)\n",status) ;

#endif

}

void CUdpSocket::OnBeforeReceive
	(int buflen,void * buf,sockaddr_in * addr)
{

#ifdef _DEBUG

	printf("OnBeforeReceive(%d,...)\n",buflen) ;

#endif

}

void CUdpSocket::OnReceive
	(int buflen,void * buf,sockaddr_in * addr)
{

#ifdef _DEBUG

	printf("OnReceive(%d,...)\n",buflen) ;

#endif

}

// End of the file