src/shared/ByteBuffer.h

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef _BYTEBUFFER_H
  20 #define _BYTEBUFFER_H
  21
  22 #include "Common.h"
  23 #include "Errors.h"
  24 #include "Log.h"
  25 #include "Utilities/ByteConverter.h"
  26
  27 class ByteBufferException
  28 {
  29     public:
  30         ByteBufferException(bool _add, size_t _pos, size_t _esize, size_t _size)
  31             : add(_add), pos(_pos), esize(_esize), size(_size)
  32         {
  33             PrintPosError();
  34         }
  35
  36         void PrintPosError() const
  37         {
  38             sLog.outError("ERROR: Attempted to %s in ByteBuffer (pos: " SIZEFMTD " size: "SIZEFMTD") value with size: " SIZEFMTD,
  39                 (add ? "put" : "get"), pos, size, esize);
  40         }
  41     private:
  42         bool add;
  43         size_t pos;
  44         size_t esize;
  45         size_t size;
  46 };
  47
  48 class ByteBuffer
  49 {
  50     public:
  51         const static size_t DEFAULT_SIZE = 0x1000;
  52
  53         // constructor
  54         ByteBuffer(): _rpos(0), _wpos(0)
  55         {
  56             _storage.reserve(DEFAULT_SIZE);
  57         }
  58
  59         // constructor
  60         ByteBuffer(size_t res): _rpos(0), _wpos(0)
  61         {
  62             _storage.reserve(res);
  63         }
  64
  65         // copy constructor
  66         ByteBuffer(const ByteBuffer &buf): _rpos(buf._rpos), _wpos(buf._wpos), _storage(buf._storage) { }
  67
  68         void clear()
  69         {
  70             _storage.clear();
  71             _rpos = _wpos = 0;
  72         }
  73
  74         template <typename T> void append(T value)
  75         {
  76             EndianConvert(value);
  77             append((uint8 *)&value, sizeof(value));
  78         }
  79
  80         template <typename T> void put(size_t pos,T value)
  81         {
  82             EndianConvert(value);
  83             put(pos,(uint8 *)&value,sizeof(value));
  84         }
  85
  86         ByteBuffer &operator<<(uint8 value)
  87         {
  88             append<uint8>(value);
  89             return *this;
  90         }
  91
  92         ByteBuffer &operator<<(uint16 value)
  93         {
  94             append<uint16>(value);
  95             return *this;
  96         }
  97
  98         ByteBuffer &operator<<(uint32 value)
  99         {
 100             append<uint32>(value);
 101             return *this;
 102         }
 103
 104         ByteBuffer &operator<<(uint64 value)
 105         {
 106             append<uint64>(value);
 107             return *this;
 108         }
 109
 110         // signed as in 2e complement
 111         ByteBuffer &operator<<(int8 value)
 112         {
 113             append<int8>(value);
 114             return *this;
 115         }
 116
 117         ByteBuffer &operator<<(int16 value)
 118         {
 119             append<int16>(value);
 120             return *this;
 121         }
 122
 123         ByteBuffer &operator<<(int32 value)
 124         {
 125             append<int32>(value);
 126             return *this;
 127         }
 128
 129         ByteBuffer &operator<<(int64 value)
 130         {
 131             append<int64>(value);
 132             return *this;
 133         }
 134
 135         // floating points
 136         ByteBuffer &operator<<(float value)
 137         {
 138             append<float>(value);
 139             return *this;
 140         }
 141
 142         ByteBuffer &operator<<(double value)
 143         {
 144             append<double>(value);
 145             return *this;
 146         }
 147
 148         ByteBuffer &operator<<(const std::string &value)
 149         {
 150             append((uint8 const *)value.c_str(), value.length());
 151             append((uint8)0);
 152             return *this;
 153         }
 154
 155         ByteBuffer &operator<<(const char *str)
 156         {
 157             append((uint8 const *)str, str ? strlen(str) : 0);
 158             append((uint8)0);
 159             return *this;
 160         }
 161
 162         ByteBuffer &operator>>(bool &value)
 163         {
 164             value = read<char>() > 0 ? true : false;
 165             return *this;
 166         }
 167
 168         ByteBuffer &operator>>(uint8 &value)
 169         {
 170             value = read<uint8>();
 171             return *this;
 172         }
 173
 174         ByteBuffer &operator>>(uint16 &value)
 175         {
 176             value = read<uint16>();
 177             return *this;
 178         }
 179
 180         ByteBuffer &operator>>(uint32 &value)
 181         {
 182             value = read<uint32>();
 183             return *this;
 184         }
 185
 186         ByteBuffer &operator>>(uint64 &value)
 187         {
 188             value = read<uint64>();
 189             return *this;
 190         }
 191
 192         //signed as in 2e complement
 193         ByteBuffer &operator>>(int8 &value)
 194         {
 195             value = read<int8>();
 196             return *this;
 197         }
 198
 199         ByteBuffer &operator>>(int16 &value)
 200         {
 201             value = read<int16>();
 202             return *this;
 203         }
 204
 205         ByteBuffer &operator>>(int32 &value)
 206         {
 207             value = read<int32>();
 208             return *this;
 209         }
 210
 211         ByteBuffer &operator>>(int64 &value)
 212         {
 213             value = read<int64>();
 214             return *this;
 215         }
 216
 217         ByteBuffer &operator>>(float &value)
 218         {
 219             value = read<float>();
 220             return *this;
 221         }
 222
 223         ByteBuffer &operator>>(double &value)
 224         {
 225             value = read<double>();
 226             return *this;
 227         }
 228
 229         ByteBuffer &operator>>(std::string& value)
 230         {
 231             value.clear();
 232             while (rpos() < size())                         // prevent crash at wrong string format in packet
 233             {
 234                 char c = read<char>();
 235                 if (c == 0)
 236                     break;
 237                 value += c;
 238             }
 239             return *this;
 240         }
 241
 242         uint8 operator[](size_t pos) const
 243         {
 244             return read<uint8>(pos);
 245         }
 246
 247         size_t rpos() const { return _rpos; }
 248
 249         size_t rpos(size_t rpos_)
 250         {
 251             _rpos = rpos_;
 252             return _rpos;
 253         }
 254
 255         size_t wpos() const { return _wpos; }
 256
 257         size_t wpos(size_t wpos_)
 258         {
 259             _wpos = wpos_;
 260             return _wpos;
 261         }
 262
 263         template<typename T>
 264         void read_skip() { read_skip(sizeof(T)); }
 265
 266         void read_skip(size_t skip)
 267         {
 268             if(_rpos + skip > size())
 269                 throw ByteBufferException(false, _rpos, skip, size());
 270             _rpos += skip;
 271         }
 272
 273         template <typename T> T read()
 274         {
 275             T r = read<T>(_rpos);
 276             _rpos += sizeof(T);
 277             return r;
 278         }
 279
 280         template <typename T> T read(size_t pos) const
 281         {
 282             if(pos + sizeof(T) > size())
 283                 throw ByteBufferException(false, pos, sizeof(T), size());
 284             T val = *((T const*)&_storage[pos]);
 285             EndianConvert(val);
 286             return val;
 287         }
 288
 289         void read(uint8 *dest, size_t len)
 290         {
 291             if(_rpos  + len > size())
 292                throw ByteBufferException(false, _rpos, len, size());
 293             memcpy(dest, &_storage[_rpos], len);
 294             _rpos += len;
 295         }
 296
 297         bool readPackGUID(uint64& guid)
 298         {
 299             if(rpos() + 1 > size())
 300                 return false;
 301
 302             guid = 0;
 303
 304             uint8 guidmark = 0;
 305             (*this) >> guidmark;
 306
 307             for(int i = 0; i < 8; ++i)
 308             {
 309                 if(guidmark & (uint8(1) << i))
 310                 {
 311                     if(rpos() + 1 > size())
 312                         return false;
 313
 314                     uint8 bit;
 315                     (*this) >> bit;
 316                     guid |= (uint64(bit) << (i * 8));
 317                 }
 318             }
 319
 320             return true;
 321         }
 322
 323         const uint8 *contents() const { return &_storage[0]; }
 324
 325         size_t size() const { return _storage.size(); }
 326         bool empty() const { return _storage.empty(); }
 327
 328         void resize(size_t newsize)
 329         {
 330             _storage.resize(newsize);
 331             _rpos = 0;
 332             _wpos = size();
 333         }
 334
 335         void reserve(size_t ressize)
 336         {
 337             if (ressize > size())
 338                 _storage.reserve(ressize);
 339         }
 340
 341         void append(const std::string& str)
 342         {
 343             append((uint8 const*)str.c_str(), str.size() + 1);
 344         }
 345
 346         void append(const char *src, size_t cnt)
 347         {
 348             return append((const uint8 *)src, cnt);
 349         }
 350
 351         template<class T> void append(const T *src, size_t cnt)
 352         {
 353             return append((const uint8 *)src, cnt * sizeof(T));
 354         }
 355
 356         void append(const uint8 *src, size_t cnt)
 357         {
 358             if (!cnt)
 359                 return;
 360
 361             ASSERT(size() < 10000000);
 362
 363             if (_storage.size() < _wpos + cnt)
 364                 _storage.resize(_wpos + cnt);
 365             memcpy(&_storage[_wpos], src, cnt);
 366             _wpos += cnt;
 367         }
 368
 369         void append(const ByteBuffer& buffer)
 370         {
 371             if(buffer.wpos())
 372                 append(buffer.contents(), buffer.wpos());
 373         }
 374
 375         // can be used in SMSG_MONSTER_MOVE opcode
 376         void appendPackXYZ(float x, float y, float z)
 377         {
 378             uint32 packed = 0;
 379             packed |= ((int)(x / 0.25f) & 0x7FF);
 380             packed |= ((int)(y / 0.25f) & 0x7FF) << 11;
 381             packed |= ((int)(z / 0.25f) & 0x3FF) << 22;
 382             *this << packed;
 383         }
 384
 385         void appendPackGUID(uint64 guid)
 386         {
 387             if (_storage.size() < _wpos + sizeof(guid) + 1)
 388                 _storage.resize(_wpos + sizeof(guid) + 1);
 389
 390             size_t mask_position = wpos();
 391             *this << uint8(0);
 392             for(uint8 i = 0; i < 8; ++i)
 393             {
 394                 if(guid & 0xFF)
 395                 {
 396                     _storage[mask_position] |= uint8(1 << i);
 397                     *this << uint8(guid & 0xFF);
 398                 }
 399
 400                 guid >>= 8;
 401             }
 402         }
 403
 404         void put(size_t pos, const uint8 *src, size_t cnt)
 405         {
 406             if(pos + cnt > size())
 407                throw ByteBufferException(true, pos, cnt, size());
 408             memcpy(&_storage[pos], src, cnt);
 409         }
 410
 411         void print_storage() const
 412         {
 413             if(!sLog.IsOutDebug())                          // optimize disabled debug output
 414                 return;
 415
 416             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
 417             for(uint32 i = 0; i < size(); ++i)
 418                 sLog.outDebugInLine("%u - ", read<uint8>(i) );
 419             sLog.outDebug(" ");
 420         }
 421
 422         void textlike() const
 423         {
 424             if(!sLog.IsOutDebug())                          // optimize disabled debug output
 425                 return;
 426
 427             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
 428             for(uint32 i = 0; i < size(); ++i)
 429                 sLog.outDebugInLine("%c", read<uint8>(i) );
 430             sLog.outDebug(" ");
 431         }
 432
 433         void hexlike() const
 434         {
 435             if(!sLog.IsOutDebug())                          // optimize disabled debug output
 436                 return;
 437
 438             uint32 j = 1, k = 1;
 439             sLog.outDebug("STORAGE_SIZE: %lu", (unsigned long)size() );
 440
 441             if(sLog.IsIncludeTime())
 442                 sLog.outDebugInLine("         ");
 443
 444             for(uint32 i = 0; i < size(); ++i)
 445             {
 446                 if ((i == (j * 8)) && ((i != (k * 16))))
 447                 {
 448                     if (read<uint8>(i) < 0x10)
 449                     {
 450                         sLog.outDebugInLine("| 0%X ", read<uint8>(i) );
 451                     }
 452                     else
 453                     {
 454                         sLog.outDebugInLine("| %X ", read<uint8>(i) );
 455                     }
 456                     ++j;
 457                 }
 458                 else if (i == (k * 16))
 459                 {
 460                     if (read<uint8>(i) < 0x10)
 461                     {
 462                         sLog.outDebugInLine("\n");
 463                         if(sLog.IsIncludeTime())
 464                             sLog.outDebugInLine("         ");
 465
 466                         sLog.outDebugInLine("0%X ", read<uint8>(i) );
 467                     }
 468                     else
 469                     {
 470                         sLog.outDebugInLine("\n");
 471                         if(sLog.IsIncludeTime())
 472                             sLog.outDebugInLine("         ");
 473
 474                         sLog.outDebugInLine("%X ", read<uint8>(i) );
 475                     }
 476
 477                     ++k;
 478                     ++j;
 479                 }
 480                 else
 481                 {
 482                     if (read<uint8>(i) < 0x10)
 483                     {
 484                         sLog.outDebugInLine("0%X ", read<uint8>(i) );
 485                     }
 486                     else
 487                     {
 488                         sLog.outDebugInLine("%X ", read<uint8>(i) );
 489                     }
 490                 }
 491             }
 492             sLog.outDebugInLine("\n");
 493         }
 494
 495     protected:
 496         size_t _rpos, _wpos;
 497         std::vector<uint8> _storage;
 498 };
 499
 500 template <typename T>
 501 inline ByteBuffer &operator<<(ByteBuffer &b, std::vector<T> v)
 502 {
 503     b << (uint32)v.size();
 504     for (typename std::vector<T>::iterator i = v.begin(); i != v.end(); ++i)
 505     {
 506         b << *i;
 507     }
 508     return b;
 509 }
 510
 511 template <typename T>
 512 inline ByteBuffer &operator>>(ByteBuffer &b, std::vector<T> &v)
 513 {
 514     uint32 vsize;
 515     b >> vsize;
 516     v.clear();
 517     while(vsize--)
 518     {
 519         T t;
 520         b >> t;
 521         v.push_back(t);
 522     }
 523     return b;
 524 }
 525
 526 template <typename T>
 527 inline ByteBuffer &operator<<(ByteBuffer &b, std::list<T> v)
 528 {
 529     b << (uint32)v.size();
 530     for (typename std::list<T>::iterator i = v.begin(); i != v.end(); ++i)
 531     {
 532         b << *i;
 533     }
 534     return b;
 535 }
 536
 537 template <typename T>
 538 inline ByteBuffer &operator>>(ByteBuffer &b, std::list<T> &v)
 539 {
 540     uint32 vsize;
 541     b >> vsize;
 542     v.clear();
 543     while(vsize--)
 544     {
 545         T t;
 546         b >> t;
 547         v.push_back(t);
 548     }
 549     return b;
 550 }
 551
 552 template <typename K, typename V>
 553 inline ByteBuffer &operator<<(ByteBuffer &b, std::map<K, V> &m)
 554 {
 555     b << (uint32)m.size();
 556     for (typename std::map<K, V>::iterator i = m.begin(); i != m.end(); ++i)
 557     {
 558         b << i->first << i->second;
 559     }
 560     return b;
 561 }
 562
 563 template <typename K, typename V>
 564 inline ByteBuffer &operator>>(ByteBuffer &b, std::map<K, V> &m)
 565 {
 566     uint32 msize;
 567     b >> msize;
 568     m.clear();
 569     while(msize--)
 570     {
 571         K k;
 572         V v;
 573         b >> k >> v;
 574         m.insert(make_pair(k, v));
 575     }
 576     return b;
 577 }
 578
 579 template<>
 580 inline void ByteBuffer::read_skip<char*>()
 581 {
 582     std::string temp;
 583     *this >> temp;
 584 }
 585
 586 template<>
 587 inline void ByteBuffer::read_skip<char const*>()
 588 {
 589     read_skip<char*>();
 590 }
 591
 592 template<>
 593 inline void ByteBuffer::read_skip<std::string>()
 594 {
 595     read_skip<char*>();
 596 }
 597 #endif