crypto/ui/ui_lib.c

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