b84cad011b818777b3fe8682821ab536c9ebd8db
[openssl.git] / crypto / ui / ui_lib.c
1 /*
2  * Copyright 2001-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <string.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/e_os2.h>
13 #include <openssl/buffer.h>
14 #include <openssl/ui.h>
15 #include <openssl/err.h>
16 #include "ui_locl.h"
17
18 static const UI_METHOD *default_UI_meth = NULL;
19
20 UI *UI_new(void)
21 {
22     return (UI_new_method(NULL));
23 }
24
25 UI *UI_new_method(const UI_METHOD *method)
26 {
27     UI *ret = OPENSSL_zalloc(sizeof(*ret));
28
29     if (ret == NULL) {
30         UIerr(UI_F_UI_NEW_METHOD, ERR_R_MALLOC_FAILURE);
31         return NULL;
32     }
33
34     ret->lock = CRYPTO_THREAD_lock_new();
35     if (ret->lock == NULL) {
36         UIerr(UI_F_UI_NEW_METHOD, ERR_R_MALLOC_FAILURE);
37         OPENSSL_free(ret);
38         return NULL;
39     }
40
41     if (method == NULL)
42         ret->meth = UI_get_default_method();
43     else
44         ret->meth = method;
45
46     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_UI, ret, &ret->ex_data)) {
47         OPENSSL_free(ret);
48         return NULL;
49     }
50     return ret;
51 }
52
53 static void free_string(UI_STRING *uis)
54 {
55     if (uis->flags & OUT_STRING_FREEABLE) {
56         OPENSSL_free((char *)uis->out_string);
57         switch (uis->type) {
58         case UIT_BOOLEAN:
59             OPENSSL_free((char *)uis->_.boolean_data.action_desc);
60             OPENSSL_free((char *)uis->_.boolean_data.ok_chars);
61             OPENSSL_free((char *)uis->_.boolean_data.cancel_chars);
62             break;
63         case UIT_NONE:
64         case UIT_PROMPT:
65         case UIT_VERIFY:
66         case UIT_ERROR:
67         case UIT_INFO:
68             break;
69         }
70     }
71     OPENSSL_free(uis);
72 }
73
74 void UI_free(UI *ui)
75 {
76     if (ui == NULL)
77         return;
78     sk_UI_STRING_pop_free(ui->strings, free_string);
79     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data);
80     CRYPTO_THREAD_lock_free(ui->lock);
81     OPENSSL_free(ui);
82 }
83
84 static int allocate_string_stack(UI *ui)
85 {
86     if (ui->strings == NULL) {
87         ui->strings = sk_UI_STRING_new_null();
88         if (ui->strings == NULL) {
89             return -1;
90         }
91     }
92     return 0;
93 }
94
95 static UI_STRING *general_allocate_prompt(UI *ui, const char *prompt,
96                                           int prompt_freeable,
97                                           enum UI_string_types type,
98                                           int input_flags, char *result_buf)
99 {
100     UI_STRING *ret = NULL;
101
102     if (prompt == NULL) {
103         UIerr(UI_F_GENERAL_ALLOCATE_PROMPT, ERR_R_PASSED_NULL_PARAMETER);
104     } else if ((type == UIT_PROMPT || type == UIT_VERIFY
105                 || type == UIT_BOOLEAN) && result_buf == NULL) {
106         UIerr(UI_F_GENERAL_ALLOCATE_PROMPT, UI_R_NO_RESULT_BUFFER);
107     } else if ((ret = OPENSSL_malloc(sizeof(*ret))) != NULL) {
108         ret->out_string = prompt;
109         ret->flags = prompt_freeable ? OUT_STRING_FREEABLE : 0;
110         ret->input_flags = input_flags;
111         ret->type = type;
112         ret->result_buf = result_buf;
113     }
114     return ret;
115 }
116
117 static int general_allocate_string(UI *ui, const char *prompt,
118                                    int prompt_freeable,
119                                    enum UI_string_types type, int input_flags,
120                                    char *result_buf, int minsize, int maxsize,
121                                    const char *test_buf)
122 {
123     int ret = -1;
124     UI_STRING *s = general_allocate_prompt(ui, prompt, prompt_freeable,
125                                            type, input_flags, result_buf);
126
127     if (s != NULL) {
128         if (allocate_string_stack(ui) >= 0) {
129             s->_.string_data.result_minsize = minsize;
130             s->_.string_data.result_maxsize = maxsize;
131             s->_.string_data.test_buf = test_buf;
132             ret = sk_UI_STRING_push(ui->strings, s);
133             /* sk_push() returns 0 on error.  Let's adapt that */
134             if (ret <= 0) {
135                 ret--;
136                 free_string(s);
137             }
138         } else
139             free_string(s);
140     }
141     return ret;
142 }
143
144 static int general_allocate_boolean(UI *ui,
145                                     const char *prompt,
146                                     const char *action_desc,
147                                     const char *ok_chars,
148                                     const char *cancel_chars,
149                                     int prompt_freeable,
150                                     enum UI_string_types type,
151                                     int input_flags, char *result_buf)
152 {
153     int ret = -1;
154     UI_STRING *s;
155     const char *p;
156
157     if (ok_chars == NULL) {
158         UIerr(UI_F_GENERAL_ALLOCATE_BOOLEAN, ERR_R_PASSED_NULL_PARAMETER);
159     } else if (cancel_chars == NULL) {
160         UIerr(UI_F_GENERAL_ALLOCATE_BOOLEAN, ERR_R_PASSED_NULL_PARAMETER);
161     } else {
162         for (p = ok_chars; *p != '\0'; p++) {
163             if (strchr(cancel_chars, *p) != NULL) {
164                 UIerr(UI_F_GENERAL_ALLOCATE_BOOLEAN,
165                       UI_R_COMMON_OK_AND_CANCEL_CHARACTERS);
166             }
167         }
168
169         s = general_allocate_prompt(ui, prompt, prompt_freeable,
170                                     type, input_flags, result_buf);
171
172         if (s != NULL) {
173             if (allocate_string_stack(ui) >= 0) {
174                 s->_.boolean_data.action_desc = action_desc;
175                 s->_.boolean_data.ok_chars = ok_chars;
176                 s->_.boolean_data.cancel_chars = cancel_chars;
177                 ret = sk_UI_STRING_push(ui->strings, s);
178                 /*
179                  * sk_push() returns 0 on error. Let's adapt that
180                  */
181                 if (ret <= 0) {
182                     ret--;
183                     free_string(s);
184                 }
185             } else
186                 free_string(s);
187         }
188     }
189     return ret;
190 }
191
192 /*
193  * Returns the index to the place in the stack or -1 for error.  Uses a
194  * direct reference to the prompt.
195  */
196 int UI_add_input_string(UI *ui, const char *prompt, int flags,
197                         char *result_buf, int minsize, int maxsize)
198 {
199     return general_allocate_string(ui, prompt, 0,
200                                    UIT_PROMPT, flags, result_buf, minsize,
201                                    maxsize, NULL);
202 }
203
204 /* Same as UI_add_input_string(), excepts it takes a copy of the prompt */
205 int UI_dup_input_string(UI *ui, const char *prompt, int flags,
206                         char *result_buf, int minsize, int maxsize)
207 {
208     char *prompt_copy = NULL;
209
210     if (prompt != NULL) {
211         prompt_copy = OPENSSL_strdup(prompt);
212         if (prompt_copy == NULL) {
213             UIerr(UI_F_UI_DUP_INPUT_STRING, ERR_R_MALLOC_FAILURE);
214             return 0;
215         }
216     }
217
218     return general_allocate_string(ui, prompt_copy, 1,
219                                    UIT_PROMPT, flags, result_buf, minsize,
220                                    maxsize, NULL);
221 }
222
223 int UI_add_verify_string(UI *ui, const char *prompt, int flags,
224                          char *result_buf, int minsize, int maxsize,
225                          const char *test_buf)
226 {
227     return general_allocate_string(ui, prompt, 0,
228                                    UIT_VERIFY, flags, result_buf, minsize,
229                                    maxsize, test_buf);
230 }
231
232 int UI_dup_verify_string(UI *ui, const char *prompt, int flags,
233                          char *result_buf, int minsize, int maxsize,
234                          const char *test_buf)
235 {
236     char *prompt_copy = NULL;
237
238     if (prompt != NULL) {
239         prompt_copy = OPENSSL_strdup(prompt);
240         if (prompt_copy == NULL) {
241             UIerr(UI_F_UI_DUP_VERIFY_STRING, ERR_R_MALLOC_FAILURE);
242             return -1;
243         }
244     }
245
246     return general_allocate_string(ui, prompt_copy, 1,
247                                    UIT_VERIFY, flags, result_buf, minsize,
248                                    maxsize, test_buf);
249 }
250
251 int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
252                          const char *ok_chars, const char *cancel_chars,
253                          int flags, char *result_buf)
254 {
255     return general_allocate_boolean(ui, prompt, action_desc,
256                                     ok_chars, cancel_chars, 0, UIT_BOOLEAN,
257                                     flags, result_buf);
258 }
259
260 int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
261                          const char *ok_chars, const char *cancel_chars,
262                          int flags, char *result_buf)
263 {
264     char *prompt_copy = NULL;
265     char *action_desc_copy = NULL;
266     char *ok_chars_copy = NULL;
267     char *cancel_chars_copy = NULL;
268
269     if (prompt != NULL) {
270         prompt_copy = OPENSSL_strdup(prompt);
271         if (prompt_copy == NULL) {
272             UIerr(UI_F_UI_DUP_INPUT_BOOLEAN, ERR_R_MALLOC_FAILURE);
273             goto err;
274         }
275     }
276
277     if (action_desc != NULL) {
278         action_desc_copy = OPENSSL_strdup(action_desc);
279         if (action_desc_copy == NULL) {
280             UIerr(UI_F_UI_DUP_INPUT_BOOLEAN, ERR_R_MALLOC_FAILURE);
281             goto err;
282         }
283     }
284
285     if (ok_chars != NULL) {
286         ok_chars_copy = OPENSSL_strdup(ok_chars);
287         if (ok_chars_copy == NULL) {
288             UIerr(UI_F_UI_DUP_INPUT_BOOLEAN, ERR_R_MALLOC_FAILURE);
289             goto err;
290         }
291     }
292
293     if (cancel_chars != NULL) {
294         cancel_chars_copy = OPENSSL_strdup(cancel_chars);
295         if (cancel_chars_copy == NULL) {
296             UIerr(UI_F_UI_DUP_INPUT_BOOLEAN, ERR_R_MALLOC_FAILURE);
297             goto err;
298         }
299     }
300
301     return general_allocate_boolean(ui, prompt_copy, action_desc_copy,
302                                     ok_chars_copy, cancel_chars_copy, 1,
303                                     UIT_BOOLEAN, flags, result_buf);
304  err:
305     OPENSSL_free(prompt_copy);
306     OPENSSL_free(action_desc_copy);
307     OPENSSL_free(ok_chars_copy);
308     OPENSSL_free(cancel_chars_copy);
309     return -1;
310 }
311
312 int UI_add_info_string(UI *ui, const char *text)
313 {
314     return general_allocate_string(ui, text, 0, UIT_INFO, 0, NULL, 0, 0,
315                                    NULL);
316 }
317
318 int UI_dup_info_string(UI *ui, const char *text)
319 {
320     char *text_copy = NULL;
321
322     if (text != NULL) {
323         text_copy = OPENSSL_strdup(text);
324         if (text_copy == NULL) {
325             UIerr(UI_F_UI_DUP_INFO_STRING, ERR_R_MALLOC_FAILURE);
326             return -1;
327         }
328     }
329
330     return general_allocate_string(ui, text_copy, 1, UIT_INFO, 0, NULL,
331                                    0, 0, NULL);
332 }
333
334 int UI_add_error_string(UI *ui, const char *text)
335 {
336     return general_allocate_string(ui, text, 0, UIT_ERROR, 0, NULL, 0, 0,
337                                    NULL);
338 }
339
340 int UI_dup_error_string(UI *ui, const char *text)
341 {
342     char *text_copy = NULL;
343
344     if (text != NULL) {
345         text_copy = OPENSSL_strdup(text);
346         if (text_copy == NULL) {
347             UIerr(UI_F_UI_DUP_ERROR_STRING, ERR_R_MALLOC_FAILURE);
348             return -1;
349         }
350     }
351     return general_allocate_string(ui, text_copy, 1, UIT_ERROR, 0, NULL,
352                                    0, 0, NULL);
353 }
354
355 char *UI_construct_prompt(UI *ui, const char *object_desc,
356                           const char *object_name)
357 {
358     char *prompt = NULL;
359
360     if (ui->meth->ui_construct_prompt != NULL)
361         prompt = ui->meth->ui_construct_prompt(ui, object_desc, object_name);
362     else {
363         char prompt1[] = "Enter ";
364         char prompt2[] = " for ";
365         char prompt3[] = ":";
366         int len = 0;
367
368         if (object_desc == NULL)
369             return NULL;
370         len = sizeof(prompt1) - 1 + strlen(object_desc);
371         if (object_name != NULL)
372             len += sizeof(prompt2) - 1 + strlen(object_name);
373         len += sizeof(prompt3) - 1;
374
375         prompt = OPENSSL_malloc(len + 1);
376         if (prompt == NULL)
377             return NULL;
378         OPENSSL_strlcpy(prompt, prompt1, len + 1);
379         OPENSSL_strlcat(prompt, object_desc, len + 1);
380         if (object_name != NULL) {
381             OPENSSL_strlcat(prompt, prompt2, len + 1);
382             OPENSSL_strlcat(prompt, object_name, len + 1);
383         }
384         OPENSSL_strlcat(prompt, prompt3, len + 1);
385     }
386     return prompt;
387 }
388
389 void *UI_add_user_data(UI *ui, void *user_data)
390 {
391     void *old_data = ui->user_data;
392     ui->user_data = user_data;
393     return old_data;
394 }
395
396 void *UI_get0_user_data(UI *ui)
397 {
398     return ui->user_data;
399 }
400
401 const char *UI_get0_result(UI *ui, int i)
402 {
403     if (i < 0) {
404         UIerr(UI_F_UI_GET0_RESULT, UI_R_INDEX_TOO_SMALL);
405         return NULL;
406     }
407     if (i >= sk_UI_STRING_num(ui->strings)) {
408         UIerr(UI_F_UI_GET0_RESULT, UI_R_INDEX_TOO_LARGE);
409         return NULL;
410     }
411     return UI_get0_result_string(sk_UI_STRING_value(ui->strings, i));
412 }
413
414 static int print_error(const char *str, size_t len, UI *ui)
415 {
416     UI_STRING uis;
417
418     memset(&uis, 0, sizeof(uis));
419     uis.type = UIT_ERROR;
420     uis.out_string = str;
421
422     if (ui->meth->ui_write_string != NULL
423         && ui->meth->ui_write_string(ui, &uis) <= 0)
424         return -1;
425     return 0;
426 }
427
428 int UI_process(UI *ui)
429 {
430     int i, ok = 0;
431     const char *state = "processing";
432
433     if (ui->meth->ui_open_session != NULL
434         && ui->meth->ui_open_session(ui) <= 0) {
435         state = "opening session";
436         ok = -1;
437         goto err;
438     }
439
440     if (ui->flags & UI_FLAG_PRINT_ERRORS)
441         ERR_print_errors_cb((int (*)(const char *, size_t, void *))
442                             print_error, (void *)ui);
443
444     for (i = 0; i < sk_UI_STRING_num(ui->strings); i++) {
445         if (ui->meth->ui_write_string != NULL
446             && (ui->meth->ui_write_string(ui,
447                                           sk_UI_STRING_value(ui->strings, i))
448                 <= 0))
449         {
450             state = "writing strings";
451             ok = -1;
452             goto err;
453         }
454     }
455
456     if (ui->meth->ui_flush != NULL)
457         switch (ui->meth->ui_flush(ui)) {
458         case -1:               /* Interrupt/Cancel/something... */
459             ok = -2;
460             goto err;
461         case 0:                /* Errors */
462             state = "flushing";
463             ok = -1;
464             goto err;
465         default:               /* Success */
466             ok = 0;
467             break;
468         }
469
470     for (i = 0; i < sk_UI_STRING_num(ui->strings); i++) {
471         if (ui->meth->ui_read_string != NULL) {
472             switch (ui->meth->ui_read_string(ui,
473                                              sk_UI_STRING_value(ui->strings,
474                                                                 i))) {
475             case -1:           /* Interrupt/Cancel/something... */
476                 ok = -2;
477                 goto err;
478             case 0:            /* Errors */
479                 state = "reading strings";
480                 ok = -1;
481                 goto err;
482             default:           /* Success */
483                 ok = 0;
484                 break;
485             }
486         }
487     }
488  err:
489     if (ui->meth->ui_close_session != NULL
490         && !ui->meth->ui_close_session(ui) <= 0) {
491         if (state == NULL)
492             state = "closing session";
493         ok = -1;
494     }
495
496     if (ok == -1) {
497         UIerr(UI_F_UI_PROCESS, UI_R_PROCESSING_ERROR);
498         ERR_add_error_data(2, "while ", state);
499     }
500     return ok;
501 }
502
503 int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void))
504 {
505     if (ui == NULL) {
506         UIerr(UI_F_UI_CTRL, ERR_R_PASSED_NULL_PARAMETER);
507         return -1;
508     }
509     switch (cmd) {
510     case UI_CTRL_PRINT_ERRORS:
511         {
512             int save_flag = ! !(ui->flags & UI_FLAG_PRINT_ERRORS);
513             if (i)
514                 ui->flags |= UI_FLAG_PRINT_ERRORS;
515             else
516                 ui->flags &= ~UI_FLAG_PRINT_ERRORS;
517             return save_flag;
518         }
519     case UI_CTRL_IS_REDOABLE:
520         return ! !(ui->flags & UI_FLAG_REDOABLE);
521     default:
522         break;
523     }
524     UIerr(UI_F_UI_CTRL, UI_R_UNKNOWN_CONTROL_COMMAND);
525     return -1;
526 }
527
528 int UI_set_ex_data(UI *r, int idx, void *arg)
529 {
530     return (CRYPTO_set_ex_data(&r->ex_data, idx, arg));
531 }
532
533 void *UI_get_ex_data(UI *r, int idx)
534 {
535     return (CRYPTO_get_ex_data(&r->ex_data, idx));
536 }
537
538 void UI_set_default_method(const UI_METHOD *meth)
539 {
540     default_UI_meth = meth;
541 }
542
543 const UI_METHOD *UI_get_default_method(void)
544 {
545     if (default_UI_meth == NULL) {
546         default_UI_meth = UI_OpenSSL();
547     }
548     return default_UI_meth;
549 }
550
551 const UI_METHOD *UI_get_method(UI *ui)
552 {
553     return ui->meth;
554 }
555
556 const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth)
557 {
558     ui->meth = meth;
559     return ui->meth;
560 }
561
562 UI_METHOD *UI_create_method(const char *name)
563 {
564     UI_METHOD *ui_method = OPENSSL_zalloc(sizeof(*ui_method));
565
566     if (ui_method != NULL) {
567         ui_method->name = OPENSSL_strdup(name);
568         if (ui_method->name == NULL) {
569             OPENSSL_free(ui_method);
570             UIerr(UI_F_UI_CREATE_METHOD, ERR_R_MALLOC_FAILURE);
571             return NULL;
572         }
573     }
574     return ui_method;
575 }
576
577 /*
578  * BIG FSCKING WARNING!!!! If you use this on a statically allocated method
579  * (that is, it hasn't been allocated using UI_create_method(), you deserve
580  * anything Murphy can throw at you and more! You have been warned.
581  */
582 void UI_destroy_method(UI_METHOD *ui_method)
583 {
584     OPENSSL_free(ui_method->name);
585     ui_method->name = NULL;
586     OPENSSL_free(ui_method);
587 }
588
589 int UI_method_set_opener(UI_METHOD *method, int (*opener) (UI *ui))
590 {
591     if (method != NULL) {
592         method->ui_open_session = opener;
593         return 0;
594     }
595     return -1;
596 }
597
598 int UI_method_set_writer(UI_METHOD *method,
599                          int (*writer) (UI *ui, UI_STRING *uis))
600 {
601     if (method != NULL) {
602         method->ui_write_string = writer;
603         return 0;
604     }
605     return -1;
606 }
607
608 int UI_method_set_flusher(UI_METHOD *method, int (*flusher) (UI *ui))
609 {
610     if (method != NULL) {
611         method->ui_flush = flusher;
612         return 0;
613     }
614     return -1;
615 }
616
617 int UI_method_set_reader(UI_METHOD *method,
618                          int (*reader) (UI *ui, UI_STRING *uis))
619 {
620     if (method != NULL) {
621         method->ui_read_string = reader;
622         return 0;
623     }
624     return -1;
625 }
626
627 int UI_method_set_closer(UI_METHOD *method, int (*closer) (UI *ui))
628 {
629     if (method != NULL) {
630         method->ui_close_session = closer;
631         return 0;
632     }
633     return -1;
634 }
635
636 int UI_method_set_prompt_constructor(UI_METHOD *method,
637                                      char *(*prompt_constructor) (UI *ui,
638                                                                   const char
639                                                                   *object_desc,
640                                                                   const char
641                                                                   *object_name))
642 {
643     if (method != NULL) {
644         method->ui_construct_prompt = prompt_constructor;
645         return 0;
646     }
647     return -1;
648 }
649
650 int (*UI_method_get_opener(UI_METHOD *method)) (UI *)
651 {
652     if (method != NULL)
653         return method->ui_open_session;
654     return NULL;
655 }
656
657 int (*UI_method_get_writer(UI_METHOD *method)) (UI *, UI_STRING *)
658 {
659     if (method != NULL)
660         return method->ui_write_string;
661     return NULL;
662 }
663
664 int (*UI_method_get_flusher(UI_METHOD *method)) (UI *)
665 {
666     if (method != NULL)
667         return method->ui_flush;
668     return NULL;
669 }
670
671 int (*UI_method_get_reader(UI_METHOD *method)) (UI *, UI_STRING *)
672 {
673     if (method != NULL)
674         return method->ui_read_string;
675     return NULL;
676 }
677
678 int (*UI_method_get_closer(UI_METHOD *method)) (UI *)
679 {
680     if (method != NULL)
681         return method->ui_close_session;
682     return NULL;
683 }
684
685 char *(*UI_method_get_prompt_constructor(UI_METHOD *method)) (UI *,
686                                                               const char *,
687                                                               const char *)
688 {
689     if (method != NULL)
690         return method->ui_construct_prompt;
691     return NULL;
692 }
693
694 enum UI_string_types UI_get_string_type(UI_STRING *uis)
695 {
696     return uis->type;
697 }
698
699 int UI_get_input_flags(UI_STRING *uis)
700 {
701     return uis->input_flags;
702 }
703
704 const char *UI_get0_output_string(UI_STRING *uis)
705 {
706     return uis->out_string;
707 }
708
709 const char *UI_get0_action_string(UI_STRING *uis)
710 {
711     switch (uis->type) {
712     case UIT_PROMPT:
713     case UIT_BOOLEAN:
714         return uis->_.boolean_data.action_desc;
715     case UIT_NONE:
716     case UIT_VERIFY:
717     case UIT_INFO:
718     case UIT_ERROR:
719         break;
720     }
721     return NULL;
722 }
723
724 const char *UI_get0_result_string(UI_STRING *uis)
725 {
726     switch (uis->type) {
727     case UIT_PROMPT:
728     case UIT_VERIFY:
729         return uis->result_buf;
730     case UIT_NONE:
731     case UIT_BOOLEAN:
732     case UIT_INFO:
733     case UIT_ERROR:
734         break;
735     }
736     return NULL;
737 }
738
739 const char *UI_get0_test_string(UI_STRING *uis)
740 {
741     switch (uis->type) {
742     case UIT_VERIFY:
743         return uis->_.string_data.test_buf;
744     case UIT_NONE:
745     case UIT_BOOLEAN:
746     case UIT_INFO:
747     case UIT_ERROR:
748     case UIT_PROMPT:
749         break;
750     }
751     return NULL;
752 }
753
754 int UI_get_result_minsize(UI_STRING *uis)
755 {
756     switch (uis->type) {
757     case UIT_PROMPT:
758     case UIT_VERIFY:
759         return uis->_.string_data.result_minsize;
760     case UIT_NONE:
761     case UIT_INFO:
762     case UIT_ERROR:
763     case UIT_BOOLEAN:
764         break;
765     }
766     return -1;
767 }
768
769 int UI_get_result_maxsize(UI_STRING *uis)
770 {
771     switch (uis->type) {
772     case UIT_PROMPT:
773     case UIT_VERIFY:
774         return uis->_.string_data.result_maxsize;
775     case UIT_NONE:
776     case UIT_INFO:
777     case UIT_ERROR:
778     case UIT_BOOLEAN:
779         break;
780     }
781     return -1;
782 }
783
784 int UI_set_result(UI *ui, UI_STRING *uis, const char *result)
785 {
786     int l = strlen(result);
787
788     ui->flags &= ~UI_FLAG_REDOABLE;
789
790     switch (uis->type) {
791     case UIT_PROMPT:
792     case UIT_VERIFY:
793         {
794             char number1[DECIMAL_SIZE(uis->_.string_data.result_minsize) + 1];
795             char number2[DECIMAL_SIZE(uis->_.string_data.result_maxsize) + 1];
796
797             BIO_snprintf(number1, sizeof(number1), "%d",
798                          uis->_.string_data.result_minsize);
799             BIO_snprintf(number2, sizeof(number2), "%d",
800                          uis->_.string_data.result_maxsize);
801
802             if (l < uis->_.string_data.result_minsize) {
803                 ui->flags |= UI_FLAG_REDOABLE;
804                 UIerr(UI_F_UI_SET_RESULT, UI_R_RESULT_TOO_SMALL);
805                 ERR_add_error_data(5, "You must type in ",
806                                    number1, " to ", number2, " characters");
807                 return -1;
808             }
809             if (l > uis->_.string_data.result_maxsize) {
810                 ui->flags |= UI_FLAG_REDOABLE;
811                 UIerr(UI_F_UI_SET_RESULT, UI_R_RESULT_TOO_LARGE);
812                 ERR_add_error_data(5, "You must type in ",
813                                    number1, " to ", number2, " characters");
814                 return -1;
815             }
816         }
817
818         if (uis->result_buf == NULL) {
819             UIerr(UI_F_UI_SET_RESULT, UI_R_NO_RESULT_BUFFER);
820             return -1;
821         }
822
823         OPENSSL_strlcpy(uis->result_buf, result,
824                     uis->_.string_data.result_maxsize + 1);
825         break;
826     case UIT_BOOLEAN:
827         {
828             const char *p;
829
830             if (uis->result_buf == NULL) {
831                 UIerr(UI_F_UI_SET_RESULT, UI_R_NO_RESULT_BUFFER);
832                 return -1;
833             }
834
835             uis->result_buf[0] = '\0';
836             for (p = result; *p; p++) {
837                 if (strchr(uis->_.boolean_data.ok_chars, *p)) {
838                     uis->result_buf[0] = uis->_.boolean_data.ok_chars[0];
839                     break;
840                 }
841                 if (strchr(uis->_.boolean_data.cancel_chars, *p)) {
842                     uis->result_buf[0] = uis->_.boolean_data.cancel_chars[0];
843                     break;
844                 }
845             }
846         }
847     case UIT_NONE:
848     case UIT_INFO:
849     case UIT_ERROR:
850         break;
851     }
852     return 0;
853 }