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