I've always wanted to make the CONF library more adaptable. Here's

the result.

I have retained the old behavior of the CONF_* functions, and have
added a more "object oriented" interface through NCONF_* functions
(New CONF, you see :-)), working the same way as, for example, the
BIO interface.  Really, the CONF_* are rewritten so they use the
NCONF_* functions internally.

In addition to that, I've split the old conf.c code into two files,
conf_def.c and conf_api.c.  conf_def.c contains the default config
object that reads a configuration file the standard OpenSSL way, as
well as configuration file with Win32 registry file syntax (I'm not
sure I got that one right).  conf_api.c provides an API to build other
configuration file readers around (can you see a configuraion file in
XML?  I can :-)).

Finally, I've changed the name conf_lcl.h to conf_def.h, since it's
made specifically for that "class" and none others.

crypto/conf/Makefile.ssl

@@ -22,14 +22,14 @@ TEST=
 APPS=
 
 LIB=$(TOP)/libcrypto.a
-LIBSRC= conf.c conf_err.c
+LIBSRC= conf_err.c conf_lib.c conf_api.c conf_def.c
 
-LIBOBJ=	conf.o conf_err.o
+LIBOBJ=	conf_err.o conf_lib.o conf_api.o conf_def.o
 
 SRC= $(LIBSRC)
 
-EXHEADER= conf.h
-HEADER=	conf_lcl.h $(EXHEADER)
+EXHEADER= conf.h conf_api.h
+HEADER=	conf_def.h $(EXHEADER)
 
 ALL=    $(GENERAL) $(SRC) $(HEADER)
 
@@ -79,14 +79,30 @@ clean:
 
 # DO NOT DELETE THIS LINE -- make depend depends on it.
 
-conf.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
-conf.o: ../../include/openssl/conf.h ../../include/openssl/crypto.h
-conf.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
-conf.o: ../../include/openssl/err.h ../../include/openssl/lhash.h
-conf.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
-conf.o: ../../include/openssl/safestack.h ../../include/openssl/stack.h
-conf.o: ../cryptlib.h conf_lcl.h
+conf_api.o: ../../include/openssl/bio.h ../../include/openssl/conf.h
+conf_api.o: ../../include/openssl/conf_api.h ../../include/openssl/crypto.h
+conf_api.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
+conf_api.o: ../../include/openssl/lhash.h ../../include/openssl/opensslconf.h
+conf_api.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+conf_api.o: ../../include/openssl/stack.h
+conf_def.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+conf_def.o: ../../include/openssl/conf.h ../../include/openssl/conf_api.h
+conf_def.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+conf_def.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
+conf_def.o: ../../include/openssl/err.h ../../include/openssl/lhash.h
+conf_def.o: ../../include/openssl/opensslconf.h
+conf_def.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+conf_def.o: ../../include/openssl/stack.h ../cryptlib.h conf_def.h
 conf_err.o: ../../include/openssl/bio.h ../../include/openssl/conf.h
-conf_err.o: ../../include/openssl/crypto.h ../../include/openssl/err.h
-conf_err.o: ../../include/openssl/lhash.h ../../include/openssl/opensslv.h
-conf_err.o: ../../include/openssl/safestack.h ../../include/openssl/stack.h
+conf_err.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+conf_err.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+conf_err.o: ../../include/openssl/lhash.h ../../include/openssl/opensslconf.h
+conf_err.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+conf_err.o: ../../include/openssl/stack.h
+conf_lib.o: ../../include/openssl/bio.h ../../include/openssl/conf.h
+conf_lib.o: ../../include/openssl/conf_api.h ../../include/openssl/crypto.h
+conf_lib.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
+conf_lib.o: ../../include/openssl/err.h ../../include/openssl/lhash.h
+conf_lib.o: ../../include/openssl/opensslconf.h
+conf_lib.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+conf_lib.o: ../../include/openssl/stack.h

crypto/conf/conf.h

@@ -67,6 +67,7 @@ extern "C" {
 #include <openssl/lhash.h>
 #include <openssl/stack.h>
 #include <openssl/safestack.h>
+#include <openssl/e_os.h>
 
 typedef struct
 	{
@@ -77,6 +78,25 @@ typedef struct
 
 DECLARE_STACK_OF(CONF_VALUE)
 
+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 *(MS_FAR *create)(CONF_METHOD *meth);
+	int (MS_FAR *init)(CONF *conf);
+	int (MS_FAR *destroy)(CONF *conf);
+	int (MS_FAR *destroy_data)(CONF *conf);
+	int (MS_FAR *load)(CONF *conf, BIO *bp, long *eline);
+	int (MS_FAR *dump)(CONF *conf, BIO *bp);
+	int (MS_FAR *is_number)(CONF *conf, char c);
+	int (MS_FAR *to_int)(CONF *conf, char c);
+	};
+
+int CONF_set_default_method(CONF_METHOD *meth);
 LHASH *CONF_load(LHASH *conf,const char *file,long *eline);
 #ifndef NO_FP_API
 LHASH *CONF_load_fp(LHASH *conf, FILE *fp,long *eline);
@@ -86,8 +106,41 @@ STACK_OF(CONF_VALUE) *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);
 void CONF_free(LHASH *conf);
+void CONF_dump(LHASH *conf, BIO *out);
+int CONF_dump_fp(LHASH *conf, FILE *out);
+int CONF_dump_bio(LHASH *conf, BIO *out);
 void ERR_load_CONF_strings(void );
 
+/* 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 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(CONF *conf,char *section);
+char *NCONF_get_string(CONF *conf,char *group,char *name);
+long NCONF_get_number(CONF *conf,char *group,char *name);
+int NCONF_dump_fp(CONF *conf, FILE *out);
+int NCONF_dump_bio(CONF *conf, BIO *out);
+
 
 /* BEGIN ERROR CODES */
 /* The following lines are auto generated by the script mkerr.pl. Any changes
@@ -97,15 +150,24 @@ 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_NCONF_DUMP_BIO				 105
+#define CONF_F_NCONF_DUMP_FP				 106
+#define CONF_F_NCONF_GET_NUMBER				 107
+#define CONF_F_NCONF_GET_SECTION			 108
+#define CONF_F_NCONF_GET_STRING				 109
+#define CONF_F_NCONF_LOAD_BIO				 110
+#define CONF_F_NCONF_NEW				 111
 #define CONF_F_STR_COPY					 101
 
 /* Reason codes. */
 #define CONF_R_MISSING_CLOSE_SQUARE_BRACKET		 100
 #define CONF_R_MISSING_EQUAL_SIGN			 101
 #define CONF_R_NO_CLOSE_BRACE				 102
+#define CONF_R_NO_CONF					 105
 #define CONF_R_UNABLE_TO_CREATE_NEW_SECTION		 103
 #define CONF_R_VARIABLE_HAS_NO_VALUE			 104
 

crypto/conf/conf_api.c

+/* conf_api.c */
+/* 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.]
+ */
+
+/* Part of the code in here was originally in conf.c, which is now removed */
+
+#include <openssl/conf.h>
+#include <openssl/conf_api.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);
+
+/* This was get_section */
+CONF_VALUE *_CONF_get_section(CONF *conf, char *section)
+	{
+	CONF_VALUE *v,vv;
+
+	if ((conf == NULL) || (section == NULL)) return(NULL);
+	vv.name=NULL;
+	vv.section=section;
+	v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
+	return(v);
+	}
+
+/* This was CONF_get_section */
+STACK_OF(CONF_VALUE) *_CONF_get_section_values(CONF *conf, char *section)
+	{
+	CONF_VALUE *v;
+
+	v=_CONF_get_section(conf,section);
+	if (v != NULL)
+		return((STACK_OF(CONF_VALUE) *)v->value);
+	else
+		return(NULL);
+	}
+
+int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value)
+	{
+	CONF_VALUE *v = NULL;
+	STACK_OF(CONF_VALUE) *ts;
+
+	ts = (STACK_OF(CONF_VALUE) *)section->value;
+
+	value->section=section->section;	
+	if (!sk_CONF_VALUE_push(ts,value))
+		{
+		return 0;
+		}
+
+	v = (CONF_VALUE *)lh_insert(conf->data, value);
+	if (v != NULL)
+		{
+		sk_CONF_VALUE_delete_ptr(ts,v);
+		Free(v->name);
+		Free(v->value);
+		Free(v);
+		}
+	return 1;
+	}
+
+char *_CONF_get_string(CONF *conf, char *section, char *name)
+	{
+	CONF_VALUE *v,vv;
+	char *p;
+
+	if (name == NULL) return(NULL);
+	if (conf != NULL)
+		{
+		if (section != NULL)
+			{
+			vv.name=name;
+			vv.section=section;
+			v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
+			if (v != NULL) return(v->value);
+			if (strcmp(section,"ENV") == 0)
+				{
+				p=Getenv(name);
+				if (p != NULL) return(p);
+				}
+			}
+		vv.section="default";
+		vv.name=name;
+		v=(CONF_VALUE *)lh_retrieve(conf->data,&vv);
+		if (v != NULL)
+			return(v->value);
+		else
+			return(NULL);
+		}
+	else
+		return(Getenv(name));
+	}
+
+long _CONF_get_number(CONF *conf, char *section, char *name)
+	{
+	char *str;
+	long ret=0;
+
+	str=_CONF_get_string(conf,section,name);
+	if (str == NULL) return(0);
+	for (;;)
+		{
+		if (conf->meth->is_number(conf, *str))
+			ret=ret*10+conf->meth->to_int(conf, *str);
+		else
+			return(ret);
+		str++;
+		}
+	}
+
+int _CONF_new_data(CONF *conf)
+	{
+	if (conf == NULL)
+		{
+		return 0;
+		}
+	if (conf->data == NULL)
+		if ((conf->data = lh_new(hash,cmp_conf)) == NULL)
+			{
+			return 0;
+			}
+	return 1;
+	}
+
+void _CONF_free_data(CONF *conf)
+	{
+	if (conf == NULL || conf->data == NULL) return;
+
+	conf->data->down_load=0; /* evil thing to make sure the 'Free()'
+				  * works as expected */
+	lh_doall_arg(conf->data,(void (*)())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_free(conf->data);
+	}
+
+static void value_free_hash(CONF_VALUE *a, LHASH *conf)
+	{
+	if (a->name != NULL)
+		{
+		a=(CONF_VALUE *)lh_delete(conf,a);
+		}
+	}
+
+static void value_free_stack(CONF_VALUE *a, LHASH *conf)
+	{
+	CONF_VALUE *vv;
+	STACK *sk;
+	int i;
+
+	if (a->name != NULL) return;
+
+	sk=(STACK *)a->value;
+	for (i=sk_num(sk)-1; i>=0; i--)
+		{
+		vv=(CONF_VALUE *)sk_value(sk,i);
+		Free(vv->value);
+		Free(vv->name);
+		Free(vv);
+		}
+	if (sk != NULL) sk_free(sk);
+	Free(a->section);
+	Free(a);
+	}
+
+static unsigned long hash(CONF_VALUE *v)
+	{
+	return((lh_strhash(v->section)<<2)^lh_strhash(v->name));
+	}
+
+static int cmp_conf(CONF_VALUE *a, CONF_VALUE *b)
+	{
+	int i;
+
+	if (a->section != b->section)
+		{
+		i=strcmp(a->section,b->section);
+		if (i) return(i);
+		}
+
+	if ((a->name != NULL) && (b->name != NULL))
+		{
+		i=strcmp(a->name,b->name);
+		return(i);
+		}
+	else if (a->name == b->name)
+		return(0);
+	else
+		return((a->name == NULL)?-1:1);
+	}
+
+/* This was new_section */
+CONF_VALUE *_CONF_new_section(CONF *conf, char *section)
+	{
+	STACK *sk=NULL;
+	int ok=0,i;
+	CONF_VALUE *v=NULL,*vv;
+
+	if ((sk=sk_new_null()) == NULL)
+		goto err;
+	if ((v=(CONF_VALUE *)Malloc(sizeof(CONF_VALUE))) == NULL)
+		goto err;
+	i=strlen(section)+1;
+	if ((v->section=(char *)Malloc(i)) == NULL)
+		goto err;
+
+	memcpy(v->section,section,i);
+	v->name=NULL;
+	v->value=(char *)sk;
+	
+	vv=(CONF_VALUE *)lh_insert(conf->data,v);
+	if (vv != NULL)
+		{
+#if !defined(NO_STDIO) && !defined(WIN16)
+		fprintf(stderr,"internal fault\n");
+#endif
+		abort();
+		}
+	ok=1;
+err:
+	if (!ok)
+		{
+		if (sk != NULL) sk_free(sk);
+		if (v != NULL) Free(v);
+		v=NULL;
+		}
+	return(v);
+	}
+
+IMPLEMENT_STACK_OF(CONF_VALUE)

crypto/conf/conf_api.h

+/* conf_api.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.]
+ */
+
+#ifndef  HEADER_CONF_API_H
+#define HEADER_CONF_API_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#include <openssl/lhash.h>
+#include <openssl/conf.h>
+
+/* This was new_section */
+CONF_VALUE *_CONF_new_section(CONF *conf, char *section);
+/* This was get_section */
+CONF_VALUE *_CONF_get_section(CONF *conf, char *section);
+/* 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(CONF *conf, 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);
+
+int _CONF_new_data(CONF *conf);
+void _CONF_free_data(CONF *conf);
+
+#ifdef  __cplusplus
+}
+#endif
+#endif
+

crypto/conf/conf.c → crypto/conf/conf_def.c

@@ -56,72 +56,128 @@
  * [including the GNU Public Licence.]
  */
 
+/* Part of the code in here was originally in conf.c, which is now removed */
+
 #include <stdio.h>
-#include <errno.h>
-#include "cryptlib.h"
 #include <openssl/stack.h>
 #include <openssl/lhash.h>
 #include <openssl/conf.h>
+#include <openssl/conf_api.h>
+#include "conf_def.h"
 #include <openssl/buffer.h>
 #include <openssl/err.h>
 
-#include "conf_lcl.h"
+static char *eat_ws(CONF *conf, char *p);
+static char *eat_alpha_numeric(CONF *conf, char *p);
+static void clear_comments(CONF *conf, char *p);
+static int str_copy(CONF *conf,char *section,char **to, char *from);
+static char *scan_quote(CONF *conf, char *p);
+static char *scan_dquote(CONF *conf, char *p);
+#define scan_esc(p)	(((IS_EOF((conf),(p)[1]))?(p+=1):(p+=2)))
+
+static CONF *def_create(CONF_METHOD *meth);
+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);
+
+const char *CONF_def_version="CONF_def" OPENSSL_VERSION_PTEXT;
+
+static CONF_METHOD default_method = {
+	"OpenSSL default",
+	def_create,
+	def_init_default,
+	def_destroy,
+	def_destroy_data,
+	def_load,
+	def_dump,
+	def_is_number,
+	def_to_int
+	};
+
+static CONF_METHOD WIN32_method = {
+	"WIN32",
+	def_create,
+	def_init_WIN32,
+	def_destroy,
+	def_destroy_data,
+	def_load,
+	def_dump,
+	def_is_number,
+	def_to_int
+	};
+
+CONF_METHOD *NCONF_default()
+	{
+	return &default_method;
+	}
+CONF_METHOD *NCONF_WIN32()
+	{
+	return &WIN32_method;
+	}
 
-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 char *eat_ws(char *p);
-static char *eat_alpha_numeric(char *p);
-static void clear_comments(char *p);
-static int str_copy(LHASH *conf,char *section,char **to, char *from);
-static char *scan_quote(char *p);
-static CONF_VALUE *new_section(LHASH *conf,char *section);
-static CONF_VALUE *get_section(LHASH *conf,char *section);
-#define scan_esc(p)	((((p)[1] == '\0')?(p++):(p+=2)),p)
+static CONF *def_create(CONF_METHOD *meth)
+	{
+	CONF *ret;
 
-const char *CONF_version="CONF" OPENSSL_VERSION_PTEXT;
+	ret = (CONF *)Malloc(sizeof(CONF) + sizeof(unsigned short *));
+	if (ret)
+		if (meth->init(ret) == 0)
+			{
+			Free(ret);
+			ret = NULL;
+			}
+	return ret;
+	}
+	
+static int def_init_default(CONF *conf)
+	{
+	if (conf == NULL)
+		return 0;
+
+	conf->meth = &default_method;
+	conf->meth_data = (void *)CONF_type_default;
+	conf->data = NULL;
 
+	return 1;
+	}
 
-LHASH *CONF_load(LHASH *h, const char *file, long *line)
+static int def_init_WIN32(CONF *conf)
 	{
-	LHASH *ltmp;
-	BIO *in=NULL;
+	if (conf == NULL)
+		return 0;
 
-#ifdef VMS
-	in=BIO_new_file(file, "r");
-#else
-	in=BIO_new_file(file, "rb");
-#endif
-	if (in == NULL)
+	conf->meth = &WIN32_method;
+	conf->meth_data = (void *)CONF_type_win32;
+	conf->data = NULL;
+
+	return 1;
+	}
+
+static int def_destroy(CONF *conf)
+	{
+	if (def_destroy_data(conf))
 		{
-		CONFerr(CONF_F_CONF_LOAD,ERR_R_SYS_LIB);
-		return NULL;
+		Free(conf);
+		return 1;
 		}
+	return 0;
+	}
 
-	ltmp = CONF_load_bio(h, in, line);
-	BIO_free(in);
-
-	return ltmp;
-}
-#ifndef NO_FP_API
-LHASH *CONF_load_fp(LHASH *h, FILE *in, long *line)
-{
-	BIO *btmp;
-	LHASH *ltmp;
-	if(!(btmp = BIO_new_fp(in, BIO_NOCLOSE))) {
-		CONFerr(CONF_F_CONF_LOAD_FP,ERR_R_BUF_LIB);
-		return NULL;
+static int def_destroy_data(CONF *conf)
+	{
+	if (conf == NULL)
+		return 0;
+	_CONF_free_data(conf);
+	return 1;
 	}
-	ltmp = CONF_load_bio(h, btmp, line);
-	BIO_free(btmp);
-	return ltmp;
-}
-#endif
 
-LHASH *CONF_load_bio(LHASH *h, BIO *in, long *line)
+static int def_load(CONF *conf, BIO *in, long *line)
 	{
-	LHASH *ret=NULL;
 #define BUFSIZE	512
 	char btmp[16];
 	int bufnum=0,i,ii;
@@ -129,11 +185,12 @@ LHASH *CONF_load_bio(LHASH *h, BIO *in, long *line)
 	char *s,*p,*end;
 	int again,n;
 	long eline=0;
-	CONF_VALUE *v=NULL,*vv,*tv;
+	CONF_VALUE *v=NULL,*tv;
 	CONF_VALUE *sv=NULL;
 	char *section=NULL,*buf;
 	STACK_OF(CONF_VALUE) *section_sk=NULL,*ts;
 	char *start,*psection,*pname;
+	void *h = (void *)(conf->data);
 
 	if ((buff=BUF_MEM_new()) == NULL)
 		{
@@ -149,18 +206,13 @@ LHASH *CONF_load_bio(LHASH *h, BIO *in, long *line)
 		}
 	strcpy(section,"default");
 
-	if (h == NULL)
+	if (_CONF_new_data(conf) == 0)
 		{
-		if ((ret=lh_new(hash,cmp_conf)) == NULL)
-			{
-			CONFerr(CONF_F_CONF_LOAD_BIO,ERR_R_MALLOC_FAILURE);
-			goto err;
-			}
+		CONFerr(CONF_F_CONF_LOAD_BIO,ERR_R_MALLOC_FAILURE);
+		goto err;
 		}
-	else
-		ret=h;
 
-	sv=new_section(ret,section);
+	sv=_CONF_new_section(conf,section);
 	if (sv == NULL)
 		{
 		CONFerr(CONF_F_CONF_LOAD_BIO,
@@ -213,8 +265,8 @@ LHASH *CONF_load_bio(LHASH *h, BIO *in, long *line)
 			/* If we have bytes and the last char '\\' and
 			 * second last char is not '\\' */
 			p= &(buff->data[bufnum-1]);
-			if (	IS_ESC(p[0]) &&
-				((bufnum <= 1) || !IS_ESC(p[-1])))
+			if (IS_ESC(conf,p[0]) &&
+				((bufnum <= 1) || !IS_ESC(conf,p[-1])))
 				{
 				bufnum--;
 				again=1;
@@ -224,20 +276,20 @@ LHASH *CONF_load_bio(LHASH *h, BIO *in, long *line)
 		bufnum=0;
 		buf=buff->data;
 
-		clear_comments(buf);
+		clear_comments(conf, buf);
 		n=strlen(buf);
-		s=eat_ws(buf);
-		if (IS_EOF(*s)) continue; /* blank line */
+		s=eat_ws(conf, buf);
+		if (IS_EOF(conf,*s)) continue; /* blank line */
 		if (*s == '[')
 			{
 			char *ss;
 
 			s++;
-			start=eat_ws(s);
+			start=eat_ws(conf, s);
 			ss=start;
 again:
-			end=eat_alpha_numeric(ss);
-			p=eat_ws(end);
+			end=eat_alpha_numeric(conf, ss);
+			p=eat_ws(conf, end);
 			if (*p != ']')
 				{
 				if (*p != '\0')
@@ -250,9 +302,9 @@ again:
 				goto err;
 				}
 			*end='\0';
-			if (!str_copy(ret,NULL,&section,start)) goto err;
-			if ((sv=get_section(ret,section)) == NULL)
-				sv=new_section(ret,section);
+			if (!str_copy(conf,NULL,&section,start)) goto err;
+			if ((sv=_CONF_get_section(conf,section)) == NULL)
+				sv=_CONF_new_section(conf,section);
 			if (sv == NULL)
 				{
 				CONFerr(CONF_F_CONF_LOAD_BIO,
@@ -266,16 +318,16 @@ again:
 			{
 			pname=s;
 			psection=NULL;
-			end=eat_alpha_numeric(s);
+			end=eat_alpha_numeric(conf, s);
 			if ((end[0] == ':') && (end[1] == ':'))
 				{
 				*end='\0';
 				end+=2;
 				psection=pname;
 				pname=end;
-				end=eat_alpha_numeric(end);
+				end=eat_alpha_numeric(conf, end);
 				}
-			p=eat_ws(end);
+			p=eat_ws(conf, end);
 			if (*p != '=')
 				{
 				CONFerr(CONF_F_CONF_LOAD_BIO,
@@ -284,11 +336,11 @@ again:
 				}
 			*end='\0';
 			p++;
-			start=eat_ws(p);
-			while (!IS_EOF(*p))
+			start=eat_ws(conf, p);
+			while (!IS_EOF(conf,*p))
 				p++;
 			p--;
-			while ((p != start) && (IS_WS(*p)))
+			while ((p != start) && (IS_WS(conf,*p)))
 				p--;
 			p++;
 			*p='\0';
@@ -309,13 +361,13 @@ again:
 				goto err;
 				}
 			strcpy(v->name,pname);
-			if (!str_copy(ret,psection,&(v->value),start)) goto err;
+			if (!str_copy(conf,psection,&(v->value),start)) goto err;
 
 			if (strcmp(psection,section) != 0)
 				{
-				if ((tv=get_section(ret,psection))
+				if ((tv=_CONF_get_section(conf,psection))
 					== NULL)
-					tv=new_section(ret,psection);
+					tv=_CONF_new_section(conf,psection);
 				if (tv == NULL)
 					{
 					CONFerr(CONF_F_CONF_LOAD_BIO,
@@ -329,6 +381,14 @@ again:
 				tv=sv;
 				ts=section_sk;
 				}
+#if 1
+			if (_CONF_add_string(conf, tv, v) == 0)
+				{
+				CONFerr(CONF_F_CONF_LOAD_BIO,
+							ERR_R_MALLOC_FAILURE);
+				goto err;
+				}
+#else
 			v->section=tv->section;	
 			if (!sk_CONF_VALUE_push(ts,v))
 				{
@@ -336,7 +396,7 @@ again:
 							ERR_R_MALLOC_FAILURE);
 				goto err;
 				}
-			vv=(CONF_VALUE *)lh_insert(ret,v);
+			vv=(CONF_VALUE *)lh_insert(conf->data,v);
 			if (vv != NULL)
 				{
 				sk_CONF_VALUE_delete_ptr(ts,vv);
@@ -344,173 +404,78 @@ again:
 				Free(vv->value);
 				Free(vv);
 				}
+#endif
 			v=NULL;
 			}
 		}
 	if (buff != NULL) BUF_MEM_free(buff);
 	if (section != NULL) Free(section);
-	return(ret);
+	return(1);
 err:
 	if (buff != NULL) BUF_MEM_free(buff);
 	if (section != NULL) Free(section);
 	if (line != NULL) *line=eline;
 	sprintf(btmp,"%ld",eline);
 	ERR_add_error_data(2,"line ",btmp);
-	if ((h != ret) && (ret != NULL)) CONF_free(ret);
+	if ((h != conf->data) && (conf->data != NULL)) CONF_free(conf->data);
 	if (v != NULL)
 		{
 		if (v->name != NULL) Free(v->name);
 		if (v->value != NULL) Free(v->value);
 		if (v != NULL) Free(v);
 		}
-	return(NULL);
+	return(0);
 	}
 
-char *CONF_get_string(LHASH *conf, char *section, char *name)
+static void clear_comments(CONF *conf, char *p)
 	{
-	CONF_VALUE *v,vv;
-	char *p;
+	char *to;
 
-	if (name == NULL) return(NULL);
-	if (conf != NULL)
+	to=p;
+	for (;;)
 		{
-		if (section != NULL)
+		if (IS_FCOMMENT(conf,*p))
 			{
-			vv.name=name;
-			vv.section=section;
-			v=(CONF_VALUE *)lh_retrieve(conf,&vv);
-			if (v != NULL) return(v->value);
-			if (strcmp(section,"ENV") == 0)
-				{
-				p=Getenv(name);
-				if (p != NULL) return(p);
-				}
+			*p='\0';
+			return;
 			}
-		vv.section="default";
-		vv.name=name;
-		v=(CONF_VALUE *)lh_retrieve(conf,&vv);
-		if (v != NULL)
-			return(v->value);
-		else
-			return(NULL);
-		}
-	else
-		return(Getenv(name));
-	}
-
-static CONF_VALUE *get_section(LHASH *conf, char *section)
-	{
-	CONF_VALUE *v,vv;
-
-	if ((conf == NULL) || (section == NULL)) return(NULL);
-	vv.name=NULL;
-	vv.section=section;
-	v=(CONF_VALUE *)lh_retrieve(conf,&vv);
-	return(v);
-	}
-
-STACK_OF(CONF_VALUE) *CONF_get_section(LHASH *conf, char *section)
-	{
-	CONF_VALUE *v;
-
-	v=get_section(conf,section);
-	if (v != NULL)
-		return((STACK_OF(CONF_VALUE) *)v->value);
-	else
-		return(NULL);
-	}
-
-long CONF_get_number(LHASH *conf, char *section, char *name)
-	{
-	char *str;
-	long ret=0;
-
-	str=CONF_get_string(conf,section,name);
-	if (str == NULL) return(0);
-	for (;;)
-		{
-		if (IS_NUMER(*str))
-			ret=ret*10+(*str -'0');
-		else
-			return(ret);
-		str++;
-		}
-	}
-
-void CONF_free(LHASH *conf)
-	{
-	if (conf == NULL) return;
-
-	conf->down_load=0; 	/* evil thing to make sure the 'Free()'
-				 * works as expected */
-	lh_doall_arg(conf,(void (*)())value_free_hash,conf);
-
-	/* We now have only 'section' entries in the hash table.
-	 * Due to problems with */
-
-	lh_doall_arg(conf,(void (*)())value_free_stack,conf);
-	lh_free(conf);
-	}
-
-static void value_free_hash(CONF_VALUE *a, LHASH *conf)
-	{
-	if (a->name != NULL)
-		{
-		a=(CONF_VALUE *)lh_delete(conf,a);
-		}
-	}
-
-static void value_free_stack(CONF_VALUE *a, LHASH *conf)
-	{
-	CONF_VALUE *vv;
-	STACK *sk;
-	int i;
-
-	if (a->name != NULL) return;
-
-	sk=(STACK *)a->value;
-	for (i=sk_num(sk)-1; i>=0; i--)
-		{
-		vv=(CONF_VALUE *)sk_value(sk,i);
-		Free(vv->value);
-		Free(vv->name);
-		Free(vv);
+		if (!IS_WS(conf,*p))
+			{
+			break;
+			}
+		p++;
 		}
-	if (sk != NULL) sk_free(sk);
-	Free(a->section);
-	Free(a);
-	}
 
-static void clear_comments(char *p)
-	{
-	char *to;
-
-	to=p;
 	for (;;)
 		{
-		if (IS_COMMENT(*p))
+		if (IS_COMMENT(conf,*p))
 			{
 			*p='\0';
 			return;
 			}
-		if (IS_QUOTE(*p))
+		if (IS_DQUOTE(conf,*p))
 			{
-			p=scan_quote(p);
+			p=scan_dquote(conf, p);
 			continue;
 			}
-		if (IS_ESC(*p))
+		if (IS_QUOTE(conf,*p))
+			{
+			p=scan_quote(conf, p);
+			continue;
+			}
+		if (IS_ESC(conf,*p))
 			{
 			p=scan_esc(p);
 			continue;
 			}
-		if (IS_EOF(*p))
+		if (IS_EOF(conf,*p))
 			return;
 		else
 			p++;
 		}
 	}
 
-static int str_copy(LHASH *conf, char *section, char **pto, char *from)
+static int str_copy(CONF *conf, char *section, char **pto, char *from)
 	{
 	int q,r,rr=0,to=0,len=0;
 	char *s,*e,*rp,*p,*rrp,*np,*cp,v;
@@ -523,32 +488,54 @@ static int str_copy(LHASH *conf, char *section, char **pto, char *from)
 
 	for (;;)
 		{
-		if (IS_QUOTE(*from))
+		if (IS_QUOTE(conf,*from))
 			{
 			q= *from;
 			from++;
-			while ((*from != '\0') && (*from != q))
+			while (!IS_EOF(conf,*from) && (*from != q))
 				{
-				if (*from == '\\')
+				if (IS_ESC(conf,*from))
 					{
 					from++;
-					if (*from == '\0') break;
+					if (IS_EOF(conf,*from)) break;
+					}
+				buf->data[to++]= *(from++);
+				}
+			if (*from == q) from++;
+			}
+		else if (IS_DQUOTE(conf,*from))
+			{
+			q= *from;
+			from++;
+			while (!IS_EOF(conf,*from))
+				{
+				if (*from == q)
+					{
+					if (*(from+1) == q)
+						{
+						from++;
+						}
+					else
+						{
+						break;
+						}
 					}
 				buf->data[to++]= *(from++);
 				}
+			if (*from == q) from++;
 			}
-		else if (*from == '\\')
+		else if (IS_ESC(conf,*from))
 			{
 			from++;
 			v= *(from++);
-			if (v == '\0') break;
+			if (IS_EOF(conf,v)) break;
 			else if (v == 'r') v='\r';
 			else if (v == 'n') v='\n';
 			else if (v == 'b') v='\b';
 			else if (v == 't') v='\t';
 			buf->data[to++]= v;
 			}
-		else if (*from == '\0')
+		else if (IS_EOF(conf,*from))
 			break;
 		else if (*from == '$')
 			{
@@ -564,7 +551,7 @@ static int str_copy(LHASH *conf, char *section, char **pto, char *from)
 			if (q) s++;
 			cp=section;
 			e=np=s;
-			while (IS_ALPHA_NUMERIC(*e))
+			while (IS_ALPHA_NUMERIC(conf,*e))
 				e++;
 			if ((e[0] == ':') && (e[1] == ':'))
 				{
@@ -574,7 +561,7 @@ static int str_copy(LHASH *conf, char *section, char **pto, char *from)
 				*rrp='\0';
 				e+=2;
 				np=e;
-				while (IS_ALPHA_NUMERIC(*e))
+				while (IS_ALPHA_NUMERIC(conf,*e))
 					e++;
 				}
 			r= *e;
@@ -598,7 +585,7 @@ static int str_copy(LHASH *conf, char *section, char **pto, char *from)
 			 * r and s are the chars replaced by the '\0'
 			 * rp and sp is where 'r' and 's' came from.
 			 */
-			p=CONF_get_string(conf,cp,np);
+			p=_CONF_get_string(conf,cp,np);
 			if (rrp != NULL) *rrp=rr;
 			*rp=r;
 			if (p == NULL)
@@ -624,65 +611,64 @@ err:
 	return(0);
 	}
 
-static char *eat_ws(char *p)
+static char *eat_ws(CONF *conf, char *p)
 	{
-	while (IS_WS(*p) && (!IS_EOF(*p)))
+	while (IS_WS(conf,*p) && (!IS_EOF(conf,*p)))
 		p++;
 	return(p);
 	}
 
-static char *eat_alpha_numeric(char *p)
+static char *eat_alpha_numeric(CONF *conf, char *p)
 	{
 	for (;;)
 		{
-		if (IS_ESC(*p))
+		if (IS_ESC(conf,*p))
 			{
 			p=scan_esc(p);
 			continue;
 			}
-		if (!IS_ALPHA_NUMERIC_PUNCT(*p))
+		if (!IS_ALPHA_NUMERIC_PUNCT(conf,*p))
 			return(p);
 		p++;
 		}
 	}
 
-static unsigned long hash(CONF_VALUE *v)
+static char *scan_quote(CONF *conf, char *p)
 	{
-	return((lh_strhash(v->section)<<2)^lh_strhash(v->name));
-	}
-
-static int cmp_conf(CONF_VALUE *a, CONF_VALUE *b)
-	{
-	int i;
-
-	if (a->section != b->section)
-		{
-		i=strcmp(a->section,b->section);
-		if (i) return(i);
-		}
+	int q= *p;
 
-	if ((a->name != NULL) && (b->name != NULL))
+	p++;
+	while (!(IS_EOF(conf,*p)) && (*p != q))
 		{
-		i=strcmp(a->name,b->name);
-		return(i);
+		if (IS_ESC(conf,*p))
+			{
+			p++;
+			if (IS_EOF(conf,*p)) return(p);
+			}
+		p++;
 		}
-	else if (a->name == b->name)
-		return(0);
-	else
-		return((a->name == NULL)?-1:1);
+	if (*p == q) p++;
+	return(p);
 	}
 
-static char *scan_quote(char *p)
+
+static char *scan_dquote(CONF *conf, char *p)
 	{
 	int q= *p;
 
 	p++;
-	while (!(IS_EOF(*p)) && (*p != q))
+	while (!(IS_EOF(conf,*p)))
 		{
-		if (IS_ESC(*p))
+		if (*p == q)
 			{
-			p++;
-			if (IS_EOF(*p)) return(p);
+			if (*(p+1) == q)
+				{
+				p++;
+				}
+			else
+				{
+				break;
+				}
 			}
 		p++;
 		}
@@ -690,41 +676,27 @@ static char *scan_quote(char *p)
 	return(p);
 	}
 
-static CONF_VALUE *new_section(LHASH *conf, char *section)
+static void dump_value(CONF_VALUE *a, BIO *out)
+	{
+	if (a->name)
+		BIO_printf(out, "[%s] %s=%s\n", a->section, a->name, a->value);
+	else
+		BIO_printf(out, "[[%s]]\n", a->section);
+	}
+
+static int def_dump(CONF *conf, BIO *out)
 	{
-	STACK *sk=NULL;
-	int ok=0,i;
-	CONF_VALUE *v=NULL,*vv;
+	lh_doall_arg(conf->data, (void (*)())dump_value, out);
+	return 1;
+	}
 
-	if ((sk=sk_new_null()) == NULL)
-		goto err;
-	if ((v=(CONF_VALUE *)Malloc(sizeof(CONF_VALUE))) == NULL)
-		goto err;
-	i=strlen(section)+1;
-	if ((v->section=(char *)Malloc(i)) == NULL)
-		goto err;
+static int def_is_number(CONF *conf, char c)
+	{
+	return IS_NUMBER(conf,c);
+	}
 
-	memcpy(v->section,section,i);
-	v->name=NULL;
-	v->value=(char *)sk;
-	
-	vv=(CONF_VALUE *)lh_insert(conf,v);
-	if (vv != NULL)
-		{
-#if !defined(NO_STDIO) && !defined(WIN16)
-		fprintf(stderr,"internal fault\n");
-#endif
-		abort();
-		}
-	ok=1;
-err:
-	if (!ok)
-		{
-		if (sk != NULL) sk_free(sk);
-		if (v != NULL) Free(v);
-		v=NULL;
-		}
-	return(v);
+static int def_to_int(CONF *conf, char c)
+	{
+	return c - '0';
 	}
 
-IMPLEMENT_STACK_OF(CONF_VALUE)

crypto/conf/conf_lcl.h → crypto/conf/conf_def.h

-/* crypto/conf/conf_lcl.h */
+/* crypto/conf/conf_def.h */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -56,6 +56,9 @@
  * [including the GNU Public Licence.]
  */
 
+/* THIS FILE WAS AUTOMAGICALLY GENERATED!
+   Please modify and use keysets.pl to regenerate it. */
+
 #define CONF_NUMBER		1
 #define CONF_UPPER		2
 #define CONF_LOWER		4
@@ -64,38 +67,45 @@
 #define CONF_WS			16
 #define CONF_ESC		32
 #define CONF_QUOTE		64
+#define CONF_DQUOTE		1024
 #define CONF_COMMENT		128
+#define CONF_FCOMMENT		2048
 #define CONF_EOF		8
 #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| \
 					CONF_PUNCTUATION)
 
+#define KEYTYPES(c)		((unsigned short *)((c)->meth_data))
 #ifndef CHARSET_EBCDIC
-#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_ALPHA_NUMERIC_PUNCT(a) \
-				(CONF_type[(a)&0x7f]&CONF_ALPHA_NUMERIC_PUNCT)
-#define IS_QUOTE(a)		(CONF_type[(a)&0x7f]&CONF_QUOTE)
+#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_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)
 
 #else /*CHARSET_EBCDIC*/
 
-#define IS_COMMENT(a)		(CONF_COMMENT&(CONF_type[os_toascii[a]&0x7f]))
-#define IS_EOF(a)		(os_toascii[a] == '\0')
-#define IS_ESC(a)		(os_toascii[a] == '\\')
-#define IS_NUMER(a)		(CONF_type[os_toascii[a]&0x7f]&CONF_NUMBER)
-#define IS_WS(a)		(CONF_type[os_toascii[a]&0x7f]&CONF_WS)
-#define IS_ALPHA_NUMERIC(a)	(CONF_type[os_toascii[a]&0x7f]&CONF_ALPHA_NUMERIC)
-#define IS_ALPHA_NUMERIC_PUNCT(a) \
-				(CONF_type[os_toascii[a]&0x7f]&CONF_ALPHA_NUMERIC_PUNCT)
-#define IS_QUOTE(a)		(CONF_type[os_toascii[a]&0x7f]&CONF_QUOTE)
+#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_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)
 #endif /*CHARSET_EBCDIC*/
 
-static unsigned short CONF_type[128]={
+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,
@@ -114,3 +124,22 @@ static unsigned short CONF_type[128]={
 	0x004,0x004,0x004,0x000,0x200,0x000,0x200,0x000,
 	};
 
+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,
+	};
+

crypto/conf/conf_err.c

@@ -66,9 +66,17 @@
 #ifndef 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_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_SECTION,0),	"NCONF_get_section"},
+{ERR_PACK(0,CONF_F_NCONF_GET_STRING,0),	"NCONF_get_string"},
+{ERR_PACK(0,CONF_F_NCONF_LOAD_BIO,0),	"NCONF_load_bio"},
+{ERR_PACK(0,CONF_F_NCONF_NEW,0),	"NCONF_new"},
 {ERR_PACK(0,CONF_F_STR_COPY,0),	"STR_COPY"},
 {0,NULL}
 	};
@@ -78,6 +86,7 @@ static ERR_STRING_DATA CONF_str_reasons[]=
 {CONF_R_MISSING_CLOSE_SQUARE_BRACKET     ,"missing close square bracket"},
 {CONF_R_MISSING_EQUAL_SIGN               ,"missing equal sign"},
 {CONF_R_NO_CLOSE_BRACE                   ,"no close brace"},
+{CONF_R_NO_CONF                          ,"no conf"},
 {CONF_R_UNABLE_TO_CREATE_NEW_SECTION     ,"unable to create new section"},
 {CONF_R_VARIABLE_HAS_NO_VALUE            ,"variable has no value"},
 {0,NULL}

crypto/conf/conf_lib.c

+/* conf_lib.c */
+/* Written by Richard Levitte (richard@levitte.org) for the OpenSSL
+ * project 2000.
+ */
+/* ====================================================================
+ * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
+ *
+ * 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 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 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
+ *    licensing@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).
+ *
+ */
+
+#include <stdio.h>
+#include <openssl/crypto.h>
+#include <openssl/err.h>
+#include <openssl/conf.h>
+#include <openssl/conf_api.h>
+#include <openssl/lhash.h>
+
+const char *CONF_version="CONF" OPENSSL_VERSION_PTEXT;
+
+static CONF_METHOD *default_CONF_method=NULL;
+
+/* The following section contains the "CONF classic" functions,
+   rewritten in terms of the new CONF interface. */
+
+int CONF_set_default_method(CONF_METHOD *meth)
+	{
+	default_CONF_method = meth;
+	return 1;
+	}
+
+LHASH *CONF_load(LHASH *conf, const char *file, long *eline)
+	{
+	LHASH *ltmp;
+	BIO *in=NULL;
+
+#ifdef VMS
+	in=BIO_new_file(file, "r");
+#else
+	in=BIO_new_file(file, "rb");
+#endif
+	if (in == NULL)
+		{
+		CONFerr(CONF_F_CONF_LOAD,ERR_R_SYS_LIB);
+		return NULL;
+		}
+
+	ltmp = CONF_load_bio(conf, in, eline);
+	BIO_free(in);
+
+	return ltmp;
+	}
+
+#ifndef NO_FP_API
+LHASH *CONF_load_fp(LHASH *conf, FILE *fp,long *eline)
+	{
+	BIO *btmp;
+	LHASH *ltmp;
+	if(!(btmp = BIO_new_fp(fp, BIO_NOCLOSE))) {
+		CONFerr(CONF_F_CONF_LOAD_FP,ERR_R_BUF_LIB);
+		return NULL;
+	}
+	ltmp = CONF_load_bio(conf, btmp, eline);
+	BIO_free(btmp);
+	return ltmp;
+	}
+#endif
+
+LHASH *CONF_load_bio(LHASH *conf, BIO *bp,long *eline)
+	{
+	CONF ctmp;
+	int ret;
+
+	if (default_CONF_method == NULL)
+		default_CONF_method = NCONF_default();
+
+	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)
+	{
+	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);
+	}
+
+char *CONF_get_string(LHASH *conf,char *group,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);
+	}
+
+long CONF_get_number(LHASH *conf,char *group,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_number(&ctmp, group, name);
+	}
+
+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;
+	NCONF_free_data(&ctmp);
+	}
+
+#ifndef NO_FP_API
+int CONF_dump_fp(LHASH *conf, FILE *out)
+	{
+	BIO *btmp;
+	int ret;
+
+	if(!(btmp = BIO_new_fp(out, BIO_NOCLOSE))) {
+		CONFerr(CONF_F_CONF_DUMP_FP,ERR_R_BUF_LIB);
+		return 0;
+	}
+	ret = CONF_dump_bio(conf, btmp);
+	BIO_free(btmp);
+	return ret;
+	}
+#endif
+
+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;
+	return NCONF_dump_bio(&ctmp, out);
+	}
+
+/* The following section contains the "New CONF" functions.  They are
+   completely centralised around a new CONF structure that may contain
+   basically anything, but at least a method pointer and a table of data.
+   These functions are also written in terms of the bridge functions used
+   by the "CONF classic" functions, for consistency.  */
+
+CONF *NCONF_new(CONF_METHOD *meth)
+	{
+	CONF *ret;
+
+	if (meth == NULL)
+		meth = NCONF_default();
+
+	ret = meth->create(meth);
+	if (ret == NULL)
+		{
+		RSAerr(CONF_F_NCONF_NEW,ERR_R_MALLOC_FAILURE);
+		return(NULL);
+		}
+
+	return ret;
+	}
+
+void NCONF_free(CONF *conf)
+	{
+	if (conf == NULL)
+		return;
+	conf->meth->destroy(conf);
+	}
+
+void NCONF_free_data(CONF *conf)
+	{
+	if (conf == NULL)
+		return;
+	conf->meth->destroy_data(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)
+		{
+		CONFerr(CONF_F_CONF_LOAD,ERR_R_SYS_LIB);
+		return 0;
+		}
+
+	ret = NCONF_load_bio(conf, in, eline);
+	BIO_free(in);
+
+	return ret;
+	}
+
+#ifndef 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);
+		return 0;
+		}
+	ret = NCONF_load_bio(conf, btmp, eline);
+	BIO_free(btmp);
+	return ret;
+	}
+#endif
+
+int NCONF_load_bio(CONF *conf, BIO *bp,long *eline)
+	{
+	if (conf == NULL)
+		{
+		CONFerr(CONF_F_NCONF_LOAD_BIO,CONF_R_NO_CONF);
+		return 0;
+		}
+
+	return conf->meth->load(conf, bp, eline);
+	}
+
+STACK_OF(CONF_VALUE) *NCONF_get_section(CONF *conf,char *section)
+	{
+	if (conf == NULL)
+		{
+		CONFerr(CONF_F_NCONF_GET_SECTION,CONF_R_NO_CONF);
+		return NULL;
+		}
+
+	return _CONF_get_section_values(conf, section);
+	}
+
+char *NCONF_get_string(CONF *conf,char *group,char *name)
+	{
+	if (conf == NULL)
+		{
+		CONFerr(CONF_F_NCONF_GET_STRING,CONF_R_NO_CONF);
+		return NULL;
+		}
+
+	return _CONF_get_string(conf, group, name);
+	}
+
+long NCONF_get_number(CONF *conf,char *group,char *name)
+	{
+	if (conf == NULL)
+		{
+		CONFerr(CONF_F_NCONF_GET_NUMBER,CONF_R_NO_CONF);
+		return 0;
+		}
+	
+	return _CONF_get_number(conf, group, name);
+	}
+
+#ifndef NO_FP_API
+int NCONF_dump_fp(CONF *conf, FILE *out)
+	{
+	BIO *btmp;
+	int ret;
+	if(!(btmp = BIO_new_fp(out, BIO_NOCLOSE))) {
+		CONFerr(CONF_F_NCONF_DUMP_FP,ERR_R_BUF_LIB);
+		return 0;
+	}
+	ret = NCONF_dump_bio(conf, btmp);
+	BIO_free(btmp);
+	return ret;
+	}
+#endif
+
+int NCONF_dump_bio(CONF *conf, BIO *out)
+	{
+	if (conf == NULL)
+		{
+		CONFerr(CONF_F_NCONF_DUMP_BIO,CONF_R_NO_CONF);
+		return 0;
+		}
+
+	return conf->meth->dump(conf, out);
+	}
+

crypto/conf/keysets.pl

@@ -3,12 +3,15 @@
 $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;
 
 foreach (0 .. 127)
 	{
@@ -18,44 +21,159 @@ 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/);
 
-	push(@V,$v);
+	push(@V_def,$v);
+	}
+
+foreach (0 .. 127)
+	{
+	$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/);
+
+	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_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)&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_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)
+
+#else /*CHARSET_EBCDIC*/
 
-#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)
+#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_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)
+#endif /*CHARSET_EBCDIC*/
 
 EOF
 
-print "static unsigned short CONF_type[128]={";
+print "static unsigned short CONF_type_default[128]={";
+
+for ($i=0; $i<128; $i++)
+	{
+	print "\n\t" if ($i % 8) == 0;
+	printf "0x%03X,",$V_def[$i];
+	}
+
+print "\n\t};\n\n";
+
+print "static unsigned short CONF_type_win32[128]={";
 
 for ($i=0; $i<128; $i++)
 	{
 	print "\n\t" if ($i % 8) == 0;
-	printf "0x%03X,",$V[$i];
+	printf "0x%03X,",$V_w32[$i];
 	}
 
-print "\n\t};\n";
+print "\n\t};\n\n";

crypto/conf/test.c

@@ -67,7 +67,10 @@ main()
 	long eline;
 	char *s,*s2;
 
-	conf=CONF_load(NULL,"openssl.conf",&eline);
+#ifdef USE_WIN32
+	CONF_set_default_method(CONF_WIN32);
+#endif
+	conf=CONF_load(NULL,"ssleay.cnf",&eline);
 	if (conf == NULL)
 		{
 		ERR_load_crypto_strings();
@@ -88,5 +91,8 @@ main()
 	s=CONF_get_string(conf,"s_client","cipher1");
 	printf("s_client:cipher1=%s\n",(s == NULL)?"NULL":s);
 
+	printf("---------------------------- DUMP ------------------------\n");
+	CONF_dump_fp(conf, stdout);
+
 	exit(0);
 	}