mirror of
https://github.com/ossrs/srs.git
synced 2025-03-09 15:49:59 +00:00
Upgrade openssl from 1.1.0e to 1.1.1b, with source code. 4.0.78
This commit is contained in:
parent
8f1c992379
commit
96dbd7bced
1476 changed files with 616554 additions and 4 deletions
4
trunk/3rdparty/openssl-1.1-fit/crypto/conf/build.info
vendored
Normal file
4
trunk/3rdparty/openssl-1.1-fit/crypto/conf/build.info
vendored
Normal file
|
@ -0,0 +1,4 @@
|
|||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]= \
|
||||
conf_err.c conf_lib.c conf_api.c conf_def.c conf_mod.c \
|
||||
conf_mall.c conf_sap.c conf_ssl.c
|
218
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_api.c
vendored
Normal file
218
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_api.c
vendored
Normal file
|
@ -0,0 +1,218 @@
|
|||
/*
|
||||
* Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
/* Part of the code in here was originally in conf.c, which is now removed */
|
||||
|
||||
#include "e_os.h"
|
||||
#include "internal/cryptlib.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <openssl/conf.h>
|
||||
#include <openssl/conf_api.h>
|
||||
|
||||
static void value_free_hash(const CONF_VALUE *a, LHASH_OF(CONF_VALUE) *conf);
|
||||
static void value_free_stack_doall(CONF_VALUE *a);
|
||||
|
||||
/* Up until OpenSSL 0.9.5a, this was get_section */
|
||||
CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section)
|
||||
{
|
||||
CONF_VALUE *v, vv;
|
||||
|
||||
if ((conf == NULL) || (section == NULL))
|
||||
return NULL;
|
||||
vv.name = NULL;
|
||||
vv.section = (char *)section;
|
||||
v = lh_CONF_VALUE_retrieve(conf->data, &vv);
|
||||
return v;
|
||||
}
|
||||
|
||||
/* Up until OpenSSL 0.9.5a, this was CONF_get_section */
|
||||
STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf,
|
||||
const 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 = lh_CONF_VALUE_insert(conf->data, value);
|
||||
if (v != NULL) {
|
||||
(void)sk_CONF_VALUE_delete_ptr(ts, v);
|
||||
OPENSSL_free(v->name);
|
||||
OPENSSL_free(v->value);
|
||||
OPENSSL_free(v);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
char *_CONF_get_string(const CONF *conf, const char *section,
|
||||
const char *name)
|
||||
{
|
||||
CONF_VALUE *v, vv;
|
||||
char *p;
|
||||
|
||||
if (name == NULL)
|
||||
return NULL;
|
||||
if (conf != NULL) {
|
||||
if (section != NULL) {
|
||||
vv.name = (char *)name;
|
||||
vv.section = (char *)section;
|
||||
v = lh_CONF_VALUE_retrieve(conf->data, &vv);
|
||||
if (v != NULL)
|
||||
return v->value;
|
||||
if (strcmp(section, "ENV") == 0) {
|
||||
p = ossl_safe_getenv(name);
|
||||
if (p != NULL)
|
||||
return p;
|
||||
}
|
||||
}
|
||||
vv.section = "default";
|
||||
vv.name = (char *)name;
|
||||
v = lh_CONF_VALUE_retrieve(conf->data, &vv);
|
||||
if (v != NULL)
|
||||
return v->value;
|
||||
else
|
||||
return NULL;
|
||||
} else
|
||||
return ossl_safe_getenv(name);
|
||||
}
|
||||
|
||||
static unsigned long conf_value_hash(const CONF_VALUE *v)
|
||||
{
|
||||
return (OPENSSL_LH_strhash(v->section) << 2) ^ OPENSSL_LH_strhash(v->name);
|
||||
}
|
||||
|
||||
static int conf_value_cmp(const CONF_VALUE *a, const 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);
|
||||
}
|
||||
|
||||
int _CONF_new_data(CONF *conf)
|
||||
{
|
||||
if (conf == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (conf->data == NULL) {
|
||||
conf->data = lh_CONF_VALUE_new(conf_value_hash, conf_value_cmp);
|
||||
if (conf->data == NULL)
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
typedef LHASH_OF(CONF_VALUE) LH_CONF_VALUE;
|
||||
|
||||
IMPLEMENT_LHASH_DOALL_ARG_CONST(CONF_VALUE, LH_CONF_VALUE);
|
||||
|
||||
void _CONF_free_data(CONF *conf)
|
||||
{
|
||||
if (conf == NULL || conf->data == NULL)
|
||||
return;
|
||||
|
||||
/* evil thing to make sure the 'OPENSSL_free()' works as expected */
|
||||
lh_CONF_VALUE_set_down_load(conf->data, 0);
|
||||
lh_CONF_VALUE_doall_LH_CONF_VALUE(conf->data, value_free_hash, conf->data);
|
||||
|
||||
/*
|
||||
* We now have only 'section' entries in the hash table. Due to problems
|
||||
* with
|
||||
*/
|
||||
|
||||
lh_CONF_VALUE_doall(conf->data, value_free_stack_doall);
|
||||
lh_CONF_VALUE_free(conf->data);
|
||||
}
|
||||
|
||||
static void value_free_hash(const CONF_VALUE *a, LHASH_OF(CONF_VALUE) *conf)
|
||||
{
|
||||
if (a->name != NULL)
|
||||
(void)lh_CONF_VALUE_delete(conf, a);
|
||||
}
|
||||
|
||||
static void value_free_stack_doall(CONF_VALUE *a)
|
||||
{
|
||||
CONF_VALUE *vv;
|
||||
STACK_OF(CONF_VALUE) *sk;
|
||||
int i;
|
||||
|
||||
if (a->name != NULL)
|
||||
return;
|
||||
|
||||
sk = (STACK_OF(CONF_VALUE) *)a->value;
|
||||
for (i = sk_CONF_VALUE_num(sk) - 1; i >= 0; i--) {
|
||||
vv = sk_CONF_VALUE_value(sk, i);
|
||||
OPENSSL_free(vv->value);
|
||||
OPENSSL_free(vv->name);
|
||||
OPENSSL_free(vv);
|
||||
}
|
||||
sk_CONF_VALUE_free(sk);
|
||||
OPENSSL_free(a->section);
|
||||
OPENSSL_free(a);
|
||||
}
|
||||
|
||||
/* Up until OpenSSL 0.9.5a, this was new_section */
|
||||
CONF_VALUE *_CONF_new_section(CONF *conf, const char *section)
|
||||
{
|
||||
STACK_OF(CONF_VALUE) *sk = NULL;
|
||||
int i;
|
||||
CONF_VALUE *v = NULL, *vv;
|
||||
|
||||
if ((sk = sk_CONF_VALUE_new_null()) == NULL)
|
||||
goto err;
|
||||
if ((v = OPENSSL_malloc(sizeof(*v))) == NULL)
|
||||
goto err;
|
||||
i = strlen(section) + 1;
|
||||
if ((v->section = OPENSSL_malloc(i)) == NULL)
|
||||
goto err;
|
||||
|
||||
memcpy(v->section, section, i);
|
||||
v->name = NULL;
|
||||
v->value = (char *)sk;
|
||||
|
||||
vv = lh_CONF_VALUE_insert(conf->data, v);
|
||||
if (vv != NULL || lh_CONF_VALUE_error(conf->data) > 0)
|
||||
goto err;
|
||||
return v;
|
||||
|
||||
err:
|
||||
sk_CONF_VALUE_free(sk);
|
||||
if (v != NULL)
|
||||
OPENSSL_free(v->section);
|
||||
OPENSSL_free(v);
|
||||
return NULL;
|
||||
}
|
878
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_def.c
vendored
Normal file
878
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_def.c
vendored
Normal file
|
@ -0,0 +1,878 @@
|
|||
/*
|
||||
* Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
/* Part of the code in here was originally in conf.c, which is now removed */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include "internal/o_dir.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>
|
||||
#ifndef OPENSSL_NO_POSIX_IO
|
||||
# include <sys/stat.h>
|
||||
# ifdef _WIN32
|
||||
# define stat _stat
|
||||
# define strcasecmp _stricmp
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef S_ISDIR
|
||||
# define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The maximum length we can grow a value to after variable expansion. 64k
|
||||
* should be more than enough for all reasonable uses.
|
||||
*/
|
||||
#define MAX_CONF_VALUE_LENGTH 65536
|
||||
|
||||
static int is_keytype(const CONF *conf, char c, unsigned short type);
|
||||
static char *eat_ws(CONF *conf, char *p);
|
||||
static void trim_ws(CONF *conf, char *start);
|
||||
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(conf,p) (((IS_EOF((conf),(p)[1]))?((p)+1):((p)+2)))
|
||||
#ifndef OPENSSL_NO_POSIX_IO
|
||||
static BIO *process_include(char *include, OPENSSL_DIR_CTX **dirctx,
|
||||
char **dirpath);
|
||||
static BIO *get_next_file(const char *path, OPENSSL_DIR_CTX **dirctx);
|
||||
#endif
|
||||
|
||||
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, const char *name, long *eline);
|
||||
static int def_load_bio(CONF *conf, BIO *bp, long *eline);
|
||||
static int def_dump(const CONF *conf, BIO *bp);
|
||||
static int def_is_number(const CONF *conf, char c);
|
||||
static int def_to_int(const CONF *conf, char c);
|
||||
|
||||
static CONF_METHOD default_method = {
|
||||
"OpenSSL default",
|
||||
def_create,
|
||||
def_init_default,
|
||||
def_destroy,
|
||||
def_destroy_data,
|
||||
def_load_bio,
|
||||
def_dump,
|
||||
def_is_number,
|
||||
def_to_int,
|
||||
def_load
|
||||
};
|
||||
|
||||
static CONF_METHOD WIN32_method = {
|
||||
"WIN32",
|
||||
def_create,
|
||||
def_init_WIN32,
|
||||
def_destroy,
|
||||
def_destroy_data,
|
||||
def_load_bio,
|
||||
def_dump,
|
||||
def_is_number,
|
||||
def_to_int,
|
||||
def_load
|
||||
};
|
||||
|
||||
CONF_METHOD *NCONF_default(void)
|
||||
{
|
||||
return &default_method;
|
||||
}
|
||||
|
||||
CONF_METHOD *NCONF_WIN32(void)
|
||||
{
|
||||
return &WIN32_method;
|
||||
}
|
||||
|
||||
static CONF *def_create(CONF_METHOD *meth)
|
||||
{
|
||||
CONF *ret;
|
||||
|
||||
ret = OPENSSL_malloc(sizeof(*ret));
|
||||
if (ret != NULL)
|
||||
if (meth->init(ret) == 0) {
|
||||
OPENSSL_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)) {
|
||||
OPENSSL_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, const char *name, long *line)
|
||||
{
|
||||
int ret;
|
||||
BIO *in = NULL;
|
||||
|
||||
#ifdef OPENSSL_SYS_VMS
|
||||
in = BIO_new_file(name, "r");
|
||||
#else
|
||||
in = BIO_new_file(name, "rb");
|
||||
#endif
|
||||
if (in == NULL) {
|
||||
if (ERR_GET_REASON(ERR_peek_last_error()) == BIO_R_NO_SUCH_FILE)
|
||||
CONFerr(CONF_F_DEF_LOAD, CONF_R_NO_SUCH_FILE);
|
||||
else
|
||||
CONFerr(CONF_F_DEF_LOAD, ERR_R_SYS_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ret = def_load_bio(conf, in, line);
|
||||
BIO_free(in);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int def_load_bio(CONF *conf, BIO *in, long *line)
|
||||
{
|
||||
/* The macro BUFSIZE conflicts with a system macro in VxWorks */
|
||||
#define CONFBUFSIZE 512
|
||||
int bufnum = 0, i, ii;
|
||||
BUF_MEM *buff = NULL;
|
||||
char *s, *p, *end;
|
||||
int again;
|
||||
long eline = 0;
|
||||
char btmp[DECIMAL_SIZE(eline) + 1];
|
||||
CONF_VALUE *v = NULL, *tv;
|
||||
CONF_VALUE *sv = NULL;
|
||||
char *section = NULL, *buf;
|
||||
char *start, *psection, *pname;
|
||||
void *h = (void *)(conf->data);
|
||||
STACK_OF(BIO) *biosk = NULL;
|
||||
#ifndef OPENSSL_NO_POSIX_IO
|
||||
char *dirpath = NULL;
|
||||
OPENSSL_DIR_CTX *dirctx = NULL;
|
||||
#endif
|
||||
|
||||
if ((buff = BUF_MEM_new()) == NULL) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_BUF_LIB);
|
||||
goto err;
|
||||
}
|
||||
|
||||
section = OPENSSL_strdup("default");
|
||||
if (section == NULL) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (_CONF_new_data(conf) == 0) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
||||
sv = _CONF_new_section(conf, section);
|
||||
if (sv == NULL) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
|
||||
goto err;
|
||||
}
|
||||
|
||||
bufnum = 0;
|
||||
again = 0;
|
||||
for (;;) {
|
||||
if (!BUF_MEM_grow(buff, bufnum + CONFBUFSIZE)) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_BUF_LIB);
|
||||
goto err;
|
||||
}
|
||||
p = &(buff->data[bufnum]);
|
||||
*p = '\0';
|
||||
read_retry:
|
||||
BIO_gets(in, p, CONFBUFSIZE - 1);
|
||||
p[CONFBUFSIZE - 1] = '\0';
|
||||
ii = i = strlen(p);
|
||||
if (i == 0 && !again) {
|
||||
/* the currently processed BIO is at EOF */
|
||||
BIO *parent;
|
||||
|
||||
#ifndef OPENSSL_NO_POSIX_IO
|
||||
/* continue processing with the next file from directory */
|
||||
if (dirctx != NULL) {
|
||||
BIO *next;
|
||||
|
||||
if ((next = get_next_file(dirpath, &dirctx)) != NULL) {
|
||||
BIO_vfree(in);
|
||||
in = next;
|
||||
goto read_retry;
|
||||
} else {
|
||||
OPENSSL_free(dirpath);
|
||||
dirpath = NULL;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
/* no more files in directory, continue with processing parent */
|
||||
if ((parent = sk_BIO_pop(biosk)) == NULL) {
|
||||
/* everything processed get out of the loop */
|
||||
break;
|
||||
} else {
|
||||
BIO_vfree(in);
|
||||
in = parent;
|
||||
goto read_retry;
|
||||
}
|
||||
}
|
||||
again = 0;
|
||||
while (i > 0) {
|
||||
if ((p[i - 1] != '\r') && (p[i - 1] != '\n'))
|
||||
break;
|
||||
else
|
||||
i--;
|
||||
}
|
||||
/*
|
||||
* we removed some trailing stuff so there is a new line on the end.
|
||||
*/
|
||||
if (ii && i == ii)
|
||||
again = 1; /* long line */
|
||||
else {
|
||||
p[i] = '\0';
|
||||
eline++; /* another input line */
|
||||
}
|
||||
|
||||
/* we now have a line with trailing \r\n removed */
|
||||
|
||||
/* i is the number of bytes */
|
||||
bufnum += i;
|
||||
|
||||
v = NULL;
|
||||
/* check for line continuation */
|
||||
if (bufnum >= 1) {
|
||||
/*
|
||||
* If we have bytes and the last char '\\' and second last char
|
||||
* is not '\\'
|
||||
*/
|
||||
p = &(buff->data[bufnum - 1]);
|
||||
if (IS_ESC(conf, p[0]) && ((bufnum <= 1) || !IS_ESC(conf, p[-1]))) {
|
||||
bufnum--;
|
||||
again = 1;
|
||||
}
|
||||
}
|
||||
if (again)
|
||||
continue;
|
||||
bufnum = 0;
|
||||
buf = buff->data;
|
||||
|
||||
clear_comments(conf, buf);
|
||||
s = eat_ws(conf, buf);
|
||||
if (IS_EOF(conf, *s))
|
||||
continue; /* blank line */
|
||||
if (*s == '[') {
|
||||
char *ss;
|
||||
|
||||
s++;
|
||||
start = eat_ws(conf, s);
|
||||
ss = start;
|
||||
again:
|
||||
end = eat_alpha_numeric(conf, ss);
|
||||
p = eat_ws(conf, end);
|
||||
if (*p != ']') {
|
||||
if (*p != '\0' && ss != p) {
|
||||
ss = p;
|
||||
goto again;
|
||||
}
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO,
|
||||
CONF_R_MISSING_CLOSE_SQUARE_BRACKET);
|
||||
goto err;
|
||||
}
|
||||
*end = '\0';
|
||||
if (!str_copy(conf, NULL, §ion, start))
|
||||
goto err;
|
||||
if ((sv = _CONF_get_section(conf, section)) == NULL)
|
||||
sv = _CONF_new_section(conf, section);
|
||||
if (sv == NULL) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO,
|
||||
CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
|
||||
goto err;
|
||||
}
|
||||
continue;
|
||||
} else {
|
||||
pname = s;
|
||||
end = eat_alpha_numeric(conf, s);
|
||||
if ((end[0] == ':') && (end[1] == ':')) {
|
||||
*end = '\0';
|
||||
end += 2;
|
||||
psection = pname;
|
||||
pname = end;
|
||||
end = eat_alpha_numeric(conf, end);
|
||||
} else {
|
||||
psection = section;
|
||||
}
|
||||
p = eat_ws(conf, end);
|
||||
if (strncmp(pname, ".include", 8) == 0
|
||||
&& (p != pname + 8 || *p == '=')) {
|
||||
char *include = NULL;
|
||||
BIO *next;
|
||||
|
||||
if (*p == '=') {
|
||||
p++;
|
||||
p = eat_ws(conf, p);
|
||||
}
|
||||
trim_ws(conf, p);
|
||||
if (!str_copy(conf, psection, &include, p))
|
||||
goto err;
|
||||
/* get the BIO of the included file */
|
||||
#ifndef OPENSSL_NO_POSIX_IO
|
||||
next = process_include(include, &dirctx, &dirpath);
|
||||
if (include != dirpath) {
|
||||
/* dirpath will contain include in case of a directory */
|
||||
OPENSSL_free(include);
|
||||
}
|
||||
#else
|
||||
next = BIO_new_file(include, "r");
|
||||
OPENSSL_free(include);
|
||||
#endif
|
||||
if (next != NULL) {
|
||||
/* push the currently processing BIO onto stack */
|
||||
if (biosk == NULL) {
|
||||
if ((biosk = sk_BIO_new_null()) == NULL) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
if (!sk_BIO_push(biosk, in)) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
/* continue with reading from the included BIO */
|
||||
in = next;
|
||||
}
|
||||
continue;
|
||||
} else if (*p != '=') {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, CONF_R_MISSING_EQUAL_SIGN);
|
||||
goto err;
|
||||
}
|
||||
*end = '\0';
|
||||
p++;
|
||||
start = eat_ws(conf, p);
|
||||
trim_ws(conf, start);
|
||||
|
||||
if ((v = OPENSSL_malloc(sizeof(*v))) == NULL) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
v->name = OPENSSL_strdup(pname);
|
||||
v->value = NULL;
|
||||
if (v->name == NULL) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
if (!str_copy(conf, psection, &(v->value), start))
|
||||
goto err;
|
||||
|
||||
if (strcmp(psection, section) != 0) {
|
||||
if ((tv = _CONF_get_section(conf, psection))
|
||||
== NULL)
|
||||
tv = _CONF_new_section(conf, psection);
|
||||
if (tv == NULL) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO,
|
||||
CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
|
||||
goto err;
|
||||
}
|
||||
} else
|
||||
tv = sv;
|
||||
if (_CONF_add_string(conf, tv, v) == 0) {
|
||||
CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
v = NULL;
|
||||
}
|
||||
}
|
||||
BUF_MEM_free(buff);
|
||||
OPENSSL_free(section);
|
||||
/*
|
||||
* No need to pop, since we only get here if the stack is empty.
|
||||
* If this causes a BIO leak, THE ISSUE IS SOMEWHERE ELSE!
|
||||
*/
|
||||
sk_BIO_free(biosk);
|
||||
return 1;
|
||||
err:
|
||||
BUF_MEM_free(buff);
|
||||
OPENSSL_free(section);
|
||||
/*
|
||||
* Since |in| is the first element of the stack and should NOT be freed
|
||||
* here, we cannot use sk_BIO_pop_free(). Instead, we pop and free one
|
||||
* BIO at a time, making sure that the last one popped isn't.
|
||||
*/
|
||||
while (sk_BIO_num(biosk) > 0) {
|
||||
BIO *popped = sk_BIO_pop(biosk);
|
||||
BIO_vfree(in);
|
||||
in = popped;
|
||||
}
|
||||
sk_BIO_free(biosk);
|
||||
#ifndef OPENSSL_NO_POSIX_IO
|
||||
OPENSSL_free(dirpath);
|
||||
if (dirctx != NULL)
|
||||
OPENSSL_DIR_end(&dirctx);
|
||||
#endif
|
||||
if (line != NULL)
|
||||
*line = eline;
|
||||
BIO_snprintf(btmp, sizeof(btmp), "%ld", eline);
|
||||
ERR_add_error_data(2, "line ", btmp);
|
||||
if (h != conf->data) {
|
||||
CONF_free(conf->data);
|
||||
conf->data = NULL;
|
||||
}
|
||||
if (v != NULL) {
|
||||
OPENSSL_free(v->name);
|
||||
OPENSSL_free(v->value);
|
||||
OPENSSL_free(v);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void clear_comments(CONF *conf, char *p)
|
||||
{
|
||||
for (;;) {
|
||||
if (IS_FCOMMENT(conf, *p)) {
|
||||
*p = '\0';
|
||||
return;
|
||||
}
|
||||
if (!IS_WS(conf, *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_QUOTE(conf, *p)) {
|
||||
p = scan_quote(conf, p);
|
||||
continue;
|
||||
}
|
||||
if (IS_ESC(conf, *p)) {
|
||||
p = scan_esc(conf, p);
|
||||
continue;
|
||||
}
|
||||
if (IS_EOF(conf, *p))
|
||||
return;
|
||||
else
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
BUF_MEM *buf;
|
||||
|
||||
if ((buf = BUF_MEM_new()) == NULL)
|
||||
return 0;
|
||||
|
||||
len = strlen(from) + 1;
|
||||
if (!BUF_MEM_grow(buf, len))
|
||||
goto err;
|
||||
|
||||
for (;;) {
|
||||
if (IS_QUOTE(conf, *from)) {
|
||||
q = *from;
|
||||
from++;
|
||||
while (!IS_EOF(conf, *from) && (*from != q)) {
|
||||
if (IS_ESC(conf, *from)) {
|
||||
from++;
|
||||
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 (IS_ESC(conf, *from)) {
|
||||
from++;
|
||||
v = *(from++);
|
||||
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 (IS_EOF(conf, *from))
|
||||
break;
|
||||
else if (*from == '$') {
|
||||
size_t newsize;
|
||||
|
||||
/* try to expand it */
|
||||
rrp = NULL;
|
||||
s = &(from[1]);
|
||||
if (*s == '{')
|
||||
q = '}';
|
||||
else if (*s == '(')
|
||||
q = ')';
|
||||
else
|
||||
q = 0;
|
||||
|
||||
if (q)
|
||||
s++;
|
||||
cp = section;
|
||||
e = np = s;
|
||||
while (IS_ALNUM(conf, *e))
|
||||
e++;
|
||||
if ((e[0] == ':') && (e[1] == ':')) {
|
||||
cp = np;
|
||||
rrp = e;
|
||||
rr = *e;
|
||||
*rrp = '\0';
|
||||
e += 2;
|
||||
np = e;
|
||||
while (IS_ALNUM(conf, *e))
|
||||
e++;
|
||||
}
|
||||
r = *e;
|
||||
*e = '\0';
|
||||
rp = e;
|
||||
if (q) {
|
||||
if (r != q) {
|
||||
CONFerr(CONF_F_STR_COPY, CONF_R_NO_CLOSE_BRACE);
|
||||
goto err;
|
||||
}
|
||||
e++;
|
||||
}
|
||||
/*-
|
||||
* So at this point we have
|
||||
* np which is the start of the name string which is
|
||||
* '\0' terminated.
|
||||
* cp which is the start of the section string which is
|
||||
* '\0' terminated.
|
||||
* e is the 'next point after'.
|
||||
* r and rr are the chars replaced by the '\0'
|
||||
* rp and rrp is where 'r' and 'rr' came from.
|
||||
*/
|
||||
p = _CONF_get_string(conf, cp, np);
|
||||
if (rrp != NULL)
|
||||
*rrp = rr;
|
||||
*rp = r;
|
||||
if (p == NULL) {
|
||||
CONFerr(CONF_F_STR_COPY, CONF_R_VARIABLE_HAS_NO_VALUE);
|
||||
goto err;
|
||||
}
|
||||
newsize = strlen(p) + buf->length - (e - from);
|
||||
if (newsize > MAX_CONF_VALUE_LENGTH) {
|
||||
CONFerr(CONF_F_STR_COPY, CONF_R_VARIABLE_EXPANSION_TOO_LONG);
|
||||
goto err;
|
||||
}
|
||||
if (!BUF_MEM_grow_clean(buf, newsize)) {
|
||||
CONFerr(CONF_F_STR_COPY, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
while (*p)
|
||||
buf->data[to++] = *(p++);
|
||||
|
||||
/*
|
||||
* Since we change the pointer 'from', we also have to change the
|
||||
* perceived length of the string it points at. /RL
|
||||
*/
|
||||
len -= e - from;
|
||||
from = e;
|
||||
|
||||
/*
|
||||
* In case there were no braces or parenthesis around the
|
||||
* variable reference, we have to put back the character that was
|
||||
* replaced with a '\0'. /RL
|
||||
*/
|
||||
*rp = r;
|
||||
} else
|
||||
buf->data[to++] = *(from++);
|
||||
}
|
||||
buf->data[to] = '\0';
|
||||
OPENSSL_free(*pto);
|
||||
*pto = buf->data;
|
||||
OPENSSL_free(buf);
|
||||
return 1;
|
||||
err:
|
||||
BUF_MEM_free(buf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifndef OPENSSL_NO_POSIX_IO
|
||||
/*
|
||||
* Check whether included path is a directory.
|
||||
* Returns next BIO to process and in case of a directory
|
||||
* also an opened directory context and the include path.
|
||||
*/
|
||||
static BIO *process_include(char *include, OPENSSL_DIR_CTX **dirctx,
|
||||
char **dirpath)
|
||||
{
|
||||
struct stat st = { 0 };
|
||||
BIO *next;
|
||||
|
||||
if (stat(include, &st) < 0) {
|
||||
SYSerr(SYS_F_STAT, errno);
|
||||
ERR_add_error_data(1, include);
|
||||
/* missing include file is not fatal error */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
if (*dirctx != NULL) {
|
||||
CONFerr(CONF_F_PROCESS_INCLUDE,
|
||||
CONF_R_RECURSIVE_DIRECTORY_INCLUDE);
|
||||
ERR_add_error_data(1, include);
|
||||
return NULL;
|
||||
}
|
||||
/* a directory, load its contents */
|
||||
if ((next = get_next_file(include, dirctx)) != NULL)
|
||||
*dirpath = include;
|
||||
return next;
|
||||
}
|
||||
|
||||
next = BIO_new_file(include, "r");
|
||||
return next;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get next file from the directory path.
|
||||
* Returns BIO of the next file to read and updates dirctx.
|
||||
*/
|
||||
static BIO *get_next_file(const char *path, OPENSSL_DIR_CTX **dirctx)
|
||||
{
|
||||
const char *filename;
|
||||
|
||||
while ((filename = OPENSSL_DIR_read(dirctx, path)) != NULL) {
|
||||
size_t namelen;
|
||||
|
||||
namelen = strlen(filename);
|
||||
|
||||
|
||||
if ((namelen > 5 && strcasecmp(filename + namelen - 5, ".conf") == 0)
|
||||
|| (namelen > 4 && strcasecmp(filename + namelen - 4, ".cnf") == 0)) {
|
||||
size_t newlen;
|
||||
char *newpath;
|
||||
BIO *bio;
|
||||
|
||||
newlen = strlen(path) + namelen + 2;
|
||||
newpath = OPENSSL_zalloc(newlen);
|
||||
if (newpath == NULL) {
|
||||
CONFerr(CONF_F_GET_NEXT_FILE, ERR_R_MALLOC_FAILURE);
|
||||
break;
|
||||
}
|
||||
#ifdef OPENSSL_SYS_VMS
|
||||
/*
|
||||
* If the given path isn't clear VMS syntax,
|
||||
* we treat it as on Unix.
|
||||
*/
|
||||
{
|
||||
size_t pathlen = strlen(path);
|
||||
|
||||
if (path[pathlen - 1] == ']' || path[pathlen - 1] == '>'
|
||||
|| path[pathlen - 1] == ':') {
|
||||
/* Clear VMS directory syntax, just copy as is */
|
||||
OPENSSL_strlcpy(newpath, path, newlen);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (newpath[0] == '\0') {
|
||||
OPENSSL_strlcpy(newpath, path, newlen);
|
||||
OPENSSL_strlcat(newpath, "/", newlen);
|
||||
}
|
||||
OPENSSL_strlcat(newpath, filename, newlen);
|
||||
|
||||
bio = BIO_new_file(newpath, "r");
|
||||
OPENSSL_free(newpath);
|
||||
/* Errors when opening files are non-fatal. */
|
||||
if (bio != NULL)
|
||||
return bio;
|
||||
}
|
||||
}
|
||||
OPENSSL_DIR_end(dirctx);
|
||||
*dirctx = NULL;
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int is_keytype(const CONF *conf, char c, unsigned short type)
|
||||
{
|
||||
const unsigned short * keytypes = (const unsigned short *) conf->meth_data;
|
||||
unsigned char key = (unsigned char)c;
|
||||
|
||||
#ifdef CHARSET_EBCDIC
|
||||
# if CHAR_BIT > 8
|
||||
if (key > 255) {
|
||||
/* key is out of range for os_toascii table */
|
||||
return 0;
|
||||
}
|
||||
# endif
|
||||
/* convert key from ebcdic to ascii */
|
||||
key = os_toascii[key];
|
||||
#endif
|
||||
|
||||
if (key > 127) {
|
||||
/* key is not a seven bit ascii character */
|
||||
return 0;
|
||||
}
|
||||
|
||||
return (keytypes[key] & type) ? 1 : 0;
|
||||
}
|
||||
|
||||
static char *eat_ws(CONF *conf, char *p)
|
||||
{
|
||||
while (IS_WS(conf, *p) && (!IS_EOF(conf, *p)))
|
||||
p++;
|
||||
return p;
|
||||
}
|
||||
|
||||
static void trim_ws(CONF *conf, char *start)
|
||||
{
|
||||
char *p = start;
|
||||
|
||||
while (!IS_EOF(conf, *p))
|
||||
p++;
|
||||
p--;
|
||||
while ((p >= start) && IS_WS(conf, *p))
|
||||
p--;
|
||||
p++;
|
||||
*p = '\0';
|
||||
}
|
||||
|
||||
static char *eat_alpha_numeric(CONF *conf, char *p)
|
||||
{
|
||||
for (;;) {
|
||||
if (IS_ESC(conf, *p)) {
|
||||
p = scan_esc(conf, p);
|
||||
continue;
|
||||
}
|
||||
if (!IS_ALNUM_PUNCT(conf, *p))
|
||||
return p;
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
static char *scan_quote(CONF *conf, char *p)
|
||||
{
|
||||
int q = *p;
|
||||
|
||||
p++;
|
||||
while (!(IS_EOF(conf, *p)) && (*p != q)) {
|
||||
if (IS_ESC(conf, *p)) {
|
||||
p++;
|
||||
if (IS_EOF(conf, *p))
|
||||
return p;
|
||||
}
|
||||
p++;
|
||||
}
|
||||
if (*p == q)
|
||||
p++;
|
||||
return p;
|
||||
}
|
||||
|
||||
static char *scan_dquote(CONF *conf, char *p)
|
||||
{
|
||||
int q = *p;
|
||||
|
||||
p++;
|
||||
while (!(IS_EOF(conf, *p))) {
|
||||
if (*p == q) {
|
||||
if (*(p + 1) == q) {
|
||||
p++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
p++;
|
||||
}
|
||||
if (*p == q)
|
||||
p++;
|
||||
return p;
|
||||
}
|
||||
|
||||
static void dump_value_doall_arg(const 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);
|
||||
}
|
||||
|
||||
IMPLEMENT_LHASH_DOALL_ARG_CONST(CONF_VALUE, BIO);
|
||||
|
||||
static int def_dump(const CONF *conf, BIO *out)
|
||||
{
|
||||
lh_CONF_VALUE_doall_BIO(conf->data, dump_value_doall_arg, out);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int def_is_number(const CONF *conf, char c)
|
||||
{
|
||||
return IS_NUMBER(conf, c);
|
||||
}
|
||||
|
||||
static int def_to_int(const CONF *conf, char c)
|
||||
{
|
||||
return c - '0';
|
||||
}
|
76
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_def.h
vendored
Normal file
76
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_def.h
vendored
Normal file
|
@ -0,0 +1,76 @@
|
|||
/*
|
||||
* WARNING: do not edit!
|
||||
* Generated by crypto/conf/keysets.pl
|
||||
*
|
||||
* Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#define CONF_NUMBER 1
|
||||
#define CONF_UPPER 2
|
||||
#define CONF_LOWER 4
|
||||
#define CONF_UNDER 256
|
||||
#define CONF_PUNCT 512
|
||||
#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_ALNUM (CONF_ALPHA|CONF_NUMBER|CONF_UNDER)
|
||||
#define CONF_ALNUM_PUNCT (CONF_ALPHA|CONF_NUMBER|CONF_UNDER|CONF_PUNCT)
|
||||
|
||||
|
||||
#define IS_COMMENT(conf,c) is_keytype(conf, c, CONF_COMMENT)
|
||||
#define IS_FCOMMENT(conf,c) is_keytype(conf, c, CONF_FCOMMENT)
|
||||
#define IS_EOF(conf,c) is_keytype(conf, c, CONF_EOF)
|
||||
#define IS_ESC(conf,c) is_keytype(conf, c, CONF_ESC)
|
||||
#define IS_NUMBER(conf,c) is_keytype(conf, c, CONF_NUMBER)
|
||||
#define IS_WS(conf,c) is_keytype(conf, c, CONF_WS)
|
||||
#define IS_ALNUM(conf,c) is_keytype(conf, c, CONF_ALNUM)
|
||||
#define IS_ALNUM_PUNCT(conf,c) is_keytype(conf, c, CONF_ALNUM_PUNCT)
|
||||
#define IS_QUOTE(conf,c) is_keytype(conf, c, CONF_QUOTE)
|
||||
#define IS_DQUOTE(conf,c) is_keytype(conf, c, CONF_DQUOTE)
|
||||
|
||||
static const unsigned short CONF_type_default[128] = {
|
||||
0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0010, 0x0010, 0x0000, 0x0000, 0x0010, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0010, 0x0200, 0x0040, 0x0080, 0x0000, 0x0200, 0x0200, 0x0040,
|
||||
0x0000, 0x0000, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
|
||||
0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
|
||||
0x0001, 0x0001, 0x0000, 0x0200, 0x0000, 0x0000, 0x0000, 0x0200,
|
||||
0x0200, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
|
||||
0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
|
||||
0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
|
||||
0x0002, 0x0002, 0x0002, 0x0000, 0x0020, 0x0000, 0x0200, 0x0100,
|
||||
0x0040, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
|
||||
0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
|
||||
0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
|
||||
0x0004, 0x0004, 0x0004, 0x0000, 0x0200, 0x0000, 0x0200, 0x0000,
|
||||
};
|
||||
|
||||
static const unsigned short CONF_type_win32[128] = {
|
||||
0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0010, 0x0010, 0x0000, 0x0000, 0x0010, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
|
||||
0x0010, 0x0200, 0x0400, 0x0000, 0x0000, 0x0200, 0x0200, 0x0000,
|
||||
0x0000, 0x0000, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
|
||||
0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
|
||||
0x0001, 0x0001, 0x0000, 0x0A00, 0x0000, 0x0000, 0x0000, 0x0200,
|
||||
0x0200, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
|
||||
0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
|
||||
0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
|
||||
0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0200, 0x0100,
|
||||
0x0000, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
|
||||
0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
|
||||
0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
|
||||
0x0004, 0x0004, 0x0004, 0x0000, 0x0200, 0x0000, 0x0200, 0x0000,
|
||||
};
|
95
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_err.c
vendored
Normal file
95
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_err.c
vendored
Normal file
|
@ -0,0 +1,95 @@
|
|||
/*
|
||||
* Generated by util/mkerr.pl DO NOT EDIT
|
||||
* Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/conferr.h>
|
||||
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
static const ERR_STRING_DATA CONF_str_functs[] = {
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_CONF_DUMP_FP, 0), "CONF_dump_fp"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_CONF_LOAD, 0), "CONF_load"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_CONF_LOAD_FP, 0), "CONF_load_fp"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_CONF_PARSE_LIST, 0), "CONF_parse_list"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_DEF_LOAD, 0), "def_load"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_DEF_LOAD_BIO, 0), "def_load_bio"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_GET_NEXT_FILE, 0), "get_next_file"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_MODULE_ADD, 0), "module_add"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_MODULE_INIT, 0), "module_init"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_MODULE_LOAD_DSO, 0), "module_load_dso"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_MODULE_RUN, 0), "module_run"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_DUMP_BIO, 0), "NCONF_dump_bio"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_DUMP_FP, 0), "NCONF_dump_fp"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_GET_NUMBER_E, 0),
|
||||
"NCONF_get_number_e"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_GET_SECTION, 0), "NCONF_get_section"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_GET_STRING, 0), "NCONF_get_string"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_LOAD, 0), "NCONF_load"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_LOAD_BIO, 0), "NCONF_load_bio"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_LOAD_FP, 0), "NCONF_load_fp"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_NCONF_NEW, 0), "NCONF_new"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_PROCESS_INCLUDE, 0), "process_include"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_SSL_MODULE_INIT, 0), "ssl_module_init"},
|
||||
{ERR_PACK(ERR_LIB_CONF, CONF_F_STR_COPY, 0), "str_copy"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static const ERR_STRING_DATA CONF_str_reasons[] = {
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_ERROR_LOADING_DSO), "error loading dso"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_LIST_CANNOT_BE_NULL),
|
||||
"list cannot be null"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MISSING_CLOSE_SQUARE_BRACKET),
|
||||
"missing close square bracket"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MISSING_EQUAL_SIGN),
|
||||
"missing equal sign"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MISSING_INIT_FUNCTION),
|
||||
"missing init function"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_MODULE_INITIALIZATION_ERROR),
|
||||
"module initialization error"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_CLOSE_BRACE), "no close brace"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_CONF), "no conf"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE),
|
||||
"no conf or environment variable"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_SECTION), "no section"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_SUCH_FILE), "no such file"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NO_VALUE), "no value"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_NUMBER_TOO_LARGE), "number too large"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_RECURSIVE_DIRECTORY_INCLUDE),
|
||||
"recursive directory include"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_SSL_COMMAND_SECTION_EMPTY),
|
||||
"ssl command section empty"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_SSL_COMMAND_SECTION_NOT_FOUND),
|
||||
"ssl command section not found"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_SSL_SECTION_EMPTY), "ssl section empty"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_SSL_SECTION_NOT_FOUND),
|
||||
"ssl section not found"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_UNABLE_TO_CREATE_NEW_SECTION),
|
||||
"unable to create new section"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_UNKNOWN_MODULE_NAME),
|
||||
"unknown module name"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_VARIABLE_EXPANSION_TOO_LONG),
|
||||
"variable expansion too long"},
|
||||
{ERR_PACK(ERR_LIB_CONF, 0, CONF_R_VARIABLE_HAS_NO_VALUE),
|
||||
"variable has no value"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
int ERR_load_CONF_strings(void)
|
||||
{
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
if (ERR_func_error_string(CONF_str_functs[0].error) == NULL) {
|
||||
ERR_load_strings_const(CONF_str_functs);
|
||||
ERR_load_strings_const(CONF_str_reasons);
|
||||
}
|
||||
#endif
|
||||
return 1;
|
||||
}
|
11
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_lcl.h
vendored
Normal file
11
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_lcl.h
vendored
Normal file
|
@ -0,0 +1,11 @@
|
|||
/*
|
||||
* Copyright 2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
void conf_add_ssl_module(void);
|
||||
|
414
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_lib.c
vendored
Normal file
414
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_lib.c
vendored
Normal file
|
@ -0,0 +1,414 @@
|
|||
/*
|
||||
* Copyright 2000-2019 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include "e_os.h"
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "internal/conf.h"
|
||||
#include "internal/ctype.h"
|
||||
#include <openssl/crypto.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/conf.h>
|
||||
#include <openssl/conf_api.h>
|
||||
#include <openssl/lhash.h>
|
||||
|
||||
static CONF_METHOD *default_CONF_method = NULL;
|
||||
|
||||
/* Init a 'CONF' structure from an old LHASH */
|
||||
|
||||
void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash)
|
||||
{
|
||||
if (default_CONF_method == NULL)
|
||||
default_CONF_method = NCONF_default();
|
||||
|
||||
default_CONF_method->init(conf);
|
||||
conf->data = hash;
|
||||
}
|
||||
|
||||
/*
|
||||
* The following section contains the "CONF classic" functions, rewritten in
|
||||
* terms of the new CONF interface.
|
||||
*/
|
||||
|
||||
int CONF_set_default_method(CONF_METHOD *meth)
|
||||
{
|
||||
default_CONF_method = meth;
|
||||
return 1;
|
||||
}
|
||||
|
||||
LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file,
|
||||
long *eline)
|
||||
{
|
||||
LHASH_OF(CONF_VALUE) *ltmp;
|
||||
BIO *in = NULL;
|
||||
|
||||
#ifdef OPENSSL_SYS_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 OPENSSL_NO_STDIO
|
||||
LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp,
|
||||
long *eline)
|
||||
{
|
||||
BIO *btmp;
|
||||
LHASH_OF(CONF_VALUE) *ltmp;
|
||||
if ((btmp = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
|
||||
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_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp,
|
||||
long *eline)
|
||||
{
|
||||
CONF ctmp;
|
||||
int ret;
|
||||
|
||||
CONF_set_nconf(&ctmp, conf);
|
||||
|
||||
ret = NCONF_load_bio(&ctmp, bp, eline);
|
||||
if (ret)
|
||||
return ctmp.data;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf,
|
||||
const char *section)
|
||||
{
|
||||
if (conf == NULL) {
|
||||
return NULL;
|
||||
} else {
|
||||
CONF ctmp;
|
||||
CONF_set_nconf(&ctmp, conf);
|
||||
return NCONF_get_section(&ctmp, section);
|
||||
}
|
||||
}
|
||||
|
||||
char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group,
|
||||
const char *name)
|
||||
{
|
||||
if (conf == NULL) {
|
||||
return NCONF_get_string(NULL, group, name);
|
||||
} else {
|
||||
CONF ctmp;
|
||||
CONF_set_nconf(&ctmp, conf);
|
||||
return NCONF_get_string(&ctmp, group, name);
|
||||
}
|
||||
}
|
||||
|
||||
long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group,
|
||||
const char *name)
|
||||
{
|
||||
int status;
|
||||
long result = 0;
|
||||
|
||||
ERR_set_mark();
|
||||
if (conf == NULL) {
|
||||
status = NCONF_get_number_e(NULL, group, name, &result);
|
||||
} else {
|
||||
CONF ctmp;
|
||||
CONF_set_nconf(&ctmp, conf);
|
||||
status = NCONF_get_number_e(&ctmp, group, name, &result);
|
||||
}
|
||||
ERR_pop_to_mark();
|
||||
return status == 0 ? 0L : result;
|
||||
}
|
||||
|
||||
void CONF_free(LHASH_OF(CONF_VALUE) *conf)
|
||||
{
|
||||
CONF ctmp;
|
||||
CONF_set_nconf(&ctmp, conf);
|
||||
NCONF_free_data(&ctmp);
|
||||
}
|
||||
|
||||
#ifndef OPENSSL_NO_STDIO
|
||||
int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out)
|
||||
{
|
||||
BIO *btmp;
|
||||
int ret;
|
||||
|
||||
if ((btmp = BIO_new_fp(out, BIO_NOCLOSE)) == NULL) {
|
||||
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_OF(CONF_VALUE) *conf, BIO *out)
|
||||
{
|
||||
CONF ctmp;
|
||||
CONF_set_nconf(&ctmp, 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) {
|
||||
CONFerr(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)
|
||||
{
|
||||
if (conf == NULL) {
|
||||
CONFerr(CONF_F_NCONF_LOAD, CONF_R_NO_CONF);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return conf->meth->load(conf, file, eline);
|
||||
}
|
||||
|
||||
#ifndef OPENSSL_NO_STDIO
|
||||
int NCONF_load_fp(CONF *conf, FILE *fp, long *eline)
|
||||
{
|
||||
BIO *btmp;
|
||||
int ret;
|
||||
if ((btmp = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
|
||||
CONFerr(CONF_F_NCONF_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_bio(conf, bp, eline);
|
||||
}
|
||||
|
||||
STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf, const char *section)
|
||||
{
|
||||
if (conf == NULL) {
|
||||
CONFerr(CONF_F_NCONF_GET_SECTION, CONF_R_NO_CONF);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (section == NULL) {
|
||||
CONFerr(CONF_F_NCONF_GET_SECTION, CONF_R_NO_SECTION);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return _CONF_get_section_values(conf, section);
|
||||
}
|
||||
|
||||
char *NCONF_get_string(const CONF *conf, const char *group, const char *name)
|
||||
{
|
||||
char *s = _CONF_get_string(conf, group, name);
|
||||
|
||||
/*
|
||||
* Since we may get a value from an environment variable even if conf is
|
||||
* NULL, let's check the value first
|
||||
*/
|
||||
if (s)
|
||||
return s;
|
||||
|
||||
if (conf == NULL) {
|
||||
CONFerr(CONF_F_NCONF_GET_STRING,
|
||||
CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE);
|
||||
return NULL;
|
||||
}
|
||||
CONFerr(CONF_F_NCONF_GET_STRING, CONF_R_NO_VALUE);
|
||||
ERR_add_error_data(4, "group=", group, " name=", name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int default_is_number(const CONF *conf, char c)
|
||||
{
|
||||
return ossl_isdigit(c);
|
||||
}
|
||||
|
||||
static int default_to_int(const CONF *conf, char c)
|
||||
{
|
||||
return (int)(c - '0');
|
||||
}
|
||||
|
||||
int NCONF_get_number_e(const CONF *conf, const char *group, const char *name,
|
||||
long *result)
|
||||
{
|
||||
char *str;
|
||||
long res;
|
||||
int (*is_number)(const CONF *, char) = &default_is_number;
|
||||
int (*to_int)(const CONF *, char) = &default_to_int;
|
||||
|
||||
if (result == NULL) {
|
||||
CONFerr(CONF_F_NCONF_GET_NUMBER_E, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
str = NCONF_get_string(conf, group, name);
|
||||
|
||||
if (str == NULL)
|
||||
return 0;
|
||||
|
||||
if (conf != NULL) {
|
||||
if (conf->meth->is_number != NULL)
|
||||
is_number = conf->meth->is_number;
|
||||
if (conf->meth->to_int != NULL)
|
||||
to_int = conf->meth->to_int;
|
||||
}
|
||||
for (res = 0; is_number(conf, *str); str++) {
|
||||
const int d = to_int(conf, *str);
|
||||
|
||||
if (res > (LONG_MAX - d) / 10L) {
|
||||
CONFerr(CONF_F_NCONF_GET_NUMBER_E, CONF_R_NUMBER_TOO_LARGE);
|
||||
return 0;
|
||||
}
|
||||
res = res * 10 + d;
|
||||
}
|
||||
|
||||
*result = res;
|
||||
return 1;
|
||||
}
|
||||
|
||||
#ifndef OPENSSL_NO_STDIO
|
||||
int NCONF_dump_fp(const CONF *conf, FILE *out)
|
||||
{
|
||||
BIO *btmp;
|
||||
int ret;
|
||||
if ((btmp = BIO_new_fp(out, BIO_NOCLOSE)) == NULL) {
|
||||
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(const 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);
|
||||
}
|
||||
|
||||
/*
|
||||
* These routines call the C malloc/free, to avoid intermixing with
|
||||
* OpenSSL function pointers before the library is initialized.
|
||||
*/
|
||||
OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void)
|
||||
{
|
||||
OPENSSL_INIT_SETTINGS *ret = malloc(sizeof(*ret));
|
||||
|
||||
if (ret != NULL)
|
||||
memset(ret, 0, sizeof(*ret));
|
||||
ret->flags = DEFAULT_CONF_MFLAGS;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
#ifndef OPENSSL_NO_STDIO
|
||||
int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings,
|
||||
const char *filename)
|
||||
{
|
||||
char *newfilename = NULL;
|
||||
|
||||
if (filename != NULL) {
|
||||
newfilename = strdup(filename);
|
||||
if (newfilename == NULL)
|
||||
return 0;
|
||||
}
|
||||
|
||||
free(settings->filename);
|
||||
settings->filename = newfilename;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings,
|
||||
unsigned long flags)
|
||||
{
|
||||
settings->flags = flags;
|
||||
}
|
||||
|
||||
int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings,
|
||||
const char *appname)
|
||||
{
|
||||
char *newappname = NULL;
|
||||
|
||||
if (appname != NULL) {
|
||||
newappname = strdup(appname);
|
||||
if (newappname == NULL)
|
||||
return 0;
|
||||
}
|
||||
|
||||
free(settings->appname);
|
||||
settings->appname = newappname;
|
||||
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings)
|
||||
{
|
||||
free(settings->filename);
|
||||
free(settings->appname);
|
||||
free(settings);
|
||||
}
|
31
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_mall.c
vendored
Normal file
31
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_mall.c
vendored
Normal file
|
@ -0,0 +1,31 @@
|
|||
/*
|
||||
* Copyright 2002-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <openssl/crypto.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include <openssl/conf.h>
|
||||
#include <openssl/x509.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/engine.h>
|
||||
#include "conf_lcl.h"
|
||||
|
||||
/* Load all OpenSSL builtin modules */
|
||||
|
||||
void OPENSSL_load_builtin_modules(void)
|
||||
{
|
||||
/* Add builtin modules here */
|
||||
ASN1_add_oid_module();
|
||||
ASN1_add_stable_module();
|
||||
#ifndef OPENSSL_NO_ENGINE
|
||||
ENGINE_add_conf_module();
|
||||
#endif
|
||||
EVP_add_alg_module();
|
||||
conf_add_ssl_module();
|
||||
}
|
551
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_mod.c
vendored
Normal file
551
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_mod.c
vendored
Normal file
|
@ -0,0 +1,551 @@
|
|||
/*
|
||||
* Copyright 2002-2019 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include "internal/cryptlib.h"
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <openssl/crypto.h>
|
||||
#include "internal/conf.h"
|
||||
#include "internal/dso.h"
|
||||
#include <openssl/x509.h>
|
||||
|
||||
#define DSO_mod_init_name "OPENSSL_init"
|
||||
#define DSO_mod_finish_name "OPENSSL_finish"
|
||||
|
||||
/*
|
||||
* This structure contains a data about supported modules. entries in this
|
||||
* table correspond to either dynamic or static modules.
|
||||
*/
|
||||
|
||||
struct conf_module_st {
|
||||
/* DSO of this module or NULL if static */
|
||||
DSO *dso;
|
||||
/* Name of the module */
|
||||
char *name;
|
||||
/* Init function */
|
||||
conf_init_func *init;
|
||||
/* Finish function */
|
||||
conf_finish_func *finish;
|
||||
/* Number of successfully initialized modules */
|
||||
int links;
|
||||
void *usr_data;
|
||||
};
|
||||
|
||||
/*
|
||||
* This structure contains information about modules that have been
|
||||
* successfully initialized. There may be more than one entry for a given
|
||||
* module.
|
||||
*/
|
||||
|
||||
struct conf_imodule_st {
|
||||
CONF_MODULE *pmod;
|
||||
char *name;
|
||||
char *value;
|
||||
unsigned long flags;
|
||||
void *usr_data;
|
||||
};
|
||||
|
||||
static STACK_OF(CONF_MODULE) *supported_modules = NULL;
|
||||
static STACK_OF(CONF_IMODULE) *initialized_modules = NULL;
|
||||
|
||||
static void module_free(CONF_MODULE *md);
|
||||
static void module_finish(CONF_IMODULE *imod);
|
||||
static int module_run(const CONF *cnf, const char *name, const char *value,
|
||||
unsigned long flags);
|
||||
static CONF_MODULE *module_add(DSO *dso, const char *name,
|
||||
conf_init_func *ifunc,
|
||||
conf_finish_func *ffunc);
|
||||
static CONF_MODULE *module_find(const char *name);
|
||||
static int module_init(CONF_MODULE *pmod, const char *name, const char *value,
|
||||
const CONF *cnf);
|
||||
static CONF_MODULE *module_load_dso(const CONF *cnf, const char *name,
|
||||
const char *value);
|
||||
|
||||
/* Main function: load modules from a CONF structure */
|
||||
|
||||
int CONF_modules_load(const CONF *cnf, const char *appname,
|
||||
unsigned long flags)
|
||||
{
|
||||
STACK_OF(CONF_VALUE) *values;
|
||||
CONF_VALUE *vl;
|
||||
char *vsection = NULL;
|
||||
|
||||
int ret, i;
|
||||
|
||||
if (!cnf)
|
||||
return 1;
|
||||
|
||||
if (appname)
|
||||
vsection = NCONF_get_string(cnf, NULL, appname);
|
||||
|
||||
if (!appname || (!vsection && (flags & CONF_MFLAGS_DEFAULT_SECTION)))
|
||||
vsection = NCONF_get_string(cnf, NULL, "openssl_conf");
|
||||
|
||||
if (!vsection) {
|
||||
ERR_clear_error();
|
||||
return 1;
|
||||
}
|
||||
|
||||
values = NCONF_get_section(cnf, vsection);
|
||||
|
||||
if (!values)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < sk_CONF_VALUE_num(values); i++) {
|
||||
vl = sk_CONF_VALUE_value(values, i);
|
||||
ret = module_run(cnf, vl->name, vl->value, flags);
|
||||
if (ret <= 0)
|
||||
if (!(flags & CONF_MFLAGS_IGNORE_ERRORS))
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
||||
}
|
||||
|
||||
int CONF_modules_load_file(const char *filename, const char *appname,
|
||||
unsigned long flags)
|
||||
{
|
||||
char *file = NULL;
|
||||
CONF *conf = NULL;
|
||||
int ret = 0;
|
||||
conf = NCONF_new(NULL);
|
||||
if (conf == NULL)
|
||||
goto err;
|
||||
|
||||
if (filename == NULL) {
|
||||
file = CONF_get1_default_config_file();
|
||||
if (!file)
|
||||
goto err;
|
||||
} else
|
||||
file = (char *)filename;
|
||||
|
||||
if (NCONF_load(conf, file, NULL) <= 0) {
|
||||
if ((flags & CONF_MFLAGS_IGNORE_MISSING_FILE) &&
|
||||
(ERR_GET_REASON(ERR_peek_last_error()) == CONF_R_NO_SUCH_FILE)) {
|
||||
ERR_clear_error();
|
||||
ret = 1;
|
||||
}
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = CONF_modules_load(conf, appname, flags);
|
||||
|
||||
err:
|
||||
if (filename == NULL)
|
||||
OPENSSL_free(file);
|
||||
NCONF_free(conf);
|
||||
|
||||
if (flags & CONF_MFLAGS_IGNORE_RETURN_CODES)
|
||||
return 1;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int module_run(const CONF *cnf, const char *name, const char *value,
|
||||
unsigned long flags)
|
||||
{
|
||||
CONF_MODULE *md;
|
||||
int ret;
|
||||
|
||||
md = module_find(name);
|
||||
|
||||
/* Module not found: try to load DSO */
|
||||
if (!md && !(flags & CONF_MFLAGS_NO_DSO))
|
||||
md = module_load_dso(cnf, name, value);
|
||||
|
||||
if (!md) {
|
||||
if (!(flags & CONF_MFLAGS_SILENT)) {
|
||||
CONFerr(CONF_F_MODULE_RUN, CONF_R_UNKNOWN_MODULE_NAME);
|
||||
ERR_add_error_data(2, "module=", name);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
ret = module_init(md, name, value, cnf);
|
||||
|
||||
if (ret <= 0) {
|
||||
if (!(flags & CONF_MFLAGS_SILENT)) {
|
||||
char rcode[DECIMAL_SIZE(ret) + 1];
|
||||
|
||||
CONFerr(CONF_F_MODULE_RUN, CONF_R_MODULE_INITIALIZATION_ERROR);
|
||||
BIO_snprintf(rcode, sizeof(rcode), "%-8d", ret);
|
||||
ERR_add_error_data(6, "module=", name, ", value=", value,
|
||||
", retcode=", rcode);
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Load a module from a DSO */
|
||||
static CONF_MODULE *module_load_dso(const CONF *cnf,
|
||||
const char *name, const char *value)
|
||||
{
|
||||
DSO *dso = NULL;
|
||||
conf_init_func *ifunc;
|
||||
conf_finish_func *ffunc;
|
||||
const char *path = NULL;
|
||||
int errcode = 0;
|
||||
CONF_MODULE *md;
|
||||
/* Look for alternative path in module section */
|
||||
path = NCONF_get_string(cnf, value, "path");
|
||||
if (!path) {
|
||||
ERR_clear_error();
|
||||
path = name;
|
||||
}
|
||||
dso = DSO_load(NULL, path, NULL, 0);
|
||||
if (!dso) {
|
||||
errcode = CONF_R_ERROR_LOADING_DSO;
|
||||
goto err;
|
||||
}
|
||||
ifunc = (conf_init_func *)DSO_bind_func(dso, DSO_mod_init_name);
|
||||
if (!ifunc) {
|
||||
errcode = CONF_R_MISSING_INIT_FUNCTION;
|
||||
goto err;
|
||||
}
|
||||
ffunc = (conf_finish_func *)DSO_bind_func(dso, DSO_mod_finish_name);
|
||||
/* All OK, add module */
|
||||
md = module_add(dso, name, ifunc, ffunc);
|
||||
|
||||
if (!md)
|
||||
goto err;
|
||||
|
||||
return md;
|
||||
|
||||
err:
|
||||
DSO_free(dso);
|
||||
CONFerr(CONF_F_MODULE_LOAD_DSO, errcode);
|
||||
ERR_add_error_data(4, "module=", name, ", path=", path);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* add module to list */
|
||||
static CONF_MODULE *module_add(DSO *dso, const char *name,
|
||||
conf_init_func *ifunc, conf_finish_func *ffunc)
|
||||
{
|
||||
CONF_MODULE *tmod = NULL;
|
||||
if (supported_modules == NULL)
|
||||
supported_modules = sk_CONF_MODULE_new_null();
|
||||
if (supported_modules == NULL)
|
||||
return NULL;
|
||||
if ((tmod = OPENSSL_zalloc(sizeof(*tmod))) == NULL) {
|
||||
CONFerr(CONF_F_MODULE_ADD, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
tmod->dso = dso;
|
||||
tmod->name = OPENSSL_strdup(name);
|
||||
tmod->init = ifunc;
|
||||
tmod->finish = ffunc;
|
||||
if (tmod->name == NULL) {
|
||||
OPENSSL_free(tmod);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!sk_CONF_MODULE_push(supported_modules, tmod)) {
|
||||
OPENSSL_free(tmod->name);
|
||||
OPENSSL_free(tmod);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return tmod;
|
||||
}
|
||||
|
||||
/*
|
||||
* Find a module from the list. We allow module names of the form
|
||||
* modname.XXXX to just search for modname to allow the same module to be
|
||||
* initialized more than once.
|
||||
*/
|
||||
|
||||
static CONF_MODULE *module_find(const char *name)
|
||||
{
|
||||
CONF_MODULE *tmod;
|
||||
int i, nchar;
|
||||
char *p;
|
||||
p = strrchr(name, '.');
|
||||
|
||||
if (p)
|
||||
nchar = p - name;
|
||||
else
|
||||
nchar = strlen(name);
|
||||
|
||||
for (i = 0; i < sk_CONF_MODULE_num(supported_modules); i++) {
|
||||
tmod = sk_CONF_MODULE_value(supported_modules, i);
|
||||
if (strncmp(tmod->name, name, nchar) == 0)
|
||||
return tmod;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
||||
}
|
||||
|
||||
/* initialize a module */
|
||||
static int module_init(CONF_MODULE *pmod, const char *name, const char *value,
|
||||
const CONF *cnf)
|
||||
{
|
||||
int ret = 1;
|
||||
int init_called = 0;
|
||||
CONF_IMODULE *imod = NULL;
|
||||
|
||||
/* Otherwise add initialized module to list */
|
||||
imod = OPENSSL_malloc(sizeof(*imod));
|
||||
if (imod == NULL)
|
||||
goto err;
|
||||
|
||||
imod->pmod = pmod;
|
||||
imod->name = OPENSSL_strdup(name);
|
||||
imod->value = OPENSSL_strdup(value);
|
||||
imod->usr_data = NULL;
|
||||
|
||||
if (!imod->name || !imod->value)
|
||||
goto memerr;
|
||||
|
||||
/* Try to initialize module */
|
||||
if (pmod->init) {
|
||||
ret = pmod->init(imod, cnf);
|
||||
init_called = 1;
|
||||
/* Error occurred, exit */
|
||||
if (ret <= 0)
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (initialized_modules == NULL) {
|
||||
initialized_modules = sk_CONF_IMODULE_new_null();
|
||||
if (!initialized_modules) {
|
||||
CONFerr(CONF_F_MODULE_INIT, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
if (!sk_CONF_IMODULE_push(initialized_modules, imod)) {
|
||||
CONFerr(CONF_F_MODULE_INIT, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
||||
pmod->links++;
|
||||
|
||||
return ret;
|
||||
|
||||
err:
|
||||
|
||||
/* We've started the module so we'd better finish it */
|
||||
if (pmod->finish && init_called)
|
||||
pmod->finish(imod);
|
||||
|
||||
memerr:
|
||||
if (imod) {
|
||||
OPENSSL_free(imod->name);
|
||||
OPENSSL_free(imod->value);
|
||||
OPENSSL_free(imod);
|
||||
}
|
||||
|
||||
return -1;
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Unload any dynamic modules that have a link count of zero: i.e. have no
|
||||
* active initialized modules. If 'all' is set then all modules are unloaded
|
||||
* including static ones.
|
||||
*/
|
||||
|
||||
void CONF_modules_unload(int all)
|
||||
{
|
||||
int i;
|
||||
CONF_MODULE *md;
|
||||
CONF_modules_finish();
|
||||
/* unload modules in reverse order */
|
||||
for (i = sk_CONF_MODULE_num(supported_modules) - 1; i >= 0; i--) {
|
||||
md = sk_CONF_MODULE_value(supported_modules, i);
|
||||
/* If static or in use and 'all' not set ignore it */
|
||||
if (((md->links > 0) || !md->dso) && !all)
|
||||
continue;
|
||||
/* Since we're working in reverse this is OK */
|
||||
(void)sk_CONF_MODULE_delete(supported_modules, i);
|
||||
module_free(md);
|
||||
}
|
||||
if (sk_CONF_MODULE_num(supported_modules) == 0) {
|
||||
sk_CONF_MODULE_free(supported_modules);
|
||||
supported_modules = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* unload a single module */
|
||||
static void module_free(CONF_MODULE *md)
|
||||
{
|
||||
DSO_free(md->dso);
|
||||
OPENSSL_free(md->name);
|
||||
OPENSSL_free(md);
|
||||
}
|
||||
|
||||
/* finish and free up all modules instances */
|
||||
|
||||
void CONF_modules_finish(void)
|
||||
{
|
||||
CONF_IMODULE *imod;
|
||||
while (sk_CONF_IMODULE_num(initialized_modules) > 0) {
|
||||
imod = sk_CONF_IMODULE_pop(initialized_modules);
|
||||
module_finish(imod);
|
||||
}
|
||||
sk_CONF_IMODULE_free(initialized_modules);
|
||||
initialized_modules = NULL;
|
||||
}
|
||||
|
||||
/* finish a module instance */
|
||||
|
||||
static void module_finish(CONF_IMODULE *imod)
|
||||
{
|
||||
if (!imod)
|
||||
return;
|
||||
if (imod->pmod->finish)
|
||||
imod->pmod->finish(imod);
|
||||
imod->pmod->links--;
|
||||
OPENSSL_free(imod->name);
|
||||
OPENSSL_free(imod->value);
|
||||
OPENSSL_free(imod);
|
||||
}
|
||||
|
||||
/* Add a static module to OpenSSL */
|
||||
|
||||
int CONF_module_add(const char *name, conf_init_func *ifunc,
|
||||
conf_finish_func *ffunc)
|
||||
{
|
||||
if (module_add(NULL, name, ifunc, ffunc))
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
void conf_modules_free_int(void)
|
||||
{
|
||||
CONF_modules_finish();
|
||||
CONF_modules_unload(1);
|
||||
}
|
||||
|
||||
/* Utility functions */
|
||||
|
||||
const char *CONF_imodule_get_name(const CONF_IMODULE *md)
|
||||
{
|
||||
return md->name;
|
||||
}
|
||||
|
||||
const char *CONF_imodule_get_value(const CONF_IMODULE *md)
|
||||
{
|
||||
return md->value;
|
||||
}
|
||||
|
||||
void *CONF_imodule_get_usr_data(const CONF_IMODULE *md)
|
||||
{
|
||||
return md->usr_data;
|
||||
}
|
||||
|
||||
void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data)
|
||||
{
|
||||
md->usr_data = usr_data;
|
||||
}
|
||||
|
||||
CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md)
|
||||
{
|
||||
return md->pmod;
|
||||
}
|
||||
|
||||
unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md)
|
||||
{
|
||||
return md->flags;
|
||||
}
|
||||
|
||||
void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags)
|
||||
{
|
||||
md->flags = flags;
|
||||
}
|
||||
|
||||
void *CONF_module_get_usr_data(CONF_MODULE *pmod)
|
||||
{
|
||||
return pmod->usr_data;
|
||||
}
|
||||
|
||||
void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data)
|
||||
{
|
||||
pmod->usr_data = usr_data;
|
||||
}
|
||||
|
||||
/* Return default config file name */
|
||||
|
||||
char *CONF_get1_default_config_file(void)
|
||||
{
|
||||
char *file, *sep = "";
|
||||
int len;
|
||||
|
||||
if ((file = ossl_safe_getenv("OPENSSL_CONF")) != NULL)
|
||||
return OPENSSL_strdup(file);
|
||||
|
||||
len = strlen(X509_get_default_cert_area());
|
||||
#ifndef OPENSSL_SYS_VMS
|
||||
len++;
|
||||
sep = "/";
|
||||
#endif
|
||||
len += strlen(OPENSSL_CONF);
|
||||
|
||||
file = OPENSSL_malloc(len + 1);
|
||||
|
||||
if (file == NULL)
|
||||
return NULL;
|
||||
BIO_snprintf(file, len + 1, "%s%s%s", X509_get_default_cert_area(),
|
||||
sep, OPENSSL_CONF);
|
||||
|
||||
return file;
|
||||
}
|
||||
|
||||
/*
|
||||
* This function takes a list separated by 'sep' and calls the callback
|
||||
* function giving the start and length of each member optionally stripping
|
||||
* leading and trailing whitespace. This can be used to parse comma separated
|
||||
* lists for example.
|
||||
*/
|
||||
|
||||
int CONF_parse_list(const char *list_, int sep, int nospc,
|
||||
int (*list_cb) (const char *elem, int len, void *usr),
|
||||
void *arg)
|
||||
{
|
||||
int ret;
|
||||
const char *lstart, *tmpend, *p;
|
||||
|
||||
if (list_ == NULL) {
|
||||
CONFerr(CONF_F_CONF_PARSE_LIST, CONF_R_LIST_CANNOT_BE_NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
lstart = list_;
|
||||
for (;;) {
|
||||
if (nospc) {
|
||||
while (*lstart && isspace((unsigned char)*lstart))
|
||||
lstart++;
|
||||
}
|
||||
p = strchr(lstart, sep);
|
||||
if (p == lstart || !*lstart)
|
||||
ret = list_cb(NULL, 0, arg);
|
||||
else {
|
||||
if (p)
|
||||
tmpend = p - 1;
|
||||
else
|
||||
tmpend = lstart + strlen(lstart) - 1;
|
||||
if (nospc) {
|
||||
while (isspace((unsigned char)*tmpend))
|
||||
tmpend--;
|
||||
}
|
||||
ret = list_cb(lstart, tmpend - lstart + 1, arg);
|
||||
}
|
||||
if (ret <= 0)
|
||||
return ret;
|
||||
if (p == NULL)
|
||||
return 1;
|
||||
lstart = p + 1;
|
||||
}
|
||||
}
|
77
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_sap.c
vendored
Normal file
77
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_sap.c
vendored
Normal file
|
@ -0,0 +1,77 @@
|
|||
/*
|
||||
* Copyright 2002-2019 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <openssl/crypto.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include "internal/conf.h"
|
||||
#include <openssl/x509.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/engine.h>
|
||||
|
||||
#ifdef _WIN32
|
||||
# define strdup _strdup
|
||||
#endif
|
||||
|
||||
/*
|
||||
* This is the automatic configuration loader: it is called automatically by
|
||||
* OpenSSL when any of a number of standard initialisation functions are
|
||||
* called, unless this is overridden by calling OPENSSL_no_config()
|
||||
*/
|
||||
|
||||
static int openssl_configured = 0;
|
||||
|
||||
#if OPENSSL_API_COMPAT < 0x10100000L
|
||||
void OPENSSL_config(const char *appname)
|
||||
{
|
||||
OPENSSL_INIT_SETTINGS settings;
|
||||
|
||||
memset(&settings, 0, sizeof(settings));
|
||||
if (appname != NULL)
|
||||
settings.appname = strdup(appname);
|
||||
OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, &settings);
|
||||
}
|
||||
#endif
|
||||
|
||||
int openssl_config_int(const OPENSSL_INIT_SETTINGS *settings)
|
||||
{
|
||||
int ret;
|
||||
const char *filename;
|
||||
const char *appname;
|
||||
unsigned long flags;
|
||||
|
||||
if (openssl_configured)
|
||||
return 1;
|
||||
|
||||
filename = settings ? settings->filename : NULL;
|
||||
appname = settings ? settings->appname : NULL;
|
||||
flags = settings ? settings->flags : DEFAULT_CONF_MFLAGS;
|
||||
|
||||
#ifdef OPENSSL_INIT_DEBUG
|
||||
fprintf(stderr, "OPENSSL_INIT: openssl_config_int(%s, %s, %lu)\n",
|
||||
filename, appname, flags);
|
||||
#endif
|
||||
|
||||
OPENSSL_load_builtin_modules();
|
||||
#ifndef OPENSSL_NO_ENGINE
|
||||
/* Need to load ENGINEs */
|
||||
ENGINE_load_builtin_engines();
|
||||
#endif
|
||||
ERR_clear_error();
|
||||
#ifndef OPENSSL_SYS_UEFI
|
||||
ret = CONF_modules_load_file(filename, appname, flags);
|
||||
#endif
|
||||
openssl_configured = 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void openssl_no_config_int(void)
|
||||
{
|
||||
openssl_configured = 1;
|
||||
}
|
181
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_ssl.c
vendored
Normal file
181
trunk/3rdparty/openssl-1.1-fit/crypto/conf/conf_ssl.c
vendored
Normal file
|
@ -0,0 +1,181 @@
|
|||
/*
|
||||
* Copyright 2015-2019 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <openssl/conf.h>
|
||||
#include <openssl/err.h>
|
||||
#include "internal/sslconf.h"
|
||||
#include "conf_lcl.h"
|
||||
|
||||
/*
|
||||
* SSL library configuration module placeholder. We load it here but defer
|
||||
* all decisions about its contents to libssl.
|
||||
*/
|
||||
|
||||
struct ssl_conf_name_st {
|
||||
/* Name of this set of commands */
|
||||
char *name;
|
||||
/* List of commands */
|
||||
SSL_CONF_CMD *cmds;
|
||||
/* Number of commands */
|
||||
size_t cmd_count;
|
||||
};
|
||||
|
||||
struct ssl_conf_cmd_st {
|
||||
/* Command */
|
||||
char *cmd;
|
||||
/* Argument */
|
||||
char *arg;
|
||||
};
|
||||
|
||||
static struct ssl_conf_name_st *ssl_names;
|
||||
static size_t ssl_names_count;
|
||||
|
||||
static void ssl_module_free(CONF_IMODULE *md)
|
||||
{
|
||||
size_t i, j;
|
||||
if (ssl_names == NULL)
|
||||
return;
|
||||
for (i = 0; i < ssl_names_count; i++) {
|
||||
struct ssl_conf_name_st *tname = ssl_names + i;
|
||||
|
||||
OPENSSL_free(tname->name);
|
||||
for (j = 0; j < tname->cmd_count; j++) {
|
||||
OPENSSL_free(tname->cmds[j].cmd);
|
||||
OPENSSL_free(tname->cmds[j].arg);
|
||||
}
|
||||
OPENSSL_free(tname->cmds);
|
||||
}
|
||||
OPENSSL_free(ssl_names);
|
||||
ssl_names = NULL;
|
||||
ssl_names_count = 0;
|
||||
}
|
||||
|
||||
static int ssl_module_init(CONF_IMODULE *md, const CONF *cnf)
|
||||
{
|
||||
size_t i, j, cnt;
|
||||
int rv = 0;
|
||||
const char *ssl_conf_section;
|
||||
STACK_OF(CONF_VALUE) *cmd_lists;
|
||||
|
||||
ssl_conf_section = CONF_imodule_get_value(md);
|
||||
cmd_lists = NCONF_get_section(cnf, ssl_conf_section);
|
||||
if (sk_CONF_VALUE_num(cmd_lists) <= 0) {
|
||||
if (cmd_lists == NULL)
|
||||
CONFerr(CONF_F_SSL_MODULE_INIT, CONF_R_SSL_SECTION_NOT_FOUND);
|
||||
else
|
||||
CONFerr(CONF_F_SSL_MODULE_INIT, CONF_R_SSL_SECTION_EMPTY);
|
||||
ERR_add_error_data(2, "section=", ssl_conf_section);
|
||||
goto err;
|
||||
}
|
||||
cnt = sk_CONF_VALUE_num(cmd_lists);
|
||||
ssl_module_free(md);
|
||||
ssl_names = OPENSSL_zalloc(sizeof(*ssl_names) * cnt);
|
||||
if (ssl_names == NULL)
|
||||
goto err;
|
||||
ssl_names_count = cnt;
|
||||
for (i = 0; i < ssl_names_count; i++) {
|
||||
struct ssl_conf_name_st *ssl_name = ssl_names + i;
|
||||
CONF_VALUE *sect = sk_CONF_VALUE_value(cmd_lists, (int)i);
|
||||
STACK_OF(CONF_VALUE) *cmds = NCONF_get_section(cnf, sect->value);
|
||||
|
||||
if (sk_CONF_VALUE_num(cmds) <= 0) {
|
||||
if (cmds == NULL)
|
||||
CONFerr(CONF_F_SSL_MODULE_INIT,
|
||||
CONF_R_SSL_COMMAND_SECTION_NOT_FOUND);
|
||||
else
|
||||
CONFerr(CONF_F_SSL_MODULE_INIT,
|
||||
CONF_R_SSL_COMMAND_SECTION_EMPTY);
|
||||
ERR_add_error_data(4, "name=", sect->name, ", value=", sect->value);
|
||||
goto err;
|
||||
}
|
||||
ssl_name->name = OPENSSL_strdup(sect->name);
|
||||
if (ssl_name->name == NULL)
|
||||
goto err;
|
||||
cnt = sk_CONF_VALUE_num(cmds);
|
||||
ssl_name->cmds = OPENSSL_zalloc(cnt * sizeof(struct ssl_conf_cmd_st));
|
||||
if (ssl_name->cmds == NULL)
|
||||
goto err;
|
||||
ssl_name->cmd_count = cnt;
|
||||
for (j = 0; j < cnt; j++) {
|
||||
const char *name;
|
||||
CONF_VALUE *cmd_conf = sk_CONF_VALUE_value(cmds, (int)j);
|
||||
struct ssl_conf_cmd_st *cmd = ssl_name->cmds + j;
|
||||
|
||||
/* Skip any initial dot in name */
|
||||
name = strchr(cmd_conf->name, '.');
|
||||
if (name != NULL)
|
||||
name++;
|
||||
else
|
||||
name = cmd_conf->name;
|
||||
cmd->cmd = OPENSSL_strdup(name);
|
||||
cmd->arg = OPENSSL_strdup(cmd_conf->value);
|
||||
if (cmd->cmd == NULL || cmd->arg == NULL)
|
||||
goto err;
|
||||
}
|
||||
|
||||
}
|
||||
rv = 1;
|
||||
err:
|
||||
if (rv == 0)
|
||||
ssl_module_free(md);
|
||||
return rv;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns the set of commands with index |idx| previously searched for via
|
||||
* conf_ssl_name_find. Also stores the name of the set of commands in |*name|
|
||||
* and the number of commands in the set in |*cnt|.
|
||||
*/
|
||||
const SSL_CONF_CMD *conf_ssl_get(size_t idx, const char **name, size_t *cnt)
|
||||
{
|
||||
*name = ssl_names[idx].name;
|
||||
*cnt = ssl_names[idx].cmd_count;
|
||||
return ssl_names[idx].cmds;
|
||||
}
|
||||
|
||||
/*
|
||||
* Search for the named set of commands given in |name|. On success return the
|
||||
* index for the command set in |*idx|.
|
||||
* Returns 1 on success or 0 on failure.
|
||||
*/
|
||||
int conf_ssl_name_find(const char *name, size_t *idx)
|
||||
{
|
||||
size_t i;
|
||||
const struct ssl_conf_name_st *nm;
|
||||
|
||||
if (name == NULL)
|
||||
return 0;
|
||||
for (i = 0, nm = ssl_names; i < ssl_names_count; i++, nm++) {
|
||||
if (strcmp(nm->name, name) == 0) {
|
||||
*idx = i;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Given a command set |cmd|, return details on the command at index |idx| which
|
||||
* must be less than the number of commands in the set (as returned by
|
||||
* conf_ssl_get). The name of the command will be returned in |*cmdstr| and the
|
||||
* argument is returned in |*arg|.
|
||||
*/
|
||||
void conf_ssl_get_cmd(const SSL_CONF_CMD *cmd, size_t idx, char **cmdstr,
|
||||
char **arg)
|
||||
{
|
||||
*cmdstr = cmd[idx].cmd;
|
||||
*arg = cmd[idx].arg;
|
||||
}
|
||||
|
||||
void conf_add_ssl_module(void)
|
||||
{
|
||||
CONF_module_add("ssl_conf", ssl_module_init, ssl_module_free);
|
||||
}
|
116
trunk/3rdparty/openssl-1.1-fit/crypto/conf/keysets.pl
vendored
Normal file
116
trunk/3rdparty/openssl-1.1-fit/crypto/conf/keysets.pl
vendored
Normal file
|
@ -0,0 +1,116 @@
|
|||
#! /usr/bin/env perl
|
||||
# Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the OpenSSL license (the "License"). You may not use
|
||||
# this file except in compliance with the License. You can obtain a copy
|
||||
# in the file LICENSE in the source distribution or at
|
||||
# https://www.openssl.org/source/license.html
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
my $NUMBER = 0x0001;
|
||||
my $UPPER = 0x0002;
|
||||
my $LOWER = 0x0004;
|
||||
my $UNDER = 0x0100;
|
||||
my $PUNCTUATION = 0x0200;
|
||||
my $WS = 0x0010;
|
||||
my $ESC = 0x0020;
|
||||
my $QUOTE = 0x0040;
|
||||
my $DQUOTE = 0x0400;
|
||||
my $COMMENT = 0x0080;
|
||||
my $FCOMMENT = 0x0800;
|
||||
my $EOF = 0x0008;
|
||||
my @V_def;
|
||||
my @V_w32;
|
||||
|
||||
my $v;
|
||||
my $c;
|
||||
foreach (0 .. 127) {
|
||||
$c = sprintf("%c", $_);
|
||||
$v = 0;
|
||||
$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 |= $ESC if $c =~ /\\/;
|
||||
$v |= $QUOTE if $c =~ /['`"]/; # for emacs: "`'
|
||||
$v |= $COMMENT if $c =~ /\#/;
|
||||
$v |= $EOF if $c =~ /\0/;
|
||||
push(@V_def, $v);
|
||||
|
||||
$v = 0;
|
||||
$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);
|
||||
}
|
||||
|
||||
# Output year depends on the year of the script.
|
||||
my $YEAR = [localtime([stat($0)]->[9])]->[5] + 1900;
|
||||
|
||||
print <<"EOF";
|
||||
/*
|
||||
* WARNING: do not edit!
|
||||
* Generated by crypto/conf/keysets.pl
|
||||
*
|
||||
* Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#define CONF_NUMBER $NUMBER
|
||||
#define CONF_UPPER $UPPER
|
||||
#define CONF_LOWER $LOWER
|
||||
#define CONF_UNDER $UNDER
|
||||
#define CONF_PUNCT $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_ALNUM (CONF_ALPHA|CONF_NUMBER|CONF_UNDER)
|
||||
#define CONF_ALNUM_PUNCT (CONF_ALPHA|CONF_NUMBER|CONF_UNDER|CONF_PUNCT)
|
||||
|
||||
|
||||
#define IS_COMMENT(conf,c) is_keytype(conf, c, CONF_COMMENT)
|
||||
#define IS_FCOMMENT(conf,c) is_keytype(conf, c, CONF_FCOMMENT)
|
||||
#define IS_EOF(conf,c) is_keytype(conf, c, CONF_EOF)
|
||||
#define IS_ESC(conf,c) is_keytype(conf, c, CONF_ESC)
|
||||
#define IS_NUMBER(conf,c) is_keytype(conf, c, CONF_NUMBER)
|
||||
#define IS_WS(conf,c) is_keytype(conf, c, CONF_WS)
|
||||
#define IS_ALNUM(conf,c) is_keytype(conf, c, CONF_ALNUM)
|
||||
#define IS_ALNUM_PUNCT(conf,c) is_keytype(conf, c, CONF_ALNUM_PUNCT)
|
||||
#define IS_QUOTE(conf,c) is_keytype(conf, c, CONF_QUOTE)
|
||||
#define IS_DQUOTE(conf,c) is_keytype(conf, c, CONF_DQUOTE)
|
||||
|
||||
EOF
|
||||
|
||||
my $i;
|
||||
|
||||
print "static const unsigned short CONF_type_default[128] = {";
|
||||
for ($i = 0; $i < 128; $i++) {
|
||||
print "\n " if ($i % 8) == 0;
|
||||
printf " 0x%04X,", $V_def[$i];
|
||||
}
|
||||
print "\n};\n\n";
|
||||
|
||||
print "static const unsigned short CONF_type_win32[128] = {";
|
||||
for ($i = 0; $i < 128; $i++) {
|
||||
print "\n " if ($i % 8) == 0;
|
||||
printf " 0x%04X,", $V_w32[$i];
|
||||
}
|
||||
print "\n};\n";
|
Loading…
Add table
Add a link
Reference in a new issue