parser.c 70 KB
Newer Older
1
/*
2
 * Copyright (C) 2004-2015  Internet Systems Consortium, Inc. ("ISC")
Mark Andrews's avatar
Mark Andrews committed
3
 * Copyright (C) 2000-2003  Internet Software Consortium.
4
 *
Automatic Updater's avatar
Automatic Updater committed
5
 * Permission to use, copy, modify, and/or distribute this software for any
6 7 8
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
Mark Andrews's avatar
Mark Andrews committed
9 10 11 12 13 14 15
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
16 17
 */

18
/*! \file */
19 20 21

#include <config.h>

Evan Hunt's avatar
Evan Hunt committed
22 23
#include <stdlib.h>

24 25
#include <isc/buffer.h>
#include <isc/dir.h>
26
#include <isc/formatcheck.h>
27 28 29 30 31
#include <isc/lex.h>
#include <isc/log.h>
#include <isc/mem.h>
#include <isc/net.h>
#include <isc/netaddr.h>
32
#include <isc/netscope.h>
33
#include <isc/print.h>
34 35 36
#include <isc/string.h>
#include <isc/sockaddr.h>
#include <isc/symtab.h>
37
#include <isc/util.h>
38 39

#include <isccfg/cfg.h>
40
#include <isccfg/grammar.h>
41
#include <isccfg/log.h>
42

43
/* Shorthand */
44 45
#define CAT CFG_LOGCATEGORY_CONFIG
#define MOD CFG_LOGMODULE_PARSER
46 47 48

#define MAP_SYM 1 	/* Unique type for isc_symtab */

49 50
#define TOKEN_STRING(pctx) (pctx->token.value.as_textregion.base)

51 52
/* Check a return value. */
#define CHECK(op) 						\
Automatic Updater's avatar
Automatic Updater committed
53
	do { result = (op); 					\
54 55 56 57 58 59 60 61 62 63 64 65 66
		if (result != ISC_R_SUCCESS) goto cleanup; 	\
	} while (0)

/* Clean up a configuration object if non-NULL. */
#define CLEANUP_OBJ(obj) \
	do { if ((obj) != NULL) cfg_obj_destroy(pctx, &(obj)); } while (0)


/*
 * Forward declarations of static functions.
 */

static void
67
free_tuple(cfg_parser_t *pctx, cfg_obj_t *obj);
68

69
static isc_result_t
70
parse_list(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
71 72

static void
73
print_list(cfg_printer_t *pctx, const cfg_obj_t *obj);
74 75

static void
76
free_list(cfg_parser_t *pctx, cfg_obj_t *obj);
77

78
static isc_result_t
79
create_listelt(cfg_parser_t *pctx, cfg_listelt_t **eltp);
80 81

static isc_result_t
82 83
create_string(cfg_parser_t *pctx, const char *contents, const cfg_type_t *type,
	      cfg_obj_t **ret);
84 85

static void
86
free_string(cfg_parser_t *pctx, cfg_obj_t *obj);
87

88
static isc_result_t
89
create_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **objp);
90 91

static void
92
free_map(cfg_parser_t *pctx, cfg_obj_t *obj);
93 94 95

static isc_result_t
parse_symtab_elt(cfg_parser_t *pctx, const char *name,
96 97
		 cfg_type_t *elttype, isc_symtab_t *symtab,
		 isc_boolean_t callback);
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113

static void
free_noop(cfg_parser_t *pctx, cfg_obj_t *obj);

static isc_result_t
cfg_getstringtoken(cfg_parser_t *pctx);

static void
parser_complain(cfg_parser_t *pctx, isc_boolean_t is_warning,
		unsigned int flags, const char *format, va_list args);

/*
 * Data representations.  These correspond to members of the
 * "value" union in struct cfg_obj (except "void", which does
 * not need a union member).
 */
114

115
cfg_rep_t cfg_rep_uint32 = { "uint32", free_noop };
116
cfg_rep_t cfg_rep_uint64 = { "uint64", free_noop };
117 118 119 120 121 122 123 124
cfg_rep_t cfg_rep_string = { "string", free_string };
cfg_rep_t cfg_rep_boolean = { "boolean", free_noop };
cfg_rep_t cfg_rep_map = { "map", free_map };
cfg_rep_t cfg_rep_list = { "list", free_list };
cfg_rep_t cfg_rep_tuple = { "tuple", free_tuple };
cfg_rep_t cfg_rep_sockaddr = { "sockaddr", free_noop };
cfg_rep_t cfg_rep_netprefix = { "netprefix", free_noop };
cfg_rep_t cfg_rep_void = { "void", free_noop };
Evan Hunt's avatar
Evan Hunt committed
125
cfg_rep_t cfg_rep_fixedpoint = { "fixedpoint", free_noop };
126
cfg_rep_t cfg_rep_percentage = { "percentage", free_noop };
127 128 129 130 131

/*
 * Configuration type definitions.
 */

132
/*%
133 134 135
 * An implicit list.  These are formed by clauses that occur multiple times.
 */
static cfg_type_t cfg_type_implicitlist = {
136
	"implicitlist", NULL, print_list, NULL, &cfg_rep_list, NULL };
137 138 139

/* Functions. */

140
void
141
cfg_print_obj(cfg_printer_t *pctx, const cfg_obj_t *obj) {
142 143 144
	obj->type->print(pctx, obj);
}

145 146
void
cfg_print_chars(cfg_printer_t *pctx, const char *text, int len) {
147 148 149 150 151
	pctx->f(pctx->closure, text, len);
}

static void
print_open(cfg_printer_t *pctx) {
152 153 154 155 156 157
	if ((pctx->flags & CFG_PRINTER_ONELINE) != 0)
		cfg_print_cstr(pctx, "{ ");
	else {
		cfg_print_cstr(pctx, "{\n");
		pctx->indent++;
	}
158 159 160 161 162
}

static void
print_indent(cfg_printer_t *pctx) {
	int indent = pctx->indent;
163 164 165 166
	if ((pctx->flags & CFG_PRINTER_ONELINE) != 0) {
		cfg_print_cstr(pctx, " ");
		return;
	}
167
	while (indent > 0) {
168
		cfg_print_cstr(pctx, "\t");
169 170 171 172 173 174
		indent--;
	}
}

static void
print_close(cfg_printer_t *pctx) {
175 176 177 178 179
	if ((pctx->flags & CFG_PRINTER_ONELINE) == 0) {
		pctx->indent--;
		print_indent(pctx);
	}
	cfg_print_cstr(pctx, "}");
180 181
}

182 183
isc_result_t
cfg_parse_obj(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
Andreas Gustafsson's avatar
Andreas Gustafsson committed
184 185 186 187 188 189 190
	isc_result_t result;
	INSIST(ret != NULL && *ret == NULL);
	result = type->parse(pctx, type, ret);
	if (result != ISC_R_SUCCESS)
		return (result);
	INSIST(*ret != NULL);
	return (ISC_R_SUCCESS);
191 192 193
}

void
194
cfg_print(const cfg_obj_t *obj,
195 196
	  void (*f)(void *closure, const char *text, int textlen),
	  void *closure)
197 198 199 200 201 202 203 204
{
	cfg_printx(obj, 0, f, closure);
}

void
cfg_printx(const cfg_obj_t *obj, unsigned int flags,
	     void (*f)(void *closure, const char *text, int textlen),
	     void *closure)
205 206 207 208 209
{
	cfg_printer_t pctx;
	pctx.f = f;
	pctx.closure = closure;
	pctx.indent = 0;
210
	pctx.flags = flags;
211 212 213
	obj->type->print(&pctx, obj);
}

214
/* Tuples. */
Automatic Updater's avatar
Automatic Updater committed
215

216 217
isc_result_t
cfg_create_tuple(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
218
	isc_result_t result;
219 220
	const cfg_tuplefielddef_t *fields = type->of;
	const cfg_tuplefielddef_t *f;
221 222 223
	cfg_obj_t *obj = NULL;
	unsigned int nfields = 0;
	int i;
224

225
	for (f = fields; f->name != NULL; f++)
226 227
		nfields++;

228
	CHECK(cfg_create_obj(pctx, type, &obj));
229 230
	obj->value.tuple = isc_mem_get(pctx->mctx,
				       nfields * sizeof(cfg_obj_t *));
231 232 233 234
	if (obj->value.tuple == NULL) {
		result = ISC_R_NOMEMORY;
		goto cleanup;
	}
235
	for (f = fields, i = 0; f->name != NULL; f++, i++)
236
		obj->value.tuple[i] = NULL;
237 238 239 240
	*ret = obj;
	return (ISC_R_SUCCESS);

 cleanup:
241 242
	if (obj != NULL)
		isc_mem_put(pctx->mctx, obj, sizeof(*obj));
243 244 245
	return (result);
}

246 247
isc_result_t
cfg_parse_tuple(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
248 249
{
	isc_result_t result;
250 251
	const cfg_tuplefielddef_t *fields = type->of;
	const cfg_tuplefielddef_t *f;
252 253
	cfg_obj_t *obj = NULL;
	unsigned int i;
254

255
	CHECK(cfg_create_tuple(pctx, type, &obj));
256
	for (f = fields, i = 0; f->name != NULL; f++, i++)
257
		CHECK(cfg_parse_obj(pctx, f->type, &obj->value.tuple[i]));
258 259 260 261 262 263 264 265 266

	*ret = obj;
	return (ISC_R_SUCCESS);

 cleanup:
	CLEANUP_OBJ(obj);
	return (result);
}

267
void
268
cfg_print_tuple(cfg_printer_t *pctx, const cfg_obj_t *obj) {
269
	unsigned int i;
270 271
	const cfg_tuplefielddef_t *fields = obj->type->of;
	const cfg_tuplefielddef_t *f;
272
	isc_boolean_t need_space = ISC_FALSE;
273

274
	for (f = fields, i = 0; f->name != NULL; f++, i++) {
275
		const cfg_obj_t *fieldobj = obj->value.tuple[i];
276
		if (need_space && fieldobj->type->rep != &cfg_rep_void)
277
			cfg_print_cstr(pctx, " ");
278
		cfg_print_obj(pctx, fieldobj);
279 280
		need_space = ISC_TF(need_space ||
				    fieldobj->type->print != cfg_print_void);
281 282 283 284 285 286 287 288 289 290 291
	}
}

void
cfg_doc_tuple(cfg_printer_t *pctx, const cfg_type_t *type) {
	const cfg_tuplefielddef_t *fields = type->of;
	const cfg_tuplefielddef_t *f;
	isc_boolean_t need_space = ISC_FALSE;

	for (f = fields; f->name != NULL; f++) {
		if (need_space)
292
			cfg_print_cstr(pctx, " ");
293 294
		cfg_doc_obj(pctx, f->type);
		need_space = ISC_TF(f->type->print != cfg_print_void);
295 296 297 298 299 300
	}
}

static void
free_tuple(cfg_parser_t *pctx, cfg_obj_t *obj) {
	unsigned int i;
301 302
	const cfg_tuplefielddef_t *fields = obj->type->of;
	const cfg_tuplefielddef_t *f;
303 304
	unsigned int nfields = 0;

305 306 307
	if (obj->value.tuple == NULL)
		return;

308
	for (f = fields, i = 0; f->name != NULL; f++, i++) {
309 310 311 312 313 314 315
		CLEANUP_OBJ(obj->value.tuple[i]);
		nfields++;
	}
	isc_mem_put(pctx->mctx, obj->value.tuple,
		    nfields * sizeof(cfg_obj_t *));
}

316
isc_boolean_t
317
cfg_obj_istuple(const cfg_obj_t *obj) {
318 319 320 321
	REQUIRE(obj != NULL);
	return (ISC_TF(obj->type->rep == &cfg_rep_tuple));
}

322 323
const cfg_obj_t *
cfg_tuple_get(const cfg_obj_t *tupleobj, const char* name) {
324
	unsigned int i;
325 326
	const cfg_tuplefielddef_t *fields;
	const cfg_tuplefielddef_t *f;
Automatic Updater's avatar
Automatic Updater committed
327

328 329 330 331 332 333 334 335 336 337 338
	REQUIRE(tupleobj != NULL && tupleobj->type->rep == &cfg_rep_tuple);

	fields = tupleobj->type->of;
	for (f = fields, i = 0; f->name != NULL; f++, i++) {
		if (strcmp(f->name, name) == 0)
			return (tupleobj->value.tuple[i]);
	}
	INSIST(0);
	return (NULL);
}

339 340
isc_result_t
cfg_parse_special(cfg_parser_t *pctx, int special) {
Automatic Updater's avatar
Automatic Updater committed
341
	isc_result_t result;
342 343 344 345 346
	CHECK(cfg_gettoken(pctx, 0));
	if (pctx->token.type == isc_tokentype_special &&
	    pctx->token.value.as_char == special)
		return (ISC_R_SUCCESS);

347
	cfg_parser_error(pctx, CFG_LOG_NEAR, "'%c' expected", special);
348 349 350 351 352 353 354 355 356 357 358 359 360 361
	return (ISC_R_UNEXPECTEDTOKEN);
 cleanup:
	return (result);
}

/*
 * Parse a required semicolon.  If it is not there, log
 * an error and increment the error count but continue
 * parsing.  Since the next token is pushed back,
 * care must be taken to make sure it is eventually
 * consumed or an infinite loop may result.
 */
static isc_result_t
parse_semicolon(cfg_parser_t *pctx) {
Automatic Updater's avatar
Automatic Updater committed
362
	isc_result_t result;
363 364 365 366 367
	CHECK(cfg_gettoken(pctx, 0));
	if (pctx->token.type == isc_tokentype_special &&
	    pctx->token.value.as_char == ';')
		return (ISC_R_SUCCESS);

368
	cfg_parser_error(pctx, CFG_LOG_BEFORE, "missing ';'");
369 370 371 372 373 374 375 376 377 378
	cfg_ungettoken(pctx);
 cleanup:
	return (result);
}

/*
 * Parse EOF, logging and returning an error if not there.
 */
static isc_result_t
parse_eof(cfg_parser_t *pctx) {
Automatic Updater's avatar
Automatic Updater committed
379
	isc_result_t result;
380 381 382 383 384
	CHECK(cfg_gettoken(pctx, 0));

	if (pctx->token.type == isc_tokentype_eof)
		return (ISC_R_SUCCESS);

385
	cfg_parser_error(pctx, CFG_LOG_NEAR, "syntax error");
386 387
	return (ISC_R_UNEXPECTEDTOKEN);
 cleanup:
Andreas Gustafsson's avatar
spacing  
Andreas Gustafsson committed
388
	return (result);
389 390 391
}

/* A list of files, used internally for pctx->files. */
392

393
static cfg_type_t cfg_type_filelist = {
394
	"filelist", NULL, print_list, NULL, &cfg_rep_list,
395 396 397 398
	&cfg_type_qstring
};

isc_result_t
399
cfg_parser_create(isc_mem_t *mctx, isc_log_t *lctx, cfg_parser_t **ret) {
400 401 402 403 404 405 406 407 408 409 410
	isc_result_t result;
	cfg_parser_t *pctx;
	isc_lexspecials_t specials;

	REQUIRE(mctx != NULL);
	REQUIRE(ret != NULL && *ret == NULL);

	pctx = isc_mem_get(mctx, sizeof(*pctx));
	if (pctx == NULL)
		return (ISC_R_NOMEMORY);

411 412 413
	pctx->mctx = NULL;
	isc_mem_attach(mctx, &pctx->mctx);

414 415
	result = isc_refcount_init(&pctx->references, 1);
	if (result != ISC_R_SUCCESS) {
416
		isc_mem_putanddetach(&pctx->mctx, pctx, sizeof(*pctx));
417 418 419
		return (result);
	}

420 421 422 423 424
	pctx->lctx = lctx;
	pctx->lexer = NULL;
	pctx->seen_eof = ISC_FALSE;
	pctx->ungotten = ISC_FALSE;
	pctx->errors = 0;
Mark Andrews's avatar
Mark Andrews committed
425
	pctx->warnings = 0;
426 427
	pctx->open_files = NULL;
	pctx->closed_files = NULL;
428
	pctx->line = 0;
429 430
	pctx->callback = NULL;
	pctx->callbackarg = NULL;
Mark Andrews's avatar
Mark Andrews committed
431
	pctx->token.type = isc_tokentype_unknown;
Automatic Updater's avatar
Automatic Updater committed
432
	pctx->flags = 0;
433
	pctx->buf_name = NULL;
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449

	memset(specials, 0, sizeof(specials));
	specials['{'] = 1;
	specials['}'] = 1;
	specials[';'] = 1;
	specials['/'] = 1;
	specials['"'] = 1;
	specials['!'] = 1;

	CHECK(isc_lex_create(pctx->mctx, 1024, &pctx->lexer));

	isc_lex_setspecials(pctx->lexer, specials);
	isc_lex_setcomments(pctx->lexer, (ISC_LEXCOMMENT_C |
					 ISC_LEXCOMMENT_CPLUSPLUS |
					 ISC_LEXCOMMENT_SHELL));

450 451
	CHECK(cfg_create_list(pctx, &cfg_type_filelist, &pctx->open_files));
	CHECK(cfg_create_list(pctx, &cfg_type_filelist, &pctx->closed_files));
452 453 454 455 456 457 458

	*ret = pctx;
	return (ISC_R_SUCCESS);

 cleanup:
	if (pctx->lexer != NULL)
		isc_lex_destroy(&pctx->lexer);
459 460
	CLEANUP_OBJ(pctx->open_files);
	CLEANUP_OBJ(pctx->closed_files);
461
	isc_mem_putanddetach(&pctx->mctx, pctx, sizeof(*pctx));
462 463 464 465
	return (result);
}

static isc_result_t
466
parser_openfile(cfg_parser_t *pctx, const char *filename) {
467 468 469 470 471 472
	isc_result_t result;
	cfg_listelt_t *elt = NULL;
	cfg_obj_t *stringobj = NULL;

	result = isc_lex_openfile(pctx->lexer, filename);
	if (result != ISC_R_SUCCESS) {
473
		cfg_parser_error(pctx, 0, "open: %s: %s",
474 475 476 477 478 479 480
			     filename, isc_result_totext(result));
		goto cleanup;
	}

	CHECK(create_string(pctx, filename, &cfg_type_qstring, &stringobj));
	CHECK(create_listelt(pctx, &elt));
	elt->obj = stringobj;
481
	ISC_LIST_APPEND(pctx->open_files->value.list, elt, link);
482 483 484 485 486 487 488

	return (ISC_R_SUCCESS);
 cleanup:
	CLEANUP_OBJ(stringobj);
	return (result);
}

489 490 491 492 493 494 495 496 497
void
cfg_parser_setcallback(cfg_parser_t *pctx,
		       cfg_parsecallback_t callback,
		       void *arg)
{
	pctx->callback = callback;
	pctx->callbackarg = arg;
}

498 499 500 501 502 503 504 505 506 507 508 509 510 511
void
cfg_parser_reset(cfg_parser_t *pctx) {
	REQUIRE(pctx != NULL);

	if (pctx->lexer != NULL)
		isc_lex_close(pctx->lexer);

	pctx->seen_eof = ISC_FALSE;
	pctx->ungotten = ISC_FALSE;
	pctx->errors = 0;
	pctx->warnings = 0;
	pctx->line = 0;
}

512 513 514 515 516
/*
 * Parse a configuration using a pctx where a lexer has already
 * been set up with a source.
 */
static isc_result_t
517
parse2(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
518 519 520
	isc_result_t result;
	cfg_obj_t *obj = NULL;

521
	result = cfg_parse_obj(pctx, type, &obj);
522 523 524 525 526 527 528 529 530 531

	if (pctx->errors != 0) {
		/* Errors have been logged. */
		if (result == ISC_R_SUCCESS)
			result = ISC_R_FAILURE;
		goto cleanup;
	}

	if (result != ISC_R_SUCCESS) {
		/* Parsing failed but no errors have been logged. */
532
		cfg_parser_error(pctx, 0, "parsing failed");
533 534 535 536 537 538 539 540 541 542 543 544 545
		goto cleanup;
	}

	CHECK(parse_eof(pctx));

	*ret = obj;
	return (ISC_R_SUCCESS);

 cleanup:
	CLEANUP_OBJ(obj);
	return (result);
}

546 547
isc_result_t
cfg_parse_file(cfg_parser_t *pctx, const char *filename,
548
	       const cfg_type_t *type, cfg_obj_t **ret)
549 550
{
	isc_result_t result;
551
	cfg_listelt_t *elt;
552 553 554 555

	REQUIRE(filename != NULL);

	CHECK(parser_openfile(pctx, filename));
556 557 558 559 560 561 562 563 564

	result = parse2(pctx, type, ret);

	/* Clean up the opened file */
	elt = ISC_LIST_TAIL(pctx->open_files->value.list);
	INSIST(elt != NULL);
	ISC_LIST_UNLINK(pctx->open_files->value.list, elt, link);
	ISC_LIST_APPEND(pctx->closed_files->value.list, elt, link);

565 566 567 568 569 570 571
 cleanup:
	return (result);
}


isc_result_t
cfg_parse_buffer(cfg_parser_t *pctx, isc_buffer_t *buffer,
572
	const cfg_type_t *type, cfg_obj_t **ret)
573 574 575 576 577 578 579 580
{
	return (cfg_parse_buffer2(pctx, buffer, NULL, type, ret));
}

isc_result_t
cfg_parse_buffer2(cfg_parser_t *pctx, isc_buffer_t *buffer,
		  const char *bufname, const cfg_type_t *type,
		  cfg_obj_t **ret)
581 582
{
	isc_result_t result;
583

584
	REQUIRE(buffer != NULL);
585

Automatic Updater's avatar
Automatic Updater committed
586
	CHECK(isc_lex_openbuffer(pctx->lexer, buffer));
587
	pctx->buf_name = bufname;
588
	CHECK(parse2(pctx, type, ret));
589
	pctx->buf_name = NULL;
590

591 592 593 594
 cleanup:
	return (result);
}

595 596 597 598 599 600 601 602
void
cfg_parser_attach(cfg_parser_t *src, cfg_parser_t **dest) {
	REQUIRE(src != NULL);
	REQUIRE(dest != NULL && *dest == NULL);
	isc_refcount_increment(&src->references, NULL);
	*dest = src;
}

603 604 605
void
cfg_parser_destroy(cfg_parser_t **pctxp) {
	cfg_parser_t *pctx = *pctxp;
606 607 608 609 610 611 612 613 614 615 616 617
	unsigned int refs;

	isc_refcount_decrement(&pctx->references, &refs);
	if (refs == 0) {
		isc_lex_destroy(&pctx->lexer);
		/*
		 * Cleaning up open_files does not
		 * close the files; that was already done
		 * by closing the lexer.
		 */
		CLEANUP_OBJ(pctx->open_files);
		CLEANUP_OBJ(pctx->closed_files);
618
		isc_mem_putanddetach(&pctx->mctx, pctx, sizeof(*pctx));
619
	}
620 621 622 623 624 625
	*pctxp = NULL;
}

/*
 * void
 */
626 627
isc_result_t
cfg_parse_void(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
628
	UNUSED(type);
629
	return (cfg_create_obj(pctx, &cfg_type_void, ret));
630 631
}

632
void
633
cfg_print_void(cfg_printer_t *pctx, const cfg_obj_t *obj) {
634 635 636
	UNUSED(pctx);
	UNUSED(obj);
}
637

638 639 640 641 642 643
void
cfg_doc_void(cfg_printer_t *pctx, const cfg_type_t *type) {
	UNUSED(pctx);
	UNUSED(type);
}

644
isc_boolean_t
645
cfg_obj_isvoid(const cfg_obj_t *obj) {
646 647 648 649
	REQUIRE(obj != NULL);
	return (ISC_TF(obj->type->rep == &cfg_rep_void));
}

650 651 652
cfg_type_t cfg_type_void = {
	"void", cfg_parse_void, cfg_print_void, cfg_doc_void, &cfg_rep_void,
	NULL };
653

654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
/*
 * percentage
 */
isc_result_t
cfg_parse_percentage(cfg_parser_t *pctx, const cfg_type_t *type,
		     cfg_obj_t **ret)
{
	char *endp;
	isc_result_t result;
	cfg_obj_t *obj = NULL;
	isc_uint32_t percent;

	UNUSED(type);

	CHECK(cfg_gettoken(pctx, 0));
	if (pctx->token.type != isc_tokentype_string) {
		cfg_parser_error(pctx, CFG_LOG_NEAR,
				 "expected percentage");
		return (ISC_R_UNEXPECTEDTOKEN);
	}

	percent = isc_string_touint64(TOKEN_STRING(pctx), &endp, 10);
	if (*endp != '%' || *(endp+1) != 0) {
		cfg_parser_error(pctx, CFG_LOG_NEAR,
				 "expected percentage");
		return (ISC_R_UNEXPECTEDTOKEN);
	}

	CHECK(cfg_create_obj(pctx, &cfg_type_percentage, &obj));
	obj->value.uint32 = percent;
	*ret = obj;

 cleanup:
	return (result);
}

void
cfg_print_percentage(cfg_printer_t *pctx, const cfg_obj_t *obj) {
	char buf[64];
	int n;

	n = snprintf(buf, sizeof(buf), "%u%%", obj->value.uint32);
	INSIST(n > 0 && (size_t)n < sizeof(buf));
	cfg_print_chars(pctx, buf, strlen(buf));
}

isc_uint32_t
cfg_obj_aspercentage(const cfg_obj_t *obj) {
	REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_percentage);
	return (obj->value.uint32);
}

cfg_type_t cfg_type_percentage = {
	"percentage", cfg_parse_percentage, cfg_print_percentage,
	cfg_doc_terminal, &cfg_rep_percentage, NULL
};

isc_boolean_t
cfg_obj_ispercentage(const cfg_obj_t *obj) {
	REQUIRE(obj != NULL);
	return (ISC_TF(obj->type->rep == &cfg_rep_percentage));
}

Evan Hunt's avatar
Evan Hunt committed
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
/*
 * Fixed point
 */
isc_result_t
cfg_parse_fixedpoint(cfg_parser_t *pctx, const cfg_type_t *type,
		     cfg_obj_t **ret)
{
	isc_result_t result;
	cfg_obj_t *obj = NULL;
	size_t n1, n2, n3, l;
	const char *p;

	UNUSED(type);

	CHECK(cfg_gettoken(pctx, 0));
	if (pctx->token.type != isc_tokentype_string) {
		cfg_parser_error(pctx, CFG_LOG_NEAR,
				 "expected fixed point number");
		return (ISC_R_UNEXPECTEDTOKEN);
	}


	p = TOKEN_STRING(pctx);
	l = strlen(p);
	n1 = strspn(p, "0123456789");
	n2 = strspn(p + n1, ".");
	n3 = strspn(p + n1 + n2, "0123456789");

	if ((n1 + n2 + n3 != l) || (n1 + n3 == 0) ||
	    n1 > 5 || n2 > 1 || n3 > 2) {
		cfg_parser_error(pctx, CFG_LOG_NEAR,
				 "expected fixed point number");
		return (ISC_R_UNEXPECTEDTOKEN);
	}

	CHECK(cfg_create_obj(pctx, &cfg_type_fixedpoint, &obj));

	obj->value.uint32 = strtoul(p, NULL, 10) * 100;
	switch (n3) {
	case 2:
		obj->value.uint32 += strtoul(p + n1 + n2, NULL, 10);
		break;
	case 1:
		obj->value.uint32 += strtoul(p + n1 + n2, NULL, 10) * 10;
		break;
	}
	*ret = obj;

 cleanup:
	return (result);
}

void
cfg_print_fixedpoint(cfg_printer_t *pctx, const cfg_obj_t *obj) {
	char buf[64];
	int n;

	n = snprintf(buf, sizeof(buf), "%u.%02u",
		     obj->value.uint32/100, obj->value.uint32%100);
	INSIST(n > 0 && (size_t)n < sizeof(buf));
	cfg_print_chars(pctx, buf, strlen(buf));
}

isc_uint32_t
cfg_obj_asfixedpoint(const cfg_obj_t *obj) {
	REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_fixedpoint);
	return (obj->value.uint32);
}

cfg_type_t cfg_type_fixedpoint = {
	"fixedpoint", cfg_parse_fixedpoint, cfg_print_fixedpoint,
	cfg_doc_terminal, &cfg_rep_fixedpoint, NULL
};
790

791 792 793 794 795 796
isc_boolean_t
cfg_obj_isfixedpoint(const cfg_obj_t *obj) {
	REQUIRE(obj != NULL);
	return (ISC_TF(obj->type->rep == &cfg_rep_fixedpoint));
}

797 798 799
/*
 * uint32
 */
800 801
isc_result_t
cfg_parse_uint32(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
Automatic Updater's avatar
Automatic Updater committed
802
	isc_result_t result;
803 804 805
	cfg_obj_t *obj = NULL;
	UNUSED(type);

806
	CHECK(cfg_gettoken(pctx, ISC_LEXOPT_NUMBER | ISC_LEXOPT_CNUMBER));
807
	if (pctx->token.type != isc_tokentype_number) {
808
		cfg_parser_error(pctx, CFG_LOG_NEAR, "expected number");
809 810 811
		return (ISC_R_UNEXPECTEDTOKEN);
	}

812
	CHECK(cfg_create_obj(pctx, &cfg_type_uint32, &obj));
813 814 815 816 817 818 819

	obj->value.uint32 = pctx->token.value.as_ulong;
	*ret = obj;
 cleanup:
	return (result);
}

820 821 822
void
cfg_print_cstr(cfg_printer_t *pctx, const char *s) {
	cfg_print_chars(pctx, s, strlen(s));
823 824
}

825 826
void
cfg_print_rawuint(cfg_printer_t *pctx, unsigned int u) {
827
	char buf[32];
828
	snprintf(buf, sizeof(buf), "%u", u);
829
	cfg_print_cstr(pctx, buf);
830 831
}

832
void
833
cfg_print_uint32(cfg_printer_t *pctx, const cfg_obj_t *obj) {
834
	cfg_print_rawuint(pctx, obj->value.uint32);
835 836
}

837
isc_boolean_t
838
cfg_obj_isuint32(const cfg_obj_t *obj) {
839 840 841 842
	REQUIRE(obj != NULL);
	return (ISC_TF(obj->type->rep == &cfg_rep_uint32));
}

843
isc_uint32_t
844
cfg_obj_asuint32(const cfg_obj_t *obj) {
845 846 847 848
	REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_uint32);
	return (obj->value.uint32);
}

849 850 851 852
cfg_type_t cfg_type_uint32 = {
	"integer", cfg_parse_uint32, cfg_print_uint32, cfg_doc_terminal,
	&cfg_rep_uint32, NULL
};
853 854


855 856 857 858
/*
 * uint64
 */
isc_boolean_t
859
cfg_obj_isuint64(const cfg_obj_t *obj) {
860 861 862 863 864
	REQUIRE(obj != NULL);
	return (ISC_TF(obj->type->rep == &cfg_rep_uint64));
}

isc_uint64_t
865
cfg_obj_asuint64(const cfg_obj_t *obj) {
866 867 868 869
	REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_uint64);
	return (obj->value.uint64);
}

870
void
871
cfg_print_uint64(cfg_printer_t *pctx, const cfg_obj_t *obj) {
872
	char buf[32];
873 874
	snprintf(buf, sizeof(buf), "%" ISC_PRINT_QUADFORMAT "u",
		 obj->value.uint64);
875
	cfg_print_cstr(pctx, buf);
876 877
}

878 879 880
cfg_type_t cfg_type_uint64 = {
	"64_bit_integer", NULL, cfg_print_uint64, cfg_doc_terminal,
	&cfg_rep_uint64, NULL
881 882
};

883
/*
884 885
 * qstring (quoted string), ustring (unquoted string), astring
 * (any string)
886 887 888 889
 */

/* Create a string object from a null-terminated C string. */
static isc_result_t
890
create_string(cfg_parser_t *pctx, const char *contents, const cfg_type_t *type,
891 892 893 894 895 896
	      cfg_obj_t **ret)
{
	isc_result_t result;
	cfg_obj_t *obj = NULL;
	int len;

897
	CHECK(cfg_create_obj(pctx, type, &obj));
898 899 900 901
	len = strlen(contents);
	obj->value.string.length = len;
	obj->value.string.base = isc_mem_get(pctx->mctx, len + 1);
	if (obj->value.string.base == 0) {
902
		isc_mem_put(pctx->mctx, obj, sizeof(*obj));
903 904
		return (ISC_R_NOMEMORY);
	}
905
	memmove(obj->value.string.base, contents, len);
906 907 908 909 910 911 912
	obj->value.string.base[len] = '\0';

	*ret = obj;
 cleanup:
	return (result);
}

913 914
isc_result_t
cfg_parse_qstring(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
Automatic Updater's avatar
Automatic Updater committed
915
	isc_result_t result;
916 917
	UNUSED(type);

918
	CHECK(cfg_gettoken(pctx, CFG_LEXOPT_QSTRING));
919
	if (pctx->token.type != isc_tokentype_qstring) {
920
		cfg_parser_error(pctx, CFG_LOG_NEAR, "expected quoted string");
921 922 923
		return (ISC_R_UNEXPECTEDTOKEN);
	}
	return (create_string(pctx,
924
			      TOKEN_STRING(pctx),
925 926 927 928 929 930 931
			      &cfg_type_qstring,
			      ret));
 cleanup:
	return (result);
}

static isc_result_t
932
parse_ustring(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
Automatic Updater's avatar
Automatic Updater committed
933
	isc_result_t result;
934 935 936 937
	UNUSED(type);

	CHECK(cfg_gettoken(pctx, 0));
	if (pctx->token.type != isc_tokentype_string) {
938
		cfg_parser_error(pctx, CFG_LOG_NEAR, "expected unquoted string");
939 940 941
		return (ISC_R_UNEXPECTEDTOKEN);
	}
	return (create_string(pctx,
942
			      TOKEN_STRING(pctx),
943 944 945 946 947 948
			      &cfg_type_ustring,
			      ret));
 cleanup:
	return (result);
}

949
isc_result_t
950 951 952
cfg_parse_astring(cfg_parser_t *pctx, const cfg_type_t *type,
		  cfg_obj_t **ret)
{
Automatic Updater's avatar
Automatic Updater committed
953
	isc_result_t result;
954 955 956 957
	UNUSED(type);

	CHECK(cfg_getstringtoken(pctx));
	return (create_string(pctx,
958
			      TOKEN_STRING(pctx),
959 960 961 962 963 964
			      &cfg_type_qstring,
			      ret));
 cleanup:
	return (result);
}

965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
isc_result_t
cfg_parse_sstring(cfg_parser_t *pctx, const cfg_type_t *type,
		  cfg_obj_t **ret)
{
	isc_result_t result;
	UNUSED(type);

	CHECK(cfg_getstringtoken(pctx));
	return (create_string(pctx,
			      TOKEN_STRING(pctx),
			      &cfg_type_sstring,
			      ret));
 cleanup:
	return (result);
}

Evan Hunt's avatar
Evan Hunt committed
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
static isc_result_t
parse_btext(cfg_parser_t *pctx, const cfg_type_t *type,
	    cfg_obj_t **ret)
{
	isc_result_t result;
	UNUSED(type);

	CHECK(cfg_gettoken(pctx, ISC_LEXOPT_BTEXT));
	if (pctx->token.type != isc_tokentype_btext) {
		cfg_parser_error(pctx, CFG_LOG_NEAR,
				 "expected bracketed text");
		return (ISC_R_UNEXPECTEDTOKEN);
	}
	return (create_string(pctx,
			      TOKEN_STRING(pctx),
			      &cfg_type_bracketed_text,
			      ret));
 cleanup:
	return (result);
}

static void
print_btext(cfg_printer_t *pctx, const cfg_obj_t *obj) {
	cfg_print_cstr(pctx, "{");
	cfg_print_chars(pctx, obj->value.string.base, obj->value.string.length);
	print_close(pctx);
}

static void
doc_btext(cfg_printer_t *pctx, const cfg_type_t *type) {
	UNUSED(type);

	cfg_print_cstr(pctx, "{ <unspecified text> }");
}


1017 1018
isc_boolean_t
cfg_is_enum(const char *s, const char *const *enums) {
1019
	const char * const *p;
Andreas Gustafsson's avatar
Andreas Gustafsson committed
1020 1021
	for (p = enums; *p != NULL; p++) {
		if (strcasecmp(*p, s) == 0)
1022
			return (ISC_TRUE);
Andreas Gustafsson's avatar
Andreas Gustafsson committed
1023
	}
1024 1025 1026 1027
	return (ISC_FALSE);
}

static isc_result_t
1028
check_enum(cfg_parser_t *pctx, cfg_obj_t *obj, const char *const *enums) {
1029
	const char *s = obj->value.string.base;
1030
	if (cfg_is_enum(s, enums))
1031
		return (ISC_R_SUCCESS);
1032
	cfg_parser_error(pctx, 0, "'%s' unexpected", s);
Andreas Gustafsson's avatar
Andreas Gustafsson committed
1033 1034 1035
	return (ISC_R_UNEXPECTEDTOKEN);
}

1036 1037
isc_result_t
cfg_parse_enum(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
Automatic Updater's avatar
Automatic Updater committed
1038
	isc_result_t result;
Andreas Gustafsson's avatar
Andreas Gustafsson committed
1039 1040 1041 1042 1043 1044
	cfg_obj_t *obj = NULL;
	CHECK(parse_ustring(pctx, NULL, &obj));
	CHECK(check_enum(pctx, obj, type->of));
	*ret = obj;
	return (ISC_R_SUCCESS);
 cleanup:
Automatic Updater's avatar
Automatic Updater committed
1045
	CLEANUP_OBJ(obj);
Andreas Gustafsson's avatar
Andreas Gustafsson committed
1046 1047 1048
	return (result);
}

1049 1050 1051
void
cfg_doc_enum(cfg_printer_t *pctx, const cfg_type_t *type) {
	const char * const *p;
1052
	cfg_print_cstr(pctx, "( ");
1053 1054 1055
	for (p = type->of; *p != NULL; p++) {
		cfg_print_cstr(pctx, *p);
		if (p[1] != NULL)
1056
			cfg_print_cstr(pctx, " | ");
1057
	}
1058
	cfg_print_cstr(pctx, " )");
1059 1060
}

1061
void
1062
cfg_print_ustring(cfg_printer_t *pctx, const cfg_obj_t *obj) {
1063
	cfg_print_chars(pctx, obj->value.string.base, obj->value.string.length);
1064 1065 1066
}

static void
1067
print_qstring(cfg_printer_t *pctx, const cfg_obj_t *obj) {
1068
	cfg_print_cstr(pctx, "\"");
1069
	cfg_print_ustring(pctx, obj);
1070
	cfg_print_cstr(pctx, "\"");
1071 1072
}

1073 1074
static void
print_sstring(cfg_printer_t *pctx, const cfg_obj_t *obj) {
1075
	cfg_print_cstr(pctx, "\"");
1076 1077 1078
	if ((pctx->flags & CFG_PRINTER_XKEY) != 0) {
		unsigned int len = obj->value.string.length;
		while (len-- > 0)
1079
			cfg_print_cstr(pctx, "?");
1080 1081
	} else
		cfg_print_ustring(pctx, obj);
1082
	cfg_print_cstr(pctx, "\"");
1083 1084
}

1085 1086
static void
free_string(cfg_parser_t *pctx, cfg_obj_t *obj) {
1087 1088
	isc_mem_put(pctx->mctx, obj->value.string.base,
		    obj->value.string.length + 1);
1089 1090
}

1091
isc_boolean_t
1092
cfg_obj_isstring(const cfg_obj_t *obj) {
1093 1094 1095 1096
	REQUIRE(obj != NULL);
	return (ISC_TF(obj->type->rep == &cfg_rep_string));
}

1097
const char *
1098
cfg_obj_asstring(const cfg_obj_t *obj) {
1099 1100 1101 1102
	REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_string);
	return (obj->value.string.base);
}