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