packets.cpp

另外一款开放源码的高质量p2p源码软件

	}

	specialtag = in.specialtag;
}

STag::~STag()
{
	delete[] tagname;
	if (type == TAGTYPE_STRING)
		delete[] stringvalue;
	if (type == TAGTYPE_HASH)
		delete[] pData;
}


///////////////////////////////////////////////////////////////////////////////
// CTag

CTag::CTag(LPCSTR name, uint32 intvalue)
{
	tag.type = TAGTYPE_UINT32;
	tag.tagname = nstrdup(name);
	tag.intvalue = intvalue;
}

CTag::CTag(uint8 special, uint32 intvalue)
{
	tag.type = TAGTYPE_UINT32;
	tag.specialtag = special;
	tag.intvalue = intvalue;
}

CTag::CTag(LPCSTR name, LPCSTR strvalue)
{
	tag.type = TAGTYPE_STRING;
	tag.tagname = nstrdup(name);
	tag.stringvalue = nstrdup(strvalue);
}

CTag::CTag(uint8 special, LPCSTR strvalue)
{
	tag.type = TAGTYPE_STRING;
	tag.specialtag = special;
	tag.stringvalue = nstrdup(strvalue);
}

CTag::CTag(uint8 uName, const BYTE* pucHash)
{
	tag.type = TAGTYPE_HASH;
	tag.specialtag = uName;
	tag.pData = new BYTE[16];
	md4cpy(tag.pData, pucHash);
}

CTag::CTag(const STag& in_tag)
	: tag(in_tag)
{
}

CTag::CTag(CFileDataIO* data)
{
	tag.type = data->ReadUInt8();
	if (tag.type & 0x80)
	{
		tag.type &= 0x7F;
		tag.specialtag = data->ReadUInt8();
	}
	else
	{
		UINT length = data->ReadUInt16();
		if (length == 1)
			tag.specialtag = data->ReadUInt8();
		else
		{
			tag.tagname = new char[length+1];
			data->Read(tag.tagname,length);
			tag.tagname[length] = '\0';
		}
	}

	// NOTE: It's very important that we read the *entire* packet data, even if we do
	// not use each tag. Otherwise we will get troubles when the packets are returned in 
	// a list - like the search results from a server.
	if (tag.type == TAGTYPE_STRING)
	{
		UINT length = data->ReadUInt16();
		tag.stringvalue = new char[length+1];
		data->Read(tag.stringvalue, length);
		tag.stringvalue[length] = '\0';
	}
	else if (tag.type == TAGTYPE_UINT32)
	{
		tag.intvalue = data->ReadUInt32();
	}
	else if (tag.type == TAGTYPE_UINT16)
	{
		tag.intvalue = data->ReadUInt16();
		tag.type = TAGTYPE_UINT32;
	}
	else if (tag.type == TAGTYPE_UINT8)
	{
		tag.intvalue = data->ReadUInt8();
		tag.type = TAGTYPE_UINT32;
	}
	else if (tag.type == TAGTYPE_FLOAT32)
	{
		data->Read(&tag.floatvalue, 4);
	}
	else if (tag.type >= TAGTYPE_STR1 && tag.type <= TAGTYPE_STR16)
	{
		UINT length = tag.type - TAGTYPE_STR1 + 1;
		tag.stringvalue = new char[length+1];
		data->Read(tag.stringvalue, length);
		tag.stringvalue[length] = '\0';
		tag.type = TAGTYPE_STRING;
	}
	else if (tag.type == TAGTYPE_HASH)
	{
		tag.pData = new BYTE[16];
		data->Read(tag.pData, 16);
	}
	else if (tag.type == TAGTYPE_BOOL)
	{
		TRACE("***NOTE: %s; Reading BOOL tag\n", __FUNCTION__);
		data->Seek(1, CFile::current);
	}
	else if (tag.type == TAGTYPE_BOOLARRAY)
	{
		TRACE("***NOTE: %s; Reading BOOL Array tag\n", __FUNCTION__);
		uint16 len;
		data->Read(&len, 2);
		// 07-Apr-2004: eMule versions prior to 0.42e.29 used the formula "(len+7)/8"!
		data->Seek((len/8)+1, CFile::current);
	}
	else if (tag.type == TAGTYPE_BLOB) // (never seen; <len> <byte>)
	{
		TRACE("***NOTE: %s; Reading BLOB tag\n", __FUNCTION__);
		uint32 len;
		// 07-Apr-2004: eMule versions prior to 0.42e.29 handled the "len" as int16!
		data->Read(&len,4);
		data->Seek(len, CFile::current);
	}
	else
	{
		if (tag.specialtag != 0)
			TRACE("%s; Unknown tag: type=0x%02X  specialtag=%u\n", __FUNCTION__, tag.type, tag.specialtag);
		else
			TRACE("%s; Unknown tag: type=0x%02X  name=\"%s\"\n", __FUNCTION__, tag.type, tag.tagname);
	}
}

CTag::~CTag()
{
}

bool CTag::WriteNewEd2kTag(CFileDataIO* data) const
{
	ASSERT( tag.type != 0 );

	// Write tag type
	UINT uTagStrValLen = 0;
	uint8 uTagType;
	if (IsInt())
	{
		if (tag.intvalue <= 0xFF)
			uTagType = TAGTYPE_UINT8;
		else if (tag.intvalue <= 0xFFFF)
			uTagType = TAGTYPE_UINT16;
		else
			uTagType = TAGTYPE_UINT32;
	}
	else if (IsStr())
	{
		uTagStrValLen = strlen(tag.stringvalue);
		if (uTagStrValLen >= 1 && uTagStrValLen <= 16)
			uTagType = TAGTYPE_STR1 + uTagStrValLen - 1;
		else
			uTagType = TAGTYPE_STRING;
	}
	else
		uTagType = tag.type;

	// Write tag name
	if (tag.tagname)
	{
		data->WriteUInt8(uTagType);
		UINT uTagNameLen = strlen(tag.tagname);
		data->WriteUInt16(uTagNameLen);
		data->Write(tag.tagname, uTagNameLen);
	}
	else
	{
		ASSERT( tag.specialtag != 0 );
		data->WriteUInt8(uTagType | 0x80);
		data->WriteUInt8(tag.specialtag);
	}

	// Write tag data
	if (uTagType == TAGTYPE_STRING)
	{
		data->WriteUInt16(uTagStrValLen);
		data->Write(tag.stringvalue, uTagStrValLen);
	}
	else if (uTagType >= TAGTYPE_STR1 && uTagType <= TAGTYPE_STR16)
	{
		data->Write(tag.stringvalue, uTagStrValLen);
	}
	else if (uTagType == TAGTYPE_UINT32)
	{
		data->WriteUInt32(tag.intvalue);
	}
	else if (uTagType == TAGTYPE_UINT16)
	{
		data->WriteUInt16(tag.intvalue);
	}
	else if (uTagType == TAGTYPE_UINT8)
	{
		data->WriteUInt8(tag.intvalue);
	}
	else if (uTagType == TAGTYPE_FLOAT32)
	{
		data->Write(&tag.floatvalue, 4);
	}
	else if (uTagType == TAGTYPE_HASH)
	{
		data->WriteHash16(tag.pData);
	}
	else
	{
		TRACE("%s; Unknown tag: type=0x%02X\n", __FUNCTION__, uTagType);
		ASSERT(0);
		return false;
	}

	return true;
}

bool CTag::WriteTagToFile(CFileDataIO* file) const
{
	// don't write tags of unknown types, we wouldn't be able to read them in again 
	// and the met file would be corrupted
	if (tag.type == TAGTYPE_STRING || tag.type == TAGTYPE_UINT32 || tag.type == TAGTYPE_FLOAT32)
	{
		file->WriteUInt8(tag.type);
		
		if (tag.tagname)
		{
			UINT taglen = strlen(tag.tagname);
			file->WriteUInt16(taglen);
			file->Write(tag.tagname, taglen);
		}
		else
		{
			file->WriteUInt16(1);
			file->WriteUInt8(tag.specialtag);
		}

		if (tag.type == TAGTYPE_STRING)
		{
			UINT len = strlen(tag.stringvalue);
			file->WriteUInt16(len);
			file->Write(tag.stringvalue,len);
		}
		else if (tag.type == TAGTYPE_UINT32)
			file->WriteUInt32(tag.intvalue);
		else if (tag.type == TAGTYPE_FLOAT32)
			file->Write(&tag.floatvalue, 4);
		//TODO: Support more tag types
		else
		{
			TRACE("%s; Unknown tag: type=0x%02X\n", __FUNCTION__, tag.type);
			ASSERT(0);
			return false;
		}
		return true;
	}
	else
	{
		TRACE("%s; Ignored tag with unknown type=0x%02X\n", __FUNCTION__, tag.type);
		ASSERT(0);
		return false;
	}
}

CString CTag::GetFullInfo() const
{
	CString strTag;
	if (tag.tagname)
	{
		strTag = _T('\"');
		strTag += tag.tagname;
		strTag += _T('\"');
	}
	else
	{
		strTag.Format(_T("0x%02X"), tag.specialtag);
	}
	strTag += _T("=");
	if (tag.type == TAGTYPE_STRING)
	{
		strTag += _T("\"");
		strTag += tag.stringvalue;
		strTag += _T("\"");
	}
	else if (tag.type >= TAGTYPE_STR1 && tag.type <= TAGTYPE_STR16)
	{
		strTag.AppendFormat(_T("(Str%u)\"%s\""), tag.type - TAGTYPE_STR1 + 1, tag.stringvalue);
	}
	else if (tag.type == TAGTYPE_UINT32)
	{
		strTag.AppendFormat(_T("(Int32)%u"), tag.intvalue);
	}
	else if (tag.type == TAGTYPE_UINT16)
	{
		strTag.AppendFormat(_T("(Int16)%u"), tag.intvalue);
	}
	else if (tag.type == TAGTYPE_UINT8)
	{
		strTag.AppendFormat(_T("(Int8)%u"), tag.intvalue);
	}
	else if (tag.type == TAGTYPE_FLOAT32)
	{
		strTag.AppendFormat(_T("(Float32)%f"), tag.floatvalue);
	}
	else
	{
		strTag.AppendFormat(_T("Type=%u"), tag.type);
	}
	return strTag;
}

CString CTag::GetStr() const
{
	CString str;
	if (IsStr() && tag.stringvalue != NULL)
	{
			str = tag.stringvalue;
	}
	return str;
}