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