[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/lib/libssl/openssl-1.1.1o/crypto/ui/build.info b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/build.info
new file mode 100644
index 0000000..c5d17fb
--- /dev/null
+++ b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/build.info
@@ -0,0 +1,3 @@
+LIBS=../../libcrypto
+SOURCE[../../libcrypto]=\
+ ui_err.c ui_lib.c ui_openssl.c ui_null.c ui_util.c
diff --git a/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_err.c b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_err.c
new file mode 100644
index 0000000..b806872
--- /dev/null
+++ b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_err.c
@@ -0,0 +1,78 @@
+/*
+ * 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/uierr.h>
+
+#ifndef OPENSSL_NO_ERR
+
+static const ERR_STRING_DATA UI_str_functs[] = {
+ {ERR_PACK(ERR_LIB_UI, UI_F_CLOSE_CONSOLE, 0), "close_console"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_ECHO_CONSOLE, 0), "echo_console"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_GENERAL_ALLOCATE_BOOLEAN, 0),
+ "general_allocate_boolean"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_GENERAL_ALLOCATE_PROMPT, 0),
+ "general_allocate_prompt"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_NOECHO_CONSOLE, 0), "noecho_console"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_OPEN_CONSOLE, 0), "open_console"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_CONSTRUCT_PROMPT, 0), "UI_construct_prompt"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_CREATE_METHOD, 0), "UI_create_method"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_CTRL, 0), "UI_ctrl"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_DUP_ERROR_STRING, 0), "UI_dup_error_string"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_DUP_INFO_STRING, 0), "UI_dup_info_string"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_DUP_INPUT_BOOLEAN, 0),
+ "UI_dup_input_boolean"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_DUP_INPUT_STRING, 0), "UI_dup_input_string"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_DUP_USER_DATA, 0), "UI_dup_user_data"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_DUP_VERIFY_STRING, 0),
+ "UI_dup_verify_string"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_GET0_RESULT, 0), "UI_get0_result"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_GET_RESULT_LENGTH, 0),
+ "UI_get_result_length"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_NEW_METHOD, 0), "UI_new_method"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_PROCESS, 0), "UI_process"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_SET_RESULT, 0), "UI_set_result"},
+ {ERR_PACK(ERR_LIB_UI, UI_F_UI_SET_RESULT_EX, 0), "UI_set_result_ex"},
+ {0, NULL}
+};
+
+static const ERR_STRING_DATA UI_str_reasons[] = {
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_COMMON_OK_AND_CANCEL_CHARACTERS),
+ "common ok and cancel characters"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_INDEX_TOO_LARGE), "index too large"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_INDEX_TOO_SMALL), "index too small"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_NO_RESULT_BUFFER), "no result buffer"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_PROCESSING_ERROR), "processing error"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_RESULT_TOO_LARGE), "result too large"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_RESULT_TOO_SMALL), "result too small"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_SYSASSIGN_ERROR), "sys$assign error"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_SYSDASSGN_ERROR), "sys$dassgn error"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_SYSQIOW_ERROR), "sys$qiow error"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_UNKNOWN_CONTROL_COMMAND),
+ "unknown control command"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_UNKNOWN_TTYGET_ERRNO_VALUE),
+ "unknown ttyget errno value"},
+ {ERR_PACK(ERR_LIB_UI, 0, UI_R_USER_DATA_DUPLICATION_UNSUPPORTED),
+ "user data duplication unsupported"},
+ {0, NULL}
+};
+
+#endif
+
+int ERR_load_UI_strings(void)
+{
+#ifndef OPENSSL_NO_ERR
+ if (ERR_func_error_string(UI_str_functs[0].error) == NULL) {
+ ERR_load_strings_const(UI_str_functs);
+ ERR_load_strings_const(UI_str_reasons);
+ }
+#endif
+ return 1;
+}
diff --git a/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_lib.c b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_lib.c
new file mode 100644
index 0000000..49cc450
--- /dev/null
+++ b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_lib.c
@@ -0,0 +1,956 @@
+/*
+ * Copyright 2001-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 <string.h>
+#include "internal/cryptlib.h"
+#include <openssl/e_os2.h>
+#include <openssl/buffer.h>
+#include <openssl/ui.h>
+#include <openssl/err.h>
+#include "ui_local.h"
+
+UI *UI_new(void)
+{
+ return UI_new_method(NULL);
+}
+
+UI *UI_new_method(const UI_METHOD *method)
+{
+ UI *ret = OPENSSL_zalloc(sizeof(*ret));
+
+ if (ret == NULL) {
+ UIerr(UI_F_UI_NEW_METHOD, ERR_R_MALLOC_FAILURE);
+ return NULL;
+ }
+
+ ret->lock = CRYPTO_THREAD_lock_new();
+ if (ret->lock == NULL) {
+ UIerr(UI_F_UI_NEW_METHOD, ERR_R_MALLOC_FAILURE);
+ OPENSSL_free(ret);
+ return NULL;
+ }
+
+ if (method == NULL)
+ method = UI_get_default_method();
+ if (method == NULL)
+ method = UI_null();
+ ret->meth = method;
+
+ if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_UI, ret, &ret->ex_data)) {
+ OPENSSL_free(ret);
+ return NULL;
+ }
+ return ret;
+}
+
+static void free_string(UI_STRING *uis)
+{
+ if (uis->flags & OUT_STRING_FREEABLE) {
+ OPENSSL_free((char *)uis->out_string);
+ switch (uis->type) {
+ case UIT_BOOLEAN:
+ OPENSSL_free((char *)uis->_.boolean_data.action_desc);
+ OPENSSL_free((char *)uis->_.boolean_data.ok_chars);
+ OPENSSL_free((char *)uis->_.boolean_data.cancel_chars);
+ break;
+ case UIT_NONE:
+ case UIT_PROMPT:
+ case UIT_VERIFY:
+ case UIT_ERROR:
+ case UIT_INFO:
+ break;
+ }
+ }
+ OPENSSL_free(uis);
+}
+
+void UI_free(UI *ui)
+{
+ if (ui == NULL)
+ return;
+ if ((ui->flags & UI_FLAG_DUPL_DATA) != 0) {
+ ui->meth->ui_destroy_data(ui, ui->user_data);
+ }
+ sk_UI_STRING_pop_free(ui->strings, free_string);
+ CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data);
+ CRYPTO_THREAD_lock_free(ui->lock);
+ OPENSSL_free(ui);
+}
+
+static int allocate_string_stack(UI *ui)
+{
+ if (ui->strings == NULL) {
+ ui->strings = sk_UI_STRING_new_null();
+ if (ui->strings == NULL) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static UI_STRING *general_allocate_prompt(UI *ui, const char *prompt,
+ int prompt_freeable,
+ enum UI_string_types type,
+ int input_flags, char *result_buf)
+{
+ UI_STRING *ret = NULL;
+
+ if (prompt == NULL) {
+ UIerr(UI_F_GENERAL_ALLOCATE_PROMPT, ERR_R_PASSED_NULL_PARAMETER);
+ } else if ((type == UIT_PROMPT || type == UIT_VERIFY
+ || type == UIT_BOOLEAN) && result_buf == NULL) {
+ UIerr(UI_F_GENERAL_ALLOCATE_PROMPT, UI_R_NO_RESULT_BUFFER);
+ } else if ((ret = OPENSSL_malloc(sizeof(*ret))) != NULL) {
+ ret->out_string = prompt;
+ ret->flags = prompt_freeable ? OUT_STRING_FREEABLE : 0;
+ ret->input_flags = input_flags;
+ ret->type = type;
+ ret->result_buf = result_buf;
+ }
+ return ret;
+}
+
+static int general_allocate_string(UI *ui, const char *prompt,
+ int prompt_freeable,
+ enum UI_string_types type, int input_flags,
+ char *result_buf, int minsize, int maxsize,
+ const char *test_buf)
+{
+ int ret = -1;
+ UI_STRING *s = general_allocate_prompt(ui, prompt, prompt_freeable,
+ type, input_flags, result_buf);
+
+ if (s != NULL) {
+ if (allocate_string_stack(ui) >= 0) {
+ s->_.string_data.result_minsize = minsize;
+ s->_.string_data.result_maxsize = maxsize;
+ s->_.string_data.test_buf = test_buf;
+ ret = sk_UI_STRING_push(ui->strings, s);
+ /* sk_push() returns 0 on error. Let's adapt that */
+ if (ret <= 0) {
+ ret--;
+ free_string(s);
+ }
+ } else
+ free_string(s);
+ }
+ return ret;
+}
+
+static int general_allocate_boolean(UI *ui,
+ const char *prompt,
+ const char *action_desc,
+ const char *ok_chars,
+ const char *cancel_chars,
+ int prompt_freeable,
+ enum UI_string_types type,
+ int input_flags, char *result_buf)
+{
+ int ret = -1;
+ UI_STRING *s;
+ const char *p;
+
+ if (ok_chars == NULL) {
+ UIerr(UI_F_GENERAL_ALLOCATE_BOOLEAN, ERR_R_PASSED_NULL_PARAMETER);
+ } else if (cancel_chars == NULL) {
+ UIerr(UI_F_GENERAL_ALLOCATE_BOOLEAN, ERR_R_PASSED_NULL_PARAMETER);
+ } else {
+ for (p = ok_chars; *p != '\0'; p++) {
+ if (strchr(cancel_chars, *p) != NULL) {
+ UIerr(UI_F_GENERAL_ALLOCATE_BOOLEAN,
+ UI_R_COMMON_OK_AND_CANCEL_CHARACTERS);
+ }
+ }
+
+ s = general_allocate_prompt(ui, prompt, prompt_freeable,
+ type, input_flags, result_buf);
+
+ if (s != NULL) {
+ if (allocate_string_stack(ui) >= 0) {
+ s->_.boolean_data.action_desc = action_desc;
+ s->_.boolean_data.ok_chars = ok_chars;
+ s->_.boolean_data.cancel_chars = cancel_chars;
+ ret = sk_UI_STRING_push(ui->strings, s);
+ /*
+ * sk_push() returns 0 on error. Let's adapt that
+ */
+ if (ret <= 0) {
+ ret--;
+ free_string(s);
+ }
+ } else
+ free_string(s);
+ }
+ }
+ return ret;
+}
+
+/*
+ * Returns the index to the place in the stack or -1 for error. Uses a
+ * direct reference to the prompt.
+ */
+int UI_add_input_string(UI *ui, const char *prompt, int flags,
+ char *result_buf, int minsize, int maxsize)
+{
+ return general_allocate_string(ui, prompt, 0,
+ UIT_PROMPT, flags, result_buf, minsize,
+ maxsize, NULL);
+}
+
+/* Same as UI_add_input_string(), excepts it takes a copy of the prompt */
+int UI_dup_input_string(UI *ui, const char *prompt, int flags,
+ char *result_buf, int minsize, int maxsize)
+{
+ char *prompt_copy = NULL;
+
+ if (prompt != NULL) {
+ prompt_copy = OPENSSL_strdup(prompt);
+ if (prompt_copy == NULL) {
+ UIerr(UI_F_UI_DUP_INPUT_STRING, ERR_R_MALLOC_FAILURE);
+ return 0;
+ }
+ }
+
+ return general_allocate_string(ui, prompt_copy, 1,
+ UIT_PROMPT, flags, result_buf, minsize,
+ maxsize, NULL);
+}
+
+int UI_add_verify_string(UI *ui, const char *prompt, int flags,
+ char *result_buf, int minsize, int maxsize,
+ const char *test_buf)
+{
+ return general_allocate_string(ui, prompt, 0,
+ UIT_VERIFY, flags, result_buf, minsize,
+ maxsize, test_buf);
+}
+
+int UI_dup_verify_string(UI *ui, const char *prompt, int flags,
+ char *result_buf, int minsize, int maxsize,
+ const char *test_buf)
+{
+ char *prompt_copy = NULL;
+
+ if (prompt != NULL) {
+ prompt_copy = OPENSSL_strdup(prompt);
+ if (prompt_copy == NULL) {
+ UIerr(UI_F_UI_DUP_VERIFY_STRING, ERR_R_MALLOC_FAILURE);
+ return -1;
+ }
+ }
+
+ return general_allocate_string(ui, prompt_copy, 1,
+ UIT_VERIFY, flags, result_buf, minsize,
+ maxsize, test_buf);
+}
+
+int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
+ const char *ok_chars, const char *cancel_chars,
+ int flags, char *result_buf)
+{
+ return general_allocate_boolean(ui, prompt, action_desc,
+ ok_chars, cancel_chars, 0, UIT_BOOLEAN,
+ flags, result_buf);
+}
+
+int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
+ const char *ok_chars, const char *cancel_chars,
+ int flags, char *result_buf)
+{
+ char *prompt_copy = NULL;
+ char *action_desc_copy = NULL;
+ char *ok_chars_copy = NULL;
+ char *cancel_chars_copy = NULL;
+
+ if (prompt != NULL) {
+ prompt_copy = OPENSSL_strdup(prompt);
+ if (prompt_copy == NULL) {
+ UIerr(UI_F_UI_DUP_INPUT_BOOLEAN, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+ }
+
+ if (action_desc != NULL) {
+ action_desc_copy = OPENSSL_strdup(action_desc);
+ if (action_desc_copy == NULL) {
+ UIerr(UI_F_UI_DUP_INPUT_BOOLEAN, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+ }
+
+ if (ok_chars != NULL) {
+ ok_chars_copy = OPENSSL_strdup(ok_chars);
+ if (ok_chars_copy == NULL) {
+ UIerr(UI_F_UI_DUP_INPUT_BOOLEAN, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+ }
+
+ if (cancel_chars != NULL) {
+ cancel_chars_copy = OPENSSL_strdup(cancel_chars);
+ if (cancel_chars_copy == NULL) {
+ UIerr(UI_F_UI_DUP_INPUT_BOOLEAN, ERR_R_MALLOC_FAILURE);
+ goto err;
+ }
+ }
+
+ return general_allocate_boolean(ui, prompt_copy, action_desc_copy,
+ ok_chars_copy, cancel_chars_copy, 1,
+ UIT_BOOLEAN, flags, result_buf);
+ err:
+ OPENSSL_free(prompt_copy);
+ OPENSSL_free(action_desc_copy);
+ OPENSSL_free(ok_chars_copy);
+ OPENSSL_free(cancel_chars_copy);
+ return -1;
+}
+
+int UI_add_info_string(UI *ui, const char *text)
+{
+ return general_allocate_string(ui, text, 0, UIT_INFO, 0, NULL, 0, 0,
+ NULL);
+}
+
+int UI_dup_info_string(UI *ui, const char *text)
+{
+ char *text_copy = NULL;
+
+ if (text != NULL) {
+ text_copy = OPENSSL_strdup(text);
+ if (text_copy == NULL) {
+ UIerr(UI_F_UI_DUP_INFO_STRING, ERR_R_MALLOC_FAILURE);
+ return -1;
+ }
+ }
+
+ return general_allocate_string(ui, text_copy, 1, UIT_INFO, 0, NULL,
+ 0, 0, NULL);
+}
+
+int UI_add_error_string(UI *ui, const char *text)
+{
+ return general_allocate_string(ui, text, 0, UIT_ERROR, 0, NULL, 0, 0,
+ NULL);
+}
+
+int UI_dup_error_string(UI *ui, const char *text)
+{
+ char *text_copy = NULL;
+
+ if (text != NULL) {
+ text_copy = OPENSSL_strdup(text);
+ if (text_copy == NULL) {
+ UIerr(UI_F_UI_DUP_ERROR_STRING, ERR_R_MALLOC_FAILURE);
+ return -1;
+ }
+ }
+ return general_allocate_string(ui, text_copy, 1, UIT_ERROR, 0, NULL,
+ 0, 0, NULL);
+}
+
+char *UI_construct_prompt(UI *ui, const char *object_desc,
+ const char *object_name)
+{
+ char *prompt = NULL;
+
+ if (ui->meth->ui_construct_prompt != NULL)
+ prompt = ui->meth->ui_construct_prompt(ui, object_desc, object_name);
+ else {
+ char prompt1[] = "Enter ";
+ char prompt2[] = " for ";
+ char prompt3[] = ":";
+ int len = 0;
+
+ if (object_desc == NULL)
+ return NULL;
+ len = sizeof(prompt1) - 1 + strlen(object_desc);
+ if (object_name != NULL)
+ len += sizeof(prompt2) - 1 + strlen(object_name);
+ len += sizeof(prompt3) - 1;
+
+ if ((prompt = OPENSSL_malloc(len + 1)) == NULL) {
+ UIerr(UI_F_UI_CONSTRUCT_PROMPT, ERR_R_MALLOC_FAILURE);
+ return NULL;
+ }
+ OPENSSL_strlcpy(prompt, prompt1, len + 1);
+ OPENSSL_strlcat(prompt, object_desc, len + 1);
+ if (object_name != NULL) {
+ OPENSSL_strlcat(prompt, prompt2, len + 1);
+ OPENSSL_strlcat(prompt, object_name, len + 1);
+ }
+ OPENSSL_strlcat(prompt, prompt3, len + 1);
+ }
+ return prompt;
+}
+
+void *UI_add_user_data(UI *ui, void *user_data)
+{
+ void *old_data = ui->user_data;
+
+ if ((ui->flags & UI_FLAG_DUPL_DATA) != 0) {
+ ui->meth->ui_destroy_data(ui, old_data);
+ old_data = NULL;
+ }
+ ui->user_data = user_data;
+ ui->flags &= ~UI_FLAG_DUPL_DATA;
+ return old_data;
+}
+
+int UI_dup_user_data(UI *ui, void *user_data)
+{
+ void *duplicate = NULL;
+
+ if (ui->meth->ui_duplicate_data == NULL
+ || ui->meth->ui_destroy_data == NULL) {
+ UIerr(UI_F_UI_DUP_USER_DATA, UI_R_USER_DATA_DUPLICATION_UNSUPPORTED);
+ return -1;
+ }
+
+ duplicate = ui->meth->ui_duplicate_data(ui, user_data);
+ if (duplicate == NULL) {
+ UIerr(UI_F_UI_DUP_USER_DATA, ERR_R_MALLOC_FAILURE);
+ return -1;
+ }
+
+ (void)UI_add_user_data(ui, duplicate);
+ ui->flags |= UI_FLAG_DUPL_DATA;
+
+ return 0;
+}
+
+void *UI_get0_user_data(UI *ui)
+{
+ return ui->user_data;
+}
+
+const char *UI_get0_result(UI *ui, int i)
+{
+ if (i < 0) {
+ UIerr(UI_F_UI_GET0_RESULT, UI_R_INDEX_TOO_SMALL);
+ return NULL;
+ }
+ if (i >= sk_UI_STRING_num(ui->strings)) {
+ UIerr(UI_F_UI_GET0_RESULT, UI_R_INDEX_TOO_LARGE);
+ return NULL;
+ }
+ return UI_get0_result_string(sk_UI_STRING_value(ui->strings, i));
+}
+
+int UI_get_result_length(UI *ui, int i)
+{
+ if (i < 0) {
+ UIerr(UI_F_UI_GET_RESULT_LENGTH, UI_R_INDEX_TOO_SMALL);
+ return -1;
+ }
+ if (i >= sk_UI_STRING_num(ui->strings)) {
+ UIerr(UI_F_UI_GET_RESULT_LENGTH, UI_R_INDEX_TOO_LARGE);
+ return -1;
+ }
+ return UI_get_result_string_length(sk_UI_STRING_value(ui->strings, i));
+}
+
+static int print_error(const char *str, size_t len, UI *ui)
+{
+ UI_STRING uis;
+
+ memset(&uis, 0, sizeof(uis));
+ uis.type = UIT_ERROR;
+ uis.out_string = str;
+
+ if (ui->meth->ui_write_string != NULL
+ && ui->meth->ui_write_string(ui, &uis) <= 0)
+ return -1;
+ return 0;
+}
+
+int UI_process(UI *ui)
+{
+ int i, ok = 0;
+ const char *state = "processing";
+
+ if (ui->meth->ui_open_session != NULL
+ && ui->meth->ui_open_session(ui) <= 0) {
+ state = "opening session";
+ ok = -1;
+ goto err;
+ }
+
+ if (ui->flags & UI_FLAG_PRINT_ERRORS)
+ ERR_print_errors_cb((int (*)(const char *, size_t, void *))
+ print_error, (void *)ui);
+
+ for (i = 0; i < sk_UI_STRING_num(ui->strings); i++) {
+ if (ui->meth->ui_write_string != NULL
+ && (ui->meth->ui_write_string(ui,
+ sk_UI_STRING_value(ui->strings, i))
+ <= 0))
+ {
+ state = "writing strings";
+ ok = -1;
+ goto err;
+ }
+ }
+
+ if (ui->meth->ui_flush != NULL)
+ switch (ui->meth->ui_flush(ui)) {
+ case -1: /* Interrupt/Cancel/something... */
+ ui->flags &= ~UI_FLAG_REDOABLE;
+ ok = -2;
+ goto err;
+ case 0: /* Errors */
+ state = "flushing";
+ ok = -1;
+ goto err;
+ default: /* Success */
+ ok = 0;
+ break;
+ }
+
+ for (i = 0; i < sk_UI_STRING_num(ui->strings); i++) {
+ if (ui->meth->ui_read_string != NULL) {
+ switch (ui->meth->ui_read_string(ui,
+ sk_UI_STRING_value(ui->strings,
+ i))) {
+ case -1: /* Interrupt/Cancel/something... */
+ ui->flags &= ~UI_FLAG_REDOABLE;
+ ok = -2;
+ goto err;
+ case 0: /* Errors */
+ state = "reading strings";
+ ok = -1;
+ goto err;
+ default: /* Success */
+ ok = 0;
+ break;
+ }
+ }
+ }
+
+ state = NULL;
+ err:
+ if (ui->meth->ui_close_session != NULL
+ && ui->meth->ui_close_session(ui) <= 0) {
+ if (state == NULL)
+ state = "closing session";
+ ok = -1;
+ }
+
+ if (ok == -1) {
+ UIerr(UI_F_UI_PROCESS, UI_R_PROCESSING_ERROR);
+ ERR_add_error_data(2, "while ", state);
+ }
+ return ok;
+}
+
+int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void))
+{
+ if (ui == NULL) {
+ UIerr(UI_F_UI_CTRL, ERR_R_PASSED_NULL_PARAMETER);
+ return -1;
+ }
+ switch (cmd) {
+ case UI_CTRL_PRINT_ERRORS:
+ {
+ int save_flag = ! !(ui->flags & UI_FLAG_PRINT_ERRORS);
+ if (i)
+ ui->flags |= UI_FLAG_PRINT_ERRORS;
+ else
+ ui->flags &= ~UI_FLAG_PRINT_ERRORS;
+ return save_flag;
+ }
+ case UI_CTRL_IS_REDOABLE:
+ return ! !(ui->flags & UI_FLAG_REDOABLE);
+ default:
+ break;
+ }
+ UIerr(UI_F_UI_CTRL, UI_R_UNKNOWN_CONTROL_COMMAND);
+ return -1;
+}
+
+int UI_set_ex_data(UI *r, int idx, void *arg)
+{
+ return CRYPTO_set_ex_data(&r->ex_data, idx, arg);
+}
+
+void *UI_get_ex_data(UI *r, int idx)
+{
+ return CRYPTO_get_ex_data(&r->ex_data, idx);
+}
+
+const UI_METHOD *UI_get_method(UI *ui)
+{
+ return ui->meth;
+}
+
+const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth)
+{
+ ui->meth = meth;
+ return ui->meth;
+}
+
+UI_METHOD *UI_create_method(const char *name)
+{
+ UI_METHOD *ui_method = NULL;
+
+ if ((ui_method = OPENSSL_zalloc(sizeof(*ui_method))) == NULL
+ || (ui_method->name = OPENSSL_strdup(name)) == NULL
+ || !CRYPTO_new_ex_data(CRYPTO_EX_INDEX_UI_METHOD, ui_method,
+ &ui_method->ex_data)) {
+ if (ui_method)
+ OPENSSL_free(ui_method->name);
+ OPENSSL_free(ui_method);
+ UIerr(UI_F_UI_CREATE_METHOD, ERR_R_MALLOC_FAILURE);
+ return NULL;
+ }
+ return ui_method;
+}
+
+/*
+ * BIG FSCKING WARNING!!!! If you use this on a statically allocated method
+ * (that is, it hasn't been allocated using UI_create_method(), you deserve
+ * anything Murphy can throw at you and more! You have been warned.
+ */
+void UI_destroy_method(UI_METHOD *ui_method)
+{
+ if (ui_method == NULL)
+ return;
+ CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI_METHOD, ui_method,
+ &ui_method->ex_data);
+ OPENSSL_free(ui_method->name);
+ ui_method->name = NULL;
+ OPENSSL_free(ui_method);
+}
+
+int UI_method_set_opener(UI_METHOD *method, int (*opener) (UI *ui))
+{
+ if (method != NULL) {
+ method->ui_open_session = opener;
+ return 0;
+ }
+ return -1;
+}
+
+int UI_method_set_writer(UI_METHOD *method,
+ int (*writer) (UI *ui, UI_STRING *uis))
+{
+ if (method != NULL) {
+ method->ui_write_string = writer;
+ return 0;
+ }
+ return -1;
+}
+
+int UI_method_set_flusher(UI_METHOD *method, int (*flusher) (UI *ui))
+{
+ if (method != NULL) {
+ method->ui_flush = flusher;
+ return 0;
+ }
+ return -1;
+}
+
+int UI_method_set_reader(UI_METHOD *method,
+ int (*reader) (UI *ui, UI_STRING *uis))
+{
+ if (method != NULL) {
+ method->ui_read_string = reader;
+ return 0;
+ }
+ return -1;
+}
+
+int UI_method_set_closer(UI_METHOD *method, int (*closer) (UI *ui))
+{
+ if (method != NULL) {
+ method->ui_close_session = closer;
+ return 0;
+ }
+ return -1;
+}
+
+int UI_method_set_data_duplicator(UI_METHOD *method,
+ void *(*duplicator) (UI *ui, void *ui_data),
+ void (*destructor)(UI *ui, void *ui_data))
+{
+ if (method != NULL) {
+ method->ui_duplicate_data = duplicator;
+ method->ui_destroy_data = destructor;
+ return 0;
+ }
+ return -1;
+}
+
+int UI_method_set_prompt_constructor(UI_METHOD *method,
+ char *(*prompt_constructor) (UI *ui,
+ const char
+ *object_desc,
+ const char
+ *object_name))
+{
+ if (method != NULL) {
+ method->ui_construct_prompt = prompt_constructor;
+ return 0;
+ }
+ return -1;
+}
+
+int UI_method_set_ex_data(UI_METHOD *method, int idx, void *data)
+{
+ return CRYPTO_set_ex_data(&method->ex_data, idx, data);
+}
+
+int (*UI_method_get_opener(const UI_METHOD *method)) (UI *)
+{
+ if (method != NULL)
+ return method->ui_open_session;
+ return NULL;
+}
+
+int (*UI_method_get_writer(const UI_METHOD *method)) (UI *, UI_STRING *)
+{
+ if (method != NULL)
+ return method->ui_write_string;
+ return NULL;
+}
+
+int (*UI_method_get_flusher(const UI_METHOD *method)) (UI *)
+{
+ if (method != NULL)
+ return method->ui_flush;
+ return NULL;
+}
+
+int (*UI_method_get_reader(const UI_METHOD *method)) (UI *, UI_STRING *)
+{
+ if (method != NULL)
+ return method->ui_read_string;
+ return NULL;
+}
+
+int (*UI_method_get_closer(const UI_METHOD *method)) (UI *)
+{
+ if (method != NULL)
+ return method->ui_close_session;
+ return NULL;
+}
+
+char *(*UI_method_get_prompt_constructor(const UI_METHOD *method))
+ (UI *, const char *, const char *)
+{
+ if (method != NULL)
+ return method->ui_construct_prompt;
+ return NULL;
+}
+
+void *(*UI_method_get_data_duplicator(const UI_METHOD *method)) (UI *, void *)
+{
+ if (method != NULL)
+ return method->ui_duplicate_data;
+ return NULL;
+}
+
+void (*UI_method_get_data_destructor(const UI_METHOD *method)) (UI *, void *)
+{
+ if (method != NULL)
+ return method->ui_destroy_data;
+ return NULL;
+}
+
+const void *UI_method_get_ex_data(const UI_METHOD *method, int idx)
+{
+ return CRYPTO_get_ex_data(&method->ex_data, idx);
+}
+
+enum UI_string_types UI_get_string_type(UI_STRING *uis)
+{
+ return uis->type;
+}
+
+int UI_get_input_flags(UI_STRING *uis)
+{
+ return uis->input_flags;
+}
+
+const char *UI_get0_output_string(UI_STRING *uis)
+{
+ return uis->out_string;
+}
+
+const char *UI_get0_action_string(UI_STRING *uis)
+{
+ switch (uis->type) {
+ case UIT_BOOLEAN:
+ return uis->_.boolean_data.action_desc;
+ case UIT_PROMPT:
+ case UIT_NONE:
+ case UIT_VERIFY:
+ case UIT_INFO:
+ case UIT_ERROR:
+ break;
+ }
+ return NULL;
+}
+
+const char *UI_get0_result_string(UI_STRING *uis)
+{
+ switch (uis->type) {
+ case UIT_PROMPT:
+ case UIT_VERIFY:
+ return uis->result_buf;
+ case UIT_NONE:
+ case UIT_BOOLEAN:
+ case UIT_INFO:
+ case UIT_ERROR:
+ break;
+ }
+ return NULL;
+}
+
+int UI_get_result_string_length(UI_STRING *uis)
+{
+ switch (uis->type) {
+ case UIT_PROMPT:
+ case UIT_VERIFY:
+ return uis->result_len;
+ case UIT_NONE:
+ case UIT_BOOLEAN:
+ case UIT_INFO:
+ case UIT_ERROR:
+ break;
+ }
+ return -1;
+}
+
+const char *UI_get0_test_string(UI_STRING *uis)
+{
+ switch (uis->type) {
+ case UIT_VERIFY:
+ return uis->_.string_data.test_buf;
+ case UIT_NONE:
+ case UIT_BOOLEAN:
+ case UIT_INFO:
+ case UIT_ERROR:
+ case UIT_PROMPT:
+ break;
+ }
+ return NULL;
+}
+
+int UI_get_result_minsize(UI_STRING *uis)
+{
+ switch (uis->type) {
+ case UIT_PROMPT:
+ case UIT_VERIFY:
+ return uis->_.string_data.result_minsize;
+ case UIT_NONE:
+ case UIT_INFO:
+ case UIT_ERROR:
+ case UIT_BOOLEAN:
+ break;
+ }
+ return -1;
+}
+
+int UI_get_result_maxsize(UI_STRING *uis)
+{
+ switch (uis->type) {
+ case UIT_PROMPT:
+ case UIT_VERIFY:
+ return uis->_.string_data.result_maxsize;
+ case UIT_NONE:
+ case UIT_INFO:
+ case UIT_ERROR:
+ case UIT_BOOLEAN:
+ break;
+ }
+ return -1;
+}
+
+int UI_set_result(UI *ui, UI_STRING *uis, const char *result)
+{
+#if 0
+ /*
+ * This is placed here solely to preserve UI_F_UI_SET_RESULT
+ * To be removed for OpenSSL 1.2.0
+ */
+ UIerr(UI_F_UI_SET_RESULT, ERR_R_DISABLED);
+#endif
+ return UI_set_result_ex(ui, uis, result, strlen(result));
+}
+
+int UI_set_result_ex(UI *ui, UI_STRING *uis, const char *result, int len)
+{
+ ui->flags &= ~UI_FLAG_REDOABLE;
+
+ switch (uis->type) {
+ case UIT_PROMPT:
+ case UIT_VERIFY:
+ {
+ char number1[DECIMAL_SIZE(uis->_.string_data.result_minsize) + 1];
+ char number2[DECIMAL_SIZE(uis->_.string_data.result_maxsize) + 1];
+
+ BIO_snprintf(number1, sizeof(number1), "%d",
+ uis->_.string_data.result_minsize);
+ BIO_snprintf(number2, sizeof(number2), "%d",
+ uis->_.string_data.result_maxsize);
+
+ if (len < uis->_.string_data.result_minsize) {
+ ui->flags |= UI_FLAG_REDOABLE;
+ UIerr(UI_F_UI_SET_RESULT_EX, UI_R_RESULT_TOO_SMALL);
+ ERR_add_error_data(5, "You must type in ",
+ number1, " to ", number2, " characters");
+ return -1;
+ }
+ if (len > uis->_.string_data.result_maxsize) {
+ ui->flags |= UI_FLAG_REDOABLE;
+ UIerr(UI_F_UI_SET_RESULT_EX, UI_R_RESULT_TOO_LARGE);
+ ERR_add_error_data(5, "You must type in ",
+ number1, " to ", number2, " characters");
+ return -1;
+ }
+ }
+
+ if (uis->result_buf == NULL) {
+ UIerr(UI_F_UI_SET_RESULT_EX, UI_R_NO_RESULT_BUFFER);
+ return -1;
+ }
+
+ memcpy(uis->result_buf, result, len);
+ if (len <= uis->_.string_data.result_maxsize)
+ uis->result_buf[len] = '\0';
+ uis->result_len = len;
+ break;
+ case UIT_BOOLEAN:
+ {
+ const char *p;
+
+ if (uis->result_buf == NULL) {
+ UIerr(UI_F_UI_SET_RESULT_EX, UI_R_NO_RESULT_BUFFER);
+ return -1;
+ }
+
+ uis->result_buf[0] = '\0';
+ for (p = result; *p; p++) {
+ if (strchr(uis->_.boolean_data.ok_chars, *p)) {
+ uis->result_buf[0] = uis->_.boolean_data.ok_chars[0];
+ break;
+ }
+ if (strchr(uis->_.boolean_data.cancel_chars, *p)) {
+ uis->result_buf[0] = uis->_.boolean_data.cancel_chars[0];
+ break;
+ }
+ }
+ }
+ case UIT_NONE:
+ case UIT_INFO:
+ case UIT_ERROR:
+ break;
+ }
+ return 0;
+}
diff --git a/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_local.h b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_local.h
new file mode 100644
index 0000000..8a7dbda
--- /dev/null
+++ b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_local.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2001-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
+ */
+
+#ifndef OSSL_CRYPTO_UI_LOCAL_H
+# define OSSL_CRYPTO_UI_LOCAL_H
+
+# include <openssl/ui.h>
+# include <openssl/crypto.h>
+
+# ifdef _
+# undef _
+# endif
+
+struct ui_method_st {
+ char *name;
+ /*
+ * All the functions return 1 or non-NULL for success and 0 or NULL for
+ * failure
+ */
+ /*
+ * Open whatever channel for this, be it the console, an X window or
+ * whatever. This function should use the ex_data structure to save
+ * intermediate data.
+ */
+ int (*ui_open_session) (UI *ui);
+ int (*ui_write_string) (UI *ui, UI_STRING *uis);
+ /*
+ * Flush the output. If a GUI dialog box is used, this function can be
+ * used to actually display it.
+ */
+ int (*ui_flush) (UI *ui);
+ int (*ui_read_string) (UI *ui, UI_STRING *uis);
+ int (*ui_close_session) (UI *ui);
+ /*
+ * Duplicate the ui_data that often comes alongside a ui_method. This
+ * allows some backends to save away UI information for later use.
+ */
+ void *(*ui_duplicate_data) (UI *ui, void *ui_data);
+ void (*ui_destroy_data) (UI *ui, void *ui_data);
+ /*
+ * Construct a prompt in a user-defined manner. object_desc is a textual
+ * short description of the object, for example "pass phrase", and
+ * object_name is the name of the object (might be a card name or a file
+ * name. The returned string shall always be allocated on the heap with
+ * OPENSSL_malloc(), and need to be free'd with OPENSSL_free().
+ */
+ char *(*ui_construct_prompt) (UI *ui, const char *object_desc,
+ const char *object_name);
+ /*
+ * UI_METHOD specific application data.
+ */
+ CRYPTO_EX_DATA ex_data;
+};
+
+struct ui_string_st {
+ enum UI_string_types type; /* Input */
+ const char *out_string; /* Input */
+ int input_flags; /* Flags from the user */
+ /*
+ * The following parameters are completely irrelevant for UIT_INFO, and
+ * can therefore be set to 0 or NULL
+ */
+ char *result_buf; /* Input and Output: If not NULL,
+ * user-defined with size in result_maxsize.
+ * Otherwise, it may be allocated by the UI
+ * routine, meaning result_minsize is going
+ * to be overwritten. */
+ size_t result_len;
+ union {
+ struct {
+ int result_minsize; /* Input: minimum required size of the
+ * result. */
+ int result_maxsize; /* Input: maximum permitted size of the
+ * result */
+ const char *test_buf; /* Input: test string to verify against */
+ } string_data;
+ struct {
+ const char *action_desc; /* Input */
+ const char *ok_chars; /* Input */
+ const char *cancel_chars; /* Input */
+ } boolean_data;
+ } _;
+
+# define OUT_STRING_FREEABLE 0x01
+ int flags; /* flags for internal use */
+};
+
+struct ui_st {
+ const UI_METHOD *meth;
+ STACK_OF(UI_STRING) *strings; /* We might want to prompt for more than
+ * one thing at a time, and with different
+ * echoing status. */
+ void *user_data;
+ CRYPTO_EX_DATA ex_data;
+# define UI_FLAG_REDOABLE 0x0001
+# define UI_FLAG_DUPL_DATA 0x0002 /* user_data was duplicated */
+# define UI_FLAG_PRINT_ERRORS 0x0100
+ int flags;
+
+ CRYPTO_RWLOCK *lock;
+};
+
+#endif
diff --git a/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_null.c b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_null.c
new file mode 100644
index 0000000..9ab00e0
--- /dev/null
+++ b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_null.c
@@ -0,0 +1,26 @@
+/*
+ * Copyright 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 "ui_local.h"
+
+static const UI_METHOD ui_null = {
+ "OpenSSL NULL UI",
+ NULL, /* opener */
+ NULL, /* writer */
+ NULL, /* flusher */
+ NULL, /* reader */
+ NULL, /* closer */
+ NULL
+};
+
+/* The method with all the built-in thingies */
+const UI_METHOD *UI_null(void)
+{
+ return &ui_null;
+}
diff --git a/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_openssl.c b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_openssl.c
new file mode 100644
index 0000000..0f630a5
--- /dev/null
+++ b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_openssl.c
@@ -0,0 +1,756 @@
+/*
+ * Copyright 2001-2022 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 <openssl/e_os2.h>
+#include <openssl/err.h>
+#include <openssl/ui.h>
+
+#ifndef OPENSSL_NO_UI_CONSOLE
+/*
+ * need for #define _POSIX_C_SOURCE arises whenever you pass -ansi to gcc
+ * [maybe others?], because it masks interfaces not discussed in standard,
+ * sigaction and fileno included. -pedantic would be more appropriate for the
+ * intended purposes, but we can't prevent users from adding -ansi.
+ */
+# if defined(OPENSSL_SYS_VXWORKS)
+# include <sys/types.h>
+# endif
+
+# if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS)
+# ifndef _POSIX_C_SOURCE
+# define _POSIX_C_SOURCE 2
+# endif
+# endif
+# include <signal.h>
+# include <stdio.h>
+# include <string.h>
+# include <errno.h>
+
+# if !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_VMS)
+# ifdef OPENSSL_UNISTD
+# include OPENSSL_UNISTD
+# else
+# include <unistd.h>
+# endif
+/*
+ * If unistd.h defines _POSIX_VERSION, we conclude that we are on a POSIX
+ * system and have sigaction and termios.
+ */
+# if defined(_POSIX_VERSION) && _POSIX_VERSION>=199309L
+
+# define SIGACTION
+# if !defined(TERMIOS) && !defined(TERMIO) && !defined(SGTTY)
+# define TERMIOS
+# endif
+
+# endif
+# endif
+
+# include "ui_local.h"
+# include "internal/cryptlib.h"
+
+# ifdef OPENSSL_SYS_VMS /* prototypes for sys$whatever */
+# include <starlet.h>
+# ifdef __DECC
+# pragma message disable DOLLARID
+# endif
+# endif
+
+# ifdef WIN_CONSOLE_BUG
+# include <windows.h>
+# ifndef OPENSSL_SYS_WINCE
+# include <wincon.h>
+# endif
+# endif
+
+/*
+ * There are 6 types of terminal interface supported, TERMIO, TERMIOS, VMS,
+ * MSDOS, WIN32 Console and SGTTY.
+ *
+ * If someone defines one of the macros TERMIO, TERMIOS or SGTTY, it will
+ * remain respected. Otherwise, we default to TERMIOS except for a few
+ * systems that require something different.
+ *
+ * Note: we do not use SGTTY unless it's defined by the configuration. We
+ * may eventually opt to remove its use entirely.
+ */
+
+# if !defined(TERMIOS) && !defined(TERMIO) && !defined(SGTTY)
+
+# if defined(_LIBC)
+# undef TERMIOS
+# define TERMIO
+# undef SGTTY
+/*
+ * We know that VMS, MSDOS, VXWORKS, use entirely other mechanisms.
+ */
+# elif !defined(OPENSSL_SYS_VMS) \
+ && !defined(OPENSSL_SYS_MSDOS) \
+ && !defined(OPENSSL_SYS_VXWORKS)
+# define TERMIOS
+# undef TERMIO
+# undef SGTTY
+# endif
+
+# endif
+
+# if defined(OPENSSL_SYS_VXWORKS)
+# undef TERMIOS
+# undef TERMIO
+# undef SGTTY
+# endif
+
+# ifdef TERMIOS
+# include <termios.h>
+# define TTY_STRUCT struct termios
+# define TTY_FLAGS c_lflag
+# define TTY_get(tty,data) tcgetattr(tty,data)
+# define TTY_set(tty,data) tcsetattr(tty,TCSANOW,data)
+# endif
+
+# ifdef TERMIO
+# include <termio.h>
+# define TTY_STRUCT struct termio
+# define TTY_FLAGS c_lflag
+# define TTY_get(tty,data) ioctl(tty,TCGETA,data)
+# define TTY_set(tty,data) ioctl(tty,TCSETA,data)
+# endif
+
+# ifdef SGTTY
+# include <sgtty.h>
+# define TTY_STRUCT struct sgttyb
+# define TTY_FLAGS sg_flags
+# define TTY_get(tty,data) ioctl(tty,TIOCGETP,data)
+# define TTY_set(tty,data) ioctl(tty,TIOCSETP,data)
+# endif
+
+# if !defined(_LIBC) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_VMS)
+# include <sys/ioctl.h>
+# endif
+
+# ifdef OPENSSL_SYS_MSDOS
+# include <conio.h>
+# endif
+
+# ifdef OPENSSL_SYS_VMS
+# include <ssdef.h>
+# include <iodef.h>
+# include <ttdef.h>
+# include <descrip.h>
+struct IOSB {
+ short iosb$w_value;
+ short iosb$w_count;
+ long iosb$l_info;
+};
+# endif
+
+# ifndef NX509_SIG
+# define NX509_SIG 32
+# endif
+
+/* Define globals. They are protected by a lock */
+# ifdef SIGACTION
+static struct sigaction savsig[NX509_SIG];
+# else
+static void (*savsig[NX509_SIG]) (int);
+# endif
+
+# ifdef OPENSSL_SYS_VMS
+static struct IOSB iosb;
+static $DESCRIPTOR(terminal, "TT");
+static long tty_orig[3], tty_new[3]; /* XXX Is there any guarantee that this
+ * will always suffice for the actual
+ * structures? */
+static long status;
+static unsigned short channel = 0;
+# elif defined(_WIN32) && !defined(_WIN32_WCE)
+static DWORD tty_orig, tty_new;
+# else
+# if !defined(OPENSSL_SYS_MSDOS) || defined(__DJGPP__)
+static TTY_STRUCT tty_orig, tty_new;
+# endif
+# endif
+static FILE *tty_in, *tty_out;
+static int is_a_tty;
+
+/* Declare static functions */
+# if !defined(OPENSSL_SYS_WINCE)
+static int read_till_nl(FILE *);
+static void recsig(int);
+static void pushsig(void);
+static void popsig(void);
+# endif
+# if defined(OPENSSL_SYS_MSDOS) && !defined(_WIN32)
+static int noecho_fgets(char *buf, int size, FILE *tty);
+# endif
+static int read_string_inner(UI *ui, UI_STRING *uis, int echo, int strip_nl);
+
+static int read_string(UI *ui, UI_STRING *uis);
+static int write_string(UI *ui, UI_STRING *uis);
+
+static int open_console(UI *ui);
+static int echo_console(UI *ui);
+static int noecho_console(UI *ui);
+static int close_console(UI *ui);
+
+/*
+ * The following function makes sure that info and error strings are printed
+ * before any prompt.
+ */
+static int write_string(UI *ui, UI_STRING *uis)
+{
+ switch (UI_get_string_type(uis)) {
+ case UIT_ERROR:
+ case UIT_INFO:
+ fputs(UI_get0_output_string(uis), tty_out);
+ fflush(tty_out);
+ break;
+ case UIT_NONE:
+ case UIT_PROMPT:
+ case UIT_VERIFY:
+ case UIT_BOOLEAN:
+ break;
+ }
+ return 1;
+}
+
+static int read_string(UI *ui, UI_STRING *uis)
+{
+ int ok = 0;
+
+ switch (UI_get_string_type(uis)) {
+ case UIT_BOOLEAN:
+ fputs(UI_get0_output_string(uis), tty_out);
+ fputs(UI_get0_action_string(uis), tty_out);
+ fflush(tty_out);
+ return read_string_inner(ui, uis,
+ UI_get_input_flags(uis) & UI_INPUT_FLAG_ECHO,
+ 0);
+ case UIT_PROMPT:
+ fputs(UI_get0_output_string(uis), tty_out);
+ fflush(tty_out);
+ return read_string_inner(ui, uis,
+ UI_get_input_flags(uis) & UI_INPUT_FLAG_ECHO,
+ 1);
+ case UIT_VERIFY:
+ fprintf(tty_out, "Verifying - %s", UI_get0_output_string(uis));
+ fflush(tty_out);
+ if ((ok = read_string_inner(ui, uis,
+ UI_get_input_flags(uis) &
+ UI_INPUT_FLAG_ECHO, 1)) <= 0)
+ return ok;
+ if (strcmp(UI_get0_result_string(uis), UI_get0_test_string(uis)) != 0) {
+ fprintf(tty_out, "Verify failure\n");
+ fflush(tty_out);
+ return 0;
+ }
+ break;
+ case UIT_NONE:
+ case UIT_INFO:
+ case UIT_ERROR:
+ break;
+ }
+ return 1;
+}
+
+# if !defined(OPENSSL_SYS_WINCE)
+/* Internal functions to read a string without echoing */
+static int read_till_nl(FILE *in)
+{
+# define SIZE 4
+ char buf[SIZE + 1];
+
+ do {
+ if (!fgets(buf, SIZE, in))
+ return 0;
+ } while (strchr(buf, '\n') == NULL);
+ return 1;
+}
+
+static volatile sig_atomic_t intr_signal;
+# endif
+
+static int read_string_inner(UI *ui, UI_STRING *uis, int echo, int strip_nl)
+{
+ static int ps;
+ int ok;
+ char result[BUFSIZ];
+ int maxsize = BUFSIZ - 1;
+# if !defined(OPENSSL_SYS_WINCE)
+ char *p = NULL;
+ int echo_eol = !echo;
+
+ intr_signal = 0;
+ ok = 0;
+ ps = 0;
+
+ pushsig();
+ ps = 1;
+
+ if (!echo && !noecho_console(ui))
+ goto error;
+ ps = 2;
+
+ result[0] = '\0';
+# if defined(_WIN32)
+ if (is_a_tty) {
+ DWORD numread;
+# if defined(CP_UTF8)
+ if (GetEnvironmentVariableW(L"OPENSSL_WIN32_UTF8", NULL, 0) != 0) {
+ WCHAR wresult[BUFSIZ];
+
+ if (ReadConsoleW(GetStdHandle(STD_INPUT_HANDLE),
+ wresult, maxsize, &numread, NULL)) {
+ if (numread >= 2 &&
+ wresult[numread-2] == L'\r' &&
+ wresult[numread-1] == L'\n') {
+ wresult[numread-2] = L'\n';
+ numread--;
+ }
+ wresult[numread] = '\0';
+ if (WideCharToMultiByte(CP_UTF8, 0, wresult, -1,
+ result, sizeof(result), NULL, 0) > 0)
+ p = result;
+
+ OPENSSL_cleanse(wresult, sizeof(wresult));
+ }
+ } else
+# endif
+ if (ReadConsoleA(GetStdHandle(STD_INPUT_HANDLE),
+ result, maxsize, &numread, NULL)) {
+ if (numread >= 2 &&
+ result[numread-2] == '\r' && result[numread-1] == '\n') {
+ result[numread-2] = '\n';
+ numread--;
+ }
+ result[numread] = '\0';
+ p = result;
+ }
+ } else
+# elif defined(OPENSSL_SYS_MSDOS)
+ if (!echo) {
+ noecho_fgets(result, maxsize, tty_in);
+ p = result; /* FIXME: noecho_fgets doesn't return errors */
+ } else
+# endif
+ p = fgets(result, maxsize, tty_in);
+ if (p == NULL)
+ goto error;
+ if (feof(tty_in))
+ goto error;
+ if (ferror(tty_in))
+ goto error;
+ if ((p = (char *)strchr(result, '\n')) != NULL) {
+ if (strip_nl)
+ *p = '\0';
+ } else if (!read_till_nl(tty_in))
+ goto error;
+ if (UI_set_result(ui, uis, result) >= 0)
+ ok = 1;
+
+ error:
+ if (intr_signal == SIGINT)
+ ok = -1;
+ if (echo_eol)
+ fprintf(tty_out, "\n");
+ if (ps >= 2 && !echo && !echo_console(ui))
+ ok = 0;
+
+ if (ps >= 1)
+ popsig();
+# else
+ ok = 1;
+# endif
+
+ OPENSSL_cleanse(result, BUFSIZ);
+ return ok;
+}
+
+/* Internal functions to open, handle and close a channel to the console. */
+static int open_console(UI *ui)
+{
+ CRYPTO_THREAD_write_lock(ui->lock);
+ is_a_tty = 1;
+
+# if defined(OPENSSL_SYS_VXWORKS)
+ tty_in = stdin;
+ tty_out = stderr;
+# elif defined(_WIN32) && !defined(_WIN32_WCE)
+ if ((tty_out = fopen("conout$", "w")) == NULL)
+ tty_out = stderr;
+
+ if (GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &tty_orig)) {
+ tty_in = stdin;
+ } else {
+ is_a_tty = 0;
+ if ((tty_in = fopen("conin$", "r")) == NULL)
+ tty_in = stdin;
+ }
+# else
+# ifdef OPENSSL_SYS_MSDOS
+# define DEV_TTY "con"
+# else
+# define DEV_TTY "/dev/tty"
+# endif
+ if ((tty_in = fopen(DEV_TTY, "r")) == NULL)
+ tty_in = stdin;
+ if ((tty_out = fopen(DEV_TTY, "w")) == NULL)
+ tty_out = stderr;
+# endif
+
+# if defined(TTY_get) && !defined(OPENSSL_SYS_VMS)
+ if (TTY_get(fileno(tty_in), &tty_orig) == -1) {
+# ifdef ENOTTY
+ if (errno == ENOTTY)
+ is_a_tty = 0;
+ else
+# endif
+# ifdef EINVAL
+ /*
+ * Ariel Glenn reports that solaris can return EINVAL instead.
+ * This should be ok
+ */
+ if (errno == EINVAL)
+ is_a_tty = 0;
+ else
+# endif
+# ifdef ENXIO
+ /*
+ * Solaris can return ENXIO.
+ * This should be ok
+ */
+ if (errno == ENXIO)
+ is_a_tty = 0;
+ else
+# endif
+# ifdef EIO
+ /*
+ * Linux can return EIO.
+ * This should be ok
+ */
+ if (errno == EIO)
+ is_a_tty = 0;
+ else
+# endif
+# ifdef EPERM
+ /*
+ * Linux can return EPERM (Operation not permitted),
+ * e.g. if a daemon executes openssl via fork()+execve()
+ * This should be ok
+ */
+ if (errno == EPERM)
+ is_a_tty = 0;
+ else
+# endif
+# ifdef ENODEV
+ /*
+ * MacOS X returns ENODEV (Operation not supported by device),
+ * which seems appropriate.
+ */
+ if (errno == ENODEV)
+ is_a_tty = 0;
+ else
+# endif
+ {
+ char tmp_num[10];
+ BIO_snprintf(tmp_num, sizeof(tmp_num) - 1, "%d", errno);
+ UIerr(UI_F_OPEN_CONSOLE, UI_R_UNKNOWN_TTYGET_ERRNO_VALUE);
+ ERR_add_error_data(2, "errno=", tmp_num);
+
+ return 0;
+ }
+ }
+# endif
+# ifdef OPENSSL_SYS_VMS
+ status = sys$assign(&terminal, &channel, 0, 0);
+
+ /* if there isn't a TT device, something is very wrong */
+ if (status != SS$_NORMAL) {
+ char tmp_num[12];
+
+ BIO_snprintf(tmp_num, sizeof(tmp_num) - 1, "%%X%08X", status);
+ UIerr(UI_F_OPEN_CONSOLE, UI_R_SYSASSIGN_ERROR);
+ ERR_add_error_data(2, "status=", tmp_num);
+ return 0;
+ }
+
+ status = sys$qiow(0, channel, IO$_SENSEMODE, &iosb, 0, 0, tty_orig, 12,
+ 0, 0, 0, 0);
+
+ /* If IO$_SENSEMODE doesn't work, this is not a terminal device */
+ if ((status != SS$_NORMAL) || (iosb.iosb$w_value != SS$_NORMAL))
+ is_a_tty = 0;
+# endif
+ return 1;
+}
+
+static int noecho_console(UI *ui)
+{
+# ifdef TTY_FLAGS
+ memcpy(&(tty_new), &(tty_orig), sizeof(tty_orig));
+ tty_new.TTY_FLAGS &= ~ECHO;
+# endif
+
+# if defined(TTY_set) && !defined(OPENSSL_SYS_VMS)
+ if (is_a_tty && (TTY_set(fileno(tty_in), &tty_new) == -1))
+ return 0;
+# endif
+# ifdef OPENSSL_SYS_VMS
+ if (is_a_tty) {
+ tty_new[0] = tty_orig[0];
+ tty_new[1] = tty_orig[1] | TT$M_NOECHO;
+ tty_new[2] = tty_orig[2];
+ status = sys$qiow(0, channel, IO$_SETMODE, &iosb, 0, 0, tty_new, 12,
+ 0, 0, 0, 0);
+ if ((status != SS$_NORMAL) || (iosb.iosb$w_value != SS$_NORMAL)) {
+ char tmp_num[2][12];
+
+ BIO_snprintf(tmp_num[0], sizeof(tmp_num[0]) - 1, "%%X%08X",
+ status);
+ BIO_snprintf(tmp_num[1], sizeof(tmp_num[1]) - 1, "%%X%08X",
+ iosb.iosb$w_value);
+ UIerr(UI_F_NOECHO_CONSOLE, UI_R_SYSQIOW_ERROR);
+ ERR_add_error_data(5, "status=", tmp_num[0],
+ ",", "iosb.iosb$w_value=", tmp_num[1]);
+ return 0;
+ }
+ }
+# endif
+# if defined(_WIN32) && !defined(_WIN32_WCE)
+ if (is_a_tty) {
+ tty_new = tty_orig;
+ tty_new &= ~ENABLE_ECHO_INPUT;
+ SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), tty_new);
+ }
+# endif
+ return 1;
+}
+
+static int echo_console(UI *ui)
+{
+# if defined(TTY_set) && !defined(OPENSSL_SYS_VMS)
+ memcpy(&(tty_new), &(tty_orig), sizeof(tty_orig));
+ if (is_a_tty && (TTY_set(fileno(tty_in), &tty_new) == -1))
+ return 0;
+# endif
+# ifdef OPENSSL_SYS_VMS
+ if (is_a_tty) {
+ tty_new[0] = tty_orig[0];
+ tty_new[1] = tty_orig[1];
+ tty_new[2] = tty_orig[2];
+ status = sys$qiow(0, channel, IO$_SETMODE, &iosb, 0, 0, tty_new, 12,
+ 0, 0, 0, 0);
+ if ((status != SS$_NORMAL) || (iosb.iosb$w_value != SS$_NORMAL)) {
+ char tmp_num[2][12];
+
+ BIO_snprintf(tmp_num[0], sizeof(tmp_num[0]) - 1, "%%X%08X",
+ status);
+ BIO_snprintf(tmp_num[1], sizeof(tmp_num[1]) - 1, "%%X%08X",
+ iosb.iosb$w_value);
+ UIerr(UI_F_ECHO_CONSOLE, UI_R_SYSQIOW_ERROR);
+ ERR_add_error_data(5, "status=", tmp_num[0],
+ ",", "iosb.iosb$w_value=", tmp_num[1]);
+ return 0;
+ }
+ }
+# endif
+# if defined(_WIN32) && !defined(_WIN32_WCE)
+ if (is_a_tty) {
+ tty_new = tty_orig;
+ SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), tty_new);
+ }
+# endif
+ return 1;
+}
+
+static int close_console(UI *ui)
+{
+ int ret = 1;
+
+ if (tty_in != stdin)
+ fclose(tty_in);
+ if (tty_out != stderr)
+ fclose(tty_out);
+# ifdef OPENSSL_SYS_VMS
+ status = sys$dassgn(channel);
+ if (status != SS$_NORMAL) {
+ char tmp_num[12];
+
+ BIO_snprintf(tmp_num, sizeof(tmp_num) - 1, "%%X%08X", status);
+ UIerr(UI_F_CLOSE_CONSOLE, UI_R_SYSDASSGN_ERROR);
+ ERR_add_error_data(2, "status=", tmp_num);
+ ret = 0;
+ }
+# endif
+ CRYPTO_THREAD_unlock(ui->lock);
+
+ return ret;
+}
+
+# if !defined(OPENSSL_SYS_WINCE)
+/* Internal functions to handle signals and act on them */
+static void pushsig(void)
+{
+# ifndef OPENSSL_SYS_WIN32
+ int i;
+# endif
+# ifdef SIGACTION
+ struct sigaction sa;
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = recsig;
+# endif
+
+# ifdef OPENSSL_SYS_WIN32
+ savsig[SIGABRT] = signal(SIGABRT, recsig);
+ savsig[SIGFPE] = signal(SIGFPE, recsig);
+ savsig[SIGILL] = signal(SIGILL, recsig);
+ savsig[SIGINT] = signal(SIGINT, recsig);
+ savsig[SIGSEGV] = signal(SIGSEGV, recsig);
+ savsig[SIGTERM] = signal(SIGTERM, recsig);
+# else
+ for (i = 1; i < NX509_SIG; i++) {
+# ifdef SIGUSR1
+ if (i == SIGUSR1)
+ continue;
+# endif
+# ifdef SIGUSR2
+ if (i == SIGUSR2)
+ continue;
+# endif
+# ifdef SIGKILL
+ if (i == SIGKILL) /* We can't make any action on that. */
+ continue;
+# endif
+# ifdef SIGACTION
+ sigaction(i, &sa, &savsig[i]);
+# else
+ savsig[i] = signal(i, recsig);
+# endif
+ }
+# endif
+
+# ifdef SIGWINCH
+ signal(SIGWINCH, SIG_DFL);
+# endif
+}
+
+static void popsig(void)
+{
+# ifdef OPENSSL_SYS_WIN32
+ signal(SIGABRT, savsig[SIGABRT]);
+ signal(SIGFPE, savsig[SIGFPE]);
+ signal(SIGILL, savsig[SIGILL]);
+ signal(SIGINT, savsig[SIGINT]);
+ signal(SIGSEGV, savsig[SIGSEGV]);
+ signal(SIGTERM, savsig[SIGTERM]);
+# else
+ int i;
+ for (i = 1; i < NX509_SIG; i++) {
+# ifdef SIGUSR1
+ if (i == SIGUSR1)
+ continue;
+# endif
+# ifdef SIGUSR2
+ if (i == SIGUSR2)
+ continue;
+# endif
+# ifdef SIGACTION
+ sigaction(i, &savsig[i], NULL);
+# else
+ signal(i, savsig[i]);
+# endif
+ }
+# endif
+}
+
+static void recsig(int i)
+{
+ intr_signal = i;
+}
+# endif
+
+/* Internal functions specific for Windows */
+# if defined(OPENSSL_SYS_MSDOS) && !defined(_WIN32)
+static int noecho_fgets(char *buf, int size, FILE *tty)
+{
+ int i;
+ char *p;
+
+ p = buf;
+ for (;;) {
+ if (size == 0) {
+ *p = '\0';
+ break;
+ }
+ size--;
+# if defined(_WIN32)
+ i = _getch();
+# else
+ i = getch();
+# endif
+ if (i == '\r')
+ i = '\n';
+ *(p++) = i;
+ if (i == '\n') {
+ *p = '\0';
+ break;
+ }
+ }
+# ifdef WIN_CONSOLE_BUG
+ /*
+ * Win95 has several evil console bugs: one of these is that the last
+ * character read using getch() is passed to the next read: this is
+ * usually a CR so this can be trouble. No STDIO fix seems to work but
+ * flushing the console appears to do the trick.
+ */
+ {
+ HANDLE inh;
+ inh = GetStdHandle(STD_INPUT_HANDLE);
+ FlushConsoleInputBuffer(inh);
+ }
+# endif
+ return strlen(buf);
+}
+# endif
+
+static UI_METHOD ui_openssl = {
+ "OpenSSL default user interface",
+ open_console,
+ write_string,
+ NULL, /* No flusher is needed for command lines */
+ read_string,
+ close_console,
+ NULL
+};
+
+/* The method with all the built-in console thingies */
+UI_METHOD *UI_OpenSSL(void)
+{
+ return &ui_openssl;
+}
+
+static const UI_METHOD *default_UI_meth = &ui_openssl;
+
+#else
+
+static const UI_METHOD *default_UI_meth = NULL;
+
+#endif
+
+void UI_set_default_method(const UI_METHOD *meth)
+{
+ default_UI_meth = meth;
+}
+
+const UI_METHOD *UI_get_default_method(void)
+{
+ return default_UI_meth;
+}
diff --git a/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_util.c b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_util.c
new file mode 100644
index 0000000..32a3c4e
--- /dev/null
+++ b/ap/lib/libssl/openssl-1.1.1o/crypto/ui/ui_util.c
@@ -0,0 +1,163 @@
+/*
+ * 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 <string.h>
+#include <openssl/pem.h> /* PEM_def_callback() */
+#include "internal/thread_once.h"
+#include "ui_local.h"
+
+#ifndef BUFSIZ
+#define BUFSIZ 256
+#endif
+
+int UI_UTIL_read_pw_string(char *buf, int length, const char *prompt,
+ int verify)
+{
+ char buff[BUFSIZ];
+ int ret;
+
+ ret =
+ UI_UTIL_read_pw(buf, buff, (length > BUFSIZ) ? BUFSIZ : length,
+ prompt, verify);
+ OPENSSL_cleanse(buff, BUFSIZ);
+ return ret;
+}
+
+int UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt,
+ int verify)
+{
+ int ok = 0;
+ UI *ui;
+
+ if (size < 1)
+ return -1;
+
+ ui = UI_new();
+ if (ui != NULL) {
+ ok = UI_add_input_string(ui, prompt, 0, buf, 0, size - 1);
+ if (ok >= 0 && verify)
+ ok = UI_add_verify_string(ui, prompt, 0, buff, 0, size - 1, buf);
+ if (ok >= 0)
+ ok = UI_process(ui);
+ UI_free(ui);
+ }
+ if (ok > 0)
+ ok = 0;
+ return ok;
+}
+
+/*
+ * Wrapper around pem_password_cb, a method to help older APIs use newer
+ * ones.
+ */
+struct pem_password_cb_data {
+ pem_password_cb *cb;
+ int rwflag;
+};
+
+static void ui_new_method_data(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
+ int idx, long argl, void *argp)
+{
+ /*
+ * Do nothing, the data is allocated externally and assigned later with
+ * CRYPTO_set_ex_data()
+ */
+}
+
+static int ui_dup_method_data(CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
+ void *from_d, int idx, long argl, void *argp)
+{
+ void **pptr = (void **)from_d;
+ if (*pptr != NULL)
+ *pptr = OPENSSL_memdup(*pptr, sizeof(struct pem_password_cb_data));
+ return 1;
+}
+
+static void ui_free_method_data(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
+ int idx, long argl, void *argp)
+{
+ OPENSSL_free(ptr);
+}
+
+static CRYPTO_ONCE get_index_once = CRYPTO_ONCE_STATIC_INIT;
+static int ui_method_data_index = -1;
+DEFINE_RUN_ONCE_STATIC(ui_method_data_index_init)
+{
+ ui_method_data_index = CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_UI_METHOD,
+ 0, NULL, ui_new_method_data,
+ ui_dup_method_data,
+ ui_free_method_data);
+ return 1;
+}
+
+static int ui_open(UI *ui)
+{
+ return 1;
+}
+static int ui_read(UI *ui, UI_STRING *uis)
+{
+ switch (UI_get_string_type(uis)) {
+ case UIT_PROMPT:
+ {
+ char result[PEM_BUFSIZE + 1];
+ const struct pem_password_cb_data *data =
+ UI_method_get_ex_data(UI_get_method(ui), ui_method_data_index);
+ int maxsize = UI_get_result_maxsize(uis);
+ int len = data->cb(result,
+ maxsize > PEM_BUFSIZE ? PEM_BUFSIZE : maxsize,
+ data->rwflag, UI_get0_user_data(ui));
+
+ if (len >= 0)
+ result[len] = '\0';
+ if (len <= 0)
+ return len;
+ if (UI_set_result_ex(ui, uis, result, len) >= 0)
+ return 1;
+ return 0;
+ }
+ case UIT_VERIFY:
+ case UIT_NONE:
+ case UIT_BOOLEAN:
+ case UIT_INFO:
+ case UIT_ERROR:
+ break;
+ }
+ return 1;
+}
+static int ui_write(UI *ui, UI_STRING *uis)
+{
+ return 1;
+}
+static int ui_close(UI *ui)
+{
+ return 1;
+}
+
+UI_METHOD *UI_UTIL_wrap_read_pem_callback(pem_password_cb *cb, int rwflag)
+{
+ struct pem_password_cb_data *data = NULL;
+ UI_METHOD *ui_method = NULL;
+
+ if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL
+ || (ui_method = UI_create_method("PEM password callback wrapper")) == NULL
+ || UI_method_set_opener(ui_method, ui_open) < 0
+ || UI_method_set_reader(ui_method, ui_read) < 0
+ || UI_method_set_writer(ui_method, ui_write) < 0
+ || UI_method_set_closer(ui_method, ui_close) < 0
+ || !RUN_ONCE(&get_index_once, ui_method_data_index_init)
+ || UI_method_set_ex_data(ui_method, ui_method_data_index, data) < 0) {
+ UI_destroy_method(ui_method);
+ OPENSSL_free(data);
+ return NULL;
+ }
+ data->rwflag = rwflag;
+ data->cb = cb != NULL ? cb : PEM_def_callback;
+
+ return ui_method;
+}