crypto/ui/ui_lib.c

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