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