conf_mod.c revision 296465 
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
76struct 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
96struct conf_imodule_st {
97    CONF_MODULE *pmod;
98    char *name;
99    char *value;
100    unsigned long flags;
101    void *usr_data;
102};
103
104static STACK_OF(CONF_MODULE) *supported_modules = NULL;
105static STACK_OF(CONF_IMODULE) *initialized_modules = NULL;
106
107static void module_free(CONF_MODULE *md);
108static void module_finish(CONF_IMODULE *imod);
109static int module_run(const CONF *cnf, char *name, char *value,
110                      unsigned long flags);
111static CONF_MODULE *module_add(DSO *dso, const char *name,
112                               conf_init_func *ifunc,
113                               conf_finish_func *ffunc);
114static CONF_MODULE *module_find(char *name);
115static int module_init(CONF_MODULE *pmod, char *name, char *value,
116                       const CONF *cnf);
117static 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
122int 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    if (!cnf)
132        return 1;
133
134    if (appname)
135        vsection = NCONF_get_string(cnf, NULL, appname);
136
137    if (!appname || (!vsection && (flags & CONF_MFLAGS_DEFAULT_SECTION)))
138        vsection = NCONF_get_string(cnf, NULL, "openssl_conf");
139
140    if (!vsection) {
141        ERR_clear_error();
142        return 1;
143    }
144
145    values = NCONF_get_section(cnf, vsection);
146
147    if (!values)
148        return 0;
149
150    for (i = 0; i < sk_CONF_VALUE_num(values); i++) {
151        vl = sk_CONF_VALUE_value(values, i);
152        ret = module_run(cnf, vl->name, vl->value, flags);
153        if (ret <= 0)
154            if (!(flags & CONF_MFLAGS_IGNORE_ERRORS))
155                return ret;
156    }
157
158    return 1;
159
160}
161
162int 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    conf = NCONF_new(NULL);
169    if (!conf)
170        goto err;
171
172    if (filename == NULL) {
173        file = CONF_get1_default_config_file();
174        if (!file)
175            goto err;
176    } else
177        file = (char *)filename;
178
179    if (NCONF_load(conf, file, NULL) <= 0) {
180        if ((flags & CONF_MFLAGS_IGNORE_MISSING_FILE) &&
181            (ERR_GET_REASON(ERR_peek_last_error()) == CONF_R_NO_SUCH_FILE)) {
182            ERR_clear_error();
183            ret = 1;
184        }
185        goto err;
186    }
187
188    ret = CONF_modules_load(conf, appname, flags);
189
190 err:
191    if (filename == NULL)
192        OPENSSL_free(file);
193    NCONF_free(conf);
194
195    return ret;
196}
197
198static int module_run(const CONF *cnf, char *name, char *value,
199                      unsigned long flags)
200{
201    CONF_MODULE *md;
202    int ret;
203
204    md = module_find(name);
205
206    /* Module not found: try to load DSO */
207    if (!md && !(flags & CONF_MFLAGS_NO_DSO))
208        md = module_load_dso(cnf, name, value, flags);
209
210    if (!md) {
211        if (!(flags & CONF_MFLAGS_SILENT)) {
212            CONFerr(CONF_F_MODULE_RUN, CONF_R_UNKNOWN_MODULE_NAME);
213            ERR_add_error_data(2, "module=", name);
214        }
215        return -1;
216    }
217
218    ret = module_init(md, name, value, cnf);
219
220    if (ret <= 0) {
221        if (!(flags & CONF_MFLAGS_SILENT)) {
222            char rcode[DECIMAL_SIZE(ret) + 1];
223            CONFerr(CONF_F_MODULE_RUN, CONF_R_MODULE_INITIALIZATION_ERROR);
224            BIO_snprintf(rcode, sizeof rcode, "%-8d", ret);
225            ERR_add_error_data(6, "module=", name, ", value=", value,
226                               ", retcode=", rcode);
227        }
228    }
229
230    return ret;
231}
232
233/* Load a module from a DSO */
234static 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    path = NCONF_get_string(cnf, value, "path");
245    if (!path) {
246        ERR_clear_error();
247        path = name;
248    }
249    dso = DSO_load(NULL, path, NULL, 0);
250    if (!dso) {
251        errcode = CONF_R_ERROR_LOADING_DSO;
252        goto err;
253    }
254    ifunc = (conf_init_func *)DSO_bind_func(dso, DSO_mod_init_name);
255    if (!ifunc) {
256        errcode = CONF_R_MISSING_INIT_FUNCTION;
257        goto err;
258    }
259    ffunc = (conf_finish_func *)DSO_bind_func(dso, DSO_mod_finish_name);
260    /* All OK, add module */
261    md = module_add(dso, name, ifunc, ffunc);
262
263    if (!md)
264        goto err;
265
266    return md;
267
268 err:
269    if (dso)
270        DSO_free(dso);
271    CONFerr(CONF_F_MODULE_LOAD_DSO, errcode);
272    ERR_add_error_data(4, "module=", name, ", path=", path);
273    return NULL;
274}
275
276/* add module to list */
277static 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    if (supported_modules == NULL)
282        supported_modules = sk_CONF_MODULE_new_null();
283    if (supported_modules == NULL)
284        return NULL;
285    tmod = OPENSSL_malloc(sizeof(CONF_MODULE));
286    if (tmod == NULL)
287        return NULL;
288
289    tmod->dso = dso;
290    tmod->name = BUF_strdup(name);
291    tmod->init = ifunc;
292    tmod->finish = ffunc;
293    tmod->links = 0;
294
295    if (!sk_CONF_MODULE_push(supported_modules, tmod)) {
296        OPENSSL_free(tmod);
297        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
309static CONF_MODULE *module_find(char *name)
310{
311    CONF_MODULE *tmod;
312    int i, nchar;
313    char *p;
314    p = strrchr(name, '.');
315
316    if (p)
317        nchar = p - name;
318    else
319        nchar = strlen(name);
320
321    for (i = 0; i < sk_CONF_MODULE_num(supported_modules); i++) {
322        tmod = sk_CONF_MODULE_value(supported_modules, i);
323        if (!strncmp(tmod->name, name, nchar))
324            return tmod;
325    }
326
327    return NULL;
328
329}
330
331/* initialize a module */
332static 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    imod = OPENSSL_malloc(sizeof(CONF_IMODULE));
341    if (!imod)
342        goto err;
343
344    imod->pmod = pmod;
345    imod->name = BUF_strdup(name);
346    imod->value = BUF_strdup(value);
347    imod->usr_data = NULL;
348
349    if (!imod->name || !imod->value)
350        goto memerr;
351
352    /* Try to initialize module */
353    if (pmod->init) {
354        ret = pmod->init(imod, cnf);
355        init_called = 1;
356        /* Error occurred, exit */
357        if (ret <= 0)
358            goto err;
359    }
360
361    if (initialized_modules == NULL) {
362        initialized_modules = sk_CONF_IMODULE_new_null();
363        if (!initialized_modules) {
364            CONFerr(CONF_F_MODULE_INIT, ERR_R_MALLOC_FAILURE);
365            goto err;
366        }
367    }
368
369    if (!sk_CONF_IMODULE_push(initialized_modules, imod)) {
370        CONFerr(CONF_F_MODULE_INIT, ERR_R_MALLOC_FAILURE);
371        goto err;
372    }
373
374    pmod->links++;
375
376    return ret;
377
378 err:
379
380    /* We've started the module so we'd better finish it */
381    if (pmod->finish && init_called)
382        pmod->finish(imod);
383
384 memerr:
385    if (imod) {
386        if (imod->name)
387            OPENSSL_free(imod->name);
388        if (imod->value)
389            OPENSSL_free(imod->value);
390        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
403void CONF_modules_unload(int all)
404{
405    int i;
406    CONF_MODULE *md;
407    CONF_modules_finish();
408    /* unload modules in reverse order */
409    for (i = sk_CONF_MODULE_num(supported_modules) - 1; i >= 0; i--) {
410        md = sk_CONF_MODULE_value(supported_modules, i);
411        /* If static or in use and 'all' not set ignore it */
412        if (((md->links > 0) || !md->dso) && !all)
413            continue;
414        /* Since we're working in reverse this is OK */
415        (void)sk_CONF_MODULE_delete(supported_modules, i);
416        module_free(md);
417    }
418    if (sk_CONF_MODULE_num(supported_modules) == 0) {
419        sk_CONF_MODULE_free(supported_modules);
420        supported_modules = NULL;
421    }
422}
423
424/* unload a single module */
425static void module_free(CONF_MODULE *md)
426{
427    if (md->dso)
428        DSO_free(md->dso);
429    OPENSSL_free(md->name);
430    OPENSSL_free(md);
431}
432
433/* finish and free up all modules instances */
434
435void CONF_modules_finish(void)
436{
437    CONF_IMODULE *imod;
438    while (sk_CONF_IMODULE_num(initialized_modules) > 0) {
439        imod = sk_CONF_IMODULE_pop(initialized_modules);
440        module_finish(imod);
441    }
442    sk_CONF_IMODULE_free(initialized_modules);
443    initialized_modules = NULL;
444}
445
446/* finish a module instance */
447
448static void module_finish(CONF_IMODULE *imod)
449{
450    if (imod->pmod->finish)
451        imod->pmod->finish(imod);
452    imod->pmod->links--;
453    OPENSSL_free(imod->name);
454    OPENSSL_free(imod->value);
455    OPENSSL_free(imod);
456}
457
458/* Add a static module to OpenSSL */
459
460int CONF_module_add(const char *name, conf_init_func *ifunc,
461                    conf_finish_func *ffunc)
462{
463    if (module_add(NULL, name, ifunc, ffunc))
464        return 1;
465    else
466        return 0;
467}
468
469void CONF_modules_free(void)
470{
471    CONF_modules_finish();
472    CONF_modules_unload(1);
473}
474
475/* Utility functions */
476
477const char *CONF_imodule_get_name(const CONF_IMODULE *md)
478{
479    return md->name;
480}
481
482const char *CONF_imodule_get_value(const CONF_IMODULE *md)
483{
484    return md->value;
485}
486
487void *CONF_imodule_get_usr_data(const CONF_IMODULE *md)
488{
489    return md->usr_data;
490}
491
492void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data)
493{
494    md->usr_data = usr_data;
495}
496
497CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md)
498{
499    return md->pmod;
500}
501
502unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md)
503{
504    return md->flags;
505}
506
507void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags)
508{
509    md->flags = flags;
510}
511
512void *CONF_module_get_usr_data(CONF_MODULE *pmod)
513{
514    return pmod->usr_data;
515}
516
517void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data)
518{
519    pmod->usr_data = usr_data;
520}
521
522/* Return default config file name */
523
524char *CONF_get1_default_config_file(void)
525{
526    char *file;
527    int len;
528
529    file = getenv("OPENSSL_CONF");
530    if (file)
531        return BUF_strdup(file);
532
533    len = strlen(X509_get_default_cert_area());
534#ifndef OPENSSL_SYS_VMS
535    len++;
536#endif
537    len += strlen(OPENSSL_CONF);
538
539    file = OPENSSL_malloc(len + 1);
540
541    if (!file)
542        return NULL;
543    BUF_strlcpy(file, X509_get_default_cert_area(), len + 1);
544#ifndef OPENSSL_SYS_VMS
545    BUF_strlcat(file, "/", len + 1);
546#endif
547    BUF_strlcat(file, OPENSSL_CONF, len + 1);
548
549    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
559int 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    lstart = list_;
566
567    for (;;) {
568        if (nospc) {
569            while (*lstart && isspace((unsigned char)*lstart))
570                lstart++;
571        }
572        p = strchr(lstart, sep);
573        if (p == lstart || !*lstart)
574            ret = list_cb(NULL, 0, arg);
575        else {
576            if (p)
577                tmpend = p - 1;
578            else
579                tmpend = lstart + strlen(lstart) - 1;
580            if (nospc) {
581                while (isspace((unsigned char)*tmpend))
582                    tmpend--;
583            }
584            ret = list_cb(lstart, tmpend - lstart + 1, arg);
585        }
586        if (ret <= 0)
587            return ret;
588        if (p == NULL)
589            return 1;
590        lstart = p + 1;
591    }
592}
593