Add ossl_inline

Add macro ossl_inline for use in public headers where a portable inline
is required. Change existing inline to use ossl_inline

Reviewed-by: Kurt Roeckx <kurt@openssl.org>

5 files changed, 186 insertions, 152 deletions

diff --git a/e_os.h b/e_os.h
index 2832f308e7..5ab4c89a70 100644
--- a/e_os.h
+++ b/e_os.h
@@ -654,23 +654,6 @@ struct servent *getservbyname(const char *name, const char *proto);
 # endif
 /* end vxworks */
 
-# if !defined(inline) && !defined(__cplusplus)
-#  if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
-   /* do nothing, inline works */
-#  elif defined(__GNUC__) && __GNUC__>=2
-#   define inline __inline__
-#  elif defined(_MSC_VER)
-  /*
-   * Visual Studio: inline is available in C++ only, however
-   * __inline is available for C, see
-   * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx
-   */
-#   define inline __inline
-#  else
-#   define inline
-#  endif
-# endif
-
 #define OSSL_NELEM(x)    (sizeof(x)/sizeof(x[0]))
 
 #ifdef  __cplusplus
diff --git a/include/internal/constant_time_locl.h b/include/internal/constant_time_locl.h
index c786aea949..8269a328f7 100644
--- a/include/internal/constant_time_locl.h
+++ b/include/internal/constant_time_locl.h
@@ -47,7 +47,7 @@
 #ifndef HEADER_CONSTANT_TIME_LOCL_H
 # define HEADER_CONSTANT_TIME_LOCL_H
 
-# include "e_os.h"              /* For 'inline' */
+# include <openssl/e_os2.h>              /* For 'ossl_inline' */
 
 #ifdef __cplusplus
 extern "C" {
@@ -76,42 +76,45 @@ extern "C" {
  * However, this is not ensured by the C standard so you may need to
  * replace this with something else on odd CPUs.
  */
-static inline unsigned int constant_time_msb(unsigned int a);
+static ossl_inline unsigned int constant_time_msb(unsigned int a);
 
 /*
  * Returns 0xff..f if a < b and 0 otherwise.
  */
-static inline unsigned int constant_time_lt(unsigned int a, unsigned int b);
+static ossl_inline unsigned int constant_time_lt(unsigned int a,
+                                                 unsigned int b);
 /* Convenience method for getting an 8-bit mask. */
-static inline unsigned char constant_time_lt_8(unsigned int a,
-                                               unsigned int b);
+static ossl_inline unsigned char constant_time_lt_8(unsigned int a,
+                                                    unsigned int b);
 
 /*
  * Returns 0xff..f if a >= b and 0 otherwise.
  */
-static inline unsigned int constant_time_ge(unsigned int a, unsigned int b);
+static ossl_inline unsigned int constant_time_ge(unsigned int a,
+                                                 unsigned int b);
 /* Convenience method for getting an 8-bit mask. */
-static inline unsigned char constant_time_ge_8(unsigned int a,
-                                               unsigned int b);
+static ossl_inline unsigned char constant_time_ge_8(unsigned int a,
+                                                    unsigned int b);
 
 /*
  * Returns 0xff..f if a == 0 and 0 otherwise.
  */
-static inline unsigned int constant_time_is_zero(unsigned int a);
+static ossl_inline unsigned int constant_time_is_zero(unsigned int a);
 /* Convenience method for getting an 8-bit mask. */
-static inline unsigned char constant_time_is_zero_8(unsigned int a);
+static ossl_inline unsigned char constant_time_is_zero_8(unsigned int a);
 
 /*
  * Returns 0xff..f if a == b and 0 otherwise.
  */
-static inline unsigned int constant_time_eq(unsigned int a, unsigned int b);
+static ossl_inline unsigned int constant_time_eq(unsigned int a,
+                                                 unsigned int b);
 /* Convenience method for getting an 8-bit mask. */
-static inline unsigned char constant_time_eq_8(unsigned int a,
-                                               unsigned int b);
+static ossl_inline unsigned char constant_time_eq_8(unsigned int a,
+                                                    unsigned int b);
 /* Signed integers. */
-static inline unsigned int constant_time_eq_int(int a, int b);
+static ossl_inline unsigned int constant_time_eq_int(int a, int b);
 /* Convenience method for getting an 8-bit mask. */
-static inline unsigned char constant_time_eq_int_8(int a, int b);
+static ossl_inline unsigned char constant_time_eq_int_8(int a, int b);
 
 /*-
  * Returns (mask & a) | (~mask & b).
@@ -120,86 +123,94 @@ static inline unsigned char constant_time_eq_int_8(int a, int b);
  * the select methods return either |a| (if |mask| is nonzero) or |b|
  * (if |mask| is zero).
  */
-static inline unsigned int constant_time_select(unsigned int mask,
-                                                unsigned int a,
-                                                unsigned int b);
+static ossl_inline unsigned int constant_time_select(unsigned int mask,
+                                                     unsigned int a,
+                                                     unsigned int b);
 /* Convenience method for unsigned chars. */
-static inline unsigned char constant_time_select_8(unsigned char mask,
-                                                   unsigned char a,
-                                                   unsigned char b);
+static ossl_inline unsigned char constant_time_select_8(unsigned char mask,
+                                                        unsigned char a,
+                                                        unsigned char b);
 /* Convenience method for signed integers. */
-static inline int constant_time_select_int(unsigned int mask, int a, int b);
+static ossl_inline int constant_time_select_int(unsigned int mask, int a,
+                                                int b);
 
-static inline unsigned int constant_time_msb(unsigned int a)
+static ossl_inline unsigned int constant_time_msb(unsigned int a)
 {
     return 0 - (a >> (sizeof(a) * 8 - 1));
 }
 
-static inline unsigned int constant_time_lt(unsigned int a, unsigned int b)
+static ossl_inline unsigned int constant_time_lt(unsigned int a,
+                                                 unsigned int b)
 {
     return constant_time_msb(a ^ ((a ^ b) | ((a - b) ^ b)));
 }
 
-static inline unsigned char constant_time_lt_8(unsigned int a, unsigned int b)
+static ossl_inline unsigned char constant_time_lt_8(unsigned int a,
+                                                    unsigned int b)
 {
     return (unsigned char)(constant_time_lt(a, b));
 }
 
-static inline unsigned int constant_time_ge(unsigned int a, unsigned int b)
+static ossl_inline unsigned int constant_time_ge(unsigned int a,
+                                                 unsigned int b)
 {
     return ~constant_time_lt(a, b);
 }
 
-static inline unsigned char constant_time_ge_8(unsigned int a, unsigned int b)
+static ossl_inline unsigned char constant_time_ge_8(unsigned int a,
+                                                    unsigned int b)
 {
     return (unsigned char)(constant_time_ge(a, b));
 }
 
-static inline unsigned int constant_time_is_zero(unsigned int a)
+static ossl_inline unsigned int constant_time_is_zero(unsigned int a)
 {
     return constant_time_msb(~a & (a - 1));
 }
 
-static inline unsigned char constant_time_is_zero_8(unsigned int a)
+static ossl_inline unsigned char constant_time_is_zero_8(unsigned int a)
 {
     return (unsigned char)(constant_time_is_zero(a));
 }
 
-static inline unsigned int constant_time_eq(unsigned int a, unsigned int b)
+static ossl_inline unsigned int constant_time_eq(unsigned int a,
+                                                 unsigned int b)
 {
     return constant_time_is_zero(a ^ b);
 }
 
-static inline unsigned char constant_time_eq_8(unsigned int a, unsigned int b)
+static ossl_inline unsigned char constant_time_eq_8(unsigned int a,
+                                                    unsigned int b)
 {
     return (unsigned char)(constant_time_eq(a, b));
 }
 
-static inline unsigned int constant_time_eq_int(int a, int b)
+static ossl_inline unsigned int constant_time_eq_int(int a, int b)
 {
     return constant_time_eq((unsigned)(a), (unsigned)(b));
 }
 
-static inline unsigned char constant_time_eq_int_8(int a, int b)
+static ossl_inline unsigned char constant_time_eq_int_8(int a, int b)
 {
     return constant_time_eq_8((unsigned)(a), (unsigned)(b));
 }
 
-static inline unsigned int constant_time_select(unsigned int mask,
-                                                unsigned int a,
-                                                unsigned int b)
+static ossl_inline unsigned int constant_time_select(unsigned int mask,
+                                                     unsigned int a,
+                                                     unsigned int b)
 {
     return (mask & a) | (~mask & b);
 }
 
-static inline unsigned char constant_time_select_8(unsigned char mask,
-                                                   unsigned char a,
-                                                   unsigned char b)
+static ossl_inline unsigned char constant_time_select_8(unsigned char mask,
+                                                        unsigned char a,
+                                                        unsigned char b)
 {
     return (unsigned char)(constant_time_select(mask, a, b));
 }
 
-static inline int constant_time_select_int(unsigned int mask, int a, int b)
+static ossl_inline int constant_time_select_int(unsigned int mask, int a,
+                                                int b)
 {
     return (int)(constant_time_select(mask, (unsigned)(a), (unsigned)(b)));
 }
diff --git a/include/openssl/e_os2.h b/include/openssl/e_os2.h
index 23602a5266..07428e9439 100644
--- a/include/openssl/e_os2.h
+++ b/include/openssl/e_os2.h
@@ -329,6 +329,25 @@ typedef unsigned __int64 uint64_t;
 #  endif
 # endif
 
+/* ossl_inline: portable inline definition usable in public headers */
+# if !defined(inline) && !defined(__cplusplus)
+#  if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
+   /* just use inline */
+#   define ossl_inline inline
+#  elif defined(__GNUC__) && __GNUC__>=2
+#   define ossl_inline __inline__
+#  elif defined(_MSC_VER)
+  /*
+   * Visual Studio: inline is available in C++ only, however
+   * __inline is available for C, see
+   * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx
+   */
+#   define ossl_inline __inline
+#  else
+#   define ossl_inline
+#  endif
+# endif
+
 #ifdef  __cplusplus
 }
 #endif
diff --git a/ssl/packet_locl.h b/ssl/packet_locl.h
index c0ab8257b7..39fac55bb4 100644
--- a/ssl/packet_locl.h
+++ b/ssl/packet_locl.h
@@ -63,7 +63,7 @@
 # include <openssl/bn.h>
 # include <openssl/buffer.h>
 # include <openssl/crypto.h>
-# include "e_os.h"
+# include <openssl/e_os2.h>
 
 # ifdef __cplusplus
 extern "C" {
@@ -77,7 +77,7 @@ typedef struct {
 } PACKET;
 
 /* Internal unchecked shorthand; don't use outside this file. */
-static inline void packet_forward(PACKET *pkt, size_t len)
+static ossl_inline void packet_forward(PACKET *pkt, size_t len)
 {
     pkt->curr += len;
     pkt->remaining -= len;
@@ -86,7 +86,7 @@ static inline void packet_forward(PACKET *pkt, size_t len)
 /*
  * Returns the number of bytes remaining to be read in the PACKET
  */
-static inline size_t PACKET_remaining(const PACKET *pkt)
+static ossl_inline size_t PACKET_remaining(const PACKET *pkt)
 {
     return pkt->remaining;
 }
@@ -97,7 +97,7 @@ static inline size_t PACKET_remaining(const PACKET *pkt)
  * TODO(openssl-team): this should return 'const unsigned char*' but can't
  * currently because legacy code passes 'unsigned char*'s around.
  */
-static inline unsigned char *PACKET_data(const PACKET *pkt)
+static ossl_inline unsigned char *PACKET_data(const PACKET *pkt)
 {
     return pkt->curr;
 }
@@ -107,8 +107,8 @@ static inline unsigned char *PACKET_data(const PACKET *pkt)
  * copy of the data so |buf| must be present for the whole time that the PACKET
  * is being used.
  */
-__owur static inline int PACKET_buf_init(PACKET *pkt, unsigned char *buf,
-                                         size_t len)
+__owur static ossl_inline int PACKET_buf_init(PACKET *pkt, unsigned char *buf,
+                                              size_t len)
 {
     /* Sanity check for negative values. */
     if (len > (size_t)(SIZE_MAX / 2))
@@ -120,7 +120,7 @@ __owur static inline int PACKET_buf_init(PACKET *pkt, unsigned char *buf,
 }
 
 /* Initialize a PACKET to hold zero bytes. */
-static inline void PACKET_null_init(PACKET *pkt)
+static ossl_inline void PACKET_null_init(PACKET *pkt)
 {
     pkt->curr = NULL;
     pkt->remaining = 0;
@@ -131,8 +131,9 @@ static inline void PACKET_null_init(PACKET *pkt)
  * bytes read from |ptr|. Returns 0 otherwise (lengths or contents not equal).
  * If lengths are equal, performs the comparison in constant time.
  */
-__owur static inline int PACKET_equal(const PACKET *pkt, const void *ptr,
-                                      size_t num) {
+__owur static ossl_inline int PACKET_equal(const PACKET *pkt, const void *ptr,
+                                           size_t num)
+{
     if (PACKET_remaining(pkt) != num)
         return 0;
     return CRYPTO_memcmp(pkt->curr, ptr, num) == 0;
@@ -143,8 +144,9 @@ __owur static inline int PACKET_equal(const PACKET *pkt, const void *ptr,
  * Data is not copied: the |subpkt| packet will share its underlying buffer with
  * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
  */
-__owur static inline int PACKET_peek_sub_packet(const PACKET *pkt,
-                                                PACKET *subpkt, size_t len)
+__owur static ossl_inline int PACKET_peek_sub_packet(const PACKET *pkt,
+                                                     PACKET *subpkt,
+                                                     size_t len)
 {
     if (PACKET_remaining(pkt) < len)
         return 0;
@@ -157,8 +159,9 @@ __owur static inline int PACKET_peek_sub_packet(const PACKET *pkt,
  * copied: the |subpkt| packet will share its underlying buffer with the
  * original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
  */
-__owur static inline int PACKET_get_sub_packet(PACKET *pkt, PACKET *subpkt,
-                                               size_t len)
+__owur static ossl_inline int PACKET_get_sub_packet(PACKET *pkt,
+                                                    PACKET *subpkt,
+                                                    size_t len)
 {
     if (!PACKET_peek_sub_packet(pkt, subpkt, len))
         return 0;
@@ -168,16 +171,17 @@ __owur static inline int PACKET_get_sub_packet(PACKET *pkt, PACKET *subpkt,
     return 1;
 }
 
-/* Peek ahead at 2 bytes in network order from |pkt| and store the value in
+/*
+ * Peek ahead at 2 bytes in network order from |pkt| and store the value in
  * |*data|
  */
-__owur static inline int PACKET_peek_net_2(const PACKET *pkt,
-                                           unsigned int *data)
+__owur static ossl_inline int PACKET_peek_net_2(const PACKET *pkt,
+                                                unsigned int *data)
 {
     if (PACKET_remaining(pkt) < 2)
         return 0;
 
-    *data  = ((unsigned int)(*pkt->curr)) <<  8;
+    *data = ((unsigned int)(*pkt->curr)) << 8;
     *data |= *(pkt->curr + 1);
 
     return 1;
@@ -185,7 +189,8 @@ __owur static inline int PACKET_peek_net_2(const PACKET *pkt,
 
 /* Equivalent of n2s */
 /* Get 2 bytes in network order from |pkt| and store the value in |*data| */
-__owur static inline int PACKET_get_net_2(PACKET *pkt, unsigned int *data)
+__owur static ossl_inline int PACKET_get_net_2(PACKET *pkt,
+                                               unsigned int *data)
 {
     if (!PACKET_peek_net_2(pkt, data))
         return 0;
@@ -195,17 +200,18 @@ __owur static inline int PACKET_get_net_2(PACKET *pkt, unsigned int *data)
     return 1;
 }
 
-/* Peek ahead at 3 bytes in network order from |pkt| and store the value in
+/*
+ * Peek ahead at 3 bytes in network order from |pkt| and store the value in
  * |*data|
  */
-__owur static inline int PACKET_peek_net_3(const PACKET *pkt,
-                                           unsigned long *data)
+__owur static ossl_inline int PACKET_peek_net_3(const PACKET *pkt,
+                                                unsigned long *data)
 {
     if (PACKET_remaining(pkt) < 3)
         return 0;
 
-    *data  = ((unsigned long)(*pkt->curr)) << 16;
-    *data |= ((unsigned long)(*(pkt->curr + 1))) <<  8;
+    *data = ((unsigned long)(*pkt->curr)) << 16;
+    *data |= ((unsigned long)(*(pkt->curr + 1))) << 8;
     *data |= *(pkt->curr + 2);
 
     return 1;
@@ -213,7 +219,8 @@ __owur static inline int PACKET_peek_net_3(const PACKET *pkt,
 
 /* Equivalent of n2l3 */
 /* Get 3 bytes in network order from |pkt| and store the value in |*data| */
-__owur static inline int PACKET_get_net_3(PACKET *pkt, unsigned long *data)
+__owur static ossl_inline int PACKET_get_net_3(PACKET *pkt,
+                                               unsigned long *data)
 {
     if (!PACKET_peek_net_3(pkt, data))
         return 0;
@@ -223,26 +230,28 @@ __owur static inline int PACKET_get_net_3(PACKET *pkt, unsigned long *data)
     return 1;
 }
 
-/* Peek ahead at 4 bytes in network order from |pkt| and store the value in
+/*
+ * Peek ahead at 4 bytes in network order from |pkt| and store the value in
  * |*data|
  */
-__owur static inline int PACKET_peek_net_4(const PACKET *pkt,
-                                           unsigned long *data)
+__owur static ossl_inline int PACKET_peek_net_4(const PACKET *pkt,
+                                                unsigned long *data)
 {
     if (PACKET_remaining(pkt) < 4)
         return 0;
 
-    *data  = ((unsigned long)(*pkt->curr)) << 24;
+    *data = ((unsigned long)(*pkt->curr)) << 24;
     *data |= ((unsigned long)(*(pkt->curr + 1))) << 16;
-    *data |= ((unsigned long)(*(pkt->curr + 2))) <<  8;
-    *data |= *(pkt->curr+3);
+    *data |= ((unsigned long)(*(pkt->curr + 2))) << 8;
+    *data |= *(pkt->curr + 3);
 
     return 1;
 }
 
 /* Equivalent of n2l */
 /* Get 4 bytes in network order from |pkt| and store the value in |*data| */
-__owur static inline int PACKET_get_net_4(PACKET *pkt, unsigned long *data)
+__owur static ossl_inline int PACKET_get_net_4(PACKET *pkt,
+                                               unsigned long *data)
 {
     if (!PACKET_peek_net_4(pkt, data))
         return 0;
@@ -253,7 +262,8 @@ __owur static inline int PACKET_get_net_4(PACKET *pkt, unsigned long *data)
 }
 
 /* Peek ahead at 1 byte from |pkt| and store the value in |*data| */
-__owur static inline int PACKET_peek_1(const PACKET *pkt, unsigned int *data)
+__owur static ossl_inline int PACKET_peek_1(const PACKET *pkt,
+                                            unsigned int *data)
 {
     if (!PACKET_remaining(pkt))
         return 0;
@@ -264,7 +274,7 @@ __owur static inline int PACKET_peek_1(const PACKET *pkt, unsigned int *data)
 }
 
 /* Get 1 byte from |pkt| and store the value in |*data| */
-__owur static inline int PACKET_get_1(PACKET *pkt, unsigned int *data)
+__owur static ossl_inline int PACKET_get_1(PACKET *pkt, unsigned int *data)
 {
     if (!PACKET_peek_1(pkt, data))
         return 0;
@@ -278,13 +288,14 @@ __owur static inline int PACKET_get_1(PACKET *pkt, unsigned int *data)
  * Peek ahead at 4 bytes in reverse network order from |pkt| and store the value
  * in |*data|
  */
-__owur static inline int PACKET_peek_4(const PACKET *pkt, unsigned long *data)
+__owur static ossl_inline int PACKET_peek_4(const PACKET *pkt,
+                                            unsigned long *data)
 {
     if (PACKET_remaining(pkt) < 4)
         return 0;
 
-    *data  = *pkt->curr;
-    *data |= ((unsigned long)(*(pkt->curr + 1))) <<  8;
+    *data = *pkt->curr;
+    *data |= ((unsigned long)(*(pkt->curr + 1))) << 8;
     *data |= ((unsigned long)(*(pkt->curr + 2))) << 16;
     *data |= ((unsigned long)(*(pkt->curr + 3))) << 24;
 
@@ -296,7 +307,7 @@ __owur static inline int PACKET_peek_4(const PACKET *pkt, unsigned long *data)
  * Get 4 bytes in reverse network order from |pkt| and store the value in
  * |*data|
  */
-__owur static inline int PACKET_get_4(PACKET *pkt, unsigned long *data)
+__owur static ossl_inline int PACKET_get_4(PACKET *pkt, unsigned long *data)
 {
     if (!PACKET_peek_4(pkt, data))
         return 0;
@@ -312,8 +323,9 @@ __owur static inline int PACKET_get_4(PACKET *pkt, unsigned long *data)
  * caller should not free this data directly (it will be freed when the
  * underlying buffer gets freed
  */
-__owur static inline int PACKET_peek_bytes(const PACKET *pkt, unsigned char **data,
-                                           size_t len)
+__owur static ossl_inline int PACKET_peek_bytes(const PACKET *pkt,
+                                                unsigned char **data,
+                                                size_t len)
 {
     if (PACKET_remaining(pkt) < len)
         return 0;
@@ -329,8 +341,9 @@ __owur static inline int PACKET_peek_bytes(const PACKET *pkt, unsigned char **da
  * not free this data directly (it will be freed when the underlying buffer gets
  * freed
  */
-__owur static inline int PACKET_get_bytes(PACKET *pkt, unsigned char **data,
-                                          size_t len)
+__owur static ossl_inline int PACKET_get_bytes(PACKET *pkt,
+                                               unsigned char **data,
+                                               size_t len)
 {
     if (!PACKET_peek_bytes(pkt, data, len))
         return 0;
@@ -341,8 +354,9 @@ __owur static inline int PACKET_get_bytes(PACKET *pkt, unsigned char **data,
 }
 
 /* Peek ahead at |len| bytes from |pkt| and copy them to |data| */
-__owur static inline int PACKET_peek_copy_bytes(const PACKET *pkt,
-                                                unsigned char *data, size_t len)
+__owur static ossl_inline int PACKET_peek_copy_bytes(const PACKET *pkt,
+                                                     unsigned char *data,
+                                                     size_t len)
 {
     if (PACKET_remaining(pkt) < len)
         return 0;
@@ -356,8 +370,9 @@ __owur static inline int PACKET_peek_copy_bytes(const PACKET *pkt,
  * Read |len| bytes from |pkt| and copy them to |data|.
  * The caller is responsible for ensuring that |data| can hold |len| bytes.
  */
-__owur static inline int PACKET_copy_bytes(PACKET *pkt, unsigned char *data,
-                                           size_t len)
+__owur static ossl_inline int PACKET_copy_bytes(PACKET *pkt,
+                                                unsigned char *data,
+                                                size_t len)
 {
     if (!PACKET_peek_copy_bytes(pkt, data, len))
         return 0;
@@ -374,8 +389,10 @@ __owur static inline int PACKET_copy_bytes(PACKET *pkt, unsigned char *data,
  * Does not forward PACKET position (because it is typically the last thing
  * done with a given PACKET).
  */
-__owur static inline int PACKET_copy_all(const PACKET *pkt, unsigned char *dest,
-                                         size_t dest_len, size_t *len) {
+__owur static ossl_inline int PACKET_copy_all(const PACKET *pkt,
+                                              unsigned char *dest,
+                                              size_t dest_len, size_t *len)
+{
     if (PACKET_remaining(pkt) > dest_len) {
         *len = 0;
         return 0;
@@ -394,8 +411,8 @@ __owur static inline int PACKET_copy_all(const PACKET *pkt, unsigned char *dest,
  * Does not forward PACKET position (because it is typically the last thing
  * done with a given PACKET).
  */
-__owur static inline int PACKET_memdup(const PACKET *pkt, unsigned char **data,
-                                       size_t *len)
+__owur static ossl_inline int PACKET_memdup(const PACKET *pkt,
+                                            unsigned char **data, size_t *len)
 {
     size_t length;
 
@@ -426,17 +443,17 @@ __owur static inline int PACKET_memdup(const PACKET *pkt, unsigned char **data,
  * Does not forward PACKET position (because it is typically the last thing done
  * with a given PACKET).
  */
-__owur static inline int PACKET_strndup(const PACKET *pkt, char **data)
+__owur static ossl_inline int PACKET_strndup(const PACKET *pkt, char **data)
 {
     OPENSSL_free(*data);
 
     /* This will succeed on an empty packet, unless pkt->curr == NULL. */
-    *data = OPENSSL_strndup((const char*)pkt->curr, PACKET_remaining(pkt));
+    *data = OPENSSL_strndup((const char *)pkt->curr, PACKET_remaining(pkt));
     return (*data != NULL);
 }
 
 /* Move the current reading position forward |len| bytes */
-__owur static inline int PACKET_forward(PACKET *pkt, size_t len)
+__owur static ossl_inline int PACKET_forward(PACKET *pkt, size_t len)
 {
     if (PACKET_remaining(pkt) < len)
         return 0;
@@ -453,21 +470,22 @@ __owur static inline int PACKET_forward(PACKET *pkt, size_t len)
  * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
  * Upon failure, the original |pkt| and |subpkt| are not modified.
  */
-__owur static inline int PACKET_get_length_prefixed_1(PACKET *pkt, PACKET *subpkt)
+__owur static ossl_inline int PACKET_get_length_prefixed_1(PACKET *pkt,
+                                                           PACKET *subpkt)
 {
-  unsigned int length;
-  unsigned char *data;
-  PACKET tmp = *pkt;
-  if (!PACKET_get_1(&tmp, &length) ||
-      !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
-      return 0;
-  }
-
-  *pkt = tmp;
-  subpkt->curr = data;
-  subpkt->remaining = length;
-
-  return 1;
+    unsigned int length;
+    unsigned char *data;
+    PACKET tmp = *pkt;
+    if (!PACKET_get_1(&tmp, &length) ||
+        !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
+        return 0;
+    }
+
+    *pkt = tmp;
+    subpkt->curr = data;
+    subpkt->remaining = length;
+
+    return 1;
 }
 
 /*
@@ -477,21 +495,22 @@ __owur static inline int PACKET_get_length_prefixed_1(PACKET *pkt, PACKET *subpk
  * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
  * Upon failure, the original |pkt| and |subpkt| are not modified.
  */
-__owur static inline int PACKET_get_length_prefixed_2(PACKET *pkt, PACKET *subpkt)
+__owur static ossl_inline int PACKET_get_length_prefixed_2(PACKET *pkt,
+                                                           PACKET *subpkt)
 {
-  unsigned int length;
-  unsigned char *data;
-  PACKET tmp = *pkt;
-  if (!PACKET_get_net_2(&tmp, &length) ||
-      !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
-      return 0;
-  }
-
-  *pkt = tmp;
-  subpkt->curr = data;
-  subpkt->remaining = length;
-
-  return 1;
+    unsigned int length;
+    unsigned char *data;
+    PACKET tmp = *pkt;
+    if (!PACKET_get_net_2(&tmp, &length) ||
+        !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
+        return 0;
+    }
+
+    *pkt = tmp;
+    subpkt->curr = data;
+    subpkt->remaining = length;
+
+    return 1;
 }
 
 /*
@@ -501,24 +520,25 @@ __owur static inline int PACKET_get_length_prefixed_2(PACKET *pkt, PACKET *subpk
  * the original |pkt|, so data wrapped by |pkt| must outlive the |subpkt|.
  * Upon failure, the original |pkt| and |subpkt| are not modified.
  */
-__owur static inline int PACKET_get_length_prefixed_3(PACKET *pkt, PACKET *subpkt)
+__owur static ossl_inline int PACKET_get_length_prefixed_3(PACKET *pkt,
+                                                           PACKET *subpkt)
 {
-  unsigned long length;
-  unsigned char *data;
-  PACKET tmp = *pkt;
-  if (!PACKET_get_net_3(&tmp, &length) ||
-      !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
-      return 0;
-  }
-
-  *pkt = tmp;
-  subpkt->curr = data;
-  subpkt->remaining = length;
-
-  return 1;
+    unsigned long length;
+    unsigned char *data;
+    PACKET tmp = *pkt;
+    if (!PACKET_get_net_3(&tmp, &length) ||
+        !PACKET_get_bytes(&tmp, &data, (size_t)length)) {
+        return 0;
+    }
+
+    *pkt = tmp;
+    subpkt->curr = data;
+    subpkt->remaining = length;
+
+    return 1;
 }
 # ifdef __cplusplus
 }
 # endif
 
-#endif /* HEADER_PACKET_LOCL_H */
+#endif                          /* HEADER_PACKET_LOCL_H */
diff --git a/test/constant_time_test.c b/test/constant_time_test.c
index 1c04cb7b61..06916ff787 100644
--- a/test/constant_time_test.c
+++ b/test/constant_time_test.c
@@ -45,6 +45,7 @@
  */
 
 #include "internal/constant_time_locl.h"
+#include "e_os.h"
 
 #include <limits.h>
 #include <stdio.h>