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