Implement boolean (yes/no or OK/Cancel, ...) input.

Implement UI controls.  Current controls are the possibility to output
the OpenSSL error stack on the same channel from within UI_process()
and to check if the same user interface can be redone without being
rebuilt (this is often more a question of philosophy than
technicalities).

crypto/ui/ui.h

@@ -91,8 +91,10 @@ UI *UI_new_method(const UI_METHOD *method);
 void UI_free(UI *ui);
 
 /* The following functions are used to add strings to be printed and prompt
-   strings to prompt for data.  The names are UI_{add,dup}_<function>_string,
+   strings to prompt for data.  The names are UI_{add,dup}_<function>_string
-   with the following meanings:
+   and UI_{add,dup}_input_boolean.
+
+   UI_{add,dup}_<function>_string have the following meanings:
 	add	add a text or prompt string.  The pointers given to these
 		functions are used verbatim, no copying is done.
 	dup	make a copy of the text or prompt string, then add the copy
@@ -108,12 +110,26 @@ void UI_free(UI *ui);
    Honestly, there's currently no difference between info and error for the
    moment.
 
-   All of the functions in this group take a UI and a string.  The input and
+   UI_{add,dup}_input_boolean have the same semantics for "add" and "dup",
-   verify addition functions also take a flag argument, a buffer for the result
+   and are typically used when one wants to prompt for a yes/no response.
-   to end up with, a minimum input size and a maximum input size (the result
+
-   buffer MUST be large enough to be able to contain the maximum number of
+
-   characters).  Additionally, the verify addition functions takes another
+   All of the functions in this group take a UI and a prompt string.
-   buffer to compare the result against.
+   The string input and verify addition functions also take a flag argument,
+   a buffer for the result to end up with, a minimum input size and a maximum
+   input size (the result buffer MUST be large enough to be able to contain
+   the maximum number of characters).  Additionally, the verify addition
+   functions takes another buffer to compare the result against.
+   The boolean input functions take an action description string (which should
+   be safe to ignore if the expected user action is obvious, for example with
+   a dialog box with an OK button and a Cancel button), a string of acceptable
+   characters to mean OK and to mean Cancel.  The two last strings are checked
+   to make sure they don't have common characters.  Additionally, the same
+   flag argument as for the string input is taken, as well as a result buffer.
+   The result buffer is required to be at least one byte long.  Depending on
+   the answer, the first character from the OK or the Cancel character strings
+   will be stored in the first byte of the result buffer.  No NUL will be
+   added, so the result is *not* a string.
 
    On success, the all return an index of the added information.  That index
    is usefull when retrieving results with UI_get0_result(). */
@@ -125,6 +141,12 @@ int UI_add_verify_string(UI *ui, const char *prompt, int flags,
 	char *result_buf, int minsize, int maxsize, const char *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);
+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);
+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);
 int UI_add_info_string(UI *ui, const char *text);
 int UI_dup_info_string(UI *ui, const char *text);
 int UI_add_error_string(UI *ui, const char *text);
@@ -192,6 +214,22 @@ const char *UI_get0_result(UI *ui, int i);
 /* When all strings have been added, process the whole thing. */
 int UI_process(UI *ui);
 
+/* Give a user interface parametrised control commands.  This can be used to
+   send down an integer, a data pointer or a function pointer, as well as
+   be used to get information from a UI. */
+int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f)());
+
+/* The commands */
+/* Use UI_CONTROL_PRINT_ERRORS with the value 1 to have UI_process print the
+   OpenSSL error stack before printing any info or added error messages and
+   before any prompting. */
+#define UI_CTRL_PRINT_ERRORS		1
+/* Check if a UI_process() is possible to do again with the same instance of
+   a user interface.  This makes UI_ctrl() return 1 if it is redoable, and 0
+   if not. */
+#define UI_CTRL_IS_REDOABLE		2
+
+
 /* Some methods may use extra data */
 #define UI_set_app_data(s,arg)         UI_set_ex_data(s,0,arg)
 #define UI_get_app_data(s)             UI_get_ex_data(s,0)
@@ -265,6 +303,7 @@ enum UI_string_types
 	UIT_NONE=0,
 	UIT_PROMPT,		/* Prompt for a string */
 	UIT_VERIFY,		/* Prompt for a string and verify */
+	UIT_BOOLEAN,		/* Prompt for a yes/no response */
 	UIT_INFO,		/* Send info to the user */
 	UIT_ERROR		/* Send an error message to the user */
 	};
@@ -292,6 +331,8 @@ enum UI_string_types UI_get_string_type(UI_STRING *uis);
 int UI_get_input_flags(UI_STRING *uis);
 /* Return the actual string to output (the prompt, info or error) */
 const char *UI_get0_output_string(UI_STRING *uis);
+/* Return the optional action string to output (the boolean promtp instruction) */
+const char *UI_get0_action_string(UI_STRING *uis);
 /* Return the result of a prompt */
 const char *UI_get0_result_string(UI_STRING *uis);
 /* Return the string to test the result against.  Only useful with verifies. */
@@ -301,7 +342,7 @@ int UI_get_result_minsize(UI_STRING *uis);
 /* Return the required maximum size of the result */
 int UI_get_result_maxsize(UI_STRING *uis);
 /* Set the result of a UI_STRING. */
-int UI_set_result(UI_STRING *uis, const char *result);
+int UI_set_result(UI *ui, UI_STRING *uis, const char *result);
 
 
 /* BEGIN ERROR CODES */
@@ -313,9 +354,13 @@ void ERR_load_UI_strings(void);
 /* Error codes for the UI functions. */
 
 /* Function codes. */
+#define UI_F_GENERAL_ALLOCATE_BOOLEAN			 108
+#define UI_F_GENERAL_ALLOCATE_PROMPT			 109
 #define UI_F_GENERAL_ALLOCATE_STRING			 100
+#define UI_F_UI_CTRL					 111
 #define UI_F_UI_DUP_ERROR_STRING			 101
 #define UI_F_UI_DUP_INFO_STRING				 102
+#define UI_F_UI_DUP_INPUT_BOOLEAN			 110
 #define UI_F_UI_DUP_INPUT_STRING			 103
 #define UI_F_UI_DUP_VERIFY_STRING			 106
 #define UI_F_UI_GET0_RESULT				 107
@@ -323,10 +368,13 @@ void ERR_load_UI_strings(void);
 #define UI_F_UI_SET_RESULT				 105
 
 /* Reason codes. */
+#define UI_R_COMMON_OK_AND_CANCEL_CHARACTERS		 104
 #define UI_R_INDEX_TOO_LARGE				 102
 #define UI_R_INDEX_TOO_SMALL				 103
+#define UI_R_NO_RESULT_BUFFER				 105
 #define UI_R_RESULT_TOO_LARGE				 100
 #define UI_R_RESULT_TOO_SMALL				 101
+#define UI_R_UNKNOWN_CONTROL_COMMAND			 106
 
 #ifdef  __cplusplus
 }

crypto/ui/ui_lib.c

@@ -98,7 +98,19 @@ UI *UI_new_method(const UI_METHOD *method)
 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);
 	}
 
@@ -123,28 +135,98 @@ static int allocate_string_stack(UI *ui)
 	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 (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;
+	int ret = -1;
+	UI_STRING *s = general_allocate_prompt(ui, prompt, prompt_freeable,
+		type, input_flags, result_buf);
 
-	if (prompt == NULL)
+	if (s)
 		{
-		UIerr(UI_F_GENERAL_ALLOCATE_STRING,ERR_R_PASSED_NULL_PARAMETER);
+		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);
+			}
+		else
+			free_string(s);
 		}
-	else if (allocate_string_stack(ui) >= 0)
+	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)
 		{
-		UI_STRING *s=(UI_STRING *)OPENSSL_malloc(sizeof(UI_STRING));
+		UIerr(UI_F_GENERAL_ALLOCATE_BOOLEAN,ERR_R_PASSED_NULL_PARAMETER);
-		s->out_string=prompt;
+		}
-		s->flags=prompt_freeable ? OUT_STRING_FREEABLE : 0;
+	else if (cancel_chars == NULL)
-		s->input_flags=input_flags;
+		{
-		s->type=type;
+		UIerr(UI_F_GENERAL_ALLOCATE_BOOLEAN,ERR_R_PASSED_NULL_PARAMETER);
-		s->result_buf=result_buf;
+		}
-		s->result_minsize=minsize;
+	else
-		s->result_maxsize=maxsize;
+		{
-		s->test_buf=test_buf;
+		for(p = ok_chars; *p; p++)
-		ret=sk_UI_STRING_push(ui->strings, s);
+			{
+			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);
+				}
+			else
+				free_string(s);
+			}
 		}
 	return ret;
 	}
@@ -204,6 +286,74 @@ int UI_dup_verify_string(UI *ui, const char *prompt, int flags,
 		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,
@@ -224,8 +374,8 @@ int UI_dup_info_string(UI *ui, const char *text)
 			}
 		}
 
-	return general_allocate_string(ui, text_copy, 1, UIT_INFO, 0, NULL, 0, 0,
+	return general_allocate_string(ui, text_copy, 1, UIT_INFO, 0, NULL,
-		NULL);
+		0, 0, NULL);
 	}
 
 int UI_add_error_string(UI *ui, const char *text)
@@ -313,6 +463,20 @@ const char *UI_get0_result(UI *ui, int i)
 	return UI_get0_result_string(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
+		&& !ui->meth->ui_write_string(ui, &uis))
+		return -1;
+	return 0;
+	}
+
 int UI_process(UI *ui)
 	{
 	int i, ok=0;
@@ -320,6 +484,11 @@ int UI_process(UI *ui)
 	if (ui->meth->ui_open_session && !ui->meth->ui_open_session(ui))
 		return -1;
 
+	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
@@ -370,6 +539,33 @@ int UI_process(UI *ui)
 	return ok;
 	}
 
+int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f)())
+	{
+	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_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 	     CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
         {
@@ -542,6 +738,20 @@ const char *UI_get0_output_string(UI_STRING *uis)
 	return uis->out_string;
 	}
 
+const char *UI_get0_action_string(UI_STRING *uis)
+	{
+	if (!uis)
+		return NULL;
+	switch(uis->type)
+		{
+	case UIT_PROMPT:
+	case UIT_BOOLEAN:
+		return uis->_.boolean_data.action_desc;
+	default:
+		return NULL;
+		}
+	}
+
 const char *UI_get0_result_string(UI_STRING *uis)
 	{
 	if (!uis)
@@ -560,51 +770,119 @@ const char *UI_get0_test_string(UI_STRING *uis)
 	{
 	if (!uis)
 		return NULL;
-	return uis->test_buf;
+	switch(uis->type)
+		{
+	case UIT_VERIFY:
+		return uis->_.string_data.test_buf;
+	default:
+		return NULL;
+		}
 	}
 
 int UI_get_result_minsize(UI_STRING *uis)
 	{
 	if (!uis)
 		return -1;
-	return uis->result_minsize;
+	switch(uis->type)
+		{
+	case UIT_PROMPT:
+	case UIT_VERIFY:
+		return uis->_.string_data.result_minsize;
+	default:
+		return -1;
+		}
 	}
 
 int UI_get_result_maxsize(UI_STRING *uis)
 	{
 	if (!uis)
 		return -1;
-	return uis->result_maxsize;
+	switch(uis->type)
+		{
+	case UIT_PROMPT:
+	case UIT_VERIFY:
+		return uis->_.string_data.result_maxsize;
+	default:
+		return -1;
+		}
 	}
 
-int UI_set_result(UI_STRING *uis, const char *result)
+int UI_set_result(UI *ui, UI_STRING *uis, const char *result)
 	{
 	int l = strlen(result);
 
+	ui->flags &= ~UI_FLAG_REDOABLE;
+
 	if (!uis)
 		return -1;
-	if (l < uis->result_minsize)
+	switch (uis->type)
 		{
-		UIerr(UI_F_UI_SET_RESULT,UI_R_RESULT_TOO_SMALL);
+	case UIT_PROMPT:
-		return -1;
+	case UIT_VERIFY:
-		}
-	if (l > uis->result_maxsize)
 		{
-		UIerr(UI_F_UI_SET_RESULT,UI_R_RESULT_TOO_LARGE);
+		char number1[20];
-		return -1;
+		char number2[20];
+
+		BIO_snprintf(number1, sizeof(number1), "%d",
+			uis->_.string_data.result_minsize);
+		BIO_snprintf(number2, sizeof(number2), "%d",
+			uis->_.string_data.result_maxsize);
+
+		if (l < uis->_.string_data.result_minsize)
+			{
+			ui->flags |= UI_FLAG_REDOABLE;
+			UIerr(UI_F_UI_SET_RESULT,UI_R_RESULT_TOO_SMALL);
+			ERR_add_error_data(5,"You must type in ",
+				number1," to ",number2," characters");
+			return -1;
+			}
+		if (l > uis->_.string_data.result_maxsize)
+			{
+			ui->flags |= UI_FLAG_REDOABLE;
+			UIerr(UI_F_UI_SET_RESULT,UI_R_RESULT_TOO_LARGE);
+			ERR_add_error_data(5,"You must type in ",
+				number1," to ",number2," characters");
+			return -1;
+			}
 		}
 
-	if (!uis->result_buf)
+		if (!uis->result_buf)
-		{
+			{
-		uis->result_buf = OPENSSL_malloc(uis->result_maxsize+1);
+			UIerr(UI_F_UI_SET_RESULT,UI_R_NO_RESULT_BUFFER);
-		}
+			return -1;
+			}
 
-	if (!uis->result_buf)
+		strcpy(uis->result_buf, result);
+		break;
+	case UIT_BOOLEAN:
 		{
-		UIerr(UI_F_UI_NEW_METHOD,ERR_R_MALLOC_FAILURE);
+		const char *p;
-		return -1;
-		}
 
-	strcpy(uis->result_buf, result);
+		if (!uis->result_buf)
+			{
+			UIerr(UI_F_UI_SET_RESULT,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;
+				}
+			}
+	default:
+		break;
+		}
+		}
 	return 0;
 	}

crypto/ui/ui_locl.h

@@ -96,21 +96,36 @@ struct ui_method_st
 
 struct ui_string_st
 	{
-	const char *out_string;	/* Input */
 	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 UI_INFO,
+	/* The following parameters are completely irrelevant for UIT_INFO,
-	   and can therefore be set to 0 ro NULL */
+	   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.*/
-	int result_minsize;	/* Input: minimum required size of the result*/
+	union
-	int result_maxsize;	/* Input: maximum permitted size of the
+		{
-				   result */
+		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 */
+			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 */
@@ -124,6 +139,10 @@ struct ui_st
 					 with different echoing status.  */
 	void *user_data;
 	CRYPTO_EX_DATA ex_data;
+
+#define UI_FLAG_REDOABLE	0x0001
+#define UI_FLAG_PRINT_ERRORS	0x0100
+	int flags;
 	};
 
 #endif