Files
Viano-Core/src/server/game/Server/Packets/PacketUtilities.h
T
2020-01-04 18:32:38 +01:00

193 lines
5.6 KiB
C++

/*
* This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef PacketUtilities_h__
#define PacketUtilities_h__
#include "ByteBuffer.h"
namespace WorldPackets
{
class PacketArrayMaxCapacityException : public ByteBufferException
{
public:
PacketArrayMaxCapacityException(std::size_t requestedSize, std::size_t sizeLimit);
};
/**
* Utility class for automated prevention of loop counter spoofing in client packets
*/
template<typename T, std::size_t N = 1000 /*select a sane default limit*/>
class Array
{
typedef std::vector<T> storage_type;
typedef typename storage_type::value_type value_type;
typedef typename storage_type::size_type size_type;
typedef typename storage_type::reference reference;
typedef typename storage_type::const_reference const_reference;
typedef typename storage_type::iterator iterator;
typedef typename storage_type::const_iterator const_iterator;
public:
Array() : _limit(N) { }
Array(size_type limit) : _limit(limit) { }
iterator begin() { return _storage.begin(); }
const_iterator begin() const { return _storage.begin(); }
iterator end() { return _storage.end(); }
const_iterator end() const { return _storage.end(); }
size_type size() const { return _storage.size(); }
bool empty() const { return _storage.empty(); }
reference operator[](size_type i) { return _storage[i]; }
const_reference operator[](size_type i) const { return _storage[i]; }
void resize(size_type newSize)
{
if (newSize > _limit)
throw PacketArrayMaxCapacityException(newSize, _limit);
_storage.resize(newSize);
}
void reserve(size_type newSize)
{
if (newSize > _limit)
throw PacketArrayMaxCapacityException(newSize, _limit);
_storage.reserve(newSize);
}
void push_back(value_type const& value)
{
if (_storage.size() >= _limit)
throw PacketArrayMaxCapacityException(_storage.size() + 1, _limit);
_storage.push_back(value);
}
void push_back(value_type&& value)
{
if (_storage.size() >= _limit)
throw PacketArrayMaxCapacityException(_storage.size() + 1, _limit);
_storage.push_back(std::forward<value_type>(value));
}
private:
storage_type _storage;
size_type _limit;
};
void CheckCompactArrayMaskOverflow(std::size_t index, std::size_t limit);
template <typename T>
class CompactArray
{
public:
CompactArray() : _mask(0) { }
CompactArray(CompactArray const& right)
: _mask(right._mask), _contents(right._contents) { }
CompactArray(CompactArray&& right)
: _mask(right._mask), _contents(std::move(right._contents))
{
right._mask = 0;
}
CompactArray& operator=(CompactArray const& right)
{
_mask = right._mask;
_contents = right._contents;
return *this;
}
CompactArray& operator=(CompactArray&& right)
{
_mask = right._mask;
right._mask = 0;
_contents = std::move(right._contents);
return *this;
}
uint32 GetMask() const { return _mask; }
T const& operator[](std::size_t index) const { return _contents.at(index); }
std::size_t GetSize() const { return _contents.size(); }
void Insert(std::size_t index, T const& value)
{
CheckCompactArrayMaskOverflow(index, sizeof(_mask) * 8);
_mask |= 1 << index;
if (_contents.size() <= index)
_contents.resize(index + 1);
_contents[index] = value;
}
void Clear()
{
_mask = 0;
_contents.clear();
}
bool operator==(CompactArray const& r) const
{
if (_mask != r._mask)
return false;
return _contents == r._contents;
}
bool operator!=(CompactArray const& r) const { return !(*this == r); }
private:
uint32 _mask;
std::vector<T> _contents;
};
template <typename T>
ByteBuffer& operator<<(ByteBuffer& data, CompactArray<T> const& v)
{
uint32 mask = v.GetMask();
data << uint32(mask);
for (std::size_t i = 0; i < v.GetSize(); ++i)
if (mask & (1 << i))
data << v[i];
return data;
}
template <typename T>
ByteBuffer& operator>>(ByteBuffer& data, CompactArray<T>& v)
{
uint32 mask;
data >> mask;
for (std::size_t index = 0; mask != 0; mask >>= 1, ++index)
if ((mask & 1) != 0)
v.Insert(index, data.read<T>());
return data;
}
}
#endif // PacketUtilities_h__