This changes the "ERR" code to have all access to state (a hash table of
[openssl.git] / crypto / err / err.c
1 /* crypto/err/err.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58 /* ====================================================================
59  * Copyright (c) 1998-2000 The OpenSSL Project.  All rights reserved.
60  *
61  * Redistribution and use in source and binary forms, with or without
62  * modification, are permitted provided that the following conditions
63  * are met:
64  *
65  * 1. Redistributions of source code must retain the above copyright
66  *    notice, this list of conditions and the following disclaimer. 
67  *
68  * 2. Redistributions in binary form must reproduce the above copyright
69  *    notice, this list of conditions and the following disclaimer in
70  *    the documentation and/or other materials provided with the
71  *    distribution.
72  *
73  * 3. All advertising materials mentioning features or use of this
74  *    software must display the following acknowledgment:
75  *    "This product includes software developed by the OpenSSL Project
76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77  *
78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79  *    endorse or promote products derived from this software without
80  *    prior written permission. For written permission, please contact
81  *    openssl-core@openssl.org.
82  *
83  * 5. Products derived from this software may not be called "OpenSSL"
84  *    nor may "OpenSSL" appear in their names without prior written
85  *    permission of the OpenSSL Project.
86  *
87  * 6. Redistributions of any form whatsoever must retain the following
88  *    acknowledgment:
89  *    "This product includes software developed by the OpenSSL Project
90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91  *
92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103  * OF THE POSSIBILITY OF SUCH DAMAGE.
104  * ====================================================================
105  *
106  * This product includes cryptographic software written by Eric Young
107  * (eay@cryptsoft.com).  This product includes software written by Tim
108  * Hudson (tjh@cryptsoft.com).
109  *
110  */
111
112 #include <stdio.h>
113 #include <stdarg.h>
114 #include <string.h>
115 #include <openssl/lhash.h>
116 #include <openssl/crypto.h>
117 #include "cryptlib.h"
118 #include <openssl/buffer.h>
119 #include <openssl/bio.h>
120 #include <openssl/err.h>
121
122 static void ERR_STATE_free(ERR_STATE *s);
123 #ifndef OPENSSL_NO_ERR
124 static ERR_STRING_DATA ERR_str_libraries[]=
125         {
126 {ERR_PACK(ERR_LIB_NONE,0,0)             ,"unknown library"},
127 {ERR_PACK(ERR_LIB_SYS,0,0)              ,"system library"},
128 {ERR_PACK(ERR_LIB_BN,0,0)               ,"bignum routines"},
129 {ERR_PACK(ERR_LIB_RSA,0,0)              ,"rsa routines"},
130 {ERR_PACK(ERR_LIB_DH,0,0)               ,"Diffie-Hellman routines"},
131 {ERR_PACK(ERR_LIB_EVP,0,0)              ,"digital envelope routines"},
132 {ERR_PACK(ERR_LIB_BUF,0,0)              ,"memory buffer routines"},
133 {ERR_PACK(ERR_LIB_OBJ,0,0)              ,"object identifier routines"},
134 {ERR_PACK(ERR_LIB_PEM,0,0)              ,"PEM routines"},
135 {ERR_PACK(ERR_LIB_DSA,0,0)              ,"dsa routines"},
136 {ERR_PACK(ERR_LIB_X509,0,0)             ,"x509 certificate routines"},
137 {ERR_PACK(ERR_LIB_ASN1,0,0)             ,"asn1 encoding routines"},
138 {ERR_PACK(ERR_LIB_CONF,0,0)             ,"configuration file routines"},
139 {ERR_PACK(ERR_LIB_CRYPTO,0,0)           ,"common libcrypto routines"},
140 {ERR_PACK(ERR_LIB_EC,0,0)               ,"elliptic curve routines"},
141 {ERR_PACK(ERR_LIB_SSL,0,0)              ,"SSL routines"},
142 {ERR_PACK(ERR_LIB_BIO,0,0)              ,"BIO routines"},
143 {ERR_PACK(ERR_LIB_PKCS7,0,0)            ,"PKCS7 routines"},
144 {ERR_PACK(ERR_LIB_X509V3,0,0)           ,"X509 V3 routines"},
145 {ERR_PACK(ERR_LIB_PKCS12,0,0)           ,"PKCS12 routines"},
146 {ERR_PACK(ERR_LIB_RAND,0,0)             ,"random number generator"},
147 {ERR_PACK(ERR_LIB_DSO,0,0)              ,"DSO support routines"},
148 {ERR_PACK(ERR_LIB_ENGINE,0,0)           ,"engine routines"},
149 {ERR_PACK(ERR_LIB_OCSP,0,0)             ,"OCSP routines"},
150 {0,NULL},
151         };
152
153 static ERR_STRING_DATA ERR_str_functs[]=
154         {
155         {ERR_PACK(0,SYS_F_FOPEN,0),             "fopen"},
156         {ERR_PACK(0,SYS_F_CONNECT,0),           "connect"},
157         {ERR_PACK(0,SYS_F_GETSERVBYNAME,0),     "getservbyname"},
158         {ERR_PACK(0,SYS_F_SOCKET,0),            "socket"}, 
159         {ERR_PACK(0,SYS_F_IOCTLSOCKET,0),       "ioctlsocket"},
160         {ERR_PACK(0,SYS_F_BIND,0),              "bind"},
161         {ERR_PACK(0,SYS_F_LISTEN,0),            "listen"},
162         {ERR_PACK(0,SYS_F_ACCEPT,0),            "accept"},
163 #ifdef OPENSSL_SYS_WINDOWS
164         {ERR_PACK(0,SYS_F_WSASTARTUP,0),        "WSAstartup"},
165 #endif
166         {ERR_PACK(0,SYS_F_OPENDIR,0),           "opendir"},
167         {0,NULL},
168         };
169
170 static ERR_STRING_DATA ERR_str_reasons[]=
171         {
172 {ERR_R_SYS_LIB                          ,"system lib"},
173 {ERR_R_BN_LIB                           ,"BN lib"},
174 {ERR_R_RSA_LIB                          ,"RSA lib"},
175 {ERR_R_DH_LIB                           ,"DH lib"},
176 {ERR_R_EVP_LIB                          ,"EVP lib"},
177 {ERR_R_BUF_LIB                          ,"BUF lib"},
178 {ERR_R_OBJ_LIB                          ,"OBJ lib"},
179 {ERR_R_PEM_LIB                          ,"PEM lib"},
180 {ERR_R_DSA_LIB                          ,"DSA lib"},
181 {ERR_R_X509_LIB                         ,"X509 lib"},
182 {ERR_R_ASN1_LIB                         ,"ASN1 lib"},
183 {ERR_R_CONF_LIB                         ,"CONF lib"},
184 {ERR_R_CRYPTO_LIB                       ,"CRYPTO lib"},
185 {ERR_R_EC_LIB                           ,"EC lib"},
186 {ERR_R_SSL_LIB                          ,"SSL lib"},
187 {ERR_R_BIO_LIB                          ,"BIO lib"},
188 {ERR_R_PKCS7_LIB                        ,"PKCS7 lib"},
189 {ERR_R_X509V3_LIB                       ,"X509V3 lib"},
190 {ERR_R_PKCS12_LIB                       ,"PKCS12 lib"},
191 {ERR_R_RAND_LIB                         ,"RAND lib"},
192 {ERR_R_DSO_LIB                          ,"DSO lib"},
193 {ERR_R_ENGINE_LIB                       ,"ENGINE lib"},
194 {ERR_R_OCSP_LIB                         ,"OCSP lib"},
195
196 {ERR_R_NESTED_ASN1_ERROR                ,"nested asn1 error"},
197 {ERR_R_BAD_ASN1_OBJECT_HEADER           ,"bad asn1 object header"},
198 {ERR_R_BAD_GET_ASN1_OBJECT_CALL         ,"bad get asn1 object call"},
199 {ERR_R_EXPECTING_AN_ASN1_SEQUENCE       ,"expecting an asn1 sequence"},
200 {ERR_R_ASN1_LENGTH_MISMATCH             ,"asn1 length mismatch"},
201 {ERR_R_MISSING_ASN1_EOS                 ,"missing asn1 eos"},
202
203 {ERR_R_FATAL                            ,"fatal"},
204 {ERR_R_MALLOC_FAILURE                   ,"malloc failure"},
205 {ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED      ,"called a function you should not call"},
206 {ERR_R_PASSED_NULL_PARAMETER            ,"passed a null parameter"},
207 {ERR_R_INTERNAL_ERROR                   ,"internal error"},
208
209 {0,NULL},
210         };
211
212
213 /* Define the predeclared (but externally opaque) "ERR_FNS" type */
214 struct st_ERR_FNS
215         {
216         /* Works on the "error_hash" string table */
217         LHASH *(*cb_err_get)(void);
218         void (*cb_err_del)(void);
219         ERR_STRING_DATA *(*cb_err_get_item)(const ERR_STRING_DATA *);
220         ERR_STRING_DATA *(*cb_err_set_item)(ERR_STRING_DATA *);
221         /* Works on the "thread_hash" error-state table */
222         LHASH *(*cb_thread_get)(void);
223         ERR_STATE *(*cb_thread_get_item)(const ERR_STATE *);
224         ERR_STATE *(*cb_thread_set_item)(ERR_STATE *);
225         void (*cb_thread_del_item)(const ERR_STATE *);
226         /* Returns the next available error "library" numbers */
227         int (*cb_get_next_lib)(void);
228         };
229
230 /* Predeclarations of the "err_defaults" functions */
231 static LHASH *int_err_get(void);
232 static void int_err_del(void);
233 static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *);
234 static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *);
235 static LHASH *int_thread_get(void);
236 static ERR_STATE *int_thread_get_item(const ERR_STATE *);
237 static ERR_STATE *int_thread_set_item(ERR_STATE *);
238 static void int_thread_del_item(const ERR_STATE *);
239 static int int_err_get_next_lib(void);
240 /* The static ERR_FNS table using these defaults functions */
241 static const ERR_FNS err_defaults =
242         {
243         int_err_get,
244         int_err_del,
245         int_err_get_item,
246         int_err_set_item,
247         int_thread_get,
248         int_thread_get_item,
249         int_thread_set_item,
250         int_thread_del_item,
251         int_err_get_next_lib
252         };
253
254 /* The replacable table of ERR_FNS functions we use at run-time */
255 static const ERR_FNS *err_fns = NULL;
256
257 /* Eg. rather than using "err_get()", use "ERRFN(err_get)()". */
258 #define ERRFN(a) err_fns->cb_##a
259
260 /* The internal state used by "err_defaults" - as such, the setting, reading,
261  * creating, and deleting of this data should only be permitted via the
262  * "err_defaults" functions. This way, a linked module can completely defer all
263  * ERR state operation (together with requisite locking) to the implementations
264  * and state in the loading application. */
265 static LHASH *int_error_hash;
266 static int int_error_hash_set = 0;
267 static LHASH *int_thread_hash;
268 static int int_thread_hash_set = 0;
269 static int int_err_library_number=ERR_LIB_USER;
270
271 /* Internal function that checks whether "err_fns" is set and if not, sets it to
272  * the defaults. */
273 static void err_fns_check(void)
274         {
275         CRYPTO_w_lock(CRYPTO_LOCK_ERR);
276         if(!err_fns)
277                 err_fns = &err_defaults;
278         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
279         }
280
281 /* API functions to get or set the underlying ERR functions. */
282
283 const ERR_FNS *ERR_get_implementation(void)
284         {
285         err_fns_check();
286         return err_fns;
287         }
288
289 int ERR_set_implementation(const ERR_FNS *fns)
290         {
291         int toret = 0;
292         CRYPTO_w_lock(CRYPTO_LOCK_ERR);
293         /* It's too late if 'err_fns' is non-NULL. BTW: not much point setting
294          * an error is there?! */
295         if(!err_fns)
296                 {
297                 err_fns = fns;
298                 toret = 1;
299                 }
300         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
301         return toret;
302         }
303
304 /* These are the callbacks provided to "lh_new()" when creating the LHASH tables
305  * internal to the "err_defaults" implementation. */
306
307 /* static unsigned long err_hash(ERR_STRING_DATA *a); */
308 static unsigned long err_hash(const void *a_void);
309 /* static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b); */
310 static int err_cmp(const void *a_void, const void *b_void);
311 /* static unsigned long pid_hash(ERR_STATE *pid); */
312 static unsigned long pid_hash(const void *pid_void);
313 /* static int pid_cmp(ERR_STATE *a,ERR_STATE *pid); */
314 static int pid_cmp(const void *a_void,const void *pid_void);
315 static unsigned long get_error_values(int inc,const char **file,int *line,
316                                       const char **data,int *flags);
317
318 /* The internal functions used in the "err_defaults" implementation */
319
320 static LHASH *int_err_get(void)
321         {
322         LHASH *toret = NULL;
323         CRYPTO_w_lock(CRYPTO_LOCK_ERR);
324         if(!int_error_hash_set)
325                 int_error_hash = lh_new(err_hash, err_cmp);
326         if(int_error_hash)
327                 {
328                 int_error_hash_set = 1;
329                 toret = int_error_hash;
330                 }
331         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
332         return(toret);
333         }
334 static void int_err_del(void)
335         {
336         CRYPTO_w_lock(CRYPTO_LOCK_ERR);
337         if(int_error_hash_set)
338                 {
339                 lh_free(int_error_hash);
340                 int_error_hash = NULL;
341                 int_error_hash_set = 0;
342                 }
343         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
344         }
345 static ERR_STRING_DATA *int_err_get_item(const ERR_STRING_DATA *d)
346         {
347         ERR_STRING_DATA *p;
348         LHASH *hash;
349         err_fns_check();
350         hash = ERRFN(err_get)();
351         if(!hash)
352                 return NULL;
353         CRYPTO_r_lock(CRYPTO_LOCK_ERR);
354         p = (ERR_STRING_DATA *)lh_retrieve(hash, d);
355         CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
356         return p;
357         }
358 static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d)
359         {
360         ERR_STRING_DATA *p;
361         LHASH *hash;
362         err_fns_check();
363         hash = ERRFN(err_get)();
364         if(!hash)
365                 return NULL;
366         CRYPTO_r_lock(CRYPTO_LOCK_ERR);
367         p = (ERR_STRING_DATA *)lh_insert(hash, d);
368         CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
369         return p;
370         }
371 static LHASH *int_thread_get(void)
372         {
373         LHASH *toret = NULL;
374         CRYPTO_w_lock(CRYPTO_LOCK_ERR);
375         if(!int_thread_hash_set)
376                 int_thread_hash = lh_new(pid_hash, pid_cmp);
377         if(int_thread_hash)
378                 {
379                 int_thread_hash_set = 1;
380                 toret = int_thread_hash;
381                 }
382         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
383         return(toret);
384         }
385 static ERR_STATE *int_thread_get_item(const ERR_STATE *d)
386         {
387         ERR_STATE *p;
388         LHASH *hash;
389         err_fns_check();
390         hash = ERRFN(thread_get)();
391         if(!hash)
392                 return NULL;
393         CRYPTO_r_lock(CRYPTO_LOCK_ERR);
394         p = (ERR_STATE *)lh_retrieve(hash, d);
395         CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
396         return p;
397         }
398 static ERR_STATE *int_thread_set_item(ERR_STATE *d)
399         {
400         ERR_STATE *p;
401         LHASH *hash;
402         err_fns_check();
403         hash = ERRFN(thread_get)();
404         if(!hash)
405                 return NULL;
406         CRYPTO_r_lock(CRYPTO_LOCK_ERR);
407         p = (ERR_STATE *)lh_insert(hash, d);
408         CRYPTO_r_unlock(CRYPTO_LOCK_ERR);
409         return p;
410         }
411 static void int_thread_del_item(const ERR_STATE *d)
412         {
413         ERR_STATE *p;
414         LHASH *hash;
415         err_fns_check();
416         hash = ERRFN(thread_get)();
417         if(!hash)
418                 return;
419         CRYPTO_w_lock(CRYPTO_LOCK_ERR);
420         p = (ERR_STATE *)lh_delete(hash, d);
421         /* make sure we don't leak memory */
422         if(int_thread_hash_set && (lh_num_items(int_thread_hash) == 0))
423                 {
424                 lh_free(int_thread_hash);
425                 int_thread_hash = NULL;
426                 int_thread_hash_set = 0;
427                 }
428         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
429         if(p)
430                 ERR_STATE_free(p);
431         }
432 static int int_err_get_next_lib(void)
433         {
434         int toret;
435         CRYPTO_w_lock(CRYPTO_LOCK_ERR);
436         toret = int_err_library_number++;
437         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
438         return toret;
439         }
440
441
442 #define NUM_SYS_STR_REASONS 127
443 #define LEN_SYS_STR_REASON 32
444
445 static ERR_STRING_DATA SYS_str_reasons[NUM_SYS_STR_REASONS + 1];
446 /* SYS_str_reasons is filled with copies of strerror() results at
447  * initialization.
448  * 'errno' values up to 127 should cover all usual errors,
449  * others will be displayed numerically by ERR_error_string.
450  * It is crucial that we have something for each reason code
451  * that occurs in ERR_str_reasons, or bogus reason strings
452  * will be returned for SYSerr(), which always gets an errno
453  * value and never one of those 'standard' reason codes. */
454
455 static void build_SYS_str_reasons()
456         {
457         /* OPENSSL_malloc cannot be used here, use static storage instead */
458         static char strerror_tab[NUM_SYS_STR_REASONS][LEN_SYS_STR_REASON];
459         int i;
460
461         CRYPTO_w_lock(CRYPTO_LOCK_ERR_HASH);
462
463         for (i = 1; i <= NUM_SYS_STR_REASONS; i++)
464                 {
465                 ERR_STRING_DATA *str = &SYS_str_reasons[i - 1];
466
467                 str->error = (unsigned long)i;
468                 if (str->string == NULL)
469                         {
470                         char (*dest)[LEN_SYS_STR_REASON] = &(strerror_tab[i - 1]);
471                         char *src = strerror(i);
472                         if (src != NULL)
473                                 {
474                                 strncpy(*dest, src, sizeof *dest);
475                                 (*dest)[sizeof *dest - 1] = '\0';
476                                 str->string = *dest;
477                                 }
478                         }
479                 if (str->string == NULL)
480                         str->string = "unknown";
481                 }
482
483         /* Now we still have SYS_str_reasons[NUM_SYS_STR_REASONS] = {0, NULL},
484          * as required by ERR_load_strings. */
485
486         CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
487         }
488 #endif
489
490 #define err_clear_data(p,i) \
491         if (((p)->err_data[i] != NULL) && \
492                 (p)->err_data_flags[i] & ERR_TXT_MALLOCED) \
493                 {  \
494                 OPENSSL_free((p)->err_data[i]); \
495                 (p)->err_data[i]=NULL; \
496                 } \
497         (p)->err_data_flags[i]=0;
498
499 static void ERR_STATE_free(ERR_STATE *s)
500         {
501         int i;
502
503         if(s == NULL)
504             return;
505
506         for (i=0; i<ERR_NUM_ERRORS; i++)
507                 {
508                 err_clear_data(s,i);
509                 }
510         OPENSSL_free(s);
511         }
512
513 void ERR_load_ERR_strings(void)
514         {
515         static int init=1;
516
517         if (init)
518                 {
519                 init=0;
520                 /* We put the first-time check code here to reduce the number of
521                  * times it is called (then it doesn't get called from
522                  * ERR_load_strings() loads of times). */
523                 err_fns_check();
524 #ifndef OPENSSL_NO_ERR
525                 ERR_load_strings(0,ERR_str_libraries);
526                 ERR_load_strings(0,ERR_str_reasons);
527                 ERR_load_strings(ERR_LIB_SYS,ERR_str_functs);
528                 build_SYS_str_reasons();
529                 ERR_load_strings(ERR_LIB_SYS,SYS_str_reasons);
530 #endif
531                 }
532         }
533
534 void ERR_load_strings(int lib, ERR_STRING_DATA *str)
535         {
536         /* Do this if it hasn't been done already (NB: The order of the "init=0"
537          * statement and the recursive calls back to this function prevent a
538          * loop). */
539         ERR_load_ERR_strings();
540         while (str->error)
541                 {
542                 str->error|=ERR_PACK(lib,0,0);
543                 ERRFN(err_set_item)(str);
544                 str++;
545                 }
546         }
547
548 void ERR_free_strings(void)
549         {
550         err_fns_check();
551         ERRFN(err_del)();
552         }
553
554 /********************************************************/
555
556 void ERR_put_error(int lib, int func, int reason, const char *file,
557              int line)
558         {
559         ERR_STATE *es;
560
561 #ifdef _OSD_POSIX
562         /* In the BS2000-OSD POSIX subsystem, the compiler generates
563          * path names in the form "*POSIX(/etc/passwd)".
564          * This dirty hack strips them to something sensible.
565          * @@@ We shouldn't modify a const string, though.
566          */
567         if (strncmp(file,"*POSIX(", sizeof("*POSIX(")-1) == 0) {
568                 char *end;
569
570                 /* Skip the "*POSIX(" prefix */
571                 file += sizeof("*POSIX(")-1;
572                 end = &file[strlen(file)-1];
573                 if (*end == ')')
574                         *end = '\0';
575                 /* Optional: use the basename of the path only. */
576                 if ((end = strrchr(file, '/')) != NULL)
577                         file = &end[1];
578         }
579 #endif
580         es=ERR_get_state();
581
582         es->top=(es->top+1)%ERR_NUM_ERRORS;
583         if (es->top == es->bottom)
584                 es->bottom=(es->bottom+1)%ERR_NUM_ERRORS;
585         es->err_buffer[es->top]=ERR_PACK(lib,func,reason);
586         es->err_file[es->top]=file;
587         es->err_line[es->top]=line;
588         err_clear_data(es,es->top);
589         }
590
591 void ERR_clear_error(void)
592         {
593         int i;
594         ERR_STATE *es;
595
596         es=ERR_get_state();
597
598         for (i=0; i<ERR_NUM_ERRORS; i++)
599                 {
600                 es->err_buffer[i]=0;
601                 err_clear_data(es,i);
602                 es->err_file[i]=NULL;
603                 es->err_line[i]= -1;
604                 }
605         es->top=es->bottom=0;
606         }
607
608
609 unsigned long ERR_get_error(void)
610         { return(get_error_values(1,NULL,NULL,NULL,NULL)); }
611
612 unsigned long ERR_get_error_line(const char **file,
613              int *line)
614         { return(get_error_values(1,file,line,NULL,NULL)); }
615
616 unsigned long ERR_get_error_line_data(const char **file, int *line,
617              const char **data, int *flags)
618         { return(get_error_values(1,file,line,
619              data,flags)); }
620
621 unsigned long ERR_peek_error(void)
622         { return(get_error_values(0,NULL,NULL,NULL,NULL)); }
623
624 unsigned long ERR_peek_error_line(const char **file,
625              int *line)
626         { return(get_error_values(0,file,line,NULL,NULL)); }
627
628 unsigned long ERR_peek_error_line_data(const char **file, int *line,
629              const char **data, int *flags)
630         { return(get_error_values(0,file,line,
631              data,flags)); }
632
633 static unsigned long get_error_values(int inc, const char **file, int *line,
634              const char **data, int *flags)
635         {       
636         int i=0;
637         ERR_STATE *es;
638         unsigned long ret;
639
640         es=ERR_get_state();
641
642         if (es->bottom == es->top) return(0);
643         i=(es->bottom+1)%ERR_NUM_ERRORS;
644
645         ret=es->err_buffer[i];
646         if (inc)
647                 {
648                 es->bottom=i;
649                 es->err_buffer[i]=0;
650                 }
651
652         if ((file != NULL) && (line != NULL))
653                 {
654                 if (es->err_file[i] == NULL)
655                         {
656                         *file="NA";
657                         if (line != NULL) *line=0;
658                         }
659                 else
660                         {
661                         *file=es->err_file[i];
662                         if (line != NULL) *line=es->err_line[i];
663                         }
664                 }
665
666         if (data == NULL)
667                 {
668                 if (inc)
669                         {
670                         err_clear_data(es, i);
671                         }
672                 }
673         else
674                 {
675                 if (es->err_data[i] == NULL)
676                         {
677                         *data="";
678                         if (flags != NULL) *flags=0;
679                         }
680                 else
681                         {
682                         *data=es->err_data[i];
683                         if (flags != NULL) *flags=es->err_data_flags[i];
684                         }
685                 }
686         return(ret);
687         }
688
689 void ERR_error_string_n(unsigned long e, char *buf, size_t len)
690         {
691         char lsbuf[64], fsbuf[64], rsbuf[64];
692         const char *ls,*fs,*rs;
693         unsigned long l,f,r;
694
695         l=ERR_GET_LIB(e);
696         f=ERR_GET_FUNC(e);
697         r=ERR_GET_REASON(e);
698
699         ls=ERR_lib_error_string(e);
700         fs=ERR_func_error_string(e);
701         rs=ERR_reason_error_string(e);
702
703         if (ls == NULL) 
704                 BIO_snprintf(lsbuf, sizeof(lsbuf), "lib(%lu)", l);
705         if (fs == NULL)
706                 BIO_snprintf(fsbuf, sizeof(fsbuf), "func(%lu)", f);
707         if (rs == NULL)
708                 BIO_snprintf(rsbuf, sizeof(rsbuf), "reason(%lu)", r);
709
710         BIO_snprintf(buf, len,"error:%08lX:%s:%s:%s", e, ls?ls:lsbuf, 
711                 fs?fs:fsbuf, rs?rs:rsbuf);
712         if (strlen(buf) == len-1)
713                 {
714                 /* output may be truncated; make sure we always have 5 
715                  * colon-separated fields, i.e. 4 colons ... */
716 #define NUM_COLONS 4
717                 if (len > NUM_COLONS) /* ... if possible */
718                         {
719                         int i;
720                         char *s = buf;
721                         
722                         for (i = 0; i < NUM_COLONS; i++)
723                                 {
724                                 char *colon = strchr(s, ':');
725                                 if (colon == NULL || colon > &buf[len-1] - NUM_COLONS + i)
726                                         {
727                                         /* set colon no. i at last possible position
728                                          * (buf[len-1] is the terminating 0)*/
729                                         colon = &buf[len-1] - NUM_COLONS + i;
730                                         *colon = ':';
731                                         }
732                                 s = colon + 1;
733                                 }
734                         }
735                 }
736         }
737
738 /* BAD for multi-threading: uses a local buffer if ret == NULL */
739 /* ERR_error_string_n should be used instead for ret != NULL
740  * as ERR_error_string cannot know how large the buffer is */
741 char *ERR_error_string(unsigned long e, char *ret)
742         {
743         static char buf[256];
744
745         if (ret == NULL) ret=buf;
746         ERR_error_string_n(e, ret, 256);
747
748         return(ret);
749         }
750
751 LHASH *ERR_get_string_table(void)
752         {
753         err_fns_check();
754         return ERRFN(err_get)();
755         }
756
757 LHASH *ERR_get_err_state_table(void)
758         {
759         err_fns_check();
760         return ERRFN(thread_get)();
761         }
762
763 const char *ERR_lib_error_string(unsigned long e)
764         {
765         ERR_STRING_DATA d,*p;
766         unsigned long l;
767
768         err_fns_check();
769         l=ERR_GET_LIB(e);
770         d.error=ERR_PACK(l,0,0);
771         p=ERRFN(err_get_item)(&d);
772         return((p == NULL)?NULL:p->string);
773         }
774
775 const char *ERR_func_error_string(unsigned long e)
776         {
777         ERR_STRING_DATA d,*p;
778         unsigned long l,f;
779
780         err_fns_check();
781         l=ERR_GET_LIB(e);
782         f=ERR_GET_FUNC(e);
783         d.error=ERR_PACK(l,f,0);
784         p=ERRFN(err_get_item)(&d);
785         return((p == NULL)?NULL:p->string);
786         }
787
788 const char *ERR_reason_error_string(unsigned long e)
789         {
790         ERR_STRING_DATA d,*p=NULL;
791         unsigned long l,r;
792
793         err_fns_check();
794         l=ERR_GET_LIB(e);
795         r=ERR_GET_REASON(e);
796         d.error=ERR_PACK(l,0,r);
797         p=ERRFN(err_get_item)(&d);
798         if(!p)
799                 {
800                 d.error=ERR_PACK(0,0,r);
801                 p=ERRFN(err_get_item)(&d);
802                 }
803         return((p == NULL)?NULL:p->string);
804         }
805
806 /* static unsigned long err_hash(ERR_STRING_DATA *a) */
807 static unsigned long err_hash(const void *a_void)
808         {
809         unsigned long ret,l;
810
811         l=((ERR_STRING_DATA *)a_void)->error;
812         ret=l^ERR_GET_LIB(l)^ERR_GET_FUNC(l);
813         return(ret^ret%19*13);
814         }
815
816 /* static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b) */
817 static int err_cmp(const void *a_void, const void *b_void)
818         {
819         return((int)(((ERR_STRING_DATA *)a_void)->error -
820                         ((ERR_STRING_DATA *)b_void)->error));
821         }
822
823 /* static unsigned long pid_hash(ERR_STATE *a) */
824 static unsigned long pid_hash(const void *a_void)
825         {
826         return(((ERR_STATE *)a_void)->pid*13);
827         }
828
829 /* static int pid_cmp(ERR_STATE *a, ERR_STATE *b) */
830 static int pid_cmp(const void *a_void, const void *b_void)
831         {
832         return((int)((long)((ERR_STATE *)a_void)->pid -
833                         (long)((ERR_STATE *)b_void)->pid));
834         }
835
836 void ERR_remove_state(unsigned long pid)
837         {
838         ERR_STATE tmp;
839         err_fns_check();
840         if (pid == 0)
841                 pid=(unsigned long)CRYPTO_thread_id();
842         tmp.pid=pid;
843         /* thread_del_item automatically destroys the LHASH if the number of
844          * items reaches zero. */
845         ERRFN(thread_del_item)(&tmp);
846         }
847
848 ERR_STATE *ERR_get_state(void)
849         {
850         static ERR_STATE fallback;
851         ERR_STATE *ret,tmp,*tmpp=NULL;
852         int i;
853         unsigned long pid;
854         err_fns_check();
855         pid=(unsigned long)CRYPTO_thread_id();
856         tmp.pid=pid;
857         ret=ERRFN(thread_get_item)(&tmp);
858
859         /* ret == the error state, if NULL, make a new one */
860         if (ret == NULL)
861                 {
862                 ret=(ERR_STATE *)OPENSSL_malloc(sizeof(ERR_STATE));
863                 if (ret == NULL) return(&fallback);
864                 ret->pid=pid;
865                 ret->top=0;
866                 ret->bottom=0;
867                 for (i=0; i<ERR_NUM_ERRORS; i++)
868                         {
869                         ret->err_data[i]=NULL;
870                         ret->err_data_flags[i]=0;
871                         }
872                 tmpp = ERRFN(thread_set_item)(ret);
873                 /* To check if insertion failed, do a get. */
874                 if(ERRFN(thread_get_item)(ret) != ret)
875                         {
876                         ERR_STATE_free(ret); /* could not insert it */
877                         return(&fallback);
878                         }
879                 /* If a race occured in this function and we came second, tmpp
880                  * is the first one that we just replaced. */
881                 if(tmpp)
882                         ERR_STATE_free(tmpp);
883                 }
884         return(ret);
885         }
886
887 int ERR_get_next_error_library(void)
888         {
889         err_fns_check();
890         return ERRFN(get_next_lib)();
891         }
892
893 void ERR_set_error_data(char *data, int flags)
894         {
895         ERR_STATE *es;
896         int i;
897
898         es=ERR_get_state();
899
900         i=es->top;
901         if (i == 0)
902                 i=ERR_NUM_ERRORS-1;
903
904         err_clear_data(es,i);
905         es->err_data[i]=data;
906         es->err_data_flags[i]=flags;
907         }
908
909 void ERR_add_error_data(int num, ...)
910         {
911         va_list args;
912         int i,n,s;
913         char *str,*p,*a;
914
915         s=80;
916         str=OPENSSL_malloc(s+1);
917         if (str == NULL) return;
918         str[0]='\0';
919
920         va_start(args, num);
921         n=0;
922         for (i=0; i<num; i++)
923                 {
924                 a=va_arg(args, char*);
925                 /* ignore NULLs, thanks to Bob Beck <beck@obtuse.com> */
926                 if (a != NULL)
927                         {
928                         n+=strlen(a);
929                         if (n > s)
930                                 {
931                                 s=n+20;
932                                 p=OPENSSL_realloc(str,s+1);
933                                 if (p == NULL)
934                                         {
935                                         OPENSSL_free(str);
936                                         return;
937                                         }
938                                 else
939                                         str=p;
940                                 }
941                         strcat(str,a);
942                         }
943                 }
944         ERR_set_error_data(str,ERR_TXT_MALLOCED|ERR_TXT_STRING);
945
946         va_end(args);
947         }
948