4c8ca9e9ae4f3df23f798b3aaede9b947f16e433
[openssl.git] / crypto / conf / conf_lib.c
1 /* conf_lib.c */
2 /* Written by Richard Levitte (richard@levitte.org) for the OpenSSL
3  * project 2000.
4  */
5 /* ====================================================================
6  * Copyright (c) 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  *    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 <stdio.h>
60 #include <openssl/crypto.h>
61 #include <openssl/err.h>
62 #include <openssl/conf.h>
63 #include <openssl/conf_api.h>
64 #include <openssl/lhash.h>
65
66 const char *CONF_version="CONF" OPENSSL_VERSION_PTEXT;
67
68 static CONF_METHOD *default_CONF_method=NULL;
69
70 /* The following section contains the "CONF classic" functions,
71    rewritten in terms of the new CONF interface. */
72
73 int CONF_set_default_method(CONF_METHOD *meth)
74         {
75         default_CONF_method = meth;
76         return 1;
77         }
78
79 LHASH *CONF_load(LHASH *conf, const char *file, long *eline)
80         {
81         LHASH *ltmp;
82         BIO *in=NULL;
83
84 #ifdef VMS
85         in=BIO_new_file(file, "r");
86 #else
87         in=BIO_new_file(file, "rb");
88 #endif
89         if (in == NULL)
90                 {
91                 CONFerr(CONF_F_CONF_LOAD,ERR_R_SYS_LIB);
92                 return NULL;
93                 }
94
95         ltmp = CONF_load_bio(conf, in, eline);
96         BIO_free(in);
97
98         return ltmp;
99         }
100
101 #ifndef NO_FP_API
102 LHASH *CONF_load_fp(LHASH *conf, FILE *fp,long *eline)
103         {
104         BIO *btmp;
105         LHASH *ltmp;
106         if(!(btmp = BIO_new_fp(fp, BIO_NOCLOSE))) {
107                 CONFerr(CONF_F_CONF_LOAD_FP,ERR_R_BUF_LIB);
108                 return NULL;
109         }
110         ltmp = CONF_load_bio(conf, btmp, eline);
111         BIO_free(btmp);
112         return ltmp;
113         }
114 #endif
115
116 LHASH *CONF_load_bio(LHASH *conf, BIO *bp,long *eline)
117         {
118         CONF ctmp;
119         int ret;
120
121         if (default_CONF_method == NULL)
122                 default_CONF_method = NCONF_default();
123
124         default_CONF_method->init(&ctmp);
125         ctmp.data = conf;
126         ret = NCONF_load_bio(&ctmp, bp, eline);
127         if (ret)
128                 return ctmp.data;
129         return NULL;
130         }
131
132 STACK_OF(CONF_VALUE) *CONF_get_section(LHASH *conf,char *section)
133         {
134         CONF ctmp;
135
136         if (default_CONF_method == NULL)
137                 default_CONF_method = NCONF_default();
138
139         default_CONF_method->init(&ctmp);
140         ctmp.data = conf;
141         return NCONF_get_section(&ctmp, section);
142         }
143
144 char *CONF_get_string(LHASH *conf,char *group,char *name)
145         {
146         CONF ctmp;
147
148         if (default_CONF_method == NULL)
149                 default_CONF_method = NCONF_default();
150
151         default_CONF_method->init(&ctmp);
152         ctmp.data = conf;
153         return NCONF_get_string(&ctmp, group, name);
154         }
155
156 long CONF_get_number(LHASH *conf,char *group,char *name)
157         {
158         CONF ctmp;
159
160         if (default_CONF_method == NULL)
161                 default_CONF_method = NCONF_default();
162
163         default_CONF_method->init(&ctmp);
164         ctmp.data = conf;
165         return NCONF_get_number(&ctmp, group, name);
166         }
167
168 void CONF_free(LHASH *conf)
169         {
170         CONF ctmp;
171
172         if (default_CONF_method == NULL)
173                 default_CONF_method = NCONF_default();
174
175         default_CONF_method->init(&ctmp);
176         ctmp.data = conf;
177         NCONF_free_data(&ctmp);
178         }
179
180 #ifndef NO_FP_API
181 int CONF_dump_fp(LHASH *conf, FILE *out)
182         {
183         BIO *btmp;
184         int ret;
185
186         if(!(btmp = BIO_new_fp(out, BIO_NOCLOSE))) {
187                 CONFerr(CONF_F_CONF_DUMP_FP,ERR_R_BUF_LIB);
188                 return 0;
189         }
190         ret = CONF_dump_bio(conf, btmp);
191         BIO_free(btmp);
192         return ret;
193         }
194 #endif
195
196 int CONF_dump_bio(LHASH *conf, BIO *out)
197         {
198         CONF ctmp;
199
200         if (default_CONF_method == NULL)
201                 default_CONF_method = NCONF_default();
202
203         default_CONF_method->init(&ctmp);
204         ctmp.data = conf;
205         return NCONF_dump_bio(&ctmp, out);
206         }
207
208 /* The following section contains the "New CONF" functions.  They are
209    completely centralised around a new CONF structure that may contain
210    basically anything, but at least a method pointer and a table of data.
211    These functions are also written in terms of the bridge functions used
212    by the "CONF classic" functions, for consistency.  */
213
214 CONF *NCONF_new(CONF_METHOD *meth)
215         {
216         CONF *ret;
217
218         if (meth == NULL)
219                 meth = NCONF_default();
220
221         ret = meth->create(meth);
222         if (ret == NULL)
223                 {
224                 CONFerr(CONF_F_NCONF_NEW,ERR_R_MALLOC_FAILURE);
225                 return(NULL);
226                 }
227
228         return ret;
229         }
230
231 void NCONF_free(CONF *conf)
232         {
233         if (conf == NULL)
234                 return;
235         conf->meth->destroy(conf);
236         }
237
238 void NCONF_free_data(CONF *conf)
239         {
240         if (conf == NULL)
241                 return;
242         conf->meth->destroy_data(conf);
243         }
244
245 int NCONF_load(CONF *conf, const char *file, long *eline)
246         {
247         int ret;
248         BIO *in=NULL;
249
250 #ifdef VMS
251         in=BIO_new_file(file, "r");
252 #else
253         in=BIO_new_file(file, "rb");
254 #endif
255         if (in == NULL)
256                 {
257                 CONFerr(CONF_F_CONF_LOAD,ERR_R_SYS_LIB);
258                 return 0;
259                 }
260
261         ret = NCONF_load_bio(conf, in, eline);
262         BIO_free(in);
263
264         return ret;
265         }
266
267 #ifndef NO_FP_API
268 int NCONF_load_fp(CONF *conf, FILE *fp,long *eline)
269         {
270         BIO *btmp;
271         int ret;
272         if(!(btmp = BIO_new_fp(fp, BIO_NOCLOSE)))
273                 {
274                 CONFerr(CONF_F_CONF_LOAD_FP,ERR_R_BUF_LIB);
275                 return 0;
276                 }
277         ret = NCONF_load_bio(conf, btmp, eline);
278         BIO_free(btmp);
279         return ret;
280         }
281 #endif
282
283 int NCONF_load_bio(CONF *conf, BIO *bp,long *eline)
284         {
285         if (conf == NULL)
286                 {
287                 CONFerr(CONF_F_NCONF_LOAD_BIO,CONF_R_NO_CONF);
288                 return 0;
289                 }
290
291         return conf->meth->load(conf, bp, eline);
292         }
293
294 STACK_OF(CONF_VALUE) *NCONF_get_section(CONF *conf,char *section)
295         {
296         if (conf == NULL)
297                 {
298                 CONFerr(CONF_F_NCONF_GET_SECTION,CONF_R_NO_CONF);
299                 return NULL;
300                 }
301
302         return _CONF_get_section_values(conf, section);
303         }
304
305 char *NCONF_get_string(CONF *conf,char *group,char *name)
306         {
307         if (conf == NULL)
308                 {
309                 CONFerr(CONF_F_NCONF_GET_STRING,CONF_R_NO_CONF);
310                 return NULL;
311                 }
312
313         return _CONF_get_string(conf, group, name);
314         }
315
316 long NCONF_get_number(CONF *conf,char *group,char *name)
317         {
318         if (conf == NULL)
319                 {
320                 CONFerr(CONF_F_NCONF_GET_NUMBER,CONF_R_NO_CONF);
321                 return 0;
322                 }
323         
324         return _CONF_get_number(conf, group, name);
325         }
326
327 #ifndef NO_FP_API
328 int NCONF_dump_fp(CONF *conf, FILE *out)
329         {
330         BIO *btmp;
331         int ret;
332         if(!(btmp = BIO_new_fp(out, BIO_NOCLOSE))) {
333                 CONFerr(CONF_F_NCONF_DUMP_FP,ERR_R_BUF_LIB);
334                 return 0;
335         }
336         ret = NCONF_dump_bio(conf, btmp);
337         BIO_free(btmp);
338         return ret;
339         }
340 #endif
341
342 int NCONF_dump_bio(CONF *conf, BIO *out)
343         {
344         if (conf == NULL)
345                 {
346                 CONFerr(CONF_F_NCONF_DUMP_BIO,CONF_R_NO_CONF);
347                 return 0;
348                 }
349
350         return conf->meth->dump(conf, out);
351         }
352