aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--dep/CMakeLists.txt1
-rw-r--r--dep/PackageList.txt4
-rw-r--r--dep/short_alloc/CMakeLists.txt15
-rw-r--r--dep/short_alloc/short_alloc/short_alloc.h162
-rw-r--r--src/common/CMakeLists.txt3
-rw-r--r--src/server/game/Server/Packets/PacketUtilities.cpp12
-rw-r--r--src/server/game/Server/Packets/PacketUtilities.h169
7 files changed, 244 insertions, 122 deletions
diff --git a/dep/CMakeLists.txt b/dep/CMakeLists.txt
index a87f460ed95..71fa48710ce 100644
--- a/dep/CMakeLists.txt
+++ b/dep/CMakeLists.txt
@@ -29,6 +29,7 @@ if(SERVERS)
add_subdirectory(readline)
add_subdirectory(gsoap)
add_subdirectory(efsw)
+ add_subdirectory(short_alloc)
endif()
if(TOOLS)
diff --git a/dep/PackageList.txt b/dep/PackageList.txt
index e4b2ece30b2..026578d952c 100644
--- a/dep/PackageList.txt
+++ b/dep/PackageList.txt
@@ -72,3 +72,7 @@ argon2
catch2
https://github.com/catchorg/Catch2
Version: v2.13.0
+
+short_alloc (Stack based allocator) https://howardhinnant.github.io/stack_alloc.html
+ https://howardhinnant.github.io/short_alloc.h
+ Version: N/A
diff --git a/dep/short_alloc/CMakeLists.txt b/dep/short_alloc/CMakeLists.txt
new file mode 100644
index 00000000000..fc6ae3941b7
--- /dev/null
+++ b/dep/short_alloc/CMakeLists.txt
@@ -0,0 +1,15 @@
+# This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+#
+# This file is free software; as a special exception the author gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+add_library(short_alloc INTERFACE)
+
+target_include_directories(short_alloc
+ INTERFACE
+ ${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/dep/short_alloc/short_alloc/short_alloc.h b/dep/short_alloc/short_alloc/short_alloc.h
new file mode 100644
index 00000000000..eb8d02c7917
--- /dev/null
+++ b/dep/short_alloc/short_alloc/short_alloc.h
@@ -0,0 +1,162 @@
+#ifndef SHORT_ALLOC_H
+#define SHORT_ALLOC_H
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+
+namespace short_alloc
+{
+template <std::size_t N, std::size_t alignment = alignof(std::max_align_t)>
+class arena
+{
+ alignas(alignment) char buf_[N];
+ char* ptr_;
+
+public:
+ ~arena() {ptr_ = nullptr;}
+ arena() noexcept : ptr_(buf_) {}
+ arena(const arena&) = delete;
+ arena& operator=(const arena&) = delete;
+
+ template <std::size_t ReqAlign> char* allocate(std::size_t n);
+ void deallocate(char* p, std::size_t n) noexcept;
+
+ static constexpr std::size_t size() noexcept {return N;}
+ std::size_t used() const noexcept {return static_cast<std::size_t>(ptr_ - buf_);}
+ void reset() noexcept {ptr_ = buf_;}
+
+private:
+ static
+ std::size_t
+ align_up(std::size_t n) noexcept
+ {return (n + (alignment-1)) & ~(alignment-1);}
+
+ bool
+ pointer_in_buffer(char* p) noexcept
+ {
+ return std::uintptr_t(buf_) <= std::uintptr_t(p) &&
+ std::uintptr_t(p) <= std::uintptr_t(buf_) + N;
+ }
+};
+
+template <std::size_t N, std::size_t alignment>
+template <std::size_t ReqAlign>
+char*
+arena<N, alignment>::allocate(std::size_t n)
+{
+ static_assert(ReqAlign <= alignment, "alignment is too small for this arena");
+ assert(pointer_in_buffer(ptr_) && "short_alloc has outlived arena");
+ auto const aligned_n = align_up(n);
+ if (static_cast<decltype(aligned_n)>(buf_ + N - ptr_) >= aligned_n)
+ {
+ char* r = ptr_;
+ ptr_ += aligned_n;
+ return r;
+ }
+
+ static_assert(alignment <= alignof(std::max_align_t), "you've chosen an "
+ "alignment that is larger than alignof(std::max_align_t), and "
+ "cannot be guaranteed by normal operator new");
+ return static_cast<char*>(::operator new(n));
+}
+
+template <std::size_t N, std::size_t alignment>
+void
+arena<N, alignment>::deallocate(char* p, std::size_t n) noexcept
+{
+ assert(pointer_in_buffer(ptr_) && "short_alloc has outlived arena");
+ if (pointer_in_buffer(p))
+ {
+ n = align_up(n);
+ if (p + n == ptr_)
+ ptr_ = p;
+ }
+ else
+ ::operator delete(p);
+}
+
+template <class T, std::size_t N, std::size_t Align = alignof(std::max_align_t)>
+class short_alloc
+{
+public:
+ using value_type = T;
+ static auto constexpr alignment = Align;
+ static auto constexpr size = N;
+ using arena_type = arena<size, alignment>;
+
+private:
+ arena_type& a_;
+
+public:
+ short_alloc(const short_alloc&) = default;
+ short_alloc& operator=(const short_alloc&) = delete;
+
+ short_alloc(arena_type& a) noexcept : a_(a)
+ {
+ static_assert(size % alignment == 0,
+ "size N needs to be a multiple of alignment Align");
+ }
+ template <class U>
+ short_alloc(const short_alloc<U, N, alignment>& a) noexcept
+ : a_(a.a_) {}
+
+ template <class _Up> struct rebind {using other = short_alloc<_Up, N, alignment>;};
+
+ T* allocate(std::size_t n)
+ {
+ return reinterpret_cast<T*>(a_.template allocate<alignof(T)>(n*sizeof(T)));
+ }
+ void deallocate(T* p, std::size_t n) noexcept
+ {
+ a_.deallocate(reinterpret_cast<char*>(p), n*sizeof(T));
+ }
+
+ template <class T1, std::size_t N1, std::size_t A1,
+ class U, std::size_t M, std::size_t A2>
+ friend
+ bool
+ operator==(const short_alloc<T1, N1, A1>& x, const short_alloc<U, M, A2>& y) noexcept;
+
+ template <class U, std::size_t M, std::size_t A> friend class short_alloc;
+};
+
+template <class T, std::size_t N, std::size_t A1, class U, std::size_t M, std::size_t A2>
+inline
+bool
+operator==(const short_alloc<T, N, A1>& x, const short_alloc<U, M, A2>& y) noexcept
+{
+ return N == M && A1 == A2 && &x.a_ == &y.a_;
+}
+
+template <class T, std::size_t N, std::size_t A1, class U, std::size_t M, std::size_t A2>
+inline
+bool
+operator!=(const short_alloc<T, N, A1>& x, const short_alloc<U, M, A2>& y) noexcept
+{
+ return !(x == y);
+}
+}
+#endif // SHORT_ALLOC_H
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 5258258a7c6..67d0d663c73 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -72,7 +72,8 @@ target_link_libraries(common
openssl
valgrind
threads
- jemalloc)
+ jemalloc
+ short_alloc)
add_dependencies(common revision_data.h)
diff --git a/src/server/game/Server/Packets/PacketUtilities.cpp b/src/server/game/Server/Packets/PacketUtilities.cpp
index 862c643013c..fe7487daaee 100644
--- a/src/server/game/Server/Packets/PacketUtilities.cpp
+++ b/src/server/game/Server/Packets/PacketUtilities.cpp
@@ -17,10 +17,7 @@
#include "PacketUtilities.h"
#include "Hyperlinks.h"
-#include "Errors.h"
#include <utf8.h>
-#include <sstream>
-#include <array>
WorldPackets::InvalidStringValueException::InvalidStringValueException(std::string const& value) : ByteBufferInvalidValueException("string", value.c_str())
{
@@ -61,12 +58,5 @@ bool WorldPackets::Strings::NoHyperlinks::Validate(std::string const& value)
WorldPackets::PacketArrayMaxCapacityException::PacketArrayMaxCapacityException(std::size_t requestedSize, std::size_t sizeLimit)
{
- std::ostringstream builder;
- builder << "Attempted to read more array elements from packet " << requestedSize << " than allowed " << sizeLimit;
- message().assign(builder.str());
-}
-
-void WorldPackets::CheckCompactArrayMaskOverflow(std::size_t index, std::size_t limit)
-{
- ASSERT(index < limit, "Attempted to insert " SZFMTD " values into CompactArray but it can only hold " SZFMTD, index, limit);
+ message().assign("Attempted to read more array elements from packet " + Trinity::ToString(requestedSize) + " than allowed " + Trinity::ToString(sizeLimit));
}
diff --git a/src/server/game/Server/Packets/PacketUtilities.h b/src/server/game/Server/Packets/PacketUtilities.h
index 0c06be5ea71..8b05803bb2b 100644
--- a/src/server/game/Server/Packets/PacketUtilities.h
+++ b/src/server/game/Server/Packets/PacketUtilities.h
@@ -20,6 +20,7 @@
#include "ByteBuffer.h"
#include "Tuples.h"
+#include <short_alloc/short_alloc.h>
#include <string_view>
namespace WorldPackets
@@ -114,21 +115,49 @@ namespace WorldPackets
/**
* 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*/>
+ template<typename T, std::size_t N>
class Array
{
- typedef std::vector<T> storage_type;
+ public:
+ using allocator_type = short_alloc::short_alloc<T, (N * sizeof(T) + (alignof(std::max_align_t) - 1)) & ~(alignof(std::max_align_t) - 1)>;
+ using arena_type = typename allocator_type::arena_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;
+ using storage_type = std::vector<T, allocator_type>;
- public:
- Array() : _limit(N) { }
- Array(size_type limit) : _limit(limit) { }
+ using max_capacity = std::integral_constant<std::size_t, N>;
+
+ using value_type = typename storage_type::value_type;
+ using size_type = typename storage_type::size_type;
+ using pointer = typename storage_type::pointer;
+ using const_pointer = typename storage_type::const_pointer;
+ using reference = typename storage_type::reference;
+ using const_reference = typename storage_type::const_reference;
+ using iterator = typename storage_type::iterator;
+ using const_iterator = typename storage_type::const_iterator;
+
+ Array() : _storage(_data) { }
+
+ Array(Array const& other) : Array()
+ {
+ for (T const& element : other)
+ _storage.push_back(element);
+ }
+
+ Array(Array&& other) noexcept = delete;
+
+ Array& operator=(Array const& other)
+ {
+ if (this == &other)
+ return *this;
+
+ _storage.clear();
+ for (T const& element : other)
+ _storage.push_back(element);
+
+ return *this;
+ }
+
+ Array& operator=(Array&& other) noexcept = delete;
iterator begin() { return _storage.begin(); }
const_iterator begin() const { return _storage.begin(); }
@@ -136,6 +165,9 @@ namespace WorldPackets
iterator end() { return _storage.end(); }
const_iterator end() const { return _storage.end(); }
+ pointer data() { return _storage.data(); }
+ const_pointer data() const { return _storage.data(); }
+
size_type size() const { return _storage.size(); }
bool empty() const { return _storage.empty(); }
@@ -144,132 +176,49 @@ namespace WorldPackets
void resize(size_type newSize)
{
- if (newSize > _limit)
- throw PacketArrayMaxCapacityException(newSize, _limit);
+ if (newSize > max_capacity::value)
+ throw PacketArrayMaxCapacityException(newSize, max_capacity::value);
_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);
+ if (_storage.size() >= max_capacity::value)
+ throw PacketArrayMaxCapacityException(_storage.size() + 1, max_capacity::value);
_storage.push_back(value);
}
void push_back(value_type&& value)
{
- if (_storage.size() >= _limit)
- throw PacketArrayMaxCapacityException(_storage.size() + 1, _limit);
+ if (_storage.size() >= max_capacity::value)
+ throw PacketArrayMaxCapacityException(_storage.size() + 1, max_capacity::value);
_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)
+ template<typename... Args>
+ T& emplace_back(Args&&... args)
{
- _mask = right._mask;
- right._mask = 0;
- _contents = std::move(right._contents);
- return *this;
+ _storage.emplace_back(std::forward<Args>(args)...);
+ return _storage.back();
}
- 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)
+ iterator erase(const_iterator first, const_iterator last)
{
- CheckCompactArrayMaskOverflow(index, sizeof(_mask) * 8);
-
- _mask |= 1 << index;
- if (_contents.size() <= index)
- _contents.resize(index + 1);
- _contents[index] = value;
+ return _storage.erase(first, last);
}
- void Clear()
+ void clear()
{
- _mask = 0;
- _contents.clear();
+ _storage.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;
+ arena_type _data;
+ storage_type _storage;
};
-
- 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__