All headers

Memory and string functions, see also buf.h.

BoringSSL has its own set of allocation functions, which keep track of allocation lengths and zero them out before freeing. All memory returned by BoringSSL API calls must therefore generally be freed using OPENSSL_free unless stated otherwise.

  1. OPENSSL_malloc
  2. OPENSSL_free
  3. OPENSSL_realloc
  4. OPENSSL_cleanse
  5. CRYPTO_memcmp
  6. OPENSSL_hash32
  7. OPENSSL_strhash
  8. OPENSSL_strdup
  9. OPENSSL_strnlen
  10. OPENSSL_tolower
  11. OPENSSL_strcasecmp
  12. OPENSSL_strncasecmp
  14. BIO_snprintf
  16. BIO_vsnprintf
  17. OPENSSL_strndup
  18. OPENSSL_memdup
  19. OPENSSL_strlcpy
  20. OPENSSL_strlcat
  21. Deprecated functions
  22. CRYPTO_malloc
  23. CRYPTO_realloc
  24. CRYPTO_free
  25. OPENSSL_clear_free
  26. CRYPTO_secure_malloc_init
  27. CRYPTO_secure_malloc_initialized
  28. CRYPTO_secure_used
  29. OPENSSL_secure_malloc
  30. OPENSSL_secure_clear_free

OPENSSL_malloc acts like a regular malloc.

OPENSSL_EXPORT void *OPENSSL_malloc(size_t size);

OPENSSL_free does nothing if ptr is NULL. Otherwise it zeros out the memory allocated at ptr and frees it.

OPENSSL_EXPORT void OPENSSL_free(void *ptr);

OPENSSL_realloc returns a pointer to a buffer of new_size bytes that contains the contents of ptr. Unlike realloc, a new buffer is always allocated and the data at ptr is always wiped and freed.

OPENSSL_EXPORT void *OPENSSL_realloc(void *ptr, size_t new_size);

OPENSSL_cleanse zeros out len bytes of memory at ptr. This is similar to memset_s from C11.

OPENSSL_EXPORT void OPENSSL_cleanse(void *ptr, size_t len);

CRYPTO_memcmp returns zero iff the len bytes at a and b are equal. It takes an amount of time dependent on len, but independent of the contents of a and b. Unlike memcmp, it cannot be used to put elements into a defined order as the return value when a != b is undefined, other than to be non-zero.

OPENSSL_EXPORT int CRYPTO_memcmp(const void *a, const void *b, size_t len);

OPENSSL_hash32 implements the 32 bit, FNV-1a hash.

OPENSSL_EXPORT uint32_t OPENSSL_hash32(const void *ptr, size_t len);

OPENSSL_strhash calls OPENSSL_hash32 on the NUL-terminated string s.

OPENSSL_EXPORT uint32_t OPENSSL_strhash(const char *s);

OPENSSL_strdup has the same behaviour as strdup(3).

OPENSSL_EXPORT char *OPENSSL_strdup(const char *s);

OPENSSL_strnlen has the same behaviour as strnlen(3).

OPENSSL_EXPORT size_t OPENSSL_strnlen(const char *s, size_t len);

OPENSSL_tolower is a locale-independent version of tolower(3).

OPENSSL_EXPORT int OPENSSL_tolower(int c);

OPENSSL_strcasecmp is a locale-independent version of strcasecmp(3).

OPENSSL_EXPORT int OPENSSL_strcasecmp(const char *a, const char *b);

OPENSSL_strncasecmp is a locale-independent version of strncasecmp(3).

OPENSSL_EXPORT int OPENSSL_strncasecmp(const char *a, const char *b, size_t n);

DECIMAL_SIZE returns an upper bound for the length of the decimal representation of the given type.

#define DECIMAL_SIZE(type)	((sizeof(type)*8+2)/3+1)

BIO_snprintf has the same behavior as snprintf(3).

OPENSSL_EXPORT int BIO_snprintf(char *buf, size_t n, const char *format, ...)

BIO_vsnprintf has the same behavior as vsnprintf(3).

OPENSSL_EXPORT int BIO_vsnprintf(char *buf, size_t n, const char *format,
                                 va_list args) OPENSSL_PRINTF_FORMAT_FUNC(3, 0);

OPENSSL_strndup returns an allocated, duplicate of str, which is, at most, size bytes. The result is always NUL terminated.

OPENSSL_EXPORT char *OPENSSL_strndup(const char *str, size_t size);

OPENSSL_memdup returns an allocated, duplicate of size bytes from data or NULL on allocation failure.

OPENSSL_EXPORT void *OPENSSL_memdup(const void *data, size_t size);

OPENSSL_strlcpy acts like strlcpy(3).

OPENSSL_EXPORT size_t OPENSSL_strlcpy(char *dst, const char *src,
                                      size_t dst_size);

OPENSSL_strlcat acts like strlcat(3).

OPENSSL_EXPORT size_t OPENSSL_strlcat(char *dst, const char *src,
                                      size_t dst_size);

Deprecated functions.

CRYPTO_malloc calls OPENSSL_malloc. file and line are ignored.

OPENSSL_EXPORT void *CRYPTO_malloc(size_t size, const char *file, int line);

CRYPTO_realloc calls OPENSSL_realloc. file and line are ignored.

OPENSSL_EXPORT void *CRYPTO_realloc(void *ptr, size_t new_size,
                                    const char *file, int line);

CRYPTO_free calls OPENSSL_free. file and line are ignored.

OPENSSL_EXPORT void CRYPTO_free(void *ptr, const char *file, int line);

OPENSSL_clear_free calls OPENSSL_free. BoringSSL automatically clears all allocations on free, but we define OPENSSL_clear_free for compatibility.

OPENSSL_EXPORT void OPENSSL_clear_free(void *ptr, size_t len);

CRYPTO_secure_malloc_init returns zero.

OPENSSL_EXPORT int CRYPTO_secure_malloc_init(size_t size, size_t min_size);

CRYPTO_secure_malloc_initialized returns zero.

OPENSSL_EXPORT int CRYPTO_secure_malloc_initialized(void);

CRYPTO_secure_used returns zero.

OPENSSL_EXPORT size_t CRYPTO_secure_used(void);

OPENSSL_secure_malloc calls OPENSSL_malloc.

OPENSSL_EXPORT void *OPENSSL_secure_malloc(size_t size);

OPENSSL_secure_clear_free calls OPENSSL_clear_free.

OPENSSL_EXPORT void OPENSSL_secure_clear_free(void *ptr, size_t len);