Instead of a script which generates macros, emit static inlines in
individual header (or C files). This solves a few issues with the
original setup:
- The documentation was off. We match the documentation now.
- The stack macros did not check constness; see some of the fixes in
crypto/x509.
- Type errors did not look like usual type errors.
- Any type which participated in STACK_OF had to be made partially
public. This allows stack types to be defined an internal header or
even an individual file.
- One could not pass sk_FOO_free into something which expects a function
pointer.
Thanks to upstream's 411abf2dd3
for the
idea.
Change-Id: Ie5431390ccad761c17596b0e93941b0d7a68f904
Reviewed-on: https://boringssl-review.googlesource.com/16087
Reviewed-by: Adam Langley <agl@google.com>
kris/onging/CECPQ3_patch15
@@ -62,6 +62,9 @@ | |||
#include <openssl/err.h> | |||
#include <openssl/mem.h> | |||
#include <openssl/obj.h> | |||
#include <openssl/stack.h> | |||
DEFINE_STACK_OF(ASN1_STRING_TABLE) | |||
static STACK_OF(ASN1_STRING_TABLE) *stable = NULL; | |||
static void st_free(ASN1_STRING_TABLE *tbl); | |||
@@ -121,6 +121,8 @@ | |||
#include "internal.h" | |||
DEFINE_STACK_OF(CRYPTO_EX_DATA_FUNCS) | |||
struct crypto_ex_data_func_st { | |||
long argl; /* Arbitary long */ | |||
void *argp; /* Arbitary void pointer */ | |||
@@ -110,6 +110,7 @@ | |||
#define OPENSSL_HEADER_CRYPTO_INTERNAL_H | |||
#include <openssl/ex_data.h> | |||
#include <openssl/stack.h> | |||
#include <openssl/thread.h> | |||
#include <string.h> | |||
@@ -504,6 +505,8 @@ OPENSSL_EXPORT int CRYPTO_set_thread_local( | |||
typedef struct crypto_ex_data_func_st CRYPTO_EX_DATA_FUNCS; | |||
DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS) | |||
/* CRYPTO_EX_DATA_CLASS tracks the ex_indices registered for a type which | |||
* supports ex_data. It should defined as a static global within the module | |||
* which defines that type. */ | |||
@@ -1,114 +0,0 @@ | |||
#!/bin/sh | |||
include_dir=../../include/openssl | |||
cat > "${include_dir}/stack_macros.h" << EOF | |||
/* Copyright (c) 2014, Google Inc. | |||
* | |||
* Permission to use, copy, modify, and/or distribute this software for any | |||
* purpose with or without fee is hereby granted, provided that the above | |||
* copyright notice and this permission notice appear in all copies. | |||
* | |||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY | |||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION | |||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN | |||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ | |||
#if !defined(IN_STACK_H) | |||
#error "Don't include this file directly. Include stack.h." | |||
#endif | |||
EOF | |||
output_stack () { | |||
type=$1 | |||
ptrtype=$2 | |||
cat >> "${include_dir}/stack_macros.h" << EOF | |||
/* ${type} */ | |||
#define sk_${type}_new(comp)\\ | |||
((STACK_OF(${type})*) sk_new(CHECKED_CAST(stack_cmp_func, int (*) (const ${ptrtype} *a, const ${ptrtype} *b), comp))) | |||
#define sk_${type}_new_null()\\ | |||
((STACK_OF(${type})*) sk_new_null()) | |||
#define sk_${type}_num(sk)\\ | |||
sk_num(CHECKED_CAST(const _STACK*, const STACK_OF(${type})*, sk)) | |||
#define sk_${type}_zero(sk)\\ | |||
sk_zero(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk)); | |||
#define sk_${type}_value(sk, i)\\ | |||
((${ptrtype}) sk_value(CHECKED_CAST(const _STACK*, const STACK_OF(${type})*, sk), (i))) | |||
#define sk_${type}_set(sk, i, p)\\ | |||
((${ptrtype}) sk_set(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk), (i), CHECKED_CAST(void*, ${ptrtype}, p))) | |||
#define sk_${type}_free(sk)\\ | |||
sk_free(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk)) | |||
#define sk_${type}_pop_free(sk, free_func)\\ | |||
sk_pop_free(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk), CHECKED_CAST(void (*) (void*), void (*) (${ptrtype}), free_func)) | |||
#define sk_${type}_insert(sk, p, where)\\ | |||
sk_insert(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk), CHECKED_CAST(void*, ${ptrtype}, p), (where)) | |||
#define sk_${type}_delete(sk, where)\\ | |||
((${ptrtype}) sk_delete(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk), (where))) | |||
#define sk_${type}_delete_ptr(sk, p)\\ | |||
((${ptrtype}) sk_delete_ptr(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk), CHECKED_CAST(void*, ${ptrtype}, p))) | |||
#define sk_${type}_find(sk, out_index, p)\\ | |||
sk_find(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk), (out_index), CHECKED_CAST(void*, ${ptrtype}, p)) | |||
#define sk_${type}_shift(sk)\\ | |||
((${ptrtype}) sk_shift(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk))) | |||
#define sk_${type}_push(sk, p)\\ | |||
sk_push(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk), CHECKED_CAST(void*, ${ptrtype}, p)) | |||
#define sk_${type}_pop(sk)\\ | |||
((${ptrtype}) sk_pop(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk))) | |||
#define sk_${type}_dup(sk)\\ | |||
((STACK_OF(${type})*) sk_dup(CHECKED_CAST(const _STACK*, const STACK_OF(${type})*, sk))) | |||
#define sk_${type}_sort(sk)\\ | |||
sk_sort(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk)) | |||
#define sk_${type}_is_sorted(sk)\\ | |||
sk_is_sorted(CHECKED_CAST(const _STACK*, const STACK_OF(${type})*, sk)) | |||
#define sk_${type}_set_cmp_func(sk, comp)\\ | |||
((int (*) (const ${type} **a, const ${type} **b)) sk_set_cmp_func(CHECKED_CAST(_STACK*, STACK_OF(${type})*, sk), CHECKED_CAST(stack_cmp_func, int (*) (const ${type} **a, const ${type} **b), comp))) | |||
#define sk_${type}_deep_copy(sk, copy_func, free_func)\\ | |||
((STACK_OF(${type})*) sk_deep_copy(CHECKED_CAST(const _STACK*, const STACK_OF(${type})*, sk), CHECKED_CAST(void* (*) (void*), ${ptrtype} (*) (${ptrtype}), copy_func), CHECKED_CAST(void (*) (void*), void (*) (${ptrtype}), free_func))) | |||
EOF | |||
} | |||
stack_types=$(cat "${include_dir}/stack.h" | grep '^ \* STACK_OF:' | sed -e 's/.*STACK_OF://' -e 's/ .*//') | |||
const_stack_types=$(cat "${include_dir}/stack.h" | grep '^ \* CONST_STACK_OF:' | sed -e 's/.*CONST_STACK_OF://' -e 's/ .*//') | |||
special_stack_types=$(cat "${include_dir}/stack.h" | grep '^ \* SPECIAL_STACK_OF:' | sed -e 's/.*SPECIAL_STACK_OF://' -e 's/ .*//') | |||
for type in $stack_types; do | |||
echo Stack of ${type} | |||
output_stack "${type}" "${type} *" | |||
done | |||
for type in $const_stack_types; do | |||
echo Stack of ${type} | |||
output_stack "${type}" "const ${type} *" | |||
done | |||
for type in $special_stack_types; do | |||
echo Stack of ${type} | |||
output_stack "${type}" "${type}" | |||
done | |||
clang-format -i "${include_dir}/stack_macros.h" |
@@ -84,8 +84,8 @@ typedef struct lookup_dir_st { | |||
STACK_OF(BY_DIR_ENTRY) *dirs; | |||
} BY_DIR; | |||
DECLARE_STACK_OF(BY_DIR_HASH) | |||
DECLARE_STACK_OF(BY_DIR_ENTRY) | |||
DEFINE_STACK_OF(BY_DIR_HASH) | |||
DEFINE_STACK_OF(BY_DIR_ENTRY) | |||
static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl, | |||
char **ret); | |||
@@ -71,7 +71,7 @@ | |||
typedef STACK_OF(X509_NAME_ENTRY) STACK_OF_X509_NAME_ENTRY; | |||
DECLARE_STACK_OF(STACK_OF_X509_NAME_ENTRY) | |||
DEFINE_STACK_OF(STACK_OF_X509_NAME_ENTRY) | |||
/* | |||
* Maximum length of X509_NAME: much larger than anything we should | |||
@@ -59,7 +59,7 @@ | |||
typedef struct X509_POLICY_DATA_st X509_POLICY_DATA; | |||
DECLARE_STACK_OF(X509_POLICY_DATA) | |||
DEFINE_STACK_OF(X509_POLICY_DATA) | |||
/* Internal structures */ | |||
@@ -207,7 +207,7 @@ X509_POLICY_NODE *tree_find_sk(STACK_OF(X509_POLICY_NODE) *sk, | |||
const ASN1_OBJECT *id); | |||
X509_POLICY_NODE *level_add_node(X509_POLICY_LEVEL *level, | |||
const X509_POLICY_DATA *data, | |||
X509_POLICY_DATA *data, | |||
X509_POLICY_NODE *parent, | |||
X509_POLICY_TREE *tree); | |||
void policy_node_free(X509_POLICY_NODE *node); | |||
@@ -107,7 +107,7 @@ X509_POLICY_NODE *level_find_node(const X509_POLICY_LEVEL *level, | |||
} | |||
X509_POLICY_NODE *level_add_node(X509_POLICY_LEVEL *level, | |||
const X509_POLICY_DATA *data, | |||
X509_POLICY_DATA *data, | |||
X509_POLICY_NODE *parent, | |||
X509_POLICY_TREE *tree) | |||
{ | |||
@@ -306,7 +306,7 @@ static int tree_init(X509_POLICY_TREE **ptree, STACK_OF(X509) *certs, | |||
} | |||
static int tree_link_matching_nodes(X509_POLICY_LEVEL *curr, | |||
const X509_POLICY_DATA *data) | |||
X509_POLICY_DATA *data) | |||
{ | |||
X509_POLICY_LEVEL *last = curr - 1; | |||
X509_POLICY_NODE *node; | |||
@@ -205,7 +205,7 @@ struct asn1_object_st | |||
int flags; /* Should we free this one */ | |||
}; | |||
DECLARE_STACK_OF(ASN1_OBJECT) | |||
DEFINE_STACK_OF(ASN1_OBJECT) | |||
#define ASN1_STRING_FLAG_BITS_LEFT 0x08 /* Set if 0x07 has bits left value */ | |||
/* This indicates that the ASN1_STRING is not a real value but just a place | |||
@@ -480,6 +480,7 @@ typedef const ASN1_ITEM ASN1_ITEM_EXP; | |||
ASN1_STRFLGS_DUMP_UNKNOWN | \ | |||
ASN1_STRFLGS_DUMP_DER) | |||
DEFINE_STACK_OF(ASN1_INTEGER) | |||
DECLARE_ASN1_SET_OF(ASN1_INTEGER) | |||
struct asn1_type_st | |||
@@ -512,6 +513,7 @@ struct asn1_type_st | |||
} value; | |||
}; | |||
DEFINE_STACK_OF(ASN1_TYPE) | |||
DECLARE_ASN1_SET_OF(ASN1_TYPE) | |||
typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY; | |||
@@ -407,10 +407,12 @@ ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */ | |||
typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE; | |||
typedef struct ASN1_ADB_st ASN1_ADB; | |||
typedef struct asn1_must_be_null_st ASN1_MUST_BE_NULL; | |||
struct ASN1_ADB_st { | |||
unsigned long flags; /* Various flags */ | |||
unsigned long offset; /* Offset of selector field */ | |||
STACK_OF(ASN1_ADB_TABLE) **app_items; /* Application defined items */ | |||
ASN1_MUST_BE_NULL *unused; | |||
const ASN1_ADB_TABLE *tbl; /* Table of possible types */ | |||
long tblcount; /* Number of entries in tbl */ | |||
const ASN1_TEMPLATE *default_tt; /* Type to use if no match */ | |||
@@ -850,7 +852,7 @@ DECLARE_ASN1_ITEM(ASN1_TBOOLEAN) | |||
DECLARE_ASN1_ITEM(ASN1_FBOOLEAN) | |||
DECLARE_ASN1_ITEM(ASN1_SEQUENCE) | |||
DECLARE_STACK_OF(ASN1_VALUE) | |||
DEFINE_STACK_OF(ASN1_VALUE) | |||
/* Functions used internally by the ASN1 code */ | |||
@@ -197,6 +197,12 @@ extern "C" { | |||
#define OPENSSL_MSVC_PRAGMA(arg) | |||
#endif | |||
#if defined(__GNUC__) | |||
#define OPENSSL_UNUSED __attribute__((unused)) | |||
#else | |||
#define OPENSSL_UNUSED | |||
#endif | |||
#if defined(BORINGSSL_UNSAFE_FUZZER_MODE) && \ | |||
!defined(BORINGSSL_UNSAFE_DETERMINISTIC_MODE) | |||
#define BORINGSSL_UNSAFE_DETERMINISTIC_MODE | |||
@@ -77,6 +77,8 @@ extern "C" { | |||
/* Allocation and freeing. */ | |||
DEFINE_STACK_OF(BIO) | |||
/* BIO_new creates a new BIO with the given type and a reference count of one. | |||
* It returns the fresh |BIO|, or NULL on error. */ | |||
OPENSSL_EXPORT BIO *BIO_new(const BIO_METHOD *type); | |||
@@ -89,6 +89,8 @@ struct conf_st { | |||
LHASH_OF(CONF_VALUE) *data; | |||
}; | |||
DEFINE_STACK_OF(CONF_VALUE) | |||
/* NCONF_new returns a fresh, empty |CONF|, or NULL on error. The |method| | |||
* argument must be NULL. */ | |||
@@ -17,6 +17,8 @@ | |||
#include <openssl/base.h> | |||
#include <openssl/stack.h> | |||
#if defined(__cplusplus) | |||
extern "C" { | |||
#endif | |||
@@ -29,6 +31,8 @@ extern "C" { | |||
* given blob to be kept in memory and referenced from multiple places. */ | |||
DEFINE_STACK_OF(CRYPTO_BUFFER) | |||
/* CRYPTO_BUFFER_POOL_new returns a freshly allocated |CRYPTO_BUFFER_POOL| or | |||
* NULL on error. */ | |||
OPENSSL_EXPORT CRYPTO_BUFFER_POOL* CRYPTO_BUFFER_POOL_new(void); | |||
@@ -1170,7 +1170,7 @@ OPENSSL_EXPORT void SSL_CTX_set_private_key_method( | |||
* | |||
* |SSL_CIPHER| objects represent cipher suites. */ | |||
DECLARE_STACK_OF(SSL_CIPHER) | |||
DEFINE_CONST_STACK_OF(SSL_CIPHER) | |||
/* SSL_get_cipher_by_value returns the structure representing a TLS cipher | |||
* suite based on its assigned number, or NULL if unknown. See | |||
@@ -2713,7 +2713,7 @@ struct srtp_protection_profile_st { | |||
unsigned long id; | |||
} /* SRTP_PROTECTION_PROFILE */; | |||
DECLARE_STACK_OF(SRTP_PROTECTION_PROFILE) | |||
DEFINE_CONST_STACK_OF(SRTP_PROTECTION_PROFILE) | |||
/* SRTP_* define constants for SRTP profiles. */ | |||
#define SRTP_AES128_CM_SHA1_80 0x0001 | |||
@@ -3601,7 +3601,7 @@ struct ssl_comp_st { | |||
char *method; | |||
}; | |||
DECLARE_STACK_OF(SSL_COMP) | |||
DEFINE_STACK_OF(SSL_COMP) | |||
/* The following flags do nothing and are included only to make it easier to | |||
* compile code with BoringSSL. */ | |||
@@ -4025,6 +4025,8 @@ struct ssl_cipher_preference_list_st { | |||
uint8_t *in_group_flags; | |||
}; | |||
DECLARE_STACK_OF(SSL_CUSTOM_EXTENSION) | |||
/* ssl_ctx_st (aka |SSL_CTX|) contains configuration common to several SSL | |||
* connections. */ | |||
struct ssl_ctx_st { | |||
@@ -74,16 +74,16 @@ extern "C" { | |||
* (once) with |DEFINE_STACK_OF(type)| and declared where needed with | |||
* |DECLARE_STACK_OF(type)|. For example: | |||
* | |||
* struct foo { | |||
* typedef struct foo_st { | |||
* int bar; | |||
* }; | |||
* } FOO; | |||
* | |||
* DEFINE_STACK_OF(struct foo); | |||
* DEFINE_STACK_OF(FOO); | |||
* | |||
* Although note that the stack will contain /pointers/ to |foo|. | |||
* Although note that the stack will contain /pointers/ to |FOO|. | |||
* | |||
* A macro will be defined for each of the sk_* functions below. For | |||
* STACK_OF(foo), the macros would be sk_foo_new, sk_foo_pop etc. */ | |||
* STACK_OF(FOO), the macros would be sk_FOO_new, sk_FOO_pop etc. */ | |||
/* stack_cmp_func is a comparison function that returns a value < 0, 0 or > 0 | |||
@@ -113,85 +113,6 @@ typedef struct stack_st { | |||
#define DECLARE_STACK_OF(type) STACK_OF(type); | |||
/* The make_macros.sh script in this directory parses the following lines and | |||
* generates the stack_macros.h file that contains macros for the following | |||
* types of stacks: | |||
* | |||
* STACK_OF:ACCESS_DESCRIPTION | |||
* STACK_OF:ASN1_ADB_TABLE | |||
* STACK_OF:ASN1_GENERALSTRING | |||
* STACK_OF:ASN1_INTEGER | |||
* STACK_OF:ASN1_OBJECT | |||
* STACK_OF:ASN1_STRING_TABLE | |||
* STACK_OF:ASN1_TYPE | |||
* STACK_OF:ASN1_VALUE | |||
* STACK_OF:BIO | |||
* STACK_OF:BY_DIR_ENTRY | |||
* STACK_OF:BY_DIR_HASH | |||
* STACK_OF:CONF_VALUE | |||
* STACK_OF:CRYPTO_BUFFER | |||
* STACK_OF:CRYPTO_EX_DATA_FUNCS | |||
* STACK_OF:DIST_POINT | |||
* STACK_OF:GENERAL_NAME | |||
* STACK_OF:GENERAL_NAMES | |||
* STACK_OF:GENERAL_SUBTREE | |||
* STACK_OF:POLICYINFO | |||
* STACK_OF:POLICYQUALINFO | |||
* STACK_OF:POLICY_MAPPING | |||
* STACK_OF:SSL_COMP | |||
* STACK_OF:SSL_CUSTOM_EXTENSION | |||
* STACK_OF:STACK_OF_X509_NAME_ENTRY | |||
* STACK_OF:SXNETID | |||
* STACK_OF:X509 | |||
* STACK_OF:X509V3_EXT_METHOD | |||
* STACK_OF:X509_ALGOR | |||
* STACK_OF:X509_ATTRIBUTE | |||
* STACK_OF:X509_CRL | |||
* STACK_OF:X509_EXTENSION | |||
* STACK_OF:X509_INFO | |||
* STACK_OF:X509_LOOKUP | |||
* STACK_OF:X509_NAME | |||
* STACK_OF:X509_NAME_ENTRY | |||
* STACK_OF:X509_OBJECT | |||
* STACK_OF:X509_POLICY_DATA | |||
* STACK_OF:X509_POLICY_NODE | |||
* STACK_OF:X509_PURPOSE | |||
* STACK_OF:X509_REVOKED | |||
* STACK_OF:X509_TRUST | |||
* STACK_OF:X509_VERIFY_PARAM | |||
* STACK_OF:void | |||
* | |||
* Some stacks contain only const structures, so the stack should return const | |||
* pointers to retain type-checking. | |||
* | |||
* CONST_STACK_OF:SRTP_PROTECTION_PROFILE | |||
* CONST_STACK_OF:SSL_CIPHER */ | |||
/* Some stacks are special because, although we would like STACK_OF(char *), | |||
* that would actually be a stack of pointers to char*, but we just want to | |||
* point to the string directly. In this case we call them "special" and use | |||
* |DEFINE_SPECIAL_STACK_OF(type)| */ | |||
#define DEFINE_SPECIAL_STACK_OF(type, inner) \ | |||
STACK_OF(type) { _STACK special_stack; }; \ | |||
OPENSSL_COMPILE_ASSERT(sizeof(type) == sizeof(void *), \ | |||
special_stack_of_non_pointer_##type); | |||
typedef char *OPENSSL_STRING; | |||
DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING, char) | |||
/* The make_macros.sh script in this directory parses the following lines and | |||
* generates the stack_macros.h file that contains macros for the following | |||
* types of stacks: | |||
* | |||
* SPECIAL_STACK_OF:OPENSSL_STRING */ | |||
#define IN_STACK_H | |||
#include <openssl/stack_macros.h> | |||
#undef IN_STACK_H | |||
/* These are the raw stack functions, you shouldn't be using them. Rather you | |||
* should be using the type stack macros implemented above. */ | |||
@@ -286,6 +207,143 @@ OPENSSL_EXPORT _STACK *sk_deep_copy(const _STACK *sk, | |||
void (*free_func)(void *)); | |||
/* Defining stack types. | |||
* | |||
* This set of macros is used to emit the typed functions that act on a | |||
* |STACK_OF(T)|. */ | |||
/* Stack functions must be tagged unused to support file-local stack types. | |||
* Clang's -Wunused-function only allows unused static inline functions if they | |||
* are defined in a header. */ | |||
#define DEFINE_STACK_OF_IMPL(name, ptrtype, constptrtype) \ | |||
DECLARE_STACK_OF(name); \ | |||
\ | |||
typedef int (*stack_##name##_cmp_func)(constptrtype *a, constptrtype *b); \ | |||
\ | |||
static inline OPENSSL_UNUSED STACK_OF(name) * \ | |||
sk_##name##_new(stack_##name##_cmp_func comp) { \ | |||
return (STACK_OF(name) *)sk_new((stack_cmp_func)comp); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED STACK_OF(name) *sk_##name##_new_null(void) { \ | |||
return (STACK_OF(name) *)sk_new_null(); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED size_t sk_##name##_num( \ | |||
const STACK_OF(name) *sk) { \ | |||
return sk_num((const _STACK *)sk); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED void sk_##name##_zero(STACK_OF(name) *sk) { \ | |||
sk_zero((_STACK *)sk); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED ptrtype sk_##name##_value( \ | |||
const STACK_OF(name) *sk, size_t i) { \ | |||
return (ptrtype)sk_value((const _STACK *)sk, i); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED ptrtype sk_##name##_set(STACK_OF(name) *sk, \ | |||
size_t i, ptrtype p) { \ | |||
return (ptrtype)sk_set((_STACK *)sk, i, (void *)p); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED void sk_##name##_free(STACK_OF(name) *sk) { \ | |||
sk_free((_STACK *)sk); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED void sk_##name##_pop_free( \ | |||
STACK_OF(name) *sk, void (*free_func)(ptrtype p)) { \ | |||
sk_pop_free((_STACK *)sk, (void (*)(void *))free_func); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED size_t sk_##name##_insert( \ | |||
STACK_OF(name) *sk, ptrtype p, size_t where) { \ | |||
return sk_insert((_STACK *)sk, (void *)p, where); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED ptrtype sk_##name##_delete(STACK_OF(name) *sk, \ | |||
size_t where) { \ | |||
return (ptrtype)sk_delete((_STACK *)sk, where); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED ptrtype sk_##name##_delete_ptr( \ | |||
STACK_OF(name) *sk, ptrtype p) { \ | |||
return (ptrtype)sk_delete_ptr((_STACK *)sk, (void *)p); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED int sk_##name##_find( \ | |||
STACK_OF(name) *sk, size_t *out_index, ptrtype p) { \ | |||
return sk_find((_STACK *)sk, out_index, (void *)p); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED ptrtype sk_##name##_shift(STACK_OF(name) *sk) { \ | |||
return (ptrtype)sk_shift((_STACK *)sk); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED size_t sk_##name##_push(STACK_OF(name) *sk, \ | |||
ptrtype p) { \ | |||
return sk_push((_STACK *)sk, (void *)p); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED ptrtype sk_##name##_pop(STACK_OF(name) *sk) { \ | |||
return (ptrtype)sk_pop((_STACK *)sk); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED STACK_OF(name) * \ | |||
sk_##name##_dup(const STACK_OF(name) *sk) { \ | |||
return (STACK_OF(name) *)sk_dup((const _STACK *)sk); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED void sk_##name##_sort(STACK_OF(name) *sk) { \ | |||
sk_sort((_STACK *)sk); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED int sk_##name##_is_sorted( \ | |||
const STACK_OF(name) *sk) { \ | |||
return sk_is_sorted((const _STACK *)sk); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED stack_##name##_cmp_func \ | |||
sk_##name##_set_cmp_func(STACK_OF(name) *sk, \ | |||
stack_##name##_cmp_func comp) { \ | |||
return (stack_##name##_cmp_func)sk_set_cmp_func((_STACK *)sk, \ | |||
(stack_cmp_func)comp); \ | |||
} \ | |||
\ | |||
static inline OPENSSL_UNUSED STACK_OF(name) * \ | |||
sk_##name##_deep_copy(const STACK_OF(name) *sk, \ | |||
ptrtype(*copy_func)(ptrtype), \ | |||
void (*free_func)(ptrtype)) { \ | |||
return (STACK_OF(name) *)sk_deep_copy((_STACK *)sk, \ | |||
(void *(*)(void *))copy_func, \ | |||
(void (*)(void *))free_func); \ | |||
} | |||
/* DEFINE_STACK_OF defines |STACK_OF(type)| to be a stack whose elements are | |||
* |type| *. */ | |||
#define DEFINE_STACK_OF(type) DEFINE_STACK_OF_IMPL(type, type *, const type *) | |||
/* DEFINE_CONST_STACK_OF defines |STACK_OF(type)| to be a stack whose elements | |||
* are const |type| *. */ | |||
#define DEFINE_CONST_STACK_OF(type) \ | |||
DEFINE_STACK_OF_IMPL(type, const type *, const type *) | |||
/* DEFINE_SPECIAL_STACK_OF defines |STACK_OF(type)| to be a stack whose elements | |||
* are |type|, where |type| must be a typedef for a pointer. */ | |||
#define DEFINE_SPECIAL_STACK_OF(type) \ | |||
OPENSSL_COMPILE_ASSERT(sizeof(type) == sizeof(void *), \ | |||
special_stack_of_non_pointer_##type); \ | |||
DEFINE_STACK_OF_IMPL(type, type, const type) | |||
typedef char *OPENSSL_STRING; | |||
DEFINE_STACK_OF(void) | |||
DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING) | |||
#if defined(__cplusplus) | |||
} /* extern C */ | |||
#endif | |||
@@ -111,6 +111,7 @@ struct X509_objects_st | |||
int (*i2a)(void); | |||
} /* X509_OBJECTS */; | |||
DEFINE_STACK_OF(X509_ALGOR) | |||
DECLARE_ASN1_SET_OF(X509_ALGOR) | |||
typedef STACK_OF(X509_ALGOR) X509_ALGORS; | |||
@@ -142,7 +143,7 @@ struct X509_name_entry_st | |||
int size; /* temp variable */ | |||
} /* X509_NAME_ENTRY */; | |||
DECLARE_STACK_OF(X509_NAME_ENTRY) | |||
DEFINE_STACK_OF(X509_NAME_ENTRY) | |||
DECLARE_ASN1_SET_OF(X509_NAME_ENTRY) | |||
/* we always keep X509_NAMEs in 2 forms. */ | |||
@@ -160,7 +161,7 @@ struct X509_name_st | |||
int canon_enclen; | |||
} /* X509_NAME */; | |||
DECLARE_STACK_OF(X509_NAME) | |||
DEFINE_STACK_OF(X509_NAME) | |||
#define X509_EX_V_NETSCAPE_HACK 0x8000 | |||
#define X509_EX_V_INIT 0x0001 | |||
@@ -173,7 +174,7 @@ struct X509_extension_st | |||
typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS; | |||
DECLARE_STACK_OF(X509_EXTENSION) | |||
DEFINE_STACK_OF(X509_EXTENSION) | |||
DECLARE_ASN1_SET_OF(X509_EXTENSION) | |||
/* a sequence of these are used */ | |||
@@ -188,7 +189,7 @@ struct x509_attributes_st | |||
} value; | |||
} /* X509_ATTRIBUTE */; | |||
DECLARE_STACK_OF(X509_ATTRIBUTE) | |||
DEFINE_STACK_OF(X509_ATTRIBUTE) | |||
DECLARE_ASN1_SET_OF(X509_ATTRIBUTE) | |||
@@ -240,6 +241,9 @@ struct x509_cert_aux_st | |||
STACK_OF(X509_ALGOR) *other; /* other unspecified info */ | |||
} /* X509_CERT_AUX */; | |||
DECLARE_STACK_OF(DIST_POINT) | |||
DECLARE_STACK_OF(GENERAL_NAME) | |||
struct x509_st | |||
{ | |||
X509_CINF *cert_info; | |||
@@ -267,7 +271,7 @@ struct x509_st | |||
CRYPTO_MUTEX lock; | |||
} /* X509 */; | |||
DECLARE_STACK_OF(X509) | |||
DEFINE_STACK_OF(X509) | |||
DECLARE_ASN1_SET_OF(X509) | |||
/* This is used for a table of trust checking functions */ | |||
@@ -281,7 +285,7 @@ struct x509_trust_st { | |||
void *arg2; | |||
} /* X509_TRUST */; | |||
DECLARE_STACK_OF(X509_TRUST) | |||
DEFINE_STACK_OF(X509_TRUST) | |||
struct x509_cert_pair_st { | |||
X509 *forward; | |||
@@ -403,7 +407,7 @@ struct x509_revoked_st | |||
int sequence; /* load sequence */ | |||
}; | |||
DECLARE_STACK_OF(X509_REVOKED) | |||
DEFINE_STACK_OF(X509_REVOKED) | |||
DECLARE_ASN1_SET_OF(X509_REVOKED) | |||
struct X509_crl_info_st | |||
@@ -418,6 +422,8 @@ struct X509_crl_info_st | |||
ASN1_ENCODING enc; | |||
} /* X509_CRL_INFO */; | |||
DECLARE_STACK_OF(GENERAL_NAMES) | |||
struct X509_crl_st | |||
{ | |||
/* actual signature */ | |||
@@ -441,7 +447,7 @@ struct X509_crl_st | |||
void *meth_data; | |||
} /* X509_CRL */; | |||
DECLARE_STACK_OF(X509_CRL) | |||
DEFINE_STACK_OF(X509_CRL) | |||
DECLARE_ASN1_SET_OF(X509_CRL) | |||
struct private_key_st | |||
@@ -476,7 +482,7 @@ struct X509_info_st | |||
} /* X509_INFO */; | |||
DECLARE_STACK_OF(X509_INFO) | |||
DEFINE_STACK_OF(X509_INFO) | |||
#endif | |||
/* The next 2 structures and their 8 routines were sent to me by | |||
@@ -129,8 +129,8 @@ typedef struct x509_object_st | |||
} data; | |||
} X509_OBJECT; | |||
DECLARE_STACK_OF(X509_LOOKUP) | |||
DECLARE_STACK_OF(X509_OBJECT) | |||
DEFINE_STACK_OF(X509_LOOKUP) | |||
DEFINE_STACK_OF(X509_OBJECT) | |||
/* This is a static that defines the function interface */ | |||
typedef struct x509_lookup_method_st | |||
@@ -173,7 +173,7 @@ struct X509_VERIFY_PARAM_st | |||
X509_VERIFY_PARAM_ID *id; /* opaque ID data */ | |||
}; | |||
DECLARE_STACK_OF(X509_VERIFY_PARAM) | |||
DEFINE_STACK_OF(X509_VERIFY_PARAM) | |||
/* This is used to hold everything. It is used for all certificate | |||
* validation. Once we have a certificate chain, the 'verify' | |||
@@ -137,7 +137,7 @@ void *db; | |||
typedef struct v3_ext_method X509V3_EXT_METHOD; | |||
DECLARE_STACK_OF(X509V3_EXT_METHOD) | |||
DEFINE_STACK_OF(X509V3_EXT_METHOD) | |||
/* ext_flags values */ | |||
#define X509V3_EXT_DYNAMIC 0x1 | |||
@@ -201,23 +201,25 @@ union { | |||
} d; | |||
} GENERAL_NAME; | |||
DEFINE_STACK_OF(GENERAL_NAME) | |||
DECLARE_ASN1_SET_OF(GENERAL_NAME) | |||
typedef STACK_OF(GENERAL_NAME) GENERAL_NAMES; | |||
DEFINE_STACK_OF(GENERAL_NAMES) | |||
typedef struct ACCESS_DESCRIPTION_st { | |||
ASN1_OBJECT *method; | |||
GENERAL_NAME *location; | |||
} ACCESS_DESCRIPTION; | |||
DEFINE_STACK_OF(ACCESS_DESCRIPTION) | |||
DECLARE_ASN1_SET_OF(ACCESS_DESCRIPTION) | |||
typedef STACK_OF(ACCESS_DESCRIPTION) AUTHORITY_INFO_ACCESS; | |||
typedef STACK_OF(ASN1_OBJECT) EXTENDED_KEY_USAGE; | |||
DECLARE_STACK_OF(GENERAL_NAME) | |||
DECLARE_ASN1_SET_OF(GENERAL_NAME) | |||
DECLARE_STACK_OF(ACCESS_DESCRIPTION) | |||
DECLARE_ASN1_SET_OF(ACCESS_DESCRIPTION) | |||
typedef struct DIST_POINT_NAME_st { | |||
int type; | |||
union { | |||
@@ -251,7 +253,7 @@ int dp_reasons; | |||
typedef STACK_OF(DIST_POINT) CRL_DIST_POINTS; | |||
DECLARE_STACK_OF(DIST_POINT) | |||
DEFINE_STACK_OF(DIST_POINT) | |||
DECLARE_ASN1_SET_OF(DIST_POINT) | |||
struct AUTHORITY_KEYID_st { | |||
@@ -267,7 +269,7 @@ typedef struct SXNET_ID_st { | |||
ASN1_OCTET_STRING *user; | |||
} SXNETID; | |||
DECLARE_STACK_OF(SXNETID) | |||
DEFINE_STACK_OF(SXNETID) | |||
DECLARE_ASN1_SET_OF(SXNETID) | |||
typedef struct SXNET_st { | |||
@@ -294,7 +296,7 @@ typedef struct POLICYQUALINFO_st { | |||
} d; | |||
} POLICYQUALINFO; | |||
DECLARE_STACK_OF(POLICYQUALINFO) | |||
DEFINE_STACK_OF(POLICYQUALINFO) | |||
DECLARE_ASN1_SET_OF(POLICYQUALINFO) | |||
typedef struct POLICYINFO_st { | |||
@@ -304,7 +306,7 @@ typedef struct POLICYINFO_st { | |||
typedef STACK_OF(POLICYINFO) CERTIFICATEPOLICIES; | |||
DECLARE_STACK_OF(POLICYINFO) | |||
DEFINE_STACK_OF(POLICYINFO) | |||
DECLARE_ASN1_SET_OF(POLICYINFO) | |||
typedef struct POLICY_MAPPING_st { | |||
@@ -312,7 +314,7 @@ typedef struct POLICY_MAPPING_st { | |||
ASN1_OBJECT *subjectDomainPolicy; | |||
} POLICY_MAPPING; | |||
DECLARE_STACK_OF(POLICY_MAPPING) | |||
DEFINE_STACK_OF(POLICY_MAPPING) | |||
typedef STACK_OF(POLICY_MAPPING) POLICY_MAPPINGS; | |||
@@ -322,7 +324,7 @@ typedef struct GENERAL_SUBTREE_st { | |||
ASN1_INTEGER *maximum; | |||
} GENERAL_SUBTREE; | |||
DECLARE_STACK_OF(GENERAL_SUBTREE) | |||
DEFINE_STACK_OF(GENERAL_SUBTREE) | |||
struct NAME_CONSTRAINTS_st { | |||
STACK_OF(GENERAL_SUBTREE) *permittedSubtrees; | |||
@@ -501,7 +503,7 @@ typedef struct x509_purpose_st { | |||
#define X509V3_ADD_DELETE 5L | |||
#define X509V3_ADD_SILENT 0x10 | |||
DECLARE_STACK_OF(X509_PURPOSE) | |||
DEFINE_STACK_OF(X509_PURPOSE) | |||
DECLARE_ASN1_FUNCTIONS(BASIC_CONSTRAINTS) | |||
@@ -721,7 +723,7 @@ OPENSSL_EXPORT int X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE)* | |||
unsigned long chtype); | |||
OPENSSL_EXPORT void X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent); | |||
DECLARE_STACK_OF(X509_POLICY_NODE) | |||
DEFINE_STACK_OF(X509_POLICY_NODE) | |||
/* BEGIN ERROR CODES */ | |||
/* The following lines are auto generated by the script mkerr.pl. Any changes | |||
@@ -591,6 +591,8 @@ struct ssl_custom_extension { | |||
void SSL_CUSTOM_EXTENSION_free(SSL_CUSTOM_EXTENSION *custom_extension); | |||
DEFINE_STACK_OF(SSL_CUSTOM_EXTENSION) | |||
int custom_ext_add_clienthello(SSL_HANDSHAKE *hs, CBB *extensions); | |||
int custom_ext_parse_serverhello(SSL_HANDSHAKE *hs, int *out_alert, | |||
uint16_t value, const CBS *extension); | |||