Import of openssl-0.9.8, a feature release.
[dragonfly.git] / crypto / openssl-0.9 / crypto / engine / eng_cnf.c
1 /* eng_cnf.c */
2 /* Written by Stephen Henson (shenson@bigfoot.com) 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  *    licensing@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 "eng_int.h"
60 #include <openssl/conf.h>
61
62 /* #define ENGINE_CONF_DEBUG */
63
64 /* ENGINE config module */
65
66 static char *skip_dot(char *name)
67         {
68         char *p;
69         p = strchr(name, '.');
70         if (p)
71                 return p + 1;
72         return name;
73         }
74
75 static STACK_OF(ENGINE) *initialized_engines = NULL;
76
77 static int int_engine_init(ENGINE *e)
78         {
79         if (!ENGINE_init(e))
80                 return 0;
81         if (!initialized_engines)
82                 initialized_engines = sk_ENGINE_new_null();
83         if (!initialized_engines || !sk_ENGINE_push(initialized_engines, e))
84                 {
85                 ENGINE_finish(e);
86                 return 0;
87                 }
88         return 1;
89         }
90         
91
92 static int int_engine_configure(char *name, char *value, const CONF *cnf)
93         {
94         int i;
95         int ret = 0;
96         long do_init = -1;
97         STACK_OF(CONF_VALUE) *ecmds;
98         CONF_VALUE *ecmd;
99         char *ctrlname, *ctrlvalue;
100         ENGINE *e = NULL;
101         name = skip_dot(name);
102 #ifdef ENGINE_CONF_DEBUG
103         fprintf(stderr, "Configuring engine %s\n", name);
104 #endif
105         /* Value is a section containing ENGINE commands */
106         ecmds = NCONF_get_section(cnf, value);
107
108         if (!ecmds)
109                 {
110                 ENGINEerr(ENGINE_F_INT_ENGINE_CONFIGURE, ENGINE_R_ENGINE_SECTION_ERROR);
111                 return 0;
112                 }
113
114         for (i = 0; i < sk_CONF_VALUE_num(ecmds); i++)
115                 {
116                 ecmd = sk_CONF_VALUE_value(ecmds, i);
117                 ctrlname = skip_dot(ecmd->name);
118                 ctrlvalue = ecmd->value;
119 #ifdef ENGINE_CONF_DEBUG
120         fprintf(stderr, "ENGINE conf: doing ctrl(%s,%s)\n", ctrlname, ctrlvalue);
121 #endif
122
123                 /* First handle some special pseudo ctrls */
124
125                 /* Override engine name to use */
126                 if (!strcmp(ctrlname, "engine_id"))
127                         name = ctrlvalue;
128                 /* Load a dynamic ENGINE */
129                 else if (!strcmp(ctrlname, "dynamic_path"))
130                         {
131                         e = ENGINE_by_id("dynamic");
132                         if (!e)
133                                 goto err;
134                         if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", ctrlvalue, 0))
135                                 goto err;
136                         if (!ENGINE_ctrl_cmd_string(e, "LIST_ADD", "2", 0))
137                                 goto err;
138                         if (!ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0))
139                                 goto err;
140                         }
141                 /* ... add other pseudos here ... */
142                 else
143                         {
144                         /* At this point we need an ENGINE structural reference
145                          * if we don't already have one.
146                          */
147                         if (!e)
148                                 {
149                                 e = ENGINE_by_id(name);
150                                 if (!e)
151                                         return 0;
152                                 }
153                         /* Allow "EMPTY" to mean no value: this allows a valid
154                          * "value" to be passed to ctrls of type NO_INPUT
155                          */
156                         if (!strcmp(ctrlvalue, "EMPTY"))
157                                 ctrlvalue = NULL;
158                         if (!strcmp(ctrlname, "init"))
159                                 {
160                                 if (!NCONF_get_number_e(cnf, value, "init", &do_init))
161                                         goto err;
162                                 if (do_init == 1)
163                                         {
164                                         if (!int_engine_init(e))
165                                                 goto err;
166                                         }
167                                 else if (do_init != 0)
168                                         {
169                                         ENGINEerr(ENGINE_F_INT_ENGINE_CONFIGURE, ENGINE_R_INVALID_INIT_VALUE);
170                                         goto err;
171                                         }
172                                 }
173                         else if (!strcmp(ctrlname, "default_algorithms"))
174                                 {
175                                 if (!ENGINE_set_default_string(e, ctrlvalue))
176                                         goto err;
177                                 }
178                         else if (!ENGINE_ctrl_cmd_string(e,
179                                         ctrlname, ctrlvalue, 0))
180                                 return 0;
181                         }
182
183
184
185                 }
186         if (e && (do_init == -1) && !int_engine_init(e))
187                 goto err;
188         ret = 1;
189         err:
190         if (e)
191                 ENGINE_free(e);
192         return ret;
193         }
194
195
196 static int int_engine_module_init(CONF_IMODULE *md, const CONF *cnf)
197         {
198         STACK_OF(CONF_VALUE) *elist;
199         CONF_VALUE *cval;
200         int i;
201 #ifdef ENGINE_CONF_DEBUG
202         fprintf(stderr, "Called engine module: name %s, value %s\n",
203                         CONF_imodule_get_name(md), CONF_imodule_get_value(md));
204 #endif
205         /* Value is a section containing ENGINEs to configure */
206         elist = NCONF_get_section(cnf, CONF_imodule_get_value(md));
207
208         if (!elist)
209                 {
210                 ENGINEerr(ENGINE_F_INT_ENGINE_MODULE_INIT, ENGINE_R_ENGINES_SECTION_ERROR);
211                 return 0;
212                 }
213
214         for (i = 0; i < sk_CONF_VALUE_num(elist); i++)
215                 {
216                 cval = sk_CONF_VALUE_value(elist, i);
217                 if (!int_engine_configure(cval->name, cval->value, cnf))
218                         return 0;
219                 }
220
221         return 1;
222         }
223
224 static void int_engine_module_finish(CONF_IMODULE *md)
225         {
226         ENGINE *e;
227         while ((e = sk_ENGINE_pop(initialized_engines)))
228                 ENGINE_finish(e);
229         sk_ENGINE_free(initialized_engines);
230         initialized_engines = NULL;
231         }
232         
233
234 void ENGINE_add_conf_module(void)
235         {
236         CONF_module_add("engines",
237                         int_engine_module_init,
238                         int_engine_module_finish);
239         }