baseudp.cpp

用PC机访问wince的远程桌面,还可以上传文件,杀进程等功能,服务端在wince,客服端在windows下

// BaseUDP.cpp: implementation of the CBaseUDP class.
//
//////////////////////////////////////////////////////////////////////

#include "BaseUDP.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
void WriteLog1(char* sfmt,...);
CBaseUDP::CBaseUDP()
{
	WSAData	wsa;
	WSAStartup(MAKEWORD(2, 2), &wsa);
	m_skServer	= 0;
	m_pRecvBuf = new char[MAX_UDP_PACKAGE*10];
}

CBaseUDP::~CBaseUDP()
{
	if(m_skServer)
	{
		closesocket(m_skServer);
	}
	WSACleanup();
	if( m_pRecvBuf )
	{
		delete[] m_pRecvBuf;
		m_pRecvBuf = 0;
	}
}

int CBaseUDP::Send(char *szData, int nLength, const char *szIP, unsigned short port, sockaddr_in &saServer)
{
	if(nLength <= 0)
	{
		return ERROR_UDP_PARAM;
	}

	if(szData == NULL)
	{
		return ERROR_UDP_PARAM;
	}

	saServer.sin_family			= AF_INET;
	saServer.sin_addr.s_addr	= inet_addr(szIP);
	saServer.sin_port			= htons(port);

	if(saServer.sin_addr.s_addr == INADDR_NONE)
	{
		return ERROR_UDP_ADDR;
	}

	int	sk	= socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (sk == SOCKET_ERROR) 
	{
		return ERROR_UDP_SOCKET;
	}
	if(sendto(sk, szData, nLength, 0, (struct sockaddr *)&saServer, sizeof(sockaddr_in)) != nLength)
	{

	}
	return sk;
}

int CBaseUDP::Send(char *szData, int nLength, int sk, sockaddr_in saClient, int	nSockaddrLen)
{
	if(nLength <= 0)
	{
		return ERROR_UDP_PARAM;
	}

	if(szData == NULL)
	{
		return ERROR_UDP_PARAM;
	}

	if(saClient.sin_addr.s_addr == INADDR_NONE)
	{
		return ERROR_UDP_ADDR;
	}

	if (sk == SOCKET_ERROR) 
	{
		return ERROR_UDP_SOCKET;
	}
	if(sendto(sk, szData, nLength, 0, (struct sockaddr *)&saClient, nSockaddrLen) != nLength)
	{
	}
	return sk;
}

int CBaseUDP::RunAsServer(unsigned short nPort)
{
	if(m_skServer)
	{
		closesocket(m_skServer);
		m_skServer	= 0;
	}
	m_skServer	= socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (m_skServer == SOCKET_ERROR) 
	{
		return ERROR_UDP_SOCKET;
	}
	sockaddr_in saServer;
	saServer.sin_family			= AF_INET;
	saServer.sin_addr.s_addr	= INADDR_ANY;
	saServer.sin_port			= htons(nPort);

	if(saServer.sin_addr.s_addr == INADDR_NONE)
	{
		return ERROR_UDP_ADDR;
	}
	int optval = MAX_UDP_PACKAGE*1000;
	int bk = setsockopt(m_skServer,SOL_SOCKET,SO_RCVBUF,(char *)&optval,optval);
	WriteLog("setsockopt = %d",bk);
	if(bind(m_skServer, (struct sockaddr *)&saServer, sizeof(struct sockaddr_in)) == SOCKET_ERROR)
	{
		closesocket(m_skServer);
		return ERROR_UDP_BIND;
	}
	
	DWORD	dwThreadID;
	HANDLE	hUdpThread	= CreateThread(NULL, 0, DataThread, this, 0, &dwThreadID);
	CeSetThreadPriority(hUdpThread, 0); //ADD AS DAIWW 2006.08.25
//	printf("DataThread线程优先级=%d",CeGetThreadPriority(hUdpThread));
	WriteLog1("DataThread线程优先级=%d",CeGetThreadPriority(hUdpThread));
	if (hUdpThread) 
	{
//		SetThreadPriority(hUdpThread, THREAD_PRIORITY_TIME_CRITICAL);
		CloseHandle(hUdpThread);
	}
	return 0;
}

int CBaseUDP::WaitForDataRecv(int sk, long nTimeout)
{
	fd_set RSet;
	struct timeval tv;
	tv.tv_sec	= nTimeout;
	tv.tv_usec	= 0;
	FD_ZERO(&RSet);
	FD_SET((unsigned int)sk, &RSet);
	int	nSelRet	= select(sk + 1,&RSet, NULL, NULL, &tv);
	if(nSelRet == 0)
		return ERROR_UDP_TIMEOUT;
	else if(nSelRet == SOCKET_ERROR)
		return ERROR_UDP_SOCKET;
	return 0;
}

int CBaseUDP::OnDataRecv(char *szData, int nLength, int sk, sockaddr_in saClient, int nSaLength)
{
	return 0;
}

DWORD WINAPI CBaseUDP::DataThread(LPVOID lpvoid)
{
	CBaseUDP	*pUdp	= (CBaseUDP *)lpvoid;	
	int nWaitRet;
	if( pUdp->m_pRecvBuf == 0 )
		return 1;
	//OnError(0x08, "[%s %d]CBaseUDP::DataThread Started.\n", GetCurFile(__FILE__), __LINE__);
	while(1)
	{
		nWaitRet	= CBaseUDP::WaitForDataRecv(pUdp->m_skServer, UDP_TIME_OUT);
		if(nWaitRet == ERROR_UDP_TIMEOUT) 
			continue;
		if(nWaitRet < 0)
		{
			break;
		}
		
		sockaddr_in	saClient;
		int	nSockaddrLen	= sizeof(struct sockaddr);
		int nRecvLength	= recvfrom(pUdp->m_skServer, pUdp->m_pRecvBuf, MAX_UDP_PACKAGE, 0, (struct sockaddr *)&saClient, &nSockaddrLen);
		PReqPackHead	pRmtCtl	= (PReqPackHead)pUdp->m_pRecvBuf;
//		WriteLog("CheckDataValidate\n");
		int nErr = pUdp->CheckDataValidate(nRecvLength);
		if( 0 == nErr )
		{
			pUdp->OnDataRecv(pUdp->m_pRecvBuf, nRecvLength, pUdp->m_skServer, saClient, nSockaddrLen);
		}
	}
	return 0L;
}
void CBaseUDP::WriteLog(char* sfmt,...)
{
	static SOCKET hsock1=0;
	char szMes[4096]={0};
	char* p = szMes;
	p += strlen(p);
	va_list ap;
	va_start(ap, ,sfmt);
	vsprintf (p, sfmt, ap);
	va_end(ap);
	
	if( 0 == hsock1 )
	{
		unsigned int addr;
		addr = inet_addr("192.168.3.163");
		if( addr == INADDR_NONE )
		{
			return;
		}
		hsock1 = socket(AF_INET,SOCK_DGRAM,0);
		SOCKADDR_IN server;
		server.sin_addr.s_addr = addr;
		server.sin_family = AF_INET;
		server.sin_port = htons(8773);
		if( connect(hsock1,(struct sockaddr*)&server,sizeof(server)) )
		{  
			closesocket(hsock1);
			return;
		}
	}
	int nsend = send(hsock1,(const char*)szMes,strlen(szMes),0);
	closesocket(hsock1);
	
}
int CBaseUDP::CheckDataValidate(int nlen)
{
//	WriteLog("-----------len=%d\n",nlen);
	int nErr = ERR_REQUEST_FRAME;
	if( nlen >= sizeof(ReqPackHead) )
	{
//		WriteLog("-----------ERR_REQUEST_FRAME\n");
		PReqPackHead pHead = (PReqPackHead)m_pRecvBuf;
		if( pHead->nFlag < 0 || pHead->nFlag > MAX_BUSS )
		{
//			WriteLog("-----------ERR_UNKNOWN_REQUESTCMD\n");
			nErr = ERR_UNKNOWN_REQUESTCMD;
		} else
			nErr = 0;
	}
	if(nErr != 0)
		WriteLog("-----------nErr=%d\n",nErr);
	return nErr;
}
int CBaseUDP::Recv(char *pcaData, const int nLength, int sk, sockaddr_in saClient, bool bClose)
{
	int nSaLength	= sizeof(sockaddr_in);
	if(recvfrom(sk, pcaData, nLength, 0, (struct sockaddr *)&saClient, &nSaLength) == SOCKET_ERROR)
	{
		closesocket(sk);
		return ERROR_UDP_SOCKET;
	}
	if(bClose)
		closesocket(sk);
	return nLength;
}