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