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
 427     if (ui->meth->ui_open_session && !ui->meth->ui_open_session(ui))
 428         return -1;
 429
 430     if (ui->flags & UI_FLAG_PRINT_ERRORS)
 431         ERR_print_errors_cb((int (*)(const char *, size_t, void *))
 432                             print_error, (void *)ui);
 433
 434     for (i = 0; i < sk_UI_STRING_num(ui->strings); i++) {
 435         if (ui->meth->ui_write_string
 436             && !ui->meth->ui_write_string(ui,
 437                                           sk_UI_STRING_value(ui->strings, i)))
 438         {
 439             ok = -1;
 440             goto err;
 441         }
 442     }
 443
 444     if (ui->meth->ui_flush)
 445         switch (ui->meth->ui_flush(ui)) {
 446         case -1:               /* Interrupt/Cancel/something... */
 447             ok = -2;
 448             goto err;
 449         case 0:                /* Errors */
 450             ok = -1;
 451             goto err;
 452         default:               /* Success */
 453             ok = 0;
 454             break;
 455         }
 456
 457     for (i = 0; i < sk_UI_STRING_num(ui->strings); i++) {
 458         if (ui->meth->ui_read_string) {
 459             switch (ui->meth->ui_read_string(ui,
 460                                              sk_UI_STRING_value(ui->strings,
 461                                                                 i))) {
 462             case -1:           /* Interrupt/Cancel/something... */
 463                 ok = -2;
 464                 goto err;
 465             case 0:            /* Errors */
 466                 ok = -1;
 467                 goto err;
 468             default:           /* Success */
 469                 ok = 0;
 470                 break;
 471             }
 472         }
 473     }
 474  err:
 475     if (ui->meth->ui_close_session && !ui->meth->ui_close_session(ui))
 476         return -1;
 477     return ok;
 478 }
 479
 480 int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void))
 481 {
 482     if (ui == NULL) {
 483         UIerr(UI_F_UI_CTRL, ERR_R_PASSED_NULL_PARAMETER);
 484         return -1;
 485     }
 486     switch (cmd) {
 487     case UI_CTRL_PRINT_ERRORS:
 488         {
 489             int save_flag = ! !(ui->flags & UI_FLAG_PRINT_ERRORS);
 490             if (i)
 491                 ui->flags |= UI_FLAG_PRINT_ERRORS;
 492             else
 493                 ui->flags &= ~UI_FLAG_PRINT_ERRORS;
 494             return save_flag;
 495         }
 496     case UI_CTRL_IS_REDOABLE:
 497         return ! !(ui->flags & UI_FLAG_REDOABLE);
 498     default:
 499         break;
 500     }
 501     UIerr(UI_F_UI_CTRL, UI_R_UNKNOWN_CONTROL_COMMAND);
 502     return -1;
 503 }
 504
 505 int UI_set_ex_data(UI *r, int idx, void *arg)
 506 {
 507     return (CRYPTO_set_ex_data(&r->ex_data, idx, arg));
 508 }
 509
 510 void *UI_get_ex_data(UI *r, int idx)
 511 {
 512     return (CRYPTO_get_ex_data(&r->ex_data, idx));
 513 }
 514
 515 void UI_set_default_method(const UI_METHOD *meth)
 516 {
 517     default_UI_meth = meth;
 518 }
 519
 520 const UI_METHOD *UI_get_default_method(void)
 521 {
 522     if (default_UI_meth == NULL) {
 523         default_UI_meth = UI_OpenSSL();
 524     }
 525     return default_UI_meth;
 526 }
 527
 528 const UI_METHOD *UI_get_method(UI *ui)
 529 {
 530     return ui->meth;
 531 }
 532
 533 const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth)
 534 {
 535     ui->meth = meth;
 536     return ui->meth;
 537 }
 538
 539 UI_METHOD *UI_create_method(const char *name)
 540 {
 541     UI_METHOD *ui_method = OPENSSL_zalloc(sizeof(*ui_method));
 542
 543     if (ui_method != NULL) {
 544         ui_method->name = OPENSSL_strdup(name);
 545         if (ui_method->name == NULL) {
 546             OPENSSL_free(ui_method);
 547             UIerr(UI_F_UI_CREATE_METHOD, ERR_R_MALLOC_FAILURE);
 548             return NULL;
 549         }
 550     }
 551     return ui_method;
 552 }
 553
 554 /*
 555  * BIG FSCKING WARNING!!!! If you use this on a statically allocated method
 556  * (that is, it hasn't been allocated using UI_create_method(), you deserve
 557  * anything Murphy can throw at you and more! You have been warned.
 558  */
 559 void UI_destroy_method(UI_METHOD *ui_method)
 560 {
 561     OPENSSL_free(ui_method->name);
 562     ui_method->name = NULL;
 563     OPENSSL_free(ui_method);
 564 }
 565
 566 int UI_method_set_opener(UI_METHOD *method, int (*opener) (UI *ui))
 567 {
 568     if (method) {
 569         method->ui_open_session = opener;
 570         return 0;
 571     } else
 572         return -1;
 573 }
 574
 575 int UI_method_set_writer(UI_METHOD *method,
 576                          int (*writer) (UI *ui, UI_STRING *uis))
 577 {
 578     if (method) {
 579         method->ui_write_string = writer;
 580         return 0;
 581     } else
 582         return -1;
 583 }
 584
 585 int UI_method_set_flusher(UI_METHOD *method, int (*flusher) (UI *ui))
 586 {
 587     if (method) {
 588         method->ui_flush = flusher;
 589         return 0;
 590     } else
 591         return -1;
 592 }
 593
 594 int UI_method_set_reader(UI_METHOD *method,
 595                          int (*reader) (UI *ui, UI_STRING *uis))
 596 {
 597     if (method) {
 598         method->ui_read_string = reader;
 599         return 0;
 600     } else
 601         return -1;
 602 }
 603
 604 int UI_method_set_closer(UI_METHOD *method, int (*closer) (UI *ui))
 605 {
 606     if (method) {
 607         method->ui_close_session = closer;
 608         return 0;
 609     } else
 610         return -1;
 611 }
 612
 613 int UI_method_set_prompt_constructor(UI_METHOD *method,
 614                                      char *(*prompt_constructor) (UI *ui,
 615                                                                   const char
 616                                                                   *object_desc,
 617                                                                   const char
 618                                                                   *object_name))
 619 {
 620     if (method) {
 621         method->ui_construct_prompt = prompt_constructor;
 622         return 0;
 623     } else
 624         return -1;
 625 }
 626
 627 int (*UI_method_get_opener(UI_METHOD *method)) (UI *) {
 628     if (method)
 629         return method->ui_open_session;
 630     else
 631         return NULL;
 632 }
 633
 634 int (*UI_method_get_writer(UI_METHOD *method)) (UI *, UI_STRING *) {
 635     if (method)
 636         return method->ui_write_string;
 637     else
 638         return NULL;
 639 }
 640
 641 int (*UI_method_get_flusher(UI_METHOD *method)) (UI *) {
 642     if (method)
 643         return method->ui_flush;
 644     else
 645         return NULL;
 646 }
 647
 648 int (*UI_method_get_reader(UI_METHOD *method)) (UI *, UI_STRING *) {
 649     if (method)
 650         return method->ui_read_string;
 651     else
 652         return NULL;
 653 }
 654
 655 int (*UI_method_get_closer(UI_METHOD *method)) (UI *) {
 656     if (method)
 657         return method->ui_close_session;
 658     else
 659         return NULL;
 660 }
 661
 662 char *(*UI_method_get_prompt_constructor(UI_METHOD *method)) (UI *,
 663                                                               const char *,
 664                                                               const char *) {
 665     if (method)
 666         return method->ui_construct_prompt;
 667     else
 668         return NULL;
 669 }
 670
 671 enum UI_string_types UI_get_string_type(UI_STRING *uis)
 672 {
 673     if (!uis)
 674         return UIT_NONE;
 675     return uis->type;
 676 }
 677
 678 int UI_get_input_flags(UI_STRING *uis)
 679 {
 680     if (!uis)
 681         return 0;
 682     return uis->input_flags;
 683 }
 684
 685 const char *UI_get0_output_string(UI_STRING *uis)
 686 {
 687     if (!uis)
 688         return NULL;
 689     return uis->out_string;
 690 }
 691
 692 const char *UI_get0_action_string(UI_STRING *uis)
 693 {
 694     if (!uis)
 695         return NULL;
 696     switch (uis->type) {
 697     case UIT_PROMPT:
 698     case UIT_BOOLEAN:
 699         return uis->_.boolean_data.action_desc;
 700     default:
 701         return NULL;
 702     }
 703 }
 704
 705 const char *UI_get0_result_string(UI_STRING *uis)
 706 {
 707     if (!uis)
 708         return NULL;
 709     switch (uis->type) {
 710     case UIT_PROMPT:
 711     case UIT_VERIFY:
 712         return uis->result_buf;
 713     default:
 714         return NULL;
 715     }
 716 }
 717
 718 const char *UI_get0_test_string(UI_STRING *uis)
 719 {
 720     if (!uis)
 721         return NULL;
 722     switch (uis->type) {
 723     case UIT_VERIFY:
 724         return uis->_.string_data.test_buf;
 725     default:
 726         return NULL;
 727     }
 728 }
 729
 730 int UI_get_result_minsize(UI_STRING *uis)
 731 {
 732     if (!uis)
 733         return -1;
 734     switch (uis->type) {
 735     case UIT_PROMPT:
 736     case UIT_VERIFY:
 737         return uis->_.string_data.result_minsize;
 738     default:
 739         return -1;
 740     }
 741 }
 742
 743 int UI_get_result_maxsize(UI_STRING *uis)
 744 {
 745     if (!uis)
 746         return -1;
 747     switch (uis->type) {
 748     case UIT_PROMPT:
 749     case UIT_VERIFY:
 750         return uis->_.string_data.result_maxsize;
 751     default:
 752         return -1;
 753     }
 754 }
 755
 756 int UI_set_result(UI *ui, UI_STRING *uis, const char *result)
 757 {
 758     int l = strlen(result);
 759
 760     ui->flags &= ~UI_FLAG_REDOABLE;
 761
 762     if (!uis)
 763         return -1;
 764     switch (uis->type) {
 765     case UIT_PROMPT:
 766     case UIT_VERIFY:
 767         {
 768             char number1[DECIMAL_SIZE(uis->_.string_data.result_minsize) + 1];
 769             char number2[DECIMAL_SIZE(uis->_.string_data.result_maxsize) + 1];
 770
 771             BIO_snprintf(number1, sizeof(number1), "%d",
 772                          uis->_.string_data.result_minsize);
 773             BIO_snprintf(number2, sizeof(number2), "%d",
 774                          uis->_.string_data.result_maxsize);
 775
 776             if (l < uis->_.string_data.result_minsize) {
 777                 ui->flags |= UI_FLAG_REDOABLE;
 778                 UIerr(UI_F_UI_SET_RESULT, UI_R_RESULT_TOO_SMALL);
 779                 ERR_add_error_data(5, "You must type in ",
 780                                    number1, " to ", number2, " characters");
 781                 return -1;
 782             }
 783             if (l > uis->_.string_data.result_maxsize) {
 784                 ui->flags |= UI_FLAG_REDOABLE;
 785                 UIerr(UI_F_UI_SET_RESULT, UI_R_RESULT_TOO_LARGE);
 786                 ERR_add_error_data(5, "You must type in ",
 787                                    number1, " to ", number2, " characters");
 788                 return -1;
 789             }
 790         }
 791
 792         if (!uis->result_buf) {
 793             UIerr(UI_F_UI_SET_RESULT, UI_R_NO_RESULT_BUFFER);
 794             return -1;
 795         }
 796
 797         OPENSSL_strlcpy(uis->result_buf, result,
 798                     uis->_.string_data.result_maxsize + 1);
 799         break;
 800     case UIT_BOOLEAN:
 801         {
 802             const char *p;
 803
 804             if (!uis->result_buf) {
 805                 UIerr(UI_F_UI_SET_RESULT, UI_R_NO_RESULT_BUFFER);
 806                 return -1;
 807             }
 808
 809             uis->result_buf[0] = '\0';
 810             for (p = result; *p; p++) {
 811                 if (strchr(uis->_.boolean_data.ok_chars, *p)) {
 812                     uis->result_buf[0] = uis->_.boolean_data.ok_chars[0];
 813                     break;
 814                 }
 815                 if (strchr(uis->_.boolean_data.cancel_chars, *p)) {
 816                     uis->result_buf[0] = uis->_.boolean_data.cancel_chars[0];
 817                     break;
 818                 }
 819             }
 820         }
 821     default:
 822         break;
 823     }
 824     return 0;
 825 }