/* ==================================================================== * Copyright (c) 1998-2001 The OpenSSL Project. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * 3. All advertising materials mentioning features or use of this * software must display the following acknowledgment: * "This product includes software developed by the OpenSSL Project * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" * * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to * endorse or promote products derived from this software without * prior written permission. For written permission, please contact * [email protected]. * * 5. Products derived from this software may not be called "OpenSSL" * nor may "OpenSSL" appear in their names without prior written * permission of the OpenSSL Project. * * 6. Redistributions of any form whatsoever must retain the following * acknowledgment: * "This product includes software developed by the OpenSSL Project * for use in the OpenSSL Toolkit (http://www.openssl.org/)" * * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. * ==================================================================== * * This product includes cryptographic software written by Eric Young * ([email protected]). This product includes software written by Tim * Hudson ([email protected]). */ #ifndef OPENSSL_HEADER_BASE_H #define OPENSSL_HEADER_BASE_H // This file should be the first included by all BoringSSL headers. #include <stddef.h> #include <stdint.h> #include <stdlib.h> #include <sys/types.h> #if defined(__MINGW32__) // stdio.h is needed on MinGW for __MINGW_PRINTF_FORMAT. #include <stdio.h> #endif #if defined(__APPLE__) #include <TargetConditionals.h> #endif // Include a BoringSSL-only header so consumers including this header without // setting up include paths do not accidentally pick up the system // opensslconf.h. #include <openssl/is_boringssl.h> #include <openssl/opensslconf.h> #include <openssl/target.h> // IWYU pragma: export #if defined(BORINGSSL_PREFIX) #include <boringssl_prefix_symbols.h> #endif #if defined(__cplusplus) extern "C" { #endif #if defined(__APPLE__) // Note |TARGET_OS_MAC| is set for all Apple OS variants. |TARGET_OS_OSX| // targets macOS specifically. #if defined(TARGET_OS_OSX) && TARGET_OS_OSX #define OPENSSL_MACOS #endif #if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE #define OPENSSL_IOS #endif #endif #define OPENSSL_IS_BORINGSSL #define OPENSSL_VERSION_NUMBER … #define SSLEAY_VERSION_NUMBER … // BORINGSSL_API_VERSION is a positive integer that increments as BoringSSL // changes over time. The value itself is not meaningful. It will be incremented // whenever is convenient to coordinate an API change with consumers. This will // not denote any special point in development. // // A consumer may use this symbol in the preprocessor to temporarily build // against multiple revisions of BoringSSL at the same time. It is not // recommended to do so for longer than is necessary. #define BORINGSSL_API_VERSION … #if defined(BORINGSSL_SHARED_LIBRARY) #if defined(OPENSSL_WINDOWS) #if defined(BORINGSSL_IMPLEMENTATION) #define OPENSSL_EXPORT … #else #define OPENSSL_EXPORT … #endif #else // defined(OPENSSL_WINDOWS) #if defined(BORINGSSL_IMPLEMENTATION) #define OPENSSL_EXPORT … #else #define OPENSSL_EXPORT #endif #endif // defined(OPENSSL_WINDOWS) #else // defined(BORINGSSL_SHARED_LIBRARY) #define OPENSSL_EXPORT #endif // defined(BORINGSSL_SHARED_LIBRARY) #if defined(_MSC_VER) // OPENSSL_DEPRECATED is used to mark a function as deprecated. Use // of any functions so marked in caller code will produce a warning. // OPENSSL_BEGIN_ALLOW_DEPRECATED and OPENSSL_END_ALLOW_DEPRECATED // can be used to suppress the warning in regions of caller code. #define OPENSSL_DEPRECATED … #define OPENSSL_BEGIN_ALLOW_DEPRECATED … #define OPENSSL_END_ALLOW_DEPRECATED … #elif defined(__GNUC__) || defined(__clang__) #define OPENSSL_DEPRECATED … #define OPENSSL_BEGIN_ALLOW_DEPRECATED … #define OPENSSL_END_ALLOW_DEPRECATED … #else #define OPENSSL_DEPRECATED #define OPENSSL_BEGIN_ALLOW_DEPRECATED #define OPENSSL_END_ALLOW_DEPRECATED #endif #if defined(__GNUC__) || defined(__clang__) // MinGW has two different printf implementations. Ensure the format macro // matches the selected implementation. See // https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/. #if defined(__MINGW_PRINTF_FORMAT) #define OPENSSL_PRINTF_FORMAT_FUNC … #else #define OPENSSL_PRINTF_FORMAT_FUNC(string_index, first_to_check) … #endif #else #define OPENSSL_PRINTF_FORMAT_FUNC … #endif // OPENSSL_CLANG_PRAGMA emits a pragma on clang and nothing on other compilers. #if defined(__clang__) #define OPENSSL_CLANG_PRAGMA(arg) … #else #define OPENSSL_CLANG_PRAGMA … #endif // OPENSSL_MSVC_PRAGMA emits a pragma on MSVC and nothing on other compilers. #if defined(_MSC_VER) #define OPENSSL_MSVC_PRAGMA … #else #define OPENSSL_MSVC_PRAGMA(arg) … #endif #if defined(__GNUC__) || defined(__clang__) #define OPENSSL_UNUSED … #else #define OPENSSL_UNUSED #endif // C and C++ handle inline functions differently. In C++, an inline function is // defined in just the header file, potentially emitted in multiple compilation // units (in cases the compiler did not inline), but each copy must be identical // to satsify ODR. In C, a non-static inline must be manually emitted in exactly // one compilation unit with a separate extern inline declaration. // // In both languages, exported inline functions referencing file-local symbols // are problematic. C forbids this altogether (though GCC and Clang seem not to // enforce it). It works in C++, but ODR requires the definitions be identical, // including all names in the definitions resolving to the "same entity". In // practice, this is unlikely to be a problem, but an inline function that // returns a pointer to a file-local symbol // could compile oddly. // // Historically, we used static inline in headers. However, to satisfy ODR, use // plain inline in C++, to allow inline consumer functions to call our header // functions. Plain inline would also work better with C99 inline, but that is // not used much in practice, extern inline is tedious, and there are conflicts // with the old gnu89 model: // https://stackoverflow.com/questions/216510/extern-inline #if defined(__cplusplus) #define OPENSSL_INLINE … #else // Add OPENSSL_UNUSED so that, should an inline function be emitted via macro // (e.g. a |STACK_OF(T)| implementation) in a source file without tripping // clang's -Wunused-function. #define OPENSSL_INLINE … #endif #if defined(__cplusplus) // enums can be predeclared, but only in C++ and only if given an explicit type. // C doesn't support setting an explicit type for enums thus a #define is used // to do this only for C++. However, the ABI type between C and C++ need to have // equal sizes, which is confirmed in a unittest. #define BORINGSSL_ENUM_INT … enum ssl_early_data_reason_t BORINGSSL_ENUM_INT; enum ssl_encryption_level_t BORINGSSL_ENUM_INT; enum ssl_private_key_result_t BORINGSSL_ENUM_INT; enum ssl_renegotiate_mode_t BORINGSSL_ENUM_INT; enum ssl_select_cert_result_t BORINGSSL_ENUM_INT; enum ssl_select_cert_result_t BORINGSSL_ENUM_INT; enum ssl_ticket_aead_result_t BORINGSSL_ENUM_INT; enum ssl_verify_result_t BORINGSSL_ENUM_INT; #else #define BORINGSSL_ENUM_INT #endif // ossl_ssize_t is a signed type which is large enough to fit the size of any // valid memory allocation. We prefer using |size_t|, but sometimes we need a // signed type for OpenSSL API compatibility. This type can be used in such // cases to avoid overflow. // // Not all |size_t| values fit in |ossl_ssize_t|, but all |size_t| values that // are sizes of or indices into C objects, can be converted without overflow. ossl_ssize_t; // CBS_ASN1_TAG is the type used by |CBS| and |CBB| for ASN.1 tags. See that // header for details. This type is defined in base.h as a forward declaration. CBS_ASN1_TAG; // CRYPTO_THREADID is a dummy value. CRYPTO_THREADID; // An |ASN1_NULL| is an opaque type. asn1.h represents the ASN.1 NULL value as // an opaque, non-NULL |ASN1_NULL*| pointer. ASN1_NULL; ASN1_BOOLEAN; ASN1_ITEM; ASN1_OBJECT; ASN1_PCTX; ASN1_BIT_STRING; ASN1_BMPSTRING; ASN1_ENUMERATED; ASN1_GENERALIZEDTIME; ASN1_GENERALSTRING; ASN1_IA5STRING; ASN1_INTEGER; ASN1_OCTET_STRING; ASN1_PRINTABLESTRING; ASN1_STRING; ASN1_T61STRING; ASN1_TIME; ASN1_UNIVERSALSTRING; ASN1_UTCTIME; ASN1_UTF8STRING; ASN1_VISIBLESTRING; ASN1_TYPE; AUTHORITY_KEYID; BASIC_CONSTRAINTS; DIST_POINT; DSA_SIG; GENERAL_NAME; ISSUING_DIST_POINT; NAME_CONSTRAINTS; NETSCAPE_SPKAC; NETSCAPE_SPKI; RIPEMD160_CTX; X509_VERIFY_PARAM; X509_ALGOR; X509_CRL; X509_EXTENSION; X509_INFO; X509_NAME_ENTRY; X509_NAME; X509_PUBKEY; X509_REQ; X509_SIG; BN_CTX; BIGNUM; BIO_METHOD; BIO; BLAKE2B_CTX; BN_GENCB; BN_MONT_CTX; BUF_MEM; CBB; CBS; CMAC_CTX; CONF; CONF_VALUE; CRYPTO_BUFFER_POOL; CRYPTO_BUFFER; CTR_DRBG_STATE; DH; DSA; EC_GROUP; EC_KEY; EC_POINT; ECDSA_METHOD; ECDSA_SIG; ENGINE; EVP_MD_CTX; EVP_MD; EVP_AEAD; EVP_AEAD_CTX; EVP_CIPHER_CTX; EVP_CIPHER; EVP_ENCODE_CTX; EVP_HPKE_AEAD; EVP_HPKE_CTX; EVP_HPKE_KDF; EVP_HPKE_KEM; EVP_HPKE_KEY; EVP_PKEY_CTX; EVP_PKEY; HMAC_CTX; MD4_CTX; MD5_CTX; OPENSSL_INIT_SETTINGS; PKCS12; PKCS8_PRIV_KEY_INFO; X509_PKEY; RAND_METHOD; RC4_KEY; RSA_METHOD; RSA_PSS_PARAMS; RSA; SHA256_CTX; SHA512_CTX; SHA_CTX; SPAKE2_CTX; SRTP_PROTECTION_PROFILE; SSL_CIPHER; SSL_CREDENTIAL; SSL_CTX; SSL_CLIENT_HELLO; SSL_ECH_KEYS; SSL_METHOD; SSL_PRIVATE_KEY_METHOD; SSL_QUIC_METHOD; SSL_SESSION; SSL; SSL_TICKET_AEAD_METHOD; ERR_FNS; TRUST_TOKEN; TRUST_TOKEN_CLIENT; TRUST_TOKEN_ISSUER; TRUST_TOKEN_METHOD; X509V3_CTX; X509V3_EXT_METHOD; X509_ATTRIBUTE; X509_LOOKUP; X509_LOOKUP_METHOD; X509_OBJECT; X509_PURPOSE; X509_REVOKED; X509; X509_STORE_CTX; X509_STORE; OPENSSL_BLOCK; // BSSL_CHECK aborts if |condition| is not true. #define BSSL_CHECK(condition) … #if defined(__cplusplus) } // extern C #elif !defined(BORINGSSL_NO_CXX) #define BORINGSSL_NO_CXX #endif #if defined(BORINGSSL_PREFIX) #define BSSL_NAMESPACE_BEGIN … #define BSSL_NAMESPACE_END … #else #define BSSL_NAMESPACE_BEGIN … #define BSSL_NAMESPACE_END … #endif // MSVC doesn't set __cplusplus to 201103 to indicate C++11 support (see // https://connect.microsoft.com/VisualStudio/feedback/details/763051/a-value-of-predefined-macro-cplusplus-is-still-199711l) // so MSVC is just assumed to support C++11. #if !defined(BORINGSSL_NO_CXX) && __cplusplus < 201103L && !defined(_MSC_VER) #define BORINGSSL_NO_CXX #endif #if !defined(BORINGSSL_NO_CXX) extern "C++" { #include <memory> // STLPort, used by some Android consumers, not have std::unique_ptr. #if defined(_STLPORT_VERSION) #define BORINGSSL_NO_CXX #endif } // extern C++ #endif // !BORINGSSL_NO_CXX #if defined(BORINGSSL_NO_CXX) #define BORINGSSL_MAKE_DELETER … #define BORINGSSL_MAKE_UP_REF … #else extern "C++" { BSSL_NAMESPACE_BEGIN namespace internal { // The Enable parameter is ignored and only exists so specializations can use // SFINAE. template <typename T, typename Enable = void> struct DeleterImpl { … }; struct Deleter { … }; template <typename T, typename CleanupRet, void (*init)(T *), CleanupRet (*cleanup)(T *)> class StackAllocated { … }; template <typename T, typename CleanupRet, void (*init)(T *), CleanupRet (*cleanup)(T *), void (*move)(T *, T *)> class StackAllocatedMovable { … }; } // namespace internal #define BORINGSSL_MAKE_DELETER(type, deleter) … // Holds ownership of heap-allocated BoringSSL structures. Sample usage: // bssl::UniquePtr<RSA> rsa(RSA_new()); // bssl::UniquePtr<BIO> bio(BIO_new(BIO_s_mem())); UniquePtr; #define BORINGSSL_MAKE_UP_REF(type, up_ref_func) … BSSL_NAMESPACE_END } // extern C++ #endif // !BORINGSSL_NO_CXX #endif // OPENSSL_HEADER_BASE_H
Codebase Browser
chromium