Merge commit '86cc97e55fe346502462284d2e636a2b3708163e' as 'Sources/OpenVPN3'

Sources/OpenVPN3/openvpn/common/hash.hpp

@@ -0,0 +1,192 @@
+//    OpenVPN -- An application to securely tunnel IP networks
+//               over a single port, with support for SSL/TLS-based
+//               session authentication and key exchange,
+//               packet encryption, packet authentication, and
+//               packet compression.
+//
+//    Copyright (C) 2012-2017 OpenVPN Inc.
+//
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU Affero General Public License Version 3
+//    as published by the Free Software Foundation.
+//
+//    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 Affero General Public License for more details.
+//
+//    You should have received a copy of the GNU Affero General Public License
+//    along with this program in the COPYING file.
+//    If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef OPENVPN_COMMON_HASH_H
+#define OPENVPN_COMMON_HASH_H
+
+#include <string>
+#include <cstdint> // for std::uint32_t, uint64_t
+
+#include <openvpn/common/exception.hpp>
+#include <openvpn/common/size.hpp>
+#include <openvpn/common/hexstr.hpp>
+
+#define OPENVPN_HASH_METHOD(T, meth)			\
+  namespace std {					\
+    template <>						\
+    struct hash<T>					\
+    {							\
+      inline std::size_t operator()(const T& obj) const	\
+      {							\
+        return obj.meth();				\
+      }							\
+    };							\
+  }
+
+#ifdef HAVE_CITYHASH
+
+#ifdef OPENVPN_HASH128_CRC
+#include <citycrc.h>
+#define OPENVPN_HASH128 ::CityHashCrc128WithSeed
+#else
+#include <city.h>
+#define OPENVPN_HASH128 ::CityHash128WithSeed
+#endif
+
+#if SIZE_MAX == 0xFFFFFFFF
+#define HashSizeT Hash32
+#elif SIZE_MAX == 0xFFFFFFFFFFFFFFFF
+#define HashSizeT Hash64
+#else
+#error "Unrecognized SIZE_MAX"
+#endif
+
+namespace openvpn {
+
+  class Hash128
+  {
+  public:
+    Hash128() : hashval(0,0) {}
+
+    void operator()(const void *data, const std::size_t size)
+    {
+      hashval = OPENVPN_HASH128((const char *)data, size, hashval);
+    }
+
+    void operator()(const std::string& str)
+    {
+      (*this)(str.c_str(), str.length());
+    }
+
+    template <typename T>
+    inline void operator()(const T& obj)
+    {
+      static_assert(std::is_pod<T>::value, "Hash128: POD type required");
+      (*this)(&obj, sizeof(obj));
+    }
+
+    std::uint64_t high() const
+    {
+      return hashval.second;
+    }
+
+    std::uint64_t low() const
+    {
+      return hashval.first;
+    }
+
+    std::string to_string() const
+    {
+      return render_hex_number(high()) + render_hex_number(low());
+    }
+
+  private:
+    uint128 hashval;
+  };
+
+  class Hash64
+  {
+  public:
+    Hash64(const std::uint64_t init_hashval=0)
+      : hashval(init_hashval)
+    {
+    }
+
+    void operator()(const void *data, const std::size_t size)
+    {
+      hashval = ::CityHash64WithSeed((const char *)data, size, hashval);
+    }
+
+    void operator()(const std::string& str)
+    {
+      (*this)(str.c_str(), str.length());
+    }
+
+    template <typename T>
+    inline void operator()(const T& obj)
+    {
+      static_assert(std::is_pod<T>::value, "Hash64: POD type required");
+      (*this)(&obj, sizeof(obj));
+    }
+
+    std::uint64_t value() const
+    {
+      return hashval;
+    }
+
+    std::string to_string() const
+    {
+      return render_hex_number(hashval);
+    }
+
+  private:
+    std::uint64_t hashval;
+  };
+
+  class Hash32
+  {
+  public:
+    Hash32(const std::uint32_t init_hashval=0)
+      : hashval(init_hashval)
+    {
+    }
+
+    void operator()(const void *data, const std::size_t size)
+    {
+      hashval = hash_combine(::CityHash32((const char *)data, size), hashval);
+    }
+
+    void operator()(const std::string& str)
+    {
+      (*this)(str.c_str(), str.length());
+    }
+
+    template <typename T>
+    inline void operator()(const T& obj)
+    {
+      static_assert(std::is_pod<T>::value, "Hash64: POD type required");
+      (*this)(&obj, sizeof(obj));
+    }
+
+    std::uint32_t value() const
+    {
+      return hashval;
+    }
+
+    std::string to_string() const
+    {
+      return render_hex_number(hashval);
+    }
+
+  private:
+    static std::uint32_t hash_combine(const std::uint32_t h1,
+				      const std::uint32_t h2)
+    {
+      return h1 ^ (h2 + 0x9e3779b9 + (h1<<6) + (h1>>2));
+    }
+
+    std::uint32_t hashval;
+  };
+
+}
+
+#endif
+#endif