|
1 /* crypto/ui/ui.h -*- 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 © Portions copyright (c) 2006 Nokia Corporation. All rights reserved. |
|
60 */ |
|
61 |
|
62 #ifndef HEADER_UI_H |
|
63 #define HEADER_UI_H |
|
64 #ifdef SYMBIAN |
|
65 #include <e32def.h> |
|
66 #endif |
|
67 #ifndef OPENSSL_NO_DEPRECATED |
|
68 #include <openssl/crypto.h> |
|
69 #endif |
|
70 #include <openssl/safestack.h> |
|
71 #include <openssl/ossl_typ.h> |
|
72 |
|
73 #ifdef __cplusplus |
|
74 extern "C" { |
|
75 #endif |
|
76 |
|
77 /* Declared already in ossl_typ.h */ |
|
78 /* typedef struct ui_st UI; */ |
|
79 /* typedef struct ui_method_st UI_METHOD; */ |
|
80 |
|
81 |
|
82 /* All the following functions return -1 or NULL on error and in some cases |
|
83 (UI_process()) -2 if interrupted or in some other way cancelled. |
|
84 When everything is fine, they return 0, a positive value or a non-NULL |
|
85 pointer, all depending on their purpose. */ |
|
86 |
|
87 /* Creators and destructor. */ |
|
88 IMPORT_C UI *UI_new(void); |
|
89 IMPORT_C UI *UI_new_method(const UI_METHOD *method); |
|
90 IMPORT_C void UI_free(UI *ui); |
|
91 |
|
92 /* The following functions are used to add strings to be printed and prompt |
|
93 strings to prompt for data. The names are UI_{add,dup}_<function>_string |
|
94 and UI_{add,dup}_input_boolean. |
|
95 |
|
96 UI_{add,dup}_<function>_string have the following meanings: |
|
97 add add a text or prompt string. The pointers given to these |
|
98 functions are used verbatim, no copying is done. |
|
99 dup make a copy of the text or prompt string, then add the copy |
|
100 to the collection of strings in the user interface. |
|
101 <function> |
|
102 The function is a name for the functionality that the given |
|
103 string shall be used for. It can be one of: |
|
104 input use the string as data prompt. |
|
105 verify use the string as verification prompt. This |
|
106 is used to verify a previous input. |
|
107 info use the string for informational output. |
|
108 error use the string for error output. |
|
109 Honestly, there's currently no difference between info and error for the |
|
110 moment. |
|
111 |
|
112 UI_{add,dup}_input_boolean have the same semantics for "add" and "dup", |
|
113 and are typically used when one wants to prompt for a yes/no response. |
|
114 |
|
115 |
|
116 All of the functions in this group take a UI and a prompt string. |
|
117 The string input and verify addition functions also take a flag argument, |
|
118 a buffer for the result to end up with, a minimum input size and a maximum |
|
119 input size (the result buffer MUST be large enough to be able to contain |
|
120 the maximum number of characters). Additionally, the verify addition |
|
121 functions takes another buffer to compare the result against. |
|
122 The boolean input functions take an action description string (which should |
|
123 be safe to ignore if the expected user action is obvious, for example with |
|
124 a dialog box with an OK button and a Cancel button), a string of acceptable |
|
125 characters to mean OK and to mean Cancel. The two last strings are checked |
|
126 to make sure they don't have common characters. Additionally, the same |
|
127 flag argument as for the string input is taken, as well as a result buffer. |
|
128 The result buffer is required to be at least one byte long. Depending on |
|
129 the answer, the first character from the OK or the Cancel character strings |
|
130 will be stored in the first byte of the result buffer. No NUL will be |
|
131 added, so the result is *not* a string. |
|
132 |
|
133 On success, the all return an index of the added information. That index |
|
134 is usefull when retrieving results with UI_get0_result(). */ |
|
135 IMPORT_C int UI_add_input_string(UI *ui, const char *prompt, int flags, |
|
136 char *result_buf, int minsize, int maxsize); |
|
137 IMPORT_C int UI_dup_input_string(UI *ui, const char *prompt, int flags, |
|
138 char *result_buf, int minsize, int maxsize); |
|
139 IMPORT_C int UI_add_verify_string(UI *ui, const char *prompt, int flags, |
|
140 char *result_buf, int minsize, int maxsize, const char *test_buf); |
|
141 IMPORT_C int UI_dup_verify_string(UI *ui, const char *prompt, int flags, |
|
142 char *result_buf, int minsize, int maxsize, const char *test_buf); |
|
143 IMPORT_C int UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc, |
|
144 const char *ok_chars, const char *cancel_chars, |
|
145 int flags, char *result_buf); |
|
146 IMPORT_C int UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc, |
|
147 const char *ok_chars, const char *cancel_chars, |
|
148 int flags, char *result_buf); |
|
149 IMPORT_C int UI_add_info_string(UI *ui, const char *text); |
|
150 IMPORT_C int UI_dup_info_string(UI *ui, const char *text); |
|
151 IMPORT_C int UI_add_error_string(UI *ui, const char *text); |
|
152 IMPORT_C int UI_dup_error_string(UI *ui, const char *text); |
|
153 |
|
154 /* These are the possible flags. They can be or'ed together. */ |
|
155 /* Use to have echoing of input */ |
|
156 #define UI_INPUT_FLAG_ECHO 0x01 |
|
157 /* Use a default password. Where that password is found is completely |
|
158 up to the application, it might for example be in the user data set |
|
159 with UI_add_user_data(). It is not recommended to have more than |
|
160 one input in each UI being marked with this flag, or the application |
|
161 might get confused. */ |
|
162 #define UI_INPUT_FLAG_DEFAULT_PWD 0x02 |
|
163 |
|
164 /* The user of these routines may want to define flags of their own. The core |
|
165 UI won't look at those, but will pass them on to the method routines. They |
|
166 must use higher bits so they don't get confused with the UI bits above. |
|
167 UI_INPUT_FLAG_USER_BASE tells which is the lowest bit to use. A good |
|
168 example of use is this: |
|
169 |
|
170 #define MY_UI_FLAG1 (0x01 << UI_INPUT_FLAG_USER_BASE) |
|
171 |
|
172 */ |
|
173 #define UI_INPUT_FLAG_USER_BASE 16 |
|
174 |
|
175 |
|
176 /* The following function helps construct a prompt. object_desc is a |
|
177 textual short description of the object, for example "pass phrase", |
|
178 and object_name is the name of the object (might be a card name or |
|
179 a file name. |
|
180 The returned string shall always be allocated on the heap with |
|
181 OPENSSL_malloc(), and need to be free'd with OPENSSL_free(). |
|
182 |
|
183 If the ui_method doesn't contain a pointer to a user-defined prompt |
|
184 constructor, a default string is built, looking like this: |
|
185 |
|
186 "Enter {object_desc} for {object_name}:" |
|
187 |
|
188 So, if object_desc has the value "pass phrase" and object_name has |
|
189 the value "foo.key", the resulting string is: |
|
190 |
|
191 "Enter pass phrase for foo.key:" |
|
192 */ |
|
193 IMPORT_C char *UI_construct_prompt(UI *ui_method, |
|
194 const char *object_desc, const char *object_name); |
|
195 |
|
196 |
|
197 /* The following function is used to store a pointer to user-specific data. |
|
198 Any previous such pointer will be returned and replaced. |
|
199 |
|
200 For callback purposes, this function makes a lot more sense than using |
|
201 ex_data, since the latter requires that different parts of OpenSSL or |
|
202 applications share the same ex_data index. |
|
203 |
|
204 Note that the UI_OpenSSL() method completely ignores the user data. |
|
205 Other methods may not, however. */ |
|
206 IMPORT_C void *UI_add_user_data(UI *ui, void *user_data); |
|
207 /* We need a user data retrieving function as well. */ |
|
208 IMPORT_C void *UI_get0_user_data(UI *ui); |
|
209 |
|
210 /* Return the result associated with a prompt given with the index i. */ |
|
211 IMPORT_C const char *UI_get0_result(UI *ui, int i); |
|
212 |
|
213 /* When all strings have been added, process the whole thing. */ |
|
214 IMPORT_C int UI_process(UI *ui); |
|
215 |
|
216 /* Give a user interface parametrised control commands. This can be used to |
|
217 send down an integer, a data pointer or a function pointer, as well as |
|
218 be used to get information from a UI. */ |
|
219 IMPORT_C int UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f)(void)); |
|
220 |
|
221 /* The commands */ |
|
222 /* Use UI_CONTROL_PRINT_ERRORS with the value 1 to have UI_process print the |
|
223 OpenSSL error stack before printing any info or added error messages and |
|
224 before any prompting. */ |
|
225 #define UI_CTRL_PRINT_ERRORS 1 |
|
226 /* Check if a UI_process() is possible to do again with the same instance of |
|
227 a user interface. This makes UI_ctrl() return 1 if it is redoable, and 0 |
|
228 if not. */ |
|
229 #define UI_CTRL_IS_REDOABLE 2 |
|
230 |
|
231 |
|
232 /* Some methods may use extra data */ |
|
233 #define UI_set_app_data(s,arg) UI_set_ex_data(s,0,arg) |
|
234 #define UI_get_app_data(s) UI_get_ex_data(s,0) |
|
235 IMPORT_C int UI_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func, |
|
236 CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func); |
|
237 IMPORT_C int UI_set_ex_data(UI *r,int idx,void *arg); |
|
238 IMPORT_C void *UI_get_ex_data(UI *r, int idx); |
|
239 |
|
240 /* Use specific methods instead of the built-in one */ |
|
241 IMPORT_C void UI_set_default_method(const UI_METHOD *meth); |
|
242 IMPORT_C const UI_METHOD *UI_get_default_method(void); |
|
243 IMPORT_C const UI_METHOD *UI_get_method(UI *ui); |
|
244 IMPORT_C const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth); |
|
245 |
|
246 /* The method with all the built-in thingies */ |
|
247 IMPORT_C UI_METHOD *UI_OpenSSL(void); |
|
248 |
|
249 |
|
250 /* ---------- For method writers ---------- */ |
|
251 /* A method contains a number of functions that implement the low level |
|
252 of the User Interface. The functions are: |
|
253 |
|
254 an opener This function starts a session, maybe by opening |
|
255 a channel to a tty, or by opening a window. |
|
256 a writer This function is called to write a given string, |
|
257 maybe to the tty, maybe as a field label in a |
|
258 window. |
|
259 a flusher This function is called to flush everything that |
|
260 has been output so far. It can be used to actually |
|
261 display a dialog box after it has been built. |
|
262 a reader This function is called to read a given prompt, |
|
263 maybe from the tty, maybe from a field in a |
|
264 window. Note that it's called wth all string |
|
265 structures, not only the prompt ones, so it must |
|
266 check such things itself. |
|
267 a closer This function closes the session, maybe by closing |
|
268 the channel to the tty, or closing the window. |
|
269 |
|
270 All these functions are expected to return: |
|
271 |
|
272 0 on error. |
|
273 1 on success. |
|
274 -1 on out-of-band events, for example if some prompting has |
|
275 been canceled (by pressing Ctrl-C, for example). This is |
|
276 only checked when returned by the flusher or the reader. |
|
277 |
|
278 The way this is used, the opener is first called, then the writer for all |
|
279 strings, then the flusher, then the reader for all strings and finally the |
|
280 closer. Note that if you want to prompt from a terminal or other command |
|
281 line interface, the best is to have the reader also write the prompts |
|
282 instead of having the writer do it. If you want to prompt from a dialog |
|
283 box, the writer can be used to build up the contents of the box, and the |
|
284 flusher to actually display the box and run the event loop until all data |
|
285 has been given, after which the reader only grabs the given data and puts |
|
286 them back into the UI strings. |
|
287 |
|
288 All method functions take a UI as argument. Additionally, the writer and |
|
289 the reader take a UI_STRING. |
|
290 */ |
|
291 |
|
292 /* The UI_STRING type is the data structure that contains all the needed info |
|
293 about a string or a prompt, including test data for a verification prompt. |
|
294 */ |
|
295 DECLARE_STACK_OF(UI_STRING) |
|
296 typedef struct ui_string_st UI_STRING; |
|
297 |
|
298 /* The different types of strings that are currently supported. |
|
299 This is only needed by method authors. */ |
|
300 enum UI_string_types |
|
301 { |
|
302 UIT_NONE=0, |
|
303 UIT_PROMPT, /* Prompt for a string */ |
|
304 UIT_VERIFY, /* Prompt for a string and verify */ |
|
305 UIT_BOOLEAN, /* Prompt for a yes/no response */ |
|
306 UIT_INFO, /* Send info to the user */ |
|
307 UIT_ERROR /* Send an error message to the user */ |
|
308 }; |
|
309 |
|
310 /* Create and manipulate methods */ |
|
311 IMPORT_C UI_METHOD *UI_create_method(char *name); |
|
312 IMPORT_C void UI_destroy_method(UI_METHOD *ui_method); |
|
313 IMPORT_C int UI_method_set_opener(UI_METHOD *method, int (*opener)(UI *ui)); |
|
314 IMPORT_C int UI_method_set_writer(UI_METHOD *method, int (*writer)(UI *ui, UI_STRING *uis)); |
|
315 IMPORT_C int UI_method_set_flusher(UI_METHOD *method, int (*flusher)(UI *ui)); |
|
316 IMPORT_C int UI_method_set_reader(UI_METHOD *method, int (*reader)(UI *ui, UI_STRING *uis)); |
|
317 IMPORT_C int UI_method_set_closer(UI_METHOD *method, int (*closer)(UI *ui)); |
|
318 IMPORT_C int (*UI_method_get_opener(UI_METHOD *method))(UI*); |
|
319 IMPORT_C int (*UI_method_get_writer(UI_METHOD *method))(UI*,UI_STRING*); |
|
320 IMPORT_C int (*UI_method_get_flusher(UI_METHOD *method))(UI*); |
|
321 IMPORT_C int (*UI_method_get_reader(UI_METHOD *method))(UI*,UI_STRING*); |
|
322 IMPORT_C int (*UI_method_get_closer(UI_METHOD *method))(UI*); |
|
323 |
|
324 /* The following functions are helpers for method writers to access relevant |
|
325 data from a UI_STRING. */ |
|
326 |
|
327 /* Return type of the UI_STRING */ |
|
328 IMPORT_C enum UI_string_types UI_get_string_type(UI_STRING *uis); |
|
329 /* Return input flags of the UI_STRING */ |
|
330 IMPORT_C int UI_get_input_flags(UI_STRING *uis); |
|
331 /* Return the actual string to output (the prompt, info or error) */ |
|
332 IMPORT_C const char *UI_get0_output_string(UI_STRING *uis); |
|
333 /* Return the optional action string to output (the boolean promtp instruction) */ |
|
334 IMPORT_C const char *UI_get0_action_string(UI_STRING *uis); |
|
335 /* Return the result of a prompt */ |
|
336 IMPORT_C const char *UI_get0_result_string(UI_STRING *uis); |
|
337 /* Return the string to test the result against. Only useful with verifies. */ |
|
338 IMPORT_C const char *UI_get0_test_string(UI_STRING *uis); |
|
339 /* Return the required minimum size of the result */ |
|
340 IMPORT_C int UI_get_result_minsize(UI_STRING *uis); |
|
341 /* Return the required maximum size of the result */ |
|
342 IMPORT_C int UI_get_result_maxsize(UI_STRING *uis); |
|
343 /* Set the result of a UI_STRING. */ |
|
344 IMPORT_C int UI_set_result(UI *ui, UI_STRING *uis, const char *result); |
|
345 |
|
346 |
|
347 /* A couple of popular utility functions */ |
|
348 IMPORT_C int UI_UTIL_read_pw_string(char *buf,int length,const char *prompt,int verify); |
|
349 IMPORT_C int UI_UTIL_read_pw(char *buf,char *buff,int size,const char *prompt,int verify); |
|
350 |
|
351 |
|
352 /* BEGIN ERROR CODES */ |
|
353 /* The following lines are auto generated by the script mkerr.pl. Any changes |
|
354 * made after this point may be overwritten when the script is next run. |
|
355 */ |
|
356 IMPORT_C void ERR_load_UI_strings(void); |
|
357 |
|
358 /* Error codes for the UI functions. */ |
|
359 |
|
360 /* Function codes. */ |
|
361 #define UI_F_GENERAL_ALLOCATE_BOOLEAN 108 |
|
362 #define UI_F_GENERAL_ALLOCATE_PROMPT 109 |
|
363 #define UI_F_GENERAL_ALLOCATE_STRING 100 |
|
364 #define UI_F_UI_CTRL 111 |
|
365 #define UI_F_UI_DUP_ERROR_STRING 101 |
|
366 #define UI_F_UI_DUP_INFO_STRING 102 |
|
367 #define UI_F_UI_DUP_INPUT_BOOLEAN 110 |
|
368 #define UI_F_UI_DUP_INPUT_STRING 103 |
|
369 #define UI_F_UI_DUP_VERIFY_STRING 106 |
|
370 #define UI_F_UI_GET0_RESULT 107 |
|
371 #define UI_F_UI_NEW_METHOD 104 |
|
372 #define UI_F_UI_SET_RESULT 105 |
|
373 |
|
374 /* Reason codes. */ |
|
375 #define UI_R_COMMON_OK_AND_CANCEL_CHARACTERS 104 |
|
376 #define UI_R_INDEX_TOO_LARGE 102 |
|
377 #define UI_R_INDEX_TOO_SMALL 103 |
|
378 #define UI_R_NO_RESULT_BUFFER 105 |
|
379 #define UI_R_RESULT_TOO_LARGE 100 |
|
380 #define UI_R_RESULT_TOO_SMALL 101 |
|
381 #define UI_R_UNKNOWN_CONTROL_COMMAND 106 |
|
382 |
|
383 #ifdef __cplusplus |
|
384 } |
|
385 #endif |
|
386 #endif |