395f700ffd66b6884cf7ab544f1d7f6736d0d06f
[openssl.git] / crypto / ui / ui_lib.c
1 /* crypto/ui/ui_lib.c -*- mode:C; c-file-style: "eay" -*- */
2 /* Written by Richard Levitte (levitte@stacken.kth.se) for the OpenSSL
3  * project 2000.
4  */
5 /* ====================================================================
6  * Copyright (c) 1998-2000 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 <openssl/e_os2.h>
61 #include <openssl/buffer.h>
62 #include <openssl/ui.h>
63 #include <openssl/err.h>
64 #include "ui_locl.h"
65
66 IMPLEMENT_STACK_OF(UI_STRING_ST)
67
68 static const UI_METHOD *default_UI_meth=NULL;
69 static int ui_meth_num=0;
70 static STACK_OF(CRYPTO_EX_DATA_FUNCS) *ui_meth=NULL;
71
72 UI *UI_new(void)
73         {
74         return(UI_new_method(NULL));
75         }
76
77 UI *UI_new_method(const UI_METHOD *method)
78         {
79         UI *ret;
80
81         ret=(UI *)OPENSSL_malloc(sizeof(UI));
82         if (ret == NULL)
83                 {
84                 UIerr(UI_F_UI_NEW_METHOD,ERR_R_MALLOC_FAILURE);
85                 return NULL;
86                 }
87         if (method == NULL)
88                 ret->meth=UI_get_default_method();
89         else
90                 ret->meth=method;
91
92         ret->strings=NULL;
93         ret->user_data=NULL;
94         CRYPTO_new_ex_data(ui_meth,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                 OPENSSL_free((char *)uis->out_string);
102         OPENSSL_free(uis);
103         }
104
105 void UI_free(UI *ui)
106         {
107         if (ui == NULL)
108                 return;
109         sk_UI_STRING_pop_free(ui->strings,free_string);
110         OPENSSL_free(ui);
111         }
112
113 static int allocate_string_stack(UI *ui)
114         {
115         if (ui->strings == NULL)
116                 {
117                 ui->strings=sk_UI_STRING_new_null();
118                 if (ui->strings == NULL)
119                         {
120                         return -1;
121                         }
122                 }
123         return 0;
124         }
125
126 static int general_allocate_string(UI *ui, const char *prompt,
127         int prompt_freeable, enum UI_string_types type, int input_flags,
128         char *result_buf, int minsize, int maxsize, const char *test_buf)
129         {
130         int ret=-1;
131
132         if (prompt == NULL)
133                 {
134                 UIerr(UI_F_GENERAL_ALLOCATE_STRING,ERR_R_PASSED_NULL_PARAMETER);
135                 }
136         else if (allocate_string_stack(ui) >= 0)
137                 {
138                 UI_STRING *s=(UI_STRING *)OPENSSL_malloc(sizeof(UI_STRING));
139                 s->out_string=prompt;
140                 s->flags=prompt_freeable ? OUT_STRING_FREEABLE : 0;
141                 s->input_flags=input_flags;
142                 s->type=type;
143                 s->result_buf=result_buf;
144                 s->result_minsize=minsize;
145                 s->result_maxsize=maxsize;
146                 s->test_buf=test_buf;
147                 ret=sk_UI_STRING_push(ui->strings, s);
148                 }
149         return ret;
150         }
151
152 /* Returns the index to the place in the stack or 0 for error.  Uses a
153    direct reference to the prompt.  */
154 int UI_add_input_string(UI *ui, const char *prompt, int flags,
155         char *result_buf, int minsize, int maxsize)
156         {
157         return general_allocate_string(ui, prompt, 0,
158                 UIT_PROMPT, flags, result_buf, minsize, maxsize, NULL);
159         }
160
161 /* Same as UI_add_input_string(), excepts it takes a copy of the prompt */
162 int UI_dup_input_string(UI *ui, const char *prompt, int flags,
163         char *result_buf, int minsize, int maxsize)
164         {
165         char *prompt_copy=NULL;
166
167         if (prompt)
168                 {
169                 prompt_copy=BUF_strdup(prompt);
170                 if (prompt_copy == NULL)
171                         {
172                         UIerr(UI_F_UI_DUP_INPUT_STRING,ERR_R_MALLOC_FAILURE);
173                         return 0;
174                         }
175                 }
176         
177         return general_allocate_string(ui, prompt_copy, 1,
178                 UIT_PROMPT, flags, result_buf, minsize, maxsize, NULL);
179         }
180
181 int UI_add_verify_string(UI *ui, const char *prompt, int flags,
182         char *result_buf, int minsize, int maxsize, const char *test_buf)
183         {
184         return general_allocate_string(ui, prompt, 0,
185                 UIT_VERIFY, flags, result_buf, minsize, maxsize, test_buf);
186         }
187
188 int UI_dup_verify_string(UI *ui, const char *prompt, int flags,
189         char *result_buf, int minsize, int maxsize, const char *test_buf)
190         {
191         char *prompt_copy=NULL;
192
193         if (prompt)
194                 {
195                 prompt_copy=BUF_strdup(prompt);
196                 if (prompt_copy == NULL)
197                         {
198                         UIerr(UI_F_UI_DUP_VERIFY_STRING,ERR_R_MALLOC_FAILURE);
199                         return -1;
200                         }
201                 }
202         
203         return general_allocate_string(ui, prompt_copy, 1,
204                 UIT_VERIFY, flags, result_buf, minsize, maxsize, test_buf);
205         }
206
207 int UI_add_info_string(UI *ui, const char *text)
208         {
209         return general_allocate_string(ui, text, 0, UIT_INFO, 0, NULL, 0, 0,
210                 NULL);
211         }
212
213 int UI_dup_info_string(UI *ui, const char *text)
214         {
215         char *text_copy=NULL;
216
217         if (text)
218                 {
219                 text_copy=BUF_strdup(text);
220                 if (text_copy == NULL)
221                         {
222                         UIerr(UI_F_UI_DUP_INFO_STRING,ERR_R_MALLOC_FAILURE);
223                         return -1;
224                         }
225                 }
226
227         return general_allocate_string(ui, text_copy, 1, UIT_INFO, 0, NULL, 0, 0,
228                 NULL);
229         }
230
231 int UI_add_error_string(UI *ui, const char *text)
232         {
233         return general_allocate_string(ui, text, 0, UIT_ERROR, 0, NULL, 0, 0,
234                 NULL);
235         }
236
237 int UI_dup_error_string(UI *ui, const char *text)
238         {
239         char *text_copy=NULL;
240
241         if (text)
242                 {
243                 text_copy=BUF_strdup(text);
244                 if (text_copy == NULL)
245                         {
246                         UIerr(UI_F_UI_DUP_ERROR_STRING,ERR_R_MALLOC_FAILURE);
247                         return -1;
248                         }
249                 }
250         return general_allocate_string(ui, text_copy, 1, UIT_ERROR, 0, NULL,
251                 0, 0, NULL);
252         }
253
254 char *UI_construct_prompt(UI *ui, const char *object_desc,
255         const char *object_name)
256         {
257         char *prompt = NULL;
258
259         if (ui->meth->ui_construct_prompt)
260                 prompt = ui->meth->ui_construct_prompt(ui,
261                         object_desc, object_name);
262         else
263                 {
264                 char prompt1[] = "Enter ";
265                 char prompt2[] = " for ";
266                 char prompt3[] = ":";
267                 int len = 0;
268
269                 if (object_desc == NULL)
270                         return NULL;
271                 len = sizeof(prompt1) - 1 + strlen(object_desc);
272                 if (object_name)
273                         len += sizeof(prompt2) - 1 + strlen(object_name);
274                 len += sizeof(prompt3) - 1;
275
276                 prompt = (char *)OPENSSL_malloc(len + 1);
277                 strcpy(prompt, prompt1);
278                 strcat(prompt, object_desc);
279                 if (object_name)
280                         {
281                         strcat(prompt, prompt2);
282                         strcat(prompt, object_name);
283                         }
284                 strcat(prompt, prompt3);
285                 }
286         return prompt;
287         }
288
289 void *UI_add_user_data(UI *ui, void *user_data)
290         {
291         void *old_data = ui->user_data;
292         ui->user_data = user_data;
293         return old_data;
294         }
295
296 void *UI_get0_user_data(UI *ui)
297         {
298         return ui->user_data;
299         }
300
301 const char *UI_get0_result(UI *ui, int i)
302         {
303         if (i < 0)
304                 {
305                 UIerr(UI_F_UI_GET0_RESULT,UI_R_INDEX_TOO_SMALL);
306                 return NULL;
307                 }
308         if (i >= sk_UI_STRING_num(ui->strings))
309                 {
310                 UIerr(UI_F_UI_GET0_RESULT,UI_R_INDEX_TOO_LARGE);
311                 return NULL;
312                 }
313         return UI_get0_result_string(sk_UI_STRING_value(ui->strings, i));
314         }
315
316 int UI_process(UI *ui)
317         {
318         int i, ok=0;
319
320         if (ui->meth->ui_open_session && !ui->meth->ui_open_session(ui))
321                 return -1;
322
323         for(i=0; i<sk_UI_STRING_num(ui->strings); i++)
324                 {
325                 if (ui->meth->ui_write_string
326                         && !ui->meth->ui_write_string(ui,
327                                 sk_UI_STRING_value(ui->strings, i)))
328                         {
329                         ok=-1;
330                         goto err;
331                         }
332                 }
333
334         if (ui->meth->ui_flush)
335                 switch(ui->meth->ui_flush(ui))
336                         {
337                 case -1: /* Interrupt/Cancel/something... */
338                         ok = -2;
339                         goto err;
340                 case 0: /* Errors */
341                         ok = -1;
342                         goto err;
343                 default: /* Success */
344                         ok = 0;
345                         break;
346                         }
347
348         for(i=0; i<sk_UI_STRING_num(ui->strings); i++)
349                 {
350                 if (ui->meth->ui_read_string)
351                         {
352                         switch(ui->meth->ui_read_string(ui,
353                                 sk_UI_STRING_value(ui->strings, i)))
354                                 {
355                         case -1: /* Interrupt/Cancel/something... */
356                                 ok = -2;
357                                 goto err;
358                         case 0: /* Errors */
359                                 ok = -1;
360                                 goto err;
361                         default: /* Success */
362                                 ok = 0;
363                                 break;
364                                 }
365                         }
366                 }
367  err:
368         if (ui->meth->ui_close_session && !ui->meth->ui_close_session(ui))
369                 return -1;
370         return ok;
371         }
372
373 int UI_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
374              CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
375         {
376         ui_meth_num++;
377         return(CRYPTO_get_ex_new_index(ui_meth_num-1,
378                 &ui_meth,argl,argp,new_func,dup_func,free_func));
379         }
380
381 int UI_set_ex_data(UI *r, int idx, void *arg)
382         {
383         return(CRYPTO_set_ex_data(&r->ex_data,idx,arg));
384         }
385
386 void *UI_get_ex_data(UI *r, int idx)
387         {
388         return(CRYPTO_get_ex_data(&r->ex_data,idx));
389         }
390
391 void UI_set_default_method(const UI_METHOD *meth)
392         {
393         default_UI_meth=meth;
394         }
395
396 const UI_METHOD *UI_get_default_method(void)
397         {
398         if (default_UI_meth == NULL)
399                 {
400                 default_UI_meth=UI_OpenSSL();
401                 }
402         return default_UI_meth;
403         }
404
405 const UI_METHOD *UI_get_method(UI *ui)
406         {
407         return ui->meth;
408         }
409
410 const UI_METHOD *UI_set_method(UI *ui, const UI_METHOD *meth)
411         {
412         ui->meth=meth;
413         return ui->meth;
414         }
415
416
417 UI_METHOD *UI_create_method(char *name)
418         {
419         UI_METHOD *ui_method = (UI_METHOD *)OPENSSL_malloc(sizeof(UI_METHOD));
420
421         if (ui_method)
422                 memset(ui_method, 0, sizeof(*ui_method));
423         ui_method->name = BUF_strdup(name);
424         return ui_method;
425         }
426
427 /* BIG FSCKING WARNING!!!!  If you use this on a statically allocated method
428    (that is, it hasn't been allocated using UI_create_method(), you deserve
429    anything Murphy can throw at you and more!  You have been warned. */
430 void UI_destroy_method(UI_METHOD *ui_method)
431         {
432         OPENSSL_free(ui_method->name);
433         ui_method->name = NULL;
434         OPENSSL_free(ui_method);
435         }
436
437 int UI_method_set_opener(UI_METHOD *method, int (*opener)(UI *ui))
438         {
439         if (method)
440                 {
441                 method->ui_open_session = opener;
442                 return 0;
443                 }
444         else
445                 return -1;
446         }
447
448 int UI_method_set_writer(UI_METHOD *method, int (*writer)(UI *ui, UI_STRING *uis))
449         {
450         if (method)
451                 {
452                 method->ui_write_string = writer;
453                 return 0;
454                 }
455         else
456                 return -1;
457         }
458
459 int UI_method_set_flusher(UI_METHOD *method, int (*flusher)(UI *ui))
460         {
461         if (method)
462                 {
463                 method->ui_flush = flusher;
464                 return 0;
465                 }
466         else
467                 return -1;
468         }
469
470 int UI_method_set_reader(UI_METHOD *method, int (*reader)(UI *ui, UI_STRING *uis))
471         {
472         if (method)
473                 {
474                 method->ui_read_string = reader;
475                 return 0;
476                 }
477         else
478                 return -1;
479         }
480
481 int UI_method_set_closer(UI_METHOD *method, int (*closer)(UI *ui))
482         {
483         if (method)
484                 {
485                 method->ui_close_session = closer;
486                 return 0;
487                 }
488         else
489                 return -1;
490         }
491
492 int (*UI_method_get_opener(UI_METHOD *method))(UI*)
493         {
494         if (method)
495                 return method->ui_open_session;
496         else
497                 return NULL;
498         }
499
500 int (*UI_method_get_writer(UI_METHOD *method))(UI*,UI_STRING*)
501         {
502         if (method)
503                 return method->ui_write_string;
504         else
505                 return NULL;
506         }
507
508 int (*UI_method_get_reader(UI_METHOD *method))(UI*,UI_STRING*)
509         {
510         if (method)
511                 return method->ui_read_string;
512         else
513                 return NULL;
514         }
515
516 int (*UI_method_get_closer(UI_METHOD *method))(UI*)
517         {
518         if (method)
519                 return method->ui_close_session;
520         else
521                 return NULL;
522         }
523
524 enum UI_string_types UI_get_string_type(UI_STRING *uis)
525         {
526         if (!uis)
527                 return UIT_NONE;
528         return uis->type;
529         }
530
531 int UI_get_input_flags(UI_STRING *uis)
532         {
533         if (!uis)
534                 return 0;
535         return uis->input_flags;
536         }
537
538 const char *UI_get0_output_string(UI_STRING *uis)
539         {
540         if (!uis)
541                 return NULL;
542         return uis->out_string;
543         }
544
545 const char *UI_get0_result_string(UI_STRING *uis)
546         {
547         if (!uis)
548                 return NULL;
549         switch(uis->type)
550                 {
551         case UIT_PROMPT:
552         case UIT_VERIFY:
553                 return uis->result_buf;
554         default:
555                 return NULL;
556                 }
557         }
558
559 const char *UI_get0_test_string(UI_STRING *uis)
560         {
561         if (!uis)
562                 return NULL;
563         return uis->test_buf;
564         }
565
566 int UI_get_result_minsize(UI_STRING *uis)
567         {
568         if (!uis)
569                 return -1;
570         return uis->result_minsize;
571         }
572
573 int UI_get_result_maxsize(UI_STRING *uis)
574         {
575         if (!uis)
576                 return -1;
577         return uis->result_maxsize;
578         }
579
580 int UI_set_result(UI_STRING *uis, const char *result)
581         {
582         int l = strlen(result);
583
584         if (!uis)
585                 return -1;
586         if (l < uis->result_minsize)
587                 {
588                 UIerr(UI_F_UI_SET_RESULT,UI_R_RESULT_TOO_SMALL);
589                 return -1;
590                 }
591         if (l > uis->result_maxsize)
592                 {
593                 UIerr(UI_F_UI_SET_RESULT,UI_R_RESULT_TOO_LARGE);
594                 return -1;
595                 }
596
597         if (!uis->result_buf)
598                 {
599                 uis->result_buf = OPENSSL_malloc(uis->result_maxsize+1);
600                 }
601
602         if (!uis->result_buf)
603                 {
604                 UIerr(UI_F_UI_NEW_METHOD,ERR_R_MALLOC_FAILURE);
605                 return -1;
606                 }
607
608         strcpy(uis->result_buf, result);
609         return 0;
610         }