aboutsummaryrefslogtreecommitdiff
path: root/openssl-1.1.0h/crypto/conf
diff options
context:
space:
mode:
Diffstat (limited to 'openssl-1.1.0h/crypto/conf')
-rw-r--r--openssl-1.1.0h/crypto/conf/build.info4
-rw-r--r--openssl-1.1.0h/crypto/conf/conf_api.c214
-rw-r--r--openssl-1.1.0h/crypto/conf/conf_def.c642
-rw-r--r--openssl-1.1.0h/crypto/conf/conf_def.h129
-rw-r--r--openssl-1.1.0h/crypto/conf/conf_err.c81
-rw-r--r--openssl-1.1.0h/crypto/conf/conf_lib.c365
-rw-r--r--openssl-1.1.0h/crypto/conf/conf_mall.c29
-rw-r--r--openssl-1.1.0h/crypto/conf/conf_mod.c549
-rw-r--r--openssl-1.1.0h/crypto/conf/conf_sap.c60
-rw-r--r--openssl-1.1.0h/crypto/conf/keysets.pl141
10 files changed, 2214 insertions, 0 deletions
diff --git a/openssl-1.1.0h/crypto/conf/build.info b/openssl-1.1.0h/crypto/conf/build.info
new file mode 100644
index 0000000..4438eb4
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/build.info
@@ -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
diff --git a/openssl-1.1.0h/crypto/conf/conf_api.c b/openssl-1.1.0h/crypto/conf/conf_api.c
new file mode 100644
index 0000000..5535416
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/conf_api.c
@@ -0,0 +1,214 @@
+/*
+ * Copyright 1995-2016 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 <stdlib.h>
+#include <string.h>
+#include <openssl/conf.h>
+#include <openssl/conf_api.h>
+#include "e_os.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 = 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 (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);
+ OPENSSL_assert(vv == NULL);
+ return v;
+
+ err:
+ sk_CONF_VALUE_free(sk);
+ OPENSSL_free(v);
+ return NULL;
+}
diff --git a/openssl-1.1.0h/crypto/conf/conf_def.c b/openssl-1.1.0h/crypto/conf/conf_def.c
new file mode 100644
index 0000000..b443903
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/conf_def.c
@@ -0,0 +1,642 @@
+/*
+ * Copyright 1995-2016 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 <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>
+
+/*
+ * 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 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(conf,p) (((IS_EOF((conf),(p)[1]))?((p)+1):((p)+2)))
+
+static CONF *def_create(CONF_METHOD *meth);
+static int def_init_default(CONF *conf);
+static int def_init_WIN32(CONF *conf);
+static int def_destroy(CONF *conf);
+static int def_destroy_data(CONF *conf);
+static int def_load(CONF *conf, 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()
+{
+ return &default_method;
+}
+
+CONF_METHOD *NCONF_WIN32()
+{
+ 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);
+
+ 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';
+ BIO_gets(in, p, CONFBUFSIZE - 1);
+ p[CONFBUFSIZE - 1] = '\0';
+ ii = i = strlen(p);
+ if (i == 0 && !again)
+ break;
+ 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, &section, 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;
+ psection = NULL;
+ 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);
+ }
+ p = eat_ws(conf, end);
+ if (*p != '=') {
+ CONFerr(CONF_F_DEF_LOAD_BIO, CONF_R_MISSING_EQUAL_SIGN);
+ goto err;
+ }
+ *end = '\0';
+ p++;
+ start = eat_ws(conf, p);
+ while (!IS_EOF(conf, *p))
+ p++;
+ p--;
+ while ((p != start) && (IS_WS(conf, *p)))
+ p--;
+ p++;
+ *p = '\0';
+
+ if ((v = OPENSSL_malloc(sizeof(*v))) == NULL) {
+ CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+ if (psection == NULL)
+ psection = section;
+ v->name = OPENSSL_malloc(strlen(pname) + 1);
+ v->value = NULL;
+ if (v->name == NULL) {
+ CONFerr(CONF_F_DEF_LOAD_BIO, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+ OPENSSL_strlcpy(v->name, pname, strlen(pname) + 1);
+ 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);
+ return (1);
+ err:
+ BUF_MEM_free(buff);
+ OPENSSL_free(section);
+ 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_ALPHA_NUMERIC(conf, *e))
+ e++;
+ if ((e[0] == ':') && (e[1] == ':')) {
+ cp = np;
+ rrp = e;
+ rr = *e;
+ *rrp = '\0';
+ e += 2;
+ np = e;
+ while (IS_ALPHA_NUMERIC(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);
+}
+
+static char *eat_ws(CONF *conf, char *p)
+{
+ while (IS_WS(conf, *p) && (!IS_EOF(conf, *p)))
+ p++;
+ return (p);
+}
+
+static char *eat_alpha_numeric(CONF *conf, char *p)
+{
+ for (;;) {
+ if (IS_ESC(conf, *p)) {
+ p = scan_esc(conf, p);
+ continue;
+ }
+ if (!IS_ALPHA_NUMERIC_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';
+}
diff --git a/openssl-1.1.0h/crypto/conf/conf_def.h b/openssl-1.1.0h/crypto/conf/conf_def.h
new file mode 100644
index 0000000..da4767e
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/conf_def.h
@@ -0,0 +1,129 @@
+/*
+ * WARNING: do not edit!
+ * Generated by crypto/conf/keysets.pl
+ *
+ * Copyright 1995-2016 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_PUNCTUATION 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_HIGHBIT 4096
+#define CONF_ALPHA (CONF_UPPER|CONF_LOWER)
+#define CONF_ALPHA_NUMERIC (CONF_ALPHA|CONF_NUMBER|CONF_UNDER)
+#define CONF_ALPHA_NUMERIC_PUNCT (CONF_ALPHA|CONF_NUMBER|CONF_UNDER| \
+ CONF_PUNCTUATION)
+
+#define KEYTYPES(c) ((const unsigned short *)((c)->meth_data))
+#ifndef CHARSET_EBCDIC
+# define IS_COMMENT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_COMMENT)
+# define IS_FCOMMENT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_FCOMMENT)
+# define IS_EOF(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_EOF)
+# define IS_ESC(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_ESC)
+# define IS_NUMBER(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_NUMBER)
+# define IS_WS(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_WS)
+# define IS_ALPHA_NUMERIC(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC)
+# define IS_ALPHA_NUMERIC_PUNCT(c,a) \
+ (KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC_PUNCT)
+# define IS_QUOTE(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_QUOTE)
+# define IS_DQUOTE(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_DQUOTE)
+# define IS_HIGHBIT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_HIGHBIT)
+
+#else /* CHARSET_EBCDIC */
+
+# define IS_COMMENT(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_COMMENT)
+# define IS_FCOMMENT(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_FCOMMENT)
+# define IS_EOF(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_EOF)
+# define IS_ESC(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_ESC)
+# define IS_NUMBER(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_NUMBER)
+# define IS_WS(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_WS)
+# define IS_ALPHA_NUMERIC(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_ALPHA_NUMERIC)
+# define IS_ALPHA_NUMERIC_PUNCT(c,a) \
+ (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_ALPHA_NUMERIC_PUNCT)
+# define IS_QUOTE(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_QUOTE)
+# define IS_DQUOTE(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_DQUOTE)
+# define IS_HIGHBIT(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_HIGHBIT)
+#endif /* CHARSET_EBCDIC */
+
+static const unsigned short CONF_type_default[256] = {
+ 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0010, 0x0010, 0x0000, 0x0000, 0x0010, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0010, 0x0200, 0x0040, 0x0080, 0x0000, 0x0200, 0x0200, 0x0040,
+ 0x0000, 0x0000, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0000, 0x0200, 0x0000, 0x0000, 0x0000, 0x0200,
+ 0x0200, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0000, 0x0020, 0x0000, 0x0200, 0x0100,
+ 0x0040, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+ 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+ 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+ 0x0004, 0x0004, 0x0004, 0x0000, 0x0200, 0x0000, 0x0200, 0x0000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+};
+
+static const unsigned short CONF_type_win32[256] = {
+ 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0010, 0x0010, 0x0000, 0x0000, 0x0010, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0010, 0x0200, 0x0400, 0x0000, 0x0000, 0x0200, 0x0200, 0x0000,
+ 0x0000, 0x0000, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200, 0x0200,
+ 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
+ 0x0001, 0x0001, 0x0000, 0x0A00, 0x0000, 0x0000, 0x0000, 0x0200,
+ 0x0200, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
+ 0x0002, 0x0002, 0x0002, 0x0000, 0x0000, 0x0000, 0x0200, 0x0100,
+ 0x0000, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+ 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+ 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
+ 0x0004, 0x0004, 0x0004, 0x0000, 0x0200, 0x0000, 0x0200, 0x0000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+ 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000, 0x1000,
+};
diff --git a/openssl-1.1.0h/crypto/conf/conf_err.c b/openssl-1.1.0h/crypto/conf/conf_err.c
new file mode 100644
index 0000000..0863bc4
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/conf_err.c
@@ -0,0 +1,81 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2017 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/err.h>
+#include <openssl/conf.h>
+
+/* BEGIN ERROR CODES */
+#ifndef OPENSSL_NO_ERR
+
+# define ERR_FUNC(func) ERR_PACK(ERR_LIB_CONF,func,0)
+# define ERR_REASON(reason) ERR_PACK(ERR_LIB_CONF,0,reason)
+
+static ERR_STRING_DATA CONF_str_functs[] = {
+ {ERR_FUNC(CONF_F_CONF_DUMP_FP), "CONF_dump_fp"},
+ {ERR_FUNC(CONF_F_CONF_LOAD), "CONF_load"},
+ {ERR_FUNC(CONF_F_CONF_LOAD_FP), "CONF_load_fp"},
+ {ERR_FUNC(CONF_F_CONF_PARSE_LIST), "CONF_parse_list"},
+ {ERR_FUNC(CONF_F_DEF_LOAD), "def_load"},
+ {ERR_FUNC(CONF_F_DEF_LOAD_BIO), "def_load_bio"},
+ {ERR_FUNC(CONF_F_MODULE_INIT), "module_init"},
+ {ERR_FUNC(CONF_F_MODULE_LOAD_DSO), "module_load_dso"},
+ {ERR_FUNC(CONF_F_MODULE_RUN), "module_run"},
+ {ERR_FUNC(CONF_F_NCONF_DUMP_BIO), "NCONF_dump_bio"},
+ {ERR_FUNC(CONF_F_NCONF_DUMP_FP), "NCONF_dump_fp"},
+ {ERR_FUNC(CONF_F_NCONF_GET_NUMBER_E), "NCONF_get_number_e"},
+ {ERR_FUNC(CONF_F_NCONF_GET_SECTION), "NCONF_get_section"},
+ {ERR_FUNC(CONF_F_NCONF_GET_STRING), "NCONF_get_string"},
+ {ERR_FUNC(CONF_F_NCONF_LOAD), "NCONF_load"},
+ {ERR_FUNC(CONF_F_NCONF_LOAD_BIO), "NCONF_load_bio"},
+ {ERR_FUNC(CONF_F_NCONF_LOAD_FP), "NCONF_load_fp"},
+ {ERR_FUNC(CONF_F_NCONF_NEW), "NCONF_new"},
+ {ERR_FUNC(CONF_F_STR_COPY), "str_copy"},
+ {0, NULL}
+};
+
+static ERR_STRING_DATA CONF_str_reasons[] = {
+ {ERR_REASON(CONF_R_ERROR_LOADING_DSO), "error loading dso"},
+ {ERR_REASON(CONF_R_LIST_CANNOT_BE_NULL), "list cannot be null"},
+ {ERR_REASON(CONF_R_MISSING_CLOSE_SQUARE_BRACKET),
+ "missing close square bracket"},
+ {ERR_REASON(CONF_R_MISSING_EQUAL_SIGN), "missing equal sign"},
+ {ERR_REASON(CONF_R_MISSING_INIT_FUNCTION), "missing init function"},
+ {ERR_REASON(CONF_R_MODULE_INITIALIZATION_ERROR),
+ "module initialization error"},
+ {ERR_REASON(CONF_R_NO_CLOSE_BRACE), "no close brace"},
+ {ERR_REASON(CONF_R_NO_CONF), "no conf"},
+ {ERR_REASON(CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE),
+ "no conf or environment variable"},
+ {ERR_REASON(CONF_R_NO_SECTION), "no section"},
+ {ERR_REASON(CONF_R_NO_SUCH_FILE), "no such file"},
+ {ERR_REASON(CONF_R_NO_VALUE), "no value"},
+ {ERR_REASON(CONF_R_UNABLE_TO_CREATE_NEW_SECTION),
+ "unable to create new section"},
+ {ERR_REASON(CONF_R_UNKNOWN_MODULE_NAME), "unknown module name"},
+ {ERR_REASON(CONF_R_VARIABLE_EXPANSION_TOO_LONG),
+ "variable expansion too long"},
+ {ERR_REASON(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(0, CONF_str_functs);
+ ERR_load_strings(0, CONF_str_reasons);
+ }
+#endif
+ return 1;
+}
diff --git a/openssl-1.1.0h/crypto/conf/conf_lib.c b/openssl-1.1.0h/crypto/conf/conf_lib.c
new file mode 100644
index 0000000..3532114
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/conf_lib.c
@@ -0,0 +1,365 @@
+/*
+ * Copyright 2000-2016 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 <internal/conf.h>
+#include <openssl/crypto.h>
+#include <openssl/err.h>
+#include <openssl/conf.h>
+#include <openssl/conf_api.h>
+#include <openssl/lhash.h>
+#include "e_os.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;
+
+ 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);
+ }
+
+ if (status == 0) {
+ /* This function does not believe in errors... */
+ ERR_clear_error();
+ }
+ return 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;
+}
+
+int NCONF_get_number_e(const CONF *conf, const char *group, const char *name,
+ long *result)
+{
+ char *str;
+
+ 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;
+
+ for (*result = 0; conf->meth->is_number(conf, *str);) {
+ *result = (*result) * 10 + conf->meth->to_int(conf, *str);
+ str++;
+ }
+
+ 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));
+ return ret;
+}
+
+
+#ifndef OPENSSL_NO_STDIO
+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->appname);
+ free(settings);
+}
diff --git a/openssl-1.1.0h/crypto/conf/conf_mall.c b/openssl-1.1.0h/crypto/conf/conf_mall.c
new file mode 100644
index 0000000..4e7a434
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/conf_mall.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2002-2016 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>
+
+/* 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();
+}
diff --git a/openssl-1.1.0h/crypto/conf/conf_mod.c b/openssl-1.1.0h/crypto/conf/conf_mod.c
new file mode 100644
index 0000000..543a8ea
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/conf_mod.c
@@ -0,0 +1,549 @@
+/*
+ * Copyright 2002-2016 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 <ctype.h>
+#include <openssl/crypto.h>
+#include "internal/cryptlib.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);
+
+ 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;
+ tmod = OPENSSL_zalloc(sizeof(*tmod));
+ if (tmod == NULL)
+ 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;
+ int len;
+
+ file = getenv("OPENSSL_CONF");
+ if (file)
+ return OPENSSL_strdup(file);
+
+ len = strlen(X509_get_default_cert_area());
+#ifndef OPENSSL_SYS_VMS
+ len++;
+#endif
+ len += strlen(OPENSSL_CONF);
+
+ file = OPENSSL_malloc(len + 1);
+
+ if (file == NULL)
+ return NULL;
+ OPENSSL_strlcpy(file, X509_get_default_cert_area(), len + 1);
+#ifndef OPENSSL_SYS_VMS
+ OPENSSL_strlcat(file, "/", len + 1);
+#endif
+ OPENSSL_strlcat(file, OPENSSL_CONF, len + 1);
+
+ 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;
+ }
+}
diff --git a/openssl-1.1.0h/crypto/conf/conf_sap.c b/openssl-1.1.0h/crypto/conf/conf_sap.c
new file mode 100644
index 0000000..bed95ab
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/conf_sap.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2002-2016 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>
+
+/*
+ * 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
+
+void openssl_config_int(const char *appname)
+{
+ if (openssl_configured)
+ return;
+
+ OPENSSL_load_builtin_modules();
+#ifndef OPENSSL_NO_ENGINE
+ /* Need to load ENGINEs */
+ ENGINE_load_builtin_engines();
+#endif
+ ERR_clear_error();
+#ifndef OPENSSL_SYS_UEFI
+ CONF_modules_load_file(NULL, appname,
+ CONF_MFLAGS_DEFAULT_SECTION |
+ CONF_MFLAGS_IGNORE_MISSING_FILE);
+#endif
+ openssl_configured = 1;
+}
+
+void openssl_no_config_int(void)
+{
+ openssl_configured = 1;
+}
diff --git a/openssl-1.1.0h/crypto/conf/keysets.pl b/openssl-1.1.0h/crypto/conf/keysets.pl
new file mode 100644
index 0000000..5af08ae
--- /dev/null
+++ b/openssl-1.1.0h/crypto/conf/keysets.pl
@@ -0,0 +1,141 @@
+#! /usr/bin/env perl
+# Copyright 1995-2016 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
+
+$NUMBER=0x01;
+$UPPER=0x02;
+$LOWER=0x04;
+$UNDER=0x100;
+$PUNCTUATION=0x200;
+$WS=0x10;
+$ESC=0x20;
+$QUOTE=0x40;
+$DQUOTE=0x400;
+$COMMENT=0x80;
+$FCOMMENT=0x800;
+$EOF=0x08;
+$HIGHBIT=0x1000;
+
+foreach (0 .. 255)
+ {
+ $v=0;
+ $c=sprintf("%c",$_);
+ $v|=$NUMBER if ($c =~ /[0-9]/);
+ $v|=$UPPER if ($c =~ /[A-Z]/);
+ $v|=$LOWER if ($c =~ /[a-z]/);
+ $v|=$UNDER if ($c =~ /_/);
+ $v|=$PUNCTUATION if ($c =~ /[!\.%&\*\+,\/;\?\@\^\~\|-]/);
+ $v|=$WS if ($c =~ /[ \t\r\n]/);
+ $v|=$ESC if ($c =~ /\\/);
+ $v|=$QUOTE if ($c =~ /['`"]/); # for emacs: "`'}/)
+ $v|=$COMMENT if ($c =~ /\#/);
+ $v|=$EOF if ($c =~ /\0/);
+ $v|=$HIGHBIT if ($c =~/[\x80-\xff]/);
+
+ push(@V_def,$v);
+ }
+
+foreach (0 .. 255)
+ {
+ $v=0;
+ $c=sprintf("%c",$_);
+ $v|=$NUMBER if ($c =~ /[0-9]/);
+ $v|=$UPPER if ($c =~ /[A-Z]/);
+ $v|=$LOWER if ($c =~ /[a-z]/);
+ $v|=$UNDER if ($c =~ /_/);
+ $v|=$PUNCTUATION if ($c =~ /[!\.%&\*\+,\/;\?\@\^\~\|-]/);
+ $v|=$WS if ($c =~ /[ \t\r\n]/);
+ $v|=$DQUOTE if ($c =~ /["]/); # for emacs: "}/)
+ $v|=$FCOMMENT if ($c =~ /;/);
+ $v|=$EOF if ($c =~ /\0/);
+ $v|=$HIGHBIT if ($c =~/[\x80-\xff]/);
+
+ push(@V_w32,$v);
+ }
+
+print <<"EOF";
+/*
+ * WARNING: do not edit!
+ * Generated by crypto/conf/keysets.pl
+ *
+ * Copyright 1995-2016 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_PUNCTUATION $PUNCTUATION
+#define CONF_WS $WS
+#define CONF_ESC $ESC
+#define CONF_QUOTE $QUOTE
+#define CONF_DQUOTE $DQUOTE
+#define CONF_COMMENT $COMMENT
+#define CONF_FCOMMENT $FCOMMENT
+#define CONF_EOF $EOF
+#define CONF_HIGHBIT $HIGHBIT
+#define CONF_ALPHA (CONF_UPPER|CONF_LOWER)
+#define CONF_ALPHA_NUMERIC (CONF_ALPHA|CONF_NUMBER|CONF_UNDER)
+#define CONF_ALPHA_NUMERIC_PUNCT (CONF_ALPHA|CONF_NUMBER|CONF_UNDER| \\
+ CONF_PUNCTUATION)
+
+#define KEYTYPES(c) ((const unsigned short *)((c)->meth_data))
+#ifndef CHARSET_EBCDIC
+# define IS_COMMENT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_COMMENT)
+# define IS_FCOMMENT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_FCOMMENT)
+# define IS_EOF(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_EOF)
+# define IS_ESC(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_ESC)
+# define IS_NUMBER(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_NUMBER)
+# define IS_WS(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_WS)
+# define IS_ALPHA_NUMERIC(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC)
+# define IS_ALPHA_NUMERIC_PUNCT(c,a) \\
+ (KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC_PUNCT)
+# define IS_QUOTE(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_QUOTE)
+# define IS_DQUOTE(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_DQUOTE)
+# define IS_HIGHBIT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_HIGHBIT)
+
+#else /* CHARSET_EBCDIC */
+
+# define IS_COMMENT(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_COMMENT)
+# define IS_FCOMMENT(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_FCOMMENT)
+# define IS_EOF(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_EOF)
+# define IS_ESC(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_ESC)
+# define IS_NUMBER(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_NUMBER)
+# define IS_WS(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_WS)
+# define IS_ALPHA_NUMERIC(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_ALPHA_NUMERIC)
+# define IS_ALPHA_NUMERIC_PUNCT(c,a) \\
+ (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_ALPHA_NUMERIC_PUNCT)
+# define IS_QUOTE(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_QUOTE)
+# define IS_DQUOTE(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_DQUOTE)
+# define IS_HIGHBIT(c,a) (KEYTYPES(c)[os_toascii[a & 0xff]]&CONF_HIGHBIT)
+#endif /* CHARSET_EBCDIC */
+
+EOF
+
+print "static const unsigned short CONF_type_default[256] = {";
+
+for ($i=0; $i<256; $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[256] = {";
+
+for ($i=0; $i<256; $i++)
+ {
+ print "\n " if ($i % 8) == 0;
+ printf " 0x%04X,",$V_w32[$i];
+ }
+
+print "\n};\n";
generated by cgit