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