@crossbind/port-openssl-linuxmusl 2.0.0-beta.66 → 2.0.0-beta.67

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/srp.h

@@ -50,9 +50,30 @@ typedef struct SRP_gN_cache_st {
 SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN_cache, SRP_gN_cache, SRP_gN_cache)
 #define sk_SRP_gN_cache_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_cache_sk_type(sk))
 #define sk_SRP_gN_cache_value(sk, idx) ((SRP_gN_cache *)OPENSSL_sk_value(ossl_check_const_SRP_gN_cache_sk_type(sk), (idx)))
-#define sk_SRP_gN_cache_new(cmp) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_SRP_gN_cache_compfunc_type(cmp)), sk_SRP_gN_cache_cmpfunc_thunk))
-#define sk_SRP_gN_cache_new_null() ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_SRP_gN_cache_freefunc_thunk))
-#define sk_SRP_gN_cache_new_reserve(cmp, n) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_SRP_gN_cache_compfunc_type(cmp), (n)), sk_SRP_gN_cache_cmpfunc_thunk))
+#define sk_SRP_gN_cache_new(cmp) \
+    ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_SRP_gN_cache_compfunc_type(cmp)), \
+                sk_SRP_gN_cache_cmpfunc_thunk), \
+            sk_SRP_gN_cache_copyfunc_thunk), \
+        sk_SRP_gN_cache_freefunc_thunk))
+#define sk_SRP_gN_cache_new_null() \
+    ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_SRP_gN_cache_cmpfunc_thunk), \
+            sk_SRP_gN_cache_copyfunc_thunk), \
+        sk_SRP_gN_cache_freefunc_thunk))
+#define sk_SRP_gN_cache_new_reserve(cmp, n) \
+    ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_SRP_gN_cache_compfunc_type(cmp), (n)), \
+                sk_SRP_gN_cache_cmpfunc_thunk), \
+            sk_SRP_gN_cache_copyfunc_thunk), \
+        sk_SRP_gN_cache_freefunc_thunk))
 #define sk_SRP_gN_cache_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_cache_sk_type(sk), (n))
 #define sk_SRP_gN_cache_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_cache_sk_type(sk))
 #define sk_SRP_gN_cache_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_cache_sk_type(sk))
@@ -70,8 +91,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN_cache, SRP_gN_cache, SRP_gN_cache)
 #define sk_SRP_gN_cache_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_type(ptr), pnum)
 #define sk_SRP_gN_cache_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_cache_sk_type(sk))
 #define sk_SRP_gN_cache_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_cache_sk_type(sk))
-#define sk_SRP_gN_cache_dup(sk) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_cache_sk_type(sk)))
-#define sk_SRP_gN_cache_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_copyfunc_type(copyfunc), ossl_check_SRP_gN_cache_freefunc_type(freefunc)))
+#define sk_SRP_gN_cache_dup(sk) \
+    ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_SRP_gN_cache_sk_type(sk)), \
+                sk_SRP_gN_cache_cmpfunc_thunk), \
+            sk_SRP_gN_cache_copyfunc_thunk), \
+        sk_SRP_gN_cache_freefunc_thunk))
+#define sk_SRP_gN_cache_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(SRP_gN_cache) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_SRP_gN_cache_sk_type(sk), \
+                    ossl_check_SRP_gN_cache_copyfunc_type(copyfunc), \
+                    ossl_check_SRP_gN_cache_freefunc_type(freefunc)), \
+                sk_SRP_gN_cache_cmpfunc_thunk), \
+            sk_SRP_gN_cache_copyfunc_thunk), \
+        sk_SRP_gN_cache_freefunc_thunk))
 #define sk_SRP_gN_cache_set_cmp_func(sk, cmp) ((sk_SRP_gN_cache_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_cache_sk_type(sk), ossl_check_SRP_gN_cache_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -91,9 +129,30 @@ typedef struct SRP_user_pwd_st {
 SKM_DEFINE_STACK_OF_INTERNAL(SRP_user_pwd, SRP_user_pwd, SRP_user_pwd)
 #define sk_SRP_user_pwd_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_user_pwd_sk_type(sk))
 #define sk_SRP_user_pwd_value(sk, idx) ((SRP_user_pwd *)OPENSSL_sk_value(ossl_check_const_SRP_user_pwd_sk_type(sk), (idx)))
-#define sk_SRP_user_pwd_new(cmp) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_SRP_user_pwd_compfunc_type(cmp)), sk_SRP_user_pwd_cmpfunc_thunk))
-#define sk_SRP_user_pwd_new_null() ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_SRP_user_pwd_freefunc_thunk))
-#define sk_SRP_user_pwd_new_reserve(cmp, n) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_SRP_user_pwd_compfunc_type(cmp), (n)), sk_SRP_user_pwd_cmpfunc_thunk))
+#define sk_SRP_user_pwd_new(cmp) \
+    ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_SRP_user_pwd_compfunc_type(cmp)), \
+                sk_SRP_user_pwd_cmpfunc_thunk), \
+            sk_SRP_user_pwd_copyfunc_thunk), \
+        sk_SRP_user_pwd_freefunc_thunk))
+#define sk_SRP_user_pwd_new_null() \
+    ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_SRP_user_pwd_cmpfunc_thunk), \
+            sk_SRP_user_pwd_copyfunc_thunk), \
+        sk_SRP_user_pwd_freefunc_thunk))
+#define sk_SRP_user_pwd_new_reserve(cmp, n) \
+    ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_SRP_user_pwd_compfunc_type(cmp), (n)), \
+                sk_SRP_user_pwd_cmpfunc_thunk), \
+            sk_SRP_user_pwd_copyfunc_thunk), \
+        sk_SRP_user_pwd_freefunc_thunk))
 #define sk_SRP_user_pwd_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_user_pwd_sk_type(sk), (n))
 #define sk_SRP_user_pwd_free(sk) OPENSSL_sk_free(ossl_check_SRP_user_pwd_sk_type(sk))
 #define sk_SRP_user_pwd_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_user_pwd_sk_type(sk))
@@ -111,8 +170,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(SRP_user_pwd, SRP_user_pwd, SRP_user_pwd)
 #define sk_SRP_user_pwd_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_type(ptr), pnum)
 #define sk_SRP_user_pwd_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_user_pwd_sk_type(sk))
 #define sk_SRP_user_pwd_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_user_pwd_sk_type(sk))
-#define sk_SRP_user_pwd_dup(sk) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_dup(ossl_check_const_SRP_user_pwd_sk_type(sk)))
-#define sk_SRP_user_pwd_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_copyfunc_type(copyfunc), ossl_check_SRP_user_pwd_freefunc_type(freefunc)))
+#define sk_SRP_user_pwd_dup(sk) \
+    ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_SRP_user_pwd_sk_type(sk)), \
+                sk_SRP_user_pwd_cmpfunc_thunk), \
+            sk_SRP_user_pwd_copyfunc_thunk), \
+        sk_SRP_user_pwd_freefunc_thunk))
+#define sk_SRP_user_pwd_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(SRP_user_pwd) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_SRP_user_pwd_sk_type(sk), \
+                    ossl_check_SRP_user_pwd_copyfunc_type(copyfunc), \
+                    ossl_check_SRP_user_pwd_freefunc_type(freefunc)), \
+                sk_SRP_user_pwd_cmpfunc_thunk), \
+            sk_SRP_user_pwd_copyfunc_thunk), \
+        sk_SRP_user_pwd_freefunc_thunk))
 #define sk_SRP_user_pwd_set_cmp_func(sk, cmp) ((sk_SRP_user_pwd_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_user_pwd_sk_type(sk), ossl_check_SRP_user_pwd_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -152,9 +228,30 @@ typedef struct SRP_gN_st {
 SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN, SRP_gN, SRP_gN)
 #define sk_SRP_gN_num(sk) OPENSSL_sk_num(ossl_check_const_SRP_gN_sk_type(sk))
 #define sk_SRP_gN_value(sk, idx) ((SRP_gN *)OPENSSL_sk_value(ossl_check_const_SRP_gN_sk_type(sk), (idx)))
-#define sk_SRP_gN_new(cmp) ((STACK_OF(SRP_gN) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_SRP_gN_compfunc_type(cmp)), sk_SRP_gN_cmpfunc_thunk))
-#define sk_SRP_gN_new_null() ((STACK_OF(SRP_gN) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_SRP_gN_freefunc_thunk))
-#define sk_SRP_gN_new_reserve(cmp, n) ((STACK_OF(SRP_gN) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_SRP_gN_compfunc_type(cmp), (n)), sk_SRP_gN_cmpfunc_thunk))
+#define sk_SRP_gN_new(cmp) \
+    ((STACK_OF(SRP_gN) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_SRP_gN_compfunc_type(cmp)), \
+                sk_SRP_gN_cmpfunc_thunk), \
+            sk_SRP_gN_copyfunc_thunk), \
+        sk_SRP_gN_freefunc_thunk))
+#define sk_SRP_gN_new_null() \
+    ((STACK_OF(SRP_gN) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_SRP_gN_cmpfunc_thunk), \
+            sk_SRP_gN_copyfunc_thunk), \
+        sk_SRP_gN_freefunc_thunk))
+#define sk_SRP_gN_new_reserve(cmp, n) \
+    ((STACK_OF(SRP_gN) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_SRP_gN_compfunc_type(cmp), (n)), \
+                sk_SRP_gN_cmpfunc_thunk), \
+            sk_SRP_gN_copyfunc_thunk), \
+        sk_SRP_gN_freefunc_thunk))
 #define sk_SRP_gN_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRP_gN_sk_type(sk), (n))
 #define sk_SRP_gN_free(sk) OPENSSL_sk_free(ossl_check_SRP_gN_sk_type(sk))
 #define sk_SRP_gN_zero(sk) OPENSSL_sk_zero(ossl_check_SRP_gN_sk_type(sk))
@@ -172,8 +269,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(SRP_gN, SRP_gN, SRP_gN)
 #define sk_SRP_gN_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_type(ptr), pnum)
 #define sk_SRP_gN_sort(sk) OPENSSL_sk_sort(ossl_check_SRP_gN_sk_type(sk))
 #define sk_SRP_gN_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRP_gN_sk_type(sk))
-#define sk_SRP_gN_dup(sk) ((STACK_OF(SRP_gN) *)OPENSSL_sk_dup(ossl_check_const_SRP_gN_sk_type(sk)))
-#define sk_SRP_gN_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRP_gN) *)OPENSSL_sk_deep_copy(ossl_check_const_SRP_gN_sk_type(sk), ossl_check_SRP_gN_copyfunc_type(copyfunc), ossl_check_SRP_gN_freefunc_type(freefunc)))
+#define sk_SRP_gN_dup(sk) \
+    ((STACK_OF(SRP_gN) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_SRP_gN_sk_type(sk)), \
+                sk_SRP_gN_cmpfunc_thunk), \
+            sk_SRP_gN_copyfunc_thunk), \
+        sk_SRP_gN_freefunc_thunk))
+#define sk_SRP_gN_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(SRP_gN) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_SRP_gN_sk_type(sk), \
+                    ossl_check_SRP_gN_copyfunc_type(copyfunc), \
+                    ossl_check_SRP_gN_freefunc_type(freefunc)), \
+                sk_SRP_gN_cmpfunc_thunk), \
+            sk_SRP_gN_copyfunc_thunk), \
+        sk_SRP_gN_freefunc_thunk))
 #define sk_SRP_gN_set_cmp_func(sk, cmp) ((sk_SRP_gN_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRP_gN_sk_type(sk), ossl_check_SRP_gN_compfunc_type(cmp)))
 
 /* clang-format on */

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/ssl.h

@@ -250,9 +250,30 @@ typedef struct srtp_protection_profile_st {
 SKM_DEFINE_STACK_OF_INTERNAL(SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE)
 #define sk_SRTP_PROTECTION_PROFILE_num(sk) OPENSSL_sk_num(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk))
 #define sk_SRTP_PROTECTION_PROFILE_value(sk, idx) ((SRTP_PROTECTION_PROFILE *)OPENSSL_sk_value(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), (idx)))
-#define sk_SRTP_PROTECTION_PROFILE_new(cmp) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)), sk_SRTP_PROTECTION_PROFILE_cmpfunc_thunk))
-#define sk_SRTP_PROTECTION_PROFILE_new_null() ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_SRTP_PROTECTION_PROFILE_freefunc_thunk))
-#define sk_SRTP_PROTECTION_PROFILE_new_reserve(cmp, n) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp), (n)), sk_SRTP_PROTECTION_PROFILE_cmpfunc_thunk))
+#define sk_SRTP_PROTECTION_PROFILE_new(cmp) \
+    ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)), \
+                sk_SRTP_PROTECTION_PROFILE_cmpfunc_thunk), \
+            sk_SRTP_PROTECTION_PROFILE_copyfunc_thunk), \
+        sk_SRTP_PROTECTION_PROFILE_freefunc_thunk))
+#define sk_SRTP_PROTECTION_PROFILE_new_null() \
+    ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_SRTP_PROTECTION_PROFILE_cmpfunc_thunk), \
+            sk_SRTP_PROTECTION_PROFILE_copyfunc_thunk), \
+        sk_SRTP_PROTECTION_PROFILE_freefunc_thunk))
+#define sk_SRTP_PROTECTION_PROFILE_new_reserve(cmp, n) \
+    ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp), (n)), \
+                sk_SRTP_PROTECTION_PROFILE_cmpfunc_thunk), \
+            sk_SRTP_PROTECTION_PROFILE_copyfunc_thunk), \
+        sk_SRTP_PROTECTION_PROFILE_freefunc_thunk))
 #define sk_SRTP_PROTECTION_PROFILE_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), (n))
 #define sk_SRTP_PROTECTION_PROFILE_free(sk) OPENSSL_sk_free(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
 #define sk_SRTP_PROTECTION_PROFILE_zero(sk) OPENSSL_sk_zero(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
@@ -270,8 +291,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(SRTP_PROTECTION_PROFILE, SRTP_PROTECTION_PROFILE, S
 #define sk_SRTP_PROTECTION_PROFILE_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_type(ptr), pnum)
 #define sk_SRTP_PROTECTION_PROFILE_sort(sk) OPENSSL_sk_sort(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk))
 #define sk_SRTP_PROTECTION_PROFILE_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk))
-#define sk_SRTP_PROTECTION_PROFILE_dup(sk) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_dup(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk)))
-#define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_deep_copy(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_copyfunc_type(copyfunc), ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc)))
+#define sk_SRTP_PROTECTION_PROFILE_dup(sk) \
+    ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk)), \
+                sk_SRTP_PROTECTION_PROFILE_cmpfunc_thunk), \
+            sk_SRTP_PROTECTION_PROFILE_copyfunc_thunk), \
+        sk_SRTP_PROTECTION_PROFILE_freefunc_thunk))
+#define sk_SRTP_PROTECTION_PROFILE_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(SRTP_PROTECTION_PROFILE) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_SRTP_PROTECTION_PROFILE_sk_type(sk), \
+                    ossl_check_SRTP_PROTECTION_PROFILE_copyfunc_type(copyfunc), \
+                    ossl_check_SRTP_PROTECTION_PROFILE_freefunc_type(freefunc)), \
+                sk_SRTP_PROTECTION_PROFILE_cmpfunc_thunk), \
+            sk_SRTP_PROTECTION_PROFILE_copyfunc_thunk), \
+        sk_SRTP_PROTECTION_PROFILE_freefunc_thunk))
 #define sk_SRTP_PROTECTION_PROFILE_set_cmp_func(sk, cmp) ((sk_SRTP_PROTECTION_PROFILE_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SRTP_PROTECTION_PROFILE_sk_type(sk), ossl_check_SRTP_PROTECTION_PROFILE_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -361,7 +399,7 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
 #define SSL_OP_LEGACY_SERVER_CONNECT SSL_OP_BIT(2)
 /* Enable support for Kernel TLS */
 #define SSL_OP_ENABLE_KTLS SSL_OP_BIT(3)
-#define SSL_OP_TLSEXT_PADDING SSL_OP_BIT(4)
+/* SSL_OP_BIT(4) was SSL_OP_TLSEXT_PADDING, now a no-op */
 #define SSL_OP_SAFARI_ECDHE_ECDSA_BUG SSL_OP_BIT(6)
 #define SSL_OP_IGNORE_UNEXPECTED_EOF SSL_OP_BIT(7)
 #define SSL_OP_ALLOW_CLIENT_RENEGOTIATION SSL_OP_BIT(8)
@@ -369,7 +407,7 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
 /* In TLSv1.3 allow a non-(ec)dhe based kex_mode */
 #define SSL_OP_ALLOW_NO_DHE_KEX SSL_OP_BIT(10)
 /*
- * Disable SSL 3.0/TLS 1.0 CBC vulnerability workaround that was added
+ * Disable TLS 1.0 CBC vulnerability workaround that was added
  * in OpenSSL 0.9.6d.  Usually (depending on the application protocol)
  * the workaround is not needed.  Unfortunately some broken SSL/TLS
  * implementations cannot handle it at all, which is why we include it
@@ -433,6 +471,7 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
 #define SSL_OP_NO_TLSv1_3 SSL_OP_BIT(29)
 #define SSL_OP_NO_DTLSv1 SSL_OP_BIT(26)
 #define SSL_OP_NO_DTLSv1_2 SSL_OP_BIT(27)
+#define SSL_OP_NO_DTLSv1_3 SSL_OP_BIT(29)
 /* Disallow all renegotiation */
 #define SSL_OP_NO_RENEGOTIATION SSL_OP_BIT(30)
 /*
@@ -476,6 +515,9 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
 #define SSL_OP_ECH_GREASE_RETRY_CONFIG SSL_OP_BIT(40)
 #endif
 
+/* RFC 8701: Send GREASE values in ClientHello */
+#define SSL_OP_GREASE SSL_OP_BIT(41)
+
 /*
  * Option "collections."
  */
@@ -488,7 +530,7 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
 /* Various bug workarounds that should be rather harmless. */
 #define SSL_OP_ALL                                                    \
     (SSL_OP_CRYPTOPRO_TLSEXT_BUG | SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS \
-        | SSL_OP_TLSEXT_PADDING | SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
+        | SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
 
 /*
  * OBSOLETE OPTIONS retained for compatibility
@@ -511,6 +553,7 @@ typedef int (*SSL_async_callback_fn)(SSL *s, void *arg);
 #define SSL_OP_PKCS1_CHECK_2 0x0
 #define SSL_OP_NETSCAPE_CA_DN_BUG 0x0
 #define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG 0x0
+#define SSL_OP_TLSEXT_PADDING 0x0
 
 /*
  * Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success
@@ -1027,9 +1070,30 @@ extern "C" {
 SKM_DEFINE_STACK_OF_INTERNAL(SSL_CIPHER, const SSL_CIPHER, SSL_CIPHER)
 #define sk_SSL_CIPHER_num(sk) OPENSSL_sk_num(ossl_check_const_SSL_CIPHER_sk_type(sk))
 #define sk_SSL_CIPHER_value(sk, idx) ((const SSL_CIPHER *)OPENSSL_sk_value(ossl_check_const_SSL_CIPHER_sk_type(sk), (idx)))
-#define sk_SSL_CIPHER_new(cmp) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_SSL_CIPHER_compfunc_type(cmp)), sk_SSL_CIPHER_cmpfunc_thunk))
-#define sk_SSL_CIPHER_new_null() ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_SSL_CIPHER_freefunc_thunk))
-#define sk_SSL_CIPHER_new_reserve(cmp, n) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_SSL_CIPHER_compfunc_type(cmp), (n)), sk_SSL_CIPHER_cmpfunc_thunk))
+#define sk_SSL_CIPHER_new(cmp) \
+    ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_SSL_CIPHER_compfunc_type(cmp)), \
+                sk_SSL_CIPHER_cmpfunc_thunk), \
+            sk_SSL_CIPHER_copyfunc_thunk), \
+        sk_SSL_CIPHER_freefunc_thunk))
+#define sk_SSL_CIPHER_new_null() \
+    ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_SSL_CIPHER_cmpfunc_thunk), \
+            sk_SSL_CIPHER_copyfunc_thunk), \
+        sk_SSL_CIPHER_freefunc_thunk))
+#define sk_SSL_CIPHER_new_reserve(cmp, n) \
+    ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_SSL_CIPHER_compfunc_type(cmp), (n)), \
+                sk_SSL_CIPHER_cmpfunc_thunk), \
+            sk_SSL_CIPHER_copyfunc_thunk), \
+        sk_SSL_CIPHER_freefunc_thunk))
 #define sk_SSL_CIPHER_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_SSL_CIPHER_sk_type(sk), (n))
 #define sk_SSL_CIPHER_free(sk) OPENSSL_sk_free(ossl_check_SSL_CIPHER_sk_type(sk))
 #define sk_SSL_CIPHER_zero(sk) OPENSSL_sk_zero(ossl_check_SSL_CIPHER_sk_type(sk))
@@ -1047,8 +1111,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(SSL_CIPHER, const SSL_CIPHER, SSL_CIPHER)
 #define sk_SSL_CIPHER_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_type(ptr), pnum)
 #define sk_SSL_CIPHER_sort(sk) OPENSSL_sk_sort(ossl_check_SSL_CIPHER_sk_type(sk))
 #define sk_SSL_CIPHER_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_SSL_CIPHER_sk_type(sk))
-#define sk_SSL_CIPHER_dup(sk) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_dup(ossl_check_const_SSL_CIPHER_sk_type(sk)))
-#define sk_SSL_CIPHER_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_deep_copy(ossl_check_const_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_copyfunc_type(copyfunc), ossl_check_SSL_CIPHER_freefunc_type(freefunc)))
+#define sk_SSL_CIPHER_dup(sk) \
+    ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_SSL_CIPHER_sk_type(sk)), \
+                sk_SSL_CIPHER_cmpfunc_thunk), \
+            sk_SSL_CIPHER_copyfunc_thunk), \
+        sk_SSL_CIPHER_freefunc_thunk))
+#define sk_SSL_CIPHER_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(SSL_CIPHER) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_SSL_CIPHER_sk_type(sk), \
+                    ossl_check_SSL_CIPHER_copyfunc_type(copyfunc), \
+                    ossl_check_SSL_CIPHER_freefunc_type(freefunc)), \
+                sk_SSL_CIPHER_cmpfunc_thunk), \
+            sk_SSL_CIPHER_copyfunc_thunk), \
+        sk_SSL_CIPHER_freefunc_thunk))
 #define sk_SSL_CIPHER_set_cmp_func(sk, cmp) ((sk_SSL_CIPHER_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_SSL_CIPHER_sk_type(sk), ossl_check_SSL_CIPHER_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -1139,7 +1220,11 @@ typedef enum {
     TLS_ST_EARLY_DATA,
     TLS_ST_PENDING_EARLY_DATA_END,
     TLS_ST_CW_END_OF_EARLY_DATA,
-    TLS_ST_SR_END_OF_EARLY_DATA
+    TLS_ST_SR_END_OF_EARLY_DATA,
+    TLS_ST_CR_ACK,
+    TLS_ST_CW_ACK,
+    TLS_ST_SR_ACK,
+    TLS_ST_SW_ACK
 } OSSL_HANDSHAKE_STATE;
 
 /*
@@ -2359,6 +2444,8 @@ __owur int SSL_is_connection(SSL *s);
 __owur int SSL_is_listener(SSL *ssl);
 __owur SSL *SSL_get0_listener(SSL *s);
 #define SSL_LISTENER_FLAG_NO_VALIDATE (1UL << 1)
+#define SSL_LISTENER_FLAG_ADDRESS_VALIDATION (1UL << 2)
+#define SSL_LISTENER_FLAG_SINGLE_THREAD (1UL << 3)
 __owur SSL *SSL_new_listener(SSL_CTX *ctx, uint64_t flags);
 __owur SSL *SSL_new_listener_from(SSL *ssl, uint64_t flags);
 __owur SSL *SSL_new_from_listener(SSL *ssl, uint64_t flags);
@@ -2484,8 +2571,18 @@ __owur int SSL_get_conn_close_info(SSL *ssl,
 #define SSL_VALUE_STREAM_WRITE_BUF_SIZE 7
 #define SSL_VALUE_STREAM_WRITE_BUF_USED 8
 #define SSL_VALUE_STREAM_WRITE_BUF_AVAIL 9
+#define SSL_VALUE_QUIC_UDP_PAYLOAD_SIZE_MAX 10
+#define SSL_VALUE_QUIC_WINDOWCON 11
+#define SSL_VALUE_QUIC_WINDOWBSTR 12
+#define SSL_VALUE_QUIC_WINDOWUSTR 13
+#define SSL_VALUE_QUIC_ACK_DELAY_EXPONENT 14
+#define SSL_VALUE_QUIC_ACK_DELAY_MAX 15
 #define SSL_VALUE_QUIC_MAX_PENDING_CONNS 16
 
+#define SSL_VALUE_DTLS_LISTENER_MAX_PENDING_CONNS 17
+#define SSL_VALUE_DTLS_LISTENER_PENDING_TIMEOUT 18
+#define SSL_VALUE_DTLS_LISTENER_MAX_DGRAM_SIZE 19
+
 #define SSL_VALUE_EVENT_HANDLING_MODE_INHERIT 0
 #define SSL_VALUE_EVENT_HANDLING_MODE_IMPLICIT 1
 #define SSL_VALUE_EVENT_HANDLING_MODE_EXPLICIT 2
@@ -2823,8 +2920,11 @@ __owur void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx);
 int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
 
 #ifndef OPENSSL_NO_UNIT_TEST
+#ifndef OPENSSL_NO_DEPRECATED_4_1
+OSSL_DEPRECATEDIN_4_1
 __owur const struct openssl_ssl_test_functions *SSL_test_functions(void);
 #endif
+#endif
 
 __owur int SSL_free_buffers(SSL *ssl);
 __owur int SSL_alloc_buffers(SSL *ssl);

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/ssl3.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
@@ -173,8 +173,6 @@ extern "C" {
 
 #define SSL3_RT_MAX_EXTRA (16384)
 
-/* Maximum plaintext length: defined by SSL/TLS standards */
-#define SSL3_RT_MAX_PLAIN_LENGTH 16384
 /* Maximum compression overhead: defined by SSL/TLS standards */
 #define SSL3_RT_MAX_COMPRESSED_OVERHEAD 1024
 
@@ -220,6 +218,7 @@ extern "C" {
 #define SSL3_RT_ALERT 21
 #define SSL3_RT_HANDSHAKE 22
 #define SSL3_RT_APPLICATION_DATA 23
+#define SSL3_RT_ACK 26 /* RFC 9147 */
 
 /* Pseudo content types to indicate additional parameters */
 #define TLS1_RT_CRYPTO 0x1000
@@ -333,6 +332,9 @@ extern "C" {
 #define SSL3_MT_MESSAGE_HASH 254
 #define DTLS1_MT_HELLO_VERIFY_REQUEST 3
 
+/* Dummy message type for handling ACK like a normal handshake message */
+#define DTLS13_MT_ACK 0x0126
+
 /* Dummy message type for handling CCS like a normal handshake message */
 #define SSL3_MT_CHANGE_CIPHER_SPEC 0x0101
 
@@ -346,6 +348,7 @@ extern "C" {
 #define SSL3_CC_EARLY 0x040
 #define SSL3_CC_HANDSHAKE 0x080
 #define SSL3_CC_APPLICATION 0x100
+#define SSL3_CC_COMP_CERT 0x200
 #define SSL3_CHANGE_CIPHER_CLIENT_WRITE (SSL3_CC_CLIENT | SSL3_CC_WRITE)
 #define SSL3_CHANGE_CIPHER_SERVER_READ (SSL3_CC_SERVER | SSL3_CC_READ)
 #define SSL3_CHANGE_CIPHER_CLIENT_READ (SSL3_CC_CLIENT | SSL3_CC_READ)

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/stack.h

@@ -26,6 +26,7 @@ typedef int (*OPENSSL_sk_compfunc)(const void *, const void *);
 typedef void (*OPENSSL_sk_freefunc)(void *);
 typedef void (*OPENSSL_sk_freefunc_thunk)(OPENSSL_sk_freefunc, void *);
 typedef void *(*OPENSSL_sk_copyfunc)(const void *);
+typedef void *(*OPENSSL_sk_copyfunc_thunk)(OPENSSL_sk_copyfunc, const void *);
 
 int OPENSSL_sk_num(const OPENSSL_STACK *);
 void *OPENSSL_sk_value(const OPENSSL_STACK *, int);
@@ -37,6 +38,7 @@ OPENSSL_STACK *OPENSSL_sk_new_null(void);
 OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n);
 OPENSSL_STACK *OPENSSL_sk_set_thunks(OPENSSL_STACK *st, OPENSSL_sk_freefunc_thunk f_thunk);
 OPENSSL_STACK *OPENSSL_sk_set_cmp_thunks(OPENSSL_STACK *st, int (*c_thunk)(int (*)(const void *, const void *), const void *, const void *));
+OPENSSL_STACK *OPENSSL_sk_set_copy_thunks(OPENSSL_STACK *st, OPENSSL_sk_copyfunc_thunk cp_thunk);
 int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n);
 void OPENSSL_sk_free(OPENSSL_STACK *);
 void OPENSSL_sk_pop_free(OPENSSL_STACK *st, OPENSSL_sk_freefunc func);

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/storeerr.h

@@ -1,6 +1,6 @@
 /*
  * Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/tls1.h

@@ -1103,10 +1103,6 @@ int SSL_CTX_set_tlsext_ticket_key_evp_cb(SSL_CTX *ctx, int (*fp)(SSL *, unsigned
 #define TLS1_TXT_ECDH_RSA_WITH_AES_128_GCM_SHA256 "ECDH-RSA-AES128-GCM-SHA256"
 #define TLS1_TXT_ECDH_RSA_WITH_AES_256_GCM_SHA384 "ECDH-RSA-AES256-GCM-SHA384"
 
-/* TLS v1.2 PSK GCM ciphersuites from RFC5487 */
-#define TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256 "PSK-AES128-GCM-SHA256"
-#define TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384 "PSK-AES256-GCM-SHA384"
-
 /* ECDHE PSK ciphersuites from RFC 5489 */
 #define TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA "ECDHE-PSK-RC4-SHA"
 #define TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA "ECDHE-PSK-3DES-EDE-CBC-SHA"
@@ -1216,9 +1212,6 @@ int SSL_CTX_set_tlsext_ticket_key_evp_cb(SSL_CTX *ctx, int (*fp)(SSL *, unsigned
 /* ASCII: "client write key", in hex for EBCDIC compatibility */
 #define TLS_MD_CLIENT_WRITE_KEY_CONST "\x63\x6c\x69\x65\x6e\x74\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
 #define TLS_MD_CLIENT_WRITE_KEY_CONST_SIZE 16
-/* ASCII: "server write key", in hex for EBCDIC compatibility */
-#define TLS_MD_SERVER_WRITE_KEY_CONST "\x73\x65\x72\x76\x65\x72\x20\x77\x72\x69\x74\x65\x20\x6b\x65\x79"
-#define TLS_MD_SERVER_WRITE_KEY_CONST_SIZE 16
 /* ASCII: "IV block", in hex for EBCDIC compatibility */
 #define TLS_MD_IV_BLOCK_CONST "\x49\x56\x20\x62\x6c\x6f\x63\x6b"
 #define TLS_MD_IV_BLOCK_CONST_SIZE 8

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/ts.h

@@ -418,19 +418,19 @@ void TS_VERIFY_CTX_cleanup(TS_VERIFY_CTX *ctx);
 int TS_VERIFY_CTX_set_flags(TS_VERIFY_CTX *ctx, int f);
 int TS_VERIFY_CTX_add_flags(TS_VERIFY_CTX *ctx, int f);
 #ifndef OPENSSL_NO_DEPRECATED_3_4
-OSSL_DEPRECATEDIN_3_4_FOR("Unclear semantics, replace with TS_VERIFY_CTX_set0_data().")
+OSSL_DEPRECATEDIN_3_4_FOR("unclear semantics, replace with TS_VERIFY_CTX_set0_data()")
 BIO *TS_VERIFY_CTX_set_data(TS_VERIFY_CTX *ctx, BIO *b);
 #endif
 int TS_VERIFY_CTX_set0_data(TS_VERIFY_CTX *ctx, BIO *b);
 #ifndef OPENSSL_NO_DEPRECATED_3_4
-OSSL_DEPRECATEDIN_3_4_FOR("Unclear semantics, replace with TS_VERIFY_CTX_set0_imprint().")
+OSSL_DEPRECATEDIN_3_4_FOR("unclear semantics, replace with TS_VERIFY_CTX_set0_imprint()")
 unsigned char *TS_VERIFY_CTX_set_imprint(TS_VERIFY_CTX *ctx,
     unsigned char *hexstr, long len);
 #endif
 int TS_VERIFY_CTX_set0_imprint(TS_VERIFY_CTX *ctx,
     unsigned char *hexstr, long len);
 #ifndef OPENSSL_NO_DEPRECATED_3_4
-OSSL_DEPRECATEDIN_3_4_FOR("Unclear semantics, replace with TS_VERIFY_CTX_set0_store().")
+OSSL_DEPRECATEDIN_3_4_FOR("unclear semantics, replace with TS_VERIFY_CTX_set0_store()")
 X509_STORE *TS_VERIFY_CTX_set_store(TS_VERIFY_CTX *ctx, X509_STORE *s);
 #endif
 int TS_VERIFY_CTX_set0_store(TS_VERIFY_CTX *ctx, X509_STORE *s);
@@ -438,7 +438,7 @@ int TS_VERIFY_CTX_set0_store(TS_VERIFY_CTX *ctx, X509_STORE *s);
 #define TS_VERIFY_CTS_set_certs(ctx, cert) TS_VERIFY_CTX_set_certs(ctx, cert)
 #endif
 #ifndef OPENSSL_NO_DEPRECATED_3_4
-OSSL_DEPRECATEDIN_3_4_FOR("Unclear semantics, replace with TS_VERIFY_CTX_set0_certs().")
+OSSL_DEPRECATEDIN_3_4_FOR("unclear semantics, replace with TS_VERIFY_CTX_set0_certs()")
 STACK_OF(X509) *TS_VERIFY_CTX_set_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs);
 #endif
 int TS_VERIFY_CTX_set0_certs(TS_VERIFY_CTX *ctx, STACK_OF(X509) *certs);

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/tserr.h

@@ -1,6 +1,6 @@
 /*
  * Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -17,7 +17,6 @@
 #include <openssl/cryptoerr_legacy.h>
 
 #ifndef OPENSSL_NO_TS
-
 /*
  * TS reason codes.
  */

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/types.h

@@ -11,6 +11,7 @@
  * Unfortunate workaround to avoid symbol conflict with wincrypt.h
  * See https://github.com/openssl/openssl/issues/9981
  */
+
 #ifdef _WIN32
 #define WINCRYPT_USE_SYMBOL_PREFIX
 #undef X509_NAME

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/ui.h

@@ -296,9 +296,30 @@ typedef struct ui_string_st UI_STRING;
 SKM_DEFINE_STACK_OF_INTERNAL(UI_STRING, UI_STRING, UI_STRING)
 #define sk_UI_STRING_num(sk) OPENSSL_sk_num(ossl_check_const_UI_STRING_sk_type(sk))
 #define sk_UI_STRING_value(sk, idx) ((UI_STRING *)OPENSSL_sk_value(ossl_check_const_UI_STRING_sk_type(sk), (idx)))
-#define sk_UI_STRING_new(cmp) ((STACK_OF(UI_STRING) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_UI_STRING_compfunc_type(cmp)), sk_UI_STRING_cmpfunc_thunk))
-#define sk_UI_STRING_new_null() ((STACK_OF(UI_STRING) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_UI_STRING_freefunc_thunk))
-#define sk_UI_STRING_new_reserve(cmp, n) ((STACK_OF(UI_STRING) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_UI_STRING_compfunc_type(cmp), (n)), sk_UI_STRING_cmpfunc_thunk))
+#define sk_UI_STRING_new(cmp) \
+    ((STACK_OF(UI_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_UI_STRING_compfunc_type(cmp)), \
+                sk_UI_STRING_cmpfunc_thunk), \
+            sk_UI_STRING_copyfunc_thunk), \
+        sk_UI_STRING_freefunc_thunk))
+#define sk_UI_STRING_new_null() \
+    ((STACK_OF(UI_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_UI_STRING_cmpfunc_thunk), \
+            sk_UI_STRING_copyfunc_thunk), \
+        sk_UI_STRING_freefunc_thunk))
+#define sk_UI_STRING_new_reserve(cmp, n) \
+    ((STACK_OF(UI_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_UI_STRING_compfunc_type(cmp), (n)), \
+                sk_UI_STRING_cmpfunc_thunk), \
+            sk_UI_STRING_copyfunc_thunk), \
+        sk_UI_STRING_freefunc_thunk))
 #define sk_UI_STRING_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_UI_STRING_sk_type(sk), (n))
 #define sk_UI_STRING_free(sk) OPENSSL_sk_free(ossl_check_UI_STRING_sk_type(sk))
 #define sk_UI_STRING_zero(sk) OPENSSL_sk_zero(ossl_check_UI_STRING_sk_type(sk))
@@ -316,8 +337,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(UI_STRING, UI_STRING, UI_STRING)
 #define sk_UI_STRING_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_type(ptr), pnum)
 #define sk_UI_STRING_sort(sk) OPENSSL_sk_sort(ossl_check_UI_STRING_sk_type(sk))
 #define sk_UI_STRING_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_UI_STRING_sk_type(sk))
-#define sk_UI_STRING_dup(sk) ((STACK_OF(UI_STRING) *)OPENSSL_sk_dup(ossl_check_const_UI_STRING_sk_type(sk)))
-#define sk_UI_STRING_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(UI_STRING) *)OPENSSL_sk_deep_copy(ossl_check_const_UI_STRING_sk_type(sk), ossl_check_UI_STRING_copyfunc_type(copyfunc), ossl_check_UI_STRING_freefunc_type(freefunc)))
+#define sk_UI_STRING_dup(sk) \
+    ((STACK_OF(UI_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_UI_STRING_sk_type(sk)), \
+                sk_UI_STRING_cmpfunc_thunk), \
+            sk_UI_STRING_copyfunc_thunk), \
+        sk_UI_STRING_freefunc_thunk))
+#define sk_UI_STRING_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(UI_STRING) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_UI_STRING_sk_type(sk), \
+                    ossl_check_UI_STRING_copyfunc_type(copyfunc), \
+                    ossl_check_UI_STRING_freefunc_type(freefunc)), \
+                sk_UI_STRING_cmpfunc_thunk), \
+            sk_UI_STRING_copyfunc_thunk), \
+        sk_UI_STRING_freefunc_thunk))
 #define sk_UI_STRING_set_cmp_func(sk, cmp) ((sk_UI_STRING_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_UI_STRING_sk_type(sk), ossl_check_UI_STRING_compfunc_type(cmp)))
 
 /* clang-format on */

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/uierr.h

@@ -1,6 +1,6 @@
 /*
  * Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy