serialization: use internal endian conversion functions

These replace our platform-specific mess in favor of c++20 endian detection
via std::endian and internal byteswap functions when necessary.

They no longer rely on autoconf detection.

Author: theuni

configure.ac

@@ -975,7 +975,7 @@ if test "$TARGET_OS" = "darwin"; then
   AX_CHECK_LINK_FLAG([-Wl,-fixup_chains], [HARDENED_LDFLAGS="$HARDENED_LDFLAGS -Wl,-fixup_chains"], [], [$LDFLAG_WERROR])
 fi
 
-AC_CHECK_HEADERS([endian.h sys/endian.h sys/select.h sys/prctl.h sys/sysctl.h vm/vm_param.h sys/vmmeter.h sys/resources.h])
+AC_CHECK_HEADERS([sys/select.h sys/prctl.h sys/sysctl.h vm/vm_param.h sys/vmmeter.h sys/resources.h])
 
 AC_CHECK_DECLS([getifaddrs, freeifaddrs],[CHECK_SOCKET],,
     [#include <sys/types.h>
@@ -990,13 +990,6 @@ AC_CHECK_DECLS([pipe2])
 
 AC_CHECK_FUNCS([timingsafe_bcmp])
 
-AC_CHECK_DECLS([le16toh, le32toh, le64toh, htole16, htole32, htole64, be16toh, be32toh, be64toh, htobe16, htobe32, htobe64],,,
-    [#if HAVE_ENDIAN_H
-                 #include <endian.h>
-                 #elif HAVE_SYS_ENDIAN_H
-                 #include <sys/endian.h>
-                 #endif])
-
 AC_MSG_CHECKING([for __builtin_clzl])
 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ ]], [[
  (void) __builtin_clzl(0);

src/compat/endian.h

@@ -5,237 +5,70 @@
 #ifndef BITCOIN_COMPAT_ENDIAN_H
 #define BITCOIN_COMPAT_ENDIAN_H
 
-#if defined(HAVE_CONFIG_H)
-#include <config/bitcoin-config.h>
-#endif
-
 #include <compat/byteswap.h>
 
+#include <bit>
 #include <cstdint>
 
-#if defined(HAVE_ENDIAN_H)
-#include <endian.h>
-#elif defined(HAVE_SYS_ENDIAN_H)
-#include <sys/endian.h>
-#endif
-
-#ifndef HAVE_CONFIG_H
-// While not technically a supported configuration, defaulting to defining these
-// DECLs when we were compiled without autotools makes it easier for other build
-// systems to build things like libbitcoinconsensus for strange targets.
-#ifdef htobe16
-#define HAVE_DECL_HTOBE16 1
-#endif
-#ifdef htole16
-#define HAVE_DECL_HTOLE16 1
-#endif
-#ifdef be16toh
-#define HAVE_DECL_BE16TOH 1
-#endif
-#ifdef le16toh
-#define HAVE_DECL_LE16TOH 1
-#endif
-
-#ifdef htobe32
-#define HAVE_DECL_HTOBE32 1
-#endif
-#ifdef htole32
-#define HAVE_DECL_HTOLE32 1
-#endif
-#ifdef be32toh
-#define HAVE_DECL_BE32TOH 1
-#endif
-#ifdef le32toh
-#define HAVE_DECL_LE32TOH 1
-#endif
-
-#ifdef htobe64
-#define HAVE_DECL_HTOBE64 1
-#endif
-#ifdef htole64
-#define HAVE_DECL_HTOLE64 1
-#endif
-#ifdef be64toh
-#define HAVE_DECL_BE64TOH 1
-#endif
-#ifdef le64toh
-#define HAVE_DECL_LE64TOH 1
-#endif
-
-#endif // HAVE_CONFIG_H
-
-#if defined(WORDS_BIGENDIAN)
-
-#if HAVE_DECL_HTOBE16 == 0
-inline uint16_t htobe16(uint16_t host_16bits)
-{
-    return host_16bits;
-}
-#endif // HAVE_DECL_HTOBE16
-
-#if HAVE_DECL_HTOLE16 == 0
-inline uint16_t htole16(uint16_t host_16bits)
-{
-    return internal_bswap_16(host_16bits);
-}
-#endif // HAVE_DECL_HTOLE16
-
-#if HAVE_DECL_BE16TOH == 0
-inline uint16_t be16toh(uint16_t big_endian_16bits)
-{
-    return big_endian_16bits;
-}
-#endif // HAVE_DECL_BE16TOH
-
-#if HAVE_DECL_LE16TOH == 0
-inline uint16_t le16toh(uint16_t little_endian_16bits)
-{
-    return internal_bswap_16(little_endian_16bits);
-}
-#endif // HAVE_DECL_LE16TOH
-
-#if HAVE_DECL_HTOBE32 == 0
-inline uint32_t htobe32(uint32_t host_32bits)
-{
-    return host_32bits;
-}
-#endif // HAVE_DECL_HTOBE32
-
-#if HAVE_DECL_HTOLE32 == 0
-inline uint32_t htole32(uint32_t host_32bits)
-{
-    return internal_bswap_32(host_32bits);
-}
-#endif // HAVE_DECL_HTOLE32
-
-#if HAVE_DECL_BE32TOH == 0
-inline uint32_t be32toh(uint32_t big_endian_32bits)
-{
-    return big_endian_32bits;
-}
-#endif // HAVE_DECL_BE32TOH
-
-#if HAVE_DECL_LE32TOH == 0
-inline uint32_t le32toh(uint32_t little_endian_32bits)
+inline BSWAP_CONSTEXPR uint16_t htobe16_internal(uint16_t host_16bits)
 {
-    return internal_bswap_32(little_endian_32bits);
+    if constexpr (std::endian::native == std::endian::little) return internal_bswap_16(host_16bits);
+        else return host_16bits;
 }
-#endif // HAVE_DECL_LE32TOH
-
-#if HAVE_DECL_HTOBE64 == 0
-inline uint64_t htobe64(uint64_t host_64bits)
-{
-    return host_64bits;
-}
-#endif // HAVE_DECL_HTOBE64
-
-#if HAVE_DECL_HTOLE64 == 0
-inline uint64_t htole64(uint64_t host_64bits)
-{
-    return internal_bswap_64(host_64bits);
-}
-#endif // HAVE_DECL_HTOLE64
-
-#if HAVE_DECL_BE64TOH == 0
-inline uint64_t be64toh(uint64_t big_endian_64bits)
-{
-    return big_endian_64bits;
-}
-#endif // HAVE_DECL_BE64TOH
-
-#if HAVE_DECL_LE64TOH == 0
-inline uint64_t le64toh(uint64_t little_endian_64bits)
-{
-    return internal_bswap_64(little_endian_64bits);
-}
-#endif // HAVE_DECL_LE64TOH
-
-#else // WORDS_BIGENDIAN
-
-#if HAVE_DECL_HTOBE16 == 0
-inline uint16_t htobe16(uint16_t host_16bits)
+inline BSWAP_CONSTEXPR uint16_t htole16_internal(uint16_t host_16bits)
 {
-    return internal_bswap_16(host_16bits);
+    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits);
+        else return host_16bits;
 }
-#endif // HAVE_DECL_HTOBE16
-
-#if HAVE_DECL_HTOLE16 == 0
-inline uint16_t htole16(uint16_t host_16bits)
+inline BSWAP_CONSTEXPR uint16_t be16toh_internal(uint16_t big_endian_16bits)
 {
-    return host_16bits;
+    if constexpr (std::endian::native == std::endian::little) return internal_bswap_16(big_endian_16bits);
+        else return big_endian_16bits;
 }
-#endif // HAVE_DECL_HTOLE16
-
-#if HAVE_DECL_BE16TOH == 0
-inline uint16_t be16toh(uint16_t big_endian_16bits)
+inline BSWAP_CONSTEXPR uint16_t le16toh_internal(uint16_t little_endian_16bits)
 {
-    return internal_bswap_16(big_endian_16bits);
+    if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits);
+        else return little_endian_16bits;
 }
-#endif // HAVE_DECL_BE16TOH
-
-#if HAVE_DECL_LE16TOH == 0
-inline uint16_t le16toh(uint16_t little_endian_16bits)
+inline BSWAP_CONSTEXPR uint32_t htobe32_internal(uint32_t host_32bits)
 {
-    return little_endian_16bits;
+    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits);
+        else return host_32bits;
 }
-#endif // HAVE_DECL_LE16TOH
-
-#if HAVE_DECL_HTOBE32 == 0
-inline uint32_t htobe32(uint32_t host_32bits)
-{
-    return internal_bswap_32(host_32bits);
-}
-#endif // HAVE_DECL_HTOBE32
-
-#if HAVE_DECL_HTOLE32 == 0
-inline uint32_t htole32(uint32_t host_32bits)
+inline BSWAP_CONSTEXPR uint32_t htole32_internal(uint32_t host_32bits)
 {
-    return host_32bits;
+    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits);
+        else return host_32bits;
 }
-#endif // HAVE_DECL_HTOLE32
-
-#if HAVE_DECL_BE32TOH == 0
-inline uint32_t be32toh(uint32_t big_endian_32bits)
+inline BSWAP_CONSTEXPR uint32_t be32toh_internal(uint32_t big_endian_32bits)
 {
-    return internal_bswap_32(big_endian_32bits);
+    if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(big_endian_32bits);
+        else return big_endian_32bits;
 }
-#endif // HAVE_DECL_BE32TOH
-
-#if HAVE_DECL_LE32TOH == 0
-inline uint32_t le32toh(uint32_t little_endian_32bits)
+inline BSWAP_CONSTEXPR uint32_t le32toh_internal(uint32_t little_endian_32bits)
 {
-    return little_endian_32bits;
+    if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits);
+        else return little_endian_32bits;
 }
-#endif // HAVE_DECL_LE32TOH
-
-#if HAVE_DECL_HTOBE64 == 0
-inline uint64_t htobe64(uint64_t host_64bits)
+inline BSWAP_CONSTEXPR uint64_t htobe64_internal(uint64_t host_64bits)
 {
-    return internal_bswap_64(host_64bits);
+    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits);
+        else return host_64bits;
 }
-#endif // HAVE_DECL_HTOBE64
-
-#if HAVE_DECL_HTOLE64 == 0
-inline uint64_t htole64(uint64_t host_64bits)
+inline BSWAP_CONSTEXPR uint64_t htole64_internal(uint64_t host_64bits)
 {
-    return host_64bits;
+    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits);
+        else return host_64bits;
 }
-#endif // HAVE_DECL_HTOLE64
-
-#if HAVE_DECL_BE64TOH == 0
-inline uint64_t be64toh(uint64_t big_endian_64bits)
+inline BSWAP_CONSTEXPR uint64_t be64toh_internal(uint64_t big_endian_64bits)
 {
-    return internal_bswap_64(big_endian_64bits);
+    if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(big_endian_64bits);
+        else return big_endian_64bits;
 }
-#endif // HAVE_DECL_BE64TOH
-
-#if HAVE_DECL_LE64TOH == 0
-inline uint64_t le64toh(uint64_t little_endian_64bits)
+inline BSWAP_CONSTEXPR uint64_t le64toh_internal(uint64_t little_endian_64bits)
 {
-    return little_endian_64bits;
+    if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits);
+        else return little_endian_64bits;
 }
-#endif // HAVE_DECL_LE64TOH
-
-#endif // WORDS_BIGENDIAN
 
 #endif // BITCOIN_COMPAT_ENDIAN_H

src/crypto/common.h

@@ -14,71 +14,71 @@ uint16_t static inline ReadLE16(const unsigned char* ptr)
 {
     uint16_t x;
     memcpy(&x, ptr, 2);
-    return le16toh(x);
+    return le16toh_internal(x);
 }
 
 uint32_t static inline ReadLE32(const unsigned char* ptr)
 {
     uint32_t x;
     memcpy(&x, ptr, 4);
-    return le32toh(x);
+    return le32toh_internal(x);
 }
 
 uint64_t static inline ReadLE64(const unsigned char* ptr)
 {
     uint64_t x;
     memcpy(&x, ptr, 8);
-    return le64toh(x);
+    return le64toh_internal(x);
 }
 
 void static inline WriteLE16(unsigned char* ptr, uint16_t x)
 {
-    uint16_t v = htole16(x);
+    uint16_t v = htole16_internal(x);
     memcpy(ptr, &v, 2);
 }
 
 void static inline WriteLE32(unsigned char* ptr, uint32_t x)
 {
-    uint32_t v = htole32(x);
+    uint32_t v = htole32_internal(x);
     memcpy(ptr, &v, 4);
 }
 
 void static inline WriteLE64(unsigned char* ptr, uint64_t x)
 {
-    uint64_t v = htole64(x);
+    uint64_t v = htole64_internal(x);
     memcpy(ptr, &v, 8);
 }
 
 uint16_t static inline ReadBE16(const unsigned char* ptr)
 {
     uint16_t x;
     memcpy(&x, ptr, 2);
-    return be16toh(x);
+    return be16toh_internal(x);
 }
 
 uint32_t static inline ReadBE32(const unsigned char* ptr)
 {
     uint32_t x;
     memcpy(&x, ptr, 4);
-    return be32toh(x);
+    return be32toh_internal(x);
 }
 
 uint64_t static inline ReadBE64(const unsigned char* ptr)
 {
     uint64_t x;
     memcpy(&x, ptr, 8);
-    return be64toh(x);
+    return be64toh_internal(x);
 }
 
 void static inline WriteBE32(unsigned char* ptr, uint32_t x)
 {
-    uint32_t v = htobe32(x);
+    uint32_t v = htobe32_internal(x);
     memcpy(ptr, &v, 4);
 }
 
 void static inline WriteBE64(unsigned char* ptr, uint64_t x)
 {
-    uint64_t v = htobe64(x);
+    uint64_t v = htobe64_internal(x);
     memcpy(ptr, &v, 8);
 }
 

src/i2p.cpp

@@ -392,7 +392,7 @@ Binary Session::MyDestination() const
     }
 
     memcpy(&cert_len, &m_private_key.at(CERT_LEN_POS), sizeof(cert_len));
-    cert_len = be16toh(cert_len);
+    cert_len = be16toh_internal(cert_len);
 
     const size_t dest_len = DEST_LEN_BASE + cert_len;