AK: Add Endian.h header to replace NetworkOrdered.h.

Author: asynts

AK/Endian.h

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2020, the SerenityOS developers.
+ * 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.
+ *
+ * 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 <AK/Platform.h>
+
+namespace AK {
+
+template<typename T>
+ALWAYS_INLINE T convert_between_host_and_little_endian(T value)
+{
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    return value;
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    if constexpr (sizeof(T) == 8)
+        return __builtin_bswap64(value);
+    if constexpr (sizeof(T) == 4)
+        return __builtin_bswap32(value);
+    if constexpr (sizeof(T) == 2)
+        return __builtin_bswap16(value);
+    if constexpr (sizeof(T) == 1)
+        return value;
+#endif
+}
+
+template<typename T>
+ALWAYS_INLINE T convert_between_host_and_big_endian(T value)
+{
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    if constexpr (sizeof(T) == 8)
+        return __builtin_bswap64(value);
+    if constexpr (sizeof(T) == 4)
+        return __builtin_bswap32(value);
+    if constexpr (sizeof(T) == 2)
+        return __builtin_bswap16(value);
+    if constexpr (sizeof(T) == 1)
+        return value;
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    return value;
+#endif
+}
+
+template<typename T>
+ALWAYS_INLINE T convert_between_host_and_network_endian(T value)
+{
+    return convert_between_host_and_big_endian(value);
+}
+
+template<typename T>
+class [[gnu::packed]] LittleEndian
+{
+public:
+    LittleEndian() { }
+
+    LittleEndian(T value)
+        : m_value(convert_between_host_and_little_endian(value))
+    {
+    }
+
+    operator T() const { return convert_between_host_and_little_endian(m_value); }
+
+private:
+    T m_value { 0 };
+};
+
+template<typename T>
+class [[gnu::packed]] BigEndian
+{
+public:
+    BigEndian() { }
+
+    BigEndian(T value)
+        : m_value(convert_between_host_and_big_endian(value))
+    {
+    }
+
+    operator T() const { return convert_between_host_and_big_endian(m_value); }
+
+private:
+    T m_value { 0 };
+};
+
+template<typename T>
+using NetworkOrdered = BigEndian<T>;
+
+}
+
+using AK::BigEndian;
+using AK::LittleEndian;
+using AK::NetworkOrdered;

AK/IPv4Address.h

@@ -26,8 +26,8 @@
 
 #pragma once
 
+#include <AK/Endian.h>
 #include <AK/LogStream.h>
-#include <AK/NetworkOrdered.h>
 #include <AK/Optional.h>
 #include <AK/String.h>
 #include <AK/StringView.h>
@@ -106,7 +106,6 @@ class [[gnu::packed]] IPv4Address
             return {};
         }
 
-
         if (a > 255 || b > 255 || c > 255 || d > 255)
             return {};
         return IPv4Address((u8)a, (u8)b, (u8)c, (u8)d);

AK/NetworkOrdered.h

@@ -37,17 +37,17 @@
 #define ARCH(arch) (defined(AK_ARCH_##arch) && AK_ARCH_##arch)
 
 #ifdef ALWAYS_INLINE
-#undef ALWAYS_INLINE
+#    undef ALWAYS_INLINE
 #endif
 #define ALWAYS_INLINE [[gnu::always_inline]] inline
 
 #ifdef NEVER_INLINE
-#undef NEVER_INLINE
+#    undef NEVER_INLINE
 #endif
 #define NEVER_INLINE [[gnu::noinline]]
 
 #ifdef FLATTEN
-#undef FLATTEN
+#    undef FLATTEN
 #endif
 #define FLATTEN [[gnu::flatten]]
 
@@ -71,33 +71,16 @@ inline int open_with_path_length(const char* path, size_t path_length, int optio
 }
 #endif
 
-template<typename T>
-ALWAYS_INLINE T convert_between_host_and_network(T value)
-{
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    if constexpr (sizeof(T) == 8)
-        return __builtin_bswap64(value);
-    if constexpr (sizeof(T) == 4)
-        return __builtin_bswap32(value);
-    if constexpr (sizeof(T) == 2)
-        return __builtin_bswap16(value);
-    if constexpr (sizeof(T) == 1)
-        return value;
-#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-    return value;
-#endif
-}
-
 ALWAYS_INLINE int count_trailing_zeroes_32(unsigned int val)
 {
 #if defined(__GNUC__) || defined(__clang__)
-        return __builtin_ctz(val);
+    return __builtin_ctz(val);
 #else
-        for (u8 i = 0; i < 32; ++i) {
-            if ((val >> i) & 1) {
-                return i;
-            }
+    for (u8 i = 0; i < 32; ++i) {
+        if ((val >> i) & 1) {
+            return i;
         }
-        return 0;
+    }
+    return 0;
 #endif
 }

AK/Platform.h

@@ -28,6 +28,7 @@
 
 #include <AK/ByteBuffer.h>
 #include <AK/Concepts.h>
+#include <AK/Endian.h>
 #include <AK/Forward.h>
 #include <AK/MemMem.h>
 #include <AK/Span.h>
@@ -74,6 +75,35 @@ class DuplexStream
     , public OutputStream {
 };
 
+template<typename T>
+InputStream& operator>>(InputStream& stream, LittleEndian<T>& value)
+{
+    T temporary;
+    stream >> temporary;
+    value = temporary;
+    return stream;
+}
+template<typename T>
+InputStream& operator<<(InputStream& stream, LittleEndian<T> value)
+{
+    stream << static_cast<T>(value);
+    return stream;
+}
+template<typename T>
+InputStream& operator>>(InputStream& stream, BigEndian<T>& value)
+{
+    T temporary;
+    stream >> temporary;
+    value = temporary;
+    return stream;
+}
+template<typename T>
+InputStream& operator<<(InputStream& stream, BigEndian<T> value)
+{
+    stream << static_cast<T>(value);
+    return stream;
+}
+
 #if defined(__cpp_concepts) && !defined(__COVERITY__)
 template<Concepts::Integral Integral>
 #else

AK/Stream.h

@@ -26,8 +26,8 @@
 
 #pragma once
 
+#include <AK/Endian.h>
 #include <AK/MACAddress.h>
-#include <AK/NetworkOrdered.h>
 #include <Kernel/Net/EtherType.h>
 #include <Kernel/Net/IPv4.h>
 

Kernel/Net/ARP.h

@@ -26,16 +26,16 @@
 
 #pragma once
 
+#include <AK/Endian.h>
 #include <AK/MACAddress.h>
-#include <AK/NetworkOrdered.h>
 
 #pragma GCC diagnostic ignored "-Warray-bounds"
 
 class [[gnu::packed]] EthernetFrameHeader
 {
 public:
-    EthernetFrameHeader() {}
-    ~EthernetFrameHeader() {}
+    EthernetFrameHeader() { }
+    ~EthernetFrameHeader() { }
 
     MACAddress destination() const { return m_destination; }
     void set_destination(const MACAddress& address) { m_destination = address; }

Kernel/Net/EthernetFrameHeader.h

@@ -27,8 +27,8 @@
 #pragma once
 
 #include <AK/Assertions.h>
+#include <AK/Endian.h>
 #include <AK/IPv4Address.h>
-#include <AK/NetworkOrdered.h>
 #include <AK/String.h>
 #include <AK/Types.h>
 
@@ -131,7 +131,7 @@ inline NetworkOrdered<u16> internet_checksum(const void* ptr, size_t count)
     u32 checksum = 0;
     auto* w = (const u16*)ptr;
     while (count > 1) {
-        checksum += convert_between_host_and_network(*w++);
+        checksum += AK::convert_between_host_and_network_endian(*w++);
         if (checksum & 0x80000000)
             checksum = (checksum & 0xffff) | (checksum >> 16);
         count -= 2;

Kernel/Net/IPv4.h

@@ -24,6 +24,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <AK/Endian.h>
 #include <AK/Types.h>
 #include <LibCrypto/Hash/SHA1.h>
 
@@ -39,7 +40,7 @@ inline void SHA1::transform(const u8* data)
 {
     u32 blocks[80];
     for (size_t i = 0; i < 16; ++i)
-        blocks[i] = convert_between_host_and_network(((const u32*)data)[i]);
+        blocks[i] = AK::convert_between_host_and_network_endian(((const u32*)data)[i]);
 
     // w[i] = (w[i-3] xor w[i-8] xor w[i-14] xor w[i-16]) leftrotate 1
     for (size_t i = 16; i < Rounds; ++i)

Libraries/LibCrypto/Hash/SHA1.cpp

@@ -25,9 +25,9 @@
  */
 
 #include "PBMLoader.h"
+#include <AK/Endian.h>
 #include <AK/LexicalPath.h>
 #include <AK/MappedFile.h>
-#include <AK/NetworkOrdered.h>
 #include <AK/StringBuilder.h>
 #include <string.h>