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