/* crypto/ui/ui_lib.c -*- mode:C; c-file-style: "eay" -*- *//* Written by Richard Levitte (richard@levitte.org) for the OpenSSL * project 2001. *//* ==================================================================== * Copyright (c) 2001 The OpenSSL Project.  All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer.  * * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in *    the documentation and/or other materials provided with the *    distribution. * * 3. All advertising materials mentioning features or use of this *    software must display the following acknowledgment: *    "This product includes software developed by the OpenSSL Project *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)" * * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to *    endorse or promote products derived from this software without *    prior written permission. For written permission, please contact *    openssl-core@openssl.org. * * 5. Products derived from this software may not be called "OpenSSL" *    nor may "OpenSSL" appear in their names without prior written *    permission of the OpenSSL Project. * * 6. Redistributions of any form whatsoever must retain the following *    acknowledgment: *    "This product includes software developed by the OpenSSL Project *    for use in the OpenSSL Toolkit (http://www.openssl.org/)" * * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. * ==================================================================== * * This product includes cryptographic software written by Eric Young * (eay@cryptsoft.com).  This product includes software written by Tim * Hudson (tjh@cryptsoft.com). * */#include <string.h>#include <openssl/e_os2.h>#include <openssl/buffer.h>#include <openssl/ui.h>#include <openssl/err.h>#include "ui_locl.h"#include "cryptlib.h"IMPLEMENT_STACK_OF(UI_STRING_ST)static const UI_METHOD *default_UI_meth=NULL;UI *UI_new(void)	{	return(UI_new_method(NULL));	}UI *UI_new_method(const UI_METHOD *method)	{	UI *ret;	ret=(UI *)OPENSSL_malloc(sizeof(UI));	if (ret == NULL)		{		UIerr(UI_F_UI_NEW_METHOD,ERR_R_MALLOC_FAILURE);		return NULL;		}	if (method == NULL)		ret->meth=UI_get_default_method();	else		ret->meth=method;	ret->strings=NULL;	ret->user_data=NULL;	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_UI, ret, &ret->ex_data);	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;		default:			break;			}		}	OPENSSL_free(uis);	}void UI_free(UI *ui)	{	if (ui == NULL)		return;	sk_UI_STRING_pop_free(ui->strings,free_string);	CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data);	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 = (UI_STRING *)OPENSSL_malloc(sizeof(UI_STRING))))		{		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)		{		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 addapt that */			if (ret <= 0) ret--;			}		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; p++)			{			if (strchr(cancel_chars, *p))				{				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)			{			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 addapt that */				if (ret <= 0) ret--;				}			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)		{		prompt_copy=BUF_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)		{		prompt_copy=BUF_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)		{		prompt_copy=BUF_strdup(prompt);		if (prompt_copy == NULL)			{			UIerr(UI_F_UI_DUP_INPUT_BOOLEAN,ERR_R_MALLOC_FAILURE);			goto err;			}		}		if (action_desc)		{		action_desc_copy=BUF_strdup(action_desc);		if (action_desc_copy == NULL)			{			UIerr(UI_F_UI_DUP_INPUT_BOOLEAN,ERR_R_MALLOC_FAILURE);			goto err;			}		}		if (ok_chars)		{		ok_chars_copy=BUF_strdup(ok_chars);		if (ok_chars_copy == NULL)			{			UIerr(UI_F_UI_DUP_INPUT_BOOLEAN,ERR_R_MALLOC_FAILURE);			goto err;			}		}		if (cancel_chars)		{		cancel_chars_copy=BUF_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:	if (prompt_copy) OPENSSL_free(prompt_copy);	if (action_desc_copy) OPENSSL_free(action_desc_copy);	if (ok_chars_copy) OPENSSL_free(ok_chars_copy);	if (cancel_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)		{		text_copy=BUF_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)		{		text_copy=BUF_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)		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)			len += sizeof(prompt2) - 1 + strlen(object_name);		len += sizeof(prompt3) - 1;		prompt = (char *)OPENSSL_malloc(len + 1);		BUF_strlcpy(prompt, prompt1, len + 1);		BUF_strlcat(prompt, object_desc, len + 1);		if (object_name)			{			BUF_strlcat(prompt, prompt2, len + 1);			BUF_strlcat(prompt, object_name, len + 1);			}		BUF_strlcat(prompt, prompt3, len + 1);		}	return prompt;	}void *UI_add_user_data(UI *ui, void *user_data)	{	void *old_data = ui->user_data;	ui->user_data = user_data;	return old_data;	}void *UI_get0_user_data(UI *ui)