MINOR: net_helper: add write functions
These ones are the equivalent of the read_* functions. They support
writing unaligned words, possibly wrapping, in host and network order.
The write_i*() functions were not implemented since the caller can
already use the unsigned version.
diff --git a/include/common/net_helper.h b/include/common/net_helper.h
index 7d5636d..288ca82 100644
--- a/include/common/net_helper.h
+++ b/include/common/net_helper.h
@@ -30,7 +30,7 @@
#include <common/compiler.h>
#include <arpa/inet.h>
-/* Functions to read various integers that may be unaligned */
+/* Functions to read/write various integers that may be unaligned */
/* Read a uint16_t in native host order */
static inline uint16_t read_u16(const void *p)
@@ -39,6 +39,13 @@
return u->u16;
}
+/* Write a uint16_t in native host order */
+static inline void write_u16(void *p, const uint16_t u16)
+{
+ union { uint16_t u16; } __attribute__((packed))*u = p;
+ u->u16 = u16;
+}
+
/* Read a uint32_t in native host order */
static inline uint32_t read_u32(const void *p)
{
@@ -46,6 +53,13 @@
return u->u32;
}
+/* Write a uint32_t in native host order */
+static inline void write_u32(void *p, const uint32_t u32)
+{
+ union { uint32_t u32; } __attribute__((packed))*u = p;
+ u->u32 = u32;
+}
+
/* Read a possibly wrapping number of bytes <bytes> into destination <dst>. The
* first segment is composed of <s1> bytes at p1. The remaining byte(s), if any,
* are read from <p2>. <s1> may be zero and may also be larger than <bytes>. The
@@ -72,6 +86,27 @@
__asm__ volatile("" ::: "memory");
}
+/* Write a possibly wrapping number of bytes <bytes> from location <src>. The
+ * first segment is composed of <s1> bytes at p1. The remaining byte(s), if any,
+ * are written to <p2>. <s1> may be zero and may also be larger than <bytes>.
+ * The caller is always responsible for providing enough room. Note: the
+ * function is purposely *not* marked inline to let the compiler decide what to
+ * do with it, because it's around 34 bytes long, placed on critical path but
+ * rarely called, and uses uses a lot of arguments if not inlined. The compiler
+ * will thus decide what's best to do with it depending on the context.
+ */
+static void writev_bytes(const void *src, const size_t bytes, void *p1, size_t s1, void *p2)
+{
+ size_t idx;
+
+ p2 -= s1;
+ for (idx = 0; idx < bytes; idx++) {
+ if (idx == s1)
+ p1 = p2;
+ ((uint8_t *)p1)[idx] = ((const uint8_t *)src)[idx];
+ }
+}
+
/* Read a possibly wrapping uint16_t in native host order. The first segment is
* composed of <s1> bytes at p1. The remaining byte(s), if any, are read from
* <p2>. <s1> may be zero and may be larger than the type. The caller is always
@@ -94,6 +129,25 @@
}
}
+/* Write a possibly wrapping uint16_t in native host order. The first segment is
+ * composed of <s1> bytes at p1. The remaining byte(s), if any, are written to
+ * <p2>. <s1> may be zero and may be larger than the type. The caller is always
+ * responsible for providing enough room.
+ */
+static inline void writev_u16(void *p1, size_t s1, void *p2, const uint16_t u16)
+{
+ union { uint16_t u16; } __attribute__((packed)) *u;
+
+ if (unlikely(s1 == 1)) {
+ *(uint8_t *)p1 = ((const uint8_t *)&u16)[0];
+ *(uint8_t *)p2 = ((const uint8_t *)&u16)[1];
+ }
+ else {
+ u = (s1 == 0) ? p2 : p1;
+ u->u16 = u16;
+ }
+}
+
/* Read a possibly wrapping uint32_t in native host order. The first segment is
* composed of <s1> bytes at p1. The remaining byte(s), if any, are read from
* <p2>. <s1> may be zero and may be larger than the type. The caller is always
@@ -110,6 +164,19 @@
return u32;
}
+/* Write a possibly wrapping uint32_t in native host order. The first segment is
+ * composed of <s1> bytes at p1. The remaining byte(s), if any, are written to
+ * <p2>. <s1> may be zero and may be larger than the type. The caller is always
+ * responsible for providing enough room.
+ */
+static inline void writev_u32(void *p1, size_t s1, void *p2, const uint32_t u32)
+{
+ if (!unlikely(s1 < sizeof(u32)))
+ write_u32(p1, u32);
+ else
+ writev_bytes(&u32, sizeof(u32), p1, s1, p2);
+}
+
/* Signed integer versions : return the same data but signed */
/* Read an int16_t in native host order */
@@ -142,12 +209,24 @@
return ntohs(read_u16(p));
}
+/* Write a uint16_t after converting it from host order to network order */
+static inline void write_n16(void *p, const uint16_t u16)
+{
+ write_u16(p, htons(u16));
+}
+
/* Read a uint32_t, and convert from network order to host order */
static inline uint32_t read_n32(const void *p)
{
return ntohl(read_u32(p));
}
+/* Write a uint32_t after converting it from host order to network order */
+static inline void write_n32(void *p, const uint32_t u32)
+{
+ write_u32(p, htonl(u32));
+}
+
/* Read a possibly wrapping uint16_t in network order. The first segment is
* composed of <s1> bytes at p1. The remaining byte(s), if any, are read from
* <p2>. <s1> may be zero and may be larger than the type. The caller is always
@@ -164,6 +243,23 @@
return (*(uint8_t *)p1 << 8) + *(uint8_t *)p2;
}
+/* Write a possibly wrapping uint16_t in network order. The first segment is
+ * composed of <s1> bytes at p1. The remaining byte(s), if any, are written to
+ * <p2>. <s1> may be zero and may be larger than the type. The caller is always
+ * responsible for providing enough room.
+ */
+static inline void writev_n16(const void *p1, size_t s1, const void *p2, const uint16_t u16)
+{
+ if (unlikely(s1 < 2)) {
+ if (s1 == 0)
+ p1 = p2++;
+ }
+ else
+ p2 = p1 + 1;
+ *(uint8_t *)p1 = u16 >> 8;
+ *(uint8_t *)p2 = u16;
+}
+
/* Read a possibly wrapping uint32_t in network order. The first segment is
* composed of <s1> bytes at p1. The remaining byte(s), if any, are read from
* <p2>. <s1> may be zero and may be larger than the type. The caller is always
@@ -174,4 +270,14 @@
return ntohl(readv_u32(p1, s1, p2));
}
+/* Write a possibly wrapping uint32_t in network order. The first segment is
+ * composed of <s1> bytes at p1. The remaining byte(s), if any, are written to
+ * <p2>. <s1> may be zero and may be larger than the type. The caller is always
+ * responsible for providing enough room.
+ */
+static inline void writev_n32(void *p1, size_t s1, void *p2, const uint32_t u32)
+{
+ writev_u32(p1, s1, p2, htonl(u32));
+}
+
#endif /* COMMON_NET_HELPER_H */