diff options
Diffstat (limited to 'src/server/shared/Packets/ByteBuffer.h')
| -rw-r--r-- | src/server/shared/Packets/ByteBuffer.h | 601 |
1 files changed, 601 insertions, 0 deletions
diff --git a/src/server/shared/Packets/ByteBuffer.h b/src/server/shared/Packets/ByteBuffer.h new file mode 100644 index 00000000000..ba0240fb58b --- /dev/null +++ b/src/server/shared/Packets/ByteBuffer.h @@ -0,0 +1,601 @@ +/* + * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/> + * + * Copyright (C) 2008-2010 Trinity <http://www.trinitycore.org/> + * + * 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 + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _BYTEBUFFER_H +#define _BYTEBUFFER_H + +#include "Common.h" +#include "Errors.h" +#include "Log.h" +#include "Utilities/ByteConverter.h" + +class ByteBufferException +{ + public: + ByteBufferException(bool _add, size_t _pos, size_t _esize, size_t _size) + : add(_add), pos(_pos), esize(_esize), size(_size) + { + PrintPosError(); + } + + void PrintPosError() const + { + sLog.outError("ERROR: Attempted to %s in ByteBuffer (pos: " SIZEFMTD " size: "SIZEFMTD") value with size: " SIZEFMTD, + (add ? "put" : "get"), pos, size, esize); + } + private: + bool add; + size_t pos; + size_t esize; + size_t size; +}; + +class ByteBuffer +{ + public: + const static size_t DEFAULT_SIZE = 0x1000; + + // constructor + ByteBuffer(): _rpos(0), _wpos(0) + { + _storage.reserve(DEFAULT_SIZE); + } + + // constructor + ByteBuffer(size_t res): _rpos(0), _wpos(0) + { + _storage.reserve(res); + } + + // copy constructor + ByteBuffer(const ByteBuffer &buf): _rpos(buf._rpos), _wpos(buf._wpos), _storage(buf._storage) { } + + void clear() + { + _storage.clear(); + _rpos = _wpos = 0; + } + + template <typename T> void append(T value) + { + EndianConvert(value); + append((uint8 *)&value, sizeof(value)); + } + + template <typename T> void put(size_t pos,T value) + { + EndianConvert(value); + put(pos,(uint8 *)&value,sizeof(value)); + } + + ByteBuffer &operator<<(uint8 value) + { + append<uint8>(value); + return *this; + } + + ByteBuffer &operator<<(uint16 value) + { + append<uint16>(value); + return *this; + } + + ByteBuffer &operator<<(uint32 value) + { + append<uint32>(value); + return *this; + } + + ByteBuffer &operator<<(uint64 value) + { + append<uint64>(value); + return *this; + } + + // signed as in 2e complement + ByteBuffer &operator<<(int8 value) + { + append<int8>(value); + return *this; + } + + ByteBuffer &operator<<(int16 value) + { + append<int16>(value); + return *this; + } + + ByteBuffer &operator<<(int32 value) + { + append<int32>(value); + return *this; + } + + ByteBuffer &operator<<(int64 value) + { + append<int64>(value); + return *this; + } + + // floating points + ByteBuffer &operator<<(float value) + { + append<float>(value); + return *this; + } + + ByteBuffer &operator<<(double value) + { + append<double>(value); + return *this; + } + + ByteBuffer &operator<<(const std::string &value) + { + append((uint8 const *)value.c_str(), value.length()); + append((uint8)0); + return *this; + } + + ByteBuffer &operator<<(const char *str) + { + append((uint8 const *)str, str ? strlen(str) : 0); + append((uint8)0); + return *this; + } + + ByteBuffer &operator>>(bool &value) + { + value = read<char>() > 0 ? true : false; + return *this; + } + + ByteBuffer &operator>>(uint8 &value) + { + value = read<uint8>(); + return *this; + } + + ByteBuffer &operator>>(uint16 &value) + { + value = read<uint16>(); + return *this; + } + + ByteBuffer &operator>>(uint32 &value) + { + value = read<uint32>(); + return *this; + } + + ByteBuffer &operator>>(uint64 &value) + { + value = read<uint64>(); + return *this; + } + + //signed as in 2e complement + ByteBuffer &operator>>(int8 &value) + { + value = read<int8>(); + return *this; + } + + ByteBuffer &operator>>(int16 &value) + { + value = read<int16>(); + return *this; + } + + ByteBuffer &operator>>(int32 &value) + { + value = read<int32>(); + return *this; + } + + ByteBuffer &operator>>(int64 &value) + { + value = read<int64>(); + return *this; + } + + ByteBuffer &operator>>(float &value) + { + value = read<float>(); + return *this; + } + + ByteBuffer &operator>>(double &value) + { + value = read<double>(); + return *this; + } + + ByteBuffer &operator>>(std::string& value) + { + value.clear(); + while (rpos() < size()) // prevent crash at wrong string format in packet + { + char c = read<char>(); + if (c == 0) + break; + value += c; + } + return *this; + } + + uint8 operator[](size_t pos) const + { + return read<uint8>(pos); + } + + size_t rpos() const { return _rpos; } + + size_t rpos(size_t rpos_) + { + _rpos = rpos_; + return _rpos; + } + + size_t wpos() const { return _wpos; } + + size_t wpos(size_t wpos_) + { + _wpos = wpos_; + return _wpos; + } + + template<typename T> + void read_skip() { read_skip(sizeof(T)); } + + void read_skip(size_t skip) + { + if(_rpos + skip > size()) + throw ByteBufferException(false, _rpos, skip, size()); + _rpos += skip; + } + + template <typename T> T read() + { + T r = read<T>(_rpos); + _rpos += sizeof(T); + return r; + } + + template <typename T> T read(size_t pos) const + { + 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) + { + if(_rpos + len > size()) + throw ByteBufferException(false, _rpos, len, size()); + memcpy(dest, &_storage[_rpos], len); + _rpos += len; + } + + bool readPackGUID(uint64& guid) + { + if(rpos() + 1 > size()) + return false; + + guid = 0; + + uint8 guidmark = 0; + (*this) >> guidmark; + + for (int i = 0; i < 8; ++i) + { + if(guidmark & (uint8(1) << i)) + { + if(rpos() + 1 > size()) + return false; + + uint8 bit; + (*this) >> bit; + guid |= (uint64(bit) << (i * 8)); + } + } + + return true; + } + + const uint8 *contents() const { return &_storage[0]; } + + size_t size() const { return _storage.size(); } + bool empty() const { return _storage.empty(); } + + void resize(size_t newsize) + { + _storage.resize(newsize); + _rpos = 0; + _wpos = size(); + } + + void reserve(size_t ressize) + { + if (ressize > size()) + _storage.reserve(ressize); + } + + void append(const std::string& str) + { + append((uint8 const*)str.c_str(), str.size() + 1); + } + + void append(const char *src, size_t cnt) + { + return append((const uint8 *)src, cnt); + } + + template<class T> void append(const T *src, size_t cnt) + { + return append((const uint8 *)src, cnt * sizeof(T)); + } + + void append(const uint8 *src, size_t cnt) + { + if (!cnt) + return; + + ASSERT(size() < 10000000); + + if (_storage.size() < _wpos + cnt) + _storage.resize(_wpos + cnt); + memcpy(&_storage[_wpos], src, cnt); + _wpos += cnt; + } + + void append(const ByteBuffer& buffer) + { + if(buffer.wpos()) + append(buffer.contents(), buffer.wpos()); + } + + // can be used in SMSG_MONSTER_MOVE opcode + void 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; + } + + void appendPackGUID(uint64 guid) + { + uint8 packGUID[8+1]; + packGUID[0] = 0; + size_t size = 1; + for(uint8 i = 0;guid != 0;++i) + { + if(guid & 0xFF) + { + packGUID[0] |= uint8(1 << i); + packGUID[size] = uint8(guid & 0xFF); + ++size; + } + + guid >>= 8; + } + append(packGUID, size); + } + + void put(size_t pos, const uint8 *src, size_t cnt) + { + if(pos + cnt > size()) + throw ByteBufferException(true, pos, cnt, size()); + memcpy(&_storage[pos], src, cnt); + } + + void print_storage() const + { + if(!sLog.IsOutDebug()) // optimize disabled debug output + return; + + sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() ); + for (uint32 i = 0; i < size(); ++i) + sLog.outDebugInLine("%u - ", read<uint8>(i) ); + sLog.outDebug(" "); + } + + void textlike() const + { + if(!sLog.IsOutDebug()) // optimize disabled debug output + return; + + sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() ); + for (uint32 i = 0; i < size(); ++i) + sLog.outDebugInLine("%c", read<uint8>(i) ); + sLog.outDebug(" "); + } + + void hexlike() const + { + if(!sLog.IsOutDebug()) // optimize disabled debug output + return; + + 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.outDebugInLine("| 0%X ", read<uint8>(i) ); + } + else + { + sLog.outDebugInLine("| %X ", read<uint8>(i) ); + } + ++j; + } + else if (i == (k * 16)) + { + if (read<uint8>(i) < 0x10) + { + sLog.outDebugInLine("\n"); + + sLog.outDebugInLine("0%X ", read<uint8>(i) ); + } + else + { + sLog.outDebugInLine("\n"); + + sLog.outDebugInLine("%X ", read<uint8>(i) ); + } + + ++k; + ++j; + } + else + { + if (read<uint8>(i) < 0x10) + { + sLog.outDebugInLine("0%X ", read<uint8>(i) ); + } + else + { + sLog.outDebugInLine("%X ", read<uint8>(i) ); + } + } + } + sLog.outDebugInLine("\n"); + } + + protected: + size_t _rpos, _wpos; + std::vector<uint8> _storage; +}; + +template <typename T> +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) + { + b << *i; + } + return b; +} + +template <typename T> +inline ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v) +{ + uint32 vsize; + b >> vsize; + v.clear(); + while(vsize--) + { + T t; + b >> t; + v.push_back(t); + } + return b; +} + +template <typename T> +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) + { + b << *i; + } + return b; +} + +template <typename T> +inline ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v) +{ + uint32 vsize; + b >> vsize; + v.clear(); + while(vsize--) + { + T t; + b >> t; + v.push_back(t); + } + return b; +} + +template <typename K, typename V> +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) + { + b << i->first << i->second; + } + return b; +} + +template <typename K, typename V> +inline ByteBuffer &operator>>(ByteBuffer &b, std::map<K, V> &m) +{ + uint32 msize; + b >> msize; + m.clear(); + while(msize--) + { + K k; + V v; + b >> k >> v; + m.insert(make_pair(k, v)); + } + 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*>() +{ + std::string temp; + *this >> temp; +} + +template<> +inline void ByteBuffer::read_skip<char const*>() +{ + read_skip<char*>(); +} + +template<> +inline void ByteBuffer::read_skip<std::string>() +{ + read_skip<char*>(); +} +#endif + |