1/*
2 * WARNING: do not edit!
3 * Generated by Makefile from include/openssl/crypto.h.in
4 *
5 * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
6 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
7 *
8 * Licensed under the Apache License 2.0 (the "License"). You may not use
9 * this file except in compliance with the License. You can obtain a copy
10 * in the file LICENSE in the source distribution or at
11 * https://www.openssl.org/source/license.html
12 */
13
14/* clang-format off */
15
16/* clang-format on */
17
18#ifndef OPENSSL_CRYPTO_H
19#define OPENSSL_CRYPTO_H
20#pragma once
21
22#include <openssl/macros.h>
23#ifndef OPENSSL_NO_DEPRECATED_3_0
24#define HEADER_CRYPTO_H
25#endif
26
27#include <stdlib.h>
28#include <time.h>
29
30#include <openssl/e_os2.h>
31
32#ifndef OPENSSL_NO_STDIO
33#include <stdio.h>
34#endif
35
36#include <openssl/safestack.h>
37#include <openssl/opensslv.h>
38#include <openssl/types.h>
39#include <openssl/opensslconf.h>
40#include <openssl/cryptoerr.h>
41#include <openssl/core.h>
42
43#ifdef CHARSET_EBCDIC
44#include <openssl/ebcdic.h>
45#endif
46
47/*
48 * Resolve problems on some operating systems with symbol names that clash
49 * one way or another
50 */
51#include <openssl/symhacks.h>
52
53#ifndef OPENSSL_NO_DEPRECATED_1_1_0
54#include <openssl/opensslv.h>
55#endif
56
57#ifdef __cplusplus
58extern "C" {
59#endif
60
61#ifndef OPENSSL_NO_DEPRECATED_1_1_0
62#define SSLeay OpenSSL_version_num
63#define SSLeay_version OpenSSL_version
64#define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER
65#define SSLEAY_VERSION OPENSSL_VERSION
66#define SSLEAY_CFLAGS OPENSSL_CFLAGS
67#define SSLEAY_BUILT_ON OPENSSL_BUILT_ON
68#define SSLEAY_PLATFORM OPENSSL_PLATFORM
69#define SSLEAY_DIR OPENSSL_DIR
70
71/*
72 * Old type for allocating dynamic locks. No longer used. Use the new thread
73 * API instead.
74 */
75typedef struct {
76 int dummy;
77} CRYPTO_dynlock;
78
79#endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
80
81typedef void CRYPTO_RWLOCK;
82
83CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void);
84__owur int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock);
85__owur int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock);
86int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock);
87void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock);
88
89int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock);
90int CRYPTO_atomic_add64(uint64_t *val, uint64_t op, uint64_t *ret,
91 CRYPTO_RWLOCK *lock);
92int CRYPTO_atomic_and(uint64_t *val, uint64_t op, uint64_t *ret,
93 CRYPTO_RWLOCK *lock);
94int CRYPTO_atomic_or(uint64_t *val, uint64_t op, uint64_t *ret,
95 CRYPTO_RWLOCK *lock);
96int CRYPTO_atomic_load(uint64_t *val, uint64_t *ret, CRYPTO_RWLOCK *lock);
97int CRYPTO_atomic_load_int(int *val, int *ret, CRYPTO_RWLOCK *lock);
98int CRYPTO_atomic_store(uint64_t *dst, uint64_t val, CRYPTO_RWLOCK *lock);
99
100/* No longer needed, so this is a no-op */
101#define OPENSSL_malloc_init() \
102 while (0) \
103 continue
104
105#define OPENSSL_malloc(num) \
106 CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
107#define OPENSSL_zalloc(num) \
108 CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
109#define OPENSSL_malloc_array(num, size) \
110 CRYPTO_malloc_array(num, size, OPENSSL_FILE, OPENSSL_LINE)
111#define OPENSSL_calloc(num, size) \
112 CRYPTO_calloc(num, size, OPENSSL_FILE, OPENSSL_LINE)
113#define OPENSSL_aligned_alloc(num, alignment, freeptr) \
114 CRYPTO_aligned_alloc(num, alignment, freeptr, \
115 OPENSSL_FILE, OPENSSL_LINE)
116#define OPENSSL_aligned_alloc_array(num, size, alignment, freeptr) \
117 CRYPTO_aligned_alloc_array(num, size, alignment, freeptr, \
118 OPENSSL_FILE, OPENSSL_LINE)
119#define OPENSSL_realloc(addr, num) \
120 CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE)
121#define OPENSSL_clear_realloc(addr, old_num, num) \
122 CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE)
123#define OPENSSL_realloc_array(addr, num, size) \
124 CRYPTO_realloc_array(addr, num, size, OPENSSL_FILE, OPENSSL_LINE)
125#define OPENSSL_clear_realloc_array(addr, old_num, num, size) \
126 CRYPTO_clear_realloc_array(addr, old_num, num, size, \
127 OPENSSL_FILE, OPENSSL_LINE)
128#define OPENSSL_clear_free(addr, num) \
129 CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
130#define OPENSSL_free(addr) \
131 CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE)
132#define OPENSSL_memdup(str, s) \
133 CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE)
134#define OPENSSL_strdup(str) \
135 CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE)
136#define OPENSSL_strndup(str, n) \
137 CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE)
138#define OPENSSL_secure_malloc(num) \
139 CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE)
140#define OPENSSL_secure_zalloc(num) \
141 CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE)
142#define OPENSSL_secure_malloc_array(num, size) \
143 CRYPTO_secure_malloc_array(num, size, OPENSSL_FILE, OPENSSL_LINE)
144#define OPENSSL_secure_calloc(num, size) \
145 CRYPTO_secure_calloc(num, size, OPENSSL_FILE, OPENSSL_LINE)
146#define OPENSSL_secure_free(addr) \
147 CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE)
148#define OPENSSL_secure_clear_free(addr, num) \
149 CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE)
150#define OPENSSL_secure_actual_size(ptr) \
151 CRYPTO_secure_actual_size(ptr)
152
153size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz);
154size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz);
155size_t OPENSSL_strnlen(const char *str, size_t maxlen);
156int OPENSSL_strtoul(const char *str, char **endptr, int base, unsigned long *num);
157int OPENSSL_buf2hexstr_ex(char *str, size_t str_n, size_t *strlength,
158 const unsigned char *buf, size_t buflen,
159 const char sep);
160char *OPENSSL_buf2hexstr(const unsigned char *buf, long buflen);
161int OPENSSL_hexstr2buf_ex(unsigned char *buf, size_t buf_n, size_t *buflen,
162 const char *str, const char sep);
163unsigned char *OPENSSL_hexstr2buf(const char *str, long *buflen);
164int OPENSSL_hexchar2int(unsigned char c);
165int OPENSSL_strcasecmp(const char *s1, const char *s2);
166int OPENSSL_strncasecmp(const char *s1, const char *s2, size_t n);
167
168#define OPENSSL_MALLOC_MAX_NELEMS(type) (((1U << (sizeof(int) * 8 - 1)) - 1) / sizeof(type))
169
170/*
171 * These functions return the values of OPENSSL_VERSION_MAJOR,
172 * OPENSSL_VERSION_MINOR, OPENSSL_VERSION_PATCH, OPENSSL_VERSION_PRE_RELEASE
173 * and OPENSSL_VERSION_BUILD_METADATA, respectively.
174 */
175unsigned int OPENSSL_version_major(void);
176unsigned int OPENSSL_version_minor(void);
177unsigned int OPENSSL_version_patch(void);
178const char *OPENSSL_version_pre_release(void);
179const char *OPENSSL_version_build_metadata(void);
180
181unsigned long OpenSSL_version_num(void);
182const char *OpenSSL_version(int type);
183#define OPENSSL_VERSION 0
184#define OPENSSL_CFLAGS 1
185#define OPENSSL_BUILT_ON 2
186#define OPENSSL_PLATFORM 3
187#define OPENSSL_DIR 4
188#define OPENSSL_ENGINES_DIR 5
189#define OPENSSL_VERSION_STRING 6
190#define OPENSSL_FULL_VERSION_STRING 7
191#define OPENSSL_MODULES_DIR 8
192#define OPENSSL_CPU_INFO 9
193#define OPENSSL_WINCTX 10
194
195const char *OPENSSL_info(int type);
196/*
197 * The series starts at 1001 to avoid confusion with the OpenSSL_version
198 * types.
199 */
200#define OPENSSL_INFO_CONFIG_DIR 1001
201#define OPENSSL_INFO_ENGINES_DIR 1002
202#define OPENSSL_INFO_MODULES_DIR 1003
203#define OPENSSL_INFO_DSO_EXTENSION 1004
204#define OPENSSL_INFO_DIR_FILENAME_SEPARATOR 1005
205#define OPENSSL_INFO_LIST_SEPARATOR 1006
206#define OPENSSL_INFO_SEED_SOURCE 1007
207#define OPENSSL_INFO_CPU_SETTINGS 1008
208#define OPENSSL_INFO_WINDOWS_CONTEXT 1009
209
210int OPENSSL_issetugid(void);
211
212struct crypto_ex_data_st {
213 OSSL_LIB_CTX *ctx;
214 STACK_OF(void) *sk;
215};
216
217/* clang-format off */
218SKM_DEFINE_STACK_OF_INTERNAL(void, void, void)
219#define sk_void_num(sk) OPENSSL_sk_num(ossl_check_const_void_sk_type(sk))
220#define sk_void_value(sk, idx) ((void *)OPENSSL_sk_value(ossl_check_const_void_sk_type(sk), (idx)))
221#define sk_void_new(cmp) ((STACK_OF(void) *)OPENSSL_sk_new(ossl_check_void_compfunc_type(cmp)))
222#define sk_void_new_null() ((STACK_OF(void) *)OPENSSL_sk_new_null())
223#define sk_void_new_reserve(cmp, n) ((STACK_OF(void) *)OPENSSL_sk_new_reserve(ossl_check_void_compfunc_type(cmp), (n)))
224#define sk_void_reserve(sk, n) OPENSSL_sk_reserve(ossl_check_void_sk_type(sk), (n))
225#define sk_void_free(sk) OPENSSL_sk_free(ossl_check_void_sk_type(sk))
226#define sk_void_zero(sk) OPENSSL_sk_zero(ossl_check_void_sk_type(sk))
227#define sk_void_delete(sk, i) ((void *)OPENSSL_sk_delete(ossl_check_void_sk_type(sk), (i)))
228#define sk_void_delete_ptr(sk, ptr) ((void *)OPENSSL_sk_delete_ptr(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr)))
229#define sk_void_push(sk, ptr) OPENSSL_sk_push(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
230#define sk_void_unshift(sk, ptr) OPENSSL_sk_unshift(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
231#define sk_void_pop(sk) ((void *)OPENSSL_sk_pop(ossl_check_void_sk_type(sk)))
232#define sk_void_shift(sk) ((void *)OPENSSL_sk_shift(ossl_check_void_sk_type(sk)))
233#define sk_void_pop_free(sk, freefunc) OPENSSL_sk_pop_free(ossl_check_void_sk_type(sk), ossl_check_void_freefunc_type(freefunc))
234#define sk_void_insert(sk, ptr, idx) OPENSSL_sk_insert(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr), (idx))
235#define sk_void_set(sk, idx, ptr) ((void *)OPENSSL_sk_set(ossl_check_void_sk_type(sk), (idx), ossl_check_void_type(ptr)))
236#define sk_void_find(sk, ptr) OPENSSL_sk_find(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
237#define sk_void_find_ex(sk, ptr) OPENSSL_sk_find_ex(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr))
238#define sk_void_find_all(sk, ptr, pnum) OPENSSL_sk_find_all(ossl_check_void_sk_type(sk), ossl_check_void_type(ptr), pnum)
239#define sk_void_sort(sk) OPENSSL_sk_sort(ossl_check_void_sk_type(sk))
240#define sk_void_is_sorted(sk) OPENSSL_sk_is_sorted(ossl_check_const_void_sk_type(sk))
241#define sk_void_dup(sk) ((STACK_OF(void) *)OPENSSL_sk_dup(ossl_check_const_void_sk_type(sk)))
242#define sk_void_deep_copy(sk, copyfunc, freefunc) ((STACK_OF(void) *)OPENSSL_sk_deep_copy(ossl_check_const_void_sk_type(sk), ossl_check_void_copyfunc_type(copyfunc), ossl_check_void_freefunc_type(freefunc)))
243#define sk_void_set_cmp_func(sk, cmp) ((sk_void_compfunc)OPENSSL_sk_set_cmp_func(ossl_check_void_sk_type(sk), ossl_check_void_compfunc_type(cmp)))
244
245/* clang-format on */
246
247/*
248 * Per class, we have a STACK of function pointers.
249 */
250#define CRYPTO_EX_INDEX_SSL 0
251#define CRYPTO_EX_INDEX_SSL_CTX 1
252#define CRYPTO_EX_INDEX_SSL_SESSION 2
253#define CRYPTO_EX_INDEX_X509 3
254#define CRYPTO_EX_INDEX_X509_STORE 4
255#define CRYPTO_EX_INDEX_X509_STORE_CTX 5
256#define CRYPTO_EX_INDEX_DH 6
257#define CRYPTO_EX_INDEX_DSA 7
258#define CRYPTO_EX_INDEX_EC_KEY 8
259#define CRYPTO_EX_INDEX_RSA 9
260#define CRYPTO_EX_INDEX_ENGINE 10
261#define CRYPTO_EX_INDEX_UI 11
262#define CRYPTO_EX_INDEX_BIO 12
263#define CRYPTO_EX_INDEX_APP 13
264#define CRYPTO_EX_INDEX_UI_METHOD 14
265#define CRYPTO_EX_INDEX_RAND_DRBG 15
266#define CRYPTO_EX_INDEX_DRBG CRYPTO_EX_INDEX_RAND_DRBG
267#define CRYPTO_EX_INDEX_OSSL_LIB_CTX 16
268#define CRYPTO_EX_INDEX_EVP_PKEY 17
269#define CRYPTO_EX_INDEX__COUNT 18
270
271typedef void CRYPTO_EX_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
272 int idx, long argl, void *argp);
273typedef void CRYPTO_EX_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
274 int idx, long argl, void *argp);
275typedef int CRYPTO_EX_dup(CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
276 void **from_d, int idx, long argl, void *argp);
277__owur int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
278 CRYPTO_EX_new *new_func,
279 CRYPTO_EX_dup *dup_func,
280 CRYPTO_EX_free *free_func);
281/* No longer use an index. */
282int CRYPTO_free_ex_index(int class_index, int idx);
283
284/*
285 * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a
286 * given class (invokes whatever per-class callbacks are applicable)
287 */
288int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
289int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
290 const CRYPTO_EX_DATA *from);
291
292void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
293
294/* Allocate a single item in the CRYPTO_EX_DATA variable */
295int CRYPTO_alloc_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad,
296 int idx);
297
298/*
299 * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular
300 * index (relative to the class type involved)
301 */
302int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
303void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
304
305#ifndef OPENSSL_NO_DEPRECATED_1_1_0
306/*
307 * This function cleans up all "ex_data" state. It mustn't be called under
308 * potential race-conditions.
309 */
310#define CRYPTO_cleanup_all_ex_data() \
311 while (0) \
312 continue
313
314/*
315 * The old locking functions have been removed completely without compatibility
316 * macros. This is because the old functions either could not properly report
317 * errors, or the returned error values were not clearly documented.
318 * Replacing the locking functions with no-ops would cause race condition
319 * issues in the affected applications. It is far better for them to fail at
320 * compile time.
321 * On the other hand, the locking callbacks are no longer used. Consequently,
322 * the callback management functions can be safely replaced with no-op macros.
323 */
324#define CRYPTO_num_locks() (1)
325#define CRYPTO_set_locking_callback(func)
326#define CRYPTO_get_locking_callback() (NULL)
327#define CRYPTO_set_add_lock_callback(func)
328#define CRYPTO_get_add_lock_callback() (NULL)
329
330/*
331 * These defines where used in combination with the old locking callbacks,
332 * they are not called anymore, but old code that's not called might still
333 * use them.
334 */
335#define CRYPTO_LOCK 1
336#define CRYPTO_UNLOCK 2
337#define CRYPTO_READ 4
338#define CRYPTO_WRITE 8
339
340/* This structure is no longer used */
341typedef struct crypto_threadid_st {
342 int dummy;
343} CRYPTO_THREADID;
344/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
345#define CRYPTO_THREADID_set_numeric(id, val)
346#define CRYPTO_THREADID_set_pointer(id, ptr)
347#define CRYPTO_THREADID_set_callback(threadid_func) (0)
348#define CRYPTO_THREADID_get_callback() (NULL)
349#define CRYPTO_THREADID_current(id)
350#define CRYPTO_THREADID_cmp(a, b) (-1)
351#define CRYPTO_THREADID_cpy(dest, src)
352#define CRYPTO_THREADID_hash(id) (0UL)
353
354#ifndef OPENSSL_NO_DEPRECATED_1_0_0
355#define CRYPTO_set_id_callback(func)
356#define CRYPTO_get_id_callback() (NULL)
357#define CRYPTO_thread_id() (0UL)
358#endif /* OPENSSL_NO_DEPRECATED_1_0_0 */
359
360#define CRYPTO_set_dynlock_create_callback(dyn_create_function)
361#define CRYPTO_set_dynlock_lock_callback(dyn_lock_function)
362#define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function)
363#define CRYPTO_get_dynlock_create_callback() (NULL)
364#define CRYPTO_get_dynlock_lock_callback() (NULL)
365#define CRYPTO_get_dynlock_destroy_callback() (NULL)
366#endif /* OPENSSL_NO_DEPRECATED_1_1_0 */
367
368typedef void *(*CRYPTO_malloc_fn)(size_t num, const char *file, int line);
369typedef void *(*CRYPTO_realloc_fn)(void *addr, size_t num, const char *file,
370 int line);
371typedef void (*CRYPTO_free_fn)(void *addr, const char *file, int line);
372int CRYPTO_set_mem_functions(CRYPTO_malloc_fn malloc_fn,
373 CRYPTO_realloc_fn realloc_fn,
374 CRYPTO_free_fn free_fn);
375void CRYPTO_get_mem_functions(CRYPTO_malloc_fn *malloc_fn,
376 CRYPTO_realloc_fn *realloc_fn,
377 CRYPTO_free_fn *free_fn);
378
379OSSL_CRYPTO_ALLOC void *CRYPTO_malloc(size_t num, const char *file, int line);
380OSSL_CRYPTO_ALLOC void *CRYPTO_zalloc(size_t num, const char *file, int line);
381OSSL_CRYPTO_ALLOC void *CRYPTO_malloc_array(size_t num, size_t size,
382 const char *file, int line);
383OSSL_CRYPTO_ALLOC void *CRYPTO_calloc(size_t num, size_t size,
384 const char *file, int line);
385OSSL_CRYPTO_ALLOC void *CRYPTO_aligned_alloc(size_t num, size_t align,
386 void **freeptr, const char *file,
387 int line);
388OSSL_CRYPTO_ALLOC void *CRYPTO_aligned_alloc_array(size_t num, size_t size,
389 size_t align, void **freeptr,
390 const char *file, int line);
391void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line);
392char *CRYPTO_strdup(const char *str, const char *file, int line);
393char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line);
394void CRYPTO_free(void *ptr, const char *file, int line);
395void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line);
396void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line);
397void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num,
398 const char *file, int line);
399void *CRYPTO_realloc_array(void *addr, size_t num, size_t size,
400 const char *file, int line);
401void *CRYPTO_clear_realloc_array(void *addr, size_t old_num, size_t num,
402 size_t size, const char *file, int line);
403
404int CRYPTO_secure_malloc_init(size_t sz, size_t minsize);
405int CRYPTO_secure_malloc_done(void);
406OSSL_CRYPTO_ALLOC void *CRYPTO_secure_malloc(size_t num, const char *file, int line);
407OSSL_CRYPTO_ALLOC void *CRYPTO_secure_zalloc(size_t num, const char *file, int line);
408OSSL_CRYPTO_ALLOC void *CRYPTO_secure_malloc_array(size_t num, size_t size,
409 const char *file, int line);
410OSSL_CRYPTO_ALLOC void *CRYPTO_secure_calloc(size_t num, size_t size,
411 const char *file, int line);
412void CRYPTO_secure_free(void *ptr, const char *file, int line);
413void CRYPTO_secure_clear_free(void *ptr, size_t num,
414 const char *file, int line);
415int CRYPTO_secure_allocated(const void *ptr);
416int CRYPTO_secure_malloc_initialized(void);
417size_t CRYPTO_secure_actual_size(void *ptr);
418size_t CRYPTO_secure_used(void);
419
420void OPENSSL_cleanse(void *ptr, size_t len);
421
422#ifndef OPENSSL_NO_CRYPTO_MDEBUG
423/*
424 * The following can be used to detect memory leaks in the library. If
425 * used, it turns on malloc checking
426 */
427#define CRYPTO_MEM_CHECK_OFF 0x0 /* Control only */
428#define CRYPTO_MEM_CHECK_ON 0x1 /* Control and mode bit */
429#define CRYPTO_MEM_CHECK_ENABLE 0x2 /* Control and mode bit */
430#define CRYPTO_MEM_CHECK_DISABLE 0x3 /* Control only */
431
432/* max allowed length for value of OPENSSL_MALLOC_FAILURES env var. */
433#define CRYPTO_MEM_CHECK_MAX_FS 256
434
435void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount);
436#ifndef OPENSSL_NO_DEPRECATED_3_0
437#define OPENSSL_mem_debug_push(info) \
438 CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE)
439#define OPENSSL_mem_debug_pop() \
440 CRYPTO_mem_debug_pop()
441#endif
442#ifndef OPENSSL_NO_DEPRECATED_3_0
443OSSL_DEPRECATEDIN_3_0 int CRYPTO_set_mem_debug(int flag);
444OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_ctrl(int mode);
445OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_push(const char *info,
446 const char *file, int line);
447OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_debug_pop(void);
448OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_malloc(void *addr, size_t num,
449 int flag,
450 const char *file, int line);
451OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_realloc(void *addr1, void *addr2,
452 size_t num, int flag,
453 const char *file, int line);
454OSSL_DEPRECATEDIN_3_0 void CRYPTO_mem_debug_free(void *addr, int flag,
455 const char *file, int line);
456OSSL_DEPRECATEDIN_3_0
457int CRYPTO_mem_leaks_cb(int (*cb)(const char *str, size_t len, void *u),
458 void *u);
459#endif
460#ifndef OPENSSL_NO_STDIO
461#ifndef OPENSSL_NO_DEPRECATED_3_0
462OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks_fp(FILE *);
463#endif
464#endif
465#ifndef OPENSSL_NO_DEPRECATED_3_0
466OSSL_DEPRECATEDIN_3_0 int CRYPTO_mem_leaks(BIO *bio);
467#endif
468#endif /* OPENSSL_NO_CRYPTO_MDEBUG */
469
470/* die if we have to */
471ossl_noreturn void OPENSSL_die(const char *assertion, const char *file, int line);
472#ifndef OPENSSL_NO_DEPRECATED_1_1_0
473#define OpenSSLDie(f, l, a) OPENSSL_die((a), (f), (l))
474#endif
475#define OPENSSL_assert(e) \
476 (void)((e) ? 0 : (OPENSSL_die("assertion failed: " #e, OPENSSL_FILE, OPENSSL_LINE), 1))
477
478int OPENSSL_isservice(void);
479
480void OPENSSL_init(void);
481#ifdef OPENSSL_SYS_UNIX
482#ifndef OPENSSL_NO_DEPRECATED_3_0
483OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_prepare(void);
484OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_parent(void);
485OSSL_DEPRECATEDIN_3_0 void OPENSSL_fork_child(void);
486#endif
487#endif
488
489struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result);
490int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec);
491int OPENSSL_gmtime_diff(int *pday, int *psec,
492 const struct tm *from, const struct tm *to);
493
494/*
495 * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal.
496 * It takes an amount of time dependent on |len|, but independent of the
497 * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements
498 * into a defined order as the return value when a != b is undefined, other
499 * than to be non-zero.
500 */
501int CRYPTO_memcmp(const void *in_a, const void *in_b, size_t len);
502
503/* Standard initialisation options */
504#define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L
505#define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L
506#define OPENSSL_INIT_ADD_ALL_CIPHERS 0x00000004L
507#define OPENSSL_INIT_ADD_ALL_DIGESTS 0x00000008L
508#define OPENSSL_INIT_NO_ADD_ALL_CIPHERS 0x00000010L
509#define OPENSSL_INIT_NO_ADD_ALL_DIGESTS 0x00000020L
510#define OPENSSL_INIT_LOAD_CONFIG 0x00000040L
511#define OPENSSL_INIT_NO_LOAD_CONFIG 0x00000080L
512#define OPENSSL_INIT_ASYNC 0x00000100L
513#define OPENSSL_INIT_ENGINE_RDRAND 0x00000200L
514#define OPENSSL_INIT_ENGINE_DYNAMIC 0x00000400L
515#define OPENSSL_INIT_ENGINE_OPENSSL 0x00000800L
516#define OPENSSL_INIT_ENGINE_CRYPTODEV 0x00001000L
517#define OPENSSL_INIT_ENGINE_CAPI 0x00002000L
518#define OPENSSL_INIT_ENGINE_PADLOCK 0x00004000L
519#define OPENSSL_INIT_ENGINE_AFALG 0x00008000L
520/* FREE: 0x00010000L */
521#define OPENSSL_INIT_ATFORK 0x00020000L
522/* OPENSSL_INIT_BASE_ONLY 0x00040000L */
523#define OPENSSL_INIT_NO_ATEXIT 0x00080000L
524/* OPENSSL_INIT flag range 0x03f00000 reserved for OPENSSL_init_ssl() */
525/* FREE: 0x04000000L */
526/* FREE: 0x08000000L */
527/* FREE: 0x10000000L */
528/* FREE: 0x20000000L */
529/* FREE: 0x40000000L */
530/* FREE: 0x80000000L */
531/* Max OPENSSL_INIT flag value is 0x80000000 */
532
533/* openssl and dasync not counted as builtin */
534#define OPENSSL_INIT_ENGINE_ALL_BUILTIN \
535 (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC \
536 | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | OPENSSL_INIT_ENGINE_PADLOCK)
537
538/* Library initialisation functions */
539void OPENSSL_cleanup(void);
540int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings);
541int OPENSSL_atexit(void (*handler)(void));
542void OPENSSL_thread_stop(void);
543void OPENSSL_thread_stop_ex(OSSL_LIB_CTX *ctx);
544
545/* Low-level control of initialization */
546OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void);
547#ifndef OPENSSL_NO_STDIO
548int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings,
549 const char *config_filename);
550void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings,
551 unsigned long flags);
552int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings,
553 const char *config_appname);
554#endif
555void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings);
556
557#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
558#if defined(_WIN32)
559#if defined(BASETYPES) || defined(_WINDEF_H)
560/* application has to include <windows.h> in order to use this */
561typedef DWORD CRYPTO_THREAD_LOCAL;
562typedef DWORD CRYPTO_THREAD_ID;
563
564typedef LONG CRYPTO_ONCE;
565#define CRYPTO_ONCE_STATIC_INIT 0
566#endif
567#else
568#if defined(__TANDEM) && defined(_SPT_MODEL_)
569#define SPT_THREAD_SIGNAL 1
570#define SPT_THREAD_AWARE 1
571#include <spthread.h>
572#else
573#include <pthread.h>
574#endif
575typedef pthread_once_t CRYPTO_ONCE;
576typedef pthread_key_t CRYPTO_THREAD_LOCAL;
577typedef pthread_t CRYPTO_THREAD_ID;
578
579#define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT
580#endif
581#endif
582
583#if !defined(CRYPTO_ONCE_STATIC_INIT)
584typedef unsigned int CRYPTO_ONCE;
585typedef unsigned int CRYPTO_THREAD_LOCAL;
586typedef unsigned int CRYPTO_THREAD_ID;
587#define CRYPTO_ONCE_STATIC_INIT 0
588#endif
589
590int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void));
591
592int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *));
593void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key);
594int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val);
595int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key);
596
597CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void);
598int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b);
599
600OSSL_LIB_CTX *OSSL_LIB_CTX_new(void);
601OSSL_LIB_CTX *OSSL_LIB_CTX_new_from_dispatch(const OSSL_CORE_HANDLE *handle,
602 const OSSL_DISPATCH *in);
603OSSL_LIB_CTX *OSSL_LIB_CTX_new_child(const OSSL_CORE_HANDLE *handle,
604 const OSSL_DISPATCH *in);
605int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX *ctx, const char *config_file);
606void OSSL_LIB_CTX_free(OSSL_LIB_CTX *);
607OSSL_LIB_CTX *OSSL_LIB_CTX_get0_global_default(void);
608OSSL_LIB_CTX *OSSL_LIB_CTX_set0_default(OSSL_LIB_CTX *libctx);
609int OSSL_LIB_CTX_get_conf_diagnostics(OSSL_LIB_CTX *ctx);
610void OSSL_LIB_CTX_set_conf_diagnostics(OSSL_LIB_CTX *ctx, int value);
611
612void OSSL_sleep(uint64_t millis);
613
614void *OSSL_LIB_CTX_get_data(OSSL_LIB_CTX *ctx, int index);
615
616#ifdef __cplusplus
617}
618#endif
619#endif
620