Branch data Line data Source code
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 : : /* Init a 'CONF' structure from an old LHASH */
71 : :
72 : 0 : void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash)
73 : : {
74 [ # # ]: 0 : if (default_CONF_method == NULL)
75 : 0 : default_CONF_method = NCONF_default();
76 : :
77 : 0 : default_CONF_method->init(conf);
78 : 0 : conf->data = hash;
79 : 0 : }
80 : :
81 : : /* The following section contains the "CONF classic" functions,
82 : : rewritten in terms of the new CONF interface. */
83 : :
84 : 0 : int CONF_set_default_method(CONF_METHOD *meth)
85 : : {
86 : 0 : default_CONF_method = meth;
87 : 0 : return 1;
88 : : }
89 : :
90 : 0 : LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file,
91 : : long *eline)
92 : : {
93 : : LHASH_OF(CONF_VALUE) *ltmp;
94 : 0 : BIO *in=NULL;
95 : :
96 : : #ifdef OPENSSL_SYS_VMS
97 : : in=BIO_new_file(file, "r");
98 : : #else
99 : 0 : in=BIO_new_file(file, "rb");
100 : : #endif
101 [ # # ]: 0 : if (in == NULL)
102 : : {
103 : 0 : CONFerr(CONF_F_CONF_LOAD,ERR_R_SYS_LIB);
104 : 0 : return NULL;
105 : : }
106 : :
107 : 0 : ltmp = CONF_load_bio(conf, in, eline);
108 : 0 : BIO_free(in);
109 : :
110 : 0 : return ltmp;
111 : : }
112 : :
113 : : #ifndef OPENSSL_NO_FP_API
114 : 0 : LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp,
115 : : long *eline)
116 : : {
117 : : BIO *btmp;
118 : : LHASH_OF(CONF_VALUE) *ltmp;
119 [ # # ]: 0 : if(!(btmp = BIO_new_fp(fp, BIO_NOCLOSE))) {
120 : 0 : CONFerr(CONF_F_CONF_LOAD_FP,ERR_R_BUF_LIB);
121 : 0 : return NULL;
122 : : }
123 : 0 : ltmp = CONF_load_bio(conf, btmp, eline);
124 : 0 : BIO_free(btmp);
125 : 0 : return ltmp;
126 : : }
127 : : #endif
128 : :
129 : 0 : LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp,
130 : : long *eline)
131 : : {
132 : : CONF ctmp;
133 : : int ret;
134 : :
135 : 0 : CONF_set_nconf(&ctmp, conf);
136 : :
137 : 0 : ret = NCONF_load_bio(&ctmp, bp, eline);
138 [ # # ]: 0 : if (ret)
139 : 0 : return ctmp.data;
140 : : return NULL;
141 : : }
142 : :
143 : 0 : STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf,
144 : : const char *section)
145 : : {
146 [ # # ]: 0 : if (conf == NULL)
147 : : {
148 : : return NULL;
149 : : }
150 : : else
151 : : {
152 : : CONF ctmp;
153 : 0 : CONF_set_nconf(&ctmp, conf);
154 : 0 : return NCONF_get_section(&ctmp, section);
155 : : }
156 : : }
157 : :
158 : 0 : char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf,const char *group,
159 : : const char *name)
160 : : {
161 [ # # ]: 0 : if (conf == NULL)
162 : : {
163 : 0 : return NCONF_get_string(NULL, group, name);
164 : : }
165 : : else
166 : : {
167 : : CONF ctmp;
168 : 0 : CONF_set_nconf(&ctmp, conf);
169 : 0 : return NCONF_get_string(&ctmp, group, name);
170 : : }
171 : : }
172 : :
173 : 0 : long CONF_get_number(LHASH_OF(CONF_VALUE) *conf,const char *group,
174 : : const char *name)
175 : : {
176 : : int status;
177 : 0 : long result = 0;
178 : :
179 [ # # ]: 0 : if (conf == NULL)
180 : : {
181 : 0 : status = NCONF_get_number_e(NULL, group, name, &result);
182 : : }
183 : : else
184 : : {
185 : : CONF ctmp;
186 : 0 : CONF_set_nconf(&ctmp, conf);
187 : 0 : status = NCONF_get_number_e(&ctmp, group, name, &result);
188 : : }
189 : :
190 [ # # ]: 0 : if (status == 0)
191 : : {
192 : : /* This function does not believe in errors... */
193 : 0 : ERR_clear_error();
194 : : }
195 : 0 : return result;
196 : : }
197 : :
198 : 0 : void CONF_free(LHASH_OF(CONF_VALUE) *conf)
199 : : {
200 : : CONF ctmp;
201 : 0 : CONF_set_nconf(&ctmp, conf);
202 : 0 : NCONF_free_data(&ctmp);
203 : 0 : }
204 : :
205 : : #ifndef OPENSSL_NO_FP_API
206 : 0 : int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out)
207 : : {
208 : : BIO *btmp;
209 : : int ret;
210 : :
211 [ # # ]: 0 : if(!(btmp = BIO_new_fp(out, BIO_NOCLOSE))) {
212 : 0 : CONFerr(CONF_F_CONF_DUMP_FP,ERR_R_BUF_LIB);
213 : 0 : return 0;
214 : : }
215 : 0 : ret = CONF_dump_bio(conf, btmp);
216 : 0 : BIO_free(btmp);
217 : 0 : return ret;
218 : : }
219 : : #endif
220 : :
221 : 0 : int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out)
222 : : {
223 : : CONF ctmp;
224 : 0 : CONF_set_nconf(&ctmp, conf);
225 : 0 : return NCONF_dump_bio(&ctmp, out);
226 : : }
227 : :
228 : : /* The following section contains the "New CONF" functions. They are
229 : : completely centralised around a new CONF structure that may contain
230 : : basically anything, but at least a method pointer and a table of data.
231 : : These functions are also written in terms of the bridge functions used
232 : : by the "CONF classic" functions, for consistency. */
233 : :
234 : 776 : CONF *NCONF_new(CONF_METHOD *meth)
235 : : {
236 : : CONF *ret;
237 : :
238 [ + - ]: 776 : if (meth == NULL)
239 : 776 : meth = NCONF_default();
240 : :
241 : 776 : ret = meth->create(meth);
242 [ - + ]: 776 : if (ret == NULL)
243 : : {
244 : 0 : CONFerr(CONF_F_NCONF_NEW,ERR_R_MALLOC_FAILURE);
245 : 0 : return(NULL);
246 : : }
247 : :
248 : : return ret;
249 : : }
250 : :
251 : 863 : void NCONF_free(CONF *conf)
252 : : {
253 [ + + ]: 863 : if (conf == NULL)
254 : 863 : return;
255 : 775 : conf->meth->destroy(conf);
256 : : }
257 : :
258 : 0 : void NCONF_free_data(CONF *conf)
259 : : {
260 [ # # ]: 0 : if (conf == NULL)
261 : 0 : return;
262 : 0 : conf->meth->destroy_data(conf);
263 : : }
264 : :
265 : 775 : int NCONF_load(CONF *conf, const char *file, long *eline)
266 : : {
267 [ - + ]: 775 : if (conf == NULL)
268 : : {
269 : 0 : CONFerr(CONF_F_NCONF_LOAD,CONF_R_NO_CONF);
270 : 0 : return 0;
271 : : }
272 : :
273 : 775 : return conf->meth->load(conf, file, eline);
274 : : }
275 : :
276 : : #ifndef OPENSSL_NO_FP_API
277 : 0 : int NCONF_load_fp(CONF *conf, FILE *fp,long *eline)
278 : : {
279 : : BIO *btmp;
280 : : int ret;
281 [ # # ]: 0 : if(!(btmp = BIO_new_fp(fp, BIO_NOCLOSE)))
282 : : {
283 : 0 : CONFerr(CONF_F_NCONF_LOAD_FP,ERR_R_BUF_LIB);
284 : 0 : return 0;
285 : : }
286 : 0 : ret = NCONF_load_bio(conf, btmp, eline);
287 : 0 : BIO_free(btmp);
288 : 0 : return ret;
289 : : }
290 : : #endif
291 : :
292 : 1 : int NCONF_load_bio(CONF *conf, BIO *bp,long *eline)
293 : : {
294 [ - + ]: 1 : if (conf == NULL)
295 : : {
296 : 0 : CONFerr(CONF_F_NCONF_LOAD_BIO,CONF_R_NO_CONF);
297 : 0 : return 0;
298 : : }
299 : :
300 : 1 : return conf->meth->load_bio(conf, bp, eline);
301 : : }
302 : :
303 : 89 : STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,const char *section)
304 : : {
305 [ - + ]: 89 : if (conf == NULL)
306 : : {
307 : 0 : CONFerr(CONF_F_NCONF_GET_SECTION,CONF_R_NO_CONF);
308 : 0 : return NULL;
309 : : }
310 : :
311 [ - + ]: 89 : if (section == NULL)
312 : : {
313 : 0 : CONFerr(CONF_F_NCONF_GET_SECTION,CONF_R_NO_SECTION);
314 : 0 : return NULL;
315 : : }
316 : :
317 : 89 : return _CONF_get_section_values(conf, section);
318 : : }
319 : :
320 : 1211 : char *NCONF_get_string(const CONF *conf,const char *group,const char *name)
321 : : {
322 : 1211 : char *s = _CONF_get_string(conf, group, name);
323 : :
324 : : /* Since we may get a value from an environment variable even
325 : : if conf is NULL, let's check the value first */
326 [ + + ]: 1211 : if (s) return s;
327 : :
328 [ - + ]: 985 : if (conf == NULL)
329 : : {
330 : 0 : CONFerr(CONF_F_NCONF_GET_STRING,
331 : : CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE);
332 : 0 : return NULL;
333 : : }
334 : 985 : CONFerr(CONF_F_NCONF_GET_STRING,
335 : : CONF_R_NO_VALUE);
336 : 985 : ERR_add_error_data(4,"group=",group," name=",name);
337 : 985 : return NULL;
338 : : }
339 : :
340 : 78 : int NCONF_get_number_e(const CONF *conf,const char *group,const char *name,
341 : : long *result)
342 : : {
343 : : char *str;
344 : :
345 [ - + ]: 78 : if (result == NULL)
346 : : {
347 : 0 : CONFerr(CONF_F_NCONF_GET_NUMBER_E,ERR_R_PASSED_NULL_PARAMETER);
348 : 0 : return 0;
349 : : }
350 : :
351 : 78 : str = NCONF_get_string(conf,group,name);
352 : :
353 [ + + ]: 78 : if (str == NULL)
354 : : return 0;
355 : :
356 [ + + ]: 54 : for (*result = 0;conf->meth->is_number(conf, *str);)
357 : : {
358 : 43 : *result = (*result)*10 + conf->meth->to_int(conf, *str);
359 : 43 : str++;
360 : : }
361 : :
362 : : return 1;
363 : : }
364 : :
365 : : #ifndef OPENSSL_NO_FP_API
366 : 0 : int NCONF_dump_fp(const CONF *conf, FILE *out)
367 : : {
368 : : BIO *btmp;
369 : : int ret;
370 [ # # ]: 0 : if(!(btmp = BIO_new_fp(out, BIO_NOCLOSE))) {
371 : 0 : CONFerr(CONF_F_NCONF_DUMP_FP,ERR_R_BUF_LIB);
372 : 0 : return 0;
373 : : }
374 : 0 : ret = NCONF_dump_bio(conf, btmp);
375 : 0 : BIO_free(btmp);
376 : 0 : return ret;
377 : : }
378 : : #endif
379 : :
380 : 0 : int NCONF_dump_bio(const CONF *conf, BIO *out)
381 : : {
382 [ # # ]: 0 : if (conf == NULL)
383 : : {
384 : 0 : CONFerr(CONF_F_NCONF_DUMP_BIO,CONF_R_NO_CONF);
385 : 0 : return 0;
386 : : }
387 : :
388 : 0 : return conf->meth->dump(conf, out);
389 : : }
390 : :
391 : :
392 : : /* This function should be avoided */
393 : : #if 0
394 : : long NCONF_get_number(CONF *conf,char *group,char *name)
395 : : {
396 : : int status;
397 : : long ret=0;
398 : :
399 : : status = NCONF_get_number_e(conf, group, name, &ret);
400 : : if (status == 0)
401 : : {
402 : : /* This function does not believe in errors... */
403 : : ERR_get_error();
404 : : }
405 : : return ret;
406 : : }
407 : : #endif
|
