summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/crypto
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/lib/libcrypto/crypto.h540
1 files changed, 0 insertions, 540 deletions
diff --git a/src/lib/libcrypto/crypto.h b/src/lib/libcrypto/crypto.h
deleted file mode 100644
index c1ee78fb2f..0000000000
--- a/src/lib/libcrypto/crypto.h
+++ /dev/null
@@ -1,540 +0,0 @@
1/* $OpenBSD: crypto.h,v 1.40 2015/09/17 09:51:40 bcook Exp $ */
2/* ====================================================================
3 * Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
15 * distribution.
16 *
17 * 3. All advertising materials mentioning features or use of this
18 * software must display the following acknowledgment:
19 * "This product includes software developed by the OpenSSL Project
20 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
21 *
22 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23 * endorse or promote products derived from this software without
24 * prior written permission. For written permission, please contact
25 * openssl-core@openssl.org.
26 *
27 * 5. Products derived from this software may not be called "OpenSSL"
28 * nor may "OpenSSL" appear in their names without prior written
29 * permission of the OpenSSL Project.
30 *
31 * 6. Redistributions of any form whatsoever must retain the following
32 * acknowledgment:
33 * "This product includes software developed by the OpenSSL Project
34 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
35 *
36 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
37 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
39 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
40 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
42 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
46 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
47 * OF THE POSSIBILITY OF SUCH DAMAGE.
48 * ====================================================================
49 *
50 * This product includes cryptographic software written by Eric Young
51 * (eay@cryptsoft.com). This product includes software written by Tim
52 * Hudson (tjh@cryptsoft.com).
53 *
54 */
55/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
56 * All rights reserved.
57 *
58 * This package is an SSL implementation written
59 * by Eric Young (eay@cryptsoft.com).
60 * The implementation was written so as to conform with Netscapes SSL.
61 *
62 * This library is free for commercial and non-commercial use as long as
63 * the following conditions are aheared to. The following conditions
64 * apply to all code found in this distribution, be it the RC4, RSA,
65 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
66 * included with this distribution is covered by the same copyright terms
67 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
68 *
69 * Copyright remains Eric Young's, and as such any Copyright notices in
70 * the code are not to be removed.
71 * If this package is used in a product, Eric Young should be given attribution
72 * as the author of the parts of the library used.
73 * This can be in the form of a textual message at program startup or
74 * in documentation (online or textual) provided with the package.
75 *
76 * Redistribution and use in source and binary forms, with or without
77 * modification, are permitted provided that the following conditions
78 * are met:
79 * 1. Redistributions of source code must retain the copyright
80 * notice, this list of conditions and the following disclaimer.
81 * 2. Redistributions in binary form must reproduce the above copyright
82 * notice, this list of conditions and the following disclaimer in the
83 * documentation and/or other materials provided with the distribution.
84 * 3. All advertising materials mentioning features or use of this software
85 * must display the following acknowledgement:
86 * "This product includes cryptographic software written by
87 * Eric Young (eay@cryptsoft.com)"
88 * The word 'cryptographic' can be left out if the rouines from the library
89 * being used are not cryptographic related :-).
90 * 4. If you include any Windows specific code (or a derivative thereof) from
91 * the apps directory (application code) you must include an acknowledgement:
92 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
93 *
94 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
95 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
96 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
97 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
98 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
99 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
100 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
101 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
102 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
103 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
104 * SUCH DAMAGE.
105 *
106 * The licence and distribution terms for any publically available version or
107 * derivative of this code cannot be changed. i.e. this code cannot simply be
108 * copied and put under another distribution licence
109 * [including the GNU Public Licence.]
110 */
111/* ====================================================================
112 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
113 * ECDH support in OpenSSL originally developed by
114 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
115 */
116
117#include <stdint.h>
118#include <stdio.h>
119#include <stdlib.h>
120
121#ifndef HEADER_CRYPTO_H
122#define HEADER_CRYPTO_H
123
124#include <openssl/opensslconf.h>
125
126#include <openssl/stack.h>
127#include <openssl/safestack.h>
128#include <openssl/opensslv.h>
129#include <openssl/ossl_typ.h>
130
131#ifdef __cplusplus
132extern "C" {
133#endif
134
135/* Backward compatibility to SSLeay */
136/* This is more to be used to check the correct DLL is being used
137 * in the MS world. */
138#define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER
139#define SSLEAY_VERSION 0
140/* #define SSLEAY_OPTIONS 1 no longer supported */
141#define SSLEAY_CFLAGS 2
142#define SSLEAY_BUILT_ON 3
143#define SSLEAY_PLATFORM 4
144#define SSLEAY_DIR 5
145
146/* A generic structure to pass assorted data in a expandable way */
147typedef struct openssl_item_st {
148 int code;
149 void *value; /* Not used for flag attributes */
150 size_t value_size; /* Max size of value for output, length for input */
151 size_t *value_length; /* Returned length of value for output */
152} OPENSSL_ITEM;
153
154
155/* When changing the CRYPTO_LOCK_* list, be sure to maintain the text lock
156 * names in cryptlib.c
157 */
158
159#define CRYPTO_LOCK_ERR 1
160#define CRYPTO_LOCK_EX_DATA 2
161#define CRYPTO_LOCK_X509 3
162#define CRYPTO_LOCK_X509_INFO 4
163#define CRYPTO_LOCK_X509_PKEY 5
164#define CRYPTO_LOCK_X509_CRL 6
165#define CRYPTO_LOCK_X509_REQ 7
166#define CRYPTO_LOCK_DSA 8
167#define CRYPTO_LOCK_RSA 9
168#define CRYPTO_LOCK_EVP_PKEY 10
169#define CRYPTO_LOCK_X509_STORE 11
170#define CRYPTO_LOCK_SSL_CTX 12
171#define CRYPTO_LOCK_SSL_CERT 13
172#define CRYPTO_LOCK_SSL_SESSION 14
173#define CRYPTO_LOCK_SSL_SESS_CERT 15
174#define CRYPTO_LOCK_SSL 16
175#define CRYPTO_LOCK_SSL_METHOD 17
176#define CRYPTO_LOCK_RAND 18
177#define CRYPTO_LOCK_RAND2 19
178#define CRYPTO_LOCK_MALLOC 20
179#define CRYPTO_LOCK_BIO 21
180#define CRYPTO_LOCK_GETHOSTBYNAME 22
181#define CRYPTO_LOCK_GETSERVBYNAME 23
182#define CRYPTO_LOCK_READDIR 24
183#define CRYPTO_LOCK_RSA_BLINDING 25
184#define CRYPTO_LOCK_DH 26
185#define CRYPTO_LOCK_MALLOC2 27
186#define CRYPTO_LOCK_DSO 28
187#define CRYPTO_LOCK_DYNLOCK 29
188#define CRYPTO_LOCK_ENGINE 30
189#define CRYPTO_LOCK_UI 31
190#define CRYPTO_LOCK_ECDSA 32
191#define CRYPTO_LOCK_EC 33
192#define CRYPTO_LOCK_ECDH 34
193#define CRYPTO_LOCK_BN 35
194#define CRYPTO_LOCK_EC_PRE_COMP 36
195#define CRYPTO_LOCK_STORE 37
196#define CRYPTO_LOCK_COMP 38
197#define CRYPTO_LOCK_FIPS 39
198#define CRYPTO_LOCK_FIPS2 40
199#define CRYPTO_NUM_LOCKS 41
200
201#define CRYPTO_LOCK 1
202#define CRYPTO_UNLOCK 2
203#define CRYPTO_READ 4
204#define CRYPTO_WRITE 8
205
206#ifndef OPENSSL_NO_LOCKING
207#ifndef CRYPTO_w_lock
208#define CRYPTO_w_lock(type) \
209 CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
210#define CRYPTO_w_unlock(type) \
211 CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
212#define CRYPTO_r_lock(type) \
213 CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__)
214#define CRYPTO_r_unlock(type) \
215 CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__)
216#define CRYPTO_add(addr,amount,type) \
217 CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__)
218#endif
219#else
220#define CRYPTO_w_lock(a)
221#define CRYPTO_w_unlock(a)
222#define CRYPTO_r_lock(a)
223#define CRYPTO_r_unlock(a)
224#define CRYPTO_add(a,b,c) ((*(a))+=(b))
225#endif
226
227/* Some applications as well as some parts of OpenSSL need to allocate
228 and deallocate locks in a dynamic fashion. The following typedef
229 makes this possible in a type-safe manner. */
230/* struct CRYPTO_dynlock_value has to be defined by the application. */
231typedef struct {
232 int references;
233 struct CRYPTO_dynlock_value *data;
234} CRYPTO_dynlock;
235
236
237/* The following can be used to detect memory leaks in the SSLeay library.
238 * It used, it turns on malloc checking */
239
240#define CRYPTO_MEM_CHECK_OFF 0x0 /* an enume */
241#define CRYPTO_MEM_CHECK_ON 0x1 /* a bit */
242#define CRYPTO_MEM_CHECK_ENABLE 0x2 /* a bit */
243#define CRYPTO_MEM_CHECK_DISABLE 0x3 /* an enume */
244
245/* The following are bit values to turn on or off options connected to the
246 * malloc checking functionality */
247
248/* Adds time to the memory checking information */
249#define V_CRYPTO_MDEBUG_TIME 0x1 /* a bit */
250/* Adds thread number to the memory checking information */
251#define V_CRYPTO_MDEBUG_THREAD 0x2 /* a bit */
252
253#define V_CRYPTO_MDEBUG_ALL (V_CRYPTO_MDEBUG_TIME | V_CRYPTO_MDEBUG_THREAD)
254
255
256/* predec of the BIO type */
257typedef struct bio_st BIO_dummy;
258
259struct crypto_ex_data_st {
260 STACK_OF(void) *sk;
261};
262DECLARE_STACK_OF(void)
263
264/* This stuff is basically class callback functions
265 * The current classes are SSL_CTX, SSL, SSL_SESSION, and a few more */
266
267typedef struct crypto_ex_data_func_st {
268 long argl; /* Arbitary long */
269 void *argp; /* Arbitary void * */
270 CRYPTO_EX_new *new_func;
271 CRYPTO_EX_free *free_func;
272 CRYPTO_EX_dup *dup_func;
273} CRYPTO_EX_DATA_FUNCS;
274
275DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS)
276
277/* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA
278 * entry.
279 */
280
281#define CRYPTO_EX_INDEX_BIO 0
282#define CRYPTO_EX_INDEX_SSL 1
283#define CRYPTO_EX_INDEX_SSL_CTX 2
284#define CRYPTO_EX_INDEX_SSL_SESSION 3
285#define CRYPTO_EX_INDEX_X509_STORE 4
286#define CRYPTO_EX_INDEX_X509_STORE_CTX 5
287#define CRYPTO_EX_INDEX_RSA 6
288#define CRYPTO_EX_INDEX_DSA 7
289#define CRYPTO_EX_INDEX_DH 8
290#define CRYPTO_EX_INDEX_ENGINE 9
291#define CRYPTO_EX_INDEX_X509 10
292#define CRYPTO_EX_INDEX_UI 11
293#define CRYPTO_EX_INDEX_ECDSA 12
294#define CRYPTO_EX_INDEX_ECDH 13
295#define CRYPTO_EX_INDEX_COMP 14
296#define CRYPTO_EX_INDEX_STORE 15
297
298/* Dynamically assigned indexes start from this value (don't use directly, use
299 * via CRYPTO_ex_data_new_class). */
300#define CRYPTO_EX_INDEX_USER 100
301
302#define CRYPTO_malloc_init() (0)
303#define CRYPTO_malloc_debug_init() (0)
304
305#if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD
306# ifndef CRYPTO_MDEBUG /* avoid duplicate #define */
307# define CRYPTO_MDEBUG
308# endif
309#endif
310
311int CRYPTO_mem_ctrl(int mode);
312int CRYPTO_is_mem_check_on(void);
313
314/* for applications */
315#define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON)
316#define MemCheck_stop() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF)
317
318#define OPENSSL_malloc(num) CRYPTO_malloc((int)num,__FILE__,__LINE__)
319#define OPENSSL_strdup(str) CRYPTO_strdup((str),__FILE__,__LINE__)
320#define OPENSSL_realloc(addr,num) \
321 CRYPTO_realloc((char *)addr,(int)num,__FILE__,__LINE__)
322#define OPENSSL_realloc_clean(addr,old_num,num) \
323 CRYPTO_realloc_clean(addr,old_num,num,__FILE__,__LINE__)
324#define OPENSSL_remalloc(addr,num) \
325 CRYPTO_remalloc((char **)addr,(int)num,__FILE__,__LINE__)
326#define OPENSSL_freeFunc CRYPTO_free
327#define OPENSSL_free(addr) CRYPTO_free(addr)
328
329#define OPENSSL_malloc_locked(num) \
330 CRYPTO_malloc_locked((int)num,__FILE__,__LINE__)
331#define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr)
332
333
334const char *SSLeay_version(int type);
335unsigned long SSLeay(void);
336
337/* An opaque type representing an implementation of "ex_data" support */
338typedef struct st_CRYPTO_EX_DATA_IMPL CRYPTO_EX_DATA_IMPL;
339/* Return an opaque pointer to the current "ex_data" implementation */
340const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void);
341/* Sets the "ex_data" implementation to be used (if it's not too late) */
342int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i);
343/* Get a new "ex_data" class, and return the corresponding "class_index" */
344int CRYPTO_ex_data_new_class(void);
345/* Within a given class, get/register a new index */
346int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
347 CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
348 CRYPTO_EX_free *free_func);
349/* Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a given
350 * class (invokes whatever per-class callbacks are applicable) */
351int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
352int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
353 CRYPTO_EX_DATA *from);
354void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad);
355/* Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular index
356 * (relative to the class type involved) */
357int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val);
358void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx);
359/* This function cleans up all "ex_data" state. It mustn't be called under
360 * potential race-conditions. */
361void CRYPTO_cleanup_all_ex_data(void);
362
363int CRYPTO_get_new_lockid(char *name);
364
365int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */
366void CRYPTO_lock(int mode, int type, const char *file, int line);
367void CRYPTO_set_locking_callback(void (*func)(int mode, int type,
368 const char *file, int line));
369void (*CRYPTO_get_locking_callback(void))(int mode, int type,
370 const char *file, int line);
371void CRYPTO_set_add_lock_callback(int (*func)(int *num, int mount, int type,
372 const char *file, int line));
373int (*CRYPTO_get_add_lock_callback(void))(int *num, int mount, int type,
374 const char *file, int line);
375
376/* Don't use this structure directly. */
377typedef struct crypto_threadid_st {
378 void *ptr;
379 unsigned long val;
380} CRYPTO_THREADID;
381/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */
382void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
383void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr);
384int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *));
385void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *);
386void CRYPTO_THREADID_current(CRYPTO_THREADID *id);
387int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, const CRYPTO_THREADID *b);
388void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, const CRYPTO_THREADID *src);
389unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);
390#ifndef OPENSSL_NO_DEPRECATED
391void CRYPTO_set_id_callback(unsigned long (*func)(void));
392unsigned long (*CRYPTO_get_id_callback(void))(void);
393unsigned long CRYPTO_thread_id(void);
394#endif
395
396const char *CRYPTO_get_lock_name(int type);
397int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
398 int line);
399
400int CRYPTO_get_new_dynlockid(void);
401void CRYPTO_destroy_dynlockid(int i);
402struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i);
403void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *(*dyn_create_function)(const char *file, int line));
404void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line));
405void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)(struct CRYPTO_dynlock_value *l, const char *file, int line));
406struct CRYPTO_dynlock_value *(*CRYPTO_get_dynlock_create_callback(void))(const char *file, int line);
407void (*CRYPTO_get_dynlock_lock_callback(void))(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line);
408void (*CRYPTO_get_dynlock_destroy_callback(void))(struct CRYPTO_dynlock_value *l, const char *file, int line);
409
410/* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions --
411 * call the latter last if you need different functions */
412int CRYPTO_set_mem_functions(void *(*m)(size_t), void *(*r)(void *, size_t), void (*f)(void *));
413int CRYPTO_set_locked_mem_functions(void *(*m)(size_t), void (*free_func)(void *));
414int CRYPTO_set_mem_ex_functions(void *(*m)(size_t, const char *, int),
415 void *(*r)(void *, size_t, const char *, int), void (*f)(void *));
416int CRYPTO_set_locked_mem_ex_functions(void *(*m)(size_t, const char *, int),
417 void (*free_func)(void *));
418int CRYPTO_set_mem_debug_functions(
419 void (*m)(void *, int, const char *, int, int),
420 void (*r)(void *, void *, int, const char *, int, int),
421 void (*f)(void *, int), void (*so)(long), long (*go)(void));
422void CRYPTO_get_mem_functions(void *(**m)(size_t), void *(**r)(void *, size_t),
423 void (**f)(void *));
424void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
425void CRYPTO_get_mem_ex_functions(void *(**m)(size_t, const char *, int),
426 void *(**r)(void *, size_t, const char *, int), void (**f)(void *));
427void CRYPTO_get_locked_mem_ex_functions(void *(**m)(size_t, const char *, int),
428 void (**f)(void *));
429void CRYPTO_get_mem_debug_functions(
430 void (**m)(void *, int, const char *, int, int),
431 void (**r)(void *, void *, int, const char *, int, int),
432 void (**f)(void *, int), void (**so)(long), long (**go)(void));
433
434#ifndef LIBRESSL_INTERNAL
435void *CRYPTO_malloc_locked(int num, const char *file, int line);
436void CRYPTO_free_locked(void *ptr);
437void *CRYPTO_malloc(int num, const char *file, int line);
438char *CRYPTO_strdup(const char *str, const char *file, int line);
439void CRYPTO_free(void *ptr);
440void *CRYPTO_realloc(void *addr, int num, const char *file, int line);
441#endif
442
443void *CRYPTO_realloc_clean(void *addr, int old_num, int num,
444 const char *file, int line);
445void *CRYPTO_remalloc(void *addr, int num, const char *file, int line);
446
447#ifndef LIBRESSL_INTERNAL
448void OPENSSL_cleanse(void *ptr, size_t len);
449#endif
450
451void CRYPTO_set_mem_debug_options(long bits);
452long CRYPTO_get_mem_debug_options(void);
453
454#define CRYPTO_push_info(info) \
455 CRYPTO_push_info_(info, __FILE__, __LINE__);
456int CRYPTO_push_info_(const char *info, const char *file, int line);
457int CRYPTO_pop_info(void);
458int CRYPTO_remove_all_info(void);
459
460
461/* Default debugging functions (enabled by CRYPTO_malloc_debug_init() macro;
462 * used as default in CRYPTO_MDEBUG compilations): */
463/* The last argument has the following significance:
464 *
465 * 0: called before the actual memory allocation has taken place
466 * 1: called after the actual memory allocation has taken place
467 */
468void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line, int before_p)
469 __attribute__ ((deprecated));
470void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num, const char *file, int line, int before_p)
471 __attribute__ ((deprecated));
472void CRYPTO_dbg_free(void *addr, int before_p)
473 __attribute__ ((deprecated));
474/* Tell the debugging code about options. By default, the following values
475 * apply:
476 *
477 * 0: Clear all options.
478 * V_CRYPTO_MDEBUG_TIME (1): Set the "Show Time" option.
479 * V_CRYPTO_MDEBUG_THREAD (2): Set the "Show Thread Number" option.
480 * V_CRYPTO_MDEBUG_ALL (3): 1 + 2
481 */
482void CRYPTO_dbg_set_options(long bits)
483 __attribute__ ((deprecated));
484long CRYPTO_dbg_get_options(void)
485 __attribute__ ((deprecated));
486
487
488void CRYPTO_mem_leaks_fp(FILE *);
489void CRYPTO_mem_leaks(struct bio_st *bio);
490/* unsigned long order, char *file, int line, int num_bytes, char *addr */
491typedef void *CRYPTO_MEM_LEAK_CB(unsigned long, const char *, int, int, void *);
492void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb);
493
494/* die if we have to */
495void OpenSSLDie(const char *file, int line, const char *assertion);
496#define OPENSSL_assert(e) (void)((e) ? 0 : (OpenSSLDie(__FILE__, __LINE__, #e),1))
497
498uint64_t OPENSSL_cpu_caps(void);
499
500int OPENSSL_isservice(void);
501
502void OPENSSL_init(void);
503
504#ifndef LIBRESSL_INTERNAL
505/* CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. It
506 * takes an amount of time dependent on |len|, but independent of the contents
507 * of |a| and |b|. Unlike memcmp, it cannot be used to put elements into a
508 * defined order as the return value when a != b is undefined, other than to be
509 * non-zero. */
510int CRYPTO_memcmp(const void *a, const void *b, size_t len);
511#endif
512
513/* BEGIN ERROR CODES */
514/* The following lines are auto generated by the script mkerr.pl. Any changes
515 * made after this point may be overwritten when the script is next run.
516 */
517void ERR_load_CRYPTO_strings(void);
518
519/* Error codes for the CRYPTO functions. */
520
521/* Function codes. */
522#define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100
523#define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID 103
524#define CRYPTO_F_CRYPTO_GET_NEW_LOCKID 101
525#define CRYPTO_F_CRYPTO_SET_EX_DATA 102
526#define CRYPTO_F_DEF_ADD_INDEX 104
527#define CRYPTO_F_DEF_GET_CLASS 105
528#define CRYPTO_F_FIPS_MODE_SET 109
529#define CRYPTO_F_INT_DUP_EX_DATA 106
530#define CRYPTO_F_INT_FREE_EX_DATA 107
531#define CRYPTO_F_INT_NEW_EX_DATA 108
532
533/* Reason codes. */
534#define CRYPTO_R_FIPS_MODE_NOT_SUPPORTED 101
535#define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK 100
536
537#ifdef __cplusplus
538}
539#endif
540#endif
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-22 07:48:34 +0000