1
/* ====================================================================
4
* Redistribution and use in source and binary forms, with or without
5
* modification, are permitted provided that the following conditions
6
* are met:
8
* 1. Redistributions of source code must retain the above copyright
9
* notice, this list of conditions and the following disclaimer.
11
* 2. Redistributions in binary form must reproduce the above copyright
12
* notice, this list of conditions and the following disclaimer in
13
* the documentation and/or other materials provided with the
14
* distribution.
16
* 3. All advertising materials mentioning features or use of this
17
* software must display the following acknowledgment:
18
* "This product includes software developed by the OpenSSL Project
19
* for use in the OpenSSL Toolkit. (
http://www.openssl.org/
)"
21
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22
* endorse or promote products derived from this software without
23
* prior written permission. For written permission, please contact
24
*
[email protected]
.
26
* 5. Products derived from this software may not be called "OpenSSL"
27
* nor may "OpenSSL" appear in their names without prior written
28
* permission of the OpenSSL Project.
30
* 6. Redistributions of any form whatsoever must retain the following
31
* acknowledgment:
32
* "This product includes software developed by the OpenSSL Project
33
* for use in the OpenSSL Toolkit (
http://www.openssl.org/
)"
35
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
39
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46
* OF THE POSSIBILITY OF SUCH DAMAGE.
47
* ====================================================================
49
* This product includes cryptographic software written by Eric Young
50
* (ea
[email protected]
). This product includes software written by Tim
51
* Hudson (
[email protected]
). */
53
#
ifndef
OPENSSL_HEADER_BASE_H
54
#define
57
// This file should be the first included by all BoringSSL headers.
59
#include
<stddef.h>
60
#include
<stdint.h>
61
#include
<sys/types.h>
63
#
if
defined(
__MINGW32__
)
64
// stdio.h is needed on MinGW for __MINGW_PRINTF_FORMAT.
65
#include <stdio.h>
66
#
endif
68
#
if
defined(
__APPLE__
)
69
#include <TargetConditionals.h>
70
#
endif
72
// Include a BoringSSL-only header so consumers including this header without
73
// setting up include paths do not accidentally pick up the system
74
// opensslconf.h.
75
#include
<openssl/is_boringssl.h>
76
#include
<openssl/opensslconf.h>
78
#
if
defined(
BORINGSSL_PREFIX
)
79
#include <boringssl_prefix_symbols.h>
80
#
endif
82
#
if
defined(
__cplusplus
)
83
extern
"C"
{
84
#
endif
87
#
if
defined(
__x86_64
) || defined(
_M_AMD64
) || defined(
_M_X64
)
88
#define
OPENSSL_64_BIT
89
#define
OPENSSL_X86_64
90
#
elif
defined(__x86) || defined(__i386) || defined(__i386__) || defined(_M_IX86)
91
#define OPENSSL_32_BIT
92
#define OPENSSL_X86
93
#elif defined(__AARCH64EL__) || defined(_M_ARM64)
94
#define OPENSSL_64_BIT
95
#define OPENSSL_AARCH64
96
#elif defined(__ARMEL__) || defined(_M_ARM)
97
#define OPENSSL_32_BIT
98
#define OPENSSL_ARM
99
#elif (defined(__PPC64__) || defined(__powerpc64__)) && defined(_LITTLE_ENDIAN)
100
#define OPENSSL_64_BIT
101
#define OPENSSL_PPC64LE
102
#elif defined(__MIPSEL__) && !defined(__LP64__)
103
#define OPENSSL_32_BIT
104
#define OPENSSL_MIPS
105
#elif defined(__MIPSEL__) && defined(__LP64__)
106
#define OPENSSL_64_BIT
107
#define OPENSSL_MIPS64
108
#elif defined(__riscv) && __SIZEOF_POINTER__ == 8
109
#define OPENSSL_64_BIT
110
#elif defined(__riscv) && __SIZEOF_POINTER__ == 4
111
#define OPENSSL_32_BIT
112
#elif defined(__pnacl__)
113
#define OPENSSL_32_BIT
114
#define OPENSSL_PNACL
115
#elif defined(__wasm__)
116
#define OPENSSL_32_BIT
117
#elif defined(__asmjs__)
118
#define OPENSSL_32_BIT
119
#elif defined(__myriad2__)
120
#define OPENSSL_32_BIT
121
#else
122
// Note BoringSSL only supports standard 32-bit and 64-bit two's-complement,
123
// little-endian architectures. Functions will not produce the correct answer
124
// on other systems. Run the crypto_test binary, notably
125
// crypto/compiler_test.cc, before adding a new architecture.
126
#error "Unknown target CPU"
127
#
endif
129
#
if
defined(
__APPLE__
)
130
#define OPENSSL_APPLE
131
// Note |TARGET_OS_MAC| is set for all Apple OS variants. |TARGET_OS_OSX|
132
// targets macOS specifically.
133
#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
134
#define OPENSSL_MACOS
135
#endif
136
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
137
#define OPENSSL_IOS
138
#endif
139
#
endif
141
#
if
defined(
_WIN32
)
142
#define OPENSSL_WINDOWS
143
#
endif
145
// Trusty isn't Linux but currently defines __linux__. As a workaround, we
146
// exclude it here.
147
// TODO(b/169780122): Remove this workaround once Trusty no longer defines it.
148
#
if
defined(
__linux__
) && !defined(
__TRUSTY__
)
149
#define
OPENSSL_LINUX
150
#
endif
152
#
if
defined(
__Fuchsia__
)
153
#define OPENSSL_FUCHSIA
154
#
endif
156
#
if
defined(
__TRUSTY__
)
157
#define OPENSSL_TRUSTY
158
#define OPENSSL_NO_THREADS_CORRUPT_MEMORY_AND_LEAK_SECRETS_IF_THREADED
159
#
endif
161
#
if
defined(
__ANDROID_API__
)
162
#define OPENSSL_ANDROID
163
#
endif
165
#
if
defined(
__FreeBSD__
)
166
#define OPENSSL_FREEBSD
167
#
endif
169
// BoringSSL requires platform's locking APIs to make internal global state
170
// thread-safe, including the PRNG. On some single-threaded embedded platforms,
171
// locking APIs may not exist, so this dependency may be disabled with the
172
// following build flag.
173
//
174
// IMPORTANT: Doing so means the consumer promises the library will never be
175
// used in any multi-threaded context. It causes BoringSSL to be globally
176
// thread-unsafe. Setting it inappropriately will subtly and unpredictably
177
// corrupt memory and leak secret keys.
178
//
179
// Do not set this flag on any platform where threads are possible. BoringSSL
180
// maintainers will not provide support for any consumers that do so. Changes
181
// which break such unsupported configurations will not be reverted.
182
#
if
!defined(
OPENSSL_NO_THREADS_CORRUPT_MEMORY_AND_LEAK_SECRETS_IF_THREADED
)
183
#define
OPENSSL_THREADS
184
#
endif
186
#define
OPENSSL_IS_BORINGSSL
187
#define
OPENSSL_VERSION_NUMBER
0x1010107f
188
#define
SSLEAY_VERSION_NUMBER
OPENSSL_VERSION_NUMBER
190
// BORINGSSL_API_VERSION is a positive integer that increments as BoringSSL
191
// changes over time. The value itself is not meaningful. It will be incremented
192
// whenever is convenient to coordinate an API change with consumers. This will
193
// not denote any special point in development.
194
//
195
// A consumer may use this symbol in the preprocessor to temporarily build
196
// against multiple revisions of BoringSSL at the same time. It is not
197
// recommended to do so for longer than is necessary.
198
#define
BORINGSSL_API_VERSION
16
200
#
if
defined(
BORINGSSL_SHARED_LIBRARY
)
202
#if defined(OPENSSL_WINDOWS)
204
#if defined(BORINGSSL_IMPLEMENTATION)
205
#define OPENSSL_EXPORT __declspec(dllexport)
206
#else
207
#define OPENSSL_EXPORT __declspec(dllimport)
208
#endif
210
#else // defined(OPENSSL_WINDOWS)
212
#if defined(BORINGSSL_IMPLEMENTATION)
213
#define OPENSSL_EXPORT __attribute__((visibility("default")))
214
#else
215
#define OPENSSL_EXPORT
216
#endif
218
#endif // defined(OPENSSL_WINDOWS)
220
#
else
// defined(BORINGSSL_SHARED_LIBRARY)
222
#define
OPENSSL_EXPORT
224
#
endif
// defined(BORINGSSL_SHARED_LIBRARY)
227
#
if
defined(
__GNUC__
) || defined(
__clang__
)
228
// MinGW has two different printf implementations. Ensure the format macro
229
// matches the selected implementation. See
230
//
https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/
.
231
#
if
defined(
__MINGW_PRINTF_FORMAT
)
232
#define OPENSSL_PRINTF_FORMAT_FUNC(string_index, first_to_check) \
233
__attribute__( \
234
(__format__(__MINGW_PRINTF_FORMAT, string_index, first_to_check)))
235
#
else
236
#define
OPENSSL_PRINTF_FORMAT_FUNC
(string_index, first_to_check) \
237
__attribute__((__format__(__printf__, string_index, first_to_check)))
238
#
endif
239
#
else
240
#define OPENSSL_PRINTF_FORMAT_FUNC(string_index, first_to_check)
241
#
endif
243
// OPENSSL_MSVC_PRAGMA emits a pragma on MSVC and nothing on other compilers.
244
#
if
defined(
_MSC_VER
)
245
#define OPENSSL_MSVC_PRAGMA(arg) __pragma(arg)
246
#
else
247
#define
OPENSSL_MSVC_PRAGMA
(arg)
248
#
endif
250
#
if
defined(
__GNUC__
) || defined(
__clang__
)
251
#define
OPENSSL_UNUSED
__attribute__((unused))
252
#
else
253
#define OPENSSL_UNUSED
254
#
endif
256
// C and C++ handle inline functions differently. In C++, an inline function is
257
// defined in just the header file, potentially emitted in multiple compilation
258
// units (in cases the compiler did not inline), but each copy must be identical
259
// to satsify ODR. In C, a non-static inline must be manually emitted in exactly
260
// one compilation unit with a separate extern inline declaration.
261
//
262
// In both languages, exported inline functions referencing file-local symbols
263
// are problematic. C forbids this altogether (though GCC and Clang seem not to
264
// enforce it). It works in C++, but ODR requires the definitions be identical,
265
// including all names in the definitions resolving to the "same entity". In
266
// practice, this is unlikely to be a problem, but an inline function that
267
// returns a pointer to a file-local symbol
268
// could compile oddly.
269
//
270
// Historically, we used static inline in headers. However, to satisfy ODR, use
271
// plain inline in C++, to allow inline consumer functions to call our header
272
// functions. Plain inline would also work better with C99 inline, but that is
273
// not used much in practice, extern inline is tedious, and there are conflicts
274
// with the old gnu89 model:
275
//
https://stackoverflow.com/questions/216510/extern-inline
276
#
if
defined(
__cplusplus
)
277
#define
OPENSSL_INLINE
inline
278
#
else
279
// Add OPENSSL_UNUSED so that, should an inline function be emitted via macro
280
// (e.g. a |STACK_OF(T)| implementation) in a source file without tripping
281
// clang's -Wunused-function.
282
#define OPENSSL_INLINE static inline OPENSSL_UNUSED
283
#
endif
285
#
if
defined(
BORINGSSL_UNSAFE_FUZZER_MODE
) && \
286
!defined(
BORINGSSL_UNSAFE_DETERMINISTIC_MODE
)
287
#define BORINGSSL_UNSAFE_DETERMINISTIC_MODE
288
#
endif
290
#
if
defined(
__has_feature
)
291
#
if
__has_feature
(address_sanitizer)
292
#define OPENSSL_ASAN
293
#
endif
294
#
if
__has_feature
(thread_sanitizer)
295
#define OPENSSL_TSAN
296
#
endif
297
#
if
__has_feature
(memory_sanitizer)
298
#define OPENSSL_MSAN
299
#define OPENSSL_ASM_INCOMPATIBLE
300
#
endif
301
#
endif
303
#
if
defined(
OPENSSL_ASM_INCOMPATIBLE
)
304
#undef OPENSSL_ASM_INCOMPATIBLE
305
#if !defined(OPENSSL_NO_ASM)
306
#define OPENSSL_NO_ASM
307
#endif
308
#
endif
// OPENSSL_ASM_INCOMPATIBLE
310
#
if
defined(
__cplusplus
)
311
// enums can be predeclared, but only in C++ and only if given an explicit type.
312
// C doesn't support setting an explicit type for enums thus a #define is used
313
// to do this only for C++. However, the ABI type between C and C++ need to have
314
// equal sizes, which is confirmed in a unittest.
315
#define
BORINGSSL_ENUM_INT
: int
316
enum
ssl_early_data_reason_t
BORINGSSL_ENUM_INT
;
317
enum
ssl_encryption_level_t
BORINGSSL_ENUM_INT
;
318
enum
ssl_private_key_result_t
BORINGSSL_ENUM_INT
;
319
enum
ssl_renegotiate_mode_t
BORINGSSL_ENUM_INT
;
320
enum
ssl_select_cert_result_t
BORINGSSL_ENUM_INT
;
321
enum
ssl_select_cert_result_t
BORINGSSL_ENUM_INT
;
322
enum
ssl_ticket_aead_result_t
BORINGSSL_ENUM_INT
;
323
enum
ssl_verify_result_t
BORINGSSL_ENUM_INT
;
324
#
else
325
#define BORINGSSL_ENUM_INT
326
#
endif
328
// CRYPTO_THREADID is a dummy value.
329
typedef
int
CRYPTO_THREADID
;
331
// An |ASN1_NULL| is an opaque type. asn1.h represents the ASN.1 NULL value as
332
// an opaque, non-NULL |ASN1_NULL*| pointer.
333
typedef
struct
asn1_null_st
ASN1_NULL
;
335
typedef
int
ASN1_BOOLEAN
;
336
typedef
struct
ASN1_ITEM_st
ASN1_ITEM
;
337
typedef
struct
asn1_object_st
ASN1_OBJECT
;
338
typedef
struct
asn1_pctx_st
ASN1_PCTX
;
339
typedef
struct
asn1_string_st
ASN1_BIT_STRING
;
340
typedef
struct
asn1_string_st
ASN1_BMPSTRING
;
341
typedef
struct
asn1_string_st
ASN1_ENUMERATED
;
342
typedef
struct
asn1_string_st
ASN1_GENERALIZEDTIME
;
343
typedef
struct
asn1_string_st
ASN1_GENERALSTRING
;
344
typedef
struct
asn1_string_st
ASN1_IA5STRING
;
345
typedef
struct
asn1_string_st
ASN1_INTEGER
;
346
typedef
struct
asn1_string_st
ASN1_OCTET_STRING
;
347
typedef
struct
asn1_string_st
ASN1_PRINTABLESTRING
;
348
typedef
struct
asn1_string_st
ASN1_STRING
;
349
typedef
struct
asn1_string_st
ASN1_T61STRING
;
350
typedef
struct
asn1_string_st
ASN1_TIME
;
351
typedef
struct
asn1_string_st
ASN1_UNIVERSALSTRING
;
352
typedef
struct
asn1_string_st
ASN1_UTCTIME
;
353
typedef
struct
asn1_string_st
ASN1_UTF8STRING
;
354
typedef
struct
asn1_string_st
ASN1_VISIBLESTRING
;
355
typedef
struct
asn1_type_st
ASN1_TYPE
;
356
typedef
struct
AUTHORITY_KEYID_st
AUTHORITY_KEYID
;
357
typedef
struct
BASIC_CONSTRAINTS_st
BASIC_CONSTRAINTS
;
358
typedef
struct
DIST_POINT_st
DIST_POINT
;
359
typedef
struct
DSA_SIG_st
DSA_SIG
;
360
typedef
struct
ISSUING_DIST_POINT_st
ISSUING_DIST_POINT
;
361
typedef
struct
NAME_CONSTRAINTS_st
NAME_CONSTRAINTS
;
362
typedef
struct
Netscape_spkac_st
NETSCAPE_SPKAC
;
363
typedef
struct
Netscape_spki_st
NETSCAPE_SPKI
;
364
typedef
struct
RIPEMD160state_st
RIPEMD160_CTX
;
365
typedef
struct
X509_POLICY_CACHE_st
X509_POLICY_CACHE
;
366
typedef
struct
X509_POLICY_LEVEL_st
X509_POLICY_LEVEL
;
367
typedef
struct
X509_POLICY_NODE_st
X509_POLICY_NODE
;
368
typedef
struct
X509_POLICY_TREE_st
X509_POLICY_TREE
;
369
typedef
struct
X509_VERIFY_PARAM_st
X509_VERIFY_PARAM
;
370
typedef
struct
X509_algor_st
X509_ALGOR
;
371
typedef
struct
X509_crl_st
X509_CRL
;
372
typedef
struct
X509_extension_st
X509_EXTENSION
;
373
typedef
struct
X509_info_st
X509_INFO
;
374
typedef
struct
X509_name_entry_st
X509_NAME_ENTRY
;
375
typedef
struct
X509_name_st
X509_NAME
;
376
typedef
struct
X509_pubkey_st
X509_PUBKEY
;
377
typedef
struct
X509_req_st
X509_REQ
;
378
typedef
struct
X509_sig_st
X509_SIG
;
379
typedef
struct
X509_val_st
X509_VAL
;
380
typedef
struct
bignum_ctx
BN_CTX
;
381
typedef
struct
bignum_st
BIGNUM
;
382
typedef
struct
bio_method_st
BIO_METHOD
;
383
typedef
struct
bio_st
BIO
;
384
typedef
struct
blake2b_state_st
BLAKE2B_CTX
;
385
typedef
struct
bn_gencb_st
BN_GENCB
;
386
typedef
struct
bn_mont_ctx_st
BN_MONT_CTX
;
387
typedef
struct
buf_mem_st
BUF_MEM
;
388
typedef
struct
cbb_st
CBB
;
389
typedef
struct
cbs_st
CBS
;
390
typedef
struct
cmac_ctx_st
CMAC_CTX
;
391
typedef
struct
conf_st
CONF
;
392
typedef
struct
conf_value_st
CONF_VALUE
;
393
typedef
struct
crypto_buffer_pool_st
CRYPTO_BUFFER_POOL
;
394
typedef
struct
crypto_buffer_st
CRYPTO_BUFFER
;
395
typedef
struct
dh_st
DH
;
396
typedef
struct
dsa_st
DSA
;
397
typedef
struct
ec_group_st
EC_GROUP
;
398
typedef
struct
ec_key_st
EC_KEY
;
399
typedef
struct
ec_point_st
EC_POINT
;
400
typedef
struct
ecdsa_method_st
ECDSA_METHOD
;
401
typedef
struct
ecdsa_sig_st
ECDSA_SIG
;
402
typedef
struct
engine_st
ENGINE
;
403
typedef
struct
env_md_ctx_st
EVP_MD_CTX
;
404
typedef
struct
env_md_st
EVP_MD
;
405
typedef
struct
evp_aead_st
EVP_AEAD
;
406
typedef
struct
evp_cipher_ctx_st
EVP_CIPHER_CTX
;
407
typedef
struct
evp_cipher_st
EVP_CIPHER
;
408
typedef
struct
evp_encode_ctx_st
EVP_ENCODE_CTX
;
409
typedef
struct
evp_hpke_aead_st
EVP_HPKE_AEAD
;
410
typedef
struct
evp_hpke_ctx_st
EVP_HPKE_CTX
;
411
typedef
struct
evp_hpke_kdf_st
EVP_HPKE_KDF
;
412
typedef
struct
evp_hpke_kem_st
EVP_HPKE_KEM
;
413
typedef
struct
evp_hpke_key_st
EVP_HPKE_KEY
;
414
typedef
struct
evp_pkey_asn1_method_st
EVP_PKEY_ASN1_METHOD
;
415
typedef
struct
evp_pkey_ctx_st
EVP_PKEY_CTX
;
416
typedef
struct
evp_pkey_method_st
EVP_PKEY_METHOD
;
417
typedef
struct
evp_pkey_st
EVP_PKEY
;
418
typedef
struct
hmac_ctx_st
HMAC_CTX
;
419
typedef
struct
md4_state_st
MD4_CTX
;
420
typedef
struct
md5_state_st
MD5_CTX
;
421
typedef
struct
ossl_init_settings_st
OPENSSL_INIT_SETTINGS
;
422
typedef
struct
pkcs12_st
PKCS12
;
423
typedef
struct
pkcs8_priv_key_info_st
PKCS8_PRIV_KEY_INFO
;
424
typedef
struct
private_key_st
X509_PKEY
;
425
typedef
struct
rand_meth_st
RAND_METHOD
;
426
typedef
struct
rc4_key_st
RC4_KEY
;
427
typedef
struct
rsa_meth_st
RSA_METHOD
;
428
typedef
struct
rsa_pss_params_st
RSA_PSS_PARAMS
;
429
typedef
struct
rsa_st
RSA
;
430
typedef
struct
sha256_state_st
SHA256_CTX
;
431
typedef
struct
sha512_state_st
SHA512_CTX
;
432
typedef
struct
sha_state_st
SHA_CTX
;
433
typedef
struct
spake2_ctx_st
SPAKE2_CTX
;
434
typedef
struct
srtp_protection_profile_st
SRTP_PROTECTION_PROFILE
;
435
typedef
struct
ssl_cipher_st
SSL_CIPHER
;
436
typedef
struct
ssl_ctx_st
SSL_CTX
;
437
typedef
struct
ssl_early_callback_ctx
SSL_CLIENT_HELLO
;
438
typedef
struct
ssl_ech_keys_st
SSL_ECH_KEYS
;
439
typedef
struct
ssl_method_st
SSL_METHOD
;
440
typedef
struct
ssl_private_key_method_st
SSL_PRIVATE_KEY_METHOD
;
441
typedef
struct
ssl_quic_method_st
SSL_QUIC_METHOD
;
442
typedef
struct
ssl_session_st
SSL_SESSION
;
443
typedef
struct
ssl_st
SSL
;
444
typedef
struct
ssl_ticket_aead_method_st
SSL_TICKET_AEAD_METHOD
;
445
typedef
struct
st_ERR_FNS
ERR_FNS
;
446
typedef
struct
trust_token_st
TRUST_TOKEN
;
447
typedef
struct
trust_token_client_st
TRUST_TOKEN_CLIENT
;
448
typedef
struct
trust_token_issuer_st
TRUST_TOKEN_ISSUER
;
449
typedef
struct
trust_token_method_st
TRUST_TOKEN_METHOD
;
450
typedef
struct
v3_ext_ctx
X509V3_CTX
;
451
typedef
struct
x509_attributes_st
X509_ATTRIBUTE
;
452
typedef
struct
x509_cert_aux_st
X509_CERT_AUX
;
453
typedef
struct
x509_crl_method_st
X509_CRL_METHOD
;
454
typedef
struct
x509_lookup_st
X509_LOOKUP
;
455
typedef
struct
x509_lookup_method_st
X509_LOOKUP_METHOD
;
456
typedef
struct
x509_object_st
X509_OBJECT
;
457
typedef
struct
x509_revoked_st
X509_REVOKED
;
458
typedef
struct
x509_st
X509
;
459
typedef
struct
x509_store_ctx_st
X509_STORE_CTX
;
460
typedef
struct
x509_store_st
X509_STORE
;
461
typedef
struct
x509_trust_st
X509_TRUST
;
463
typedef
void
*
OPENSSL_BLOCK
;
466
#
if
defined(
__cplusplus
)
467}
// extern C
468
#
elif
!defined(BORINGSSL_NO_CXX)
469
#define BORINGSSL_NO_CXX
470
#
endif
472
#
if
defined(
BORINGSSL_PREFIX
)
473
#define BSSL_NAMESPACE_BEGIN \
474
namespace bssl { \
475
inline namespace BORINGSSL_PREFIX {
476
#define BSSL_NAMESPACE_END \
477
} \
478
}
479
#
else
480
#define
BSSL_NAMESPACE_BEGIN
namespace
bssl
{
481
#define
BSSL_NAMESPACE_END
}
482
#
endif
484
// MSVC doesn't set __cplusplus to 201103 to indicate C++11 support (see
485
//
https://connect.microsoft.com/VisualStudio/feedback/details/763051/a-value-of-predefined-macro-cplusplus-is-still-199711l
)
486
// so MSVC is just assumed to support C++11.
487
#
if
!defined(
BORINGSSL_NO_CXX
) &&
__cplusplus
< 201103L && !defined(
_MSC_VER
)
488
#define BORINGSSL_NO_CXX
489
#
endif
491
#
if
!defined(
BORINGSSL_NO_CXX
)
493
extern
"C++"
{
495
#include
<memory>
497
// STLPort, used by some Android consumers, not have std::unique_ptr.
498
#
if
defined(
_STLPORT_VERSION
)
499
#define BORINGSSL_NO_CXX
500
#
endif
502}
// extern C++
503
#
endif
// !BORINGSSL_NO_CXX
505
#
if
defined(
BORINGSSL_NO_CXX
)
507
#define BORINGSSL_MAKE_DELETER(type, deleter)
508
#define BORINGSSL_MAKE_UP_REF(type, up_ref_func)
510
#
else
512
extern
"C++"
{
514
BSSL_NAMESPACE_BEGIN
516
namespace
internal
{
518
// The Enable parameter is ignored and only exists so specializations can use
519
// SFINAE.
520
template
<
typename
T,
typename
Enable =
void
>
521
struct
DeleterImpl
{};
523
template
<
typename
T>
524
struct
Deleter
{
525
void
operator
()
(T *
ptr
) {
526
// Rather than specialize Deleter for each type, we specialize
527
// DeleterImpl. This allows bssl::UniquePtr<T> to be used while only
528
// including base.h as long as the destructor is not emitted. This matches
529
// std::unique_ptr's behavior on forward-declared types.
530
//
531
// DeleterImpl itself is specialized in the corresponding module's header
532
// and must be included to release an object. If not included, the compiler
533
// will error that DeleterImpl<T> does not have a method Free.
534
DeleterImpl
<T>::Free(
ptr
);
535 }
536};
538
template
<
typename
T,
typename
CleanupRet,
void
(*init)(T *),
539 CleanupRet (*cleanup)(T *)>
540
class
StackAllocated
{
541
public
:
542
StackAllocated
() {
init
(&
ctx_
); }
543
~StackAllocated
() {
cleanup
(&
ctx_
); }
545
StackAllocated
(
const
StackAllocated &) =
delete
;
546 StackAllocated&
operator
=
(
const
StackAllocated &) =
delete
;
548 T *
get
() {
return
&
ctx_
; }
549
const
T *
get
()
const
{
return
&
ctx_
; }
551 T *
operator
->
() {
return
&
ctx_
; }
552
const
T *
operator
->
()
const
{
return
&
ctx_
; }
554
void
Reset
() {
555
cleanup
(&
ctx_
);
556
init
(&
ctx_
);
557 }
559
private
:
560 T
ctx_
;
561};
563
template
<
typename
T,
typename
CleanupRet,
void
(*init)(T *),
564 CleanupRet (*cleanup)(T *),
void
(*move)(T *, T *)>
565
class
StackAllocatedMovable
{
566
public
:
567
StackAllocatedMovable
() {
init
(&
ctx_
); }
568
~StackAllocatedMovable
() {
cleanup
(&
ctx_
); }
570
StackAllocatedMovable
(StackAllocatedMovable &&
other
) {
571
init
(&
ctx_
);
572
move
(&
ctx_
, &
other
.ctx_);
573 }
574 StackAllocatedMovable &
operator
=
(StackAllocatedMovable &&
other
) {
575
move
(&
ctx_
, &
other
.ctx_);
576
return
*
this
;
577 }
579 T *
get
() {
return
&
ctx_
; }
580
const
T *
get
()
const
{
return
&
ctx_
; }
582 T *
operator
->
() {
return
&
ctx_
; }
583
const
T *
operator
->
()
const
{
return
&
ctx_
; }
585
void
Reset
() {
586
cleanup
(&
ctx_
);
587
init
(&
ctx_
);
588 }
590
private
:
591 T
ctx_
;
592};
594}
// namespace internal
596
#define
BORINGSSL_MAKE_DELETER
(type, deleter) \
597
namespace internal { \
598
template <> \
599
struct DeleterImpl<type> { \
600
static void Free(type *ptr) { deleter(ptr); } \
601
}; \
602
}
604
// Holds ownership of heap-allocated BoringSSL structures. Sample usage:
605
// bssl::UniquePtr<RSA> rsa(RSA_new());
606
// bssl::UniquePtr<BIO> bio(BIO_new(BIO_s_mem()));
607
template
<
typename
T>
608
using
UniquePtr
=
std::
unique_ptr
<T,
internal::
Deleter
<T>>;
610
#define
BORINGSSL_MAKE_UP_REF
(type, up_ref_func) \
611
inline UniquePtr<type> UpRef(type *v) { \
612
if (v != nullptr) { \
613
up_ref_func(v); \
614
} \
615
return UniquePtr<type>(v); \
616
} \
617
\
618
inline UniquePtr<type> UpRef(const UniquePtr<type> &ptr) { \
619
return UpRef(ptr.get()); \
620
}
622
BSSL_NAMESPACE_END
624}
// extern C++
626
#
endif
// !BORINGSSL_NO_CXX