mirrors/openssl
0
0
Fork 0
mirror of https://github.com/openssl/openssl.git synced 2024-11-24 02:23:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
Richard Levitte 2000-04-09 12:04:35 +00:00
parent 05e15b046f
commit d86b6915be
10 changed files with 1277 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
crypto/conf/Makefile.ssl
View File

@ -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

62
crypto/conf/conf.h
View File

@ -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

288
crypto/conf/conf_api.c Normal file
View File

@ -0,0 +1,288 @@
/* 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)

88
crypto/conf/conf_api.h Normal file
View File

@ -0,0 +1,88 @@
/* 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

542
crypto/conf/conf.c → crypto/conf/conf_def.c
View File

@ -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 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);
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_version="CONF" OPENSSL_VERSION_PTEXT;
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
};
LHASH *CONF_load(LHASH *h, const char *file, long *line)
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()
{
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(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;
return &default_method;
}
ltmp = CONF_load_bio(h, btmp, line);
BIO_free(btmp);
return ltmp;
}
#endif
LHASH *CONF_load_bio(LHASH *h, BIO *in, long *line)
CONF_METHOD *NCONF_WIN32()
{
return &WIN32_method;
}
static CONF *def_create(CONF_METHOD *meth)
{
CONF *ret;
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;
}
static int def_init_WIN32(CONF *conf)
{
if (conf == NULL)
return 0;
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))
{
Free(conf);
return 1;
}
return 0;
}
static int def_destroy_data(CONF *conf)
{
if (conf == NULL)
return 0;
_CONF_free_data(conf);
return 1;
}
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)
{
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,&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,&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 (sk != NULL) sk_free(sk);
Free(a->section);
Free(a);
}
static void clear_comments(char *p)
static void clear_comments(CONF *conf, char *p)
{
char *to;
to=p;
for (;;)
{
if (IS_COMMENT(*p))
if (IS_FCOMMENT(conf,*p))
{
*p='\0';
return;
}
if (IS_QUOTE(*p))
if (!IS_WS(conf,*p))
{
p=scan_quote(p);
break;
}
p++;
}
for (;;)
{
if (IS_COMMENT(conf,*p))
{
*p='\0';
return;
}
if (IS_DQUOTE(conf,*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 (*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 (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,39 @@ 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)
{
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);
}
static char *scan_quote(char *p)
static char *scan_quote(CONF *conf, char *p)
{
int q= *p;
p++;
while (!(IS_EOF(*p)) && (*p != q))
while (!(IS_EOF(conf,*p)) && (*p != q))
{
if (IS_ESC(*p))
if (IS_ESC(conf,*p))
{
p++;
if (IS_EOF(*p)) return(p);
if (IS_EOF(conf,*p)) return(p);
}
p++;
}
@ -690,41 +651,52 @@ static char *scan_quote(char *p)
return(p);
}
static CONF_VALUE *new_section(LHASH *conf, char *section)
static char *scan_dquote(CONF *conf, char *p)
{
STACK *sk=NULL;
int ok=0,i;
CONF_VALUE *v=NULL,*vv;
int q= *p;
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,v);
if (vv != NULL)
p++;
while (!(IS_EOF(conf,*p)))
{
#if !defined(NO_STDIO) && !defined(WIN16)
fprintf(stderr,"internal fault\n");
#endif
abort();
if (*p == q)
{
if (*(p+1) == q)
{
p++;
}
else
{
break;
}
}
p++;
}
ok=1;
err:
if (!ok)
{
if (sk != NULL) sk_free(sk);
if (v != NULL) Free(v);
v=NULL;
}
return(v);
if (*p == q) p++;
return(p);
}
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)
{
lh_doall_arg(conf->data, (void (*)())dump_value, out);
return 1;
}
static int def_is_number(CONF *conf, char c)
{
return IS_NUMBER(conf,c);
}
static int def_to_int(CONF *conf, char c)
{
return c - '0';
}
IMPLEMENT_STACK_OF(CONF_VALUE)

69
crypto/conf/conf_lcl.h → crypto/conf/conf_def.h
View File

@ -1,4 +1,4 @@
/* 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,
};

9
crypto/conf/conf_err.c
View File

@ -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}

352
crypto/conf/conf_lib.c Normal file
View File

@ -0,0 +1,352 @@
/* 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);
}

152
crypto/conf/keysets.pl
View File

@ -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 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 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(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[$i];
printf "0x%03X,",$V_def[$i];
}
print "\n\t};\n";
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_w32[$i];
}
print "\n\t};\n\n";

8
crypto/conf/test.c
View File

@ -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);
}