GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libcrypto/conf/conf_def.c Lines: 162 309 52.4 %
Date: 2017-11-13 Branches: 90 219 41.1 %

Line Branch Exec Source
1
/* $OpenBSD: conf_def.c,v 1.32 2017/01/29 17:49:22 beck Exp $ */
2
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3
 * All rights reserved.
4
 *
5
 * This package is an SSL implementation written
6
 * by Eric Young (eay@cryptsoft.com).
7
 * The implementation was written so as to conform with Netscapes SSL.
8
 *
9
 * This library is free for commercial and non-commercial use as long as
10
 * the following conditions are aheared to.  The following conditions
11
 * apply to all code found in this distribution, be it the RC4, RSA,
12
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13
 * included with this distribution is covered by the same copyright terms
14
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15
 *
16
 * Copyright remains Eric Young's, and as such any Copyright notices in
17
 * the code are not to be removed.
18
 * If this package is used in a product, Eric Young should be given attribution
19
 * as the author of the parts of the library used.
20
 * This can be in the form of a textual message at program startup or
21
 * in documentation (online or textual) provided with the package.
22
 *
23
 * Redistribution and use in source and binary forms, with or without
24
 * modification, are permitted provided that the following conditions
25
 * are met:
26
 * 1. Redistributions of source code must retain the copyright
27
 *    notice, this list of conditions and the following disclaimer.
28
 * 2. Redistributions in binary form must reproduce the above copyright
29
 *    notice, this list of conditions and the following disclaimer in the
30
 *    documentation and/or other materials provided with the distribution.
31
 * 3. All advertising materials mentioning features or use of this software
32
 *    must display the following acknowledgement:
33
 *    "This product includes cryptographic software written by
34
 *     Eric Young (eay@cryptsoft.com)"
35
 *    The word 'cryptographic' can be left out if the rouines from the library
36
 *    being used are not cryptographic related :-).
37
 * 4. If you include any Windows specific code (or a derivative thereof) from
38
 *    the apps directory (application code) you must include an acknowledgement:
39
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40
 *
41
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51
 * SUCH DAMAGE.
52
 *
53
 * The licence and distribution terms for any publically available version or
54
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
55
 * copied and put under another distribution licence
56
 * [including the GNU Public Licence.]
57
 */
58
59
/* Part of the code in here was originally in conf.c, which is now removed */
60
61
#include <stdio.h>
62
#include <string.h>
63
64
#include <openssl/buffer.h>
65
#include <openssl/conf.h>
66
#include <openssl/conf_api.h>
67
#include <openssl/err.h>
68
#include <openssl/lhash.h>
69
#include <openssl/stack.h>
70
71
#include "conf_def.h"
72
73
static char *eat_ws(CONF *conf, char *p);
74
static char *eat_alpha_numeric(CONF *conf, char *p);
75
static void clear_comments(CONF *conf, char *p);
76
static int str_copy(CONF *conf, char *section, char **to, char *from);
77
static char *scan_quote(CONF *conf, char *p);
78
static char *scan_dquote(CONF *conf, char *p);
79
#define scan_esc(conf,p)	(((IS_EOF((conf),(p)[1]))?((p)+1):((p)+2)))
80
81
static CONF *def_create(CONF_METHOD *meth);
82
static int def_init_default(CONF *conf);
83
static int def_init_WIN32(CONF *conf);
84
static int def_destroy(CONF *conf);
85
static int def_destroy_data(CONF *conf);
86
static int def_load(CONF *conf, const char *name, long *eline);
87
static int def_load_bio(CONF *conf, BIO *bp, long *eline);
88
static int def_dump(const CONF *conf, BIO *bp);
89
static int def_is_number(const CONF *conf, char c);
90
static int def_to_int(const CONF *conf, char c);
91
92
static CONF_METHOD default_method = {
93
	.name = "OpenSSL default",
94
	.create = def_create,
95
	.init = def_init_default,
96
	.destroy = def_destroy,
97
	.destroy_data = def_destroy_data,
98
	.load_bio = def_load_bio,
99
	.dump = def_dump,
100
	.is_number = def_is_number,
101
	.to_int = def_to_int,
102
	.load = def_load
103
};
104
105
static CONF_METHOD WIN32_method = {
106
	"WIN32",
107
	def_create,
108
	def_init_WIN32,
109
	def_destroy,
110
	def_destroy_data,
111
	def_load_bio,
112
	def_dump,
113
	def_is_number,
114
	def_to_int,
115
	def_load
116
};
117
118
CONF_METHOD *
119
NCONF_default(void)
120
{
121
2870
	return &default_method;
122
}
123
124
CONF_METHOD *
125
NCONF_WIN32(void)
126
{
127
	return &WIN32_method;
128
}
129
130
static CONF *
131
def_create(CONF_METHOD *meth)
132
{
133
	CONF *ret;
134
135
2866
	ret = malloc(sizeof(CONF) + sizeof(unsigned short *));
136
1433
	if (ret)
137
1433
		if (meth->init(ret) == 0) {
138
			free(ret);
139
			ret = NULL;
140
		}
141
1433
	return ret;
142
}
143
144
static int
145
def_init_default(CONF *conf)
146
{
147
2878
	if (conf == NULL)
148
		return 0;
149
150
1439
	conf->meth = &default_method;
151
1439
	conf->meth_data = CONF_type_default;
152
1439
	conf->data = NULL;
153
154
1439
	return 1;
155
1439
}
156
157
static int
158
def_init_WIN32(CONF *conf)
159
{
160
	if (conf == NULL)
161
		return 0;
162
163
	conf->meth = &WIN32_method;
164
	conf->meth_data = (void *)CONF_type_win32;
165
	conf->data = NULL;
166
167
	return 1;
168
}
169
170
static int
171
def_destroy(CONF *conf)
172
{
173
2866
	if (def_destroy_data(conf)) {
174
1433
		free(conf);
175
1433
		return 1;
176
	}
177
	return 0;
178
1433
}
179
180
static int
181
def_destroy_data(CONF *conf)
182
{
183
2870
	if (conf == NULL)
184
		return 0;
185
1435
	_CONF_free_data(conf);
186
1435
	return 1;
187
1435
}
188
189
static int
190
def_load(CONF *conf, const char *name, long *line)
191
{
192
	int ret;
193
	BIO *in = NULL;
194
195
2862
	in = BIO_new_file(name, "rb");
196
1431
	if (in == NULL) {
197
2
		if (ERR_GET_REASON(ERR_peek_last_error()) == BIO_R_NO_SUCH_FILE)
198
2
			CONFerror(CONF_R_NO_SUCH_FILE);
199
		else
200
			CONFerror(ERR_R_SYS_LIB);
201
2
		return 0;
202
	}
203
204
1429
	ret = def_load_bio(conf, in, line);
205
1429
	BIO_free(in);
206
207
1429
	return ret;
208
1431
}
209
210
static int
211
def_load_bio(CONF *conf, BIO *in, long *line)
212
{
213
/* The macro BUFSIZE conflicts with a system macro in VxWorks */
214
#define CONFBUFSIZE	512
215
	int bufnum = 0, i, ii;
216
	BUF_MEM *buff = NULL;
217
	char *s, *p, *end;
218
	int again;
219
	long eline = 0;
220
	CONF_VALUE *v = NULL, *tv;
221
	CONF_VALUE *sv = NULL;
222
2866
	char *section = NULL, *buf;
223
	char *start, *psection, *pname;
224
1433
	void *h = (void *)(conf->data);
225
226
1433
	if ((buff = BUF_MEM_new()) == NULL) {
227
		CONFerror(ERR_R_BUF_LIB);
228
		goto err;
229
	}
230
231
1433
	section = strdup("default");
232
1433
	if (section == NULL) {
233
		CONFerror(ERR_R_MALLOC_FAILURE);
234
		goto err;
235
	}
236
237
1433
	if (_CONF_new_data(conf) == 0) {
238
		CONFerror(ERR_R_MALLOC_FAILURE);
239
		goto err;
240
	}
241
242
1433
	sv = _CONF_new_section(conf, section);
243
1433
	if (sv == NULL) {
244
		CONFerror(CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
245
		goto err;
246
	}
247
248
	bufnum = 0;
249
	again = 0;
250
13507
	for (;;) {
251
18323
		if (!BUF_MEM_grow(buff, bufnum + CONFBUFSIZE)) {
252
			CONFerror(ERR_R_BUF_LIB);
253
			goto err;
254
		}
255
18323
		p = &(buff->data[bufnum]);
256
18323
		*p = '\0';
257
18323
		BIO_gets(in, p, CONFBUFSIZE - 1);
258
18323
		p[CONFBUFSIZE - 1] = '\0';
259
18323
		ii = i = strlen(p);
260
18323
		if (i == 0 && !again)
261
			break;
262
		again = 0;
263
67552
		while (i > 0) {
264

65692
			if ((p[i - 1] != '\r') && (p[i - 1] != '\n'))
265
				break;
266
			else
267
16886
				i--;
268
		}
269
		/* we removed some trailing stuff so there is a new
270
		 * line on the end. */
271

33780
		if (ii && i == ii)
272
4
			again = 1; /* long line */
273
		else {
274
16886
			p[i] = '\0';
275
16886
			eline++; /* another input line */
276
		}
277
278
		/* we now have a line with trailing \r\n removed */
279
280
		/* i is the number of bytes */
281
16890
		bufnum += i;
282
283
		v = NULL;
284
		/* check for line continuation */
285
16890
		if (bufnum >= 1) {
286
			/* If we have bytes and the last char '\\' and
287
			 * second last char is not '\\' */
288
15960
			p = &(buff->data[bufnum - 1]);
289

15960
			if (IS_ESC(conf, p[0]) &&
290
			    ((bufnum <= 1) || !IS_ESC(conf, p[-1]))) {
291
				bufnum--;
292
				again = 1;
293
			}
294
		}
295
16890
		if (again)
296
4
			continue;
297
		bufnum = 0;
298
16886
		buf = buff->data;
299
300
16886
		clear_comments(conf, buf);
301
16886
		s = eat_ws(conf, buf);
302
16886
		if (IS_EOF(conf, *s))
303
2311
			continue; /* blank line */
304
14575
		if (*s == '[') {
305
			char *ss;
306
307
2501
			s++;
308
2501
			start = eat_ws(conf, s);
309
2501
			ss = start;
310
again:
311
2501
			end = eat_alpha_numeric(conf, ss);
312
2501
			p = eat_ws(conf, end);
313
2501
			if (*p != ']') {
314
				if (*p != '\0' && ss != p) {
315
					ss = p;
316
					goto again;
317
				}
318
				CONFerror(CONF_R_MISSING_CLOSE_SQUARE_BRACKET);
319
				goto err;
320
			}
321
2501
			*end = '\0';
322
2501
			if (!str_copy(conf, NULL, &section, start))
323
				goto err;
324
2501
			if ((sv = _CONF_get_section(conf, section)) == NULL)
325
2501
				sv = _CONF_new_section(conf, section);
326
2501
			if (sv == NULL) {
327
				CONFerror(CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
328
				goto err;
329
			}
330
2501
			continue;
331
		} else {
332
			pname = s;
333
			psection = NULL;
334
12074
			end = eat_alpha_numeric(conf, s);
335

12074
			if ((end[0] == ':') && (end[1] == ':')) {
336
				*end = '\0';
337
				end += 2;
338
				psection = pname;
339
				pname = end;
340
				end = eat_alpha_numeric(conf, end);
341
			}
342
12074
			p = eat_ws(conf, end);
343
12074
			if (*p != '=') {
344
				CONFerror(CONF_R_MISSING_EQUAL_SIGN);
345
				goto err;
346
			}
347
12074
			*end = '\0';
348
12074
			p++;
349
12074
			start = eat_ws(conf, p);
350
425056
			while (!IS_EOF(conf, *p))
351
200454
				p++;
352
12074
			p--;
353

47529
			while ((p != start) && (IS_WS(conf, *p)))
354
232
				p--;
355
12074
			p++;
356
12074
			*p = '\0';
357
358
12074
			if (!(v = malloc(sizeof(CONF_VALUE)))) {
359
				CONFerror(ERR_R_MALLOC_FAILURE);
360
				goto err;
361
			}
362
12074
			if (psection == NULL)
363
12074
				psection = section;
364
12074
			v->name = strdup(pname);
365
12074
			v->value = NULL;
366
12074
			if (v->name == NULL) {
367
				CONFerror(ERR_R_MALLOC_FAILURE);
368
				goto err;
369
			}
370
12074
			if (!str_copy(conf, psection, &(v->value), start))
371
				goto err;
372
373
12074
			if (strcmp(psection, section) != 0) {
374
				if ((tv = _CONF_get_section(conf, psection))
375
					== NULL)
376
					tv = _CONF_new_section(conf, psection);
377
				if (tv == NULL) {
378
					CONFerror(CONF_R_UNABLE_TO_CREATE_NEW_SECTION);
379
					goto err;
380
				}
381
			} else
382
				tv = sv;
383
384
12074
			if (_CONF_add_string(conf, tv, v) == 0) {
385
				CONFerror(ERR_R_MALLOC_FAILURE);
386
				goto err;
387
			}
388
			v = NULL;
389
		}
390
	}
391
1433
	if (buff != NULL)
392
1433
		BUF_MEM_free(buff);
393
1433
	free(section);
394
1433
	return (1);
395
396
err:
397
	if (buff != NULL)
398
		BUF_MEM_free(buff);
399
	free(section);
400
	if (line != NULL)
401
		*line = eline;
402
	ERR_asprintf_error_data("line %ld", eline);
403
	if ((h != conf->data) && (conf->data != NULL)) {
404
		CONF_free(conf->data);
405
		conf->data = NULL;
406
	}
407
	if (v != NULL) {
408
		free(v->name);
409
		free(v->value);
410
		free(v);
411
	}
412
	return (0);
413
1433
}
414
415
static void
416
clear_comments(CONF *conf, char *p)
417
{
418
33772
	for (;;) {
419
16886
		if (IS_FCOMMENT(conf, *p)) {
420
			*p = '\0';
421
			return;
422
		}
423
16886
		if (!IS_WS(conf, *p)) {
424
			break;
425
		}
426
		p++;
427
	}
428
429
492954
	for (;;) {
430
492954
		if (IS_COMMENT(conf, *p)) {
431
			*p = '\0';
432
1381
			return;
433
		}
434
491573
		if (IS_DQUOTE(conf, *p)) {
435
			p = scan_dquote(conf, p);
436
			continue;
437
		}
438
491573
		if (IS_QUOTE(conf, *p)) {
439
			p = scan_quote(conf, p);
440
			continue;
441
		}
442
491573
		if (IS_ESC(conf, *p)) {
443
			p = scan_esc(conf, p);
444
			continue;
445
		}
446
491573
		if (IS_EOF(conf, *p))
447
			return;
448
		else
449
476068
			p++;
450
	}
451
18267
}
452
453
static int
454
str_copy(CONF *conf, char *section, char **pto, char *from)
455
{
456
	int q, r,rr = 0, to = 0, len = 0;
457
	char *s, *e, *rp, *p, *rrp, *np, *cp, v;
458
	BUF_MEM *buf;
459
460
29150
	if ((buf = BUF_MEM_new()) == NULL)
461
		return (0);
462
463
14575
	len = strlen(from) + 1;
464
14575
	if (!BUF_MEM_grow(buf, len))
465
		goto err;
466
467
228168
	for (;;) {
468
228168
		if (IS_QUOTE(conf, *from)) {
469
			q = *from;
470
			from++;
471
			while (!IS_EOF(conf, *from) && (*from != q)) {
472
				if (IS_ESC(conf, *from)) {
473
					from++;
474
					if (IS_EOF(conf, *from))
475
						break;
476
				}
477
				buf->data[to++] = *(from++);
478
			}
479
			if (*from == q)
480
				from++;
481
228168
		} else if (IS_DQUOTE(conf, *from)) {
482
			q = *from;
483
			from++;
484
			while (!IS_EOF(conf, *from)) {
485
				if (*from == q) {
486
					if (*(from + 1) == q) {
487
						from++;
488
					} else {
489
						break;
490
					}
491
				}
492
				buf->data[to++] = *(from++);
493
			}
494
			if (*from == q)
495
				from++;
496
228168
		} else if (IS_ESC(conf, *from)) {
497
			from++;
498
			v = *(from++);
499
			if (IS_EOF(conf, v))
500
				break;
501
			else if (v == 'r')
502
				v = '\r';
503
			else if (v == 'n')
504
				v = '\n';
505
			else if (v == 'b')
506
				v = '\b';
507
			else if (v == 't')
508
				v = '\t';
509
			buf->data[to++] = v;
510
228168
		} else if (IS_EOF(conf, *from))
511
			break;
512
213593
		else if (*from == '$') {
513
			/* try to expand it */
514
			rrp = NULL;
515
684
			s = &(from[1]);
516
684
			if (*s == '{')
517
				q = '}';
518
684
			else if (*s == '(')
519
				q = ')';
520
			else
521
				q = 0;
522
523
684
			if (q)
524
				s++;
525
			cp = section;
526
			e = np = s;
527
5472
			while (IS_ALPHA_NUMERIC(conf, *e))
528
2052
				e++;
529

684
			if ((e[0] == ':') && (e[1] == ':')) {
530
				cp = np;
531
				rrp = e;
532
				rr = *e;
533
				*rrp = '\0';
534
				e += 2;
535
				np = e;
536
				while (IS_ALPHA_NUMERIC(conf, *e))
537
					e++;
538
			}
539
684
			r = *e;
540
684
			*e = '\0';
541
			rp = e;
542
684
			if (q) {
543
				if (r != q) {
544
					CONFerror(CONF_R_NO_CLOSE_BRACE);
545
					goto err;
546
				}
547
				e++;
548
			}
549
			/* So at this point we have
550
			 * np which is the start of the name string which is
551
			 *   '\0' terminated.
552
			 * cp which is the start of the section string which is
553
			 *   '\0' terminated.
554
			 * e is the 'next point after'.
555
			 * r and rr are the chars replaced by the '\0'
556
			 * rp and rrp is where 'r' and 'rr' came from.
557
			 */
558
684
			p = _CONF_get_string(conf, cp, np);
559
684
			if (rrp != NULL)
560
				*rrp = rr;
561
684
			*rp = r;
562
684
			if (p == NULL) {
563
				CONFerror(CONF_R_VARIABLE_HAS_NO_VALUE);
564
				goto err;
565
			}
566
684
			if (!BUF_MEM_grow_clean(buf,
567
684
				(strlen(p) + buf->length - (e - from)))) {
568
				CONFerror(CONF_R_MODULE_INITIALIZATION_ERROR);
569
				goto err;
570
			}
571
30324
			while (*p)
572
14478
				buf->data[to++] = *(p++);
573
574
			/* Since we change the pointer 'from', we also have
575
			   to change the perceived length of the string it
576
			   points at.  /RL */
577
684
			len -= e - from;
578
			from = e;
579
580
			/* In case there were no braces or parenthesis around
581
			   the variable reference, we have to put back the
582
			   character that was replaced with a '\0'.  /RL */
583
684
			*rp = r;
584
684
		} else
585
212909
			buf->data[to++] = *(from++);
586
	}
587
14575
	buf->data[to]='\0';
588
14575
	free(*pto);
589
14575
	*pto = buf->data;
590
14575
	free(buf);
591
14575
	return (1);
592
593
err:
594
	if (buf != NULL)
595
		BUF_MEM_free(buf);
596
	return (0);
597
14575
}
598
599
static char *
600
eat_ws(CONF *conf, char *p)
601
{
602

460696
	while (IS_WS(conf, *p) && (!IS_EOF(conf, *p)))
603
69138
		p++;
604
46036
	return (p);
605
}
606
607
static char *
608
eat_alpha_numeric(CONF *conf, char *p)
609
{
610
230620
	for (;;) {
611
216045
		if (IS_ESC(conf, *p)) {
612
			p = scan_esc(conf, p);
613
			continue;
614
		}
615
216045
		if (!IS_ALPHA_NUMERIC_PUNCT(conf, *p))
616
14575
			return (p);
617
201470
		p++;
618
	}
619
}
620
621
static char *
622
scan_quote(CONF *conf, char *p)
623
{
624
	int q = *p;
625
626
	p++;
627
	while (!(IS_EOF(conf, *p)) && (*p != q)) {
628
		if (IS_ESC(conf, *p)) {
629
			p++;
630
			if (IS_EOF(conf, *p))
631
				return (p);
632
		}
633
		p++;
634
	}
635
	if (*p == q)
636
		p++;
637
	return (p);
638
}
639
640
641
static char *
642
scan_dquote(CONF *conf, char *p)
643
{
644
	int q = *p;
645
646
	p++;
647
	while (!(IS_EOF(conf, *p))) {
648
		if (*p == q) {
649
			if (*(p + 1) == q) {
650
				p++;
651
			} else {
652
				break;
653
			}
654
		}
655
		p++;
656
	}
657
	if (*p == q)
658
		p++;
659
	return (p);
660
}
661
662
static void
663
dump_value_doall_arg(CONF_VALUE *a, BIO *out)
664
{
665
	if (a->name)
666
		BIO_printf(out, "[%s] %s=%s\n", a->section, a->name, a->value);
667
	else
668
		BIO_printf(out, "[[%s]]\n", a->section);
669
}
670
671
static IMPLEMENT_LHASH_DOALL_ARG_FN(dump_value, CONF_VALUE, BIO)
672
673
static int
674
def_dump(const CONF *conf, BIO *out)
675
{
676
	lh_CONF_VALUE_doall_arg(conf->data, LHASH_DOALL_ARG_FN(dump_value),
677
	    BIO, out);
678
	return 1;
679
}
680
681
static int
682
def_is_number(const CONF *conf, char c)
683
{
684
56
	return IS_NUMBER(conf, c);
685
}
686
687
static int
688
def_to_int(const CONF *conf, char c)
689
{
690
28
	return c - '0';
691
}