/*

 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * See the COPYRIGHT file distributed with this work for additional

 * information regarding copyright ownership.

 */

/*! \file */

#include <config.h>

#include <inttypes.h>

#include <stdbool.h>

#include <stdlib.h>

#include <isc/buffer.h>

#include <isc/dir.h>

#include <isc/formatcheck.h>

#include <isc/lex.h>

#include <isc/log.h>

#include <isc/mem.h>

#include <isc/net.h>

#include <isc/netaddr.h>

#include <isc/netscope.h>

#include <isc/print.h>

#include <isc/refcount.h>

#include <isc/string.h>

#include <isc/sockaddr.h>

#include <isc/symtab.h>

#include <isc/util.h>

#include <isccfg/cfg.h>

#include <isccfg/grammar.h>

#include <isccfg/log.h>

/* Shorthand */

#define CAT CFG_LOGCATEGORY_CONFIG

#define MOD CFG_LOGMODULE_PARSER

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

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

/* Check a return value. */

#define CHECK(op) 						\

	do { result = (op); 					\

		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

free_tuple(cfg_parser_t *pctx, cfg_obj_t *obj);

static isc_result_t

parse_list(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);

static void

print_list(cfg_printer_t *pctx, const cfg_obj_t *obj);

static void

free_list(cfg_parser_t *pctx, cfg_obj_t *obj);

static isc_result_t

create_listelt(cfg_parser_t *pctx, cfg_listelt_t **eltp);

static isc_result_t

create_string(cfg_parser_t *pctx, const char *contents, const cfg_type_t *type,

	      cfg_obj_t **ret);

static void

free_string(cfg_parser_t *pctx, cfg_obj_t *obj);

static isc_result_t

create_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **objp);

static void

free_map(cfg_parser_t *pctx, cfg_obj_t *obj);

static isc_result_t

parse_symtab_elt(cfg_parser_t *pctx, const char *name,

		 cfg_type_t *elttype, isc_symtab_t *symtab,

		 bool callback);

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, bool 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).

 */

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_uint32 = { "uint32", free_noop };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_uint64 = { "uint64", free_noop };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_string = { "string", free_string };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_boolean = { "boolean", free_noop };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_map = { "map", free_map };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_list = { "list", free_list };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_tuple = { "tuple", free_tuple };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_sockaddr = { "sockaddr", free_noop };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_netprefix =

	{ "netprefix", free_noop };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_void = { "void", free_noop };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_fixedpoint =

	{ "fixedpoint", free_noop };

LIBISCCFG_EXTERNAL_DATA cfg_rep_t cfg_rep_percentage =

	{ "percentage", free_noop };

/*

 * Configuration type definitions.

 */

/*%

 * An implicit list.  These are formed by clauses that occur multiple times.

 */

static cfg_type_t cfg_type_implicitlist = {

	"implicitlist", NULL, print_list, NULL, &cfg_rep_list, NULL };

/* Functions. */

void

cfg_print_obj(cfg_printer_t *pctx, const cfg_obj_t *obj) {

	REQUIRE(pctx != NULL);

	REQUIRE(obj != NULL);

	obj->type->print(pctx, obj);

}

void

cfg_print_chars(cfg_printer_t *pctx, const char *text, int len) {

	REQUIRE(pctx != NULL);

	REQUIRE(text != NULL);

	pctx->f(pctx->closure, text, len);

}

static void

print_open(cfg_printer_t *pctx) {

	if ((pctx->flags & CFG_PRINTER_ONELINE) != 0)

		cfg_print_cstr(pctx, "{ ");

	else {

		cfg_print_cstr(pctx, "{\n");

		pctx->indent++;

	}

}

void

cfg_print_indent(cfg_printer_t *pctx) {

	int indent = pctx->indent;

	if ((pctx->flags & CFG_PRINTER_ONELINE) != 0) {

		cfg_print_cstr(pctx, " ");

		return;

	}

	while (indent > 0) {

		cfg_print_cstr(pctx, "\t");

		indent--;

	}

}

static void

print_close(cfg_printer_t *pctx) {

	if ((pctx->flags & CFG_PRINTER_ONELINE) == 0) {

		pctx->indent--;

		cfg_print_indent(pctx);

	}

	cfg_print_cstr(pctx, "}");

}

isc_result_t

cfg_parse_obj(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {

	isc_result_t result;

	REQUIRE(pctx != NULL);

	REQUIRE(type != NULL);

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

	result = type->parse(pctx, type, ret);

	if (result != ISC_R_SUCCESS)

		return (result);

	ENSURE(*ret != NULL);

	return (ISC_R_SUCCESS);

}

void

cfg_print(const cfg_obj_t *obj,

	  void (*f)(void *closure, const char *text, int textlen),

	  void *closure)

{

	REQUIRE(obj != NULL);

	REQUIRE(f != NULL);

	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)

{

	cfg_printer_t pctx;

	REQUIRE(obj != NULL);

	REQUIRE(f != NULL);

	pctx.f = f;

	pctx.closure = closure;

	pctx.indent = 0;

	pctx.flags = flags;

	obj->type->print(&pctx, obj);

}

/* Tuples. */

isc_result_t

cfg_create_tuple(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {

	isc_result_t result;

	const cfg_tuplefielddef_t *fields;

	const cfg_tuplefielddef_t *f;

	cfg_obj_t *obj = NULL;

	unsigned int nfields = 0;

	int i;

	REQUIRE(pctx != NULL);

	REQUIRE(type != NULL);

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

	fields = type->of;

	for (f = fields; f->name != NULL; f++)

		nfields++;

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

	obj->value.tuple = isc_mem_get(pctx->mctx,

				       nfields * sizeof(cfg_obj_t *));

	if (obj->value.tuple == NULL) {

		result = ISC_R_NOMEMORY;

		goto cleanup;

	}

	for (f = fields, i = 0; f->name != NULL; f++, i++)

		obj->value.tuple[i] = NULL;

	*ret = obj;

	return (ISC_R_SUCCESS);

 cleanup:

	if (obj != NULL)

		isc_mem_put(pctx->mctx, obj, sizeof(*obj));

	return (result);

}

isc_result_t

cfg_parse_tuple(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)

{

	isc_result_t result;

	const cfg_tuplefielddef_t *fields;

	const cfg_tuplefielddef_t *f;

	cfg_obj_t *obj = NULL;

	unsigned int i;

	REQUIRE(pctx != NULL);

	REQUIRE(type != NULL);

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

	fields = type->of;

	CHECK(cfg_create_tuple(pctx, type, &obj));

	for (f = fields, i = 0; f->name != NULL; f++, i++)

		CHECK(cfg_parse_obj(pctx, f->type, &obj->value.tuple[i]));

	*ret = obj;

	return (ISC_R_SUCCESS);

 cleanup:

	CLEANUP_OBJ(obj);

	return (result);

}

void

cfg_print_tuple(cfg_printer_t *pctx, const cfg_obj_t *obj) {

	unsigned int i;

	const cfg_tuplefielddef_t *fields;

	const cfg_tuplefielddef_t *f;

	bool need_space = false;

	REQUIRE(pctx != NULL);

	REQUIRE(obj != NULL);

	fields = obj->type->of;

	for (f = fields, i = 0; f->name != NULL; f++, i++) {

		const cfg_obj_t *fieldobj = obj->value.tuple[i];

		if (need_space && fieldobj->type->rep != &cfg_rep_void)

			cfg_print_cstr(pctx, " ");

		cfg_print_obj(pctx, fieldobj);

		need_space = (need_space ||

			      fieldobj->type->print != cfg_print_void);

	}

}

void

cfg_doc_tuple(cfg_printer_t *pctx, const cfg_type_t *type) {

	const cfg_tuplefielddef_t *fields;

	const cfg_tuplefielddef_t *f;

	bool need_space = false;

	REQUIRE(pctx != NULL);

	REQUIRE(type != NULL);

	fields = type->of;

	for (f = fields; f->name != NULL; f++) {

		if (need_space)

			cfg_print_cstr(pctx, " ");

		cfg_doc_obj(pctx, f->type);

		need_space = (f->type->print != cfg_print_void);

	}

}

static void

free_tuple(cfg_parser_t *pctx, cfg_obj_t *obj) {

	unsigned int i;

	const cfg_tuplefielddef_t *fields = obj->type->of;

	const cfg_tuplefielddef_t *f;

	unsigned int nfields = 0;

	if (obj->value.tuple == NULL)

		return;

	for (f = fields, i = 0; f->name != NULL; f++, i++) {

		CLEANUP_OBJ(obj->value.tuple[i]);

		nfields++;

	}

	isc_mem_put(pctx->mctx, obj->value.tuple,

		    nfields * sizeof(cfg_obj_t *));

}

bool

cfg_obj_istuple(const cfg_obj_t *obj) {

	REQUIRE(obj != NULL);

	return (obj->type->rep == &cfg_rep_tuple);

}

const cfg_obj_t *

cfg_tuple_get(const cfg_obj_t *tupleobj, const char* name) {

	unsigned int i;

	const cfg_tuplefielddef_t *fields;

	const cfg_tuplefielddef_t *f;

	REQUIRE(tupleobj != NULL && tupleobj->type->rep == &cfg_rep_tuple);

	REQUIRE(name != NULL);

	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);

	ISC_UNREACHABLE();

}

isc_result_t

cfg_parse_special(cfg_parser_t *pctx, int special) {

	isc_result_t result;

	REQUIRE(pctx != NULL);

	CHECK(cfg_gettoken(pctx, 0));

	if (pctx->token.type == isc_tokentype_special &&

	    pctx->token.value.as_char == special)

		return (ISC_R_SUCCESS);

	cfg_parser_error(pctx, CFG_LOG_NEAR, "'%c' expected", special);

	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) {

	isc_result_t result;

	CHECK(cfg_gettoken(pctx, 0));

	if (pctx->token.type == isc_tokentype_special &&

	    pctx->token.value.as_char == ';')

		return (ISC_R_SUCCESS);

	cfg_parser_error(pctx, CFG_LOG_BEFORE, "missing ';'");

	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) {

	isc_result_t result;

	CHECK(cfg_gettoken(pctx, 0));

	if (pctx->token.type == isc_tokentype_eof)

		return (ISC_R_SUCCESS);

	cfg_parser_error(pctx, CFG_LOG_NEAR, "syntax error");

	return (ISC_R_UNEXPECTEDTOKEN);

 cleanup:

	return (result);

}

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

static cfg_type_t cfg_type_filelist = {

	"filelist", NULL, print_list, NULL, &cfg_rep_list,

	&cfg_type_qstring

};

isc_result_t

cfg_parser_create(isc_mem_t *mctx, isc_log_t *lctx, cfg_parser_t **ret) {

	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);

	pctx->mctx = NULL;

	isc_mem_attach(mctx, &pctx->mctx);

	result = isc_refcount_init(&pctx->references, 1);

	if (result != ISC_R_SUCCESS) {

		isc_mem_putanddetach(&pctx->mctx, pctx, sizeof(*pctx));

		return (result);

	}

	pctx->lctx = lctx;

	pctx->lexer = NULL;

	pctx->seen_eof = false;

	pctx->ungotten = false;

	pctx->errors = 0;

	pctx->warnings = 0;

	pctx->open_files = NULL;

	pctx->closed_files = NULL;

	pctx->line = 0;

	pctx->callback = NULL;

	pctx->callbackarg = NULL;

	pctx->token.type = isc_tokentype_unknown;

	pctx->flags = 0;

	pctx->buf_name = NULL;

	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));

	CHECK(cfg_create_list(pctx, &cfg_type_filelist, &pctx->open_files));

	CHECK(cfg_create_list(pctx, &cfg_type_filelist, &pctx->closed_files));

	*ret = pctx;

	return (ISC_R_SUCCESS);

 cleanup:

	if (pctx->lexer != NULL)

		isc_lex_destroy(&pctx->lexer);

	CLEANUP_OBJ(pctx->open_files);

	CLEANUP_OBJ(pctx->closed_files);

	isc_mem_putanddetach(&pctx->mctx, pctx, sizeof(*pctx));

	return (result);

}

static isc_result_t

parser_openfile(cfg_parser_t *pctx, const char *filename) {

	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) {

		cfg_parser_error(pctx, 0, "open: %s: %s",

			     filename, isc_result_totext(result));

		goto cleanup;

	}

	CHECK(create_string(pctx, filename, &cfg_type_qstring, &stringobj));

	CHECK(create_listelt(pctx, &elt));

	elt->obj = stringobj;

	ISC_LIST_APPEND(pctx->open_files->value.list, elt, link);

	return (ISC_R_SUCCESS);

 cleanup:

	CLEANUP_OBJ(stringobj);

	return (result);

}

void

cfg_parser_setcallback(cfg_parser_t *pctx,

		       cfg_parsecallback_t callback,

		       void *arg)

{

	REQUIRE(pctx != NULL);

	pctx->callback = callback;

	pctx->callbackarg = arg;

}

void

cfg_parser_reset(cfg_parser_t *pctx) {

	REQUIRE(pctx != NULL);

	if (pctx->lexer != NULL)

		isc_lex_close(pctx->lexer);

	pctx->seen_eof = false;

	pctx->ungotten = false;

	pctx->errors = 0;

	pctx->warnings = 0;

	pctx->line = 0;

}

/*

 * Parse a configuration using a pctx where a lexer has already

 * been set up with a source.

 */

static isc_result_t

parse2(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {

	isc_result_t result;

	cfg_obj_t *obj = NULL;

	result = cfg_parse_obj(pctx, type, &obj);

	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. */

		cfg_parser_error(pctx, 0, "parsing failed: %s",

				 isc_result_totext(result));

		goto cleanup;

	}

	CHECK(parse_eof(pctx));

	*ret = obj;

	return (ISC_R_SUCCESS);

 cleanup:

	CLEANUP_OBJ(obj);

	return (result);

}

isc_result_t

cfg_parse_file(cfg_parser_t *pctx, const char *filename,

	       const cfg_type_t *type, cfg_obj_t **ret)

{

	isc_result_t result;

	cfg_listelt_t *elt;

	REQUIRE(pctx != NULL);

	REQUIRE(filename != NULL);

	REQUIRE(type != NULL);

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

	CHECK(parser_openfile(pctx, filename));

	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);

 cleanup:

	return (result);

}

isc_result_t

cfg_parse_buffer(cfg_parser_t *pctx, isc_buffer_t *buffer,

	const cfg_type_t *type, cfg_obj_t **ret)

{

	return (cfg_parse_buffer4(pctx, buffer, NULL, 0, type, 0, ret));

}

isc_result_t

cfg_parse_buffer2(cfg_parser_t *pctx, isc_buffer_t *buffer,

		  const char *file, const cfg_type_t *type,

		  cfg_obj_t **ret)

{

	return (cfg_parse_buffer4(pctx, buffer, file, 0, type, 0, ret));

}

isc_result_t

cfg_parse_buffer3(cfg_parser_t *pctx, isc_buffer_t *buffer,

		  const char *file, unsigned int line,

		  const cfg_type_t *type, cfg_obj_t **ret)

{

	return (cfg_parse_buffer4(pctx, buffer, file, line, type, 0, ret));

}

isc_result_t

cfg_parse_buffer4(cfg_parser_t *pctx, isc_buffer_t *buffer,

		  const char *file, unsigned int line,

		  const cfg_type_t *type, unsigned int flags,

		  cfg_obj_t **ret)

{

	isc_result_t result;

	REQUIRE(pctx != NULL);

	REQUIRE(type != NULL);

	REQUIRE(buffer != NULL);

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

	REQUIRE((flags & ~(CFG_PCTX_NODEPRECATED)) == 0);

	CHECK(isc_lex_openbuffer(pctx->lexer, buffer));

	pctx->buf_name = file;

	pctx->flags = flags;

	if (line != 0U)

		CHECK(isc_lex_setsourceline(pctx->lexer, line));

	CHECK(parse2(pctx, type, ret));

	pctx->buf_name = NULL;

 cleanup:

	return (result);

}

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;

}

void

cfg_parser_destroy(cfg_parser_t **pctxp) {

	cfg_parser_t *pctx;

	unsigned int refs;

	REQUIRE(pctxp != NULL && *pctxp != NULL);

	pctx = *pctxp;

	*pctxp = NULL;

	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);

		isc_mem_putanddetach(&pctx->mctx, pctx, sizeof(*pctx));

	}

}

/*

 * void

 */

isc_result_t

cfg_parse_void(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {

	REQUIRE(pctx != NULL);

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

	UNUSED(type);

	return (cfg_create_obj(pctx, &cfg_type_void, ret));

}

void

cfg_print_void(cfg_printer_t *pctx, const cfg_obj_t *obj) {

	REQUIRE(pctx != NULL);

	REQUIRE(obj != NULL);

	UNUSED(pctx);

	UNUSED(obj);

}

void

cfg_doc_void(cfg_printer_t *pctx, const cfg_type_t *type) {

	REQUIRE(pctx != NULL);

	REQUIRE(type != NULL);

	UNUSED(pctx);

	UNUSED(type);

}

bool

cfg_obj_isvoid(const cfg_obj_t *obj) {

	REQUIRE(obj != NULL);

	return (obj->type->rep == &cfg_rep_void);

}

LIBISCCFG_EXTERNAL_DATA cfg_type_t cfg_type_void = {

	"void", cfg_parse_void, cfg_print_void, cfg_doc_void, &cfg_rep_void,

	NULL };

/*

 * 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;

	uint64_t percent;

	REQUIRE(pctx != NULL);

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

	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 = (uint32_t)percent;

	*ret = obj;

 cleanup:

	return (result);

}

void

cfg_print_percentage(cfg_printer_t *pctx, const cfg_obj_t *obj) {

	char buf[64];

	int n;

	REQUIRE(pctx != NULL);

	REQUIRE(obj != NULL);

	n = snprintf(buf, sizeof(buf), "%u%%", obj->value.uint32);

	INSIST(n > 0 && (size_t)n < sizeof(buf));

	cfg_print_chars(pctx, buf, strlen(buf));

}

uint32_t

cfg_obj_aspercentage(const cfg_obj_t *obj) {

	REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_percentage);

	return (obj->value.uint32);

}

LIBISCCFG_EXTERNAL_DATA cfg_type_t cfg_type_percentage = {

	"percentage", cfg_parse_percentage, cfg_print_percentage,

	cfg_doc_terminal, &cfg_rep_percentage, NULL

};

bool

cfg_obj_ispercentage(const cfg_obj_t *obj) {

	REQUIRE(obj != NULL);

	return (obj->type->rep == &cfg_rep_percentage);

}

/*

 * 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;

	REQUIRE(pctx != NULL);

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

	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;

	REQUIRE(pctx != NULL);

	REQUIRE(obj != NULL);