OpenSSL 0.9.4 merge

1 files changed, 93 insertions, 92 deletions

diff --git a/src/lib/libcrypto/err/err.c b/src/lib/libcrypto/err/err.c
index 5aef6a1259..8810d838c6 100644
--- a/src/lib/libcrypto/err/err.c
+++ b/src/lib/libcrypto/err/err.c
@@ -57,34 +57,25 @@
  */
 
 #include <stdio.h>
-#include "lhash.h"
-#include "crypto.h"
+#include <stdarg.h>
+#include <openssl/lhash.h>
+#include <openssl/crypto.h>
 #include "cryptlib.h"
-#include "buffer.h"
-#include "err.h"
-#include "crypto.h"
+#include <openssl/buffer.h>
+#include <openssl/err.h>
+#include <openssl/crypto.h>
 
 
 static LHASH *error_hash=NULL;
 static LHASH *thread_hash=NULL;
 
-#ifndef NOPROTO
 static unsigned long err_hash(ERR_STRING_DATA *a);
 static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b);
 static unsigned long pid_hash(ERR_STATE *pid);
 static int pid_cmp(ERR_STATE *a,ERR_STATE *pid);
-static unsigned long get_error_values(int inc,char **file,int *line,
-        char **data,int *flags);
+static unsigned long get_error_values(int inc,const char **file,int *line,
+                                      const char **data,int *flags);
 static void ERR_STATE_free(ERR_STATE *s);
-#else
-static unsigned long err_hash();
-static int err_cmp();
-static unsigned long pid_hash();
-static int pid_cmp();
-static void ERR_STATE_free();
-ERR_STATE *s;
-#endif
-
 #ifndef NO_ERR
 static ERR_STRING_DATA ERR_str_libraries[]=
         {
@@ -107,6 +98,8 @@ static ERR_STRING_DATA ERR_str_libraries[]=
 {ERR_PACK(ERR_LIB_PROXY,0,0)            ,"Proxy routines"},
 {ERR_PACK(ERR_LIB_BIO,0,0)              ,"BIO routines"},
 {ERR_PACK(ERR_LIB_PKCS7,0,0)            ,"PKCS7 routines"},
+{ERR_PACK(ERR_LIB_X509V3,0,0)           ,"X509 V3 routines"},
+{ERR_PACK(ERR_LIB_PKCS12,0,0)           ,"PKCS12 routines"},
 {0,NULL},
         };
 
@@ -123,6 +116,7 @@ static ERR_STRING_DATA ERR_str_functs[]=
 #ifdef WINDOWS
         {ERR_PACK(0,SYS_F_WSASTARTUP,0),        "WSAstartup"},
 #endif
+        {ERR_PACK(0,SYS_F_OPENDIR,0),           "opendir"},
         {0,NULL},
         };
 
@@ -146,8 +140,17 @@ static ERR_STRING_DATA ERR_str_reasons[]=
 {ERR_R_PROXY_LIB                        ,"PROXY lib"},
 {ERR_R_BIO_LIB                          ,"BIO lib"},
 {ERR_R_PKCS7_LIB                        ,"PKCS7 lib"},
+{ERR_R_PKCS12_LIB                       ,"PKCS12 lib"},
 {ERR_R_MALLOC_FAILURE                   ,"Malloc failure"},
-{ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED      ,"called a fuction you should not call"},
+{ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED      ,"called a function you should not call"},
+{ERR_R_PASSED_NULL_PARAMETER            ,"passed a null parameter"},
+{ERR_R_NESTED_ASN1_ERROR                ,"nested asn1 error"},
+{ERR_R_BAD_ASN1_OBJECT_HEADER           ,"bad asn1 object header"},
+{ERR_R_BAD_GET_ASN1_OBJECT_CALL         ,"bad get asn1 object call"},
+{ERR_R_EXPECTING_AN_ASN1_SEQUENCE       ,"expecting an asn1 sequence"},
+{ERR_R_ASN1_LENGTH_MISMATCH             ,"asn1 length mismatch"},
+{ERR_R_MISSING_ASN1_EOS                 ,"missing asn1 eos"},
+
 {0,NULL},
         };
 #endif
@@ -161,11 +164,13 @@ static ERR_STRING_DATA ERR_str_reasons[]=
                 } \
         (p)->err_data_flags[i]=0;
 
-static void ERR_STATE_free(s)
-ERR_STATE *s;
+static void ERR_STATE_free(ERR_STATE *s)
         {
         int i;
 
+        if(s == NULL)
+            return;
+
         for (i=0; i<ERR_NUM_ERRORS; i++)
                 {
                 err_clear_data(s,i);
@@ -173,7 +178,7 @@ ERR_STATE *s;
         Free(s);
         }
 
-void ERR_load_ERR_strings()
+void ERR_load_ERR_strings(void)
         {
         static int init=1;
 
@@ -196,9 +201,7 @@ void ERR_load_ERR_strings()
                 }
         }
 
-void ERR_load_strings(lib,str)
-int lib;
-ERR_STRING_DATA *str;
+void ERR_load_strings(int lib, ERR_STRING_DATA *str)
         {
         if (error_hash == NULL)
                 {
@@ -224,7 +227,7 @@ ERR_STRING_DATA *str;
         CRYPTO_w_unlock(CRYPTO_LOCK_ERR_HASH);
         }
 
-void ERR_free_strings()
+void ERR_free_strings(void)
         {
         CRYPTO_w_lock(CRYPTO_LOCK_ERR);
 
@@ -239,13 +242,30 @@ void ERR_free_strings()
 
 /********************************************************/
 
-void ERR_put_error(lib,func,reason,file,line)
-int lib,func,reason;
-char *file;
-int line;
+void ERR_put_error(int lib, int func, int reason, const char *file,
+             int line)
         {
         ERR_STATE *es;
 
+#ifdef _OSD_POSIX
+        /* In the BS2000-OSD POSIX subsystem, the compiler generates
+         * path names in the form "*POSIX(/etc/passwd)".
+         * This dirty hack strips them to something sensible.
+         * @@@ We shouldn't modify a const string, though.
+         */
+        if (strncmp(file,"*POSIX(", sizeof("*POSIX(")-1) == 0) {
+                char *end;
+
+                /* Skip the "*POSIX(" prefix */
+                file += sizeof("*POSIX(")-1;
+                end = &file[strlen(file)-1];
+                if (*end == ')')
+                        *end = '\0';
+                /* Optional: use the basename of the path only. */
+                if ((end = strrchr(file, '/')) != NULL)
+                        file = &end[1];
+        }
+#endif
         es=ERR_get_state();
 
         es->top=(es->top+1)%ERR_NUM_ERRORS;
@@ -257,7 +277,7 @@ int line;
         err_clear_data(es,es->top);
         }
 
-void ERR_clear_error()
+void ERR_clear_error(void)
         {
         ERR_STATE *es;
 
@@ -277,42 +297,32 @@ void ERR_clear_error()
         }
 
 
-unsigned long ERR_get_error()
+unsigned long ERR_get_error(void)
         { return(get_error_values(1,NULL,NULL,NULL,NULL)); }
 
-unsigned long ERR_get_error_line(file,line)
-char **file;
-int *line;
+unsigned long ERR_get_error_line(const char **file,
+             int *line)
         { return(get_error_values(1,file,line,NULL,NULL)); }
 
-unsigned long ERR_get_error_line_data(file,line,data,flags)
-char **file;
-int *line;
-char **data;
-int *flags;
-        { return(get_error_values(1,file,line,data,flags)); }
+unsigned long ERR_get_error_line_data(const char **file, int *line,
+             const char **data, int *flags)
+        { return(get_error_values(1,file,line,
+             data,flags)); }
 
-unsigned long ERR_peek_error()
+unsigned long ERR_peek_error(void)
         { return(get_error_values(0,NULL,NULL,NULL,NULL)); }
 
-unsigned long ERR_peek_error_line(file,line)
-char **file;
-int *line;
+unsigned long ERR_peek_error_line(const char **file,
+             int *line)
         { return(get_error_values(0,file,line,NULL,NULL)); }
 
-unsigned long ERR_peek_error_line_data(file,line,data,flags)
-char **file;
-int *line;
-char **data;
-int *flags;
-        { return(get_error_values(0,file,line,data,flags)); }
-
-static unsigned long get_error_values(inc,file,line,data,flags)
-int inc;
-char **file;
-int *line;
-char **data;
-int *flags;
+unsigned long ERR_peek_error_line_data(const char **file, int *line,
+             const char **data, int *flags)
+        { return(get_error_values(0,file,line,
+             data,flags)); }
+
+static unsigned long get_error_values(int inc, const char **file, int *line,
+             const char **data, int *flags)
         {       
         int i=0;
         ERR_STATE *es;
@@ -361,12 +371,10 @@ int *flags;
         }
 
 /* BAD for multi-threaded, uses a local buffer if ret == NULL */
-char *ERR_error_string(e,ret)
-unsigned long e;
-char *ret;
+char *ERR_error_string(unsigned long e, char *ret)
         {
         static char buf[256];
-        char *ls,*fs,*rs;
+        const char *ls,*fs,*rs;
         unsigned long l,f,r;
         int i;
 
@@ -397,18 +405,17 @@ char *ret;
         return(ret);
         }
 
-LHASH *ERR_get_string_table()
+LHASH *ERR_get_string_table(void)
         {
         return(error_hash);
         }
 
-LHASH *ERR_get_err_state_table()
+LHASH *ERR_get_err_state_table(void)
         {
         return(thread_hash);
         }
 
-char *ERR_lib_error_string(e)
-unsigned long e;
+const char *ERR_lib_error_string(unsigned long e)
         {
         ERR_STRING_DATA d,*p=NULL;
         unsigned long l;
@@ -428,8 +435,7 @@ unsigned long e;
         return((p == NULL)?NULL:p->string);
         }
 
-char *ERR_func_error_string(e)
-unsigned long e;
+const char *ERR_func_error_string(unsigned long e)
         {
         ERR_STRING_DATA d,*p=NULL;
         unsigned long l,f;
@@ -450,8 +456,7 @@ unsigned long e;
         return((p == NULL)?NULL:p->string);
         }
 
-char *ERR_reason_error_string(e)
-unsigned long e;
+const char *ERR_reason_error_string(unsigned long e)
         {
         ERR_STRING_DATA d,*p=NULL;
         unsigned long l,r;
@@ -478,8 +483,7 @@ unsigned long e;
         return((p == NULL)?NULL:p->string);
         }
 
-static unsigned long err_hash(a)
-ERR_STRING_DATA *a;
+static unsigned long err_hash(ERR_STRING_DATA *a)
         {
         unsigned long ret,l;
 
@@ -488,26 +492,22 @@ ERR_STRING_DATA *a;
         return(ret^ret%19*13);
         }
 
-static int err_cmp(a,b)
-ERR_STRING_DATA *a,*b;
+static int err_cmp(ERR_STRING_DATA *a, ERR_STRING_DATA *b)
         {
         return((int)(a->error-b->error));
         }
 
-static unsigned long pid_hash(a)
-ERR_STATE *a;
+static unsigned long pid_hash(ERR_STATE *a)
         {
         return(a->pid*13);
         }
 
-static int pid_cmp(a,b)
-ERR_STATE *a,*b;
+static int pid_cmp(ERR_STATE *a, ERR_STATE *b)
         {
         return((int)((long)a->pid - (long)b->pid));
         }
 
-void ERR_remove_state(pid)
-unsigned long pid;
+void ERR_remove_state(unsigned long pid)
         {
         ERR_STATE *p,tmp;
 
@@ -523,7 +523,7 @@ unsigned long pid;
         if (p != NULL) ERR_STATE_free(p);
         }
 
-ERR_STATE *ERR_get_state()
+ERR_STATE *ERR_get_state(void)
         {
         static ERR_STATE fallback;
         ERR_STATE *ret=NULL,tmp,*tmpp;
@@ -539,7 +539,9 @@ ERR_STATE *ERR_get_state()
                 CRYPTO_w_lock(CRYPTO_LOCK_ERR);
                 if (thread_hash == NULL)
                         {
+                        MemCheck_off();
                         thread_hash=lh_new(pid_hash,pid_cmp);
+                        MemCheck_on();
                         CRYPTO_w_unlock(CRYPTO_LOCK_ERR);
                         if (thread_hash == NULL) return(&fallback);
                         }
@@ -577,16 +579,14 @@ ERR_STATE *ERR_get_state()
         return(ret);
         }
 
-int ERR_get_next_error_library()
+int ERR_get_next_error_library(void)
         {
         static int value=ERR_LIB_USER;
 
         return(value++);
         }
 
-void ERR_set_error_data(data,flags)
-char *data;
-int flags;
+void ERR_set_error_data(char *data, int flags)
         {
         ERR_STATE *es;
         int i;
@@ -601,10 +601,9 @@ int flags;
         es->err_data_flags[es->top]=flags;
         }
 
-void ERR_add_error_data( VAR_PLIST(int , num))
-VAR_ALIST
-        {
-        VAR_BDEFN(args, int, num);
+void ERR_add_error_data(int num, ...)
+        {
+        va_list args;
         int i,n,s;
         char *str,*p,*a;
 
@@ -613,12 +612,14 @@ VAR_ALIST
         if (str == NULL) return;
         str[0]='\0';
 
-        VAR_INIT(args,int,num);
+        va_start(args, num);
         n=0;
         for (i=0; i<num; i++)
                 {
-                VAR_ARG(args,char *,a);
-                if (a != NULL) {
+                a=va_arg(args, char*);
+                /* ignore NULLs, thanks to Bob Beck <beck@obtuse.com> */
+                if (a != NULL)
+                        {
                         n+=strlen(a);
                         if (n > s)
                                 {
@@ -637,6 +638,6 @@ VAR_ALIST
                 }
         ERR_set_error_data(str,ERR_TXT_MALLOCED|ERR_TXT_STRING);
 
-        VAR_END( args );
+        va_end(args);
         }