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

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

@@ -97,9 +97,30 @@ typedef struct ocsp_request_st OCSP_REQUEST;
 SKM_DEFINE_STACK_OF_INTERNAL(OCSP_CERTID, OCSP_CERTID, OCSP_CERTID)
 #define sk_OCSP_CERTID_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_CERTID_sk_type(sk))
 #define sk_OCSP_CERTID_value(sk, idx) ((OCSP_CERTID *)OPENSSL_sk_value(ossl_check_const_OCSP_CERTID_sk_type(sk), (idx)))
-#define sk_OCSP_CERTID_new(cmp) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_OCSP_CERTID_compfunc_type(cmp)), sk_OCSP_CERTID_cmpfunc_thunk))
-#define sk_OCSP_CERTID_new_null() ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_OCSP_CERTID_freefunc_thunk))
-#define sk_OCSP_CERTID_new_reserve(cmp, n) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_OCSP_CERTID_compfunc_type(cmp), (n)), sk_OCSP_CERTID_cmpfunc_thunk))
+#define sk_OCSP_CERTID_new(cmp) \
+    ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_OCSP_CERTID_compfunc_type(cmp)), \
+                sk_OCSP_CERTID_cmpfunc_thunk), \
+            sk_OCSP_CERTID_copyfunc_thunk), \
+        sk_OCSP_CERTID_freefunc_thunk))
+#define sk_OCSP_CERTID_new_null() \
+    ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_OCSP_CERTID_cmpfunc_thunk), \
+            sk_OCSP_CERTID_copyfunc_thunk), \
+        sk_OCSP_CERTID_freefunc_thunk))
+#define sk_OCSP_CERTID_new_reserve(cmp, n) \
+    ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_OCSP_CERTID_compfunc_type(cmp), (n)), \
+                sk_OCSP_CERTID_cmpfunc_thunk), \
+            sk_OCSP_CERTID_copyfunc_thunk), \
+        sk_OCSP_CERTID_freefunc_thunk))
 #define sk_OCSP_CERTID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_CERTID_sk_type(sk), (n))
 #define sk_OCSP_CERTID_free(sk) OPENSSL_sk_free(ossl_check_OCSP_CERTID_sk_type(sk))
 #define sk_OCSP_CERTID_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_CERTID_sk_type(sk))
@@ -117,15 +138,53 @@ SKM_DEFINE_STACK_OF_INTERNAL(OCSP_CERTID, OCSP_CERTID, OCSP_CERTID)
 #define sk_OCSP_CERTID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_type(ptr), pnum)
 #define sk_OCSP_CERTID_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_CERTID_sk_type(sk))
 #define sk_OCSP_CERTID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_CERTID_sk_type(sk))
-#define sk_OCSP_CERTID_dup(sk) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_dup(ossl_check_const_OCSP_CERTID_sk_type(sk)))
-#define sk_OCSP_CERTID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_copyfunc_type(copyfunc), ossl_check_OCSP_CERTID_freefunc_type(freefunc)))
+#define sk_OCSP_CERTID_dup(sk) \
+    ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_OCSP_CERTID_sk_type(sk)), \
+                sk_OCSP_CERTID_cmpfunc_thunk), \
+            sk_OCSP_CERTID_copyfunc_thunk), \
+        sk_OCSP_CERTID_freefunc_thunk))
+#define sk_OCSP_CERTID_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(OCSP_CERTID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_OCSP_CERTID_sk_type(sk), \
+                    ossl_check_OCSP_CERTID_copyfunc_type(copyfunc), \
+                    ossl_check_OCSP_CERTID_freefunc_type(freefunc)), \
+                sk_OCSP_CERTID_cmpfunc_thunk), \
+            sk_OCSP_CERTID_copyfunc_thunk), \
+        sk_OCSP_CERTID_freefunc_thunk))
 #define sk_OCSP_CERTID_set_cmp_func(sk, cmp) ((sk_OCSP_CERTID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_CERTID_sk_type(sk), ossl_check_OCSP_CERTID_compfunc_type(cmp)))
 SKM_DEFINE_STACK_OF_INTERNAL(OCSP_ONEREQ, OCSP_ONEREQ, OCSP_ONEREQ)
 #define sk_OCSP_ONEREQ_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_ONEREQ_sk_type(sk))
 #define sk_OCSP_ONEREQ_value(sk, idx) ((OCSP_ONEREQ *)OPENSSL_sk_value(ossl_check_const_OCSP_ONEREQ_sk_type(sk), (idx)))
-#define sk_OCSP_ONEREQ_new(cmp) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_OCSP_ONEREQ_compfunc_type(cmp)), sk_OCSP_ONEREQ_cmpfunc_thunk))
-#define sk_OCSP_ONEREQ_new_null() ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_OCSP_ONEREQ_freefunc_thunk))
-#define sk_OCSP_ONEREQ_new_reserve(cmp, n) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_OCSP_ONEREQ_compfunc_type(cmp), (n)), sk_OCSP_ONEREQ_cmpfunc_thunk))
+#define sk_OCSP_ONEREQ_new(cmp) \
+    ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_OCSP_ONEREQ_compfunc_type(cmp)), \
+                sk_OCSP_ONEREQ_cmpfunc_thunk), \
+            sk_OCSP_ONEREQ_copyfunc_thunk), \
+        sk_OCSP_ONEREQ_freefunc_thunk))
+#define sk_OCSP_ONEREQ_new_null() \
+    ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_OCSP_ONEREQ_cmpfunc_thunk), \
+            sk_OCSP_ONEREQ_copyfunc_thunk), \
+        sk_OCSP_ONEREQ_freefunc_thunk))
+#define sk_OCSP_ONEREQ_new_reserve(cmp, n) \
+    ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_OCSP_ONEREQ_compfunc_type(cmp), (n)), \
+                sk_OCSP_ONEREQ_cmpfunc_thunk), \
+            sk_OCSP_ONEREQ_copyfunc_thunk), \
+        sk_OCSP_ONEREQ_freefunc_thunk))
 #define sk_OCSP_ONEREQ_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_ONEREQ_sk_type(sk), (n))
 #define sk_OCSP_ONEREQ_free(sk) OPENSSL_sk_free(ossl_check_OCSP_ONEREQ_sk_type(sk))
 #define sk_OCSP_ONEREQ_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_ONEREQ_sk_type(sk))
@@ -143,8 +202,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(OCSP_ONEREQ, OCSP_ONEREQ, OCSP_ONEREQ)
 #define sk_OCSP_ONEREQ_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_type(ptr), pnum)
 #define sk_OCSP_ONEREQ_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_ONEREQ_sk_type(sk))
 #define sk_OCSP_ONEREQ_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_ONEREQ_sk_type(sk))
-#define sk_OCSP_ONEREQ_dup(sk) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_dup(ossl_check_const_OCSP_ONEREQ_sk_type(sk)))
-#define sk_OCSP_ONEREQ_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_copyfunc_type(copyfunc), ossl_check_OCSP_ONEREQ_freefunc_type(freefunc)))
+#define sk_OCSP_ONEREQ_dup(sk) \
+    ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_OCSP_ONEREQ_sk_type(sk)), \
+                sk_OCSP_ONEREQ_cmpfunc_thunk), \
+            sk_OCSP_ONEREQ_copyfunc_thunk), \
+        sk_OCSP_ONEREQ_freefunc_thunk))
+#define sk_OCSP_ONEREQ_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(OCSP_ONEREQ) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_OCSP_ONEREQ_sk_type(sk), \
+                    ossl_check_OCSP_ONEREQ_copyfunc_type(copyfunc), \
+                    ossl_check_OCSP_ONEREQ_freefunc_type(freefunc)), \
+                sk_OCSP_ONEREQ_cmpfunc_thunk), \
+            sk_OCSP_ONEREQ_copyfunc_thunk), \
+        sk_OCSP_ONEREQ_freefunc_thunk))
 #define sk_OCSP_ONEREQ_set_cmp_func(sk, cmp) ((sk_OCSP_ONEREQ_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_ONEREQ_sk_type(sk), ossl_check_OCSP_ONEREQ_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -165,9 +241,30 @@ typedef struct ocsp_resp_bytes_st OCSP_RESPBYTES;
 SKM_DEFINE_STACK_OF_INTERNAL(OCSP_RESPID, OCSP_RESPID, OCSP_RESPID)
 #define sk_OCSP_RESPID_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_RESPID_sk_type(sk))
 #define sk_OCSP_RESPID_value(sk, idx) ((OCSP_RESPID *)OPENSSL_sk_value(ossl_check_const_OCSP_RESPID_sk_type(sk), (idx)))
-#define sk_OCSP_RESPID_new(cmp) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_OCSP_RESPID_compfunc_type(cmp)), sk_OCSP_RESPID_cmpfunc_thunk))
-#define sk_OCSP_RESPID_new_null() ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_OCSP_RESPID_freefunc_thunk))
-#define sk_OCSP_RESPID_new_reserve(cmp, n) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_OCSP_RESPID_compfunc_type(cmp), (n)), sk_OCSP_RESPID_cmpfunc_thunk))
+#define sk_OCSP_RESPID_new(cmp) \
+    ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_OCSP_RESPID_compfunc_type(cmp)), \
+                sk_OCSP_RESPID_cmpfunc_thunk), \
+            sk_OCSP_RESPID_copyfunc_thunk), \
+        sk_OCSP_RESPID_freefunc_thunk))
+#define sk_OCSP_RESPID_new_null() \
+    ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_OCSP_RESPID_cmpfunc_thunk), \
+            sk_OCSP_RESPID_copyfunc_thunk), \
+        sk_OCSP_RESPID_freefunc_thunk))
+#define sk_OCSP_RESPID_new_reserve(cmp, n) \
+    ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_OCSP_RESPID_compfunc_type(cmp), (n)), \
+                sk_OCSP_RESPID_cmpfunc_thunk), \
+            sk_OCSP_RESPID_copyfunc_thunk), \
+        sk_OCSP_RESPID_freefunc_thunk))
 #define sk_OCSP_RESPID_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_RESPID_sk_type(sk), (n))
 #define sk_OCSP_RESPID_free(sk) OPENSSL_sk_free(ossl_check_OCSP_RESPID_sk_type(sk))
 #define sk_OCSP_RESPID_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_RESPID_sk_type(sk))
@@ -185,8 +282,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(OCSP_RESPID, OCSP_RESPID, OCSP_RESPID)
 #define sk_OCSP_RESPID_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_type(ptr), pnum)
 #define sk_OCSP_RESPID_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_RESPID_sk_type(sk))
 #define sk_OCSP_RESPID_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_RESPID_sk_type(sk))
-#define sk_OCSP_RESPID_dup(sk) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_dup(ossl_check_const_OCSP_RESPID_sk_type(sk)))
-#define sk_OCSP_RESPID_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_copyfunc_type(copyfunc), ossl_check_OCSP_RESPID_freefunc_type(freefunc)))
+#define sk_OCSP_RESPID_dup(sk) \
+    ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_OCSP_RESPID_sk_type(sk)), \
+                sk_OCSP_RESPID_cmpfunc_thunk), \
+            sk_OCSP_RESPID_copyfunc_thunk), \
+        sk_OCSP_RESPID_freefunc_thunk))
+#define sk_OCSP_RESPID_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(OCSP_RESPID) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_OCSP_RESPID_sk_type(sk), \
+                    ossl_check_OCSP_RESPID_copyfunc_type(copyfunc), \
+                    ossl_check_OCSP_RESPID_freefunc_type(freefunc)), \
+                sk_OCSP_RESPID_cmpfunc_thunk), \
+            sk_OCSP_RESPID_copyfunc_thunk), \
+        sk_OCSP_RESPID_freefunc_thunk))
 #define sk_OCSP_RESPID_set_cmp_func(sk, cmp) ((sk_OCSP_RESPID_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_RESPID_sk_type(sk), ossl_check_OCSP_RESPID_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -204,9 +318,30 @@ typedef struct ocsp_single_response_st OCSP_SINGLERESP;
 SKM_DEFINE_STACK_OF_INTERNAL(OCSP_SINGLERESP, OCSP_SINGLERESP, OCSP_SINGLERESP)
 #define sk_OCSP_SINGLERESP_num(sk) OPENSSL_sk_num(ossl_check_const_OCSP_SINGLERESP_sk_type(sk))
 #define sk_OCSP_SINGLERESP_value(sk, idx) ((OCSP_SINGLERESP *)OPENSSL_sk_value(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), (idx)))
-#define sk_OCSP_SINGLERESP_new(cmp) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)), sk_OCSP_SINGLERESP_cmpfunc_thunk))
-#define sk_OCSP_SINGLERESP_new_null() ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_OCSP_SINGLERESP_freefunc_thunk))
-#define sk_OCSP_SINGLERESP_new_reserve(cmp, n) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp), (n)), sk_OCSP_SINGLERESP_cmpfunc_thunk))
+#define sk_OCSP_SINGLERESP_new(cmp) \
+    ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)), \
+                sk_OCSP_SINGLERESP_cmpfunc_thunk), \
+            sk_OCSP_SINGLERESP_copyfunc_thunk), \
+        sk_OCSP_SINGLERESP_freefunc_thunk))
+#define sk_OCSP_SINGLERESP_new_null() \
+    ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_OCSP_SINGLERESP_cmpfunc_thunk), \
+            sk_OCSP_SINGLERESP_copyfunc_thunk), \
+        sk_OCSP_SINGLERESP_freefunc_thunk))
+#define sk_OCSP_SINGLERESP_new_reserve(cmp, n) \
+    ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_OCSP_SINGLERESP_compfunc_type(cmp), (n)), \
+                sk_OCSP_SINGLERESP_cmpfunc_thunk), \
+            sk_OCSP_SINGLERESP_copyfunc_thunk), \
+        sk_OCSP_SINGLERESP_freefunc_thunk))
 #define sk_OCSP_SINGLERESP_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_OCSP_SINGLERESP_sk_type(sk), (n))
 #define sk_OCSP_SINGLERESP_free(sk) OPENSSL_sk_free(ossl_check_OCSP_SINGLERESP_sk_type(sk))
 #define sk_OCSP_SINGLERESP_zero(sk) OPENSSL_sk_zero(ossl_check_OCSP_SINGLERESP_sk_type(sk))
@@ -224,8 +359,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(OCSP_SINGLERESP, OCSP_SINGLERESP, OCSP_SINGLERESP)
 #define sk_OCSP_SINGLERESP_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_type(ptr), pnum)
 #define sk_OCSP_SINGLERESP_sort(sk) OPENSSL_sk_sort(ossl_check_OCSP_SINGLERESP_sk_type(sk))
 #define sk_OCSP_SINGLERESP_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_OCSP_SINGLERESP_sk_type(sk))
-#define sk_OCSP_SINGLERESP_dup(sk) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_dup(ossl_check_const_OCSP_SINGLERESP_sk_type(sk)))
-#define sk_OCSP_SINGLERESP_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_deep_copy(ossl_check_const_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_copyfunc_type(copyfunc), ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc)))
+#define sk_OCSP_SINGLERESP_dup(sk) \
+    ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_OCSP_SINGLERESP_sk_type(sk)), \
+                sk_OCSP_SINGLERESP_cmpfunc_thunk), \
+            sk_OCSP_SINGLERESP_copyfunc_thunk), \
+        sk_OCSP_SINGLERESP_freefunc_thunk))
+#define sk_OCSP_SINGLERESP_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(OCSP_SINGLERESP) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_OCSP_SINGLERESP_sk_type(sk), \
+                    ossl_check_OCSP_SINGLERESP_copyfunc_type(copyfunc), \
+                    ossl_check_OCSP_SINGLERESP_freefunc_type(freefunc)), \
+                sk_OCSP_SINGLERESP_cmpfunc_thunk), \
+            sk_OCSP_SINGLERESP_copyfunc_thunk), \
+        sk_OCSP_SINGLERESP_freefunc_thunk))
 #define sk_OCSP_SINGLERESP_set_cmp_func(sk, cmp) ((sk_OCSP_SINGLERESP_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_OCSP_SINGLERESP_sk_type(sk), ossl_check_OCSP_SINGLERESP_compfunc_type(cmp)))
 
 /* clang-format on */
@@ -240,9 +392,13 @@ typedef struct ocsp_service_locator_st OCSP_SERVICELOC;
 #define PEM_STRING_OCSP_REQUEST "OCSP REQUEST"
 #define PEM_STRING_OCSP_RESPONSE "OCSP RESPONSE"
 
-#define d2i_OCSP_REQUEST_bio(bp, p) ASN1_d2i_bio_of(OCSP_REQUEST, OCSP_REQUEST_new, d2i_OCSP_REQUEST, bp, p)
+#define d2i_OCSP_REQUEST_bio(bp, p)                                  \
+    ((OCSP_REQUEST *)ASN1_item_d2i_bio(ASN1_ITEM_rptr(OCSP_REQUEST), \
+        (bp), CHECKED_PPTR_OF(OCSP_REQUEST, p)))
 
-#define d2i_OCSP_RESPONSE_bio(bp, p) ASN1_d2i_bio_of(OCSP_RESPONSE, OCSP_RESPONSE_new, d2i_OCSP_RESPONSE, bp, p)
+#define d2i_OCSP_RESPONSE_bio(bp, p)                                   \
+    ((OCSP_RESPONSE *)ASN1_item_d2i_bio(ASN1_ITEM_rptr(OCSP_RESPONSE), \
+        (bp), CHECKED_PPTR_OF(OCSP_RESPONSE, p)))
 
 #define PEM_read_bio_OCSP_REQUEST(bp, x, cb) (OCSP_REQUEST *)PEM_ASN1_read_bio( \
     (d2i_of_void *)d2i_OCSP_REQUEST, PEM_STRING_OCSP_REQUEST,                   \
@@ -260,9 +416,13 @@ typedef struct ocsp_service_locator_st OCSP_SERVICELOC;
     PEM_ASN1_write_bio((i2d_of_void *)i2d_OCSP_RESPONSE, PEM_STRING_OCSP_RESPONSE, \
         bp, (char *)(o), NULL, NULL, 0, NULL, NULL)
 
-#define i2d_OCSP_RESPONSE_bio(bp, o) ASN1_i2d_bio_of(OCSP_RESPONSE, i2d_OCSP_RESPONSE, bp, o)
+#define i2d_OCSP_RESPONSE_bio(bp, o)                 \
+    ASN1_item_i2d_bio(ASN1_ITEM_rptr(OCSP_RESPONSE), \
+        (bp), CHECKED_PTR_OF(const OCSP_RESPONSE, o))
 
-#define i2d_OCSP_REQUEST_bio(bp, o) ASN1_i2d_bio_of(OCSP_REQUEST, i2d_OCSP_REQUEST, bp, o)
+#define i2d_OCSP_REQUEST_bio(bp, o)                 \
+    ASN1_item_i2d_bio(ASN1_ITEM_rptr(OCSP_REQUEST), \
+        (bp), CHECKED_PTR_OF(const OCSP_REQUEST, o))
 
 #define ASN1_BIT_STRING_digest(data, type, md, len) \
     ASN1_item_digest(ASN1_ITEM_rptr(ASN1_BIT_STRING), type, data, md, len)

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/ocsperr.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_OCSP
-
 /*
  * OCSP reason codes.
  */

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

@@ -31,10 +31,10 @@ extern "C" {
 # define OPENSSL_VERSION_MAJOR  4
 /* clang-format on */
 /* clang-format off */
-# define OPENSSL_VERSION_MINOR  0
+# define OPENSSL_VERSION_MINOR  1
 /* clang-format on */
 /* clang-format off */
-# define OPENSSL_VERSION_PATCH  3
+# define OPENSSL_VERSION_PATCH  0
 /* clang-format on */
 
 /*
@@ -87,10 +87,10 @@ extern "C" {
  * OPENSSL_VERSION_BUILD_METADATA_STR appended.
  */
 /* clang-format off */
-# define OPENSSL_VERSION_STR "4.0.3"
+# define OPENSSL_VERSION_STR "4.1.0"
 /* clang-format on */
 /* clang-format off */
-# define OPENSSL_FULL_VERSION_STR "4.0.3"
+# define OPENSSL_FULL_VERSION_STR "4.1.0"
 /* clang-format on */
 
 /*
@@ -99,7 +99,7 @@ extern "C" {
  * These strings are defined separately to allow them to be parsable.
  */
 /* clang-format off */
-# define OPENSSL_RELEASE_DATE "29 Sep 2026"
+# define OPENSSL_RELEASE_DATE "23 Oct 2026"
 /* clang-format on */
 
 /*
@@ -107,7 +107,7 @@ extern "C" {
  */
 
 /* clang-format off */
-# define OPENSSL_VERSION_TEXT "OpenSSL 4.0.3 29 Sep 2026"
+# define OPENSSL_VERSION_TEXT "OpenSSL 4.1.0 23 Oct 2026"
 /* clang-format on */
 
 /* clang-format off */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2019-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
@@ -13,4 +13,9 @@
  * This header file only exists for compatibility reasons with older
  * applications which #include <openssl/ossl_typ.h>.
  */
+#if !defined(OSSL_OPENSSL_OSSL_TYP_H)
+#define OSSL_OPENSSL_OSSL_TYP_H
+
 #include <openssl/types.h>
+
+#endif /* !defined(OSSL_OPENSSL_OSSL_TYP_H) */

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

@@ -117,8 +117,26 @@ extern "C" {
 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1)                        \
     type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u) \
     {                                                                       \
-        return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str, fp,            \
-            (void **)x, cb, u);                                             \
+        BIO *b;                                                             \
+        const unsigned char *p = NULL;                                      \
+        unsigned char *data = NULL;                                         \
+        long len;                                                           \
+        type *ret = NULL;                                                   \
+                                                                            \
+        if ((b = BIO_new(BIO_s_file())) == NULL) {                          \
+            ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);                          \
+            return NULL;                                                    \
+        }                                                                   \
+        BIO_set_fp(b, fp, BIO_NOCLOSE);                                     \
+        if (PEM_bytes_read_bio(&data, &len, NULL, str, b, cb, u)) {         \
+            p = data;                                                       \
+            ret = d2i_##asn1(x, &p, len);                                   \
+            if (ret == NULL)                                                \
+                ERR_raise(ERR_LIB_PEM, ERR_R_ASN1_LIB);                     \
+        }                                                                   \
+        BIO_free(b);                                                        \
+        OPENSSL_free(data);                                                 \
+        return ret;                                                         \
     }
 
 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1)              \
@@ -146,12 +164,24 @@ extern "C" {
 #endif
 #endif
 
-#define IMPLEMENT_PEM_read_bio(name, type, str, asn1)                \
-    type *PEM_read_bio_##name(BIO *bp, type **x,                     \
-        pem_password_cb *cb, void *u)                                \
-    {                                                                \
-        return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str, bp, \
-            (void **)x, cb, u);                                      \
+#define IMPLEMENT_PEM_read_bio(name, type, str, asn1)   \
+    type *PEM_read_bio_##name(BIO *bp, type **x,        \
+        pem_password_cb *cb, void *u)                   \
+    {                                                   \
+        const unsigned char *p = NULL;                  \
+        unsigned char *data = NULL;                     \
+        long len;                                       \
+        type *ret = NULL;                               \
+                                                        \
+        if (!PEM_bytes_read_bio(&data, &len, NULL, str, \
+                bp, cb, u))                             \
+            return NULL;                                \
+        p = data;                                       \
+        ret = d2i_##asn1(x, &p, len);                   \
+        if (ret == NULL)                                \
+            ERR_raise(ERR_LIB_PEM, ERR_R_ASN1_LIB);     \
+        OPENSSL_free(data);                             \
+        return ret;                                     \
     }
 
 #define IMPLEMENT_PEM_write_bio(name, type, str, asn1)                 \

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/pemerr.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/pkcs12.h

@@ -74,9 +74,30 @@ typedef struct PKCS12_SAFEBAG_st PKCS12_SAFEBAG;
 SKM_DEFINE_STACK_OF_INTERNAL(PKCS12_SAFEBAG, PKCS12_SAFEBAG, PKCS12_SAFEBAG)
 #define sk_PKCS12_SAFEBAG_num(sk) OPENSSL_sk_num(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk))
 #define sk_PKCS12_SAFEBAG_value(sk, idx) ((PKCS12_SAFEBAG *)OPENSSL_sk_value(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), (idx)))
-#define sk_PKCS12_SAFEBAG_new(cmp) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)), sk_PKCS12_SAFEBAG_cmpfunc_thunk))
-#define sk_PKCS12_SAFEBAG_new_null() ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_set_thunks(OPENSSL_sk_new_null(), sk_PKCS12_SAFEBAG_freefunc_thunk))
-#define sk_PKCS12_SAFEBAG_new_reserve(cmp, n) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_set_cmp_thunks(OPENSSL_sk_new_reserve(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp), (n)), sk_PKCS12_SAFEBAG_cmpfunc_thunk))
+#define sk_PKCS12_SAFEBAG_new(cmp) \
+    ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)), \
+                sk_PKCS12_SAFEBAG_cmpfunc_thunk), \
+            sk_PKCS12_SAFEBAG_copyfunc_thunk), \
+        sk_PKCS12_SAFEBAG_freefunc_thunk))
+#define sk_PKCS12_SAFEBAG_new_null() \
+    ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_null(), \
+                sk_PKCS12_SAFEBAG_cmpfunc_thunk), \
+            sk_PKCS12_SAFEBAG_copyfunc_thunk), \
+        sk_PKCS12_SAFEBAG_freefunc_thunk))
+#define sk_PKCS12_SAFEBAG_new_reserve(cmp, n) \
+    ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_new_reserve(ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp), (n)), \
+                sk_PKCS12_SAFEBAG_cmpfunc_thunk), \
+            sk_PKCS12_SAFEBAG_copyfunc_thunk), \
+        sk_PKCS12_SAFEBAG_freefunc_thunk))
 #define sk_PKCS12_SAFEBAG_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_PKCS12_SAFEBAG_sk_type(sk), (n))
 #define sk_PKCS12_SAFEBAG_free(sk) OPENSSL_sk_free(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
 #define sk_PKCS12_SAFEBAG_zero(sk) OPENSSL_sk_zero(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
@@ -94,8 +115,25 @@ SKM_DEFINE_STACK_OF_INTERNAL(PKCS12_SAFEBAG, PKCS12_SAFEBAG, PKCS12_SAFEBAG)
 #define sk_PKCS12_SAFEBAG_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_type(ptr), pnum)
 #define sk_PKCS12_SAFEBAG_sort(sk) OPENSSL_sk_sort(ossl_check_PKCS12_SAFEBAG_sk_type(sk))
 #define sk_PKCS12_SAFEBAG_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk))
-#define sk_PKCS12_SAFEBAG_dup(sk) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_dup(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk)))
-#define sk_PKCS12_SAFEBAG_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_deep_copy(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_copyfunc_type(copyfunc), ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc)))
+#define sk_PKCS12_SAFEBAG_dup(sk) \
+    ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_dup(ossl_check_const_PKCS12_SAFEBAG_sk_type(sk)), \
+                sk_PKCS12_SAFEBAG_cmpfunc_thunk), \
+            sk_PKCS12_SAFEBAG_copyfunc_thunk), \
+        sk_PKCS12_SAFEBAG_freefunc_thunk))
+#define sk_PKCS12_SAFEBAG_deep_copy(sk, copyfunc, freefunc) \
+    ((STACK_OF(PKCS12_SAFEBAG) *)OPENSSL_sk_set_thunks( \
+        OPENSSL_sk_set_copy_thunks( \
+            OPENSSL_sk_set_cmp_thunks( \
+                OPENSSL_sk_deep_copy( \
+                    ossl_check_const_PKCS12_SAFEBAG_sk_type(sk), \
+                    ossl_check_PKCS12_SAFEBAG_copyfunc_type(copyfunc), \
+                    ossl_check_PKCS12_SAFEBAG_freefunc_type(freefunc)), \
+                sk_PKCS12_SAFEBAG_cmpfunc_thunk), \
+            sk_PKCS12_SAFEBAG_copyfunc_thunk), \
+        sk_PKCS12_SAFEBAG_freefunc_thunk))
 #define sk_PKCS12_SAFEBAG_set_cmp_func(sk, cmp) ((sk_PKCS12_SAFEBAG_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_PKCS12_SAFEBAG_sk_type(sk), ossl_check_PKCS12_SAFEBAG_compfunc_type(cmp)))
 
 /* clang-format on */

package/dist/prebuilt/linuxmusl-x64-mt-release/include/openssl/pkcs12err.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