diff options
Diffstat (limited to 'converter/cNBTData.cpp')
| -rw-r--r-- | converter/cNBTData.cpp | 700 |
1 files changed, 700 insertions, 0 deletions
diff --git a/converter/cNBTData.cpp b/converter/cNBTData.cpp new file mode 100644 index 000000000..9bc25b789 --- /dev/null +++ b/converter/cNBTData.cpp @@ -0,0 +1,700 @@ +#include "cNBTData.h" +#include <string> // memcpy +#include <stdio.h> +#include "zlib.h" +#include <assert.h> + +#ifndef _WIN32 +#include <cstring> +#include <netinet/in.h> +#endif + +#ifdef _WIN32 +#include <WinSock2.h> +#endif + +cNBTData::~cNBTData() +{ + // TODO: Delete all compounds and stuff in it + Clear(); +} + +cNBTData::cNBTData( char* a_Buffer, unsigned int a_BufferSize ) + : cNBTCompound( 0 ) +{ + m_NumUnnamedElements = 0; + for(int i = 0; i < TAG_NumTags; i++) + { + m_ParseFunctions[i] = 0; + } + m_ParseFunctions[TAG_Byte] = &cNBTData::ParseByte; + m_ParseFunctions[TAG_Short] = &cNBTData::ParseShort; + m_ParseFunctions[TAG_Int] = &cNBTData::ParseInt; + m_ParseFunctions[TAG_String] = &cNBTData::ParseString; + m_ParseFunctions[TAG_List] = &cNBTData::ParseList; + m_ParseFunctions[TAG_Compound] = &cNBTData::ParseCompound; + + + m_Buffer = a_Buffer; + m_BufferSize = a_BufferSize; + m_Index = 0; + + m_CurrentCompound = this; + + m_bDecompressed = false; +} + +bool cNBTData::OpenCompound( std::string a_Name ) +{ + cNBTCompound* Compound = GetCompound( a_Name ); + if( Compound ) + { + m_CurrentCompound = Compound; + return true; + } + printf("WARNING: Could not open NBT Compound %s\n", a_Name.c_str() ); + return false; +} + +bool cNBTData::CloseCompound() +{ + if( m_CurrentCompound->GetParentCompound() ) + { + m_CurrentCompound = m_CurrentCompound->GetParentCompound(); + return true; + } + printf("WARNING: Could not close NBT Compound, already at root!\n" ); + return false; +} + +bool cNBTCompound::OpenList( std::string a_Name ) +{ + if( GetList( a_Name ) ) + { + m_CurrentList = GetList( a_Name ); + return true; + } + printf("WARNING: Could not open NBT List %s\n", a_Name.c_str() ); + return false; +} + +bool cNBTCompound::CloseList() +{ + if( m_CurrentList ) + { + m_CurrentList = m_CurrentList->GetParentList(); + return true; + } + printf("WARNING: Could not close NBT List, no list open!\n" ); + return false; +} + +bool cNBTData::OpenList( std::string a_Name ) +{ + return m_CurrentCompound->OpenList( a_Name ); +} + +bool cNBTData::CloseList() +{ + return m_CurrentCompound->CloseList(); +} + +void cNBTData::Compress() +{ + //printf("Before Compress size: %i\n", m_BufferSize ); + const int MAXNBTSIZE = 1024 * 2; + + int ret; + unsigned have; + z_stream strm; + unsigned char* Compressed = new unsigned char[MAXNBTSIZE]; + + /* allocate deflate state */ + strm.zalloc = Z_NULL; + strm.zfree = Z_NULL; + strm.opaque = Z_NULL; + strm.avail_in = m_BufferSize; + strm.avail_out = MAXNBTSIZE; + strm.next_in =(Bytef*)m_Buffer; + strm.next_out = Compressed; + strm.total_in = 0; + strm.total_out = 0; + ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15+MAX_WBITS, 8, Z_DEFAULT_STRATEGY); + if (ret != Z_OK) + { + printf("deflateInit2 returned NOT OK\n"); + return; + } + + + + /* run deflate() on input until output buffer not full, finish + compression if all of source has been read in */ + + ret = deflate(&strm, Z_FULL_FLUSH); /* no bad return value */ + if( ret != Z_OK ) + { + printf("WARNING: deflate returned NOT OK\n"); + } + assert(ret != Z_STREAM_ERROR); /* state not clobbered */ + have = strm.total_out; + + assert(strm.avail_in == 0); /* all input will be used */ + + if( ret != Z_STREAM_END ) + { + //printf("WARNING: Compressing didn't go to end of stream\n"); + } + + if(m_Buffer) + { + delete [] m_Buffer; + m_Buffer = 0; + } + + //printf("Compressed size: %i\n", have ); + + m_BufferSize = have; + m_Buffer = new char[ m_BufferSize ]; + memcpy( m_Buffer, Compressed, m_BufferSize ); + delete Compressed; + + /* clean up and return */ + deflateEnd(&strm); + m_bDecompressed = false; + return; +} + +bool cNBTData::Decompress() +{ + if( m_bDecompressed ) + { + printf("WARNING: Decompress called, while it has already been decompressed\n"); + return false; + } + if( m_BufferSize == 0 ) + { + printf("WARNING: Decompress called, with m_BufferSize of 0\n"); + return false; + } + + //printf("Before Decompress size: %i\n", m_BufferSize ); + + const int MAXNBTSIZE = 1024 * 2; + + int ret; + z_stream strm; + unsigned char* out = new unsigned char[MAXNBTSIZE]; + + /* allocate inflate state */ + strm.zalloc = Z_NULL; + strm.zfree = Z_NULL; + strm.opaque = Z_NULL; + strm.avail_in = Z_NULL; + strm.next_in = Z_NULL; + strm.avail_in = m_BufferSize; + strm.avail_out = Z_NULL; + strm.next_in = (Bytef*)m_Buffer; + strm.next_out = Z_NULL; + strm.avail_out = MAXNBTSIZE; + strm.next_out = out; + strm.total_in = 0; + strm.total_out = 0; + + ret = inflateInit2(&strm, 16+MAX_WBITS); + if (ret != Z_OK) + { + printf("inflateInit2 returned NOT OK\n"); + delete out; + return false; + } + + if( (ret = inflate(&strm, Z_NO_FLUSH)) != Z_STREAM_END) + { + assert(ret != Z_STREAM_ERROR); /* state not clobbered */ + printf("ret != Z_STREAM_END\n"); + } + unsigned UncompressedSize = strm.total_out; //MAXNBTSIZE - strm.avail_out; + + m_Buffer = new char[ UncompressedSize ]; + memcpy( m_Buffer, out, UncompressedSize ); + m_BufferSize = UncompressedSize; + + inflateEnd(&strm); + delete [] out; + + if( ret != Z_STREAM_END ) + { + printf("WARNING: NBT Data received was too big! (More than %i bytes)\n", MAXNBTSIZE); + } + + //printf("Decompressed Size: %i\n", UncompressedSize ); + m_bDecompressed = true; + return (ret == Z_STREAM_END) ? true : false; +} + +void cNBTCompound::AppendShort( std::string & a_Buffer, short a_Value ) +{ + a_Buffer.push_back( (char)((a_Value>>8)&0xff) ); + a_Buffer.push_back( (char)((a_Value)&0xff) ); +} + +void cNBTCompound::AppendInteger( std::string & a_Buffer, int a_Value ) +{ + int NetVal = htonl( a_Value ); + a_Buffer.append( (char*)&NetVal, sizeof( int ) ); +} + +void cNBTCompound::Serialize(std::string & a_Buffer) +{ + //printf("cNBTCompound::Serialize()\n"); + for( CompoundMap::iterator itr = m_Compounds.begin(); itr != m_Compounds.end(); itr++ ) + { + if( itr->second == 0 ) continue; + a_Buffer.push_back( TAG_Compound ); + AppendShort( a_Buffer, (short)itr->first.size() ); + if( itr->first.size() > 0 ) + { + a_Buffer.append( itr->first.c_str(), itr->first.size() ); + } + itr->second->Serialize( a_Buffer ); + a_Buffer.push_back( TAG_End ); + } + + for( ListMap::iterator itr = m_Lists.begin(); itr != m_Lists.end(); itr++ ) + { + if( itr->second == 0 ) continue; + a_Buffer.push_back( TAG_List ); + AppendShort( a_Buffer, (short)itr->first.size() ); + if( itr->first.size() > 0 ) + { + a_Buffer.append( itr->first.c_str(), itr->first.size() ); + } + a_Buffer.push_back( (char)itr->second->GetType() ); + AppendInteger( a_Buffer, itr->second->GetSize() ); + itr->second->Serialize( a_Buffer ); + } + + for( IntegerMap::iterator itr = m_Integers.begin(); itr != m_Integers.end(); itr++ ) + { + a_Buffer.push_back( TAG_Int ); + AppendShort( a_Buffer, (short)itr->first.size() ); + if( itr->first.size() > 0 ) + { + a_Buffer.append( itr->first.c_str(), itr->first.size() ); + } + AppendInteger( a_Buffer, itr->second ); + } + + for( ShortMap::iterator itr = m_Shorts.begin(); itr != m_Shorts.end(); itr++ ) + { + a_Buffer.push_back( TAG_Short ); + AppendShort( a_Buffer, (short)itr->first.size() ); + if( itr->first.size() > 0 ) + { + a_Buffer.append( itr->first.c_str(), itr->first.size() ); + } + AppendShort( a_Buffer, itr->second ); + } + + for( ByteMap::iterator itr = m_Bytes.begin(); itr != m_Bytes.end(); itr++ ) + { + a_Buffer.push_back( TAG_Byte ); + AppendShort( a_Buffer, (short)itr->first.size() ); + if( itr->first.size() > 0 ) + { + a_Buffer.append( itr->first.c_str(), itr->first.size() ); + } + a_Buffer.push_back( itr->second ); + } +} + +void cNBTCompound::PrintData( int a_Depth, std::string a_Name ) +{ + char* Prefix = new char[a_Depth*4+1]; + for(int i = 0; i < a_Depth*4; i++) + Prefix[i] = ' '; + Prefix[ a_Depth*4 ] = 0; + + if( a_Name.size() > 0 ) + printf("%s COMPOUND (%s)\n", Prefix, a_Name.c_str() ); + else + printf("%s COMPOUND\n", Prefix ); + + delete Prefix; + a_Depth++; + Prefix = new char[a_Depth*4]; + for(int i = 0; i < a_Depth*4; i++) + Prefix[i] = ' '; + Prefix[ a_Depth*4-1 ] = 0; + + for( CompoundMap::iterator itr = m_Compounds.begin(); itr != m_Compounds.end(); itr++ ) + { + if( itr->second == 0 ) continue; + itr->second->PrintData( a_Depth, itr->first ); + } + + for( ListMap::iterator itr = m_Lists.begin(); itr != m_Lists.end(); itr++) + { + if( itr->second == 0 ) continue; + itr->second->PrintData( a_Depth, itr->first ); + } + + for( IntegerMap::iterator itr = m_Integers.begin(); itr != m_Integers.end(); itr++ ) + { + printf("%s INTEGER %s (%i)\n", Prefix, itr->first.c_str(), itr->second ); + } + + for( ShortMap::iterator itr = m_Shorts.begin(); itr != m_Shorts.end(); itr++ ) + { + printf("%s SHORT %s (%i)\n", Prefix, itr->first.c_str(), itr->second ); + } + + for( ByteMap::iterator itr = m_Bytes.begin(); itr != m_Bytes.end(); itr++ ) + { + printf("%s BYTE %s (%i)\n", Prefix, itr->first.c_str(), itr->second ); + } + + delete Prefix; +} + +void cNBTData::PrintData() +{ + printf("==== STRUCTURED NBT DATA ====\n"); + m_CurrentCompound->PrintData( 0, " " ); + printf("=============================\n"); +} + +void cNBTData::Serialize() +{ + std::string Buffer; + m_CurrentCompound->Serialize( Buffer ); + + if( m_Buffer ) + delete m_Buffer; + m_Buffer = new char[Buffer.size()]; + memcpy( m_Buffer, Buffer.c_str(), Buffer.size() ); + m_BufferSize = Buffer.size(); + +// for(unsigned int i = 0; i < m_BufferSize; i++) +// { +// printf("%02i %02x %3i %c\n", i, (unsigned char)m_Buffer[i], (unsigned char)m_Buffer[i], m_Buffer[i] ); +// } +} + +void cNBTData::ParseData() +{ + if(!m_bDecompressed) + { + printf("WARNING: ParseData() called while data was not decompressed\n"); + return; + } + + m_Index = 0; +// printf("cNBTData::ParseData()\n"); +// for(unsigned int i = 0; i < m_BufferSize; i++) +// { +// printf("%02i %02x %3i %c\n", i, (unsigned char)m_Buffer[i], (unsigned char)m_Buffer[i], m_Buffer[i] ); +// } + + while( m_Index < m_BufferSize ) + { + ParseTags(); + } +} + +void cNBTData::ParseTags() +{ + if( m_Index < m_BufferSize ) + { + //printf("ParseTags idx:%02i %02x %3i %c\n", m_Index, (unsigned char)m_Buffer[m_Index], (unsigned char)m_Buffer[m_Index], m_Buffer[m_Index] ); + unsigned char Tag = m_Buffer[m_Index]; + if( Tag > 0 && m_ParseFunctions[ Tag ] ) + { + m_Index++; + (*this.*m_ParseFunctions[ Tag ])(true); + } + else if( Tag == TAG_End ) + { + m_Index++; + } + else + { + printf("UNKNOWN TAG %x\n", m_Buffer[m_Index] ); + for(unsigned int i = (m_Index-10 > 0)?m_Index-10:0 ; i < m_Index+10 && i < m_BufferSize; i++) + { + printf("%02i %02x %3i %c\n", i, (unsigned char)m_Buffer[i], (unsigned char)m_Buffer[i], m_Buffer[i] ); + } + m_Index = m_BufferSize; + return; + } + } +} + +void cNBTData::ParseCompound( bool a_bNamed ) +{ + std::string Name; + if( a_bNamed ) Name = ReadName(); + //printf("OPEN COMPOUND: %s\n", Name.c_str() ); + + PutCompound( Name ); + OpenCompound( Name ); + while( m_Index < m_BufferSize && m_Buffer[ m_Index ] != TAG_End ) + { + ParseTags(); + } + CloseCompound(); + //printf("CLOSE COMPOUND\n"); +} + +void cNBTData::ParseList( bool a_bNamed ) +{ + std::string Name; + if( a_bNamed ) Name = ReadName(); + ENUM_TAG TagType = (ENUM_TAG)ReadByte(); + int Length = ReadInt(); + //printf("LIST: %s Type: %02x Length: %i\n", Name.c_str(), TagType, Length ); + +// for(unsigned int i = (m_Index-10 > 0)?m_Index-10:0 ; i < m_Index+10 && i < m_BufferSize; i++) +// { +// printf("%02i %02x %3i %c\n", i, (unsigned char)m_Buffer[i], (unsigned char)m_Buffer[i], m_Buffer[i] ); +// } + + PutList( Name, TagType ); + OpenList( Name ); + for(int i = 0; i < Length && m_Index < m_BufferSize; i++) + { + if( m_ParseFunctions[ TagType ] ) + { + (*this.*m_ParseFunctions[ TagType ] )(false); + m_Index++; + } + } + CloseList(); + +} + +void cNBTData::ParseByte( bool a_bNamed ) +{ + std::string Name; + if( a_bNamed ) Name = ReadName(); + char Value = ReadByte(); + + PutByte( Name, Value ); + + //printf("BYTE: %s %i\n", Name.c_str(), Value ); +} + +void cNBTData::ParseShort( bool a_bNamed ) +{ + std::string Name; + if( a_bNamed ) Name = ReadName(); + short Value = ReadShort(); + + PutShort( Name, Value ); + + //printf("SHORT: %s %i\n", Name.c_str(), Value ); +} + +void cNBTData::ParseInt( bool a_bNamed ) +{ + std::string Name; + if( a_bNamed ) Name = ReadName(); + int Value = ReadInt(); + + PutInteger( Name, Value ); + + //printf("INT: %s %i\n", Name.c_str(), Value ); +} + +void cNBTData::ParseString( bool a_bNamed ) +{ + std::string Name; + if( a_bNamed ) Name = ReadName(); + std::string String = ReadName(); + + PutString( Name, String ); + + //printf("STRING: %s (%s)\n", Name.c_str(), String.c_str() ); +} + +std::string cNBTData::ReadName() +{ + short Length = ReadShort(); + + std::string Name; + if( Length > 0 ) + { + for(int i = 0; i < Length; i++, m_Index++) + { + Name.push_back( m_Buffer[m_Index] ); + } + } + return Name; +} + +char cNBTData::ReadByte() +{ + unsigned char Byte = m_Buffer[ m_Index ]; m_Index++; + return Byte; +} + +short cNBTData::ReadShort() +{ + short Length = 0; + Length |= m_Buffer[ m_Index ] << 8; m_Index++; + Length |= m_Buffer[ m_Index ]; m_Index++; + return Length; +} + +int cNBTData::ReadInt() +{ + int Value = 0; + memcpy( &Value, m_Buffer+m_Index, sizeof(int) ); + m_Index+=sizeof(int); + + return ntohl( Value ); +} + +void cNBTCompound::PutList( std::string Name, ENUM_TAG Type ) +{ + m_Lists[Name] = new cNBTList( m_CurrentList, Type ); +} + +void cNBTCompound::PutCompound( std::string Name ) +{ + if( m_CurrentList ) + { + m_CurrentList->AddToList( new cNBTCompound( this ) ); + } + else + { + m_Compounds[Name] = new cNBTCompound( this ); + } +} + +cNBTCompound* cNBTCompound::GetCompound( std::string Name ) +{ + if( m_CurrentList ) + { + if( m_CurrentList->GetType() != TAG_Compound ) + return 0; + + return (cNBTCompound*)m_CurrentList->GetLastElement(); + } + return m_Compounds[Name]; +} + +void cNBTList::PrintData(int a_Depth, std::string a_Name) +{ + char* Prefix = new char[a_Depth*4]; + for(int i = 0; i < a_Depth*4; i++) + Prefix[i] = ' '; + Prefix[ a_Depth*4-1 ] = 0; + + if( a_Name.size() > 0 ) + printf("%s LIST (%s)\n", Prefix, a_Name.c_str() ); + else + printf("%s LIST\n", Prefix ); + + delete [] Prefix; + + for( VoidList::iterator itr = m_List.begin(); itr != m_List.end(); itr++) + { + switch( m_Type ) + { + case cNBTCompound::TAG_Compound: + { + ((cNBTCompound*)*itr)->PrintData(a_Depth+1, "..."); + } + break; + default: + break; + } + } +} + +void cNBTList::Serialize(std::string & a_Buffer) +{ + for( VoidList::iterator itr = m_List.begin(); itr != m_List.end(); itr++ ) + { + switch( m_Type ) + { + case cNBTCompound::TAG_Compound: + { + ((cNBTCompound*)(*itr))->Serialize( a_Buffer ); + a_Buffer.push_back( cNBTCompound::TAG_End ); + } + break; + default: + break; + } + } +} + +void cNBTData::Clear() +{ + while( m_CurrentCompound != this ) CloseCompound(); + m_CurrentCompound->Clear(); + + if( m_Buffer ) + { + delete m_Buffer; + m_Buffer = 0; + } + m_BufferSize = 0; +} + +void cNBTCompound::Clear() +{ + for( CompoundMap::iterator itr = m_Compounds.begin(); itr != m_Compounds.end(); itr++ ) + { + if( itr->second == 0 ) continue; + itr->second->Clear(); + delete itr->second; + itr->second = 0; + } + m_Compounds.clear(); + + for( ListMap::iterator itr = m_Lists.begin(); itr != m_Lists.end(); itr++ ) + { + if( itr->second == 0 ) continue; + itr->second->Clear(); + delete itr->second; + itr->second = 0; + } + m_Lists.clear(); + m_Bytes.clear(); + m_Shorts.clear(); + m_Integers.clear(); + m_Strings.clear(); +} + +void cNBTList::Clear() +{ + for( VoidList::iterator itr = m_List.begin(); itr != m_List.end(); itr++) + { + switch( m_Type ) + { + case cNBTCompound::TAG_Compound: + { + cNBTCompound* Compound = (cNBTCompound*)(*itr); + Compound->Clear(); + delete Compound; + *itr = 0; + } + break; + case cNBTCompound::TAG_List: + { + cNBTList* List = (cNBTList*)(*itr); + List->Clear(); + delete List; + *itr = 0; + } + break; + default: + break; + } + } + m_List.clear(); +} |