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