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