Fix CMSG_CHAR_ENUM

Note: VC80/VC90 need update =)

Signed-off-by: Salja <salja2012@hotmail.de>

src/game/CharacterHandler.cpp

@@ -137,29 +137,109 @@ class CharacterHandler
         }
 } chrHandler;
 
-void WorldSession::HandleCharEnum(QueryResult* result)
+struct charEnumInfo
 {
-    WorldPacket data(SMSG_CHAR_ENUM, 100);                  // we guess size
+    uint8 nameLenghts;
+    bool firstLogin;
+};
 
-    uint8 num = 0;
+void WorldSession::HandleCharEnum(QueryResult * result)
+{
+    WorldPacket data(SMSG_CHAR_ENUM, 270);
 
-    data << num;
+    uint8 charCount = 0;
+    ByteBuffer buffer;
+
+    data.WriteBits(0, 23);
+    data.WriteBit(1);
+    data.WriteBits(result ? (*result).GetRowCount() : 0 , 17);
+
+    std::vector<charEnumInfo> charInfoList;
+    charInfoList.resize(result ? (*result).GetRowCount() : 0);
 
     if (result)
     {
+        typedef std::pair<uint64, uint64> Guids;
+        std::vector<Guids> guidsVect;
+        _allowedCharsToLogin.clear();
+
         do
         {
-            uint32 guidlow = (*result)[0].GetUInt32();
+            uint32 GuidLow = (*result)[0].GetUInt32();
-            DETAIL_LOG("Build enum data for char guid %u from account %u.", guidlow, GetAccountId());
+            uint32 atLoginFlags = (*result)[15].GetUInt32();
-            if (Player::BuildEnumData(result, &data))
+            uint64 GuildGuid = (*result)[13].GetUInt64();
-                ++num;
+
+            charEnumInfo charInfo = charEnumInfo();
+            std::string name = (*result)[1].GetString();
+            uint32 nameLen = name.length();
+            charInfo.nameLenghts =  nameLen;
+            charInfo.firstLogin = atLoginFlags & AT_LOGIN_FIRST ? true : false;
+            charInfoList[charCount] = charInfo;
+            charCount++;
+
+            guidsVect.push_back(std::make_pair(GuidLow, atLoginFlags));
+
+            sLog.outDetail("Loading char guid %u from account %u.", GuidLow, GetAccountId());
+
+            if (!Player::BuildEnumData(result, &buffer))
+            {
+                sLog.outError("Building enum data for SMSG_CHAR_ENUM has failed, aborting");
+                return;
+            }
+            _allowedCharsToLogin.insert(GuidLow);
         }
         while (result->NextRow());
 
-        delete result;
+        int counter = 0;
+        for (std::vector<Guids>::iterator itr = guidsVect.begin(); itr != guidsVect.end(); ++itr)
+        {
+            uint32 Guid = (*itr).first;
+            uint64 GuildGuid = (*itr).second;
+
+            uint8 Guid0 = uint8(Guid);
+            uint8 Guid1 = uint8(Guid >> 8);
+            uint8 Guid2 = uint8(Guid >> 16);
+            uint8 Guid3 = uint8(Guid >> 24);
+
+            for (int i = 0; i < 18; ++i)
+            {
+                switch (i)
+                {
+                    case 14:
+                        data.WriteBit(Guid0 ? 1 : 0);
+                        break;
+                    case 10:
+                        data.WriteBit(Guid1 ? 1 : 0);
+                        break;
+                    case 15:
+                        data.WriteBit(Guid2 ? 1 : 0);
+                        break;
+                    case 0:
+                        data.WriteBit(Guid3 ? 1 : 0);
+                        break;
+                    case 4:
+                        data.WriteBits(charInfoList[counter].nameLenghts, 7);
+                        break;
+                    case 13:
+                        data.WriteBit(charInfoList[counter].firstLogin ? 1 : 0);
+                        break;
+                    default:
+                        data.WriteBit(0);
+                        break;
+                }
             }
 
-    data.put<uint8>(0, num);
+            counter++;
+        }
+
+        data.FlushBits();
+        data.append(buffer);
+    }
+    else
+    {
+        data.WriteBit(1);
+        data.FlushBits();
+    }
 
     SendPacket(&data);
 }

src/game/World.cpp

@@ -247,12 +247,19 @@ World::AddSession_(WorldSession* s)
         return;
     }
 
-    WorldPacket packet(SMSG_AUTH_RESPONSE, 1 + 4 + 1 + 4 + 1);
+    WorldPacket packet(SMSG_AUTH_RESPONSE, 16);
-    packet << uint8(AUTH_OK);
+
+    packet.WriteBit(false);
+    packet.WriteBit(true);
+
+    packet << uint32(0);                                    // Unknown - 4.3.2
+    packet << uint8(s->Expansion());                        // 0 - normal, 1 - TBC, 2 - WotLK, 3 - CT. must be set in database manually for each account
     packet << uint32(0);                                    // BillingTimeRemaining
-    packet << uint8(0);                                     // BillingPlanFlags
+    packet << uint8(s->Expansion());                        // 0 - normal, 1 - TBC, 2 - WotLK, 3 - CT. Must be set in database manually for each account.
     packet << uint32(0);                                    // BillingTimeRested
-    packet << uint8(s->Expansion());                        // 0 - normal, 1 - TBC, 2 - WotLK. Must be set in database manually for each account.
+    packet << uint8(0);                                     // BillingPlanFlags
+    packet << uint8(AUTH_OK);
+
     s->SendPacket(&packet);
 
     s->SendAddonsInfo();
@@ -295,17 +302,24 @@ int32 World::GetQueuedSessionPos(WorldSession* sess)
 void World::AddQueuedSession(WorldSession* sess)
 {
     sess->SetInQueue(true);
-    m_QueuedSessions.push_back(sess);
+    m_QueuedSessions.push_back (sess);
 
     // The 1st SMSG_AUTH_RESPONSE needs to contain other info too.
-    WorldPacket packet(SMSG_AUTH_RESPONSE, 1 + 4 + 1 + 4 + 1 + 4 + 1);
+    WorldPacket packet (SMSG_AUTH_RESPONSE, 21);
-    packet << uint8(AUTH_WAIT_QUEUE);
+
-    packet << uint32(0);                                    // BillingTimeRemaining
+    packet.WriteBit(true);
-    packet << uint8(0);                                     // BillingPlanFlags
+    packet.WriteBit(true);
-    packet << uint32(0);                                    // BillingTimeRested
+
-    packet << uint8(sess->Expansion());                     // 0 - normal, 1 - TBC, must be set in database manually for each account
-    packet << uint32(GetQueuedSessionPos(sess));            // position in queue
     packet << uint8(0);                                     // unk 3.3.0
+    packet << uint32(0);                                    // Unknown - 4.3.2
+    packet << uint8(sess->Expansion());                        // 0 - normal, 1 - TBC, 2 - WotLK, 3 - CT. must be set in database manually for each account
+    packet << uint32(0);                                    // BillingTimeRemaining
+    packet << uint8(sess->Expansion());                        // 0 - normal, 1 - TBC, 2 - WotLK, 3 - CT. Must be set in database manually for each account.
+    packet << uint32(0);                                    // BillingTimeRested
+    packet << uint8(0);                                     // BillingPlanFlags
+    packet << uint8(AUTH_WAIT_QUEUE);
+    packet << uint32(GetQueuedSessionPos(sess));            // position in queue
+
     sess->SendPacket(&packet);
 }
 

src/game/WorldSession.h

@@ -872,6 +872,14 @@ class MANGOS_DLL_SPEC WorldSession
         void LogUnexpectedOpcode(WorldPacket* packet, const char* reason);
         void LogUnprocessedTail(WorldPacket* packet);
 
+        // EnumData helpers
+        bool CharCanLogin(uint32 lowGUID)
+        {
+            return _allowedCharsToLogin.find(lowGUID) != _allowedCharsToLogin.end();
+        }
+
+        std::set<uint64> _allowedCharsToLogin;
+
         uint32 m_GUIDLow;                                   // set logged or recently logout player (while m_playerRecentlyLogout set)
         Player* _player;
         WorldSocket* m_Socket;

src/game/WorldSocket.cpp

@@ -667,7 +667,7 @@ int WorldSocket::ProcessIncoming(WorldPacket* new_pct)
 
     const ACE_UINT16 opcode = new_pct->GetOpcode();
 
-    if (opcode >= NUM_MSG_TYPES)
+    if (opcode >= NUM_MSG_TYPES && opcode != MSG_WOW_CONNECTION)
     {
         sLog.outError("SESSION: received nonexistent opcode 0x%.4X", opcode);
         return -1;

src/shared/ByteBuffer.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2005-2012 MaNGOS <http://getmangos.com/>
+ * Copyright (C) 2005-2011 MaNGOS <http://getmangos.com/>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,95 +17,68 @@
  */
 
 #include "ByteBuffer.h"
-#include "Log.h"
 
-void ByteBufferException::PrintPosError() const
+void BitStream::Clear()
 {
-    char const* traceStr;
+    _data.clear();
-
+    _rpos = _wpos = 0;
-#ifdef HAVE_ACE_STACK_TRACE_H
-    ACE_Stack_Trace trace;
-    traceStr = trace.c_str();
-#else
-    traceStr = NULL;
-#endif
-
-    sLog.outError(
-        "Attempted to %s in ByteBuffer (pos: " SIZEFMTD " size: "SIZEFMTD") "
-        "value with size: " SIZEFMTD "%s%s",
-        (add ? "put" : "get"), pos, size, esize,
-        traceStr ? "\n" : "", traceStr ? traceStr : "");
 }
 
-void ByteBuffer::print_storage() const
+uint8 BitStream::GetBit(uint32 bit)
 {
-    if (!sLog.HasLogLevelOrHigher(LOG_LVL_DEBUG))   // optimize disabled debug output
+    MANGOS_ASSERT(_data.size() > bit);
-        return;
+    return _data[bit];
+}
 
-    std::ostringstream ss;
+uint8 BitStream::ReadBit()
-    ss <<  "STORAGE_SIZE: " << size() << "\n";
+{
+    MANGOS_ASSERT(_data.size() < _rpos);
+    uint8 b = _data[_rpos];
+    ++_rpos;
+    return b;
+}
 
-    if (sLog.IsIncludeTime())
+void BitStream::WriteBit(uint32 bit)
-        ss << "         ";
+{
+    _data.push_back(bit ? uint8(1) : uint8(0));
+    ++_wpos;
+}
 
-    for (size_t i = 0; i < size(); ++i)
+template <typename T> void BitStream::WriteBits(T value, size_t bits)
-        ss << uint32(read<uint8>(i)) << " - ";
+{
+    for (int32 i = bits-1; i >= 0; --i)
+        WriteBit((value >> i) & 1);
+}
+
+bool BitStream::Empty()
+{
+    return _data.empty();
+}
+
+void BitStream::Reverse()
+{
+    uint32 len = GetLength();
+    std::vector<uint8> b = _data;
+    Clear();
+
+    for(uint32 i = len; i > 0; --i)
+        WriteBit(b[i-1]);
+}
+
+void BitStream::Print()
+{
+    std::stringstream ss;
+    ss << "BitStream: ";
+    for (uint32 i = 0; i < GetLength(); ++i)
+        ss << uint32(GetBit(i)) << " ";
 
     sLog.outDebug(ss.str().c_str());
 }
 
-void ByteBuffer::textlike() const
+ByteBuffer::ByteBuffer(size_t res, bool init): _rpos(0), _wpos(0), _bitpos(8), _curbitval(0)
 {
-    if (!sLog.HasLogLevelOrHigher(LOG_LVL_DEBUG))   // optimize disabled debug output
+    if (init)
-        return;
+        _storage.resize(res, 0);
-
+    else
-    std::ostringstream ss;
+        _storage.reserve(res);
-    ss <<  "STORAGE_SIZE: " << size() << "\n";
-
-    if (sLog.IsIncludeTime())
-        ss << "         ";
-
-    for (size_t i = 0; i < size(); ++i)
-        ss << read<uint8>(i);
-
-    sLog.outDebug(ss.str().c_str());
-}
-
-void ByteBuffer::hexlike() const
-{
-    if (!sLog.HasLogLevelOrHigher(LOG_LVL_DEBUG))   // optimize disabled debug output
-        return;
-
-    std::ostringstream ss;
-    ss <<  "STORAGE_SIZE: " << size() << "\n";
-
-    if (sLog.IsIncludeTime())
-        ss << "         ";
-
-    size_t j = 1, k = 1;
-
-    for (size_t i = 0; i < size(); ++i)
-    {
-        if ((i == (j * 8)) && ((i != (k * 16))))
-        {
-            ss << "| ";
-            ++j;
-        }
-        else if (i == (k * 16))
-        {
-            ss << "\n";
-
-            if (sLog.IsIncludeTime())
-                ss << "         ";
-
-            ++k;
-            ++j;
-        }
-
-        char buf[4];
-        snprintf(buf, 4, "%02X", read<uint8>(i));
-        ss << buf << " ";
-    }
-
-    sLog.outDebug(ss.str().c_str());
 }

src/shared/ByteBuffer.h

@@ -20,8 +20,29 @@
 #define _BYTEBUFFER_H
 
 #include "Common.h"
+#include "Log.h"
 #include "Utilities/ByteConverter.h"
 
+#define BITS_1 uint8 _1
+#define BITS_2 BITS_1, uint8 _2
+#define BITS_3 BITS_2, uint8 _3
+#define BITS_4 BITS_3, uint8 _4
+#define BITS_5 BITS_4, uint8 _5
+#define BITS_6 BITS_5, uint8 _6
+#define BITS_7 BITS_6, uint8 _7
+#define BITS_8 BITS_7, uint8 _8
+
+#define BIT_VALS_1 _1
+#define BIT_VALS_2 BIT_VALS_1, _2
+#define BIT_VALS_3 BIT_VALS_2, _3
+#define BIT_VALS_4 BIT_VALS_3, _4
+#define BIT_VALS_5 BIT_VALS_4, _5
+#define BIT_VALS_6 BIT_VALS_5, _6
+#define BIT_VALS_7 BIT_VALS_6, _7
+#define BIT_VALS_8 BIT_VALS_7, _8
+
+class ObjectGuid;
+
 class ByteBufferException
 {
     public:
@@ -31,7 +52,23 @@ class ByteBufferException
             PrintPosError();
         }
 
-        void PrintPosError() const;
+        void PrintPosError() const
+        {
+            char const* traceStr;
+
+#ifdef HAVE_ACE_STACK_TRACE_H
+            ACE_Stack_Trace trace;
+            traceStr = trace.c_str();
+#else
+            traceStr = NULL;
+#endif
+
+            sLog.outError(
+                "Attempted to %s in ByteBuffer (pos: " SIZEFMTD " size: "SIZEFMTD") "
+                "value with size: " SIZEFMTD "%s%s",
+                (add ? "put" : "get"), pos, size, esize,
+                traceStr ? "\n" : "", traceStr ? traceStr : "");
+        }
     private:
         bool add;
         size_t pos;
@@ -39,6 +76,47 @@ class ByteBufferException
         size_t size;
 };
 
+class BitStream
+{
+    public:
+        BitStream(): _rpos(0), _wpos(0) {}
+
+        BitStream(uint32 val, size_t len): _rpos(0), _wpos(0)
+        {
+            WriteBits(val, len);
+        }
+
+        BitStream(BitStream const& bs) : _rpos(bs._rpos), _wpos(bs._wpos), _data(bs._data) {}
+
+        void Clear();
+        uint8 GetBit(uint32 bit);
+        uint8 ReadBit();
+        void WriteBit(uint32 bit);
+        template <typename T> void WriteBits(T value, size_t bits);
+        bool Empty();
+        void Reverse();
+        void Print();
+
+        size_t GetLength() { return _data.size(); }
+        uint32 GetReadPosition() { return _rpos; }
+        uint32 GetWritePosition() { return _wpos; }
+        void SetReadPos(uint32 pos) { _rpos = pos; }
+
+        uint8 const& operator[](uint32 const pos) const
+        {
+            return _data[pos];
+        }
+
+        uint8& operator[] (uint32 const pos)
+        {
+            return _data[pos];
+        }
+
+    private:
+        std::vector<uint8> _data;
+        uint32 _rpos, _wpos;
+};
+
 template<class T>
 struct Unused
 {
@@ -48,22 +126,22 @@ struct Unused
 class ByteBuffer
 {
     public:
-        const static size_t DEFAULT_SIZE = 0x1000;
+        const static size_t DEFAULT_SIZE = 64;
 
         // constructor
-        ByteBuffer(): _rpos(0), _wpos(0)
+        ByteBuffer(): _rpos(0), _wpos(0), _bitpos(8), _curbitval(0)
         {
             _storage.reserve(DEFAULT_SIZE);
         }
 
         // constructor
-        ByteBuffer(size_t res): _rpos(0), _wpos(0)
+        ByteBuffer(size_t res, bool init = false);
-        {
-            _storage.reserve(res);
-        }
 
         // copy constructor
-        ByteBuffer(const ByteBuffer& buf): _rpos(buf._rpos), _wpos(buf._wpos), _storage(buf._storage) { }
+        ByteBuffer(const ByteBuffer &buf) : _rpos(buf._rpos), _wpos(buf._wpos),
+            _storage(buf._storage), _bitpos(buf._bitpos), _curbitval(buf._curbitval)
+        {
+        }
 
         void clear()
         {
@@ -71,156 +149,310 @@ class ByteBuffer
             _rpos = _wpos = 0;
         }
 
+        template <typename T> ByteBuffer& append(T value)
+        {
+            FlushBits();
+            EndianConvert(value);
+            return append((uint8*)&value, sizeof(value));
+        }
+
+        void FlushBits()
+        {
+            if (_bitpos == 8)
+                return;
+
+            append((uint8 *)&_curbitval, sizeof(uint8));
+            _curbitval = 0;
+            _bitpos = 8;
+        }
+
+        template <typename T> bool WriteBit(T bit)
+        {
+            --_bitpos;
+            if (bit)
+                _curbitval |= (1 << (_bitpos));
+
+            if (_bitpos == 0)
+            {
+                _bitpos = 8;
+                append((uint8 *)&_curbitval, sizeof(_curbitval));
+                _curbitval = 0;
+            }
+
+            return (bit != 0);
+        }
+
+        bool ReadBit()
+        {
+            ++_bitpos;
+            if (_bitpos > 7)
+            {
+                _bitpos = 0;
+                _curbitval = read<uint8>();
+            }
+
+            return ((_curbitval >> (7-_bitpos)) & 1) != 0;
+        }
+
+        template <typename T> void WriteBits(T value, size_t bits)
+        {
+            for (int32 i = bits-1; i >= 0; --i)
+                WriteBit((value >> i) & 1);
+        }
+
+        uint32 ReadBits(size_t bits)
+        {
+            uint32 value = 0;
+            for (int32 i = bits-1; i >= 0; --i)
+                if (ReadBit())
+                    value |= (1 << i);
+
+            return value;
+        }
+
+        BitStream ReadBitStream(uint32 len)
+        {
+            BitStream b;
+            for (uint32 i = 0; i < len; ++i)
+                b.WriteBit(ReadBit());
+            return b;
+        }
+
+        void WriteGuidMask(uint64 guid, uint8* maskOrder, uint8 maskCount, uint8 maskPos = 0)
+        {
+            uint8* guidByte = ((uint8*)&guid);
+
+            for (uint8 i = 0; i < maskCount; i++)
+                WriteBit(guidByte[maskOrder[i + maskPos]]);
+        }
+
+        void WriteGuidBytes(uint64 guid, uint8* byteOrder, uint8 byteCount, uint8 bytePos)
+        {
+            uint8* guidByte = ((uint8*)&guid);
+
+            for (uint8 i = 0; i < byteCount; i++)
+                if (guidByte[byteOrder[i + bytePos]])
+                    (*this) << uint8(guidByte[byteOrder[i + bytePos]] ^ 1);
+        }
+
+        template<BITS_1>
+            void ReadGuidMask(ObjectGuid& guid);
+        template<BITS_2>
+            void ReadGuidMask(ObjectGuid& guid);
+        template<BITS_3>
+            void ReadGuidMask(ObjectGuid& guid);
+        template<BITS_4>
+            void ReadGuidMask(ObjectGuid& guid);
+        template<BITS_5>
+            void ReadGuidMask(ObjectGuid& guid);
+        template<BITS_6>
+            void ReadGuidMask(ObjectGuid& guid);
+        template<BITS_7>
+            void ReadGuidMask(ObjectGuid& guid);
+        template<BITS_8>
+            void ReadGuidMask(ObjectGuid& guid);
+
+        template<BITS_1>
+            void WriteGuidMask(ObjectGuid& guid);
+        template<BITS_2>
+            void WriteGuidMask(ObjectGuid& guid);
+        template<BITS_3>
+            void WriteGuidMask(ObjectGuid& guid);
+        template<BITS_4>
+            void WriteGuidMask(ObjectGuid& guid);
+        template<BITS_5>
+            void WriteGuidMask(ObjectGuid& guid);
+        template<BITS_6>
+            void WriteGuidMask(ObjectGuid& guid);
+        template<BITS_7>
+            void WriteGuidMask(ObjectGuid& guid);
+        template<BITS_8>
+            void WriteGuidMask(ObjectGuid& guid);
+
+        template<BITS_1>
+            void ReadGuidBytes(ObjectGuid& guid);
+        template<BITS_2>
+            void ReadGuidBytes(ObjectGuid& guid);
+        template<BITS_3>
+            void ReadGuidBytes(ObjectGuid& guid);
+        template<BITS_4>
+            void ReadGuidBytes(ObjectGuid& guid);
+        template<BITS_5>
+            void ReadGuidBytes(ObjectGuid& guid);
+        template<BITS_6>
+            void ReadGuidBytes(ObjectGuid& guid);
+        template<BITS_7>
+            void ReadGuidBytes(ObjectGuid& guid);
+        template<BITS_8>
+            void ReadGuidBytes(ObjectGuid& guid);
+
+        template<BITS_1>
+            void WriteGuidBytes(ObjectGuid& guid);
+        template<BITS_2>
+            void WriteGuidBytes(ObjectGuid& guid);
+        template<BITS_3>
+            void WriteGuidBytes(ObjectGuid& guid);
+        template<BITS_4>
+            void WriteGuidBytes(ObjectGuid& guid);
+        template<BITS_5>
+            void WriteGuidBytes(ObjectGuid& guid);
+        template<BITS_6>
+            void WriteGuidBytes(ObjectGuid& guid);
+        template<BITS_7>
+            void WriteGuidBytes(ObjectGuid& guid);
+        template<BITS_8>
+            void WriteGuidBytes(ObjectGuid& guid);
+
         template <typename T> void put(size_t pos, T value)
         {
             EndianConvert(value);
-            put(pos, (uint8*)&value, sizeof(value));
+            put(pos, (uint8 *)&value, sizeof(value));
         }
 
-        ByteBuffer& operator<<(uint8 value)
+        ByteBuffer &operator<<(uint8 value)
         {
             append<uint8>(value);
             return *this;
         }
 
-        ByteBuffer& operator<<(uint16 value)
+        ByteBuffer &operator<<(uint16 value)
         {
             append<uint16>(value);
             return *this;
         }
 
-        ByteBuffer& operator<<(uint32 value)
+        ByteBuffer &operator<<(uint32 value)
         {
             append<uint32>(value);
             return *this;
         }
 
-        ByteBuffer& operator<<(uint64 value)
+        ByteBuffer &operator<<(uint64 value)
         {
             append<uint64>(value);
             return *this;
         }
 
         // signed as in 2e complement
-        ByteBuffer& operator<<(int8 value)
+        ByteBuffer &operator<<(int8 value)
         {
             append<int8>(value);
             return *this;
         }
 
-        ByteBuffer& operator<<(int16 value)
+        ByteBuffer &operator<<(int16 value)
         {
             append<int16>(value);
             return *this;
         }
 
-        ByteBuffer& operator<<(int32 value)
+        ByteBuffer &operator<<(int32 value)
         {
             append<int32>(value);
             return *this;
         }
 
-        ByteBuffer& operator<<(int64 value)
+        ByteBuffer &operator<<(int64 value)
         {
             append<int64>(value);
             return *this;
         }
 
         // floating points
-        ByteBuffer& operator<<(float value)
+        ByteBuffer &operator<<(float value)
         {
             append<float>(value);
             return *this;
         }
 
-        ByteBuffer& operator<<(double value)
+        ByteBuffer &operator<<(double value)
         {
             append<double>(value);
             return *this;
         }
 
-        ByteBuffer& operator<<(const std::string& value)
+        ByteBuffer &operator<<(const std::string &value)
         {
-            append((uint8 const*)value.c_str(), value.length());
+            append((uint8 const *)value.c_str(), value.length());
             append((uint8)0);
             return *this;
         }
 
-        ByteBuffer& operator<<(const char* str)
+        ByteBuffer &operator<<(const char *str)
         {
-            append((uint8 const*)str, str ? strlen(str) : 0);
+            append((uint8 const *)str, str ? strlen(str) : 0);
             append((uint8)0);
             return *this;
         }
 
-        ByteBuffer& operator>>(bool& value)
+        ByteBuffer &operator>>(bool &value)
         {
             value = read<char>() > 0 ? true : false;
             return *this;
         }
 
-        ByteBuffer& operator>>(uint8& value)
+        ByteBuffer &operator>>(uint8 &value)
         {
             value = read<uint8>();
             return *this;
         }
 
-        ByteBuffer& operator>>(uint16& value)
+        ByteBuffer &operator>>(uint16 &value)
         {
             value = read<uint16>();
             return *this;
         }
 
-        ByteBuffer& operator>>(uint32& value)
+        ByteBuffer &operator>>(uint32 &value)
         {
             value = read<uint32>();
             return *this;
         }
 
-        ByteBuffer& operator>>(uint64& value)
+        ByteBuffer &operator>>(uint64 &value)
         {
             value = read<uint64>();
             return *this;
         }
 
-        // signed as in 2e complement
+        //signed as in 2e complement
-        ByteBuffer& operator>>(int8& value)
+        ByteBuffer &operator>>(int8 &value)
         {
             value = read<int8>();
             return *this;
         }
 
-        ByteBuffer& operator>>(int16& value)
+        ByteBuffer &operator>>(int16 &value)
         {
             value = read<int16>();
             return *this;
         }
 
-        ByteBuffer& operator>>(int32& value)
+        ByteBuffer &operator>>(int32 &value)
         {
             value = read<int32>();
             return *this;
         }
 
-        ByteBuffer& operator>>(int64& value)
+        ByteBuffer &operator>>(int64 &value)
         {
             value = read<int64>();
             return *this;
         }
 
-        ByteBuffer& operator>>(float& value)
+        ByteBuffer &operator>>(float &value)
         {
             value = read<float>();
             return *this;
         }
 
-        ByteBuffer& operator>>(double& value)
+        ByteBuffer &operator>>(double &value)
         {
             value = read<double>();
             return *this;
         }
 
-        ByteBuffer& operator>>(std::string& value)
+        ByteBuffer &operator>>(std::string& value)
         {
             value.clear();
             while (rpos() < size())                         // prevent crash at wrong string format in packet
@@ -234,16 +466,23 @@ class ByteBuffer
         }
 
         template<class T>
-        ByteBuffer& operator>>(Unused<T> const&)
+        ByteBuffer &operator>>(Unused<T> const&)
         {
-            read_skip<T>();
+            return read_skip<T>();
-            return *this;
         }
 
-
+        uint8& operator[](size_t const pos)
-        uint8 operator[](size_t pos) const
         {
-            return read<uint8>(pos);
+            if (pos >= size())
+                throw ByteBufferException(false, pos, 1, size());
+            return _storage[pos];
+        }
+
+        uint8 const& operator[](size_t const pos) const
+        {
+            if (pos >= size())
+                throw ByteBufferException(false, pos, 1, size());
+            return _storage[pos];
         }
 
         size_t rpos() const { return _rpos; }
@@ -254,6 +493,11 @@ class ByteBuffer
             return _rpos;
         }
 
+        void rfinish()
+        {
+            _rpos = wpos();
+        }
+
         size_t wpos() const { return _wpos; }
 
         size_t wpos(size_t wpos_)
@@ -263,13 +507,19 @@ class ByteBuffer
         }
 
         template<typename T>
-        void read_skip() { read_skip(sizeof(T)); }
+        ByteBuffer& read_skip()
-
-        void read_skip(size_t skip)
         {
-            if (_rpos + skip > size())
+            read_skip(sizeof(T));
+            return *this;
+        }
+
+        ByteBuffer& read_skip(size_t skip)
+        {
+            if(_rpos + skip > size())
                 throw ByteBufferException(false, _rpos, skip, size());
             _rpos += skip;
+
+            return *this;
         }
 
         template <typename T> T read()
@@ -281,19 +531,21 @@ class ByteBuffer
 
         template <typename T> T read(size_t pos) const
         {
-            if (pos + sizeof(T) > size())
+            if(pos + sizeof(T) > size())
                 throw ByteBufferException(false, pos, sizeof(T), size());
             T val = *((T const*)&_storage[pos]);
             EndianConvert(val);
             return val;
         }
 
-        void read(uint8* dest, size_t len)
+        ByteBuffer& read(uint8* dest, size_t len)
         {
-            if (_rpos  + len > size())
+            if(_rpos  + len > size())
                 throw ByteBufferException(false, _rpos, len, size());
             memcpy(dest, &_storage[_rpos], len);
             _rpos += len;
+
+            return *this;
         }
 
         uint64 readPackGUID()
@@ -302,9 +554,9 @@ class ByteBuffer
             uint8 guidmark = 0;
             (*this) >> guidmark;
 
-            for (int i = 0; i < 8; ++i)
+            for(int i = 0; i < 8; ++i)
             {
-                if (guidmark & (uint8(1) << i))
+                if(guidmark & (uint8(1) << i))
                 {
                     uint8 bit;
                     (*this) >> bit;
@@ -315,7 +567,94 @@ class ByteBuffer
             return guid;
         }
 
-        const uint8* contents() const { return &_storage[0]; }
+        uint8 ReadUInt8()
+        {
+            uint8 u = 0;
+            (*this) >> u;
+            return u;
+        }
+
+        uint16 ReadUInt16()
+        {
+            uint16 u = 0;
+            (*this) >> u;
+            return u;
+        }
+
+        uint32 ReadUInt32()
+        {
+            uint32 u = 0;
+            (*this) >> u;
+            return u;
+        }
+
+        uint64 ReadUInt64()
+        {
+            uint64 u = 0;
+            (*this) >> u;
+            return u;
+        }
+
+        int8 ReadInt8()
+        {
+            int8 u = 0;
+            (*this) >> u;
+            return u;
+        }
+
+        int16 ReadInt16()
+        {
+            int16 u = 0;
+            (*this) >> u;
+            return u;
+        }
+
+        int32 ReadInt32()
+        {
+            uint32 u = 0;
+            (*this) >> u;
+            return u;
+        }
+
+        int64 ReadInt64()
+        {
+            int64 u = 0;
+            (*this) >> u;
+            return u;
+        }
+
+        std::string ReadString()
+        {
+            std::string s = 0;
+            (*this) >> s;
+            return s;
+        }
+
+        std::string ReadString(uint32 count)
+        {
+            std::string out;
+            uint32 start = rpos();
+            while (rpos() < size() && rpos() < start + count)       // prevent crash at wrong string format in packet
+                out += read<char>();
+
+            return out;
+        }
+
+        bool ReadBoolean()
+        {
+            uint8 b = 0;
+            (*this) >> b;
+            return b > 0 ? true : false;
+        }
+
+        float ReadSingle()
+        {
+            float f = 0;
+            (*this) >> f;
+            return f;
+        }
+
+        const uint8 *contents() const { return &_storage[0]; }
 
         size_t size() const { return _storage.size(); }
         bool empty() const { return _storage.empty(); }
@@ -333,25 +672,25 @@ class ByteBuffer
                 _storage.reserve(ressize);
         }
 
-        void append(const std::string& str)
+        ByteBuffer& append(const std::string& str)
         {
-            append((uint8 const*)str.c_str(), str.size() + 1);
+            return append((uint8 const*)str.c_str(), str.size() + 1);
         }
 
-        void append(const char* src, size_t cnt)
+        ByteBuffer& append(const char* src, size_t cnt)
         {
-            return append((const uint8*)src, cnt);
+            return append((const uint8 *)src, cnt);
         }
 
-        template<class T> void append(const T* src, size_t cnt)
+        template<class T> ByteBuffer& append(const T* src, size_t cnt)
         {
-            return append((const uint8*)src, cnt * sizeof(T));
+            return append((const uint8 *)src, cnt * sizeof(T));
         }
 
-        void append(const uint8* src, size_t cnt)
+        ByteBuffer& append(const uint8* src, size_t cnt)
         {
             if (!cnt)
-                return;
+                return *this;
 
             MANGOS_ASSERT(size() < 10000000);
 
@@ -359,27 +698,33 @@ class ByteBuffer
                 _storage.resize(_wpos + cnt);
             memcpy(&_storage[_wpos], src, cnt);
             _wpos += cnt;
+
+            return *this;
         }
 
-        void append(const ByteBuffer& buffer)
+        ByteBuffer& append(const ByteBuffer& buffer)
         {
             if (buffer.wpos())
-                append(buffer.contents(), buffer.wpos());
+                return append(buffer.contents(), buffer.wpos());
+
+            return *this;
         }
 
         // can be used in SMSG_MONSTER_MOVE opcode
-        void appendPackXYZ(float x, float y, float z)
+        ByteBuffer& appendPackXYZ(float x, float y, float z)
         {
             uint32 packed = 0;
             packed |= ((int)(x / 0.25f) & 0x7FF);
             packed |= ((int)(y / 0.25f) & 0x7FF) << 11;
             packed |= ((int)(z / 0.25f) & 0x3FF) << 22;
             *this << packed;
+
+            return *this;
         }
 
-        void appendPackGUID(uint64 guid)
+        ByteBuffer& appendPackGUID(uint64 guid)
         {
-            uint8 packGUID[8 + 1];
+            uint8 packGUID[8+1];
             packGUID[0] = 0;
             size_t size = 1;
             for (uint8 i = 0; guid != 0; ++i)
@@ -393,36 +738,92 @@ class ByteBuffer
 
                 guid >>= 8;
             }
-
+            return append(packGUID, size);
-            append(packGUID, size);
         }
 
-        void put(size_t pos, const uint8* src, size_t cnt)
+        void put(size_t pos, const uint8 *src, size_t cnt)
         {
-            if (pos + cnt > size())
+            if(pos + cnt > size())
                 throw ByteBufferException(true, pos, cnt, size());
             memcpy(&_storage[pos], src, cnt);
         }
 
-        void print_storage() const;
+        void print_storage() const
-        void textlike() const;
-        void hexlike() const;
-
-    private:
-        // limited for internal use because can "append" any unexpected type (like pointer and etc) with hard detection problem
-        template <typename T> void append(T value)
         {
-            EndianConvert(value);
+            sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
-            append((uint8*)&value, sizeof(value));
+            for (uint32 i = 0; i < size(); ++i)
+                sLog.outDebug("%u - ", read<uint8>(i) );
+            sLog.outDebug(" ");
+        }
+
+        void textlike() const
+        {
+            sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
+            for (uint32 i = 0; i < size(); ++i)
+                sLog.outDebug("%c", read<uint8>(i) );
+            sLog.outDebug(" ");
+        }
+
+        void hexlike() const
+        {
+            uint32 j = 1, k = 1;
+            sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
+
+            for (uint32 i = 0; i < size(); ++i)
+            {
+                if ((i == (j * 8)) && ((i != (k * 16))))
+                {
+                    if (read<uint8>(i) < 0x10)
+                    {
+                        sLog.outDebug("| 0%X ", read<uint8>(i) );
+                    }
+                    else
+                    {
+                        sLog.outDebug("| %X ", read<uint8>(i) );
+                    }
+                    ++j;
+                }
+                else if (i == (k * 16))
+                {
+                    if (read<uint8>(i) < 0x10)
+                    {
+                        sLog.outDebug("\n");
+
+                        sLog.outDebug("0%X ", read<uint8>(i) );
+                    }
+                    else
+                    {
+                        sLog.outDebug("\n");
+
+                        sLog.outDebug("%X ", read<uint8>(i) );
+                    }
+
+                    ++k;
+                    ++j;
+                }
+                else
+                {
+                    if (read<uint8>(i) < 0x10)
+                    {
+                        sLog.outDebug("0%X ", read<uint8>(i) );
+                    }
+                    else
+                    {
+                        sLog.outDebug("%X ", read<uint8>(i) );
+                    }
+                }
+            }
+            sLog.outDebug("\n");
         }
 
     protected:
-        size_t _rpos, _wpos;
+        size_t _rpos, _wpos, _bitpos;
+        uint8 _curbitval;
         std::vector<uint8> _storage;
 };
 
 template <typename T>
-inline ByteBuffer& operator<<(ByteBuffer& b, std::vector<T> const& v)
+inline ByteBuffer &operator<<(ByteBuffer &b, std::vector<T> v)
 {
     b << (uint32)v.size();
     for (typename std::vector<T>::iterator i = v.begin(); i != v.end(); ++i)
@@ -433,7 +834,7 @@ inline ByteBuffer& operator<<(ByteBuffer& b, std::vector<T> const& v)
 }
 
 template <typename T>
-inline ByteBuffer& operator>>(ByteBuffer& b, std::vector<T>& v)
+inline ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
 {
     uint32 vsize;
     b >> vsize;
@@ -448,7 +849,7 @@ inline ByteBuffer& operator>>(ByteBuffer& b, std::vector<T>& v)
 }
 
 template <typename T>
-inline ByteBuffer& operator<<(ByteBuffer& b, std::list<T> const& v)
+inline ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
 {
     b << (uint32)v.size();
     for (typename std::list<T>::iterator i = v.begin(); i != v.end(); ++i)
@@ -459,7 +860,7 @@ inline ByteBuffer& operator<<(ByteBuffer& b, std::list<T> const& v)
 }
 
 template <typename T>
-inline ByteBuffer& operator>>(ByteBuffer& b, std::list<T>& v)
+inline ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v)
 {
     uint32 vsize;
     b >> vsize;
@@ -474,7 +875,7 @@ inline ByteBuffer& operator>>(ByteBuffer& b, std::list<T>& v)
 }
 
 template <typename K, typename V>
-inline ByteBuffer& operator<<(ByteBuffer& b, std::map<K, V>& m)
+inline ByteBuffer &operator<<(ByteBuffer &b, std::map<K, V> &m)
 {
     b << (uint32)m.size();
     for (typename std::map<K, V>::iterator i = m.begin(); i != m.end(); ++i)
@@ -485,7 +886,7 @@ inline ByteBuffer& operator<<(ByteBuffer& b, std::map<K, V>& m)
 }
 
 template <typename K, typename V>
-inline ByteBuffer& operator>>(ByteBuffer& b, std::map<K, V>& m)
+inline ByteBuffer &operator>>(ByteBuffer &b, std::map<K, V> &m)
 {
     uint32 msize;
     b >> msize;
@@ -500,22 +901,72 @@ inline ByteBuffer& operator>>(ByteBuffer& b, std::map<K, V>& m)
     return b;
 }
 
+// TODO: Make a ByteBuffer.cpp and move all this inlining to it.
+template<> inline std::string ByteBuffer::read<std::string>()
+{
+    std::string tmp;
+    *this >> tmp;
+    return tmp;
+}
+
 template<>
-inline void ByteBuffer::read_skip<char*>()
+inline ByteBuffer& ByteBuffer::read_skip<char*>()
 {
     std::string temp;
     *this >> temp;
+
+    return *this;
 }
 
 template<>
-inline void ByteBuffer::read_skip<char const*>()
+inline ByteBuffer& ByteBuffer::read_skip<char const*>()
 {
-    read_skip<char*>();
+    return read_skip<char*>();
 }
 
 template<>
-inline void ByteBuffer::read_skip<std::string>()
+inline ByteBuffer& ByteBuffer::read_skip<std::string>()
 {
-    read_skip<char*>();
+    return read_skip<char*>();
 }
+
+class BitConverter
+{
+    public:
+        static uint8 ToUInt8(ByteBuffer const& buff, size_t start = 0)
+        {
+            return buff.read<uint8>(start);
+        }
+
+        static uint16 ToUInt16(ByteBuffer const& buff, size_t start = 0)
+        {
+            return buff.read<uint16>(start);
+        }
+
+        static uint32 ToUInt32(ByteBuffer const& buff, size_t start = 0)
+        {
+            return buff.read<uint32>(start);
+        }
+
+        static uint64 ToUInt64(ByteBuffer const& buff, size_t start = 0)
+        {
+            return buff.read<uint64>(start);
+        }
+
+        static int16 ToInt16(ByteBuffer const& buff, size_t start = 0)
+        {
+            return buff.read<int16>(start);
+        }
+
+        static int32 ToInt32(ByteBuffer const& buff, size_t start = 0)
+        {
+            return buff.read<int32>(start);
+        }
+
+        static int64 ToInt64(ByteBuffer const& buff, size_t start = 0)
+        {
+            return buff.read<int64>(start);
+        }
+};
+
 #endif

win/VC100/shared.vcxproj.filters

@@ -87,6 +87,9 @@
     <ClCompile Include="..\..\src\shared\Database\DB2FileLoader.cpp">
       <Filter>Database\DataStores</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\src\shared\ByteBuffer.cpp">
+      <Filter>Util</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\src\shared\Database\Database.h">