Line data Source code
1 : /* conf_mod.c */
2 : /*
3 : * Written by Stephen Henson (steve@openssl.org) for the OpenSSL project
4 : * 2001.
5 : */
6 : /* ====================================================================
7 : * Copyright (c) 2001 The OpenSSL Project. All rights reserved.
8 : *
9 : * Redistribution and use in source and binary forms, with or without
10 : * modification, are permitted provided that the following conditions
11 : * are met:
12 : *
13 : * 1. Redistributions of source code must retain the above copyright
14 : * notice, this list of conditions and the following disclaimer.
15 : *
16 : * 2. Redistributions in binary form must reproduce the above copyright
17 : * notice, this list of conditions and the following disclaimer in
18 : * the documentation and/or other materials provided with the
19 : * distribution.
20 : *
21 : * 3. All advertising materials mentioning features or use of this
22 : * software must display the following acknowledgment:
23 : * "This product includes software developed by the OpenSSL Project
24 : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25 : *
26 : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27 : * endorse or promote products derived from this software without
28 : * prior written permission. For written permission, please contact
29 : * licensing@OpenSSL.org.
30 : *
31 : * 5. Products derived from this software may not be called "OpenSSL"
32 : * nor may "OpenSSL" appear in their names without prior written
33 : * permission of the OpenSSL Project.
34 : *
35 : * 6. Redistributions of any form whatsoever must retain the following
36 : * acknowledgment:
37 : * "This product includes software developed by the OpenSSL Project
38 : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 : *
40 : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41 : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43 : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
44 : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47 : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 : * OF THE POSSIBILITY OF SUCH DAMAGE.
52 : * ====================================================================
53 : *
54 : * This product includes cryptographic software written by Eric Young
55 : * (eay@cryptsoft.com). This product includes software written by Tim
56 : * Hudson (tjh@cryptsoft.com).
57 : *
58 : */
59 :
60 : #include <stdio.h>
61 : #include <ctype.h>
62 : #include <openssl/crypto.h>
63 : #include "cryptlib.h"
64 : #include <openssl/conf.h>
65 : #include <openssl/dso.h>
66 : #include <openssl/x509.h>
67 :
68 : #define DSO_mod_init_name "OPENSSL_init"
69 : #define DSO_mod_finish_name "OPENSSL_finish"
70 :
71 : /*
72 : * This structure contains a data about supported modules. entries in this
73 : * table correspond to either dynamic or static modules.
74 : */
75 :
76 : struct conf_module_st {
77 : /* DSO of this module or NULL if static */
78 : DSO *dso;
79 : /* Name of the module */
80 : char *name;
81 : /* Init function */
82 : conf_init_func *init;
83 : /* Finish function */
84 : conf_finish_func *finish;
85 : /* Number of successfully initialized modules */
86 : int links;
87 : void *usr_data;
88 : };
89 :
90 : /*
91 : * This structure contains information about modules that have been
92 : * successfully initialized. There may be more than one entry for a given
93 : * module.
94 : */
95 :
96 : struct conf_imodule_st {
97 : CONF_MODULE *pmod;
98 : char *name;
99 : char *value;
100 : unsigned long flags;
101 : void *usr_data;
102 : };
103 :
104 : static STACK_OF(CONF_MODULE) *supported_modules = NULL;
105 : static STACK_OF(CONF_IMODULE) *initialized_modules = NULL;
106 :
107 : static void module_free(CONF_MODULE *md);
108 : static void module_finish(CONF_IMODULE *imod);
109 : static int module_run(const CONF *cnf, char *name, char *value,
110 : unsigned long flags);
111 : static CONF_MODULE *module_add(DSO *dso, const char *name,
112 : conf_init_func *ifunc,
113 : conf_finish_func *ffunc);
114 : static CONF_MODULE *module_find(char *name);
115 : static int module_init(CONF_MODULE *pmod, char *name, char *value,
116 : const CONF *cnf);
117 : static CONF_MODULE *module_load_dso(const CONF *cnf, char *name, char *value,
118 : unsigned long flags);
119 :
120 : /* Main function: load modules from a CONF structure */
121 :
122 0 : int CONF_modules_load(const CONF *cnf, const char *appname,
123 : unsigned long flags)
124 : {
125 : STACK_OF(CONF_VALUE) *values;
126 : CONF_VALUE *vl;
127 : char *vsection = NULL;
128 :
129 : int ret, i;
130 :
131 0 : if (!cnf)
132 : return 1;
133 :
134 0 : if (appname)
135 0 : vsection = NCONF_get_string(cnf, NULL, appname);
136 :
137 0 : if (!appname || (!vsection && (flags & CONF_MFLAGS_DEFAULT_SECTION)))
138 0 : vsection = NCONF_get_string(cnf, NULL, "openssl_conf");
139 :
140 0 : if (!vsection) {
141 0 : ERR_clear_error();
142 0 : return 1;
143 : }
144 :
145 0 : values = NCONF_get_section(cnf, vsection);
146 :
147 0 : if (!values)
148 : return 0;
149 :
150 0 : for (i = 0; i < sk_CONF_VALUE_num(values); i++) {
151 0 : vl = sk_CONF_VALUE_value(values, i);
152 0 : ret = module_run(cnf, vl->name, vl->value, flags);
153 0 : if (ret <= 0)
154 0 : if (!(flags & CONF_MFLAGS_IGNORE_ERRORS))
155 : return ret;
156 : }
157 :
158 : return 1;
159 :
160 : }
161 :
162 0 : int CONF_modules_load_file(const char *filename, const char *appname,
163 : unsigned long flags)
164 : {
165 : char *file = NULL;
166 : CONF *conf = NULL;
167 : int ret = 0;
168 0 : conf = NCONF_new(NULL);
169 0 : if (!conf)
170 : goto err;
171 :
172 0 : if (filename == NULL) {
173 0 : file = CONF_get1_default_config_file();
174 0 : if (!file)
175 : goto err;
176 : } else
177 : file = (char *)filename;
178 :
179 0 : if (NCONF_load(conf, file, NULL) <= 0) {
180 0 : if ((flags & CONF_MFLAGS_IGNORE_MISSING_FILE) &&
181 0 : (ERR_GET_REASON(ERR_peek_last_error()) == CONF_R_NO_SUCH_FILE)) {
182 0 : ERR_clear_error();
183 : ret = 1;
184 : }
185 : goto err;
186 : }
187 :
188 0 : ret = CONF_modules_load(conf, appname, flags);
189 :
190 : err:
191 0 : if (filename == NULL)
192 0 : OPENSSL_free(file);
193 0 : NCONF_free(conf);
194 :
195 0 : return ret;
196 : }
197 :
198 0 : static int module_run(const CONF *cnf, char *name, char *value,
199 : unsigned long flags)
200 : {
201 : CONF_MODULE *md;
202 : int ret;
203 :
204 0 : md = module_find(name);
205 :
206 : /* Module not found: try to load DSO */
207 0 : if (!md && !(flags & CONF_MFLAGS_NO_DSO))
208 0 : md = module_load_dso(cnf, name, value, flags);
209 :
210 0 : if (!md) {
211 0 : if (!(flags & CONF_MFLAGS_SILENT)) {
212 0 : CONFerr(CONF_F_MODULE_RUN, CONF_R_UNKNOWN_MODULE_NAME);
213 0 : ERR_add_error_data(2, "module=", name);
214 : }
215 : return -1;
216 : }
217 :
218 0 : ret = module_init(md, name, value, cnf);
219 :
220 0 : if (ret <= 0) {
221 0 : if (!(flags & CONF_MFLAGS_SILENT)) {
222 : char rcode[DECIMAL_SIZE(ret) + 1];
223 0 : CONFerr(CONF_F_MODULE_RUN, CONF_R_MODULE_INITIALIZATION_ERROR);
224 0 : BIO_snprintf(rcode, sizeof rcode, "%-8d", ret);
225 0 : ERR_add_error_data(6, "module=", name, ", value=", value,
226 : ", retcode=", rcode);
227 : }
228 : }
229 :
230 0 : return ret;
231 : }
232 :
233 : /* Load a module from a DSO */
234 0 : static CONF_MODULE *module_load_dso(const CONF *cnf, char *name, char *value,
235 : unsigned long flags)
236 : {
237 : DSO *dso = NULL;
238 : conf_init_func *ifunc;
239 : conf_finish_func *ffunc;
240 : char *path = NULL;
241 : int errcode = 0;
242 : CONF_MODULE *md;
243 : /* Look for alternative path in module section */
244 0 : path = NCONF_get_string(cnf, value, "path");
245 0 : if (!path) {
246 0 : ERR_clear_error();
247 : path = name;
248 : }
249 0 : dso = DSO_load(NULL, path, NULL, 0);
250 0 : if (!dso) {
251 : errcode = CONF_R_ERROR_LOADING_DSO;
252 : goto err;
253 : }
254 0 : ifunc = (conf_init_func *)DSO_bind_func(dso, DSO_mod_init_name);
255 0 : if (!ifunc) {
256 : errcode = CONF_R_MISSING_INIT_FUNCTION;
257 : goto err;
258 : }
259 0 : ffunc = (conf_finish_func *)DSO_bind_func(dso, DSO_mod_finish_name);
260 : /* All OK, add module */
261 0 : md = module_add(dso, name, ifunc, ffunc);
262 :
263 0 : if (!md)
264 : goto err;
265 :
266 : return md;
267 :
268 : err:
269 0 : if (dso)
270 0 : DSO_free(dso);
271 0 : CONFerr(CONF_F_MODULE_LOAD_DSO, errcode);
272 0 : ERR_add_error_data(4, "module=", name, ", path=", path);
273 : return NULL;
274 : }
275 :
276 : /* add module to list */
277 0 : static CONF_MODULE *module_add(DSO *dso, const char *name,
278 : conf_init_func *ifunc, conf_finish_func *ffunc)
279 : {
280 : CONF_MODULE *tmod = NULL;
281 0 : if (supported_modules == NULL)
282 0 : supported_modules = sk_CONF_MODULE_new_null();
283 0 : if (supported_modules == NULL)
284 : return NULL;
285 0 : tmod = OPENSSL_malloc(sizeof(CONF_MODULE));
286 0 : if (tmod == NULL)
287 : return NULL;
288 :
289 0 : tmod->dso = dso;
290 0 : tmod->name = BUF_strdup(name);
291 0 : tmod->init = ifunc;
292 0 : tmod->finish = ffunc;
293 0 : tmod->links = 0;
294 :
295 0 : if (!sk_CONF_MODULE_push(supported_modules, tmod)) {
296 0 : OPENSSL_free(tmod);
297 0 : return NULL;
298 : }
299 :
300 : return tmod;
301 : }
302 :
303 : /*
304 : * Find a module from the list. We allow module names of the form
305 : * modname.XXXX to just search for modname to allow the same module to be
306 : * initialized more than once.
307 : */
308 :
309 0 : static CONF_MODULE *module_find(char *name)
310 : {
311 : CONF_MODULE *tmod;
312 : int i, nchar;
313 : char *p;
314 0 : p = strrchr(name, '.');
315 :
316 0 : if (p)
317 0 : nchar = p - name;
318 : else
319 0 : nchar = strlen(name);
320 :
321 0 : for (i = 0; i < sk_CONF_MODULE_num(supported_modules); i++) {
322 0 : tmod = sk_CONF_MODULE_value(supported_modules, i);
323 0 : if (!strncmp(tmod->name, name, nchar))
324 : return tmod;
325 : }
326 :
327 : return NULL;
328 :
329 : }
330 :
331 : /* initialize a module */
332 0 : static int module_init(CONF_MODULE *pmod, char *name, char *value,
333 : const CONF *cnf)
334 : {
335 : int ret = 1;
336 : int init_called = 0;
337 : CONF_IMODULE *imod = NULL;
338 :
339 : /* Otherwise add initialized module to list */
340 0 : imod = OPENSSL_malloc(sizeof(CONF_IMODULE));
341 0 : if (!imod)
342 : goto err;
343 :
344 0 : imod->pmod = pmod;
345 0 : imod->name = BUF_strdup(name);
346 0 : imod->value = BUF_strdup(value);
347 0 : imod->usr_data = NULL;
348 :
349 0 : if (!imod->name || !imod->value)
350 : goto memerr;
351 :
352 : /* Try to initialize module */
353 0 : if (pmod->init) {
354 0 : ret = pmod->init(imod, cnf);
355 : init_called = 1;
356 : /* Error occurred, exit */
357 0 : if (ret <= 0)
358 : goto err;
359 : }
360 :
361 0 : if (initialized_modules == NULL) {
362 0 : initialized_modules = sk_CONF_IMODULE_new_null();
363 0 : if (!initialized_modules) {
364 0 : CONFerr(CONF_F_MODULE_INIT, ERR_R_MALLOC_FAILURE);
365 0 : goto err;
366 : }
367 : }
368 :
369 0 : if (!sk_CONF_IMODULE_push(initialized_modules, imod)) {
370 0 : CONFerr(CONF_F_MODULE_INIT, ERR_R_MALLOC_FAILURE);
371 0 : goto err;
372 : }
373 :
374 0 : pmod->links++;
375 :
376 0 : return ret;
377 :
378 : err:
379 :
380 : /* We've started the module so we'd better finish it */
381 0 : if (pmod->finish && init_called)
382 0 : pmod->finish(imod);
383 :
384 : memerr:
385 0 : if (imod) {
386 0 : if (imod->name)
387 0 : OPENSSL_free(imod->name);
388 0 : if (imod->value)
389 0 : OPENSSL_free(imod->value);
390 0 : OPENSSL_free(imod);
391 : }
392 :
393 : return -1;
394 :
395 : }
396 :
397 : /*
398 : * Unload any dynamic modules that have a link count of zero: i.e. have no
399 : * active initialized modules. If 'all' is set then all modules are unloaded
400 : * including static ones.
401 : */
402 :
403 0 : void CONF_modules_unload(int all)
404 : {
405 : int i;
406 : CONF_MODULE *md;
407 0 : CONF_modules_finish();
408 : /* unload modules in reverse order */
409 0 : for (i = sk_CONF_MODULE_num(supported_modules) - 1; i >= 0; i--) {
410 0 : md = sk_CONF_MODULE_value(supported_modules, i);
411 : /* If static or in use and 'all' not set ignore it */
412 0 : if (((md->links > 0) || !md->dso) && !all)
413 0 : continue;
414 : /* Since we're working in reverse this is OK */
415 0 : (void)sk_CONF_MODULE_delete(supported_modules, i);
416 0 : module_free(md);
417 : }
418 0 : if (sk_CONF_MODULE_num(supported_modules) == 0) {
419 0 : sk_CONF_MODULE_free(supported_modules);
420 0 : supported_modules = NULL;
421 : }
422 0 : }
423 :
424 : /* unload a single module */
425 0 : static void module_free(CONF_MODULE *md)
426 : {
427 0 : if (md->dso)
428 0 : DSO_free(md->dso);
429 0 : OPENSSL_free(md->name);
430 0 : OPENSSL_free(md);
431 0 : }
432 :
433 : /* finish and free up all modules instances */
434 :
435 0 : void CONF_modules_finish(void)
436 : {
437 : CONF_IMODULE *imod;
438 0 : while (sk_CONF_IMODULE_num(initialized_modules) > 0) {
439 0 : imod = sk_CONF_IMODULE_pop(initialized_modules);
440 0 : module_finish(imod);
441 : }
442 0 : sk_CONF_IMODULE_free(initialized_modules);
443 0 : initialized_modules = NULL;
444 0 : }
445 :
446 : /* finish a module instance */
447 :
448 0 : static void module_finish(CONF_IMODULE *imod)
449 : {
450 0 : if (imod->pmod->finish)
451 0 : imod->pmod->finish(imod);
452 0 : imod->pmod->links--;
453 0 : OPENSSL_free(imod->name);
454 0 : OPENSSL_free(imod->value);
455 0 : OPENSSL_free(imod);
456 0 : }
457 :
458 : /* Add a static module to OpenSSL */
459 :
460 0 : int CONF_module_add(const char *name, conf_init_func *ifunc,
461 : conf_finish_func *ffunc)
462 : {
463 0 : if (module_add(NULL, name, ifunc, ffunc))
464 : return 1;
465 : else
466 0 : return 0;
467 : }
468 :
469 0 : void CONF_modules_free(void)
470 : {
471 0 : CONF_modules_finish();
472 0 : CONF_modules_unload(1);
473 0 : }
474 :
475 : /* Utility functions */
476 :
477 0 : const char *CONF_imodule_get_name(const CONF_IMODULE *md)
478 : {
479 0 : return md->name;
480 : }
481 :
482 0 : const char *CONF_imodule_get_value(const CONF_IMODULE *md)
483 : {
484 0 : return md->value;
485 : }
486 :
487 0 : void *CONF_imodule_get_usr_data(const CONF_IMODULE *md)
488 : {
489 0 : return md->usr_data;
490 : }
491 :
492 0 : void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data)
493 : {
494 0 : md->usr_data = usr_data;
495 0 : }
496 :
497 0 : CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md)
498 : {
499 0 : return md->pmod;
500 : }
501 :
502 0 : unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md)
503 : {
504 0 : return md->flags;
505 : }
506 :
507 0 : void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags)
508 : {
509 0 : md->flags = flags;
510 0 : }
511 :
512 0 : void *CONF_module_get_usr_data(CONF_MODULE *pmod)
513 : {
514 0 : return pmod->usr_data;
515 : }
516 :
517 0 : void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data)
518 : {
519 0 : pmod->usr_data = usr_data;
520 0 : }
521 :
522 : /* Return default config file name */
523 :
524 0 : char *CONF_get1_default_config_file(void)
525 : {
526 : char *file;
527 : int len;
528 :
529 0 : file = getenv("OPENSSL_CONF");
530 0 : if (file)
531 0 : return BUF_strdup(file);
532 :
533 0 : len = strlen(X509_get_default_cert_area());
534 : #ifndef OPENSSL_SYS_VMS
535 0 : len++;
536 : #endif
537 0 : len += strlen(OPENSSL_CONF);
538 :
539 0 : file = OPENSSL_malloc(len + 1);
540 :
541 0 : if (!file)
542 : return NULL;
543 0 : BUF_strlcpy(file, X509_get_default_cert_area(), len + 1);
544 : #ifndef OPENSSL_SYS_VMS
545 0 : BUF_strlcat(file, "/", len + 1);
546 : #endif
547 0 : BUF_strlcat(file, OPENSSL_CONF, len + 1);
548 :
549 0 : return file;
550 : }
551 :
552 : /*
553 : * This function takes a list separated by 'sep' and calls the callback
554 : * function giving the start and length of each member optionally stripping
555 : * leading and trailing whitespace. This can be used to parse comma separated
556 : * lists for example.
557 : */
558 :
559 0 : int CONF_parse_list(const char *list_, int sep, int nospc,
560 : int (*list_cb) (const char *elem, int len, void *usr),
561 : void *arg)
562 : {
563 : int ret;
564 : const char *lstart, *tmpend, *p;
565 :
566 0 : if (list_ == NULL) {
567 0 : CONFerr(CONF_F_CONF_PARSE_LIST, CONF_R_LIST_CANNOT_BE_NULL);
568 0 : return 0;
569 : }
570 :
571 : lstart = list_;
572 : for (;;) {
573 0 : if (nospc) {
574 0 : while (*lstart && isspace((unsigned char)*lstart))
575 0 : lstart++;
576 : }
577 0 : p = strchr(lstart, sep);
578 0 : if (p == lstart || !*lstart)
579 0 : ret = list_cb(NULL, 0, arg);
580 : else {
581 0 : if (p)
582 0 : tmpend = p - 1;
583 : else
584 0 : tmpend = lstart + strlen(lstart) - 1;
585 0 : if (nospc) {
586 0 : while (isspace((unsigned char)*tmpend))
587 0 : tmpend--;
588 : }
589 0 : ret = list_cb(lstart, tmpend - lstart + 1, arg);
590 : }
591 0 : if (ret <= 0)
592 : return ret;
593 0 : if (p == NULL)
594 : return 1;
595 0 : lstart = p + 1;
596 0 : }
597 : }
|
