aboutsummaryrefslogtreecommitdiff
path: root/contrib/epee
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/epee')
-rw-r--r--contrib/epee/include/hex.h65
-rw-r--r--contrib/epee/include/span.h130
-rw-r--r--contrib/epee/include/string_tools.h33
-rw-r--r--contrib/epee/src/CMakeLists.txt2
-rw-r--r--contrib/epee/src/hex.cpp82
-rw-r--r--contrib/epee/src/http_auth.cpp22
6 files changed, 285 insertions, 49 deletions
diff --git a/contrib/epee/include/hex.h b/contrib/epee/include/hex.h
new file mode 100644
index 000000000..f8d6be048
--- /dev/null
+++ b/contrib/epee/include/hex.h
@@ -0,0 +1,65 @@
+// Copyright (c) 2017, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+// of conditions and the following disclaimer in the documentation and/or other
+// materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+// used to endorse or promote products derived from this software without specific
+// prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <iosfwd>
+#include <string>
+
+#include "span.h"
+
+namespace epee
+{
+ struct to_hex
+ {
+ //! \return A std::string containing hex of `src`.
+ static std::string string(const span<const std::uint8_t> src);
+
+ //! \return An array containing hex of `src`.
+ template<std::size_t N>
+ static std::array<char, N * 2> array(const std::array<std::uint8_t, N>& src) noexcept
+ {
+ std::array<char, N * 2> out{{}};
+ static_assert(N <= 128, "keep the stack size down");
+ buffer_unchecked(out.data(), {src.data(), src.size()});
+ return out;
+ }
+
+ //! Append `src` as hex to `out`.
+ static void buffer(std::ostream& out, const span<const std::uint8_t> src);
+
+ //! Append `< + src + >` as hex to `out`.
+ static void formatted(std::ostream& out, const span<const std::uint8_t> src);
+
+ private:
+ //! Write `src` bytes as hex to `out`. `out` must be twice the length
+ static void buffer_unchecked(char* out, const span<const std::uint8_t> src) noexcept;
+ };
+}
diff --git a/contrib/epee/include/span.h b/contrib/epee/include/span.h
new file mode 100644
index 000000000..ea4ba63dd
--- /dev/null
+++ b/contrib/epee/include/span.h
@@ -0,0 +1,130 @@
+// Copyright (c) 2017, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+// of conditions and the following disclaimer in the documentation and/or other
+// materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+// used to endorse or promote products derived from this software without specific
+// prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+
+namespace epee
+{
+ /*!
+ \brief Non-owning sequence of data. Does not deep copy
+
+ Inspired by `gsl::span` and/or `boost::iterator_range`. This class is
+ intended to be used as a parameter type for functions that need to take a
+ writable or read-only sequence of data. Most common cases are `span<char>`
+ and `span<std::uint8_t>`. Using as a class member is only recommended if
+ clearly documented as not doing a deep-copy. C-arrays are easily convertible
+ to this type.
+
+ \note Conversion from C string literal to `span<const char>` will include
+ the NULL-terminator.
+ \note Never allows derived-to-base pointer conversion; an array of derived
+ types is not an array of base types.
+ */
+ template<typename T>
+ class span
+ {
+ /* Supporting class types is tricky - the {ptr,len} constructor will allow
+ derived-to-base conversions. This is NOT desireable because an array of
+ derived types is not an array of base types. It is possible to handle
+ this case, implement when/if needed. */
+ static_assert(!std::is_class<T>(), "no class types are currently allowed");
+ public:
+ using value_type = T;
+ using size_type = std::size_t;
+ using difference_type = std::ptrdiff_t;
+ using pointer = T*;
+ using const_pointer = const T*;
+ using reference = T&;
+ using const_reference = const T&;
+ using iterator = pointer;
+ using const_iterator = const_pointer;
+
+ constexpr span() noexcept : ptr(nullptr), len(0) {}
+ constexpr span(std::nullptr_t) noexcept : span() {}
+
+ constexpr span(T* const src_ptr, const std::size_t count) noexcept
+ : ptr(src_ptr), len(count) {}
+
+ //! Conversion from C-array. Prevents common bugs with sizeof + arrays.
+ template<std::size_t N>
+ constexpr span(T (&src)[N]) noexcept : span(src, N) {}
+
+ constexpr span(const span&) noexcept = default;
+ span& operator=(const span&) noexcept = default;
+
+ constexpr iterator begin() const noexcept { return ptr; }
+ constexpr const_iterator cbegin() const noexcept { return ptr; }
+
+ constexpr iterator end() const noexcept { return begin() + size(); }
+ constexpr const_iterator cend() const noexcept { return cbegin() + size(); }
+
+ constexpr bool empty() const noexcept { return size() == 0; }
+ constexpr pointer data() const noexcept { return ptr; }
+ constexpr std::size_t size() const noexcept { return len; }
+ constexpr std::size_t size_bytes() const noexcept { return size() * sizeof(value_type); }
+
+ private:
+ T* ptr;
+ std::size_t len;
+ };
+
+ //! \return `span<const T::value_type>` from a STL compatible `src`.
+ template<typename T>
+ constexpr span<const typename T::value_type> to_span(const T& src)
+ {
+ // compiler provides diagnostic if size() is not size_t.
+ return {src.data(), src.size()};
+ }
+
+ template<typename T>
+ constexpr bool has_padding() noexcept
+ {
+ return !std::is_pod<T>() || alignof(T) != 1;
+ }
+
+ //! \return Cast data from `src` as `span<const std::uint8_t>`.
+ template<typename T>
+ span<const std::uint8_t> to_byte_span(const span<const T> src) noexcept
+ {
+ static_assert(!has_padding<T>(), "source type may have padding");
+ return {reinterpret_cast<const std::uint8_t*>(src.data()), src.size_bytes()};
+ }
+
+ //! \return `span<const std::uint8_t>` which represents the bytes at `&src`.
+ template<typename T>
+ span<const std::uint8_t> as_byte_span(const T& src) noexcept
+ {
+ static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
+ static_assert(!has_padding<T>(), "source type may have padding");
+ return {reinterpret_cast<const std::uint8_t*>(std::addressof(src)), sizeof(T)};
+ }
+}
diff --git a/contrib/epee/include/string_tools.h b/contrib/epee/include/string_tools.h
index 530000028..67984b9e4 100644
--- a/contrib/epee/include/string_tools.h
+++ b/contrib/epee/include/string_tools.h
@@ -45,6 +45,8 @@
#include <boost/uuid/uuid_io.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
+#include "hex.h"
+#include "span.h"
#include "warnings.h"
@@ -114,33 +116,10 @@ namespace string_tools
return false;
}
}
- //----------------------------------------------------------------------------
- template<class CharT>
- std::basic_string<CharT> buff_to_hex(const std::basic_string<CharT>& s)
- {
- using namespace std;
- basic_stringstream<CharT> hexStream;
- hexStream << hex << noshowbase << setw(2);
-
- for(typename std::basic_string<CharT>::const_iterator it = s.begin(); it != s.end(); it++)
- {
- hexStream << "0x"<< static_cast<unsigned int>(static_cast<unsigned char>(*it)) << " ";
- }
- return hexStream.str();
- }
//----------------------------------------------------------------------------
- template<class CharT>
- std::basic_string<CharT> buff_to_hex_nodelimer(const std::basic_string<CharT>& s)
+ inline std::string buff_to_hex_nodelimer(const std::string& src)
{
- using namespace std;
- basic_stringstream<CharT> hexStream;
- hexStream << hex << noshowbase;
-
- for(typename std::basic_string<CharT>::const_iterator it = s.begin(); it != s.end(); it++)
- {
- hexStream << setw(2) << setfill('0') << static_cast<unsigned int>(static_cast<unsigned char>(*it));
- }
- return hexStream.str();
+ return to_hex::string(to_byte_span(to_span(src)));
}
//----------------------------------------------------------------------------
template<class CharT>
@@ -559,9 +538,7 @@ POP_WARNINGS
std::string pod_to_hex(const t_pod_type& s)
{
static_assert(std::is_pod<t_pod_type>::value, "expected pod type");
- std::string buff;
- buff.assign(reinterpret_cast<const char*>(&s), sizeof(s));
- return buff_to_hex_nodelimer(buff);
+ return to_hex::string(as_byte_span(s));
}
//----------------------------------------------------------------------------
template<class t_pod_type>
diff --git a/contrib/epee/src/CMakeLists.txt b/contrib/epee/src/CMakeLists.txt
index 9db4c46ce..1d5fa0394 100644
--- a/contrib/epee/src/CMakeLists.txt
+++ b/contrib/epee/src/CMakeLists.txt
@@ -26,7 +26,7 @@
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-add_library(epee STATIC http_auth.cpp mlog.cpp string_tools.cpp)
+add_library(epee STATIC hex.cpp http_auth.cpp mlog.cpp string_tools.cpp)
# Build and install libepee if we're building for GUI
if (BUILD_GUI_DEPS)
if(IOS)
diff --git a/contrib/epee/src/hex.cpp b/contrib/epee/src/hex.cpp
new file mode 100644
index 000000000..cfbd3cf87
--- /dev/null
+++ b/contrib/epee/src/hex.cpp
@@ -0,0 +1,82 @@
+// Copyright (c) 2017, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+// of conditions and the following disclaimer in the documentation and/or other
+// materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+// used to endorse or promote products derived from this software without specific
+// prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "hex.h"
+
+#include <iterator>
+#include <limits>
+#include <ostream>
+#include <stdexcept>
+
+namespace epee
+{
+ namespace
+ {
+ template<typename T>
+ void write_hex(T&& out, const span<const std::uint8_t> src)
+ {
+ static constexpr const char hex[] = u8"0123456789abcdef";
+ static_assert(sizeof(hex) == 17, "bad string size");
+ for (const std::uint8_t byte : src)
+ {
+ *out = hex[byte >> 4];
+ ++out;
+ *out = hex[byte & 0x0F];
+ ++out;
+ }
+ }
+ }
+
+ std::string to_hex::string(const span<const std::uint8_t> src)
+ {
+ if (std::numeric_limits<std::size_t>::max() / 2 < src.size())
+ throw std::range_error("hex_view::to_string exceeded maximum size");
+
+ std::string out{};
+ out.resize(src.size() * 2);
+ buffer_unchecked(std::addressof(out[0]), src);
+ return out;
+ }
+
+ void to_hex::buffer(std::ostream& out, const span<const std::uint8_t> src)
+ {
+ write_hex(std::ostreambuf_iterator<char>{out}, src);
+ }
+
+ void to_hex::formatted(std::ostream& out, const span<const std::uint8_t> src)
+ {
+ out.put('<');
+ buffer(out, src);
+ out.put('>');
+ }
+
+ void to_hex::buffer_unchecked(char* out, const span<const std::uint8_t> src) noexcept
+ {
+ return write_hex(out, src);
+ }
+}
diff --git a/contrib/epee/src/http_auth.cpp b/contrib/epee/src/http_auth.cpp
index 5a1c2142a..30e562700 100644
--- a/contrib/epee/src/http_auth.cpp
+++ b/contrib/epee/src/http_auth.cpp
@@ -67,6 +67,7 @@
#include <type_traits>
#include "crypto/crypto.h"
+#include "hex.h"
#include "md5_l.h"
#include "string_coding.h"
@@ -104,25 +105,6 @@ namespace
//// Digest Algorithms
- template<std::size_t N>
- std::array<char, N * 2> to_hex(const std::array<std::uint8_t, N>& digest) noexcept
- {
- static constexpr const char alphabet[] = u8"0123456789abcdef";
- static_assert(sizeof(alphabet) == 17, "bad alphabet size");
-
- // TODO upgrade (improve performance) of to hex in epee string tools
- std::array<char, N * 2> out{{}};
- auto current = out.begin();
- for (const std::uint8_t byte : digest)
- {
- *current = alphabet[byte >> 4];
- ++current;
- *current = alphabet[byte & 0x0F];
- ++current;
- }
- return out;
- }
-
struct md5_
{
static constexpr const boost::string_ref name = ceref(u8"MD5");
@@ -156,7 +138,7 @@ namespace
std::array<std::uint8_t, 16> digest{{}};
md5::MD5Final(digest.data(), std::addressof(ctx));
- return to_hex(digest);
+ return epee::to_hex::array(digest);
}
};
constexpr const boost::string_ref md5_::name;
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-28 01:50:07 +0000