| 1 |
/* crypto/crypto.h */ |
| 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 |
* [email protected]. |
| 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 |
* ([email protected]). This product includes software written by Tim |
| 52 |
* Hudson ([email protected]). |
| 53 |
* |
| 54 |
*/ |
| 55 |
/* Copyright (C) 1995-1998 Eric Young ([email protected]) |
| 56 |
* All rights reserved. |
| 57 |
* |
| 58 |
* This package is an SSL implementation written |
| 59 |
* by Eric Young ([email protected]). |
| 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 ([email protected]). |
| 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 ([email protected])" |
| 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 ([email protected])" |
| 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 |
#ifndef HEADER_CRYPTO_H |
| 118 |
# define HEADER_CRYPTO_H |
| 119 |
|
| 120 |
# include <string.h> |
| 121 |
# include <stdlib.h> |
| 122 |
|
| 123 |
# include <openssl/e_os2.h> |
| 124 |
|
| 125 |
# ifndef OPENSSL_NO_FP_API |
| 126 |
# include <stdio.h> |
| 127 |
# endif |
| 128 |
|
| 129 |
# include <openssl/stack.h> |
| 130 |
# include <openssl/safestack.h> |
| 131 |
# include <openssl/opensslv.h> |
| 132 |
# include <openssl/ossl_typ.h> |
| 133 |
|
| 134 |
# ifdef CHARSET_EBCDIC |
| 135 |
# include <openssl/ebcdic.h> |
| 136 |
# endif |
| 137 |
|
| 138 |
/* |
| 139 |
* Resolve problems on some operating systems with symbol names that clash |
| 140 |
* one way or another |
| 141 |
*/ |
| 142 |
# include <openssl/symhacks.h> |
| 143 |
|
| 144 |
#ifdef __cplusplus |
| 145 |
extern "C" { |
| 146 |
#endif |
| 147 |
|
| 148 |
/* Backward compatibility to SSLeay */ |
| 149 |
/* |
| 150 |
* This is more to be used to check the correct DLL is being used in the MS |
| 151 |
* world. |
| 152 |
*/ |
| 153 |
# define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER |
| 154 |
# define SSLEAY_VERSION 0 |
| 155 |
/* #define SSLEAY_OPTIONS 1 no longer supported */ |
| 156 |
# define SSLEAY_CFLAGS 2 |
| 157 |
# define SSLEAY_BUILT_ON 3 |
| 158 |
# define SSLEAY_PLATFORM 4 |
| 159 |
# define SSLEAY_DIR 5 |
| 160 |
|
| 161 |
/* Already declared in ossl_typ.h */ |
| 162 |
# if 0 |
| 163 |
typedef struct crypto_ex_data_st CRYPTO_EX_DATA; |
| 164 |
/* Called when a new object is created */ |
| 165 |
typedef int CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad, |
| 166 |
int idx, long argl, void *argp); |
| 167 |
/* Called when an object is free()ed */ |
| 168 |
typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad, |
| 169 |
int idx, long argl, void *argp); |
| 170 |
/* Called when we need to dup an object */ |
| 171 |
typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, CRYPTO_EX_DATA *from, |
| 172 |
void *from_d, int idx, long argl, void *argp); |
| 173 |
# endif |
| 174 |
|
| 175 |
/* A generic structure to pass assorted data in a expandable way */ |
| 176 |
typedef struct openssl_item_st { |
| 177 |
int code; |
| 178 |
void *value; /* Not used for flag attributes */ |
| 179 |
size_t value_size; /* Max size of value for output, length for |
| 180 |
* input */ |
| 181 |
size_t *value_length; /* Returned length of value for output */ |
| 182 |
} OPENSSL_ITEM; |
| 183 |
|
| 184 |
/* |
| 185 |
* When changing the CRYPTO_LOCK_* list, be sure to maintin the text lock |
| 186 |
* names in cryptlib.c |
| 187 |
*/ |
| 188 |
|
| 189 |
# define CRYPTO_LOCK_ERR 1 |
| 190 |
# define CRYPTO_LOCK_EX_DATA 2 |
| 191 |
# define CRYPTO_LOCK_X509 3 |
| 192 |
# define CRYPTO_LOCK_X509_INFO 4 |
| 193 |
# define CRYPTO_LOCK_X509_PKEY 5 |
| 194 |
# define CRYPTO_LOCK_X509_CRL 6 |
| 195 |
# define CRYPTO_LOCK_X509_REQ 7 |
| 196 |
# define CRYPTO_LOCK_DSA 8 |
| 197 |
# define CRYPTO_LOCK_RSA 9 |
| 198 |
# define CRYPTO_LOCK_EVP_PKEY 10 |
| 199 |
# define CRYPTO_LOCK_X509_STORE 11 |
| 200 |
# define CRYPTO_LOCK_SSL_CTX 12 |
| 201 |
# define CRYPTO_LOCK_SSL_CERT 13 |
| 202 |
# define CRYPTO_LOCK_SSL_SESSION 14 |
| 203 |
# define CRYPTO_LOCK_SSL_SESS_CERT 15 |
| 204 |
# define CRYPTO_LOCK_SSL 16 |
| 205 |
# define CRYPTO_LOCK_SSL_METHOD 17 |
| 206 |
# define CRYPTO_LOCK_RAND 18 |
| 207 |
# define CRYPTO_LOCK_RAND2 19 |
| 208 |
# define CRYPTO_LOCK_MALLOC 20 |
| 209 |
# define CRYPTO_LOCK_BIO 21 |
| 210 |
# define CRYPTO_LOCK_GETHOSTBYNAME 22 |
| 211 |
# define CRYPTO_LOCK_GETSERVBYNAME 23 |
| 212 |
# define CRYPTO_LOCK_READDIR 24 |
| 213 |
# define CRYPTO_LOCK_RSA_BLINDING 25 |
| 214 |
# define CRYPTO_LOCK_DH 26 |
| 215 |
# define CRYPTO_LOCK_MALLOC2 27 |
| 216 |
# define CRYPTO_LOCK_DSO 28 |
| 217 |
# define CRYPTO_LOCK_DYNLOCK 29 |
| 218 |
# define CRYPTO_LOCK_ENGINE 30 |
| 219 |
# define CRYPTO_LOCK_UI 31 |
| 220 |
# define CRYPTO_LOCK_ECDSA 32 |
| 221 |
# define CRYPTO_LOCK_EC 33 |
| 222 |
# define CRYPTO_LOCK_ECDH 34 |
| 223 |
# define CRYPTO_LOCK_BN 35 |
| 224 |
# define CRYPTO_LOCK_EC_PRE_COMP 36 |
| 225 |
# define CRYPTO_LOCK_STORE 37 |
| 226 |
# define CRYPTO_LOCK_COMP 38 |
| 227 |
# define CRYPTO_LOCK_FIPS 39 |
| 228 |
# define CRYPTO_LOCK_FIPS2 40 |
| 229 |
# define CRYPTO_NUM_LOCKS 41 |
| 230 |
|
| 231 |
# define CRYPTO_LOCK 1 |
| 232 |
# define CRYPTO_UNLOCK 2 |
| 233 |
# define CRYPTO_READ 4 |
| 234 |
# define CRYPTO_WRITE 8 |
| 235 |
|
| 236 |
# ifndef OPENSSL_NO_LOCKING |
| 237 |
# ifndef CRYPTO_w_lock |
| 238 |
# define CRYPTO_w_lock(type) \ |
| 239 |
CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,OPENSSL_FILE,OPENSSL_LINE) |
| 240 |
# define CRYPTO_w_unlock(type) \ |
| 241 |
CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,OPENSSL_FILE,OPENSSL_LINE) |
| 242 |
# define CRYPTO_r_lock(type) \ |
| 243 |
CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,OPENSSL_FILE,OPENSSL_LINE) |
| 244 |
# define CRYPTO_r_unlock(type) \ |
| 245 |
CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,OPENSSL_FILE,OPENSSL_LINE) |
| 246 |
# define CRYPTO_add(addr,amount,type) \ |
| 247 |
CRYPTO_add_lock(addr,amount,type,OPENSSL_FILE,OPENSSL_LINE) |
| 248 |
# endif |
| 249 |
# else |
| 250 |
# define CRYPTO_w_lock(a) |
| 251 |
# define CRYPTO_w_unlock(a) |
| 252 |
# define CRYPTO_r_lock(a) |
| 253 |
# define CRYPTO_r_unlock(a) |
| 254 |
# define CRYPTO_add(a,b,c) ((*(a))+=(b)) |
| 255 |
# endif |
| 256 |
|
| 257 |
/* |
| 258 |
* Some applications as well as some parts of OpenSSL need to allocate and |
| 259 |
* deallocate locks in a dynamic fashion. The following typedef makes this |
| 260 |
* possible in a type-safe manner. |
| 261 |
*/ |
| 262 |
/* struct CRYPTO_dynlock_value has to be defined by the application. */ |
| 263 |
typedef struct { |
| 264 |
int references; |
| 265 |
struct CRYPTO_dynlock_value *data; |
| 266 |
} CRYPTO_dynlock; |
| 267 |
|
| 268 |
/* |
| 269 |
* The following can be used to detect memory leaks in the SSLeay library. It |
| 270 |
* used, it turns on malloc checking |
| 271 |
*/ |
| 272 |
|
| 273 |
# define CRYPTO_MEM_CHECK_OFF 0x0/* an enume */ |
| 274 |
# define CRYPTO_MEM_CHECK_ON 0x1/* a bit */ |
| 275 |
# define CRYPTO_MEM_CHECK_ENABLE 0x2/* a bit */ |
| 276 |
# define CRYPTO_MEM_CHECK_DISABLE 0x3/* an enume */ |
| 277 |
|
| 278 |
/* |
| 279 |
* The following are bit values to turn on or off options connected to the |
| 280 |
* malloc checking functionality |
| 281 |
*/ |
| 282 |
|
| 283 |
/* Adds time to the memory checking information */ |
| 284 |
# define V_CRYPTO_MDEBUG_TIME 0x1/* a bit */ |
| 285 |
/* Adds thread number to the memory checking information */ |
| 286 |
# define V_CRYPTO_MDEBUG_THREAD 0x2/* a bit */ |
| 287 |
|
| 288 |
# define V_CRYPTO_MDEBUG_ALL (V_CRYPTO_MDEBUG_TIME | V_CRYPTO_MDEBUG_THREAD) |
| 289 |
|
| 290 |
/* predec of the BIO type */ |
| 291 |
typedef struct bio_st BIO_dummy; |
| 292 |
|
| 293 |
struct crypto_ex_data_st { |
| 294 |
STACK_OF(void) *sk; |
| 295 |
/* gcc is screwing up this data structure :-( */ |
| 296 |
int dummy; |
| 297 |
}; |
| 298 |
DECLARE_STACK_OF(void) |
| 299 |
|
| 300 |
/* |
| 301 |
* This stuff is basically class callback functions The current classes are |
| 302 |
* SSL_CTX, SSL, SSL_SESSION, and a few more |
| 303 |
*/ |
| 304 |
|
| 305 |
typedef struct crypto_ex_data_func_st { |
| 306 |
long argl; /* Arbitary long */ |
| 307 |
void *argp; /* Arbitary void * */ |
| 308 |
CRYPTO_EX_new *new_func; |
| 309 |
CRYPTO_EX_free *free_func; |
| 310 |
CRYPTO_EX_dup *dup_func; |
| 311 |
} CRYPTO_EX_DATA_FUNCS; |
| 312 |
|
| 313 |
DECLARE_STACK_OF(CRYPTO_EX_DATA_FUNCS) |
| 314 |
|
| 315 |
/* |
| 316 |
* Per class, we have a STACK of CRYPTO_EX_DATA_FUNCS for each CRYPTO_EX_DATA |
| 317 |
* entry. |
| 318 |
*/ |
| 319 |
|
| 320 |
# define CRYPTO_EX_INDEX_BIO 0 |
| 321 |
# define CRYPTO_EX_INDEX_SSL 1 |
| 322 |
# define CRYPTO_EX_INDEX_SSL_CTX 2 |
| 323 |
# define CRYPTO_EX_INDEX_SSL_SESSION 3 |
| 324 |
# define CRYPTO_EX_INDEX_X509_STORE 4 |
| 325 |
# define CRYPTO_EX_INDEX_X509_STORE_CTX 5 |
| 326 |
# define CRYPTO_EX_INDEX_RSA 6 |
| 327 |
# define CRYPTO_EX_INDEX_DSA 7 |
| 328 |
# define CRYPTO_EX_INDEX_DH 8 |
| 329 |
# define CRYPTO_EX_INDEX_ENGINE 9 |
| 330 |
# define CRYPTO_EX_INDEX_X509 10 |
| 331 |
# define CRYPTO_EX_INDEX_UI 11 |
| 332 |
# define CRYPTO_EX_INDEX_ECDSA 12 |
| 333 |
# define CRYPTO_EX_INDEX_ECDH 13 |
| 334 |
# define CRYPTO_EX_INDEX_COMP 14 |
| 335 |
# define CRYPTO_EX_INDEX_STORE 15 |
| 336 |
|
| 337 |
/* |
| 338 |
* Dynamically assigned indexes start from this value (don't use directly, |
| 339 |
* use via CRYPTO_ex_data_new_class). |
| 340 |
*/ |
| 341 |
# define CRYPTO_EX_INDEX_USER 100 |
| 342 |
|
| 343 |
/* |
| 344 |
* This is the default callbacks, but we can have others as well: this is |
| 345 |
* needed in Win32 where the application malloc and the library malloc may |
| 346 |
* not be the same. |
| 347 |
*/ |
| 348 |
# define CRYPTO_malloc_init() CRYPTO_set_mem_functions(\ |
| 349 |
malloc, realloc, free) |
| 350 |
|
| 351 |
# if defined CRYPTO_MDEBUG_ALL || defined CRYPTO_MDEBUG_TIME || defined CRYPTO_MDEBUG_THREAD |
| 352 |
# ifndef CRYPTO_MDEBUG /* avoid duplicate #define */ |
| 353 |
# define CRYPTO_MDEBUG |
| 354 |
# endif |
| 355 |
# endif |
| 356 |
|
| 357 |
/* |
| 358 |
* Set standard debugging functions (not done by default unless CRYPTO_MDEBUG |
| 359 |
* is defined) |
| 360 |
*/ |
| 361 |
# define CRYPTO_malloc_debug_init() do {\ |
| 362 |
CRYPTO_set_mem_debug_functions(\ |
| 363 |
CRYPTO_dbg_malloc,\ |
| 364 |
CRYPTO_dbg_realloc,\ |
| 365 |
CRYPTO_dbg_free,\ |
| 366 |
CRYPTO_dbg_set_options,\ |
| 367 |
CRYPTO_dbg_get_options);\ |
| 368 |
} while(0) |
| 369 |
|
| 370 |
int CRYPTO_mem_ctrl(int mode); |
| 371 |
int CRYPTO_is_mem_check_on(void); |
| 372 |
|
| 373 |
/* for applications */ |
| 374 |
# define MemCheck_start() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON) |
| 375 |
# define MemCheck_stop() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_OFF) |
| 376 |
|
| 377 |
/* for library-internal use */ |
| 378 |
# define MemCheck_on() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ENABLE) |
| 379 |
# define MemCheck_off() CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_DISABLE) |
| 380 |
# define is_MemCheck_on() CRYPTO_is_mem_check_on() |
| 381 |
|
| 382 |
# define OPENSSL_malloc(num) CRYPTO_malloc((int)num,OPENSSL_FILE,OPENSSL_LINE) |
| 383 |
# define OPENSSL_strdup(str) CRYPTO_strdup((str),OPENSSL_FILE,OPENSSL_LINE) |
| 384 |
# define OPENSSL_realloc(addr,num) \ |
| 385 |
CRYPTO_realloc((char *)addr,(int)num,OPENSSL_FILE,OPENSSL_LINE) |
| 386 |
# define OPENSSL_realloc_clean(addr,old_num,num) \ |
| 387 |
CRYPTO_realloc_clean(addr,old_num,num,OPENSSL_FILE,OPENSSL_LINE) |
| 388 |
# define OPENSSL_remalloc(addr,num) \ |
| 389 |
CRYPTO_remalloc((char **)addr,(int)num,OPENSSL_FILE,OPENSSL_LINE) |
| 390 |
# define OPENSSL_freeFunc CRYPTO_free |
| 391 |
# define OPENSSL_free(addr) CRYPTO_free(addr) |
| 392 |
|
| 393 |
# define OPENSSL_malloc_locked(num) \ |
| 394 |
CRYPTO_malloc_locked((int)num,OPENSSL_FILE,OPENSSL_LINE) |
| 395 |
# define OPENSSL_free_locked(addr) CRYPTO_free_locked(addr) |
| 396 |
|
| 397 |
const char *SSLeay_version(int type); |
| 398 |
unsigned long SSLeay(void); |
| 399 |
|
| 400 |
int OPENSSL_issetugid(void); |
| 401 |
|
| 402 |
/* An opaque type representing an implementation of "ex_data" support */ |
| 403 |
typedef struct st_CRYPTO_EX_DATA_IMPL CRYPTO_EX_DATA_IMPL; |
| 404 |
/* Return an opaque pointer to the current "ex_data" implementation */ |
| 405 |
const CRYPTO_EX_DATA_IMPL *CRYPTO_get_ex_data_implementation(void); |
| 406 |
/* Sets the "ex_data" implementation to be used (if it's not too late) */ |
| 407 |
int CRYPTO_set_ex_data_implementation(const CRYPTO_EX_DATA_IMPL *i); |
| 408 |
/* Get a new "ex_data" class, and return the corresponding "class_index" */ |
| 409 |
int CRYPTO_ex_data_new_class(void); |
| 410 |
/* Within a given class, get/register a new index */ |
| 411 |
int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp, |
| 412 |
CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, |
| 413 |
CRYPTO_EX_free *free_func); |
| 414 |
/* |
| 415 |
* Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a |
| 416 |
* given class (invokes whatever per-class callbacks are applicable) |
| 417 |
*/ |
| 418 |
int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); |
| 419 |
int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, |
| 420 |
CRYPTO_EX_DATA *from); |
| 421 |
void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); |
| 422 |
/* |
| 423 |
* Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular |
| 424 |
* index (relative to the class type involved) |
| 425 |
*/ |
| 426 |
int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val); |
| 427 |
void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx); |
| 428 |
/* |
| 429 |
* This function cleans up all "ex_data" state. It mustn't be called under |
| 430 |
* potential race-conditions. |
| 431 |
*/ |
| 432 |
void CRYPTO_cleanup_all_ex_data(void); |
| 433 |
|
| 434 |
int CRYPTO_get_new_lockid(char *name); |
| 435 |
|
| 436 |
int CRYPTO_num_locks(void); /* return CRYPTO_NUM_LOCKS (shared libs!) */ |
| 437 |
void CRYPTO_lock(int mode, int type, const char *file, int line); |
| 438 |
void CRYPTO_set_locking_callback(void (*func) (int mode, int type, |
| 439 |
const char *file, int line)); |
| 440 |
void (*CRYPTO_get_locking_callback(void)) (int mode, int type, |
| 441 |
const char *file, int line); |
| 442 |
void CRYPTO_set_add_lock_callback(int (*func) |
| 443 |
(int *num, int mount, int type, |
| 444 |
const char *file, int line)); |
| 445 |
int (*CRYPTO_get_add_lock_callback(void)) (int *num, int mount, int type, |
| 446 |
const char *file, int line); |
| 447 |
|
| 448 |
/* Don't use this structure directly. */ |
| 449 |
typedef struct crypto_threadid_st { |
| 450 |
void *ptr; |
| 451 |
unsigned long val; |
| 452 |
} CRYPTO_THREADID; |
| 453 |
/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */ |
| 454 |
void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val); |
| 455 |
void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr); |
| 456 |
int CRYPTO_THREADID_set_callback(void (*threadid_func) (CRYPTO_THREADID *)); |
| 457 |
void (*CRYPTO_THREADID_get_callback(void)) (CRYPTO_THREADID *); |
| 458 |
void CRYPTO_THREADID_current(CRYPTO_THREADID *id); |
| 459 |
int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, const CRYPTO_THREADID *b); |
| 460 |
void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, const CRYPTO_THREADID *src); |
| 461 |
unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id); |
| 462 |
# ifndef OPENSSL_NO_DEPRECATED |
| 463 |
void CRYPTO_set_id_callback(unsigned long (*func) (void)); |
| 464 |
unsigned long (*CRYPTO_get_id_callback(void)) (void); |
| 465 |
unsigned long CRYPTO_thread_id(void); |
| 466 |
# endif |
| 467 |
|
| 468 |
const char *CRYPTO_get_lock_name(int type); |
| 469 |
int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file, |
| 470 |
int line); |
| 471 |
|
| 472 |
int CRYPTO_get_new_dynlockid(void); |
| 473 |
void CRYPTO_destroy_dynlockid(int i); |
| 474 |
struct CRYPTO_dynlock_value *CRYPTO_get_dynlock_value(int i); |
| 475 |
void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value |
| 476 |
*(*dyn_create_function) (const char |
| 477 |
*file, |
| 478 |
int line)); |
| 479 |
void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function) |
| 480 |
(int mode, |
| 481 |
struct CRYPTO_dynlock_value *l, |
| 482 |
const char *file, int line)); |
| 483 |
void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function) |
| 484 |
(struct CRYPTO_dynlock_value *l, |
| 485 |
const char *file, int line)); |
| 486 |
struct CRYPTO_dynlock_value |
| 487 |
*(*CRYPTO_get_dynlock_create_callback(void)) (const char *file, int line); |
| 488 |
void (*CRYPTO_get_dynlock_lock_callback(void)) (int mode, |
| 489 |
struct CRYPTO_dynlock_value |
| 490 |
*l, const char *file, |
| 491 |
int line); |
| 492 |
void (*CRYPTO_get_dynlock_destroy_callback(void)) (struct CRYPTO_dynlock_value |
| 493 |
*l, const char *file, |
| 494 |
int line); |
| 495 |
|
| 496 |
/* |
| 497 |
* CRYPTO_set_mem_functions includes CRYPTO_set_locked_mem_functions -- call |
| 498 |
* the latter last if you need different functions |
| 499 |
*/ |
| 500 |
int CRYPTO_set_mem_functions(void *(*m) (size_t), void *(*r) (void *, size_t), |
| 501 |
void (*f) (void *)); |
| 502 |
int CRYPTO_set_locked_mem_functions(void *(*m) (size_t), |
| 503 |
void (*free_func) (void *)); |
| 504 |
int CRYPTO_set_mem_ex_functions(void *(*m) (size_t, const char *, int), |
| 505 |
void *(*r) (void *, size_t, const char *, |
| 506 |
int), void (*f) (void *)); |
| 507 |
int CRYPTO_set_locked_mem_ex_functions(void *(*m) (size_t, const char *, int), |
| 508 |
void (*free_func) (void *)); |
| 509 |
int CRYPTO_set_mem_debug_functions(void (*m) |
| 510 |
(void *, int, const char *, int, int), |
| 511 |
void (*r) (void *, void *, int, |
| 512 |
const char *, int, int), |
| 513 |
void (*f) (void *, int), void (*so) (long), |
| 514 |
long (*go) (void)); |
| 515 |
void CRYPTO_get_mem_functions(void *(**m) (size_t), |
| 516 |
void *(**r) (void *, size_t), |
| 517 |
void (**f) (void *)); |
| 518 |
void CRYPTO_get_locked_mem_functions(void *(**m) (size_t), |
| 519 |
void (**f) (void *)); |
| 520 |
void CRYPTO_get_mem_ex_functions(void *(**m) (size_t, const char *, int), |
| 521 |
void *(**r) (void *, size_t, const char *, |
| 522 |
int), void (**f) (void *)); |
| 523 |
void CRYPTO_get_locked_mem_ex_functions(void |
| 524 |
*(**m) (size_t, const char *, int), |
| 525 |
void (**f) (void *)); |
| 526 |
void CRYPTO_get_mem_debug_functions(void (**m) |
| 527 |
(void *, int, const char *, int, int), |
| 528 |
void (**r) (void *, void *, int, |
| 529 |
const char *, int, int), |
| 530 |
void (**f) (void *, int), |
| 531 |
void (**so) (long), long (**go) (void)); |
| 532 |
|
| 533 |
void *CRYPTO_malloc_locked(int num, const char *file, int line); |
| 534 |
void CRYPTO_free_locked(void *ptr); |
| 535 |
void *CRYPTO_malloc(int num, const char *file, int line); |
| 536 |
char *CRYPTO_strdup(const char *str, const char *file, int line); |
| 537 |
void CRYPTO_free(void *ptr); |
| 538 |
void *CRYPTO_realloc(void *addr, int num, const char *file, int line); |
| 539 |
void *CRYPTO_realloc_clean(void *addr, int old_num, int num, const char *file, |
| 540 |
int line); |
| 541 |
void *CRYPTO_remalloc(void *addr, int num, const char *file, int line); |
| 542 |
|
| 543 |
void OPENSSL_cleanse(void *ptr, size_t len); |
| 544 |
|
| 545 |
void CRYPTO_set_mem_debug_options(long bits); |
| 546 |
long CRYPTO_get_mem_debug_options(void); |
| 547 |
|
| 548 |
# define CRYPTO_push_info(info) \ |
| 549 |
CRYPTO_push_info_(info, OPENSSL_FILE, OPENSSL_LINE); |
| 550 |
int CRYPTO_push_info_(const char *info, const char *file, int line); |
| 551 |
int CRYPTO_pop_info(void); |
| 552 |
int CRYPTO_remove_all_info(void); |
| 553 |
|
| 554 |
/* |
| 555 |
* Default debugging functions (enabled by CRYPTO_malloc_debug_init() macro; |
| 556 |
* used as default in CRYPTO_MDEBUG compilations): |
| 557 |
*/ |
| 558 |
/*- |
| 559 |
* The last argument has the following significance: |
| 560 |
* |
| 561 |
* 0: called before the actual memory allocation has taken place |
| 562 |
* 1: called after the actual memory allocation has taken place |
| 563 |
*/ |
| 564 |
void CRYPTO_dbg_malloc(void *addr, int num, const char *file, int line, |
| 565 |
int before_p); |
| 566 |
void CRYPTO_dbg_realloc(void *addr1, void *addr2, int num, const char *file, |
| 567 |
int line, int before_p); |
| 568 |
void CRYPTO_dbg_free(void *addr, int before_p); |
| 569 |
/*- |
| 570 |
* Tell the debugging code about options. By default, the following values |
| 571 |
* apply: |
| 572 |
* |
| 573 |
* 0: Clear all options. |
| 574 |
* V_CRYPTO_MDEBUG_TIME (1): Set the "Show Time" option. |
| 575 |
* V_CRYPTO_MDEBUG_THREAD (2): Set the "Show Thread Number" option. |
| 576 |
* V_CRYPTO_MDEBUG_ALL (3): 1 + 2 |
| 577 |
*/ |
| 578 |
void CRYPTO_dbg_set_options(long bits); |
| 579 |
long CRYPTO_dbg_get_options(void); |
| 580 |
|
| 581 |
# ifndef OPENSSL_NO_FP_API |
| 582 |
void CRYPTO_mem_leaks_fp(FILE *); |
| 583 |
# endif |
| 584 |
void CRYPTO_mem_leaks(struct bio_st *bio); |
| 585 |
/* unsigned long order, char *file, int line, int num_bytes, char *addr */ |
| 586 |
typedef void *CRYPTO_MEM_LEAK_CB (unsigned long, const char *, int, int, |
| 587 |
void *); |
| 588 |
void CRYPTO_mem_leaks_cb(CRYPTO_MEM_LEAK_CB *cb); |
| 589 |
|
| 590 |
/* die if we have to */ |
| 591 |
void OpenSSLDie(const char *file, int line, const char *assertion); |
| 592 |
# define OPENSSL_assert(e) (void)((e) ? 0 : (OpenSSLDie(OPENSSL_FILE, OPENSSL_LINE, #e),1)) |
| 593 |
|
| 594 |
unsigned long *OPENSSL_ia32cap_loc(void); |
| 595 |
# define OPENSSL_ia32cap (*(OPENSSL_ia32cap_loc())) |
| 596 |
int OPENSSL_isservice(void); |
| 597 |
|
| 598 |
int FIPS_mode(void); |
| 599 |
int FIPS_mode_set(int r); |
| 600 |
|
| 601 |
void OPENSSL_init(void); |
| 602 |
|
| 603 |
# define fips_md_init(alg) fips_md_init_ctx(alg, alg) |
| 604 |
|
| 605 |
# ifdef OPENSSL_FIPS |
| 606 |
# define fips_md_init_ctx(alg, cx) \ |
| 607 |
int alg##_Init(cx##_CTX *c) \ |
| 608 |
{ \ |
| 609 |
if (FIPS_mode()) OpenSSLDie(OPENSSL_FILE, OPENSSL_LINE, \ |
| 610 |
"Low level API call to digest " #alg " forbidden in FIPS mode!"); \ |
| 611 |
return private_##alg##_Init(c); \ |
| 612 |
} \ |
| 613 |
int private_##alg##_Init(cx##_CTX *c) |
| 614 |
|
| 615 |
# define fips_cipher_abort(alg) \ |
| 616 |
if (FIPS_mode()) OpenSSLDie(OPENSSL_FILE, OPENSSL_LINE, \ |
| 617 |
"Low level API call to cipher " #alg " forbidden in FIPS mode!") |
| 618 |
|
| 619 |
# else |
| 620 |
# define fips_md_init_ctx(alg, cx) \ |
| 621 |
int alg##_Init(cx##_CTX *c) |
| 622 |
# define fips_cipher_abort(alg) while(0) |
| 623 |
# endif |
| 624 |
|
| 625 |
/* |
| 626 |
* CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. |
| 627 |
* It takes an amount of time dependent on |len|, but independent of the |
| 628 |
* contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements |
| 629 |
* into a defined order as the return value when a != b is undefined, other |
| 630 |
* than to be non-zero. |
| 631 |
*/ |
| 632 |
int CRYPTO_memcmp(const volatile void *a, const volatile void *b, size_t len); |
| 633 |
|
| 634 |
/* BEGIN ERROR CODES */ |
| 635 |
/* |
| 636 |
* The following lines are auto generated by the script mkerr.pl. Any changes |
| 637 |
* made after this point may be overwritten when the script is next run. |
| 638 |
*/ |
| 639 |
void ERR_load_CRYPTO_strings(void); |
| 640 |
|
| 641 |
/* Error codes for the CRYPTO functions. */ |
| 642 |
|
| 643 |
/* Function codes. */ |
| 644 |
# define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100 |
| 645 |
# define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID 103 |
| 646 |
# define CRYPTO_F_CRYPTO_GET_NEW_LOCKID 101 |
| 647 |
# define CRYPTO_F_CRYPTO_SET_EX_DATA 102 |
| 648 |
# define CRYPTO_F_DEF_ADD_INDEX 104 |
| 649 |
# define CRYPTO_F_DEF_GET_CLASS 105 |
| 650 |
# define CRYPTO_F_FIPS_MODE_SET 109 |
| 651 |
# define CRYPTO_F_INT_DUP_EX_DATA 106 |
| 652 |
# define CRYPTO_F_INT_FREE_EX_DATA 107 |
| 653 |
# define CRYPTO_F_INT_NEW_EX_DATA 108 |
| 654 |
|
| 655 |
/* Reason codes. */ |
| 656 |
# define CRYPTO_R_FIPS_MODE_NOT_SUPPORTED 101 |
| 657 |
# define CRYPTO_R_NO_DYNLOCK_CREATE_CALLBACK 100 |
| 658 |
|
| 659 |
#ifdef __cplusplus |
| 660 |
} |
| 661 |
#endif |
| 662 |
#endif |