duckdb 1.3.4 → 1.4.1-dev2.0

package/src/duckdb/third_party/mbedtls/library/cipher_wrap.cpp

@@ -58,9 +58,60 @@
 
 #include "mbedtls/platform.h"
 
-enum mbedtls_cipher_base_index : uint8_t {
-    MBEDTLS_CIPHER_BASE_INDEX_AES = 0,
-    MBEDTLS_CIPHER_BASE_INDEX_GCM_AES = 1,
+enum mbedtls_cipher_base_index {
+#if defined(MBEDTLS_AES_C)
+    MBEDTLS_CIPHER_BASE_INDEX_AES,
+#endif
+#if defined(MBEDTLS_ARIA_C)
+    MBEDTLS_CIPHER_BASE_INDEX_ARIA,
+#endif
+#if defined(MBEDTLS_CAMELLIA_C)
+    MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA,
+#endif
+#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
+    MBEDTLS_CIPHER_BASE_INDEX_CCM_AES,
+#endif
+#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_ARIA_C)
+    MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA,
+#endif
+#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CAMELLIA_C)
+    MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA,
+#endif
+#if defined(MBEDTLS_CHACHA20_C)
+    MBEDTLS_CIPHER_BASE_INDEX_CHACHA20_BASE,
+#endif
+#if defined(MBEDTLS_CHACHAPOLY_C)
+    MBEDTLS_CIPHER_BASE_INDEX_CHACHAPOLY_BASE,
+#endif
+#if defined(MBEDTLS_DES_C)
+    MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3,
+#endif
+#if defined(MBEDTLS_DES_C)
+    MBEDTLS_CIPHER_BASE_INDEX_DES_EDE,
+#endif
+#if defined(MBEDTLS_DES_C)
+    MBEDTLS_CIPHER_BASE_INDEX_DES,
+#endif
+#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
+    MBEDTLS_CIPHER_BASE_INDEX_GCM_AES,
+#endif
+#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_ARIA_C)
+    MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA,
+#endif
+#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CAMELLIA_C)
+    MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA,
+#endif
+#if defined(MBEDTLS_NIST_KW_C)
+    MBEDTLS_CIPHER_BASE_INDEX_KW_AES,
+#endif
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+    MBEDTLS_CIPHER_BASE_INDEX_NULL_BASE,
+#endif
+#if defined(MBEDTLS_CIPHER_MODE_XTS) && defined(MBEDTLS_AES_C)
+    MBEDTLS_CIPHER_BASE_INDEX_XTS_AES,
+#endif
+    /* Prevent compile failure due to empty enum */
+    MBEDTLS_CIPHER_BASE_PREVENT_EMPTY_ENUM
 };
 
 #if defined(MBEDTLS_GCM_C) && \
@@ -80,7 +131,7 @@ static void *gcm_ctx_alloc(void)
 
 static void gcm_ctx_free(void *ctx)
 {
-    mbedtls_gcm_free((mbedtls_gcm_context *)ctx);
+    mbedtls_gcm_free((mbedtls_gcm_context *) ctx);
     mbedtls_free(ctx);
 }
 #endif /* MBEDTLS_GCM_C */
@@ -195,7 +246,7 @@ static int aes_setkey_enc_wrap(void *ctx, const unsigned char *key,
 
 static void *aes_ctx_alloc(void)
 {
-    mbedtls_aes_context *aes = (mbedtls_aes_context *)mbedtls_calloc(1, sizeof(mbedtls_aes_context));
+    mbedtls_aes_context *aes = (mbedtls_aes_context *) mbedtls_calloc(1, sizeof(mbedtls_aes_context));
 
     if (aes == NULL) {
         return NULL;
@@ -777,7 +828,7 @@ static int camellia_setkey_enc_wrap(void *ctx, const unsigned char *key,
 static void *camellia_ctx_alloc(void)
 {
     mbedtls_camellia_context *ctx;
-    ctx = (mbedtls_camellia_context *)mbedtls_calloc(1, sizeof(mbedtls_camellia_context));
+    ctx = mbedtls_calloc(1, sizeof(mbedtls_camellia_context));
 
     if (ctx == NULL) {
         return NULL;
@@ -1195,7 +1246,7 @@ static int aria_setkey_enc_wrap(void *ctx, const unsigned char *key,
 static void *aria_ctx_alloc(void)
 {
     mbedtls_aria_context *ctx;
-    ctx = (mbedtls_aria_context *)mbedtls_calloc(1, sizeof(mbedtls_aria_context));
+    ctx = mbedtls_calloc(1, sizeof(mbedtls_aria_context));
 
     if (ctx == NULL) {
         return NULL;
@@ -2374,9 +2425,58 @@ const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
                      sizeof(mbedtls_cipher_definitions[0]))
 int mbedtls_cipher_supported[NUM_CIPHERS];
 
-const mbedtls_cipher_base_t *mbedtls_cipher_base_lookup_table[] = {
-   /* MBEDTLS_CIPHER_BASE_INDEX_AES */ &aes_info,
-   /* MBEDTLS_CIPHER_BASE_INDEX_GCM_AES */ &gcm_aes_info,
+const mbedtls_cipher_base_t * const mbedtls_cipher_base_lookup_table[] = {
+#if defined(MBEDTLS_AES_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_AES] = */ &aes_info,
+#endif
+#if defined(MBEDTLS_ARIA_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_ARIA] = */ &aria_info,
+#endif
+#if defined(MBEDTLS_CAMELLIA_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_CAMELLIA] = */ &camellia_info,
+#endif
+#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_CCM_AES] = */ &ccm_aes_info,
+#endif
+#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_ARIA_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_CCM_ARIA] = */ &ccm_aria_info,
+#endif
+#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_CAMELLIA_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_CCM_CAMELLIA] = */ &ccm_camellia_info,
+#endif
+#if defined(MBEDTLS_CHACHA20_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_CHACHA20_BASE] = */ &chacha20_base_info,
+#endif
+#if defined(MBEDTLS_CHACHAPOLY_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_CHACHAPOLY_BASE] = */ &chachapoly_base_info,
+#endif
+#if defined(MBEDTLS_DES_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_DES_EDE3] = */ &des_ede3_info,
+#endif
+#if defined(MBEDTLS_DES_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_DES_EDE] = */ &des_ede_info,
+#endif
+#if defined(MBEDTLS_DES_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_DES] = */ &des_info,
+#endif
+#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_GCM_AES] =  */ &gcm_aes_info,
+#endif
+#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_ARIA_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_GCM_ARIA] = */ &gcm_aria_info,
+#endif
+#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_CAMELLIA_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_GCM_CAMELLIA] =*/  &gcm_camellia_info,
+#endif
+#if defined(MBEDTLS_NIST_KW_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_KW_AES] = */ &kw_aes_info,
+#endif
+#if defined(MBEDTLS_CIPHER_NULL_CIPHER)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_NULL_BASE] = */ &null_base_info,
+#endif
+#if defined(MBEDTLS_CIPHER_MODE_XTS) && defined(MBEDTLS_AES_C)
+    /* [MBEDTLS_CIPHER_BASE_INDEX_XTS_AES] = */ &xts_aes_info
+#endif
 };
 
 #endif /* MBEDTLS_CIPHER_C */

package/src/duckdb/third_party/mbedtls/library/cipher_wrap.h

@@ -169,7 +169,7 @@ extern const mbedtls_cipher_definition_t mbedtls_cipher_definitions[];
 
 extern int mbedtls_cipher_supported[];
 
-extern const mbedtls_cipher_base_t *mbedtls_cipher_base_lookup_table[];
+extern const mbedtls_cipher_base_t * const mbedtls_cipher_base_lookup_table[];
 
 #ifdef __cplusplus
 }

package/src/duckdb/third_party/mbedtls/library/common.h

@@ -135,7 +135,7 @@ void mbedtls_zeroize_and_free(void *buf, size_t len);
  *              Note that this is only a valid pointer if the size of the
  *              buffer is at least \p n + 1.
  */
-inline unsigned char *mbedtls_buffer_offset(
+static inline unsigned char *mbedtls_buffer_offset(
     unsigned char *p, size_t n)
 {
     return p == NULL ? NULL : p + n;
@@ -152,7 +152,7 @@ inline unsigned char *mbedtls_buffer_offset(
  *              Note that this is only a valid pointer if the size of the
  *              buffer is at least \p n + 1.
  */
-inline const unsigned char *mbedtls_buffer_offset_const(
+static inline const unsigned char *mbedtls_buffer_offset_const(
     const unsigned char *p, size_t n)
 {
     return p == NULL ? NULL : p + n;
@@ -183,7 +183,7 @@ __attribute__((always_inline))
  *            the result is not used immediately (e.g., in AES-CTR), mbedtls_xor() may be faster.
  *            For targets without SIMD support, they will behave the same.
  */
-inline void mbedtls_xor(unsigned char *r,
+static inline void mbedtls_xor(unsigned char *r,
                                const unsigned char *a,
                                const unsigned char *b,
                                size_t n)
@@ -265,7 +265,7 @@ __attribute__((always_inline))
  *            the result is not used immediately (e.g., in AES-CTR), mbedtls_xor() may be faster.
  *            For targets without SIMD support, they will behave the same.
  */
-inline void mbedtls_xor_no_simd(unsigned char *r,
+static inline void mbedtls_xor_no_simd(unsigned char *r,
                                        const unsigned char *a,
                                        const unsigned char *b,
                                        size_t n)
@@ -434,4 +434,20 @@ inline void mbedtls_xor_no_simd(unsigned char *r,
 #    define MBEDTLS_MAYBE_UNUSED
 #endif
 
+/* GCC >= 15 has a warning 'unterminated-string-initialization' which complains if you initialize
+ * a string into an array without space for a terminating NULL character. In some places in the
+ * codebase this behaviour is intended, so we add the macro MBEDTLS_ATTRIBUTE_UNTERMINATED_STRING
+ * to suppress the warning in these places.
+ */
+#if defined(__has_attribute)
+#if __has_attribute(nonstring)
+#define MBEDTLS_HAS_ATTRIBUTE_NONSTRING
+#endif /* __has_attribute(nonstring) */
+#endif /* __has_attribute */
+#if defined(MBEDTLS_HAS_ATTRIBUTE_NONSTRING)
+#define MBEDTLS_ATTRIBUTE_UNTERMINATED_STRING __attribute__((nonstring))
+#else
+#define MBEDTLS_ATTRIBUTE_UNTERMINATED_STRING
+#endif /* MBEDTLS_HAS_ATTRIBUTE_NONSTRING */
+
 #endif /* MBEDTLS_LIBRARY_COMMON_H */

package/src/duckdb/third_party/mbedtls/library/constant_time.cpp

@@ -46,7 +46,7 @@ volatile mbedtls_ct_uint_t mbedtls_ct_zero = 0;
 /* We check pointer sizes to avoid issues with them not matching register size requirements */
 #define MBEDTLS_EFFICIENT_UNALIGNED_VOLATILE_ACCESS
 
-inline uint32_t mbedtls_get_unaligned_volatile_uint32(volatile const unsigned char *p)
+static inline uint32_t mbedtls_get_unaligned_volatile_uint32(volatile const unsigned char *p)
 {
     /* This is UB, even where it's safe:
      *    return *((volatile uint32_t*)p);

package/src/duckdb/third_party/mbedtls/library/constant_time_impl.h

@@ -17,12 +17,12 @@
 #endif
 
 /*
- * To improve readability of constant_time_internal.h, the inline
+ * To improve readability of constant_time_internal.h, the static inline
  * definitions are here, and constant_time_internal.h has only the declarations.
  *
  * This results in duplicate declarations of the form:
- *     inline void f();         // from constant_time_internal.h
- *     inline void f() { ... }  // from constant_time_impl.h
+ *     static inline void f();         // from constant_time_internal.h
+ *     static inline void f() { ... }  // from constant_time_impl.h
  * when constant_time_internal.h is included.
  *
  * This appears to behave as if the declaration-without-definition was not present
@@ -36,24 +36,9 @@
     #pragma GCC diagnostic ignored "-Wredundant-decls"
 #endif
 
-/* Disable asm under Memsan because it confuses Memsan and generates false errors.
- *
- * We also disable under Valgrind by default, because it's more useful
- * for Valgrind to test the plain C implementation. MBEDTLS_TEST_CONSTANT_FLOW_ASM //no-check-names
- * may be set to permit building asm under Valgrind.
- */
-#if defined(MBEDTLS_TEST_CONSTANT_FLOW_MEMSAN) || \
-    (defined(MBEDTLS_TEST_CONSTANT_FLOW_VALGRIND) && !defined(MBEDTLS_TEST_CONSTANT_FLOW_ASM)) //no-check-names
-#define MBEDTLS_CT_NO_ASM
-#elif defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-#define MBEDTLS_CT_NO_ASM
-#endif
-#endif
-
 /* armcc5 --gnu defines __GNUC__ but doesn't support GNU's extended asm */
 #if defined(MBEDTLS_HAVE_ASM) && defined(__GNUC__) && (!defined(__ARMCC_VERSION) || \
-    __ARMCC_VERSION >= 6000000) && !defined(MBEDTLS_CT_NO_ASM)
+    __ARMCC_VERSION >= 6000000)
 #define MBEDTLS_CT_ASM
 #if (defined(__arm__) || defined(__thumb__) || defined(__thumb2__))
 #define MBEDTLS_CT_ARM_ASM
@@ -97,7 +82,7 @@ extern volatile mbedtls_ct_uint_t mbedtls_ct_zero;
  *                 there is no way for the compiler to ever know anything about
  *                 the value of an mbedtls_ct_condition_t.
  */
-inline mbedtls_ct_uint_t mbedtls_ct_compiler_opaque(mbedtls_ct_uint_t x)
+static inline mbedtls_ct_uint_t mbedtls_ct_compiler_opaque(mbedtls_ct_uint_t x)
 {
 #if defined(MBEDTLS_CT_ASM)
     asm volatile ("" : [x] "+r" (x) :);
@@ -132,7 +117,7 @@ inline mbedtls_ct_uint_t mbedtls_ct_compiler_opaque(mbedtls_ct_uint_t x)
 #endif
 
 /* Convert a number into a condition in constant time. */
-inline mbedtls_ct_condition_t mbedtls_ct_bool(mbedtls_ct_uint_t x)
+static inline mbedtls_ct_condition_t mbedtls_ct_bool(mbedtls_ct_uint_t x)
 {
     /*
      * Define mask-generation code that, as far as possible, will not use branches or conditional instructions.
@@ -217,7 +202,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool(mbedtls_ct_uint_t x)
 #endif
 }
 
-inline mbedtls_ct_uint_t mbedtls_ct_if(mbedtls_ct_condition_t condition,
+static inline mbedtls_ct_uint_t mbedtls_ct_if(mbedtls_ct_condition_t condition,
                                               mbedtls_ct_uint_t if1,
                                               mbedtls_ct_uint_t if0)
 {
@@ -283,7 +268,7 @@ inline mbedtls_ct_uint_t mbedtls_ct_if(mbedtls_ct_condition_t condition,
 #endif
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_uint_lt(mbedtls_ct_uint_t x, mbedtls_ct_uint_t y)
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_lt(mbedtls_ct_uint_t x, mbedtls_ct_uint_t y)
 {
 #if defined(MBEDTLS_CT_AARCH64_ASM) && (defined(MBEDTLS_CT_SIZE_32) || defined(MBEDTLS_CT_SIZE_64))
     uint64_t s1;
@@ -394,7 +379,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_uint_lt(mbedtls_ct_uint_t x, mbedtls_ct
 #endif
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_uint_ne(mbedtls_ct_uint_t x, mbedtls_ct_uint_t y)
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_ne(mbedtls_ct_uint_t x, mbedtls_ct_uint_t y)
 {
     /* diff = 0 if x == y, non-zero otherwise */
     const mbedtls_ct_uint_t diff = mbedtls_ct_compiler_opaque(x) ^ mbedtls_ct_compiler_opaque(y);
@@ -403,7 +388,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_uint_ne(mbedtls_ct_uint_t x, mbedtls_ct
     return mbedtls_ct_bool(diff);
 }
 
-inline unsigned char mbedtls_ct_uchar_in_range_if(unsigned char low,
+static inline unsigned char mbedtls_ct_uchar_in_range_if(unsigned char low,
                                                          unsigned char high,
                                                          unsigned char c,
                                                          unsigned char t)
@@ -423,21 +408,21 @@ inline unsigned char mbedtls_ct_uchar_in_range_if(unsigned char low,
  * Everything below here is trivial wrapper functions
  */
 
-inline size_t mbedtls_ct_size_if(mbedtls_ct_condition_t condition,
+static inline size_t mbedtls_ct_size_if(mbedtls_ct_condition_t condition,
                                         size_t if1,
                                         size_t if0)
 {
     return (size_t) mbedtls_ct_if(condition, (mbedtls_ct_uint_t) if1, (mbedtls_ct_uint_t) if0);
 }
 
-inline unsigned mbedtls_ct_uint_if(mbedtls_ct_condition_t condition,
+static inline unsigned mbedtls_ct_uint_if(mbedtls_ct_condition_t condition,
                                           unsigned if1,
                                           unsigned if0)
 {
     return (unsigned) mbedtls_ct_if(condition, (mbedtls_ct_uint_t) if1, (mbedtls_ct_uint_t) if0);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_bool_if(mbedtls_ct_condition_t condition,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_if(mbedtls_ct_condition_t condition,
                                                         mbedtls_ct_condition_t if1,
                                                         mbedtls_ct_condition_t if0)
 {
@@ -447,7 +432,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool_if(mbedtls_ct_condition_t conditio
 
 #if defined(MBEDTLS_BIGNUM_C)
 
-inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if(mbedtls_ct_condition_t condition,
+static inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if(mbedtls_ct_condition_t condition,
                                                       mbedtls_mpi_uint if1,
                                                       mbedtls_mpi_uint if0)
 {
@@ -458,17 +443,17 @@ inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if(mbedtls_ct_condition_t condition,
 
 #endif
 
-inline size_t mbedtls_ct_size_if_else_0(mbedtls_ct_condition_t condition, size_t if1)
+static inline size_t mbedtls_ct_size_if_else_0(mbedtls_ct_condition_t condition, size_t if1)
 {
     return (size_t) (condition & if1);
 }
 
-inline unsigned mbedtls_ct_uint_if_else_0(mbedtls_ct_condition_t condition, unsigned if1)
+static inline unsigned mbedtls_ct_uint_if_else_0(mbedtls_ct_condition_t condition, unsigned if1)
 {
     return (unsigned) (condition & if1);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_bool_if_else_0(mbedtls_ct_condition_t condition,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_if_else_0(mbedtls_ct_condition_t condition,
                                                                mbedtls_ct_condition_t if1)
 {
     return (mbedtls_ct_condition_t) (condition & if1);
@@ -476,7 +461,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool_if_else_0(mbedtls_ct_condition_t c
 
 #if defined(MBEDTLS_BIGNUM_C)
 
-inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if_else_0(mbedtls_ct_condition_t condition,
+static inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if_else_0(mbedtls_ct_condition_t condition,
                                                              mbedtls_mpi_uint if1)
 {
     return (mbedtls_mpi_uint) (condition & if1);
@@ -484,7 +469,7 @@ inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if_else_0(mbedtls_ct_condition_t con
 
 #endif /* MBEDTLS_BIGNUM_C */
 
-inline int mbedtls_ct_error_if(mbedtls_ct_condition_t condition, int if1, int if0)
+static inline int mbedtls_ct_error_if(mbedtls_ct_condition_t condition, int if1, int if0)
 {
     /* Coverting int -> uint -> int here is safe, because we require if1 and if0 to be
      * in the range -32767..0, and we require 32-bit int and uint types.
@@ -496,54 +481,54 @@ inline int mbedtls_ct_error_if(mbedtls_ct_condition_t condition, int if1, int if
                                  (mbedtls_ct_uint_t) (-if0)));
 }
 
-inline int mbedtls_ct_error_if_else_0(mbedtls_ct_condition_t condition, int if1)
+static inline int mbedtls_ct_error_if_else_0(mbedtls_ct_condition_t condition, int if1)
 {
     return -((int) (condition & (-if1)));
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_uint_eq(mbedtls_ct_uint_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_eq(mbedtls_ct_uint_t x,
                                                         mbedtls_ct_uint_t y)
 {
     return ~mbedtls_ct_uint_ne(x, y);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_uint_gt(mbedtls_ct_uint_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_gt(mbedtls_ct_uint_t x,
                                                         mbedtls_ct_uint_t y)
 {
     return mbedtls_ct_uint_lt(y, x);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_uint_ge(mbedtls_ct_uint_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_ge(mbedtls_ct_uint_t x,
                                                         mbedtls_ct_uint_t y)
 {
     return ~mbedtls_ct_uint_lt(x, y);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_uint_le(mbedtls_ct_uint_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_le(mbedtls_ct_uint_t x,
                                                         mbedtls_ct_uint_t y)
 {
     return ~mbedtls_ct_uint_gt(x, y);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_bool_ne(mbedtls_ct_condition_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_ne(mbedtls_ct_condition_t x,
                                                         mbedtls_ct_condition_t y)
 {
     return (mbedtls_ct_condition_t) (x ^ y);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_bool_and(mbedtls_ct_condition_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_and(mbedtls_ct_condition_t x,
                                                          mbedtls_ct_condition_t y)
 {
     return (mbedtls_ct_condition_t) (x & y);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_bool_or(mbedtls_ct_condition_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_or(mbedtls_ct_condition_t x,
                                                         mbedtls_ct_condition_t y)
 {
     return (mbedtls_ct_condition_t) (x | y);
 }
 
-inline mbedtls_ct_condition_t mbedtls_ct_bool_not(mbedtls_ct_condition_t x)
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_not(mbedtls_ct_condition_t x)
 {
     return (mbedtls_ct_condition_t) (~x);
 }

package/src/duckdb/third_party/mbedtls/library/constant_time_internal.h

@@ -58,7 +58,7 @@
  * (this has been observed to be constant-time on latest gcc, clang and MSVC
  * as of May 2023).
  *
- * For readability, the inline definitions are separated out into
+ * For readability, the static inline definitions are separated out into
  * constant_time_impl.h.
  */
 
@@ -96,7 +96,7 @@ typedef int32_t   mbedtls_ct_int_t;
  * \return MBEDTLS_CT_TRUE if \p x != 0, or MBEDTLS_CT_FALSE if \p x == 0
  *
  */
-inline mbedtls_ct_condition_t mbedtls_ct_bool(mbedtls_ct_uint_t x);
+static inline mbedtls_ct_condition_t mbedtls_ct_bool(mbedtls_ct_uint_t x);
 
 /** Boolean "not equal" operation.
  *
@@ -109,7 +109,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool(mbedtls_ct_uint_t x);
  *
  * \return      MBEDTLS_CT_TRUE if \p x != \p y, otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_uint_ne(mbedtls_ct_uint_t x, mbedtls_ct_uint_t y);
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_ne(mbedtls_ct_uint_t x, mbedtls_ct_uint_t y);
 
 /** Boolean "equals" operation.
  *
@@ -122,7 +122,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_uint_ne(mbedtls_ct_uint_t x, mbedtls_ct
  *
  * \return      MBEDTLS_CT_TRUE if \p x == \p y, otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_uint_eq(mbedtls_ct_uint_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_eq(mbedtls_ct_uint_t x,
                                                         mbedtls_ct_uint_t y);
 
 /** Boolean "less than" operation.
@@ -136,7 +136,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_uint_eq(mbedtls_ct_uint_t x,
  *
  * \return      MBEDTLS_CT_TRUE if \p x < \p y, otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_uint_lt(mbedtls_ct_uint_t x, mbedtls_ct_uint_t y);
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_lt(mbedtls_ct_uint_t x, mbedtls_ct_uint_t y);
 
 /** Boolean "greater than" operation.
  *
@@ -149,7 +149,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_uint_lt(mbedtls_ct_uint_t x, mbedtls_ct
  *
  * \return      MBEDTLS_CT_TRUE if \p x > \p y, otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_uint_gt(mbedtls_ct_uint_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_gt(mbedtls_ct_uint_t x,
                                                         mbedtls_ct_uint_t y);
 
 /** Boolean "greater or equal" operation.
@@ -164,7 +164,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_uint_gt(mbedtls_ct_uint_t x,
  * \return      MBEDTLS_CT_TRUE if \p x >= \p y,
  *              otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_uint_ge(mbedtls_ct_uint_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_ge(mbedtls_ct_uint_t x,
                                                         mbedtls_ct_uint_t y);
 
 /** Boolean "less than or equal" operation.
@@ -179,7 +179,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_uint_ge(mbedtls_ct_uint_t x,
  * \return      MBEDTLS_CT_TRUE if \p x <= \p y,
  *              otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_uint_le(mbedtls_ct_uint_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_uint_le(mbedtls_ct_uint_t x,
                                                         mbedtls_ct_uint_t y);
 
 /** Boolean not-equals operation.
@@ -197,7 +197,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_uint_le(mbedtls_ct_uint_t x,
  * \return      MBEDTLS_CT_TRUE if \p x != \p y,
  *              otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_bool_ne(mbedtls_ct_condition_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_ne(mbedtls_ct_condition_t x,
                                                         mbedtls_ct_condition_t y);
 
 /** Boolean "and" operation.
@@ -212,7 +212,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool_ne(mbedtls_ct_condition_t x,
  * \return      MBEDTLS_CT_TRUE if \p x && \p y,
  *              otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_bool_and(mbedtls_ct_condition_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_and(mbedtls_ct_condition_t x,
                                                          mbedtls_ct_condition_t y);
 
 /** Boolean "or" operation.
@@ -227,7 +227,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool_and(mbedtls_ct_condition_t x,
  * \return      MBEDTLS_CT_TRUE if \p x || \p y,
  *              otherwise MBEDTLS_CT_FALSE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_bool_or(mbedtls_ct_condition_t x,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_or(mbedtls_ct_condition_t x,
                                                         mbedtls_ct_condition_t y);
 
 /** Boolean "not" operation.
@@ -240,7 +240,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool_or(mbedtls_ct_condition_t x,
  *
  * \return      MBEDTLS_CT_FALSE if \p x, otherwise MBEDTLS_CT_TRUE.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_bool_not(mbedtls_ct_condition_t x);
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_not(mbedtls_ct_condition_t x);
 
 
 /* ============================================================================
@@ -259,7 +259,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool_not(mbedtls_ct_condition_t x);
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise \c if0.
  */
-inline size_t mbedtls_ct_size_if(mbedtls_ct_condition_t condition,
+static inline size_t mbedtls_ct_size_if(mbedtls_ct_condition_t condition,
                                         size_t if1,
                                         size_t if0);
 
@@ -275,7 +275,7 @@ inline size_t mbedtls_ct_size_if(mbedtls_ct_condition_t condition,
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise \c if0.
  */
-inline unsigned mbedtls_ct_uint_if(mbedtls_ct_condition_t condition,
+static inline unsigned mbedtls_ct_uint_if(mbedtls_ct_condition_t condition,
                                           unsigned if1,
                                           unsigned if0);
 
@@ -291,7 +291,7 @@ inline unsigned mbedtls_ct_uint_if(mbedtls_ct_condition_t condition,
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise \c if0.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_bool_if(mbedtls_ct_condition_t condition,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_if(mbedtls_ct_condition_t condition,
                                                         mbedtls_ct_condition_t if1,
                                                         mbedtls_ct_condition_t if0);
 
@@ -309,7 +309,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool_if(mbedtls_ct_condition_t conditio
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise \c if0.
  */
-inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if(mbedtls_ct_condition_t condition, \
+static inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if(mbedtls_ct_condition_t condition, \
                                                       mbedtls_mpi_uint if1, \
                                                       mbedtls_mpi_uint if0);
 
@@ -329,7 +329,7 @@ inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if(mbedtls_ct_condition_t condition,
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise 0.
  */
-inline unsigned mbedtls_ct_uint_if_else_0(mbedtls_ct_condition_t condition, unsigned if1);
+static inline unsigned mbedtls_ct_uint_if_else_0(mbedtls_ct_condition_t condition, unsigned if1);
 
 /** Choose between an mbedtls_ct_condition_t and 0.
  *
@@ -345,7 +345,7 @@ inline unsigned mbedtls_ct_uint_if_else_0(mbedtls_ct_condition_t condition, unsi
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise 0.
  */
-inline mbedtls_ct_condition_t mbedtls_ct_bool_if_else_0(mbedtls_ct_condition_t condition,
+static inline mbedtls_ct_condition_t mbedtls_ct_bool_if_else_0(mbedtls_ct_condition_t condition,
                                                                mbedtls_ct_condition_t if1);
 
 /** Choose between a size_t value and 0.
@@ -362,7 +362,7 @@ inline mbedtls_ct_condition_t mbedtls_ct_bool_if_else_0(mbedtls_ct_condition_t c
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise 0.
  */
-inline size_t mbedtls_ct_size_if_else_0(mbedtls_ct_condition_t condition, size_t if1);
+static inline size_t mbedtls_ct_size_if_else_0(mbedtls_ct_condition_t condition, size_t if1);
 
 #if defined(MBEDTLS_BIGNUM_C)
 
@@ -380,7 +380,7 @@ inline size_t mbedtls_ct_size_if_else_0(mbedtls_ct_condition_t condition, size_t
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise 0.
  */
-inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if_else_0(mbedtls_ct_condition_t condition,
+static inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if_else_0(mbedtls_ct_condition_t condition,
                                                              mbedtls_mpi_uint if1);
 
 #endif
@@ -394,7 +394,7 @@ inline mbedtls_mpi_uint mbedtls_ct_mpi_uint_if_else_0(mbedtls_ct_condition_t con
  *
  * \return      \p t if \p low <= \p c <= \p high, 0 otherwise.
  */
-inline unsigned char mbedtls_ct_uchar_in_range_if(unsigned char low,
+static inline unsigned char mbedtls_ct_uchar_in_range_if(unsigned char low,
                                                          unsigned char high,
                                                          unsigned char c,
                                                          unsigned char t);
@@ -411,7 +411,7 @@ inline unsigned char mbedtls_ct_uchar_in_range_if(unsigned char low,
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise \c if0.
  */
-inline int mbedtls_ct_error_if(mbedtls_ct_condition_t condition, int if1, int if0);
+static inline int mbedtls_ct_error_if(mbedtls_ct_condition_t condition, int if1, int if0);
 
 /** Choose between an error value and 0. The error value must be in the range [-32767..0].
  *
@@ -427,7 +427,7 @@ inline int mbedtls_ct_error_if(mbedtls_ct_condition_t condition, int if1, int if
  *
  * \return  \c if1 if \p condition == MBEDTLS_CT_TRUE, otherwise 0.
  */
-inline int mbedtls_ct_error_if_else_0(mbedtls_ct_condition_t condition, int if1);
+static inline int mbedtls_ct_error_if_else_0(mbedtls_ct_condition_t condition, int if1);
 
 /* ============================================================================
  * Block memory operations
@@ -573,7 +573,7 @@ int mbedtls_ct_memcmp_partial(const void *a,
 
 #endif
 
-/* Include the implementation of inline functions above. */
+/* Include the implementation of static inline functions above. */
 #include "constant_time_impl.h"
 
 #endif /* MBEDTLS_CONSTANT_TIME_INTERNAL_H */