net_packet.cpp

来自「网络泡泡被.net管理」· C++ 代码 · 共 375 行

             // NET_Packet.cpp: implementation of the NET_Packet class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "net_lib.h"

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

NET_Packet::NET_Packet(int data_size)
{
	m_data	= new char[data_size];
	m_max_data_size	= data_size;
	m_cursor = m_data + PACKET_CONTENT_POS;
	m_uid_sendto	= 0;
	m_datalen		= 0;
	setCmd(NLIBP_NULL);
	memset(m_data, 0, sizeof(NET_PACKET_HEADER));
	setVersion(VER_PACKET);

}

NET_Packet::~NET_Packet()
{
	if(m_data)
	{
		delete[] m_data;
	}
}


void NET_Packet::write8(uint8 b)
{
	if (m_cursor <= m_data + m_max_data_size - sizeof(b)) 
	{
		*(uint8 *) m_cursor = b;
		m_cursor += sizeof(b);
	}
}

void NET_Packet::write16(uint16 w)
{
	if (m_cursor <= m_data + m_max_data_size - sizeof(w)) 
	{
		*(uint16 *) m_cursor = htons(w);
		m_cursor += sizeof(w);
	}
}

void NET_Packet::write32(uint32 dw)
{
	if (m_cursor <= m_data + m_max_data_size - sizeof(dw)) 
	{
		*(uint32 *) m_cursor = htonl(dw);
		m_cursor += sizeof(dw);
	}
}

void NET_Packet::writeString(const char *str)
{
	uint16 len = strlen(str) + 1;
	if (m_cursor <= m_data + m_max_data_size - sizeof(len) - len) 
	{
		write16(len);
		strcpy(m_cursor, str);
		m_cursor += len;
	}
}


void NET_Packet::writeData(void* pData, uint16 len)
{
	if (m_cursor <= m_data + m_max_data_size - sizeof(len) - len) 
	{
		write16(len);
		memcpy(m_cursor, pData, len);
		m_cursor += len;
	}
}


uint8 NET_Packet::read8()
{
	uint8 b = 0;
	if (m_cursor <= m_data + m_datalen  - sizeof(uint8)) 
	{
		b = *m_cursor;
		m_cursor += sizeof(b);
	}
	return b;
}

uint16 NET_Packet::read16()
{
	uint16 w = 0;
	if (m_cursor <= m_data + m_datalen - sizeof(w)) 
	{
		w = ntohs(*(uint16 *) m_cursor);
		m_cursor += sizeof(w);
	}
	return w;
}

uint32 NET_Packet::read32()
{
	uint32 dw = 0;
	if (m_cursor <= m_data + m_datalen - sizeof(dw)) 
	{
		dw = ntohl(*(uint32 *) m_cursor);
		m_cursor += sizeof(uint32);
	}
	return dw;
}

const char *NET_Packet::readString()
{
	const char *str = NULL;
	uint16 len = read16();
	if (m_cursor <= m_data + m_datalen - len && !m_cursor[len - 1]) 
	{
		str = m_cursor;
		m_cursor += len;
	}
	return str;
}

void* NET_Packet::readData()
{
	uint16 len = read16();
	void* str = NULL;
	if (m_cursor <= m_data + m_datalen - len) 
	{
		str = m_cursor;
		m_cursor += len;
	}
	return str;
}

_PACKET_DATA NET_Packet::readBinary()
{
	_PACKET_DATA	ret;
	ret.data_len = read16();
	if (m_cursor <= m_data + m_datalen - ret.data_len) 
	{
		ret.ptr_data = m_cursor;
		m_cursor += ret.data_len;
	}
	return ret;
	
}


void NET_Packet::begin()		
{
	m_cursor = m_data + PACKET_CONTENT_POS;
}


void NET_Packet::end()	
{
	if(getLen() < m_cursor-m_data)
	{
		*((uint16*)(m_data + sizeof(NET_PACKET_HEADER))) 
			= ((NET_PACKET_HEADER *) m_data)->len 
			= ntohs(m_cursor-m_data);
	}
}


//void NET_Packet::decrypt(const char *key)
//{
//	int n = m_datalen - sizeof(NET_PACKET_HEADER);
//	if (n > 0) {
//		setkey((char *) key);
//	
//		char *p = m_data + sizeof(NET_PACKET_HEADER);
//		while (n > 0) {
//			dedes(p);
//			p += 8;
//			n -= 8;
//		}
//	}
//}


//void UDP_Packet::setSendto(uint32 uid)
//{
//	m_uid_session	= uid;
//}


int NET_Packet::recv(SOCKET socket)
{
	int len = ::recv(socket, 
						 m_data + m_datalen, 
						 m_max_data_size - m_datalen, 
						 0
						 );
	if (len > 0)
		begin();
	m_datalen += len;
	return len;
}
int NET_Packet::recv_from(TCP_Session* pSession)
{
	int len = ::recv(pSession->get_SOCKET(), 
						 m_data + m_datalen, 
						 m_max_data_size - m_datalen, 
						 0
						 );
	if (len > 0)
		begin();
	m_datalen += len;
	return len;
}

int NET_Packet::send(SOCKET socket)
{
	end();
	return ::send(socket, m_data, m_cursor - m_data, 0);
}

int NET_Packet::send_to(TCP_Session* pSession)
{
	setSID(pSession->getUID());
	setUID(pSession->getUID_opposite());
	end();
	return ::send(pSession->get_SOCKET(), m_data, m_cursor - m_data, 0);
}


int NET_Packet::recv(UDP_Socket* ptr_socket)
{
	if(NULL==ptr_socket)
		return 0;
	socklen_t len = sizeof(m_addr_in);
	int rlen = recvfrom(ptr_socket->get_SOCKET(), 
						 m_data + m_datalen, 
						 m_max_data_size - m_datalen, 
						 0, 
						 (sockaddr *) &m_addr_in, 
						 &len);
	if (rlen > 0)
		begin();
//	if(getCmd()==0 && getUID()==0)
//	{
//	}
	m_datalen	+= rlen;
	return rlen;
}

int NET_Packet::send_to(UDP_Session *ptr_session)
{
	if(NULL==ptr_session || ptr_session->get_UDP_Socket()<=0)
		return 0;
	setSID(ptr_session->getUID());
	setUID(ptr_session->getUID_opposite());
	end();
	int nret = ::sendto(ptr_session->get_UDP_Socket()->get_SOCKET(), 
					  m_data, 
					  m_cursor - m_data, 
					  0, 
					  (sockaddr *) ptr_session->get_sockaddr_in(), 
					  sizeof(sockaddr_in)
					  );
	return nret;
}

int NET_Packet::send_to(uint32 uid, UDP_Socket *ptr_socket)
{
	if(NULL==ptr_socket)
		return 0;
	UDP_Session* ptr_session = ptr_socket->get_UDP_Session(uid);
	if(NULL==ptr_session)
		return 0;
	setSID(uid);
	setUID(ptr_session->getUID_opposite());
	end();
	int nret = ::sendto(ptr_socket->get_SOCKET(), 
					  m_data, 
					  m_cursor - m_data, 
					  0, 
					  (sockaddr *) ptr_session->get_sockaddr_in(), 
					  sizeof(sockaddr_in)
					  );
	return nret;
}

int NET_Packet::send(UDP_Socket *ptr_socket)
{
	if(NULL==ptr_socket)
		return 0;
	UDP_Session* ptr_session = ptr_socket->get_UDP_Session(getSID());
	if(NULL==ptr_session)
		return 0;
	end();
	int nret = ::sendto(ptr_socket->get_SOCKET(), 
					  m_data, 
					  m_cursor - m_data, 
					  0, 
					  (sockaddr *) ptr_session->get_sockaddr_in(), 
					  sizeof(sockaddr_in)
					  );
	return nret;
}


void NET_Packet::setSendto(uint32 uid)
{
	m_uid_sendto	= uid;
}






NET_Packet* NET_Packet::get_cling_packet()
{
	if(m_datalen<=getLen() /*|| m_datalen + PACKET_CONTENT_POS >= m_max_data_size*/)
	{
		return NULL;
	}
//	NET_PACKET_HEADER*	p_head	= (NET_PACKET_HEADER*)(m_data + getLen());
//	if(p_head->ver!=VER_PACKET
//		|| p_head->len<=0
//		|| p_head->len + getLen() >= m_max_data_size)
//	{
//		return NULL;
//	}
	int size_cling = m_datalen - getLen();
	NET_Packet*	pRet	= new NET_Packet;
	memcpy(pRet->m_data, (void*)(m_data + getLen()), size_cling);
	pRet->m_datalen	= size_cling;
	return pRet;

}


bool NET_Packet::is_cling()
{
	if(m_datalen>=sizeof(NET_PACKET_HEADER) && m_datalen>=getLen())
	{
		return true;
	}
	else 
	{
		return false;
	}
}

void NET_Packet::reset()
{
	m_cursor = m_data + PACKET_CONTENT_POS;
	m_uid_sendto	= 0;
	m_datalen		= 0;
	setCmd(NLIBP_NULL);
}

NET_Packet* NET_Packet::clone_packet()
{
	int len = m_cursor - m_data;
	if(len<=PACKET_CONTENT_POS)
		return NULL;
	NET_Packet*		pPacket	= new NET_Packet(len+1);
	memcpy(pPacket->m_data, m_data, len);
	pPacket->m_addr_in	= m_addr_in;
	pPacket->m_datalen	= m_datalen;
	pPacket->m_uid_sendto	= m_uid_sendto;
	pPacket->m_cursor	= pPacket->m_data + len;
	return pPacket;
}