8 files changed, 686 insertions, 260 deletions

diff --git a/src/lib/libcrypto/conf/conf.h b/src/lib/libcrypto/conf/conf.h
index 1446226a16..3c03fb19c0 100644
--- a/src/lib/libcrypto/conf/conf.h
+++ b/src/lib/libcrypto/conf/conf.h
@@ -59,13 +59,16 @@
 #ifndef  HEADER_CONF_H
 #define HEADER_CONF_H
 
+#include <openssl/bio.h>
+#include <openssl/lhash.h>
+#include <openssl/stack.h>
+#include <openssl/safestack.h>
+#include <openssl/e_os2.h>
+
 #ifdef  __cplusplus
 extern "C" {
 #endif
 
-#include "stack.h"
-#include "lhash.h"
-
 typedef struct
         {
         char *section;
@@ -73,42 +76,173 @@ typedef struct
         char *value;
         } CONF_VALUE;
 
-#ifndef NOPROTO
+DECLARE_STACK_OF(CONF_VALUE)
+DECLARE_STACK_OF(CONF_MODULE)
+DECLARE_STACK_OF(CONF_IMODULE)
+
+struct conf_st;
+typedef struct conf_st CONF;
+struct conf_method_st;
+typedef struct conf_method_st CONF_METHOD;
+
+struct conf_method_st
+        {
+        const char *name;
+        CONF *(*create)(CONF_METHOD *meth);
+        int (*init)(CONF *conf);
+        int (*destroy)(CONF *conf);
+        int (*destroy_data)(CONF *conf);
+        int (*load_bio)(CONF *conf, BIO *bp, long *eline);
+        int (*dump)(const CONF *conf, BIO *bp);
+        int (*is_number)(const CONF *conf, char c);
+        int (*to_int)(const CONF *conf, char c);
+        int (*load)(CONF *conf, const char *name, long *eline);
+        };
+
+/* Module definitions */
+
+typedef struct conf_imodule_st CONF_IMODULE;
+typedef struct conf_module_st CONF_MODULE;
 
-LHASH *CONF_load(LHASH *conf,char *file,long *eline);
-STACK *CONF_get_section(LHASH *conf,char *section);
-char *CONF_get_string(LHASH *conf,char *group,char *name);
-long CONF_get_number(LHASH *conf,char *group,char *name);
+/* DSO module function typedefs */
+typedef int conf_init_func(CONF_IMODULE *md, const CONF *cnf);
+typedef void conf_finish_func(CONF_IMODULE *md);
+
+#define CONF_MFLAGS_IGNORE_ERRORS       0x1
+#define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2
+#define CONF_MFLAGS_SILENT              0x4
+#define CONF_MFLAGS_NO_DSO              0x8
+#define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10
+
+int CONF_set_default_method(CONF_METHOD *meth);
+void CONF_set_nconf(CONF *conf,LHASH *hash);
+LHASH *CONF_load(LHASH *conf,const char *file,long *eline);
+#ifndef OPENSSL_NO_FP_API
+LHASH *CONF_load_fp(LHASH *conf, FILE *fp,long *eline);
+#endif
+LHASH *CONF_load_bio(LHASH *conf, BIO *bp,long *eline);
+STACK_OF(CONF_VALUE) *CONF_get_section(LHASH *conf,const char *section);
+char *CONF_get_string(LHASH *conf,const char *group,const char *name);
+long CONF_get_number(LHASH *conf,const char *group,const char *name);
 void CONF_free(LHASH *conf);
-void ERR_load_CONF_strings(void );
+int CONF_dump_fp(LHASH *conf, FILE *out);
+int CONF_dump_bio(LHASH *conf, BIO *out);
 
-#else
+void OPENSSL_config(const char *config_name);
 
-LHASH *CONF_load();
-STACK *CONF_get_section();
-char *CONF_get_string();
-long CONF_get_number();
-void CONF_free();
-void ERR_load_CONF_strings();
+/* New conf code.  The semantics are different from the functions above.
+   If that wasn't the case, the above functions would have been replaced */
 
+struct conf_st
+        {
+        CONF_METHOD *meth;
+        void *meth_data;
+        LHASH *data;
+        };
+
+CONF *NCONF_new(CONF_METHOD *meth);
+CONF_METHOD *NCONF_default();
+CONF_METHOD *NCONF_WIN32();
+#if 0 /* Just to give you an idea of what I have in mind */
+CONF_METHOD *NCONF_XML();
 #endif
+void NCONF_free(CONF *conf);
+void NCONF_free_data(CONF *conf);
+
+int NCONF_load(CONF *conf,const char *file,long *eline);
+#ifndef OPENSSL_NO_FP_API
+int NCONF_load_fp(CONF *conf, FILE *fp,long *eline);
+#endif
+int NCONF_load_bio(CONF *conf, BIO *bp,long *eline);
+STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,const char *section);
+char *NCONF_get_string(const CONF *conf,const char *group,const char *name);
+int NCONF_get_number_e(const CONF *conf,const char *group,const char *name,
+                       long *result);
+int NCONF_dump_fp(const CONF *conf, FILE *out);
+int NCONF_dump_bio(const CONF *conf, BIO *out);
+
+#if 0 /* The following function has no error checking,
+         and should therefore be avoided */
+long NCONF_get_number(CONF *conf,char *group,char *name);
+#else
+#define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r)
+#endif
+  
+/* Module functions */
+
+int CONF_modules_load(const CONF *cnf, const char *appname,
+                      unsigned long flags);
+int CONF_modules_load_file(const char *filename, const char *appname,
+                           unsigned long flags);
+void CONF_modules_unload(int all);
+void CONF_modules_finish(void);
+int CONF_module_add(const char *name, conf_init_func *ifunc,
+                    conf_finish_func *ffunc);
+
+const char *CONF_imodule_get_name(const CONF_IMODULE *md);
+const char *CONF_imodule_get_value(const CONF_IMODULE *md);
+void *CONF_imodule_get_usr_data(const CONF_IMODULE *md);
+void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data);
+CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md);
+unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md);
+void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags);
+void *CONF_module_get_usr_data(CONF_MODULE *pmod);
+void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data);
+
+char *CONF_get1_default_config_file(void);
+
+int CONF_parse_list(const char *list, int sep, int nospc,
+        int (*list_cb)(const char *elem, int len, void *usr), void *arg);
+
+void OPENSSL_load_builtin_modules(void);
 
 /* BEGIN ERROR CODES */
+/* The following lines are auto generated by the script mkerr.pl. Any changes
+ * made after this point may be overwritten when the script is next run.
+ */
+void ERR_load_CONF_strings(void);
+
 /* Error codes for the CONF functions. */
 
 /* Function codes. */
+#define CONF_F_CONF_DUMP_FP                              104
 #define CONF_F_CONF_LOAD                                 100
+#define CONF_F_CONF_LOAD_BIO                             102
+#define CONF_F_CONF_LOAD_FP                              103
+#define CONF_F_CONF_MODULES_LOAD                         116
+#define CONF_F_MODULE_INIT                               115
+#define CONF_F_MODULE_LOAD_DSO                           117
+#define CONF_F_MODULE_RUN                                118
+#define CONF_F_NCONF_DUMP_BIO                            105
+#define CONF_F_NCONF_DUMP_FP                             106
+#define CONF_F_NCONF_GET_NUMBER                          107
+#define CONF_F_NCONF_GET_NUMBER_E                        112
+#define CONF_F_NCONF_GET_SECTION                         108
+#define CONF_F_NCONF_GET_STRING                          109
+#define CONF_F_NCONF_LOAD                                113
+#define CONF_F_NCONF_LOAD_BIO                            110
+#define CONF_F_NCONF_LOAD_FP                             114
+#define CONF_F_NCONF_NEW                                 111
 #define CONF_F_STR_COPY                                  101
 
 /* Reason codes. */
+#define CONF_R_ERROR_LOADING_DSO                         110
 #define CONF_R_MISSING_CLOSE_SQUARE_BRACKET              100
 #define CONF_R_MISSING_EQUAL_SIGN                        101
+#define CONF_R_MISSING_FINISH_FUNCTION                   111
+#define CONF_R_MISSING_INIT_FUNCTION                     112
+#define CONF_R_MODULE_INITIALIZATION_ERROR               109
 #define CONF_R_NO_CLOSE_BRACE                            102
+#define CONF_R_NO_CONF                                   105
+#define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE           106
+#define CONF_R_NO_SECTION                                107
+#define CONF_R_NO_SUCH_FILE                              114
+#define CONF_R_NO_VALUE                                  108
 #define CONF_R_UNABLE_TO_CREATE_NEW_SECTION              103
+#define CONF_R_UNKNOWN_MODULE_NAME                       113
 #define CONF_R_VARIABLE_HAS_NO_VALUE                     104
- 
+
 #ifdef  __cplusplus
 }
 #endif
 #endif
-
diff --git a/src/lib/libcrypto/conf/conf_api.c b/src/lib/libcrypto/conf/conf_api.c
index d05a778ff6..0032baa711 100644
--- a/src/lib/libcrypto/conf/conf_api.c
+++ b/src/lib/libcrypto/conf/conf_api.c
@@ -67,26 +67,34 @@
 #include <string.h>
 #include <openssl/conf.h>
 #include <openssl/conf_api.h>
+#include "e_os.h"
 
 static void value_free_hash(CONF_VALUE *a, LHASH *conf);
 static void value_free_stack(CONF_VALUE *a,LHASH *conf);
-static unsigned long hash(CONF_VALUE *v);
-static int cmp_conf(CONF_VALUE *a,CONF_VALUE *b);
+static IMPLEMENT_LHASH_DOALL_ARG_FN(value_free_hash, CONF_VALUE *, LHASH *)
+static IMPLEMENT_LHASH_DOALL_ARG_FN(value_free_stack, CONF_VALUE *, LHASH *)
+/* We don't use function pointer casting or wrapper functions - but cast each
+ * callback parameter inside the callback functions. */
+/* static unsigned long hash(CONF_VALUE *v); */
+static unsigned long hash(const void *v_void);
+/* static int cmp_conf(CONF_VALUE *a,CONF_VALUE *b); */
+static int cmp_conf(const void *a_void,const void *b_void);
 
 /* Up until OpenSSL 0.9.5a, this was get_section */
-CONF_VALUE *_CONF_get_section(CONF *conf, char *section)
+CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section)
         {
         CONF_VALUE *v,vv;
 
         if ((conf == NULL) || (section == NULL)) return(NULL);
         vv.name=NULL;
-        vv.section=section;
+        vv.section=(char *)section;
         v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
         return(v);
         }
 
 /* Up until OpenSSL 0.9.5a, this was CONF_get_section */
-STACK_OF(CONF_VALUE) *_CONF_get_section_values(CONF *conf, char *section)
+STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf,
+                                               const char *section)
         {
         CONF_VALUE *v;
 
@@ -121,7 +129,7 @@ int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value)
         return 1;
         }
 
-char *_CONF_get_string(CONF *conf, char *section, char *name)
+char *_CONF_get_string(const CONF *conf, const char *section, const char *name)
         {
         CONF_VALUE *v,vv;
         char *p;
@@ -131,8 +139,8 @@ char *_CONF_get_string(CONF *conf, char *section, char *name)
                 {
                 if (section != NULL)
                         {
-                        vv.name=name;
-                        vv.section=section;
+                        vv.name=(char *)name;
+                        vv.section=(char *)section;
                         v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
                         if (v != NULL) return(v->value);
                         if (strcmp(section,"ENV") == 0)
@@ -142,7 +150,7 @@ char *_CONF_get_string(CONF *conf, char *section, char *name)
                                 }
                         }
                 vv.section="default";
-                vv.name=name;
+                vv.name=(char *)name;
                 v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
                 if (v != NULL)
                         return(v->value);
@@ -153,6 +161,9 @@ char *_CONF_get_string(CONF *conf, char *section, char *name)
                 return(Getenv(name));
         }
 
+#if 0 /* There's no way to provide error checking with this function, so
+         force implementors of the higher levels to get a string and read
+         the number themselves. */
 long _CONF_get_number(CONF *conf, char *section, char *name)
         {
         char *str;
@@ -169,6 +180,7 @@ long _CONF_get_number(CONF *conf, char *section, char *name)
                 str++;
                 }
         }
+#endif
 
 int _CONF_new_data(CONF *conf)
         {
@@ -177,7 +189,7 @@ int _CONF_new_data(CONF *conf)
                 return 0;
                 }
         if (conf->data == NULL)
-                if ((conf->data = lh_new(hash,cmp_conf)) == NULL)
+                if ((conf->data = lh_new(hash, cmp_conf)) == NULL)
                         {
                         return 0;
                         }
@@ -190,12 +202,14 @@ void _CONF_free_data(CONF *conf)
 
         conf->data->down_load=0; /* evil thing to make sure the 'OPENSSL_free()'
                                   * works as expected */
-        lh_doall_arg(conf->data,(void (*)())value_free_hash,conf->data);
+        lh_doall_arg(conf->data, LHASH_DOALL_ARG_FN(value_free_hash),
+                        conf->data);
 
         /* We now have only 'section' entries in the hash table.
          * Due to problems with */
 
-        lh_doall_arg(conf->data,(void (*)())value_free_stack,conf->data);
+        lh_doall_arg(conf->data, LHASH_DOALL_ARG_FN(value_free_stack),
+                        conf->data);
         lh_free(conf->data);
         }
 
@@ -228,14 +242,19 @@ static void value_free_stack(CONF_VALUE *a, LHASH *conf)
         OPENSSL_free(a);
         }
 
-static unsigned long hash(CONF_VALUE *v)
+/* static unsigned long hash(CONF_VALUE *v) */
+static unsigned long hash(const void *v_void)
         {
+        CONF_VALUE *v = (CONF_VALUE *)v_void;
         return((lh_strhash(v->section)<<2)^lh_strhash(v->name));
         }
 
-static int cmp_conf(CONF_VALUE *a, CONF_VALUE *b)
+/* static int cmp_conf(CONF_VALUE *a, CONF_VALUE *b) */
+static int cmp_conf(const void *a_void,const  void *b_void)
         {
         int i;
+        CONF_VALUE *a = (CONF_VALUE *)a_void;
+        CONF_VALUE *b = (CONF_VALUE *)b_void;
 
         if (a->section != b->section)
                 {
@@ -255,7 +274,7 @@ static int cmp_conf(CONF_VALUE *a, CONF_VALUE *b)
         }
 
 /* Up until OpenSSL 0.9.5a, this was new_section */
-CONF_VALUE *_CONF_new_section(CONF *conf, char *section)
+CONF_VALUE *_CONF_new_section(CONF *conf, const char *section)
         {
         STACK *sk=NULL;
         int ok=0,i;
diff --git a/src/lib/libcrypto/conf/conf_api.h b/src/lib/libcrypto/conf/conf_api.h
index a5cc17b233..87a954aff6 100644
--- a/src/lib/libcrypto/conf/conf_api.h
+++ b/src/lib/libcrypto/conf/conf_api.h
@@ -67,15 +67,17 @@ extern "C" {
 #endif
 
 /* Up until OpenSSL 0.9.5a, this was new_section */
-CONF_VALUE *_CONF_new_section(CONF *conf, char *section);
+CONF_VALUE *_CONF_new_section(CONF *conf, const char *section);
 /* Up until OpenSSL 0.9.5a, this was get_section */
-CONF_VALUE *_CONF_get_section(CONF *conf, char *section);
+CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section);
 /* Up until OpenSSL 0.9.5a, this was CONF_get_section */
-STACK_OF(CONF_VALUE) *_CONF_get_section_values(CONF *conf, char *section);
+STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf,
+                                               const char *section);
 
 int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value);
-char *_CONF_get_string(CONF *conf, char *section, char *name);
-long _CONF_get_number(CONF *conf, char *section, char *name);
+char *_CONF_get_string(const CONF *conf, const char *section,
+                       const char *name);
+long _CONF_get_number(const CONF *conf, const char *section, const char *name);
 
 int _CONF_new_data(CONF *conf);
 void _CONF_free_data(CONF *conf);
diff --git a/src/lib/libcrypto/conf/conf_def.c b/src/lib/libcrypto/conf/conf_def.c
index 773df32c68..31f2766246 100644
--- a/src/lib/libcrypto/conf/conf_def.c
+++ b/src/lib/libcrypto/conf/conf_def.c
@@ -81,10 +81,11 @@ static int def_init_default(CONF *conf);
 static int def_init_WIN32(CONF *conf);
 static int def_destroy(CONF *conf);
 static int def_destroy_data(CONF *conf);
-static int def_load(CONF *conf, BIO *bp, long *eline);
-static int def_dump(CONF *conf, BIO *bp);
-static int def_is_number(CONF *conf, char c);
-static int def_to_int(CONF *conf, char c);
+static int def_load(CONF *conf, const char *name, long *eline);
+static int def_load_bio(CONF *conf, BIO *bp, long *eline);
+static int def_dump(const CONF *conf, BIO *bp);
+static int def_is_number(const CONF *conf, char c);
+static int def_to_int(const CONF *conf, char c);
 
 const char *CONF_def_version="CONF_def" OPENSSL_VERSION_PTEXT;
 
@@ -94,10 +95,11 @@ static CONF_METHOD default_method = {
         def_init_default,
         def_destroy,
         def_destroy_data,
-        def_load,
+        def_load_bio,
         def_dump,
         def_is_number,
-        def_to_int
+        def_to_int,
+        def_load
         };
 
 static CONF_METHOD WIN32_method = {
@@ -106,10 +108,11 @@ static CONF_METHOD WIN32_method = {
         def_init_WIN32,
         def_destroy,
         def_destroy_data,
-        def_load,
+        def_load_bio,
         def_dump,
         def_is_number,
-        def_to_int
+        def_to_int,
+        def_load
         };
 
 CONF_METHOD *NCONF_default()
@@ -177,7 +180,32 @@ static int def_destroy_data(CONF *conf)
         return 1;
         }
 
-static int def_load(CONF *conf, BIO *in, long *line)
+static int def_load(CONF *conf, const char *name, long *line)
+        {
+        int ret;
+        BIO *in=NULL;
+
+#ifdef OPENSSL_SYS_VMS
+        in=BIO_new_file(name, "r");
+#else
+        in=BIO_new_file(name, "rb");
+#endif
+        if (in == NULL)
+                {
+                if (ERR_GET_REASON(ERR_peek_last_error()) == BIO_R_NO_SUCH_FILE)
+                        CONFerr(CONF_F_CONF_LOAD,CONF_R_NO_SUCH_FILE);
+                else
+                        CONFerr(CONF_F_CONF_LOAD,ERR_R_SYS_LIB);
+                return 0;
+                }
+
+        ret = def_load_bio(conf, in, line);
+        BIO_free(in);
+
+        return ret;
+        }
+
+static int def_load_bio(CONF *conf, BIO *in, long *line)
         {
 #define BUFSIZE 512
         char btmp[16];
@@ -418,7 +446,11 @@ err:
         if (line != NULL) *line=eline;
         sprintf(btmp,"%ld",eline);
         ERR_add_error_data(2,"line ",btmp);
-        if ((h != conf->data) && (conf->data != NULL)) CONF_free(conf->data);
+        if ((h != conf->data) && (conf->data != NULL))
+                {
+                CONF_free(conf->data);
+                conf->data=NULL;
+                }
         if (v != NULL)
                 {
                 if (v->name != NULL) OPENSSL_free(v->name);
@@ -685,18 +717,20 @@ static void dump_value(CONF_VALUE *a, BIO *out)
                 BIO_printf(out, "[[%s]]\n", a->section);
         }
 
-static int def_dump(CONF *conf, BIO *out)
+static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE *, BIO *)
+
+static int def_dump(const CONF *conf, BIO *out)
         {
-        lh_doall_arg(conf->data, (void (*)())dump_value, out);
+        lh_doall_arg(conf->data, LHASH_DOALL_ARG_FN(dump_value), out);
         return 1;
         }
 
-static int def_is_number(CONF *conf, char c)
+static int def_is_number(const CONF *conf, char c)
         {
         return IS_NUMBER(conf,c);
         }
 
-static int def_to_int(CONF *conf, char c)
+static int def_to_int(const CONF *conf, char c)
         {
         return c - '0';
         }
diff --git a/src/lib/libcrypto/conf/conf_def.h b/src/lib/libcrypto/conf/conf_def.h
index 3244d9a331..92a7d8ad77 100644
--- a/src/lib/libcrypto/conf/conf_def.h
+++ b/src/lib/libcrypto/conf/conf_def.h
@@ -71,6 +71,7 @@
 #define CONF_COMMENT            128
 #define CONF_FCOMMENT           2048
 #define CONF_EOF                8
+#define CONF_HIGHBIT            4096
 #define CONF_ALPHA              (CONF_UPPER|CONF_LOWER)
 #define CONF_ALPHA_NUMERIC      (CONF_ALPHA|CONF_NUMBER|CONF_UNDER)
 #define CONF_ALPHA_NUMERIC_PUNCT (CONF_ALPHA|CONF_NUMBER|CONF_UNDER| \
@@ -78,68 +79,102 @@
 
 #define KEYTYPES(c)             ((unsigned short *)((c)->meth_data))
 #ifndef CHARSET_EBCDIC
-#define IS_COMMENT(c,a)         (KEYTYPES(c)[(a)&0x7f]&CONF_COMMENT)
-#define IS_FCOMMENT(c,a)        (KEYTYPES(c)[(a)&0x7f]&CONF_FCOMMENT)
-#define IS_EOF(c,a)             (KEYTYPES(c)[(a)&0x7f]&CONF_EOF)
-#define IS_ESC(c,a)             (KEYTYPES(c)[(a)&0x7f]&CONF_ESC)
-#define IS_NUMBER(c,a)          (KEYTYPES(c)[(a)&0x7f]&CONF_NUMBER)
-#define IS_WS(c,a)              (KEYTYPES(c)[(a)&0x7f]&CONF_WS)
-#define IS_ALPHA_NUMERIC(c,a)   (KEYTYPES(c)[(a)&0x7f]&CONF_ALPHA_NUMERIC)
+#define IS_COMMENT(c,a)         (KEYTYPES(c)[(a)&0xff]&CONF_COMMENT)
+#define IS_FCOMMENT(c,a)        (KEYTYPES(c)[(a)&0xff]&CONF_FCOMMENT)
+#define IS_EOF(c,a)             (KEYTYPES(c)[(a)&0xff]&CONF_EOF)
+#define IS_ESC(c,a)             (KEYTYPES(c)[(a)&0xff]&CONF_ESC)
+#define IS_NUMBER(c,a)          (KEYTYPES(c)[(a)&0xff]&CONF_NUMBER)
+#define IS_WS(c,a)              (KEYTYPES(c)[(a)&0xff]&CONF_WS)
+#define IS_ALPHA_NUMERIC(c,a)   (KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC)
 #define IS_ALPHA_NUMERIC_PUNCT(c,a) \
-                                (KEYTYPES(c)[(a)&0x7f]&CONF_ALPHA_NUMERIC_PUNCT)
-#define IS_QUOTE(c,a)           (KEYTYPES(c)[(a)&0x7f]&CONF_QUOTE)
-#define IS_DQUOTE(c,a)          (KEYTYPES(c)[(a)&0x7f]&CONF_DQUOTE)
+                                (KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC_PUNCT)
+#define IS_QUOTE(c,a)           (KEYTYPES(c)[(a)&0xff]&CONF_QUOTE)
+#define IS_DQUOTE(c,a)          (KEYTYPES(c)[(a)&0xff]&CONF_DQUOTE)
+#define IS_HIGHBIT(c,a)         (KEYTYPES(c)[(a)&0xff]&CONF_HIGHBIT)
 
 #else /*CHARSET_EBCDIC*/
 
-#define IS_COMMENT(c,a)         (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_COMMENT)
-#define IS_FCOMMENT(c,a)        (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_FCOMMENT)
-#define IS_EOF(c,a)             (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_EOF)
-#define IS_ESC(c,a)             (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_ESC)
-#define IS_NUMBER(c,a)          (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_NUMBER)
-#define IS_WS(c,a)              (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_WS)
-#define IS_ALPHA_NUMERIC(c,a)   (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_ALPHA_NUMERIC)
+#define IS_COMMENT(c,a)         (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_COMMENT)
+#define IS_FCOMMENT(c,a)        (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_FCOMMENT)
+#define IS_EOF(c,a)             (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_EOF)
+#define IS_ESC(c,a)             (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_ESC)
+#define IS_NUMBER(c,a)          (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_NUMBER)
+#define IS_WS(c,a)              (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_WS)
+#define IS_ALPHA_NUMERIC(c,a)   (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_ALPHA_NUMERIC)
 #define IS_ALPHA_NUMERIC_PUNCT(c,a) \
-                                (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_ALPHA_NUMERIC_PUNCT)
-#define IS_QUOTE(c,a)           (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_QUOTE)
-#define IS_DQUOTE(c,a)          (KEYTYPES(c)[os_toascii[a]&0x7f]&CONF_DQUOTE)
+                                (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_ALPHA_NUMERIC_PUNCT)
+#define IS_QUOTE(c,a)           (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_QUOTE)
+#define IS_DQUOTE(c,a)          (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_DQUOTE)
+#define IS_HIGHBIT(c,a)         (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_HIGHBIT)
 #endif /*CHARSET_EBCDIC*/
 
-static unsigned short CONF_type_default[128]={
-        0x008,0x000,0x000,0x000,0x000,0x000,0x000,0x000,
-        0x000,0x010,0x010,0x000,0x000,0x010,0x000,0x000,
-        0x000,0x000,0x000,0x000,0x000,0x000,0x000,0x000,
-        0x000,0x000,0x000,0x000,0x000,0x000,0x000,0x000,
-        0x010,0x200,0x040,0x080,0x000,0x200,0x200,0x040,
-        0x000,0x000,0x200,0x200,0x200,0x200,0x200,0x200,
-        0x001,0x001,0x001,0x001,0x001,0x001,0x001,0x001,
-        0x001,0x001,0x000,0x200,0x000,0x000,0x000,0x200,
-        0x200,0x002,0x002,0x002,0x002,0x002,0x002,0x002,
-        0x002,0x002,0x002,0x002,0x002,0x002,0x002,0x002,
-        0x002,0x002,0x002,0x002,0x002,0x002,0x002,0x002,
-        0x002,0x002,0x002,0x000,0x020,0x000,0x200,0x100,
-        0x040,0x004,0x004,0x004,0x004,0x004,0x004,0x004,
-        0x004,0x004,0x004,0x004,0x004,0x004,0x004,0x004,
-        0x004,0x004,0x004,0x004,0x004,0x004,0x004,0x004,
-        0x004,0x004,0x004,0x000,0x200,0x000,0x200,0x000,
+static unsigned short CONF_type_default[256]={
+        0x0008,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+        0x0000,0x0010,0x0010,0x0000,0x0000,0x0010,0x0000,0x0000,
+        0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+        0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+        0x0010,0x0200,0x0040,0x0080,0x0000,0x0200,0x0200,0x0040,
+        0x0000,0x0000,0x0200,0x0200,0x0200,0x0200,0x0200,0x0200,
+        0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
+        0x0001,0x0001,0x0000,0x0200,0x0000,0x0000,0x0000,0x0200,
+        0x0200,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,
+        0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,
+        0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,
+        0x0002,0x0002,0x0002,0x0000,0x0020,0x0000,0x0200,0x0100,
+        0x0040,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,
+        0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,
+        0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,
+        0x0004,0x0004,0x0004,0x0000,0x0200,0x0000,0x0200,0x0000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
         };
 
-static unsigned short CONF_type_win32[128]={
-        0x008,0x000,0x000,0x000,0x000,0x000,0x000,0x000,
-        0x000,0x010,0x010,0x000,0x000,0x010,0x000,0x000,
-        0x000,0x000,0x000,0x000,0x000,0x000,0x000,0x000,
-        0x000,0x000,0x000,0x000,0x000,0x000,0x000,0x000,
-        0x010,0x200,0x400,0x000,0x000,0x200,0x200,0x000,
-        0x000,0x000,0x200,0x200,0x200,0x200,0x200,0x200,
-        0x001,0x001,0x001,0x001,0x001,0x001,0x001,0x001,
-        0x001,0x001,0x000,0xA00,0x000,0x000,0x000,0x200,
-        0x200,0x002,0x002,0x002,0x002,0x002,0x002,0x002,
-        0x002,0x002,0x002,0x002,0x002,0x002,0x002,0x002,
-        0x002,0x002,0x002,0x002,0x002,0x002,0x002,0x002,
-        0x002,0x002,0x002,0x000,0x000,0x000,0x200,0x100,
-        0x000,0x004,0x004,0x004,0x004,0x004,0x004,0x004,
-        0x004,0x004,0x004,0x004,0x004,0x004,0x004,0x004,
-        0x004,0x004,0x004,0x004,0x004,0x004,0x004,0x004,
-        0x004,0x004,0x004,0x000,0x200,0x000,0x200,0x000,
+static unsigned short CONF_type_win32[256]={
+        0x0008,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+        0x0000,0x0010,0x0010,0x0000,0x0000,0x0010,0x0000,0x0000,
+        0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+        0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
+        0x0010,0x0200,0x0400,0x0000,0x0000,0x0200,0x0200,0x0000,
+        0x0000,0x0000,0x0200,0x0200,0x0200,0x0200,0x0200,0x0200,
+        0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,0x0001,
+        0x0001,0x0001,0x0000,0x0A00,0x0000,0x0000,0x0000,0x0200,
+        0x0200,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,
+        0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,
+        0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,
+        0x0002,0x0002,0x0002,0x0000,0x0000,0x0000,0x0200,0x0100,
+        0x0000,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,
+        0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,
+        0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,0x0004,
+        0x0004,0x0004,0x0004,0x0000,0x0200,0x0000,0x0200,0x0000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
+        0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,
         };
 
diff --git a/src/lib/libcrypto/conf/conf_err.c b/src/lib/libcrypto/conf/conf_err.c
index a8db8f266f..ee07bfe9d9 100644
--- a/src/lib/libcrypto/conf/conf_err.c
+++ b/src/lib/libcrypto/conf/conf_err.c
@@ -1,93 +1,123 @@
-/* lib/conf/conf_err.c */
-/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
+/* crypto/conf/conf_err.c */
+/* ====================================================================
+ * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
  *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
  * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
  */
+
+/* NOTE: this file was auto generated by the mkerr.pl script: any changes
+ * made to it will be overwritten when the script next updates this file,
+ * only reason strings will be preserved.
+ */
+
 #include <stdio.h>
-#include "err.h"
-#include "conf.h"
+#include <openssl/err.h>
+#include <openssl/conf.h>
 
 /* BEGIN ERROR CODES */
-#ifndef NO_ERR
+#ifndef OPENSSL_NO_ERR
 static ERR_STRING_DATA CONF_str_functs[]=
         {
+{ERR_PACK(0,CONF_F_CONF_DUMP_FP,0),     "CONF_dump_fp"},
 {ERR_PACK(0,CONF_F_CONF_LOAD,0),        "CONF_load"},
+{ERR_PACK(0,CONF_F_CONF_LOAD_BIO,0),    "CONF_load_bio"},
+{ERR_PACK(0,CONF_F_CONF_LOAD_FP,0),     "CONF_load_fp"},
+{ERR_PACK(0,CONF_F_CONF_MODULES_LOAD,0),        "CONF_modules_load"},
+{ERR_PACK(0,CONF_F_MODULE_INIT,0),      "MODULE_INIT"},
+{ERR_PACK(0,CONF_F_MODULE_LOAD_DSO,0),  "MODULE_LOAD_DSO"},
+{ERR_PACK(0,CONF_F_MODULE_RUN,0),       "MODULE_RUN"},
+{ERR_PACK(0,CONF_F_NCONF_DUMP_BIO,0),   "NCONF_dump_bio"},
+{ERR_PACK(0,CONF_F_NCONF_DUMP_FP,0),    "NCONF_dump_fp"},
+{ERR_PACK(0,CONF_F_NCONF_GET_NUMBER,0), "NCONF_get_number"},
+{ERR_PACK(0,CONF_F_NCONF_GET_NUMBER_E,0),       "NCONF_get_number_e"},
+{ERR_PACK(0,CONF_F_NCONF_GET_SECTION,0),        "NCONF_get_section"},
+{ERR_PACK(0,CONF_F_NCONF_GET_STRING,0), "NCONF_get_string"},
+{ERR_PACK(0,CONF_F_NCONF_LOAD,0),       "NCONF_load"},
+{ERR_PACK(0,CONF_F_NCONF_LOAD_BIO,0),   "NCONF_load_bio"},
+{ERR_PACK(0,CONF_F_NCONF_LOAD_FP,0),    "NCONF_load_fp"},
+{ERR_PACK(0,CONF_F_NCONF_NEW,0),        "NCONF_new"},
 {ERR_PACK(0,CONF_F_STR_COPY,0), "STR_COPY"},
-{0,NULL},
+{0,NULL}
         };
 
 static ERR_STRING_DATA CONF_str_reasons[]=
         {
+{CONF_R_ERROR_LOADING_DSO                ,"error loading dso"},
 {CONF_R_MISSING_CLOSE_SQUARE_BRACKET     ,"missing close square bracket"},
 {CONF_R_MISSING_EQUAL_SIGN               ,"missing equal sign"},
+{CONF_R_MISSING_FINISH_FUNCTION          ,"missing finish function"},
+{CONF_R_MISSING_INIT_FUNCTION            ,"missing init function"},
+{CONF_R_MODULE_INITIALIZATION_ERROR      ,"module initialization error"},
 {CONF_R_NO_CLOSE_BRACE                   ,"no close brace"},
+{CONF_R_NO_CONF                          ,"no conf"},
+{CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE  ,"no conf or environment variable"},
+{CONF_R_NO_SECTION                       ,"no section"},
+{CONF_R_NO_SUCH_FILE                     ,"no such file"},
+{CONF_R_NO_VALUE                         ,"no value"},
 {CONF_R_UNABLE_TO_CREATE_NEW_SECTION     ,"unable to create new section"},
+{CONF_R_UNKNOWN_MODULE_NAME              ,"unknown module name"},
 {CONF_R_VARIABLE_HAS_NO_VALUE            ,"variable has no value"},
-{0,NULL},
+{0,NULL}
         };
 
 #endif
 
-void ERR_load_CONF_strings()
+void ERR_load_CONF_strings(void)
         {
         static int init=1;
 
-        if (init);
-                {;
+        if (init)
+                {
                 init=0;
-#ifndef NO_ERR
+#ifndef OPENSSL_NO_ERR
                 ERR_load_strings(ERR_LIB_CONF,CONF_str_functs);
                 ERR_load_strings(ERR_LIB_CONF,CONF_str_reasons);
 #endif
diff --git a/src/lib/libcrypto/conf/conf_lib.c b/src/lib/libcrypto/conf/conf_lib.c
index 4c8ca9e9ae..7998f34c7b 100644
--- a/src/lib/libcrypto/conf/conf_lib.c
+++ b/src/lib/libcrypto/conf/conf_lib.c
@@ -67,6 +67,17 @@ const char *CONF_version="CONF" OPENSSL_VERSION_PTEXT;
 
 static CONF_METHOD *default_CONF_method=NULL;
 
+/* Init a 'CONF' structure from an old LHASH */
+
+void CONF_set_nconf(CONF *conf, LHASH *hash)
+        {
+        if (default_CONF_method == NULL)
+                default_CONF_method = NCONF_default();
+
+        default_CONF_method->init(conf);
+        conf->data = hash;
+        }
+
 /* The following section contains the "CONF classic" functions,
    rewritten in terms of the new CONF interface. */
 
@@ -81,7 +92,7 @@ LHASH *CONF_load(LHASH *conf, const char *file, long *eline)
         LHASH *ltmp;
         BIO *in=NULL;
 
-#ifdef VMS
+#ifdef OPENSSL_SYS_VMS
         in=BIO_new_file(file, "r");
 #else
         in=BIO_new_file(file, "rb");
@@ -98,7 +109,7 @@ LHASH *CONF_load(LHASH *conf, const char *file, long *eline)
         return ltmp;
         }
 
-#ifndef NO_FP_API
+#ifndef OPENSSL_NO_FP_API
 LHASH *CONF_load_fp(LHASH *conf, FILE *fp,long *eline)
         {
         BIO *btmp;
@@ -118,66 +129,74 @@ LHASH *CONF_load_bio(LHASH *conf, BIO *bp,long *eline)
         CONF ctmp;
         int ret;
 
-        if (default_CONF_method == NULL)
-                default_CONF_method = NCONF_default();
+        CONF_set_nconf(&ctmp, conf);
 
-        default_CONF_method->init(&ctmp);
-        ctmp.data = conf;
         ret = NCONF_load_bio(&ctmp, bp, eline);
         if (ret)
                 return ctmp.data;
         return NULL;
         }
 
-STACK_OF(CONF_VALUE) *CONF_get_section(LHASH *conf,char *section)
+STACK_OF(CONF_VALUE) *CONF_get_section(LHASH *conf,const char *section)
         {
-        CONF ctmp;
-
-        if (default_CONF_method == NULL)
-                default_CONF_method = NCONF_default();
-
-        default_CONF_method->init(&ctmp);
-        ctmp.data = conf;
-        return NCONF_get_section(&ctmp, section);
+        if (conf == NULL)
+                {
+                return NULL;
+                }
+        else
+                {
+                CONF ctmp;
+                CONF_set_nconf(&ctmp, conf);
+                return NCONF_get_section(&ctmp, section);
+                }
         }
 
-char *CONF_get_string(LHASH *conf,char *group,char *name)
+char *CONF_get_string(LHASH *conf,const char *group,const char *name)
         {
-        CONF ctmp;
-
-        if (default_CONF_method == NULL)
-                default_CONF_method = NCONF_default();
-
-        default_CONF_method->init(&ctmp);
-        ctmp.data = conf;
-        return NCONF_get_string(&ctmp, group, name);
+        if (conf == NULL)
+                {
+                return NCONF_get_string(NULL, group, name);
+                }
+        else
+                {
+                CONF ctmp;
+                CONF_set_nconf(&ctmp, conf);
+                return NCONF_get_string(&ctmp, group, name);
+                }
         }
 
-long CONF_get_number(LHASH *conf,char *group,char *name)
+long CONF_get_number(LHASH *conf,const char *group,const char *name)
         {
-        CONF ctmp;
+        int status;
+        long result = 0;
 
-        if (default_CONF_method == NULL)
-                default_CONF_method = NCONF_default();
+        if (conf == NULL)
+                {
+                status = NCONF_get_number_e(NULL, group, name, &result);
+                }
+        else
+                {
+                CONF ctmp;
+                CONF_set_nconf(&ctmp, conf);
+                status = NCONF_get_number_e(&ctmp, group, name, &result);
+                }
 
-        default_CONF_method->init(&ctmp);
-        ctmp.data = conf;
-        return NCONF_get_number(&ctmp, group, name);
+        if (status == 0)
+                {
+                /* This function does not believe in errors... */
+                ERR_get_error();
+                }
+        return result;
         }
 
 void CONF_free(LHASH *conf)
         {
         CONF ctmp;
-
-        if (default_CONF_method == NULL)
-                default_CONF_method = NCONF_default();
-
-        default_CONF_method->init(&ctmp);
-        ctmp.data = conf;
+        CONF_set_nconf(&ctmp, conf);
         NCONF_free_data(&ctmp);
         }
 
-#ifndef NO_FP_API
+#ifndef OPENSSL_NO_FP_API
 int CONF_dump_fp(LHASH *conf, FILE *out)
         {
         BIO *btmp;
@@ -196,12 +215,7 @@ int CONF_dump_fp(LHASH *conf, FILE *out)
 int CONF_dump_bio(LHASH *conf, BIO *out)
         {
         CONF ctmp;
-
-        if (default_CONF_method == NULL)
-                default_CONF_method = NCONF_default();
-
-        default_CONF_method->init(&ctmp);
-        ctmp.data = conf;
+        CONF_set_nconf(&ctmp, conf);
         return NCONF_dump_bio(&ctmp, out);
         }
 
@@ -244,34 +258,23 @@ void NCONF_free_data(CONF *conf)
 
 int NCONF_load(CONF *conf, const char *file, long *eline)
         {
-        int ret;
-        BIO *in=NULL;
-
-#ifdef VMS
-        in=BIO_new_file(file, "r");
-#else
-        in=BIO_new_file(file, "rb");
-#endif
-        if (in == NULL)
+        if (conf == NULL)
                 {
-                CONFerr(CONF_F_CONF_LOAD,ERR_R_SYS_LIB);
+                CONFerr(CONF_F_NCONF_LOAD,CONF_R_NO_CONF);
                 return 0;
                 }
 
-        ret = NCONF_load_bio(conf, in, eline);
-        BIO_free(in);
-
-        return ret;
+        return conf->meth->load(conf, file, eline);
         }
 
-#ifndef NO_FP_API
+#ifndef OPENSSL_NO_FP_API
 int NCONF_load_fp(CONF *conf, FILE *fp,long *eline)
         {
         BIO *btmp;
         int ret;
         if(!(btmp = BIO_new_fp(fp, BIO_NOCLOSE)))
                 {
-                CONFerr(CONF_F_CONF_LOAD_FP,ERR_R_BUF_LIB);
+                CONFerr(CONF_F_NCONF_LOAD_FP,ERR_R_BUF_LIB);
                 return 0;
                 }
         ret = NCONF_load_bio(conf, btmp, eline);
@@ -288,10 +291,10 @@ int NCONF_load_bio(CONF *conf, BIO *bp,long *eline)
                 return 0;
                 }
 
-        return conf->meth->load(conf, bp, eline);
+        return conf->meth->load_bio(conf, bp, eline);
         }
 
-STACK_OF(CONF_VALUE) *NCONF_get_section(CONF *conf,char *section)
+STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,const char *section)
         {
         if (conf == NULL)
                 {
@@ -299,33 +302,62 @@ STACK_OF(CONF_VALUE) *NCONF_get_section(CONF *conf,char *section)
                 return NULL;
                 }
 
+        if (section == NULL)
+                {
+                CONFerr(CONF_F_NCONF_GET_SECTION,CONF_R_NO_SECTION);
+                return NULL;
+                }
+
         return _CONF_get_section_values(conf, section);
         }
 
-char *NCONF_get_string(CONF *conf,char *group,char *name)
+char *NCONF_get_string(const CONF *conf,const char *group,const char *name)
         {
+        char *s = _CONF_get_string(conf, group, name);
+
+        /* Since we may get a value from an environment variable even
+           if conf is NULL, let's check the value first */
+        if (s) return s;
+
         if (conf == NULL)
                 {
-                CONFerr(CONF_F_NCONF_GET_STRING,CONF_R_NO_CONF);
+                CONFerr(CONF_F_NCONF_GET_STRING,
+                        CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE);
                 return NULL;
                 }
-
-        return _CONF_get_string(conf, group, name);
+        CONFerr(CONF_F_NCONF_GET_STRING,
+                CONF_R_NO_VALUE);
+        ERR_add_error_data(4,"group=",group," name=",name);
+        return NULL;
         }
 
-long NCONF_get_number(CONF *conf,char *group,char *name)
+int NCONF_get_number_e(const CONF *conf,const char *group,const char *name,
+                       long *result)
         {
-        if (conf == NULL)
+        char *str;
+
+        if (result == NULL)
                 {
-                CONFerr(CONF_F_NCONF_GET_NUMBER,CONF_R_NO_CONF);
+                CONFerr(CONF_F_NCONF_GET_NUMBER_E,ERR_R_PASSED_NULL_PARAMETER);
                 return 0;
                 }
-        
-        return _CONF_get_number(conf, group, name);
+
+        str = NCONF_get_string(conf,group,name);
+
+        if (str == NULL)
+                return 0;
+
+        for (*result = 0;conf->meth->is_number(conf, *str);)
+                {
+                *result = (*result)*10 + conf->meth->to_int(conf, *str);
+                str++;
+                }
+
+        return 1;
         }
 
-#ifndef NO_FP_API
-int NCONF_dump_fp(CONF *conf, FILE *out)
+#ifndef OPENSSL_NO_FP_API
+int NCONF_dump_fp(const CONF *conf, FILE *out)
         {
         BIO *btmp;
         int ret;
@@ -339,7 +371,7 @@ int NCONF_dump_fp(CONF *conf, FILE *out)
         }
 #endif
 
-int NCONF_dump_bio(CONF *conf, BIO *out)
+int NCONF_dump_bio(const CONF *conf, BIO *out)
         {
         if (conf == NULL)
                 {
@@ -350,3 +382,19 @@ int NCONF_dump_bio(CONF *conf, BIO *out)
         return conf->meth->dump(conf, out);
         }
 
+/* This function should be avoided */
+#undef NCONF_get_number
+long NCONF_get_number(CONF *conf,char *group,char *name)
+        {
+        int status;
+        long ret=0;
+
+        status = NCONF_get_number_e(conf, group, name, &ret);
+        if (status == 0)
+                {
+                /* This function does not believe in errors... */
+                ERR_get_error();
+                }
+        return ret;
+        }
+
diff --git a/src/lib/libcrypto/conf/keysets.pl b/src/lib/libcrypto/conf/keysets.pl
index e40fed0ca1..50ed67fa52 100644
--- a/src/lib/libcrypto/conf/keysets.pl
+++ b/src/lib/libcrypto/conf/keysets.pl
@@ -1,16 +1,20 @@
-#!/usr/bin/perl
+#!/usr/local/bin/perl
 
 $NUMBER=0x01;
 $UPPER=0x02;
 $LOWER=0x04;
-$EOF=0x08;
+$UNDER=0x100;
+$PUNCTUATION=0x200;
 $WS=0x10;
 $ESC=0x20;
 $QUOTE=0x40;
+$DQUOTE=0x400;
 $COMMENT=0x80;
-$UNDER=0x100;
+$FCOMMENT=0x800;
+$EOF=0x08;
+$HIGHBIT=0x1000;
 
-foreach (0 .. 127)
+foreach (0 .. 255)
         {
         $v=0;
         $c=sprintf("%c",$_);
@@ -18,44 +22,164 @@ foreach (0 .. 127)
         $v|=$UPPER      if ($c =~ /[A-Z]/);
         $v|=$LOWER      if ($c =~ /[a-z]/);
         $v|=$UNDER      if ($c =~ /_/);
-        $v|=$WS         if ($c =~ / \t\r\n/);
+        $v|=$PUNCTUATION if ($c =~ /[!\.%&\*\+,\/;\?\@\^\~\|-]/);
+        $v|=$WS         if ($c =~ /[ \t\r\n]/);
         $v|=$ESC        if ($c =~ /\\/);
-        $v|=$QUOTE      if ($c =~ /['`"]/);
+        $v|=$QUOTE      if ($c =~ /['`"]/); # for emacs: "`'}/)
         $v|=$COMMENT    if ($c =~ /\#/);
         $v|=$EOF        if ($c =~ /\0/);
+        $v|=$HIGHBIT    if ($c =~/[\x80-\xff]/);
+
+        push(@V_def,$v);
+        }
+
+foreach (0 .. 255)
+        {
+        $v=0;
+        $c=sprintf("%c",$_);
+        $v|=$NUMBER     if ($c =~ /[0-9]/);
+        $v|=$UPPER      if ($c =~ /[A-Z]/);
+        $v|=$LOWER      if ($c =~ /[a-z]/);
+        $v|=$UNDER      if ($c =~ /_/);
+        $v|=$PUNCTUATION if ($c =~ /[!\.%&\*\+,\/;\?\@\^\~\|-]/);
+        $v|=$WS         if ($c =~ /[ \t\r\n]/);
+        $v|=$DQUOTE     if ($c =~ /["]/); # for emacs: "}/)
+        $v|=$FCOMMENT   if ($c =~ /;/);
+        $v|=$EOF        if ($c =~ /\0/);
+        $v|=$HIGHBIT    if ($c =~/[\x80-\xff]/);
 
-        push(@V,$v);
+        push(@V_w32,$v);
         }
 
 print <<"EOF";
+/* crypto/conf/conf_def.h */
+/* Copyright (C) 1995-1998 Eric Young (eay\@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay\@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ * 
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh\@cryptsoft.com).
+ * 
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay\@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from 
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh\@cryptsoft.com)"
+ * 
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * 
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ */
+
+/* THIS FILE WAS AUTOMAGICALLY GENERATED!
+   Please modify and use keysets.pl to regenerate it. */
+
 #define CONF_NUMBER             $NUMBER
 #define CONF_UPPER              $UPPER
 #define CONF_LOWER              $LOWER
-#define CONF_EOF                $EOF
+#define CONF_UNDER              $UNDER
+#define CONF_PUNCTUATION        $PUNCTUATION
 #define CONF_WS                 $WS
 #define CONF_ESC                $ESC
 #define CONF_QUOTE              $QUOTE
+#define CONF_DQUOTE             $DQUOTE
 #define CONF_COMMENT            $COMMENT
+#define CONF_FCOMMENT           $FCOMMENT
+#define CONF_EOF                $EOF
+#define CONF_HIGHBIT            $HIGHBIT
 #define CONF_ALPHA              (CONF_UPPER|CONF_LOWER)
 #define CONF_ALPHA_NUMERIC      (CONF_ALPHA|CONF_NUMBER|CONF_UNDER)
-#define CONF_UNDER              $UNDER
+#define CONF_ALPHA_NUMERIC_PUNCT (CONF_ALPHA|CONF_NUMBER|CONF_UNDER| \\
+                                        CONF_PUNCTUATION)
+
+#define KEYTYPES(c)             ((unsigned short *)((c)->meth_data))
+#ifndef CHARSET_EBCDIC
+#define IS_COMMENT(c,a)         (KEYTYPES(c)[(a)&0xff]&CONF_COMMENT)
+#define IS_FCOMMENT(c,a)        (KEYTYPES(c)[(a)&0xff]&CONF_FCOMMENT)
+#define IS_EOF(c,a)             (KEYTYPES(c)[(a)&0xff]&CONF_EOF)
+#define IS_ESC(c,a)             (KEYTYPES(c)[(a)&0xff]&CONF_ESC)
+#define IS_NUMBER(c,a)          (KEYTYPES(c)[(a)&0xff]&CONF_NUMBER)
+#define IS_WS(c,a)              (KEYTYPES(c)[(a)&0xff]&CONF_WS)
+#define IS_ALPHA_NUMERIC(c,a)   (KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC)
+#define IS_ALPHA_NUMERIC_PUNCT(c,a) \\
+                                (KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC_PUNCT)
+#define IS_QUOTE(c,a)           (KEYTYPES(c)[(a)&0xff]&CONF_QUOTE)
+#define IS_DQUOTE(c,a)          (KEYTYPES(c)[(a)&0xff]&CONF_DQUOTE)
+#define IS_HIGHBIT(c,a)         (KEYTYPES(c)[(a)&0xff]&CONF_HIGHBIT)
 
-#define IS_COMMENT(a)           (CONF_COMMENT&(CONF_type[(a)&0x7f]))
-#define IS_EOF(a)               ((a) == '\\0')
-#define IS_ESC(a)               ((a) == '\\\\')
-#define IS_NUMER(a)             (CONF_type[(a)&0x7f]&CONF_NUMBER)
-#define IS_WS(a)                (CONF_type[(a)&0x7f]&CONF_WS)
-#define IS_ALPHA_NUMERIC(a)     (CONF_type[(a)&0x7f]&CONF_ALPHA_NUMERIC)
-#define IS_QUOTE(a)             (CONF_type[(a)&0x7f]&CONF_QUOTE)
+#else /*CHARSET_EBCDIC*/
+
+#define IS_COMMENT(c,a)         (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_COMMENT)
+#define IS_FCOMMENT(c,a)        (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_FCOMMENT)
+#define IS_EOF(c,a)             (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_EOF)
+#define IS_ESC(c,a)             (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_ESC)
+#define IS_NUMBER(c,a)          (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_NUMBER)
+#define IS_WS(c,a)              (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_WS)
+#define IS_ALPHA_NUMERIC(c,a)   (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_ALPHA_NUMERIC)
+#define IS_ALPHA_NUMERIC_PUNCT(c,a) \\
+                                (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_ALPHA_NUMERIC_PUNCT)
+#define IS_QUOTE(c,a)           (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_QUOTE)
+#define IS_DQUOTE(c,a)          (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_DQUOTE)
+#define IS_HIGHBIT(c,a)         (KEYTYPES(c)[os_toascii[a]&0xff]&CONF_HIGHBIT)
+#endif /*CHARSET_EBCDIC*/
 
 EOF
 
-print "static unsigned short CONF_type[128]={";
+print "static unsigned short CONF_type_default[256]={";
+
+for ($i=0; $i<256; $i++)
+        {
+        print "\n\t" if ($i % 8) == 0;
+        printf "0x%04X,",$V_def[$i];
+        }
+
+print "\n\t};\n\n";
+
+print "static unsigned short CONF_type_win32[256]={";
 
-for ($i=0; $i<128; $i++)
+for ($i=0; $i<256; $i++)
         {
         print "\n\t" if ($i % 8) == 0;
-        printf "0x%03X,",$V[$i];
+        printf "0x%04X,",$V_w32[$i];
         }
 
-print "\n\t};\n";
+print "\n\t};\n\n";