Use new-style system-id macros everywhere possible. I hope I haven't
[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 OPENSSL_SYS_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 OPENSSL_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         if (conf == NULL)
135                 {
136                 return NULL;
137                 }
138         else
139                 {
140                 CONF ctmp;
141
142                 if (default_CONF_method == NULL)
143                         default_CONF_method = NCONF_default();
144
145                 default_CONF_method->init(&ctmp);
146                 ctmp.data = conf;
147                 return NCONF_get_section(&ctmp, section);
148                 }
149         }
150
151 char *CONF_get_string(LHASH *conf,char *group,char *name)
152         {
153         if (conf == NULL)
154                 {
155                 return NCONF_get_string(NULL, group, name);
156                 }
157         else
158                 {
159                 CONF ctmp;
160
161                 if (default_CONF_method == NULL)
162                         default_CONF_method = NCONF_default();
163
164                 default_CONF_method->init(&ctmp);
165                 ctmp.data = conf;
166                 return NCONF_get_string(&ctmp, group, name);
167                 }
168         }
169
170 long CONF_get_number(LHASH *conf,char *group,char *name)
171         {
172         int status;
173         long result = 0;
174
175         if (conf == NULL)
176                 {
177                 status = NCONF_get_number_e(NULL, group, name, &result);
178                 }
179         else
180                 {
181                 CONF ctmp;
182
183                 if (default_CONF_method == NULL)
184                         default_CONF_method = NCONF_default();
185
186                 default_CONF_method->init(&ctmp);
187                 ctmp.data = conf;
188                 status = NCONF_get_number_e(&ctmp, group, name, &result);
189                 }
190
191         if (status == 0)
192                 {
193                 /* This function does not believe in errors... */
194                 ERR_get_error();
195                 }
196         return result;
197         }
198
199 void CONF_free(LHASH *conf)
200         {
201         CONF ctmp;
202
203         if (default_CONF_method == NULL)
204                 default_CONF_method = NCONF_default();
205
206         default_CONF_method->init(&ctmp);
207         ctmp.data = conf;
208         NCONF_free_data(&ctmp);
209         }
210
211 #ifndef OPENSSL_NO_FP_API
212 int CONF_dump_fp(LHASH *conf, FILE *out)
213         {
214         BIO *btmp;
215         int ret;
216
217         if(!(btmp = BIO_new_fp(out, BIO_NOCLOSE))) {
218                 CONFerr(CONF_F_CONF_DUMP_FP,ERR_R_BUF_LIB);
219                 return 0;
220         }
221         ret = CONF_dump_bio(conf, btmp);
222         BIO_free(btmp);
223         return ret;
224         }
225 #endif
226
227 int CONF_dump_bio(LHASH *conf, BIO *out)
228         {
229         CONF ctmp;
230
231         if (default_CONF_method == NULL)
232                 default_CONF_method = NCONF_default();
233
234         default_CONF_method->init(&ctmp);
235         ctmp.data = conf;
236         return NCONF_dump_bio(&ctmp, out);
237         }
238
239 /* The following section contains the "New CONF" functions.  They are
240    completely centralised around a new CONF structure that may contain
241    basically anything, but at least a method pointer and a table of data.
242    These functions are also written in terms of the bridge functions used
243    by the "CONF classic" functions, for consistency.  */
244
245 CONF *NCONF_new(CONF_METHOD *meth)
246         {
247         CONF *ret;
248
249         if (meth == NULL)
250                 meth = NCONF_default();
251
252         ret = meth->create(meth);
253         if (ret == NULL)
254                 {
255                 CONFerr(CONF_F_NCONF_NEW,ERR_R_MALLOC_FAILURE);
256                 return(NULL);
257                 }
258
259         return ret;
260         }
261
262 void NCONF_free(CONF *conf)
263         {
264         if (conf == NULL)
265                 return;
266         conf->meth->destroy(conf);
267         }
268
269 void NCONF_free_data(CONF *conf)
270         {
271         if (conf == NULL)
272                 return;
273         conf->meth->destroy_data(conf);
274         }
275
276 int NCONF_load(CONF *conf, const char *file, long *eline)
277         {
278         if (conf == NULL)
279                 {
280                 CONFerr(CONF_F_NCONF_LOAD,CONF_R_NO_CONF);
281                 return 0;
282                 }
283
284         return conf->meth->load(conf, file, eline);
285         }
286
287 #ifndef OPENSSL_NO_FP_API
288 int NCONF_load_fp(CONF *conf, FILE *fp,long *eline)
289         {
290         BIO *btmp;
291         int ret;
292         if(!(btmp = BIO_new_fp(fp, BIO_NOCLOSE)))
293                 {
294                 CONFerr(CONF_F_NCONF_LOAD_FP,ERR_R_BUF_LIB);
295                 return 0;
296                 }
297         ret = NCONF_load_bio(conf, btmp, eline);
298         BIO_free(btmp);
299         return ret;
300         }
301 #endif
302
303 int NCONF_load_bio(CONF *conf, BIO *bp,long *eline)
304         {
305         if (conf == NULL)
306                 {
307                 CONFerr(CONF_F_NCONF_LOAD_BIO,CONF_R_NO_CONF);
308                 return 0;
309                 }
310
311         return conf->meth->load_bio(conf, bp, eline);
312         }
313
314 STACK_OF(CONF_VALUE) *NCONF_get_section(CONF *conf,char *section)
315         {
316         if (conf == NULL)
317                 {
318                 CONFerr(CONF_F_NCONF_GET_SECTION,CONF_R_NO_CONF);
319                 return NULL;
320                 }
321
322         if (section == NULL)
323                 {
324                 CONFerr(CONF_F_NCONF_GET_SECTION,CONF_R_NO_SECTION);
325                 return NULL;
326                 }
327
328         return _CONF_get_section_values(conf, section);
329         }
330
331 char *NCONF_get_string(CONF *conf,char *group,char *name)
332         {
333         char *s = _CONF_get_string(conf, group, name);
334
335         /* Since we may get a value from an environment variable even
336            if conf is NULL, let's check the value first */
337         if (s) return s;
338
339         if (conf == NULL)
340                 {
341                 CONFerr(CONF_F_NCONF_GET_STRING,
342                         CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE);
343                 return NULL;
344                 }
345         CONFerr(CONF_F_NCONF_GET_STRING,
346                 CONF_R_NO_VALUE);
347         return NULL;
348         }
349
350 int NCONF_get_number_e(CONF *conf,char *group,char *name,long *result)
351         {
352         char *str;
353
354         if (result == NULL)
355                 {
356                 CONFerr(CONF_F_NCONF_GET_NUMBER_E,ERR_R_PASSED_NULL_PARAMETER);
357                 return 0;
358                 }
359
360         str = NCONF_get_string(conf,group,name);
361
362         if (str == NULL)
363                 return 0;
364
365         for (;conf->meth->is_number(conf, *str);)
366                 {
367                 *result = (*result)*10 + conf->meth->to_int(conf, *str);
368                 str++;
369                 }
370
371         return 1;
372         }
373
374 #ifndef OPENSSL_NO_FP_API
375 int NCONF_dump_fp(CONF *conf, FILE *out)
376         {
377         BIO *btmp;
378         int ret;
379         if(!(btmp = BIO_new_fp(out, BIO_NOCLOSE))) {
380                 CONFerr(CONF_F_NCONF_DUMP_FP,ERR_R_BUF_LIB);
381                 return 0;
382         }
383         ret = NCONF_dump_bio(conf, btmp);
384         BIO_free(btmp);
385         return ret;
386         }
387 #endif
388
389 int NCONF_dump_bio(CONF *conf, BIO *out)
390         {
391         if (conf == NULL)
392                 {
393                 CONFerr(CONF_F_NCONF_DUMP_BIO,CONF_R_NO_CONF);
394                 return 0;
395                 }
396
397         return conf->meth->dump(conf, out);
398         }
399
400 /* This function should be avoided */
401 #undef NCONF_get_number
402 long NCONF_get_number(CONF *conf,char *group,char *name)
403         {
404         int status;
405         long ret=0;
406
407         status = NCONF_get_number_e(conf, group, name, &ret);
408         if (status == 0)
409                 {
410                 /* This function does not believe in errors... */
411                 ERR_get_error();
412                 }
413         return ret;
414         }
415