Prefix the private stack functions
OpenSSL 1.1.x renamed these functions with an OPENSSL_ prefix.
Unfortunately, rust-openssl uses these, losing type-safety, rather than
the type-safe macros. It currently expects the old, unprefixed names due
to a different bug
(https://github.com/sfackler/rust-openssl/issues/1944), but to fix that,
we'll need to align with the OpenSSL names.
To keep the current version of rust-openssl working, I've preserved the
old names that rust-openssl uses, but we should clear these out.
Bug: 499
Change-Id: I3be56a54ef503620b92ce8154fafd46b2906ae63
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/60505
Reviewed-by: Bob Beck <bbe@google.com>
Auto-Submit: David Benjamin <davidben@google.com>
Commit-Queue: David Benjamin <davidben@google.com>
Commit-Queue: Bob Beck <bbe@google.com>
diff --git a/crypto/stack/stack.c b/crypto/stack/stack.c
index c81afcb..4f4f1df 100644
--- a/crypto/stack/stack.c
+++ b/crypto/stack/stack.c
@@ -65,16 +65,30 @@
#include "../internal.h"
+struct stack_st {
+ // num contains the number of valid pointers in |data|.
+ size_t num;
+ void **data;
+ // sorted is non-zero if the values pointed to by |data| are in ascending
+ // order, based on |comp|.
+ int sorted;
+ // num_alloc contains the number of pointers allocated in the buffer pointed
+ // to by |data|, which may be larger than |num|.
+ size_t num_alloc;
+ // comp is an optional comparison function.
+ OPENSSL_sk_cmp_func comp;
+};
+
// kMinSize is the number of pointers that will be initially allocated in a new
// stack.
static const size_t kMinSize = 4;
-_STACK *sk_new(OPENSSL_sk_cmp_func comp) {
- _STACK *ret = OPENSSL_malloc(sizeof(_STACK));
+OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_cmp_func comp) {
+ OPENSSL_STACK *ret = OPENSSL_malloc(sizeof(OPENSSL_STACK));
if (ret == NULL) {
return NULL;
}
- OPENSSL_memset(ret, 0, sizeof(_STACK));
+ OPENSSL_memset(ret, 0, sizeof(OPENSSL_STACK));
ret->data = OPENSSL_malloc(sizeof(void *) * kMinSize);
if (ret->data == NULL) {
@@ -93,16 +107,16 @@
return NULL;
}
-_STACK *sk_new_null(void) { return sk_new(NULL); }
+OPENSSL_STACK *OPENSSL_sk_new_null(void) { return OPENSSL_sk_new(NULL); }
-size_t sk_num(const _STACK *sk) {
+size_t OPENSSL_sk_num(const OPENSSL_STACK *sk) {
if (sk == NULL) {
return 0;
}
return sk->num;
}
-void sk_zero(_STACK *sk) {
+void OPENSSL_sk_zero(OPENSSL_STACK *sk) {
if (sk == NULL || sk->num == 0) {
return;
}
@@ -111,21 +125,21 @@
sk->sorted = 0;
}
-void *sk_value(const _STACK *sk, size_t i) {
+void *OPENSSL_sk_value(const OPENSSL_STACK *sk, size_t i) {
if (!sk || i >= sk->num) {
return NULL;
}
return sk->data[i];
}
-void *sk_set(_STACK *sk, size_t i, void *value) {
+void *OPENSSL_sk_set(OPENSSL_STACK *sk, size_t i, void *value) {
if (!sk || i >= sk->num) {
return NULL;
}
return sk->data[i] = value;
}
-void sk_free(_STACK *sk) {
+void OPENSSL_sk_free(OPENSSL_STACK *sk) {
if (sk == NULL) {
return;
}
@@ -133,8 +147,9 @@
OPENSSL_free(sk);
}
-void sk_pop_free_ex(_STACK *sk, OPENSSL_sk_call_free_func call_free_func,
- OPENSSL_sk_free_func free_func) {
+void OPENSSL_sk_pop_free_ex(OPENSSL_STACK *sk,
+ OPENSSL_sk_call_free_func call_free_func,
+ OPENSSL_sk_free_func free_func) {
if (sk == NULL) {
return;
}
@@ -144,7 +159,7 @@
call_free_func(free_func, sk->data[i]);
}
}
- sk_free(sk);
+ OPENSSL_sk_free(sk);
}
// Historically, |sk_pop_free| called the function as |OPENSSL_sk_free_func|
@@ -154,11 +169,11 @@
func(ptr);
}
-void sk_pop_free(_STACK *sk, OPENSSL_sk_free_func free_func) {
- sk_pop_free_ex(sk, call_free_func_legacy, free_func);
+void sk_pop_free(OPENSSL_STACK *sk, OPENSSL_sk_free_func free_func) {
+ OPENSSL_sk_pop_free_ex(sk, call_free_func_legacy, free_func);
}
-size_t sk_insert(_STACK *sk, void *p, size_t where) {
+size_t OPENSSL_sk_insert(OPENSSL_STACK *sk, void *p, size_t where) {
if (sk == NULL) {
return 0;
}
@@ -208,7 +223,7 @@
return sk->num;
}
-void *sk_delete(_STACK *sk, size_t where) {
+void *OPENSSL_sk_delete(OPENSSL_STACK *sk, size_t where) {
void *ret;
if (!sk || where >= sk->num) {
@@ -226,22 +241,23 @@
return ret;
}
-void *sk_delete_ptr(_STACK *sk, const void *p) {
+void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *sk, const void *p) {
if (sk == NULL) {
return NULL;
}
for (size_t i = 0; i < sk->num; i++) {
if (sk->data[i] == p) {
- return sk_delete(sk, i);
+ return OPENSSL_sk_delete(sk, i);
}
}
return NULL;
}
-void sk_delete_if(_STACK *sk, OPENSSL_sk_call_delete_if_func call_func,
- OPENSSL_sk_delete_if_func func, void *data) {
+void OPENSSL_sk_delete_if(OPENSSL_STACK *sk,
+ OPENSSL_sk_call_delete_if_func call_func,
+ OPENSSL_sk_delete_if_func func, void *data) {
if (sk == NULL) {
return;
}
@@ -256,8 +272,8 @@
sk->num = new_num;
}
-int sk_find(const _STACK *sk, size_t *out_index, const void *p,
- OPENSSL_sk_call_cmp_func call_cmp_func) {
+int OPENSSL_sk_find(const OPENSSL_STACK *sk, size_t *out_index, const void *p,
+ OPENSSL_sk_call_cmp_func call_cmp_func) {
if (sk == NULL) {
return 0;
}
@@ -279,7 +295,7 @@
return 0;
}
- if (!sk_is_sorted(sk)) {
+ if (!OPENSSL_sk_is_sorted(sk)) {
for (size_t i = 0; i < sk->num; i++) {
const void *elem = sk->data[i];
if (call_cmp_func(sk->comp, &p, &elem) == 0) {
@@ -327,38 +343,40 @@
return 0; // Not found.
}
-void *sk_shift(_STACK *sk) {
+void *OPENSSL_sk_shift(OPENSSL_STACK *sk) {
if (sk == NULL) {
return NULL;
}
if (sk->num == 0) {
return NULL;
}
- return sk_delete(sk, 0);
+ return OPENSSL_sk_delete(sk, 0);
}
-size_t sk_push(_STACK *sk, void *p) { return (sk_insert(sk, p, sk->num)); }
+size_t OPENSSL_sk_push(OPENSSL_STACK *sk, void *p) {
+ return OPENSSL_sk_insert(sk, p, sk->num);
+}
-void *sk_pop(_STACK *sk) {
+void *OPENSSL_sk_pop(OPENSSL_STACK *sk) {
if (sk == NULL) {
return NULL;
}
if (sk->num == 0) {
return NULL;
}
- return sk_delete(sk, sk->num - 1);
+ return OPENSSL_sk_delete(sk, sk->num - 1);
}
-_STACK *sk_dup(const _STACK *sk) {
+OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *sk) {
if (sk == NULL) {
return NULL;
}
- _STACK *ret = OPENSSL_malloc(sizeof(_STACK));
+ OPENSSL_STACK *ret = OPENSSL_malloc(sizeof(OPENSSL_STACK));
if (ret == NULL) {
return NULL;
}
- OPENSSL_memset(ret, 0, sizeof(_STACK));
+ OPENSSL_memset(ret, 0, sizeof(OPENSSL_STACK));
ret->data = OPENSSL_malloc(sizeof(void *) * sk->num_alloc);
if (ret->data == NULL) {
@@ -373,7 +391,7 @@
return ret;
err:
- sk_free(ret);
+ OPENSSL_sk_free(ret);
return NULL;
}
@@ -389,7 +407,8 @@
}
#endif
-void sk_sort(_STACK *sk, OPENSSL_sk_call_cmp_func call_cmp_func) {
+void OPENSSL_sk_sort(OPENSSL_STACK *sk,
+ OPENSSL_sk_call_cmp_func call_cmp_func) {
if (sk == NULL || sk->comp == NULL || sk->sorted) {
return;
}
@@ -418,7 +437,7 @@
sk->sorted = 1;
}
-int sk_is_sorted(const _STACK *sk) {
+int OPENSSL_sk_is_sorted(const OPENSSL_STACK *sk) {
if (!sk) {
return 1;
}
@@ -426,7 +445,8 @@
return sk->sorted || (sk->comp != NULL && sk->num < 2);
}
-OPENSSL_sk_cmp_func sk_set_cmp_func(_STACK *sk, OPENSSL_sk_cmp_func comp) {
+OPENSSL_sk_cmp_func OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk,
+ OPENSSL_sk_cmp_func comp) {
OPENSSL_sk_cmp_func old = sk->comp;
if (sk->comp != comp) {
@@ -437,11 +457,12 @@
return old;
}
-_STACK *sk_deep_copy(const _STACK *sk, OPENSSL_sk_call_copy_func call_copy_func,
- OPENSSL_sk_copy_func copy_func,
- OPENSSL_sk_call_free_func call_free_func,
- OPENSSL_sk_free_func free_func) {
- _STACK *ret = sk_dup(sk);
+OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *sk,
+ OPENSSL_sk_call_copy_func call_copy_func,
+ OPENSSL_sk_copy_func copy_func,
+ OPENSSL_sk_call_free_func call_free_func,
+ OPENSSL_sk_free_func free_func) {
+ OPENSSL_STACK *ret = OPENSSL_sk_dup(sk);
if (ret == NULL) {
return NULL;
}
@@ -457,7 +478,7 @@
call_free_func(free_func, ret->data[j]);
}
}
- sk_free(ret);
+ OPENSSL_sk_free(ret);
return NULL;
}
}
diff --git a/include/openssl/stack.h b/include/openssl/stack.h
index 2774e86..ce92be6 100644
--- a/include/openssl/stack.h
+++ b/include/openssl/stack.h
@@ -245,8 +245,11 @@
// Private functions.
//
-// TODO(https://crbug.com/boringssl/499): Rename to |OPENSSL_sk_foo|, after
-// external code that calls them is fixed.
+// The |sk_*| functions generated above are implemented internally using the
+// type-erased functions below. Callers should use the typed wrappers instead.
+// When using the type-erased functions, callers are responsible for ensuring
+// the underlying types are correct. Casting pointers to the wrong types will
+// result in memory errors.
// OPENSSL_sk_free_func is a function that frees an element in a stack. Note its
// actual type is void (*)(T *) for some T. Low-level |sk_*| functions will be
@@ -282,63 +285,83 @@
typedef int (*OPENSSL_sk_call_delete_if_func)(OPENSSL_sk_delete_if_func, void *,
void *);
-// stack_st contains an array of pointers. It is not designed to be used
+// An OPENSSL_STACK contains an array of pointers. It is not designed to be used
// directly, rather the wrapper macros should be used.
-typedef struct stack_st {
- // num contains the number of valid pointers in |data|.
- size_t num;
- void **data;
- // sorted is non-zero if the values pointed to by |data| are in ascending
- // order, based on |comp|.
- int sorted;
- // num_alloc contains the number of pointers allocated in the buffer pointed
- // to by |data|, which may be larger than |num|.
- size_t num_alloc;
- // comp is an optional comparison function.
- OPENSSL_sk_cmp_func comp;
-} _STACK;
+typedef struct stack_st OPENSSL_STACK;
// The following are raw stack functions. They implement the corresponding typed
// |sk_SAMPLE_*| functions generated by |DEFINE_STACK_OF|. Callers shouldn't be
// using them. Rather, callers should use the typed functions.
-OPENSSL_EXPORT _STACK *sk_new(OPENSSL_sk_cmp_func comp);
-OPENSSL_EXPORT _STACK *sk_new_null(void);
-OPENSSL_EXPORT size_t sk_num(const _STACK *sk);
-OPENSSL_EXPORT void sk_zero(_STACK *sk);
-OPENSSL_EXPORT void *sk_value(const _STACK *sk, size_t i);
-OPENSSL_EXPORT void *sk_set(_STACK *sk, size_t i, void *p);
-OPENSSL_EXPORT void sk_free(_STACK *sk);
-OPENSSL_EXPORT void sk_pop_free_ex(_STACK *sk,
- OPENSSL_sk_call_free_func call_free_func,
- OPENSSL_sk_free_func free_func);
-OPENSSL_EXPORT size_t sk_insert(_STACK *sk, void *p, size_t where);
-OPENSSL_EXPORT void *sk_delete(_STACK *sk, size_t where);
-OPENSSL_EXPORT void *sk_delete_ptr(_STACK *sk, const void *p);
-OPENSSL_EXPORT void sk_delete_if(_STACK *sk,
- OPENSSL_sk_call_delete_if_func call_func,
- OPENSSL_sk_delete_if_func func, void *data);
-OPENSSL_EXPORT int sk_find(const _STACK *sk, size_t *out_index, const void *p,
- OPENSSL_sk_call_cmp_func call_cmp_func);
-OPENSSL_EXPORT void *sk_shift(_STACK *sk);
-OPENSSL_EXPORT size_t sk_push(_STACK *sk, void *p);
-OPENSSL_EXPORT void *sk_pop(_STACK *sk);
-OPENSSL_EXPORT _STACK *sk_dup(const _STACK *sk);
-OPENSSL_EXPORT void sk_sort(_STACK *sk, OPENSSL_sk_call_cmp_func call_cmp_func);
-OPENSSL_EXPORT int sk_is_sorted(const _STACK *sk);
-OPENSSL_EXPORT OPENSSL_sk_cmp_func sk_set_cmp_func(_STACK *sk,
- OPENSSL_sk_cmp_func comp);
-OPENSSL_EXPORT _STACK *sk_deep_copy(const _STACK *sk,
- OPENSSL_sk_call_copy_func call_copy_func,
- OPENSSL_sk_copy_func copy_func,
- OPENSSL_sk_call_free_func call_free_func,
- OPENSSL_sk_free_func free_func);
+OPENSSL_EXPORT OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_cmp_func comp);
+OPENSSL_EXPORT OPENSSL_STACK *OPENSSL_sk_new_null(void);
+OPENSSL_EXPORT size_t OPENSSL_sk_num(const OPENSSL_STACK *sk);
+OPENSSL_EXPORT void OPENSSL_sk_zero(OPENSSL_STACK *sk);
+OPENSSL_EXPORT void *OPENSSL_sk_value(const OPENSSL_STACK *sk, size_t i);
+OPENSSL_EXPORT void *OPENSSL_sk_set(OPENSSL_STACK *sk, size_t i, void *p);
+OPENSSL_EXPORT void OPENSSL_sk_free(OPENSSL_STACK *sk);
+OPENSSL_EXPORT void OPENSSL_sk_pop_free_ex(
+ OPENSSL_STACK *sk, OPENSSL_sk_call_free_func call_free_func,
+ OPENSSL_sk_free_func free_func);
+OPENSSL_EXPORT size_t OPENSSL_sk_insert(OPENSSL_STACK *sk, void *p,
+ size_t where);
+OPENSSL_EXPORT void *OPENSSL_sk_delete(OPENSSL_STACK *sk, size_t where);
+OPENSSL_EXPORT void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *sk, const void *p);
+OPENSSL_EXPORT void OPENSSL_sk_delete_if(
+ OPENSSL_STACK *sk, OPENSSL_sk_call_delete_if_func call_func,
+ OPENSSL_sk_delete_if_func func, void *data);
+OPENSSL_EXPORT int OPENSSL_sk_find(const OPENSSL_STACK *sk, size_t *out_index,
+ const void *p,
+ OPENSSL_sk_call_cmp_func call_cmp_func);
+OPENSSL_EXPORT void *OPENSSL_sk_shift(OPENSSL_STACK *sk);
+OPENSSL_EXPORT size_t OPENSSL_sk_push(OPENSSL_STACK *sk, void *p);
+OPENSSL_EXPORT void *OPENSSL_sk_pop(OPENSSL_STACK *sk);
+OPENSSL_EXPORT OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *sk);
+OPENSSL_EXPORT void OPENSSL_sk_sort(OPENSSL_STACK *sk,
+ OPENSSL_sk_call_cmp_func call_cmp_func);
+OPENSSL_EXPORT int OPENSSL_sk_is_sorted(const OPENSSL_STACK *sk);
+OPENSSL_EXPORT OPENSSL_sk_cmp_func
+OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk, OPENSSL_sk_cmp_func comp);
+OPENSSL_EXPORT OPENSSL_STACK *OPENSSL_sk_deep_copy(
+ const OPENSSL_STACK *sk, OPENSSL_sk_call_copy_func call_copy_func,
+ OPENSSL_sk_copy_func copy_func, OPENSSL_sk_call_free_func call_free_func,
+ OPENSSL_sk_free_func free_func);
+
+
+// Deprecated private functions (hidden).
+//
+// TODO(crbug.com/boringssl/499): Migrate callers to the typed wrappers, or at
+// least the new names and remove the old ones.
+
+typedef OPENSSL_STACK _STACK;
+
+OPENSSL_INLINE OPENSSL_STACK *sk_new_null(void) {
+ return OPENSSL_sk_new_null();
+}
+
+OPENSSL_INLINE size_t sk_num(const OPENSSL_STACK *sk) {
+ return OPENSSL_sk_num(sk);
+}
+
+OPENSSL_INLINE void *sk_value(const OPENSSL_STACK *sk, size_t i) {
+ return OPENSSL_sk_value(sk, i);
+}
+
+OPENSSL_INLINE void sk_free(OPENSSL_STACK *sk) { OPENSSL_sk_free(sk); }
+
+OPENSSL_INLINE size_t sk_push(OPENSSL_STACK *sk, void *p) {
+ return OPENSSL_sk_push(sk, p);
+}
+
+OPENSSL_INLINE void *sk_pop(OPENSSL_STACK *sk) { return OPENSSL_sk_pop(sk); }
// sk_pop_free behaves like |sk_pop_free_ex| but performs an invalid function
// pointer cast. It exists because some existing callers called |sk_pop_free|
// directly.
//
// TODO(davidben): Migrate callers to bssl::UniquePtr and remove this.
-OPENSSL_EXPORT void sk_pop_free(_STACK *sk, OPENSSL_sk_free_func free_func);
+OPENSSL_EXPORT void sk_pop_free(OPENSSL_STACK *sk,
+ OPENSSL_sk_free_func free_func);
+
#if !defined(BORINGSSL_NO_CXX)
extern "C++" {
@@ -368,153 +391,154 @@
#define BORINGSSL_DEFINE_STACK_TRAITS(name, type, is_const)
#endif
-#define BORINGSSL_DEFINE_STACK_OF_IMPL(name, ptrtype, constptrtype) \
- /* We disable MSVC C4191 in this macro, which warns when pointers are cast \
- * to the wrong type. While the cast itself is valid, it is often a bug \
- * because calling it through the cast is UB. However, we never actually \
- * call functions as |OPENSSL_sk_cmp_func|. The type is just a type-erased \
- * function pointer. (C does not guarantee function pointers fit in \
- * |void*|, and GCC will warn on this.) Thus we just disable the false \
- * positive warning. */ \
- OPENSSL_MSVC_PRAGMA(warning(push)) \
- OPENSSL_MSVC_PRAGMA(warning(disable : 4191)) \
- \
- DECLARE_STACK_OF(name) \
- \
- typedef void (*sk_##name##_free_func)(ptrtype); \
- typedef ptrtype (*sk_##name##_copy_func)(constptrtype); \
- typedef int (*sk_##name##_cmp_func)(constptrtype const *, \
- constptrtype const *); \
- typedef int (*sk_##name##_delete_if_func)(ptrtype, void *); \
- \
- OPENSSL_INLINE void sk_##name##_call_free_func( \
- OPENSSL_sk_free_func free_func, void *ptr) { \
- ((sk_##name##_free_func)free_func)((ptrtype)ptr); \
- } \
- \
- OPENSSL_INLINE void *sk_##name##_call_copy_func( \
- OPENSSL_sk_copy_func copy_func, const void *ptr) { \
- return (void *)((sk_##name##_copy_func)copy_func)((constptrtype)ptr); \
- } \
- \
- OPENSSL_INLINE int sk_##name##_call_cmp_func(OPENSSL_sk_cmp_func cmp_func, \
- const void *const *a, \
- const void *const *b) { \
- /* The data is actually stored as |void*| pointers, so read the pointer \
- * as |void*| and then pass the corrected type into the caller-supplied \
- * function, which expects |constptrtype*|. */ \
- constptrtype a_ptr = (constptrtype)*a; \
- constptrtype b_ptr = (constptrtype)*b; \
- return ((sk_##name##_cmp_func)cmp_func)(&a_ptr, &b_ptr); \
- } \
- \
- OPENSSL_INLINE int sk_##name##_call_delete_if_func( \
- OPENSSL_sk_delete_if_func func, void *obj, void *data) { \
- return ((sk_##name##_delete_if_func)func)((ptrtype)obj, data); \
- } \
- \
- OPENSSL_INLINE STACK_OF(name) *sk_##name##_new(sk_##name##_cmp_func comp) { \
- return (STACK_OF(name) *)sk_new((OPENSSL_sk_cmp_func)comp); \
- } \
- \
- OPENSSL_INLINE STACK_OF(name) *sk_##name##_new_null(void) { \
- return (STACK_OF(name) *)sk_new_null(); \
- } \
- \
- OPENSSL_INLINE size_t sk_##name##_num(const STACK_OF(name) *sk) { \
- return sk_num((const _STACK *)sk); \
- } \
- \
- OPENSSL_INLINE void sk_##name##_zero(STACK_OF(name) *sk) { \
- sk_zero((_STACK *)sk); \
- } \
- \
- OPENSSL_INLINE ptrtype sk_##name##_value(const STACK_OF(name) *sk, \
- size_t i) { \
- return (ptrtype)sk_value((const _STACK *)sk, i); \
- } \
- \
- OPENSSL_INLINE ptrtype sk_##name##_set(STACK_OF(name) *sk, size_t i, \
- ptrtype p) { \
- return (ptrtype)sk_set((_STACK *)sk, i, (void *)p); \
- } \
- \
- OPENSSL_INLINE void sk_##name##_free(STACK_OF(name) *sk) { \
- sk_free((_STACK *)sk); \
- } \
- \
- OPENSSL_INLINE void sk_##name##_pop_free(STACK_OF(name) *sk, \
- sk_##name##_free_func free_func) { \
- sk_pop_free_ex((_STACK *)sk, sk_##name##_call_free_func, \
- (OPENSSL_sk_free_func)free_func); \
- } \
- \
- OPENSSL_INLINE size_t sk_##name##_insert(STACK_OF(name) *sk, ptrtype p, \
- size_t where) { \
- return sk_insert((_STACK *)sk, (void *)p, where); \
- } \
- \
- OPENSSL_INLINE ptrtype sk_##name##_delete(STACK_OF(name) *sk, \
- size_t where) { \
- return (ptrtype)sk_delete((_STACK *)sk, where); \
- } \
- \
- OPENSSL_INLINE ptrtype sk_##name##_delete_ptr(STACK_OF(name) *sk, \
- constptrtype p) { \
- return (ptrtype)sk_delete_ptr((_STACK *)sk, (const void *)p); \
- } \
- \
- OPENSSL_INLINE void sk_##name##_delete_if( \
- STACK_OF(name) *sk, sk_##name##_delete_if_func func, void *data) { \
- sk_delete_if((_STACK *)sk, sk_##name##_call_delete_if_func, \
- (OPENSSL_sk_delete_if_func)func, data); \
- } \
- \
- OPENSSL_INLINE int sk_##name##_find(const STACK_OF(name) *sk, \
- size_t *out_index, constptrtype p) { \
- return sk_find((const _STACK *)sk, out_index, (const void *)p, \
- sk_##name##_call_cmp_func); \
- } \
- \
- OPENSSL_INLINE ptrtype sk_##name##_shift(STACK_OF(name) *sk) { \
- return (ptrtype)sk_shift((_STACK *)sk); \
- } \
- \
- OPENSSL_INLINE size_t sk_##name##_push(STACK_OF(name) *sk, ptrtype p) { \
- return sk_push((_STACK *)sk, (void *)p); \
- } \
- \
- OPENSSL_INLINE ptrtype sk_##name##_pop(STACK_OF(name) *sk) { \
- return (ptrtype)sk_pop((_STACK *)sk); \
- } \
- \
- OPENSSL_INLINE STACK_OF(name) *sk_##name##_dup(const STACK_OF(name) *sk) { \
- return (STACK_OF(name) *)sk_dup((const _STACK *)sk); \
- } \
- \
- OPENSSL_INLINE void sk_##name##_sort(STACK_OF(name) *sk) { \
- sk_sort((_STACK *)sk, sk_##name##_call_cmp_func); \
- } \
- \
- OPENSSL_INLINE int sk_##name##_is_sorted(const STACK_OF(name) *sk) { \
- return sk_is_sorted((const _STACK *)sk); \
- } \
- \
- OPENSSL_INLINE sk_##name##_cmp_func sk_##name##_set_cmp_func( \
- STACK_OF(name) *sk, sk_##name##_cmp_func comp) { \
- return (sk_##name##_cmp_func)sk_set_cmp_func((_STACK *)sk, \
- (OPENSSL_sk_cmp_func)comp); \
- } \
- \
- OPENSSL_INLINE STACK_OF(name) *sk_##name##_deep_copy( \
- const STACK_OF(name) *sk, sk_##name##_copy_func copy_func, \
- sk_##name##_free_func free_func) { \
- return (STACK_OF(name) *)sk_deep_copy( \
- (const _STACK *)sk, sk_##name##_call_copy_func, \
- (OPENSSL_sk_copy_func)copy_func, sk_##name##_call_free_func, \
- (OPENSSL_sk_free_func)free_func); \
- } \
- \
+#define BORINGSSL_DEFINE_STACK_OF_IMPL(name, ptrtype, constptrtype) \
+ /* We disable MSVC C4191 in this macro, which warns when pointers are cast \
+ * to the wrong type. While the cast itself is valid, it is often a bug \
+ * because calling it through the cast is UB. However, we never actually \
+ * call functions as |OPENSSL_sk_cmp_func|. The type is just a type-erased \
+ * function pointer. (C does not guarantee function pointers fit in \
+ * |void*|, and GCC will warn on this.) Thus we just disable the false \
+ * positive warning. */ \
+ OPENSSL_MSVC_PRAGMA(warning(push)) \
+ OPENSSL_MSVC_PRAGMA(warning(disable : 4191)) \
+ \
+ DECLARE_STACK_OF(name) \
+ \
+ typedef void (*sk_##name##_free_func)(ptrtype); \
+ typedef ptrtype (*sk_##name##_copy_func)(constptrtype); \
+ typedef int (*sk_##name##_cmp_func)(constptrtype const *, \
+ constptrtype const *); \
+ typedef int (*sk_##name##_delete_if_func)(ptrtype, void *); \
+ \
+ OPENSSL_INLINE void sk_##name##_call_free_func( \
+ OPENSSL_sk_free_func free_func, void *ptr) { \
+ ((sk_##name##_free_func)free_func)((ptrtype)ptr); \
+ } \
+ \
+ OPENSSL_INLINE void *sk_##name##_call_copy_func( \
+ OPENSSL_sk_copy_func copy_func, const void *ptr) { \
+ return (void *)((sk_##name##_copy_func)copy_func)((constptrtype)ptr); \
+ } \
+ \
+ OPENSSL_INLINE int sk_##name##_call_cmp_func(OPENSSL_sk_cmp_func cmp_func, \
+ const void *const *a, \
+ const void *const *b) { \
+ /* The data is actually stored as |void*| pointers, so read the pointer \
+ * as |void*| and then pass the corrected type into the caller-supplied \
+ * function, which expects |constptrtype*|. */ \
+ constptrtype a_ptr = (constptrtype)*a; \
+ constptrtype b_ptr = (constptrtype)*b; \
+ return ((sk_##name##_cmp_func)cmp_func)(&a_ptr, &b_ptr); \
+ } \
+ \
+ OPENSSL_INLINE int sk_##name##_call_delete_if_func( \
+ OPENSSL_sk_delete_if_func func, void *obj, void *data) { \
+ return ((sk_##name##_delete_if_func)func)((ptrtype)obj, data); \
+ } \
+ \
+ OPENSSL_INLINE STACK_OF(name) *sk_##name##_new(sk_##name##_cmp_func comp) { \
+ return (STACK_OF(name) *)OPENSSL_sk_new((OPENSSL_sk_cmp_func)comp); \
+ } \
+ \
+ OPENSSL_INLINE STACK_OF(name) *sk_##name##_new_null(void) { \
+ return (STACK_OF(name) *)OPENSSL_sk_new_null(); \
+ } \
+ \
+ OPENSSL_INLINE size_t sk_##name##_num(const STACK_OF(name) *sk) { \
+ return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \
+ } \
+ \
+ OPENSSL_INLINE void sk_##name##_zero(STACK_OF(name) *sk) { \
+ OPENSSL_sk_zero((OPENSSL_STACK *)sk); \
+ } \
+ \
+ OPENSSL_INLINE ptrtype sk_##name##_value(const STACK_OF(name) *sk, \
+ size_t i) { \
+ return (ptrtype)OPENSSL_sk_value((const OPENSSL_STACK *)sk, i); \
+ } \
+ \
+ OPENSSL_INLINE ptrtype sk_##name##_set(STACK_OF(name) *sk, size_t i, \
+ ptrtype p) { \
+ return (ptrtype)OPENSSL_sk_set((OPENSSL_STACK *)sk, i, (void *)p); \
+ } \
+ \
+ OPENSSL_INLINE void sk_##name##_free(STACK_OF(name) *sk) { \
+ OPENSSL_sk_free((OPENSSL_STACK *)sk); \
+ } \
+ \
+ OPENSSL_INLINE void sk_##name##_pop_free(STACK_OF(name) *sk, \
+ sk_##name##_free_func free_func) { \
+ OPENSSL_sk_pop_free_ex((OPENSSL_STACK *)sk, sk_##name##_call_free_func, \
+ (OPENSSL_sk_free_func)free_func); \
+ } \
+ \
+ OPENSSL_INLINE size_t sk_##name##_insert(STACK_OF(name) *sk, ptrtype p, \
+ size_t where) { \
+ return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (void *)p, where); \
+ } \
+ \
+ OPENSSL_INLINE ptrtype sk_##name##_delete(STACK_OF(name) *sk, \
+ size_t where) { \
+ return (ptrtype)OPENSSL_sk_delete((OPENSSL_STACK *)sk, where); \
+ } \
+ \
+ OPENSSL_INLINE ptrtype sk_##name##_delete_ptr(STACK_OF(name) *sk, \
+ constptrtype p) { \
+ return (ptrtype)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \
+ (const void *)p); \
+ } \
+ \
+ OPENSSL_INLINE void sk_##name##_delete_if( \
+ STACK_OF(name) *sk, sk_##name##_delete_if_func func, void *data) { \
+ OPENSSL_sk_delete_if((OPENSSL_STACK *)sk, sk_##name##_call_delete_if_func, \
+ (OPENSSL_sk_delete_if_func)func, data); \
+ } \
+ \
+ OPENSSL_INLINE int sk_##name##_find(const STACK_OF(name) *sk, \
+ size_t *out_index, constptrtype p) { \
+ return OPENSSL_sk_find((const OPENSSL_STACK *)sk, out_index, \
+ (const void *)p, sk_##name##_call_cmp_func); \
+ } \
+ \
+ OPENSSL_INLINE ptrtype sk_##name##_shift(STACK_OF(name) *sk) { \
+ return (ptrtype)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \
+ } \
+ \
+ OPENSSL_INLINE size_t sk_##name##_push(STACK_OF(name) *sk, ptrtype p) { \
+ return OPENSSL_sk_push((OPENSSL_STACK *)sk, (void *)p); \
+ } \
+ \
+ OPENSSL_INLINE ptrtype sk_##name##_pop(STACK_OF(name) *sk) { \
+ return (ptrtype)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \
+ } \
+ \
+ OPENSSL_INLINE STACK_OF(name) *sk_##name##_dup(const STACK_OF(name) *sk) { \
+ return (STACK_OF(name) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); \
+ } \
+ \
+ OPENSSL_INLINE void sk_##name##_sort(STACK_OF(name) *sk) { \
+ OPENSSL_sk_sort((OPENSSL_STACK *)sk, sk_##name##_call_cmp_func); \
+ } \
+ \
+ OPENSSL_INLINE int sk_##name##_is_sorted(const STACK_OF(name) *sk) { \
+ return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \
+ } \
+ \
+ OPENSSL_INLINE sk_##name##_cmp_func sk_##name##_set_cmp_func( \
+ STACK_OF(name) *sk, sk_##name##_cmp_func comp) { \
+ return (sk_##name##_cmp_func)OPENSSL_sk_set_cmp_func( \
+ (OPENSSL_STACK *)sk, (OPENSSL_sk_cmp_func)comp); \
+ } \
+ \
+ OPENSSL_INLINE STACK_OF(name) *sk_##name##_deep_copy( \
+ const STACK_OF(name) *sk, sk_##name##_copy_func copy_func, \
+ sk_##name##_free_func free_func) { \
+ return (STACK_OF(name) *)OPENSSL_sk_deep_copy( \
+ (const OPENSSL_STACK *)sk, sk_##name##_call_copy_func, \
+ (OPENSSL_sk_copy_func)copy_func, sk_##name##_call_free_func, \
+ (OPENSSL_sk_free_func)free_func); \
+ } \
+ \
OPENSSL_MSVC_PRAGMA(warning(pop))
@@ -542,7 +566,9 @@
// Stacks defined with |DEFINE_CONST_STACK_OF| are freed with |sk_free|.
template <typename Stack>
struct DeleterImpl<Stack, std::enable_if_t<StackTraits<Stack>::kIsConst>> {
- static void Free(Stack *sk) { sk_free(reinterpret_cast<_STACK *>(sk)); }
+ static void Free(Stack *sk) {
+ OPENSSL_sk_free(reinterpret_cast<OPENSSL_STACK *>(sk));
+ }
};
// Stacks defined with |DEFINE_STACK_OF| are freed with |sk_pop_free| and the
@@ -553,11 +579,12 @@
// sk_FOO_pop_free is defined by macros and bound by name, so we cannot
// access it from C++ here.
using Type = typename StackTraits<Stack>::Type;
- sk_pop_free_ex(reinterpret_cast<_STACK *>(sk),
- [](OPENSSL_sk_free_func /* unused */, void *ptr) {
- DeleterImpl<Type>::Free(reinterpret_cast<Type *>(ptr));
- },
- nullptr);
+ OPENSSL_sk_pop_free_ex(
+ reinterpret_cast<OPENSSL_STACK *>(sk),
+ [](OPENSSL_sk_free_func /* unused */, void *ptr) {
+ DeleterImpl<Type>::Free(reinterpret_cast<Type *>(ptr));
+ },
+ nullptr);
}
};
@@ -578,7 +605,7 @@
Type *operator*() const {
return reinterpret_cast<Type *>(
- sk_value(reinterpret_cast<const _STACK *>(sk_), idx_));
+ OPENSSL_sk_value(reinterpret_cast<const OPENSSL_STACK *>(sk_), idx_));
}
StackIteratorImpl &operator++(/* prefix */) {
@@ -609,10 +636,10 @@
inline std::enable_if_t<!internal::StackTraits<Stack>::kIsConst, bool>
PushToStack(Stack *sk,
UniquePtr<typename internal::StackTraits<Stack>::Type> elem) {
- if (!sk_push(reinterpret_cast<_STACK *>(sk), elem.get())) {
+ if (!OPENSSL_sk_push(reinterpret_cast<OPENSSL_STACK *>(sk), elem.get())) {
return false;
}
- // sk_push takes ownership on success.
+ // OPENSSL_sk_push takes ownership on success.
elem.release();
return true;
}
@@ -628,7 +655,7 @@
template <typename Stack>
inline bssl::internal::StackIterator<Stack> end(const Stack *sk) {
return bssl::internal::StackIterator<Stack>(
- sk, sk_num(reinterpret_cast<const _STACK *>(sk)));
+ sk, OPENSSL_sk_num(reinterpret_cast<const OPENSSL_STACK *>(sk)));
}
} // extern C++
