?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add BIND 9.2.4rc7.
[dragonfly.git] / contrib / bind-9.2.4rc7 / lib / isccfg / parser.c
blobdf4ed7a93090680cc19716572689fb44eef1d779
1 /*
2 * Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000-2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /* $Id: parser.c,v 1.70.2.24 2004/03/28 23:09:55 marka Exp $ */
19
20 #include <config.h>
21
22 #include <isc/buffer.h>
23 #include <isc/dir.h>
24 #include <isc/formatcheck.h>
25 #include <isc/lex.h>
26 #include <isc/log.h>
27 #include <isc/mem.h>
28 #include <isc/net.h>
29 #include <isc/netaddr.h>
30 #include <isc/print.h>
31 #include <isc/string.h>
32 #include <isc/sockaddr.h>
33 #include <isc/util.h>
34 #include <isc/symtab.h>
35
36 #include <isccfg/cfg.h>
37 #include <isccfg/log.h>
38
39 /* Shorthand */
40 #define CAT CFG_LOGCATEGORY_CONFIG
41 #define MOD CFG_LOGMODULE_PARSER
42
43 #define QSTRING (ISC_LEXOPT_QSTRING | ISC_LEXOPT_QSTRINGMULTILINE)
44
45 /*
46 * Pass one of these flags to parser_error() to include the
47 * token text in log message.
48 */
49 #define LOG_NEAR 0x00000001 /* Say "near <token>" */
50 #define LOG_BEFORE 0x00000002 /* Say "before <token>" */
51 #define LOG_NOPREP 0x00000004 /* Say just "<token>" */
52
53 #define MAP_SYM 1 /* Unique type for isc_symtab */
54
55 /* Clause may occur multiple times (e.g., "zone") */
56 #define CFG_CLAUSEFLAG_MULTI 0x00000001
57 /* Clause is obsolete */
58 #define CFG_CLAUSEFLAG_OBSOLETE 0x00000002
59 /* Clause is not implemented, and may never be */
60 #define CFG_CLAUSEFLAG_NOTIMP 0x00000004
61 /* Clause is not implemented yet */
62 #define CFG_CLAUSEFLAG_NYI 0x00000008
63 /* Default value has changed since earlier release */
64 #define CFG_CLAUSEFLAG_NEWDEFAULT 0x00000010
65 /*
66 * Clause needs to be interpreted during parsing
67 * by calling a callback function, like the
68 * "directory" option.
69 */
70 #define CFG_CLAUSEFLAG_CALLBACK 0x00000020
71
72 /*
73 * Flags defining whether to accept certain types of network addresses.
74 */
75 #define V4OK 0x00000001
76 #define V4PREFIXOK 0x00000002
77 #define V6OK 0x00000004
78 #define WILDOK 0x00000008
79
80 /* Check a return value. */
81 #define CHECK(op) \
82 do { result = (op); \
83 if (result != ISC_R_SUCCESS) goto cleanup; \
84 } while (0)
85
86 /* Clean up a configuration object if non-NULL. */
87 #define CLEANUP_OBJ(obj) \
88 do { if ((obj) != NULL) cfg_obj_destroy(pctx, &(obj)); } while (0)
89
90
91 typedef struct cfg_clausedef cfg_clausedef_t;
92 typedef struct cfg_tuplefielddef cfg_tuplefielddef_t;
93 typedef struct cfg_printer cfg_printer_t;
94 typedef ISC_LIST(cfg_listelt_t) cfg_list_t;
95 typedef struct cfg_map cfg_map_t;
96 typedef struct cfg_rep cfg_rep_t;
97
98 /*
99 * Function types for configuration object methods
100 */
101
102 typedef isc_result_t (*cfg_parsefunc_t)(cfg_parser_t *, const cfg_type_t *type,
103 cfg_obj_t **);
104 typedef void (*cfg_printfunc_t)(cfg_printer_t *, cfg_obj_t *);
105 typedef void (*cfg_freefunc_t)(cfg_parser_t *, cfg_obj_t *);
106
107
108 /*
109 * Structure definitions
110 */
111
112 /* The parser object. */
113 struct cfg_parser {
114 isc_mem_t * mctx;
115 isc_log_t * lctx;
116 isc_lex_t * lexer;
117 unsigned int errors;
118 unsigned int warnings;
119 isc_token_t token;
120
121 /* We are at the end of all input. */
122 isc_boolean_t seen_eof;
123
124 /* The current token has been pushed back. */
125 isc_boolean_t ungotten;
126
127 /*
128 * The stack of currently active files, represented
129 * as a configuration list of configuration strings.
130 * The head is the top-level file, subsequent elements
131 * (if any) are the nested include files, and the
132 * last element is the file currently being parsed.
133 */
134 cfg_obj_t * open_files;
135
136 /*
137 * Names of files that we have parsed and closed
138 * and were previously on the open_file list.
139 * We keep these objects around after closing
140 * the files because the file names may still be
141 * referenced from other configuration objects
142 * for use in reporting semantic errors after
143 * parsing is complete.
144 */
145 cfg_obj_t * closed_files;
146
147 /*
148 * Current line number. We maintain our own
149 * copy of this so that it is available even
150 * when a file has just been closed.
151 */
152 unsigned int line;
153
154 cfg_parsecallback_t callback;
155 void *callbackarg;
156 };
157
158 /*
159 * A configuration printer object. This is an abstract
160 * interface to a destination to which text can be printed
161 * by calling the function 'f'.
162 */
163 struct cfg_printer {
164 void (*f)(void *closure, const char *text, int textlen);
165 void *closure;
166 int indent;
167 };
168
169 /* A clause definition. */
170
171 struct cfg_clausedef {
172 const char *name;
173 cfg_type_t *type;
174 unsigned int flags;
175 };
176
177 /* A tuple field definition. */
178
179 struct cfg_tuplefielddef {
180 const char *name;
181 cfg_type_t *type;
182 unsigned int flags;
183 };
184
185 /* A configuration object type definition. */
186 struct cfg_type {
187 const char *name; /* For debugging purposes only */
188 cfg_parsefunc_t parse;
189 cfg_printfunc_t print;
190 cfg_rep_t * rep; /* Data representation */
191 const void * of; /* For meta-types */
192 };
193
194 /* A keyword-type definition, for things like "port <integer>". */
195
196 typedef struct {
197 const char *name;
198 const cfg_type_t *type;
199 } keyword_type_t;
200
201 struct cfg_map {
202 cfg_obj_t *id; /* Used for 'named maps' like keys, zones, &c */
203 const cfg_clausedef_t * const *clausesets; /* The clauses that
204 can occur in this map;
205 used for printing */
206 isc_symtab_t *symtab;
207 };
208
209 typedef struct cfg_netprefix cfg_netprefix_t;
210
211 struct cfg_netprefix {
212 isc_netaddr_t address; /* IP4/IP6 */
213 unsigned int prefixlen;
214 };
215
216 /*
217 * A configuration data representation.
218 */
219 struct cfg_rep {
220 const char * name; /* For debugging only */
221 cfg_freefunc_t free; /* How to free this kind of data. */
222 };
223
224 /*
225 * A configuration object. This is the main building block
226 * of the configuration parse tree.
227 */
228
229 struct cfg_obj {
230 const cfg_type_t *type;
231 union {
232 isc_uint32_t uint32;
233 isc_uint64_t uint64;
234 isc_textregion_t string; /* null terminated, too */
235 isc_boolean_t boolean;
236 cfg_map_t map;
237 cfg_list_t list;
238 cfg_obj_t ** tuple;
239 isc_sockaddr_t sockaddr;
240 cfg_netprefix_t netprefix;
241 } value;
242 char * file;
243 unsigned int line;
244 };
245
246
247 /* A list element. */
248
249 struct cfg_listelt {
250 cfg_obj_t *obj;
251 ISC_LINK(cfg_listelt_t) link;
252 };
253
254 /*
255 * Forward declarations of static functions.
256 */
257
258 static isc_result_t
259 create_cfgobj(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **objp);
260
261 static isc_result_t
262 create_list(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **objp);
263
264 static isc_result_t
265 create_listelt(cfg_parser_t *pctx, cfg_listelt_t **eltp);
266
267 static void
268 free_list(cfg_parser_t *pctx, cfg_obj_t *obj);
269
270 static isc_result_t
271 create_string(cfg_parser_t *pctx, const char *contents, const cfg_type_t *type,
272 cfg_obj_t **ret);
273
274 static void
275 free_string(cfg_parser_t *pctx, cfg_obj_t *obj);
276
277 static isc_result_t
278 create_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **objp);
279
280 static isc_result_t
281 create_tuple(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **objp);
282
283 static void
284 free_map(cfg_parser_t *pctx, cfg_obj_t *obj);
285
286 static isc_result_t
287 get_addr(cfg_parser_t *pctx, unsigned int flags, isc_netaddr_t *na);
288
289 static void
290 print(cfg_printer_t *pctx, const char *text, int len);
291
292 static void
293 print_void(cfg_printer_t *pctx, cfg_obj_t *obj);
294
295 static isc_result_t
296 parse_enum_or_other(cfg_parser_t *pctx, const cfg_type_t *enumtype,
297 const cfg_type_t *othertype, cfg_obj_t **ret);
298
299 static isc_result_t
300 parse_mapbody(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
301
302 static void
303 print_mapbody(cfg_printer_t *pctx, cfg_obj_t *obj);
304
305 static isc_result_t
306 parse_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
307
308 static void
309 print_map(cfg_printer_t *pctx, cfg_obj_t *obj);
310
311 static isc_result_t
312 parse_named_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
313
314 static isc_result_t
315 parse_addressed_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
316
317 static isc_result_t
318 parse_list(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
319
320 static void
321 print_list(cfg_printer_t *pctx, cfg_obj_t *obj);
322
323 static isc_result_t
324 parse_tuple(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
325
326 static void
327 print_tuple(cfg_printer_t *pctx, cfg_obj_t *obj);
328
329 static void
330 free_tuple(cfg_parser_t *pctx, cfg_obj_t *obj);
331
332 static isc_result_t
333 parse_spacelist(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
334
335 static void
336 print_spacelist(cfg_printer_t *pctx, cfg_obj_t *obj);
337
338 static void
339 print_sockaddr(cfg_printer_t *pctx, cfg_obj_t *obj);
340
341 static isc_result_t
342 parse_addrmatchelt(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
343
344 static isc_result_t
345 parse_bracketed_list(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
346
347 static void
348 print_bracketed_list(cfg_printer_t *pctx, cfg_obj_t *obj);
349
350 static isc_result_t
351 parse_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
352
353 static isc_result_t
354 parse_optional_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
355
356 static void
357 print_keyvalue(cfg_printer_t *pctx, cfg_obj_t *obj);
358
359 static isc_result_t
360 parse_symtab_elt(cfg_parser_t *pctx, const char *name,
361 cfg_type_t *elttype, isc_symtab_t *symtab,
362 isc_boolean_t callback);
363
364 static void
365 free_noop(cfg_parser_t *pctx, cfg_obj_t *obj);
366
367 static isc_result_t
368 cfg_gettoken(cfg_parser_t *pctx, int options);
369
370 static void
371 cfg_ungettoken(cfg_parser_t *pctx);
372
373 static isc_result_t
374 cfg_peektoken(cfg_parser_t *pctx, int options);
375
376 static isc_result_t
377 cfg_getstringtoken(cfg_parser_t *pctx);
378
379 static void
380 parser_error(cfg_parser_t *pctx, unsigned int flags,
381 const char *fmt, ...) ISC_FORMAT_PRINTF(3, 4);
382
383 static void
384 parser_warning(cfg_parser_t *pctx, unsigned int flags,
385 const char *fmt, ...) ISC_FORMAT_PRINTF(3, 4);
386
387 static void
388 parser_complain(cfg_parser_t *pctx, isc_boolean_t is_warning,
389 unsigned int flags, const char *format, va_list args);
390
391 static void
392 print_uint32(cfg_printer_t *pctx, cfg_obj_t *obj);
393
394 static void
395 print_ustring(cfg_printer_t *pctx, cfg_obj_t *obj);
396
397 static isc_result_t
398 parse_enum(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret);
399
400 /*
401 * Data representations. These correspond to members of the
402 * "value" union in struct cfg_obj (except "void", which does
403 * not need a union member).
404 */
405
406 cfg_rep_t cfg_rep_uint32 = { "uint32", free_noop };
407 cfg_rep_t cfg_rep_uint64 = { "uint64", free_noop };
408 cfg_rep_t cfg_rep_string = { "string", free_string };
409 cfg_rep_t cfg_rep_boolean = { "boolean", free_noop };
410 cfg_rep_t cfg_rep_map = { "map", free_map };
411 cfg_rep_t cfg_rep_list = { "list", free_list };
412 cfg_rep_t cfg_rep_tuple = { "tuple", free_tuple };
413 cfg_rep_t cfg_rep_sockaddr = { "sockaddr", free_noop };
414 cfg_rep_t cfg_rep_netprefix = { "netprefix", free_noop };
415 cfg_rep_t cfg_rep_void = { "void", free_noop };
416
417 /*
418 * Forward declarations of configuration type definitions.
419 * Additional types are declared publicly in cfg.h.
420 */
421
422 static cfg_type_t cfg_type_boolean;
423 static cfg_type_t cfg_type_uint32;
424 static cfg_type_t cfg_type_qstring;
425 static cfg_type_t cfg_type_astring;
426 static cfg_type_t cfg_type_ustring;
427 static cfg_type_t cfg_type_optional_port;
428 static cfg_type_t cfg_type_bracketed_aml;
429 static cfg_type_t cfg_type_acl;
430 static cfg_type_t cfg_type_portiplist;
431 static cfg_type_t cfg_type_bracketed_sockaddrlist;
432 static cfg_type_t cfg_type_sockaddr;
433 static cfg_type_t cfg_type_netaddr;
434 static cfg_type_t cfg_type_optional_keyref;
435 static cfg_type_t cfg_type_options;
436 static cfg_type_t cfg_type_view;
437 static cfg_type_t cfg_type_viewopts;
438 static cfg_type_t cfg_type_key;
439 static cfg_type_t cfg_type_server;
440 static cfg_type_t cfg_type_controls;
441 static cfg_type_t cfg_type_bracketed_sockaddrkeylist;
442 static cfg_type_t cfg_type_querysource4;
443 static cfg_type_t cfg_type_querysource6;
444 static cfg_type_t cfg_type_querysource;
445 static cfg_type_t cfg_type_sockaddr4wild;
446 static cfg_type_t cfg_type_sockaddr6wild;
447 static cfg_type_t cfg_type_sockaddr;
448 static cfg_type_t cfg_type_netprefix;
449 static cfg_type_t cfg_type_zone;
450 static cfg_type_t cfg_type_zoneopts;
451 static cfg_type_t cfg_type_logging;
452 static cfg_type_t cfg_type_optional_facility;
453 static cfg_type_t cfg_type_void;
454 static cfg_type_t cfg_type_optional_class;
455 static cfg_type_t cfg_type_destinationlist;
456 static cfg_type_t cfg_type_size;
457 static cfg_type_t cfg_type_sizenodefault;
458 static cfg_type_t cfg_type_negated;
459 static cfg_type_t cfg_type_addrmatchelt;
460 static cfg_type_t cfg_type_unsupported;
461 static cfg_type_t cfg_type_token;
462 static cfg_type_t cfg_type_server_key_kludge;
463 static cfg_type_t cfg_type_optional_facility;
464 static cfg_type_t cfg_type_logseverity;
465 static cfg_type_t cfg_type_logfile;
466 static cfg_type_t cfg_type_lwres;
467 static cfg_type_t cfg_type_controls_sockaddr;
468 static cfg_type_t cfg_type_notifytype;
469 static cfg_type_t cfg_type_dialuptype;
470
471 /*
472 * Configuration type definitions.
473 */
474
475 /* tkey-dhkey */
476
477 static cfg_tuplefielddef_t tkey_dhkey_fields[] = {
478 { "name", &cfg_type_qstring, 0 },
479 { "keyid", &cfg_type_uint32, 0 },
480 { NULL, NULL, 0 }
481 };
482
483 static cfg_type_t cfg_type_tkey_dhkey = {
484 "tkey-dhkey", parse_tuple, print_tuple, &cfg_rep_tuple,
485 tkey_dhkey_fields
486 };
487
488 /* listen-on */
489
490 static cfg_tuplefielddef_t listenon_fields[] = {
491 { "port", &cfg_type_optional_port, 0 },
492 { "acl", &cfg_type_bracketed_aml, 0 },
493 { NULL, NULL, 0 }
494 };
495 static cfg_type_t cfg_type_listenon = {
496 "listenon", parse_tuple, print_tuple, &cfg_rep_tuple, listenon_fields };
497
498 /* acl */
499
500 static cfg_tuplefielddef_t acl_fields[] = {
501 { "name", &cfg_type_astring, 0 },
502 { "value", &cfg_type_bracketed_aml, 0 },
503 { NULL, NULL, 0 }
504 };
505
506 static cfg_type_t cfg_type_acl = {
507 "acl", parse_tuple, print_tuple, &cfg_rep_tuple, acl_fields };
508
509
510 /*
511 * "sockaddrkeylist", a list of socket addresses with optional keys
512 * and an optional default port, as used in the masters option.
513 * E.g.,
514 * "port 1234 { 10.0.0.1 key foo; 1::2 port 69; }"
515 */
516
517 static cfg_tuplefielddef_t sockaddrkey_fields[] = {
518 { "sockaddr", &cfg_type_sockaddr, 0 },
519 { "key", &cfg_type_optional_keyref, 0 },
520 { NULL, NULL, 0 },
521 };
522
523 static cfg_type_t cfg_type_sockaddrkey = {
524 "sockaddrkey", parse_tuple, print_tuple, &cfg_rep_tuple,
525 sockaddrkey_fields
526 };
527
528 static cfg_type_t cfg_type_bracketed_sockaddrkeylist = {
529 "bracketed_sockaddrkeylist", parse_bracketed_list,
530 print_bracketed_list, &cfg_rep_list, &cfg_type_sockaddrkey
531 };
532
533 static cfg_tuplefielddef_t sockaddrkeylist_fields[] = {
534 { "port", &cfg_type_optional_port, 0 },
535 { "addresses", &cfg_type_bracketed_sockaddrkeylist, 0 },
536 { NULL, NULL, 0 }
537 };
538 static cfg_type_t cfg_type_sockaddrkeylist = {
539 "sockaddrkeylist", parse_tuple, print_tuple, &cfg_rep_tuple,
540 sockaddrkeylist_fields
541 };
542
543 /*
544 * A list of socket addresses with an optional default port,
545 * as used in the also-notify option. E.g.,
546 * "port 1234 { 10.0.0.1; 1::2 port 69; }"
547 */
548 static cfg_tuplefielddef_t portiplist_fields[] = {
549 { "port", &cfg_type_optional_port, 0 },
550 { "addresses", &cfg_type_bracketed_sockaddrlist, 0 },
551 { NULL, NULL, 0 }
552 };
553 static cfg_type_t cfg_type_portiplist = {
554 "portiplist", parse_tuple, print_tuple, &cfg_rep_tuple,
555 portiplist_fields
556 };
557
558 /*
559 * A public key, as in the "pubkey" statement.
560 */
561 static cfg_tuplefielddef_t pubkey_fields[] = {
562 { "flags", &cfg_type_uint32, 0 },
563 { "protocol", &cfg_type_uint32, 0 },
564 { "algorithm", &cfg_type_uint32, 0 },
565 { "key", &cfg_type_qstring, 0 },
566 { NULL, NULL, 0 }
567 };
568 static cfg_type_t cfg_type_pubkey = {
569 "pubkey", parse_tuple, print_tuple, &cfg_rep_tuple, pubkey_fields };
570
571
572 /*
573 * A list of RR types, used in grant statements.
574 * Note that the old parser allows quotes around the RR type names.
575 */
576 static cfg_type_t cfg_type_rrtypelist = {
577 "rrtypelist", parse_spacelist, print_spacelist, &cfg_rep_list,
578 &cfg_type_astring
579 };
580
581 static const char *mode_enums[] = { "grant", "deny", NULL };
582 static cfg_type_t cfg_type_mode = {
583 "mode", parse_enum, print_ustring, &cfg_rep_string,
584 &mode_enums
585 };
586
587 static const char *matchtype_enums[] = {
588 "name", "subdomain", "wildcard", "self", NULL };
589 static cfg_type_t cfg_type_matchtype = {
590 "matchtype", parse_enum, print_ustring, &cfg_rep_string,
591 &matchtype_enums
592 };
593
594 /*
595 * A grant statement, used in the update policy.
596 */
597 static cfg_tuplefielddef_t grant_fields[] = {
598 { "mode", &cfg_type_mode, 0 },
599 { "identity", &cfg_type_astring, 0 }, /* domain name */
600 { "matchtype", &cfg_type_matchtype, 0 },
601 { "name", &cfg_type_astring, 0 }, /* domain name */
602 { "types", &cfg_type_rrtypelist, 0 },
603 { NULL, NULL, 0 }
604 };
605 static cfg_type_t cfg_type_grant = {
606 "grant", parse_tuple, print_tuple, &cfg_rep_tuple, grant_fields };
607
608 static cfg_type_t cfg_type_updatepolicy = {
609 "update_policy", parse_bracketed_list, print_bracketed_list,
610 &cfg_rep_list, &cfg_type_grant
611 };
612
613 /*
614 * A view statement.
615 */
616 static cfg_tuplefielddef_t view_fields[] = {
617 { "name", &cfg_type_astring, 0 },
618 { "class", &cfg_type_optional_class, 0 },
619 { "options", &cfg_type_viewopts, 0 },
620 { NULL, NULL, 0 }
621 };
622 static cfg_type_t cfg_type_view = {
623 "view", parse_tuple, print_tuple, &cfg_rep_tuple, view_fields };
624
625 /*
626 * A zone statement.
627 */
628 static cfg_tuplefielddef_t zone_fields[] = {
629 { "name", &cfg_type_astring, 0 },
630 { "class", &cfg_type_optional_class, 0 },
631 { "options", &cfg_type_zoneopts, 0 },
632 { NULL, NULL, 0 }
633 };
634 static cfg_type_t cfg_type_zone = {
635 "zone", parse_tuple, print_tuple, &cfg_rep_tuple, zone_fields };
636
637 /*
638 * A "category" clause in the "logging" statement.
639 */
640 static cfg_tuplefielddef_t category_fields[] = {
641 { "name", &cfg_type_astring, 0 },
642 { "destinations", &cfg_type_destinationlist,0 },
643 { NULL, NULL, 0 }
644 };
645 static cfg_type_t cfg_type_category = {
646 "category", parse_tuple, print_tuple, &cfg_rep_tuple, category_fields };
647
648
649 /*
650 * A trusted key, as used in the "trusted-keys" statement.
651 */
652 static cfg_tuplefielddef_t trustedkey_fields[] = {
653 { "name", &cfg_type_astring, 0 },
654 { "flags", &cfg_type_uint32, 0 },
655 { "protocol", &cfg_type_uint32, 0 },
656 { "algorithm", &cfg_type_uint32, 0 },
657 { "key", &cfg_type_qstring, 0 },
658 { NULL, NULL, 0 }
659 };
660 static cfg_type_t cfg_type_trustedkey = {
661 "trustedkey", parse_tuple, print_tuple, &cfg_rep_tuple,
662 trustedkey_fields
663 };
664
665
666 static keyword_type_t wild_class_kw = { "class", &cfg_type_ustring };
667
668 static cfg_type_t cfg_type_optional_wild_class = {
669 "optional_wild_class", parse_optional_keyvalue,
670 print_keyvalue, &cfg_rep_string, &wild_class_kw
671 };
672
673 static keyword_type_t wild_type_kw = { "type", &cfg_type_ustring };
674
675 static cfg_type_t cfg_type_optional_wild_type = {
676 "optional_wild_type", parse_optional_keyvalue,
677 print_keyvalue, &cfg_rep_string, &wild_type_kw
678 };
679
680 static keyword_type_t wild_name_kw = { "name", &cfg_type_qstring };
681
682 static cfg_type_t cfg_type_optional_wild_name = {
683 "optional_wild_name", parse_optional_keyvalue,
684 print_keyvalue, &cfg_rep_string, &wild_name_kw
685 };
686
687 /*
688 * An rrset ordering element.
689 */
690 static cfg_tuplefielddef_t rrsetorderingelement_fields[] = {
691 { "class", &cfg_type_optional_wild_class, 0 },
692 { "type", &cfg_type_optional_wild_type, 0 },
693 { "name", &cfg_type_optional_wild_name, 0 },
694 { "order", &cfg_type_ustring, 0 }, /* must be literal "order" */
695 { "ordering", &cfg_type_ustring, 0 },
696 { NULL, NULL, 0 }
697 };
698 static cfg_type_t cfg_type_rrsetorderingelement = {
699 "rrsetorderingelement", parse_tuple, print_tuple, &cfg_rep_tuple,
700 rrsetorderingelement_fields
701 };
702
703 /*
704 * A global or view "check-names" option. Note that the zone
705 * "check-names" option has a different syntax.
706 */
707 static cfg_tuplefielddef_t checknames_fields[] = {
708 { "type", &cfg_type_ustring, 0 },
709 { "mode", &cfg_type_ustring, 0 },
710 { NULL, NULL, 0 }
711 };
712 static cfg_type_t cfg_type_checknames = {
713 "checknames", parse_tuple, print_tuple, &cfg_rep_tuple,
714 checknames_fields
715 };
716
717 static cfg_type_t cfg_type_bracketed_sockaddrlist = {
718 "bracketed_sockaddrlist", parse_bracketed_list, print_bracketed_list,
719 &cfg_rep_list, &cfg_type_sockaddr
720 };
721
722 static cfg_type_t cfg_type_rrsetorder = {
723 "rrsetorder", parse_bracketed_list, print_bracketed_list,
724 &cfg_rep_list, &cfg_type_rrsetorderingelement
725 };
726
727 static keyword_type_t port_kw = { "port", &cfg_type_uint32 };
728
729 static cfg_type_t cfg_type_optional_port = {
730 "optional_port", parse_optional_keyvalue, print_keyvalue,
731 &cfg_rep_uint32, &port_kw
732 };
733
734 /* A list of keys, as in the "key" clause of the controls statement. */
735 static cfg_type_t cfg_type_keylist = {
736 "keylist", parse_bracketed_list, print_bracketed_list, &cfg_rep_list,
737 &cfg_type_astring
738 };
739
740 static cfg_type_t cfg_type_trustedkeys = {
741 "trusted-keys", parse_bracketed_list, print_bracketed_list, &cfg_rep_list,
742 &cfg_type_trustedkey
743 };
744
745 /*
746 * An implicit list. These are formed by clauses that occur multiple times.
747 */
748 static cfg_type_t cfg_type_implicitlist = {
749 "implicitlist", NULL, print_list, &cfg_rep_list, NULL };
750
751 static const char *forwardtype_enums[] = { "first", "only", NULL };
752 static cfg_type_t cfg_type_forwardtype = {
753 "forwardtype", parse_enum, print_ustring, &cfg_rep_string,
754 &forwardtype_enums
755 };
756
757 static const char *zonetype_enums[] = {
758 "master", "slave", "stub", "hint", "forward", "delegation-only", NULL };
759 static cfg_type_t cfg_type_zonetype = {
760 "zonetype", parse_enum, print_ustring, &cfg_rep_string,
761 &zonetype_enums
762 };
763
764 static const char *loglevel_enums[] = {
765 "critical", "error", "warning", "notice", "info", "dynamic", NULL };
766 static cfg_type_t cfg_type_loglevel = {
767 "loglevel", parse_enum, print_ustring, &cfg_rep_string,
768 &loglevel_enums
769 };
770
771 static const char *transferformat_enums[] = {
772 "many-answers", "one-answer", NULL };
773 static cfg_type_t cfg_type_transferformat = {
774 "transferformat", parse_enum, print_ustring, &cfg_rep_string,
775 &transferformat_enums
776 };
777
778 /*
779 * Clauses that can be found within the top level of the named.conf
780 * file only.
781 */
782 static cfg_clausedef_t
783 namedconf_clauses[] = {
784 { "options", &cfg_type_options, 0 },
785 { "controls", &cfg_type_controls, CFG_CLAUSEFLAG_MULTI },
786 { "acl", &cfg_type_acl, CFG_CLAUSEFLAG_MULTI },
787 { "logging", &cfg_type_logging, 0 },
788 { "view", &cfg_type_view, CFG_CLAUSEFLAG_MULTI },
789 { "lwres", &cfg_type_lwres, CFG_CLAUSEFLAG_MULTI },
790 { NULL, NULL, 0 }
791 };
792
793 /*
794 * Clauses that can occur at the top level or in the view
795 * statement, but not in the options block.
796 */
797 static cfg_clausedef_t
798 namedconf_or_view_clauses[] = {
799 { "key", &cfg_type_key, CFG_CLAUSEFLAG_MULTI },
800 { "zone", &cfg_type_zone, CFG_CLAUSEFLAG_MULTI },
801 { "server", &cfg_type_server, CFG_CLAUSEFLAG_MULTI },
802 #ifdef ISC_RFC2535
803 { "trusted-keys", &cfg_type_trustedkeys, CFG_CLAUSEFLAG_MULTI },
804 #else
805 { "trusted-keys", &cfg_type_trustedkeys,
806 CFG_CLAUSEFLAG_MULTI|CFG_CLAUSEFLAG_OBSOLETE },
807 #endif
808 { NULL, NULL, 0 }
809 };
810
811 /*
812 * Clauses that can be found within the 'options' statement.
813 */
814 static cfg_clausedef_t
815 options_clauses[] = {
816 { "blackhole", &cfg_type_bracketed_aml, 0 },
817 { "coresize", &cfg_type_size, 0 },
818 { "datasize", &cfg_type_size, 0 },
819 { "deallocate-on-exit", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
820 { "directory", &cfg_type_qstring, CFG_CLAUSEFLAG_CALLBACK },
821 { "dump-file", &cfg_type_qstring, 0 },
822 { "fake-iquery", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
823 { "files", &cfg_type_size, 0 },
824 { "has-old-clients", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
825 { "heartbeat-interval", &cfg_type_uint32, 0 },
826 { "host-statistics", &cfg_type_boolean, CFG_CLAUSEFLAG_NOTIMP },
827 { "interface-interval", &cfg_type_uint32, 0 },
828 { "listen-on", &cfg_type_listenon, CFG_CLAUSEFLAG_MULTI },
829 { "listen-on-v6", &cfg_type_listenon, CFG_CLAUSEFLAG_MULTI },
830 { "match-mapped-addresses", &cfg_type_boolean, 0 },
831 { "memstatistics-file", &cfg_type_qstring, CFG_CLAUSEFLAG_NOTIMP },
832 { "multiple-cnames", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
833 { "named-xfer", &cfg_type_qstring, CFG_CLAUSEFLAG_OBSOLETE },
834 { "pid-file", &cfg_type_qstring, 0 },
835 { "port", &cfg_type_uint32, 0 },
836 { "random-device", &cfg_type_qstring, 0 },
837 { "recursive-clients", &cfg_type_uint32, 0 },
838 { "rrset-order", &cfg_type_rrsetorder, CFG_CLAUSEFLAG_NOTIMP },
839 { "serial-queries", &cfg_type_uint32, CFG_CLAUSEFLAG_OBSOLETE },
840 { "serial-query-rate", &cfg_type_uint32, 0 },
841 { "stacksize", &cfg_type_size, 0 },
842 { "statistics-file", &cfg_type_qstring, 0 },
843 { "statistics-interval", &cfg_type_uint32, CFG_CLAUSEFLAG_NYI },
844 { "tcp-clients", &cfg_type_uint32, 0 },
845 { "tkey-dhkey", &cfg_type_tkey_dhkey, 0 },
846 { "tkey-gssapi-credential", &cfg_type_qstring, 0 },
847 { "tkey-domain", &cfg_type_qstring, 0 },
848 { "transfers-per-ns", &cfg_type_uint32, 0 },
849 { "transfers-in", &cfg_type_uint32, 0 },
850 { "transfers-out", &cfg_type_uint32, 0 },
851 { "treat-cr-as-space", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
852 { "use-id-pool", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
853 { "use-ixfr", &cfg_type_boolean, 0 },
854 { "version", &cfg_type_qstring, 0 },
855 { NULL, NULL, 0 }
856 };
857
858
859 static cfg_type_t cfg_type_namelist = {
860 "namelist", parse_bracketed_list, print_bracketed_list,
861 &cfg_rep_list, &cfg_type_qstring };
862
863 static keyword_type_t exclude_kw = { "exclude", &cfg_type_namelist };
864
865 static cfg_type_t cfg_type_optional_exclude = {
866 "optional_exclude", parse_optional_keyvalue, print_keyvalue,
867 &cfg_rep_list, &exclude_kw };
868
869 /*
870 * Clauses that can be found within the 'view' statement,
871 * with defaults in the 'options' statement.
872 */
873
874 static cfg_clausedef_t
875 view_clauses[] = {
876 { "allow-recursion", &cfg_type_bracketed_aml, 0 },
877 { "allow-v6-synthesis", &cfg_type_bracketed_aml, 0 },
878 { "sortlist", &cfg_type_bracketed_aml, 0 },
879 { "topology", &cfg_type_bracketed_aml, CFG_CLAUSEFLAG_NOTIMP },
880 { "auth-nxdomain", &cfg_type_boolean, CFG_CLAUSEFLAG_NEWDEFAULT },
881 { "minimal-responses", &cfg_type_boolean, 0 },
882 { "recursion", &cfg_type_boolean, 0 },
883 { "provide-ixfr", &cfg_type_boolean, 0 },
884 { "request-ixfr", &cfg_type_boolean, 0 },
885 { "fetch-glue", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
886 { "rfc2308-type1", &cfg_type_boolean, CFG_CLAUSEFLAG_NYI },
887 { "additional-from-auth", &cfg_type_boolean, 0 },
888 { "additional-from-cache", &cfg_type_boolean, 0 },
889 /*
890 * Note that the query-source option syntax is different
891 * from the other -source options.
892 */
893 { "query-source", &cfg_type_querysource4, 0 },
894 { "query-source-v6", &cfg_type_querysource6, 0 },
895 { "cleaning-interval", &cfg_type_uint32, 0 },
896 { "min-roots", &cfg_type_uint32, CFG_CLAUSEFLAG_NOTIMP },
897 { "lame-ttl", &cfg_type_uint32, 0 },
898 { "max-ncache-ttl", &cfg_type_uint32, 0 },
899 { "max-cache-ttl", &cfg_type_uint32, 0 },
900 { "transfer-format", &cfg_type_transferformat, 0 },
901 { "max-cache-size", &cfg_type_sizenodefault, 0 },
902 { "check-names", &cfg_type_checknames,
903 CFG_CLAUSEFLAG_MULTI | CFG_CLAUSEFLAG_NOTIMP },
904 { "cache-file", &cfg_type_qstring, 0 },
905 { "root-delegation-only", &cfg_type_optional_exclude, 0 },
906 { NULL, NULL, 0 }
907 };
908
909 /*
910 * Clauses that can be found within the 'view' statement only.
911 */
912 static cfg_clausedef_t
913 view_only_clauses[] = {
914 { "match-clients", &cfg_type_bracketed_aml, 0 },
915 { "match-destinations", &cfg_type_bracketed_aml, 0 },
916 { "match-recursive-only", &cfg_type_boolean, 0 },
917 { NULL, NULL, 0 }
918 };
919
920 /*
921 * Clauses that can be found in a 'zone' statement,
922 * with defaults in the 'view' or 'options' statement.
923 */
924 static cfg_clausedef_t
925 zone_clauses[] = {
926 { "allow-query", &cfg_type_bracketed_aml, 0 },
927 { "allow-transfer", &cfg_type_bracketed_aml, 0 },
928 { "allow-update-forwarding", &cfg_type_bracketed_aml, 0 },
929 { "allow-notify", &cfg_type_bracketed_aml, 0 },
930 { "notify", &cfg_type_notifytype, 0 },
931 { "notify-source", &cfg_type_sockaddr4wild, 0 },
932 { "notify-source-v6", &cfg_type_sockaddr6wild, 0 },
933 { "also-notify", &cfg_type_portiplist, 0 },
934 { "dialup", &cfg_type_dialuptype, 0 },
935 { "forward", &cfg_type_forwardtype, 0 },
936 { "forwarders", &cfg_type_portiplist, 0 },
937 { "maintain-ixfr-base", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
938 { "max-ixfr-log-size", &cfg_type_size, CFG_CLAUSEFLAG_OBSOLETE },
939 { "transfer-source", &cfg_type_sockaddr4wild, 0 },
940 { "transfer-source-v6", &cfg_type_sockaddr6wild, 0 },
941 { "max-transfer-time-in", &cfg_type_uint32, 0 },
942 { "max-transfer-time-out", &cfg_type_uint32, 0 },
943 { "max-transfer-idle-in", &cfg_type_uint32, 0 },
944 { "max-transfer-idle-out", &cfg_type_uint32, 0 },
945 { "max-retry-time", &cfg_type_uint32, 0 },
946 { "min-retry-time", &cfg_type_uint32, 0 },
947 { "max-refresh-time", &cfg_type_uint32, 0 },
948 { "min-refresh-time", &cfg_type_uint32, 0 },
949 { "sig-validity-interval", &cfg_type_uint32, 0 },
950 { "zone-statistics", &cfg_type_boolean, 0 },
951 { NULL, NULL, 0 }
952 };
953
954 /*
955 * Clauses that can be found in a 'zone' statement
956 * only.
957 */
958 static cfg_clausedef_t
959 zone_only_clauses[] = {
960 { "type", &cfg_type_zonetype, 0 },
961 { "allow-update", &cfg_type_bracketed_aml, 0 },
962 { "file", &cfg_type_qstring, 0 },
963 { "ixfr-base", &cfg_type_qstring, CFG_CLAUSEFLAG_OBSOLETE },
964 { "ixfr-tmp-file", &cfg_type_qstring, CFG_CLAUSEFLAG_OBSOLETE },
965 { "masters", &cfg_type_sockaddrkeylist, 0 },
966 { "pubkey", &cfg_type_pubkey,
967 CFG_CLAUSEFLAG_MULTI | CFG_CLAUSEFLAG_OBSOLETE },
968 { "update-policy", &cfg_type_updatepolicy, 0 },
969 { "database", &cfg_type_astring, 0 },
970 { "delegation-only", &cfg_type_boolean, 0 },
971 /*
972 * Note that the format of the check-names option is different between
973 * the zone options and the global/view options. Ugh.
974 */
975 { "check-names", &cfg_type_ustring, CFG_CLAUSEFLAG_NOTIMP },
976 { NULL, NULL, 0 }
977 };
978
979
980 /* The top-level named.conf syntax. */
981
982 static cfg_clausedef_t *
983 namedconf_clausesets[] = {
984 namedconf_clauses,
985 namedconf_or_view_clauses,
986 NULL
987 };
988
989 LIBISCCFG_EXTERNAL_DATA cfg_type_t cfg_type_namedconf = {
990 "namedconf", parse_mapbody, print_mapbody, &cfg_rep_map,
991 namedconf_clausesets
992 };
993
994 /* The "options" statement syntax. */
995
996 static cfg_clausedef_t *
997 options_clausesets[] = {
998 options_clauses,
999 view_clauses,
1000 zone_clauses,
1001 NULL
1002 };
1003 static cfg_type_t cfg_type_options = {
1004 "options", parse_map, print_map, &cfg_rep_map, options_clausesets };
1005
1006 /* The "view" statement syntax. */
1007
1008 static cfg_clausedef_t *
1009 view_clausesets[] = {
1010 view_only_clauses,
1011 namedconf_or_view_clauses,
1012 view_clauses,
1013 zone_clauses,
1014 NULL
1015 };
1016 static cfg_type_t cfg_type_viewopts = {
1017 "view", parse_map, print_map, &cfg_rep_map, view_clausesets };
1018
1019 /* The "zone" statement syntax. */
1020
1021 static cfg_clausedef_t *
1022 zone_clausesets[] = {
1023 zone_only_clauses,
1024 zone_clauses,
1025 NULL
1026 };
1027 static cfg_type_t cfg_type_zoneopts = {
1028 "zoneopts", parse_map, print_map, &cfg_rep_map, zone_clausesets };
1029
1030 /*
1031 * Clauses that can be found within the 'key' statement.
1032 */
1033 static cfg_clausedef_t
1034 key_clauses[] = {
1035 { "algorithm", &cfg_type_astring, 0 },
1036 { "secret", &cfg_type_astring, 0 },
1037 { NULL, NULL, 0 }
1038 };
1039
1040 static cfg_clausedef_t *
1041 key_clausesets[] = {
1042 key_clauses,
1043 NULL
1044 };
1045 static cfg_type_t cfg_type_key = {
1046 "key", parse_named_map, print_map, &cfg_rep_map, key_clausesets };
1047
1048
1049 /*
1050 * Clauses that can be found in a 'server' statement.
1051 */
1052 static cfg_clausedef_t
1053 server_clauses[] = {
1054 { "bogus", &cfg_type_boolean, 0 },
1055 { "provide-ixfr", &cfg_type_boolean, 0 },
1056 { "request-ixfr", &cfg_type_boolean, 0 },
1057 { "support-ixfr", &cfg_type_boolean, CFG_CLAUSEFLAG_OBSOLETE },
1058 { "transfers", &cfg_type_uint32, 0 },
1059 { "transfer-format", &cfg_type_transferformat, 0 },
1060 { "keys", &cfg_type_server_key_kludge, 0 },
1061 { "edns", &cfg_type_boolean, 0 },
1062 { NULL, NULL, 0 }
1063 };
1064 static cfg_clausedef_t *
1065 server_clausesets[] = {
1066 server_clauses,
1067 NULL
1068 };
1069 static cfg_type_t cfg_type_server = {
1070 "server", parse_addressed_map, print_map, &cfg_rep_map,
1071 server_clausesets
1072 };
1073
1074
1075 /*
1076 * Clauses that can be found in a 'channel' clause in the
1077 * 'logging' statement.
1078 *
1079 * These have some additional constraints that need to be
1080 * checked after parsing:
1081 * - There must exactly one of file/syslog/null/stderr
1082 *
1083 */
1084 static cfg_clausedef_t
1085 channel_clauses[] = {
1086 /* Destinations. We no longer require these to be first. */
1087 { "file", &cfg_type_logfile, 0 },
1088 { "syslog", &cfg_type_optional_facility, 0 },
1089 { "null", &cfg_type_void, 0 },
1090 { "stderr", &cfg_type_void, 0 },
1091 /* Options. We now accept these for the null channel, too. */
1092 { "severity", &cfg_type_logseverity, 0 },
1093 { "print-time", &cfg_type_boolean, 0 },
1094 { "print-severity", &cfg_type_boolean, 0 },
1095 { "print-category", &cfg_type_boolean, 0 },
1096 { NULL, NULL, 0 }
1097 };
1098 static cfg_clausedef_t *
1099 channel_clausesets[] = {
1100 channel_clauses,
1101 NULL
1102 };
1103 static cfg_type_t cfg_type_channel = {
1104 "channel", parse_named_map, print_map,
1105 &cfg_rep_map, channel_clausesets
1106 };
1107
1108 /* A list of log destination, used in the "category" clause. */
1109 static cfg_type_t cfg_type_destinationlist = {
1110 "destinationlist", parse_bracketed_list, print_bracketed_list,
1111 &cfg_rep_list, &cfg_type_astring };
1112
1113 /*
1114 * Clauses that can be found in a 'logging' statement.
1115 */
1116 static cfg_clausedef_t
1117 logging_clauses[] = {
1118 { "channel", &cfg_type_channel, CFG_CLAUSEFLAG_MULTI },
1119 { "category", &cfg_type_category, CFG_CLAUSEFLAG_MULTI },
1120 { NULL, NULL, 0 }
1121 };
1122 static cfg_clausedef_t *
1123 logging_clausesets[] = {
1124 logging_clauses,
1125 NULL
1126 };
1127 static cfg_type_t cfg_type_logging = {
1128 "logging", parse_map, print_map, &cfg_rep_map, logging_clausesets };
1129
1130
1131 /* Functions. */
1132
1133 static void
1134 print_obj(cfg_printer_t *pctx, cfg_obj_t *obj) {
1135 obj->type->print(pctx, obj);
1136 }
1137
1138 static void
1139 print(cfg_printer_t *pctx, const char *text, int len) {
1140 pctx->f(pctx->closure, text, len);
1141 }
1142
1143 static void
1144 print_open(cfg_printer_t *pctx) {
1145 print(pctx, "{\n", 2);
1146 pctx->indent++;
1147 }
1148
1149 static void
1150 print_indent(cfg_printer_t *pctx) {
1151 int indent = pctx->indent;
1152 while (indent > 0) {
1153 print(pctx, "\t", 1);
1154 indent--;
1155 }
1156 }
1157
1158 static void
1159 print_close(cfg_printer_t *pctx) {
1160 pctx->indent--;
1161 print_indent(pctx);
1162 print(pctx, "}", 1);
1163 }
1164
1165 static isc_result_t
1166 parse(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1167 isc_result_t result;
1168 INSIST(ret != NULL && *ret == NULL);
1169 result = type->parse(pctx, type, ret);
1170 if (result != ISC_R_SUCCESS)
1171 return (result);
1172 INSIST(*ret != NULL);
1173 return (ISC_R_SUCCESS);
1174 }
1175
1176 void
1177 cfg_print(cfg_obj_t *obj,
1178 void (*f)(void *closure, const char *text, int textlen),
1179 void *closure)
1180 {
1181 cfg_printer_t pctx;
1182 pctx.f = f;
1183 pctx.closure = closure;
1184 pctx.indent = 0;
1185 obj->type->print(&pctx, obj);
1186 }
1187
1188
1189 /* Tuples. */
1190
1191 static isc_result_t
1192 create_tuple(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1193 isc_result_t result;
1194 const cfg_tuplefielddef_t *fields = type->of;
1195 const cfg_tuplefielddef_t *f;
1196 cfg_obj_t *obj = NULL;
1197 unsigned int nfields = 0;
1198 int i;
1199
1200 for (f = fields; f->name != NULL; f++)
1201 nfields++;
1202
1203 CHECK(create_cfgobj(pctx, type, &obj));
1204 obj->value.tuple = isc_mem_get(pctx->mctx,
1205 nfields * sizeof(cfg_obj_t *));
1206 if (obj->value.tuple == NULL) {
1207 result = ISC_R_NOMEMORY;
1208 goto cleanup;
1209 }
1210 for (f = fields, i = 0; f->name != NULL; f++, i++)
1211 obj->value.tuple[i] = NULL;
1212 *ret = obj;
1213 return (ISC_R_SUCCESS);
1214
1215 cleanup:
1216 if (obj != NULL)
1217 isc_mem_put(pctx->mctx, obj, sizeof(*obj));
1218 return (result);
1219 }
1220
1221 static isc_result_t
1222 parse_tuple(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
1223 {
1224 isc_result_t result;
1225 const cfg_tuplefielddef_t *fields = type->of;
1226 const cfg_tuplefielddef_t *f;
1227 cfg_obj_t *obj = NULL;
1228 unsigned int i;
1229
1230 CHECK(create_tuple(pctx, type, &obj));
1231 for (f = fields, i = 0; f->name != NULL; f++, i++)
1232 CHECK(parse(pctx, f->type, &obj->value.tuple[i]));
1233
1234 *ret = obj;
1235 return (ISC_R_SUCCESS);
1236
1237 cleanup:
1238 CLEANUP_OBJ(obj);
1239 return (result);
1240 }
1241
1242 static void
1243 print_tuple(cfg_printer_t *pctx, cfg_obj_t *obj) {
1244 unsigned int i;
1245 const cfg_tuplefielddef_t *fields = obj->type->of;
1246 const cfg_tuplefielddef_t *f;
1247 isc_boolean_t need_space = ISC_FALSE;
1248
1249 for (f = fields, i = 0; f->name != NULL; f++, i++) {
1250 cfg_obj_t *fieldobj = obj->value.tuple[i];
1251 if (need_space)
1252 print(pctx, " ", 1);
1253 print_obj(pctx, fieldobj);
1254 need_space = ISC_TF(fieldobj->type->print != print_void);
1255 }
1256 }
1257
1258 static void
1259 free_tuple(cfg_parser_t *pctx, cfg_obj_t *obj) {
1260 unsigned int i;
1261 const cfg_tuplefielddef_t *fields = obj->type->of;
1262 const cfg_tuplefielddef_t *f;
1263 unsigned int nfields = 0;
1264
1265 if (obj->value.tuple == NULL)
1266 return;
1267
1268 for (f = fields, i = 0; f->name != NULL; f++, i++) {
1269 CLEANUP_OBJ(obj->value.tuple[i]);
1270 nfields++;
1271 }
1272 isc_mem_put(pctx->mctx, obj->value.tuple,
1273 nfields * sizeof(cfg_obj_t *));
1274 }
1275
1276 isc_boolean_t
1277 cfg_obj_istuple(cfg_obj_t *obj) {
1278 REQUIRE(obj != NULL);
1279 return (ISC_TF(obj->type->rep == &cfg_rep_tuple));
1280 }
1281
1282 cfg_obj_t *
1283 cfg_tuple_get(cfg_obj_t *tupleobj, const char* name) {
1284 unsigned int i;
1285 const cfg_tuplefielddef_t *fields;
1286 const cfg_tuplefielddef_t *f;
1287
1288 REQUIRE(tupleobj != NULL && tupleobj->type->rep == &cfg_rep_tuple);
1289
1290 fields = tupleobj->type->of;
1291 for (f = fields, i = 0; f->name != NULL; f++, i++) {
1292 if (strcmp(f->name, name) == 0)
1293 return (tupleobj->value.tuple[i]);
1294 }
1295 INSIST(0);
1296 return (NULL);
1297 }
1298
1299 /*
1300 * Parse a required special character.
1301 */
1302 static isc_result_t
1303 parse_special(cfg_parser_t *pctx, int special) {
1304 isc_result_t result;
1305 CHECK(cfg_gettoken(pctx, 0));
1306 if (pctx->token.type == isc_tokentype_special &&
1307 pctx->token.value.as_char == special)
1308 return (ISC_R_SUCCESS);
1309
1310 parser_error(pctx, LOG_NEAR, "'%c' expected", special);
1311 return (ISC_R_UNEXPECTEDTOKEN);
1312 cleanup:
1313 return (result);
1314 }
1315
1316 /*
1317 * Parse a required semicolon. If it is not there, log
1318 * an error and increment the error count but continue
1319 * parsing. Since the next token is pushed back,
1320 * care must be taken to make sure it is eventually
1321 * consumed or an infinite loop may result.
1322 */
1323 static isc_result_t
1324 parse_semicolon(cfg_parser_t *pctx) {
1325 isc_result_t result;
1326 CHECK(cfg_gettoken(pctx, 0));
1327 if (pctx->token.type == isc_tokentype_special &&
1328 pctx->token.value.as_char == ';')
1329 return (ISC_R_SUCCESS);
1330
1331 parser_error(pctx, LOG_BEFORE, "missing ';'");
1332 cfg_ungettoken(pctx);
1333 cleanup:
1334 return (result);
1335 }
1336
1337 /*
1338 * Parse EOF, logging and returning an error if not there.
1339 */
1340 static isc_result_t
1341 parse_eof(cfg_parser_t *pctx) {
1342 isc_result_t result;
1343 CHECK(cfg_gettoken(pctx, 0));
1344
1345 if (pctx->token.type == isc_tokentype_eof)
1346 return (ISC_R_SUCCESS);
1347
1348 parser_error(pctx, LOG_NEAR, "syntax error");
1349 return (ISC_R_UNEXPECTEDTOKEN);
1350 cleanup:
1351 return(result);
1352 }
1353
1354 /* A list of files, used internally for pctx->files. */
1355
1356 static cfg_type_t cfg_type_filelist = {
1357 "filelist", NULL, print_list, &cfg_rep_list,
1358 &cfg_type_qstring
1359 };
1360
1361 isc_result_t
1362 cfg_parser_create(isc_mem_t *mctx, isc_log_t *lctx, cfg_parser_t **ret)
1363 {
1364 isc_result_t result;
1365 cfg_parser_t *pctx;
1366 isc_lexspecials_t specials;
1367
1368 REQUIRE(mctx != NULL);
1369 REQUIRE(ret != NULL && *ret == NULL);
1370
1371 pctx = isc_mem_get(mctx, sizeof(*pctx));
1372 if (pctx == NULL)
1373 return (ISC_R_NOMEMORY);
1374
1375 pctx->mctx = mctx;
1376 pctx->lctx = lctx;
1377 pctx->lexer = NULL;
1378 pctx->seen_eof = ISC_FALSE;
1379 pctx->ungotten = ISC_FALSE;
1380 pctx->errors = 0;
1381 pctx->warnings = 0;
1382 pctx->open_files = NULL;
1383 pctx->closed_files = NULL;
1384 pctx->line = 0;
1385 pctx->callback = NULL;
1386 pctx->callbackarg = NULL;
1387 pctx->token.type = isc_tokentype_unknown;
1388
1389 memset(specials, 0, sizeof(specials));
1390 specials['{'] = 1;
1391 specials['}'] = 1;
1392 specials[';'] = 1;
1393 specials['/'] = 1;
1394 specials['"'] = 1;
1395 specials['!'] = 1;
1396
1397 CHECK(isc_lex_create(pctx->mctx, 1024, &pctx->lexer));
1398
1399 isc_lex_setspecials(pctx->lexer, specials);
1400 isc_lex_setcomments(pctx->lexer, (ISC_LEXCOMMENT_C |
1401 ISC_LEXCOMMENT_CPLUSPLUS |
1402 ISC_LEXCOMMENT_SHELL));
1403
1404 CHECK(create_list(pctx, &cfg_type_filelist, &pctx->open_files));
1405 CHECK(create_list(pctx, &cfg_type_filelist, &pctx->closed_files));
1406
1407 *ret = pctx;
1408 return (ISC_R_SUCCESS);
1409
1410 cleanup:
1411 if (pctx->lexer != NULL)
1412 isc_lex_destroy(&pctx->lexer);
1413 CLEANUP_OBJ(pctx->open_files);
1414 CLEANUP_OBJ(pctx->closed_files);
1415 isc_mem_put(mctx, pctx, sizeof(*pctx));
1416 return (result);
1417 }
1418
1419 static isc_result_t
1420 parser_openfile(cfg_parser_t *pctx, const char *filename) {
1421 isc_result_t result;
1422 cfg_listelt_t *elt = NULL;
1423 cfg_obj_t *stringobj = NULL;
1424
1425 result = isc_lex_openfile(pctx->lexer, filename);
1426 if (result != ISC_R_SUCCESS) {
1427 parser_error(pctx, 0, "open: %s: %s",
1428 filename, isc_result_totext(result));
1429 goto cleanup;
1430 }
1431
1432 CHECK(create_string(pctx, filename, &cfg_type_qstring, &stringobj));
1433 CHECK(create_listelt(pctx, &elt));
1434 elt->obj = stringobj;
1435 ISC_LIST_APPEND(pctx->open_files->value.list, elt, link);
1436
1437 return (ISC_R_SUCCESS);
1438 cleanup:
1439 CLEANUP_OBJ(stringobj);
1440 return (result);
1441 }
1442
1443 void
1444 cfg_parser_setcallback(cfg_parser_t *pctx,
1445 cfg_parsecallback_t callback,
1446 void *arg)
1447 {
1448 pctx->callback = callback;
1449 pctx->callbackarg = arg;
1450 }
1451
1452 /*
1453 * Parse a configuration using a pctx where a lexer has already
1454 * been set up with a source.
1455 */
1456 static isc_result_t
1457 parse2(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1458 isc_result_t result;
1459 cfg_obj_t *obj = NULL;
1460
1461 result = parse(pctx, type, &obj);
1462
1463 if (pctx->errors != 0) {
1464 /* Errors have been logged. */
1465 if (result == ISC_R_SUCCESS)
1466 result = ISC_R_FAILURE;
1467 goto cleanup;
1468 }
1469
1470 if (result != ISC_R_SUCCESS) {
1471 /* Parsing failed but no errors have been logged. */
1472 parser_error(pctx, 0, "parsing failed");
1473 goto cleanup;
1474 }
1475
1476 CHECK(parse_eof(pctx));
1477
1478 *ret = obj;
1479 return (ISC_R_SUCCESS);
1480
1481 cleanup:
1482 CLEANUP_OBJ(obj);
1483 return (result);
1484 }
1485
1486 isc_result_t
1487 cfg_parse_file(cfg_parser_t *pctx, const char *filename,
1488 const cfg_type_t *type, cfg_obj_t **ret)
1489 {
1490 isc_result_t result;
1491
1492 REQUIRE(filename != NULL);
1493
1494 CHECK(parser_openfile(pctx, filename));
1495 CHECK(parse2(pctx, type, ret));
1496 cleanup:
1497 return (result);
1498 }
1499
1500
1501 isc_result_t
1502 cfg_parse_buffer(cfg_parser_t *pctx, isc_buffer_t *buffer,
1503 const cfg_type_t *type, cfg_obj_t **ret)
1504 {
1505 isc_result_t result;
1506 REQUIRE(buffer != NULL);
1507 CHECK(isc_lex_openbuffer(pctx->lexer, buffer));
1508 CHECK(parse2(pctx, type, ret));
1509 cleanup:
1510 return (result);
1511 }
1512
1513 void
1514 cfg_parser_destroy(cfg_parser_t **pctxp) {
1515 cfg_parser_t *pctx = *pctxp;
1516 isc_lex_destroy(&pctx->lexer);
1517 /*
1518 * Cleaning up open_files does not
1519 * close the files; that was already done
1520 * by closing the lexer.
1521 */
1522 CLEANUP_OBJ(pctx->open_files);
1523 CLEANUP_OBJ(pctx->closed_files);
1524 isc_mem_put(pctx->mctx, pctx, sizeof(*pctx));
1525 *pctxp = NULL;
1526 }
1527
1528 /*
1529 * void
1530 */
1531 static isc_result_t
1532 parse_void(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1533 UNUSED(type);
1534 return (create_cfgobj(pctx, &cfg_type_void, ret));
1535 }
1536
1537 static void
1538 print_void(cfg_printer_t *pctx, cfg_obj_t *obj) {
1539 UNUSED(pctx);
1540 UNUSED(obj);
1541 }
1542
1543 isc_boolean_t
1544 cfg_obj_isvoid(cfg_obj_t *obj) {
1545 REQUIRE(obj != NULL);
1546 return (ISC_TF(obj->type->rep == &cfg_rep_void));
1547 }
1548
1549 static cfg_type_t cfg_type_void = {
1550 "void", parse_void, print_void, &cfg_rep_void, NULL };
1551
1552
1553 /*
1554 * uint32
1555 */
1556 static isc_result_t
1557 parse_uint32(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1558 isc_result_t result;
1559 cfg_obj_t *obj = NULL;
1560 UNUSED(type);
1561
1562 CHECK(cfg_gettoken(pctx, ISC_LEXOPT_NUMBER | ISC_LEXOPT_CNUMBER));
1563 if (pctx->token.type != isc_tokentype_number) {
1564 parser_error(pctx, LOG_NEAR, "expected number");
1565 return (ISC_R_UNEXPECTEDTOKEN);
1566 }
1567
1568 CHECK(create_cfgobj(pctx, &cfg_type_uint32, &obj));
1569
1570 obj->value.uint32 = pctx->token.value.as_ulong;
1571 *ret = obj;
1572 cleanup:
1573 return (result);
1574 }
1575
1576 static void
1577 print_cstr(cfg_printer_t *pctx, const char *s) {
1578 print(pctx, s, strlen(s));
1579 }
1580
1581 static void
1582 print_uint(cfg_printer_t *pctx, unsigned int u) {
1583 char buf[32];
1584 snprintf(buf, sizeof(buf), "%u", u);
1585 print_cstr(pctx, buf);
1586 }
1587
1588 static void
1589 print_uint32(cfg_printer_t *pctx, cfg_obj_t *obj) {
1590 print_uint(pctx, obj->value.uint32);
1591 }
1592
1593 isc_boolean_t
1594 cfg_obj_isuint32(cfg_obj_t *obj) {
1595 REQUIRE(obj != NULL);
1596 return (ISC_TF(obj->type->rep == &cfg_rep_uint32));
1597 }
1598
1599 isc_uint32_t
1600 cfg_obj_asuint32(cfg_obj_t *obj) {
1601 REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_uint32);
1602 return (obj->value.uint32);
1603 }
1604
1605 static cfg_type_t cfg_type_uint32 = {
1606 "integer", parse_uint32, print_uint32, &cfg_rep_uint32, NULL };
1607
1608
1609 /*
1610 * uint64
1611 */
1612 isc_boolean_t
1613 cfg_obj_isuint64(cfg_obj_t *obj) {
1614 REQUIRE(obj != NULL);
1615 return (ISC_TF(obj->type->rep == &cfg_rep_uint64));
1616 }
1617
1618 isc_uint64_t
1619 cfg_obj_asuint64(cfg_obj_t *obj) {
1620 REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_uint64);
1621 return (obj->value.uint64);
1622 }
1623
1624 static isc_result_t
1625 parse_unitstring(char *str, isc_resourcevalue_t *valuep) {
1626 char *endp;
1627 unsigned int len;
1628 isc_uint64_t value;
1629 isc_uint64_t unit;
1630
1631 value = isc_string_touint64(str, &endp, 10);
1632 if (*endp == 0) {
1633 *valuep = value;
1634 return (ISC_R_SUCCESS);
1635 }
1636
1637 len = strlen(str);
1638 if (len < 2 || endp[1] != '\0')
1639 return (ISC_R_FAILURE);
1640
1641 switch (str[len - 1]) {
1642 case 'k':
1643 case 'K':
1644 unit = 1024;
1645 break;
1646 case 'm':
1647 case 'M':
1648 unit = 1024 * 1024;
1649 break;
1650 case 'g':
1651 case 'G':
1652 unit = 1024 * 1024 * 1024;
1653 break;
1654 default:
1655 return (ISC_R_FAILURE);
1656 }
1657 if (value > ISC_UINT64_MAX / unit)
1658 return (ISC_R_FAILURE);
1659 *valuep = value * unit;
1660 return (ISC_R_SUCCESS);
1661 }
1662
1663 static void
1664 print_uint64(cfg_printer_t *pctx, cfg_obj_t *obj) {
1665 char buf[32];
1666 sprintf(buf, "%" ISC_PRINT_QUADFORMAT "u", obj->value.uint64);
1667 print_cstr(pctx, buf);
1668 }
1669
1670 static cfg_type_t cfg_type_uint64 = {
1671 "64_bit_integer", NULL, print_uint64, &cfg_rep_uint64, NULL };
1672
1673 static isc_result_t
1674 parse_sizeval(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1675 isc_result_t result;
1676 cfg_obj_t *obj = NULL;
1677 isc_uint64_t val;
1678
1679 UNUSED(type);
1680
1681 CHECK(cfg_gettoken(pctx, 0));
1682 if (pctx->token.type != isc_tokentype_string) {
1683 result = ISC_R_UNEXPECTEDTOKEN;
1684 goto cleanup;
1685 }
1686 CHECK(parse_unitstring(pctx->token.value.as_pointer, &val));
1687
1688 CHECK(create_cfgobj(pctx, &cfg_type_uint64, &obj));
1689 obj->value.uint64 = val;
1690 *ret = obj;
1691 return (ISC_R_SUCCESS);
1692
1693 cleanup:
1694 parser_error(pctx, LOG_NEAR, "expected integer and optional unit");
1695 return (result);
1696 }
1697
1698 /*
1699 * A size value (number + optional unit).
1700 */
1701 static cfg_type_t cfg_type_sizeval = {
1702 "sizeval", parse_sizeval, print_uint64, &cfg_rep_uint64, NULL };
1703
1704 /*
1705 * A size, "unlimited", or "default".
1706 */
1707
1708 static isc_result_t
1709 parse_size(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1710 return (parse_enum_or_other(pctx, type, &cfg_type_sizeval, ret));
1711 }
1712
1713 static const char *size_enums[] = { "unlimited", "default", NULL };
1714 static cfg_type_t cfg_type_size = {
1715 "size", parse_size, print_ustring, &cfg_rep_string, size_enums
1716 };
1717
1718 /*
1719 * A size or "unlimited", but not "default".
1720 */
1721 static const char *sizenodefault_enums[] = { "unlimited", NULL };
1722 static cfg_type_t cfg_type_sizenodefault = {
1723 "size_no_default", parse_size, print_ustring, &cfg_rep_string,
1724 sizenodefault_enums
1725 };
1726
1727 /*
1728 * optional_keyvalue
1729 */
1730 static isc_result_t
1731 parse_maybe_optional_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type,
1732 isc_boolean_t optional, cfg_obj_t **ret)
1733 {
1734 isc_result_t result;
1735 cfg_obj_t *obj = NULL;
1736 const keyword_type_t *kw = type->of;
1737
1738 CHECK(cfg_peektoken(pctx, 0));
1739 if (pctx->token.type == isc_tokentype_string &&
1740 strcasecmp(pctx->token.value.as_pointer, kw->name) == 0) {
1741 CHECK(cfg_gettoken(pctx, 0));
1742 CHECK(kw->type->parse(pctx, kw->type, &obj));
1743 obj->type = type; /* XXX kludge */
1744 } else {
1745 if (optional) {
1746 CHECK(parse_void(pctx, NULL, &obj));
1747 } else {
1748 parser_error(pctx, LOG_NEAR, "expected '%s'",
1749 kw->name);
1750 result = ISC_R_UNEXPECTEDTOKEN;
1751 goto cleanup;
1752 }
1753 }
1754 *ret = obj;
1755 cleanup:
1756 return (result);
1757 }
1758
1759 static isc_result_t
1760 parse_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1761 return (parse_maybe_optional_keyvalue(pctx, type, ISC_FALSE, ret));
1762 }
1763
1764 static isc_result_t
1765 parse_optional_keyvalue(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1766 return (parse_maybe_optional_keyvalue(pctx, type, ISC_TRUE, ret));
1767 }
1768
1769 static void
1770 print_keyvalue(cfg_printer_t *pctx, cfg_obj_t *obj) {
1771 const keyword_type_t *kw = obj->type->of;
1772 print_cstr(pctx, kw->name);
1773 print(pctx, " ", 1);
1774 kw->type->print(pctx, obj);
1775 }
1776
1777 /*
1778 * qstring, ustring, astring
1779 */
1780
1781 /* Create a string object from a null-terminated C string. */
1782 static isc_result_t
1783 create_string(cfg_parser_t *pctx, const char *contents, const cfg_type_t *type,
1784 cfg_obj_t **ret)
1785 {
1786 isc_result_t result;
1787 cfg_obj_t *obj = NULL;
1788 int len;
1789
1790 CHECK(create_cfgobj(pctx, type, &obj));
1791 len = strlen(contents);
1792 obj->value.string.length = len;
1793 obj->value.string.base = isc_mem_get(pctx->mctx, len + 1);
1794 if (obj->value.string.base == 0) {
1795 isc_mem_put(pctx->mctx, obj, sizeof(*obj));
1796 return (ISC_R_NOMEMORY);
1797 }
1798 memcpy(obj->value.string.base, contents, len);
1799 obj->value.string.base[len] = '\0';
1800
1801 *ret = obj;
1802 cleanup:
1803 return (result);
1804 }
1805
1806 static isc_result_t
1807 parse_qstring(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1808 isc_result_t result;
1809 UNUSED(type);
1810
1811 CHECK(cfg_gettoken(pctx, QSTRING));
1812 if (pctx->token.type != isc_tokentype_qstring) {
1813 parser_error(pctx, LOG_NEAR, "expected quoted string");
1814 return (ISC_R_UNEXPECTEDTOKEN);
1815 }
1816 return (create_string(pctx,
1817 pctx->token.value.as_pointer,
1818 &cfg_type_qstring,
1819 ret));
1820 cleanup:
1821 return (result);
1822 }
1823
1824 static isc_result_t
1825 parse_ustring(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1826 isc_result_t result;
1827 UNUSED(type);
1828
1829 CHECK(cfg_gettoken(pctx, 0));
1830 if (pctx->token.type != isc_tokentype_string) {
1831 parser_error(pctx, LOG_NEAR, "expected unquoted string");
1832 return (ISC_R_UNEXPECTEDTOKEN);
1833 }
1834 return (create_string(pctx,
1835 pctx->token.value.as_pointer,
1836 &cfg_type_ustring,
1837 ret));
1838 cleanup:
1839 return (result);
1840 }
1841
1842 static isc_result_t
1843 parse_astring(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1844 isc_result_t result;
1845 UNUSED(type);
1846
1847 CHECK(cfg_getstringtoken(pctx));
1848 return (create_string(pctx,
1849 pctx->token.value.as_pointer,
1850 &cfg_type_qstring,
1851 ret));
1852 cleanup:
1853 return (result);
1854 }
1855
1856 static isc_boolean_t
1857 is_enum(const char *s, const char *const *enums) {
1858 const char * const *p;
1859 for (p = enums; *p != NULL; p++) {
1860 if (strcasecmp(*p, s) == 0)
1861 return (ISC_TRUE);
1862 }
1863 return (ISC_FALSE);
1864 }
1865
1866 static isc_result_t
1867 check_enum(cfg_parser_t *pctx, cfg_obj_t *obj, const char *const *enums) {
1868 const char *s = obj->value.string.base;
1869 if (is_enum(s, enums))
1870 return (ISC_R_SUCCESS);
1871 parser_error(pctx, 0, "'%s' unexpected", s);
1872 return (ISC_R_UNEXPECTEDTOKEN);
1873 }
1874
1875 static isc_result_t
1876 parse_enum(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
1877 isc_result_t result;
1878 cfg_obj_t *obj = NULL;
1879 CHECK(parse_ustring(pctx, NULL, &obj));
1880 CHECK(check_enum(pctx, obj, type->of));
1881 *ret = obj;
1882 return (ISC_R_SUCCESS);
1883 cleanup:
1884 CLEANUP_OBJ(obj);
1885 return (result);
1886 }
1887
1888 static isc_result_t
1889 parse_enum_or_other(cfg_parser_t *pctx, const cfg_type_t *enumtype,
1890 const cfg_type_t *othertype, cfg_obj_t **ret)
1891 {
1892 isc_result_t result;
1893 CHECK(cfg_peektoken(pctx, 0));
1894 if (pctx->token.type == isc_tokentype_string &&
1895 is_enum(pctx->token.value.as_pointer, enumtype->of)) {
1896 CHECK(parse_enum(pctx, enumtype, ret));
1897 } else {
1898 CHECK(parse(pctx, othertype, ret));
1899 }
1900 cleanup:
1901 return (result);
1902 }
1903
1904
1905 /*
1906 * Print a string object.
1907 */
1908 static void
1909 print_ustring(cfg_printer_t *pctx, cfg_obj_t *obj) {
1910 print(pctx, obj->value.string.base, obj->value.string.length);
1911 }
1912
1913 static void
1914 print_qstring(cfg_printer_t *pctx, cfg_obj_t *obj) {
1915 print(pctx, "\"", 1);
1916 print_ustring(pctx, obj);
1917 print(pctx, "\"", 1);
1918 }
1919
1920 static void
1921 free_string(cfg_parser_t *pctx, cfg_obj_t *obj) {
1922 isc_mem_put(pctx->mctx, obj->value.string.base,
1923 obj->value.string.length + 1);
1924 }
1925
1926 isc_boolean_t
1927 cfg_obj_isstring(cfg_obj_t *obj) {
1928 REQUIRE(obj != NULL);
1929 return (ISC_TF(obj->type->rep == &cfg_rep_string));
1930 }
1931
1932 char *
1933 cfg_obj_asstring(cfg_obj_t *obj) {
1934 REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_string);
1935 return (obj->value.string.base);
1936 }
1937
1938 isc_boolean_t
1939 cfg_obj_isboolean(cfg_obj_t *obj) {
1940 REQUIRE(obj != NULL);
1941 return (ISC_TF(obj->type->rep == &cfg_rep_boolean));
1942 }
1943
1944 isc_boolean_t
1945 cfg_obj_asboolean(cfg_obj_t *obj) {
1946 REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_boolean);
1947 return (obj->value.boolean);
1948 }
1949
1950 /* Quoted string only */
1951 static cfg_type_t cfg_type_qstring = {
1952 "quoted_string", parse_qstring, print_qstring, &cfg_rep_string, NULL };
1953
1954 /* Unquoted string only */
1955 static cfg_type_t cfg_type_ustring = {
1956 "string", parse_ustring, print_ustring, &cfg_rep_string, NULL };
1957
1958 /* Any string (quoted or unquoted); printed with quotes */
1959 static cfg_type_t cfg_type_astring = {
1960 "string", parse_astring, print_qstring, &cfg_rep_string, NULL };
1961
1962
1963 /*
1964 * boolean
1965 */
1966 static isc_result_t
1967 parse_boolean(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
1968 {
1969 isc_result_t result;
1970 isc_boolean_t value;
1971 cfg_obj_t *obj = NULL;
1972 UNUSED(type);
1973
1974 result = cfg_gettoken(pctx, 0);
1975 if (result != ISC_R_SUCCESS)
1976 return (result);
1977
1978 if (pctx->token.type != isc_tokentype_string)
1979 goto bad_boolean;
1980
1981 if ((strcasecmp(pctx->token.value.as_pointer, "true") == 0) ||
1982 (strcasecmp(pctx->token.value.as_pointer, "yes") == 0) ||
1983 (strcmp(pctx->token.value.as_pointer, "1") == 0)) {
1984 value = ISC_TRUE;
1985 } else if ((strcasecmp(pctx->token.value.as_pointer, "false") == 0) ||
1986 (strcasecmp(pctx->token.value.as_pointer, "no") == 0) ||
1987 (strcmp(pctx->token.value.as_pointer, "0") == 0)) {
1988 value = ISC_FALSE;
1989 } else {
1990 goto bad_boolean;
1991 }
1992
1993 CHECK(create_cfgobj(pctx, &cfg_type_boolean, &obj));
1994 obj->value.boolean = value;
1995 *ret = obj;
1996 return (result);
1997
1998 bad_boolean:
1999 parser_error(pctx, LOG_NEAR, "boolean expected");
2000 return (ISC_R_UNEXPECTEDTOKEN);
2001
2002 cleanup:
2003 return (result);
2004 }
2005
2006 static void
2007 print_boolean(cfg_printer_t *pctx, cfg_obj_t *obj) {
2008 if (obj->value.boolean)
2009 print(pctx, "yes", 3);
2010 else
2011 print(pctx, "no", 2);
2012 }
2013
2014 static cfg_type_t cfg_type_boolean = {
2015 "boolean", parse_boolean, print_boolean, &cfg_rep_boolean, NULL };
2016
2017 static const char *dialup_enums[] = {
2018 "notify", "notify-passive", "refresh", "passive", NULL };
2019 static isc_result_t
2020 parse_dialup_type(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2021 return (parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
2022 }
2023 static cfg_type_t cfg_type_dialuptype = {
2024 "dialuptype", parse_dialup_type, print_ustring,
2025 &cfg_rep_string, dialup_enums
2026 };
2027
2028 static const char *notify_enums[] = { "explicit", NULL };
2029 static isc_result_t
2030 parse_notify_type(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2031 return (parse_enum_or_other(pctx, type, &cfg_type_boolean, ret));
2032 }
2033 static cfg_type_t cfg_type_notifytype = {
2034 "notifytype", parse_notify_type, print_ustring,
2035 &cfg_rep_string, notify_enums,
2036 };
2037
2038 static keyword_type_t key_kw = { "key", &cfg_type_astring };
2039
2040 LIBISCCFG_EXTERNAL_DATA cfg_type_t cfg_type_keyref = {
2041 "keyref", parse_keyvalue, print_keyvalue,
2042 &cfg_rep_string, &key_kw
2043 };
2044
2045 static cfg_type_t cfg_type_optional_keyref = {
2046 "optional_keyref", parse_optional_keyvalue, print_keyvalue,
2047 &cfg_rep_string, &key_kw
2048 };
2049
2050
2051 /*
2052 * Lists.
2053 */
2054
2055 static isc_result_t
2056 create_list(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **obj) {
2057 isc_result_t result;
2058 CHECK(create_cfgobj(pctx, type, obj));
2059 ISC_LIST_INIT((*obj)->value.list);
2060 cleanup:
2061 return (result);
2062 }
2063
2064 static isc_result_t
2065 create_listelt(cfg_parser_t *pctx, cfg_listelt_t **eltp) {
2066 cfg_listelt_t *elt;
2067 elt = isc_mem_get(pctx->mctx, sizeof(*elt));
2068 if (elt == NULL)
2069 return (ISC_R_NOMEMORY);
2070 elt->obj = NULL;
2071 ISC_LINK_INIT(elt, link);
2072 *eltp = elt;
2073 return (ISC_R_SUCCESS);
2074 }
2075
2076 static void
2077 free_list_elt(cfg_parser_t *pctx, cfg_listelt_t *elt) {
2078 cfg_obj_destroy(pctx, &elt->obj);
2079 isc_mem_put(pctx->mctx, elt, sizeof(*elt));
2080 }
2081
2082 static void
2083 free_list(cfg_parser_t *pctx, cfg_obj_t *obj) {
2084 cfg_listelt_t *elt, *next;
2085 for (elt = ISC_LIST_HEAD(obj->value.list);
2086 elt != NULL;
2087 elt = next)
2088 {
2089 next = ISC_LIST_NEXT(elt, link);
2090 free_list_elt(pctx, elt);
2091 }
2092 }
2093
2094 static isc_result_t
2095 parse_list_elt(cfg_parser_t *pctx, const cfg_type_t *elttype,
2096 cfg_listelt_t **ret)
2097 {
2098 isc_result_t result;
2099 cfg_listelt_t *elt = NULL;
2100 cfg_obj_t *value = NULL;
2101
2102 CHECK(create_listelt(pctx, &elt));
2103
2104 result = parse(pctx, elttype, &value);
2105 if (result != ISC_R_SUCCESS)
2106 goto cleanup;
2107
2108 elt->obj = value;
2109
2110 *ret = elt;
2111 return (ISC_R_SUCCESS);
2112
2113 cleanup:
2114 isc_mem_put(pctx->mctx, elt, sizeof(*elt));
2115 return (result);
2116 }
2117
2118 /*
2119 * Parse a homogeneous list whose elements are of type 'elttype'
2120 * and where each element is terminated by a semicolon.
2121 */
2122 static isc_result_t
2123 parse_list(cfg_parser_t *pctx, const cfg_type_t *listtype, cfg_obj_t **ret)
2124 {
2125 cfg_obj_t *listobj = NULL;
2126 const cfg_type_t *listof = listtype->of;
2127 isc_result_t result;
2128 cfg_listelt_t *elt = NULL;
2129
2130 CHECK(create_list(pctx, listtype, &listobj));
2131
2132 for (;;) {
2133 CHECK(cfg_peektoken(pctx, 0));
2134 if (pctx->token.type == isc_tokentype_special &&
2135 pctx->token.value.as_char == /*{*/ '}')
2136 break;
2137 CHECK(parse_list_elt(pctx, listof, &elt));
2138 CHECK(parse_semicolon(pctx));
2139 ISC_LIST_APPEND(listobj->value.list, elt, link);
2140 elt = NULL;
2141 }
2142 *ret = listobj;
2143 return (ISC_R_SUCCESS);
2144
2145 cleanup:
2146 if (elt != NULL)
2147 free_list_elt(pctx, elt);
2148 CLEANUP_OBJ(listobj);
2149 return (result);
2150 }
2151
2152 static void
2153 print_list(cfg_printer_t *pctx, cfg_obj_t *obj) {
2154 cfg_list_t *list = &obj->value.list;
2155 cfg_listelt_t *elt;
2156
2157 for (elt = ISC_LIST_HEAD(*list);
2158 elt != NULL;
2159 elt = ISC_LIST_NEXT(elt, link)) {
2160 print_indent(pctx);
2161 print_obj(pctx, elt->obj);
2162 print(pctx, ";\n", 2);
2163 }
2164 }
2165
2166 static isc_result_t
2167 parse_bracketed_list(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
2168 {
2169 isc_result_t result;
2170 CHECK(parse_special(pctx, '{'));
2171 CHECK(parse_list(pctx, type, ret));
2172 CHECK(parse_special(pctx, '}'));
2173 cleanup:
2174 return (result);
2175 }
2176
2177 static void
2178 print_bracketed_list(cfg_printer_t *pctx, cfg_obj_t *obj) {
2179 print_open(pctx);
2180 print_list(pctx, obj);
2181 print_close(pctx);
2182 }
2183
2184 /*
2185 * Parse a homogeneous list whose elements are of type 'elttype'
2186 * and where elements are separated by space. The list ends
2187 * before the first semicolon.
2188 */
2189 static isc_result_t
2190 parse_spacelist(cfg_parser_t *pctx, const cfg_type_t *listtype, cfg_obj_t **ret)
2191 {
2192 cfg_obj_t *listobj = NULL;
2193 const cfg_type_t *listof = listtype->of;
2194 isc_result_t result;
2195
2196 CHECK(create_list(pctx, listtype, &listobj));
2197
2198 for (;;) {
2199 cfg_listelt_t *elt = NULL;
2200
2201 CHECK(cfg_peektoken(pctx, 0));
2202 if (pctx->token.type == isc_tokentype_special &&
2203 pctx->token.value.as_char == ';')
2204 break;
2205 CHECK(parse_list_elt(pctx, listof, &elt));
2206 ISC_LIST_APPEND(listobj->value.list, elt, link);
2207 }
2208 *ret = listobj;
2209 return (ISC_R_SUCCESS);
2210
2211 cleanup:
2212 CLEANUP_OBJ(listobj);
2213 return (result);
2214 }
2215
2216 static void
2217 print_spacelist(cfg_printer_t *pctx, cfg_obj_t *obj) {
2218 cfg_list_t *list = &obj->value.list;
2219 cfg_listelt_t *elt;
2220
2221 for (elt = ISC_LIST_HEAD(*list);
2222 elt != NULL;
2223 elt = ISC_LIST_NEXT(elt, link)) {
2224 print_obj(pctx, elt->obj);
2225 if (ISC_LIST_NEXT(elt, link) != NULL)
2226 print(pctx, " ", 1);
2227 }
2228 }
2229
2230 isc_boolean_t
2231 cfg_obj_islist(cfg_obj_t *obj) {
2232 REQUIRE(obj != NULL);
2233 return (ISC_TF(obj->type->rep == &cfg_rep_list));
2234 }
2235
2236 cfg_listelt_t *
2237 cfg_list_first(cfg_obj_t *obj) {
2238 REQUIRE(obj == NULL || obj->type->rep == &cfg_rep_list);
2239 if (obj == NULL)
2240 return (NULL);
2241 return (ISC_LIST_HEAD(obj->value.list));
2242 }
2243
2244 cfg_listelt_t *
2245 cfg_list_next(cfg_listelt_t *elt) {
2246 REQUIRE(elt != NULL);
2247 return (ISC_LIST_NEXT(elt, link));
2248 }
2249
2250 cfg_obj_t *
2251 cfg_listelt_value(cfg_listelt_t *elt) {
2252 REQUIRE(elt != NULL);
2253 return (elt->obj);
2254 }
2255
2256 /*
2257 * Maps.
2258 */
2259
2260 /*
2261 * Parse a map body. That's something like
2262 *
2263 * "foo 1; bar { glub; }; zap true; zap false;"
2264 *
2265 * i.e., a sequence of option names followed by values and
2266 * terminated by semicolons. Used for the top level of
2267 * the named.conf syntax, as well as for the body of the
2268 * options, view, zone, and other statements.
2269 */
2270 static isc_result_t
2271 parse_mapbody(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
2272 {
2273 const cfg_clausedef_t * const *clausesets = type->of;
2274 isc_result_t result;
2275 const cfg_clausedef_t * const *clauseset;
2276 const cfg_clausedef_t *clause;
2277 cfg_obj_t *value = NULL;
2278 cfg_obj_t *obj = NULL;
2279 cfg_obj_t *eltobj = NULL;
2280 cfg_obj_t *includename = NULL;
2281 isc_symvalue_t symval;
2282 cfg_list_t *list = NULL;
2283
2284 CHECK(create_map(pctx, type, &obj));
2285
2286 obj->value.map.clausesets = clausesets;
2287
2288 for (;;) {
2289 cfg_listelt_t *elt;
2290
2291 redo:
2292 /*
2293 * Parse the option name and see if it is known.
2294 */
2295 CHECK(cfg_gettoken(pctx, 0));
2296
2297 if (pctx->token.type != isc_tokentype_string) {
2298 cfg_ungettoken(pctx);
2299 break;
2300 }
2301
2302 /*
2303 * We accept "include" statements wherever a map body
2304 * clause can occur.
2305 */
2306 if (strcasecmp(pctx->token.value.as_pointer, "include") == 0) {
2307 /*
2308 * Turn the file name into a temporary configuration
2309 * object just so that it is not overwritten by the
2310 * semicolon token.
2311 */
2312 CHECK(parse(pctx, &cfg_type_qstring, &includename));
2313 CHECK(parse_semicolon(pctx));
2314 CHECK(parser_openfile(pctx, includename->
2315 value.string.base));
2316 cfg_obj_destroy(pctx, &includename);
2317 goto redo;
2318 }
2319
2320 clause = NULL;
2321 for (clauseset = clausesets; *clauseset != NULL; clauseset++) {
2322 for (clause = *clauseset;
2323 clause->name != NULL;
2324 clause++) {
2325 if (strcasecmp(pctx->token.value.as_pointer,
2326 clause->name) == 0)
2327 goto done;
2328 }
2329 }
2330 done:
2331 if (clause == NULL || clause->name == NULL) {
2332 parser_error(pctx, LOG_NOPREP, "unknown option");
2333 /*
2334 * Try to recover by parsing this option as an unknown
2335 * option and discarding it.
2336 */
2337 CHECK(parse(pctx, &cfg_type_unsupported, &eltobj));
2338 cfg_obj_destroy(pctx, &eltobj);
2339 CHECK(parse_semicolon(pctx));
2340 continue;
2341 }
2342
2343 /* Clause is known. */
2344
2345 /* Issue warnings if appropriate */
2346 if ((clause->flags & CFG_CLAUSEFLAG_OBSOLETE) != 0)
2347 parser_warning(pctx, 0, "option '%s' is obsolete",
2348 clause->name);
2349 if ((clause->flags & CFG_CLAUSEFLAG_NOTIMP) != 0)
2350 parser_warning(pctx, 0, "option '%s' is "
2351 "not implemented", clause->name);
2352 if ((clause->flags & CFG_CLAUSEFLAG_NYI) != 0)
2353 parser_warning(pctx, 0, "option '%s' is "
2354 "not implemented", clause->name);
2355 /*
2356 * Don't log options with CFG_CLAUSEFLAG_NEWDEFAULT
2357 * set here - we need to log the *lack* of such an option,
2358 * not its presence.
2359 */
2360
2361 /* See if the clause already has a value; if not create one. */
2362 result = isc_symtab_lookup(obj->value.map.symtab,
2363 clause->name, 0, &symval);
2364
2365 if ((clause->flags & CFG_CLAUSEFLAG_MULTI) != 0) {
2366 /* Multivalued clause */
2367 cfg_obj_t *listobj = NULL;
2368 if (result == ISC_R_NOTFOUND) {
2369 CHECK(create_list(pctx,
2370 &cfg_type_implicitlist,
2371 &listobj));
2372 symval.as_pointer = listobj;
2373 result = isc_symtab_define(obj->value.
2374 map.symtab,
2375 clause->name,
2376 1, symval,
2377 isc_symexists_reject);
2378 if (result != ISC_R_SUCCESS) {
2379 parser_error(pctx, LOG_NEAR,
2380 "isc_symtab_define(%s) "
2381 "failed", clause->name);
2382 isc_mem_put(pctx->mctx, list,
2383 sizeof(cfg_list_t));
2384 goto cleanup;
2385 }
2386 } else {
2387 INSIST(result == ISC_R_SUCCESS);
2388 listobj = symval.as_pointer;
2389 }
2390
2391 elt = NULL;
2392 CHECK(parse_list_elt(pctx, clause->type, &elt));
2393 CHECK(parse_semicolon(pctx));
2394
2395 ISC_LIST_APPEND(listobj->value.list, elt, link);
2396 } else {
2397 /* Single-valued clause */
2398 if (result == ISC_R_NOTFOUND) {
2399 isc_boolean_t callback =
2400 ISC_TF((clause->flags &
2401 CFG_CLAUSEFLAG_CALLBACK) != 0);
2402 CHECK(parse_symtab_elt(pctx, clause->name,
2403 clause->type,
2404 obj->value.map.symtab,
2405 callback));
2406 CHECK(parse_semicolon(pctx));
2407 } else if (result == ISC_R_SUCCESS) {
2408 parser_error(pctx, LOG_NEAR, "'%s' redefined",
2409 clause->name);
2410 result = ISC_R_EXISTS;
2411 goto cleanup;
2412 } else {
2413 parser_error(pctx, LOG_NEAR,
2414 "isc_symtab_define() failed");
2415 goto cleanup;
2416 }
2417 }
2418 }
2419
2420
2421 *ret = obj;
2422 return (ISC_R_SUCCESS);
2423
2424 cleanup:
2425 CLEANUP_OBJ(value);
2426 CLEANUP_OBJ(obj);
2427 CLEANUP_OBJ(eltobj);
2428 CLEANUP_OBJ(includename);
2429 return (result);
2430 }
2431
2432 static isc_result_t
2433 parse_symtab_elt(cfg_parser_t *pctx, const char *name,
2434 cfg_type_t *elttype, isc_symtab_t *symtab,
2435 isc_boolean_t callback)
2436 {
2437 isc_result_t result;
2438 cfg_obj_t *obj = NULL;
2439 isc_symvalue_t symval;
2440
2441 CHECK(parse(pctx, elttype, &obj));
2442
2443 if (callback && pctx->callback != NULL)
2444 CHECK(pctx->callback(name, obj, pctx->callbackarg));
2445
2446 symval.as_pointer = obj;
2447 CHECK(isc_symtab_define(symtab, name,
2448 1, symval,
2449 isc_symexists_reject));
2450 return (ISC_R_SUCCESS);
2451
2452 cleanup:
2453 CLEANUP_OBJ(obj);
2454 return (result);
2455 }
2456
2457 /*
2458 * Parse a map; e.g., "{ foo 1; bar { glub; }; zap true; zap false; }"
2459 */
2460 static isc_result_t
2461 parse_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
2462 {
2463 isc_result_t result;
2464 CHECK(parse_special(pctx, '{'));
2465 CHECK(parse_mapbody(pctx, type, ret));
2466 CHECK(parse_special(pctx, '}'));
2467 cleanup:
2468 return (result);
2469 }
2470
2471 /*
2472 * Subroutine for parse_named_map() and parse_addressed_map().
2473 */
2474 static isc_result_t
2475 parse_any_named_map(cfg_parser_t *pctx, cfg_type_t *nametype, const cfg_type_t *type,
2476 cfg_obj_t **ret)
2477 {
2478 isc_result_t result;
2479 cfg_obj_t *idobj = NULL;
2480 cfg_obj_t *mapobj = NULL;
2481
2482 CHECK(parse(pctx, nametype, &idobj));
2483 CHECK(parse_map(pctx, type, &mapobj));
2484 mapobj->value.map.id = idobj;
2485 idobj = NULL;
2486 *ret = mapobj;
2487 cleanup:
2488 CLEANUP_OBJ(idobj);
2489 return (result);
2490 }
2491
2492 /*
2493 * Parse a map identified by a string name. E.g., "name { foo 1; }".
2494 * Used for the "key" and "channel" statements.
2495 */
2496 static isc_result_t
2497 parse_named_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2498 return (parse_any_named_map(pctx, &cfg_type_astring, type, ret));
2499 }
2500
2501 /*
2502 * Parse a map identified by a network address.
2503 * Used for the "server" statement.
2504 */
2505 static isc_result_t
2506 parse_addressed_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2507 return (parse_any_named_map(pctx, &cfg_type_netaddr, type, ret));
2508 }
2509
2510 static void
2511 print_mapbody(cfg_printer_t *pctx, cfg_obj_t *obj) {
2512 isc_result_t result = ISC_R_SUCCESS;
2513
2514 const cfg_clausedef_t * const *clauseset;
2515
2516 for (clauseset = obj->value.map.clausesets;
2517 *clauseset != NULL;
2518 clauseset++)
2519 {
2520 isc_symvalue_t symval;
2521 const cfg_clausedef_t *clause;
2522
2523 for (clause = *clauseset;
2524 clause->name != NULL;
2525 clause++) {
2526 result = isc_symtab_lookup(obj->value.map.symtab,
2527 clause->name, 0, &symval);
2528 if (result == ISC_R_SUCCESS) {
2529 cfg_obj_t *obj = symval.as_pointer;
2530 if (obj->type == &cfg_type_implicitlist) {
2531 /* Multivalued. */
2532 cfg_list_t *list = &obj->value.list;
2533 cfg_listelt_t *elt;
2534 for (elt = ISC_LIST_HEAD(*list);
2535 elt != NULL;
2536 elt = ISC_LIST_NEXT(elt, link)) {
2537 print_indent(pctx);
2538 print_cstr(pctx, clause->name);
2539 print(pctx, " ", 1);
2540 print_obj(pctx, elt->obj);
2541 print(pctx, ";\n", 2);
2542 }
2543 } else {
2544 /* Single-valued. */
2545 print_indent(pctx);
2546 print_cstr(pctx, clause->name);
2547 print(pctx, " ", 1);
2548 print_obj(pctx, obj);
2549 print(pctx, ";\n", 2);
2550 }
2551 } else if (result == ISC_R_NOTFOUND) {
2552 ; /* do nothing */
2553 } else {
2554 INSIST(0);
2555 }
2556 }
2557 }
2558 }
2559
2560 static void
2561 print_map(cfg_printer_t *pctx, cfg_obj_t *obj) {
2562 if (obj->value.map.id != NULL) {
2563 print_obj(pctx, obj->value.map.id);
2564 print(pctx, " ", 1);
2565 }
2566 print_open(pctx);
2567 print_mapbody(pctx, obj);
2568 print_close(pctx);
2569 }
2570
2571 isc_boolean_t
2572 cfg_obj_ismap(cfg_obj_t *obj) {
2573 REQUIRE(obj != NULL);
2574 return (ISC_TF(obj->type->rep == &cfg_rep_map));
2575 }
2576
2577 isc_result_t
2578 cfg_map_get(cfg_obj_t *mapobj, const char* name, cfg_obj_t **obj) {
2579 isc_result_t result;
2580 isc_symvalue_t val;
2581 cfg_map_t *map;
2582
2583 REQUIRE(mapobj != NULL && mapobj->type->rep == &cfg_rep_map);
2584 REQUIRE(name != NULL);
2585 REQUIRE(obj != NULL && *obj == NULL);
2586
2587 map = &mapobj->value.map;
2588
2589 result = isc_symtab_lookup(map->symtab, name, MAP_SYM, &val);
2590 if (result != ISC_R_SUCCESS)
2591 return (result);
2592 *obj = val.as_pointer;
2593 return (ISC_R_SUCCESS);
2594 }
2595
2596 cfg_obj_t *
2597 cfg_map_getname(cfg_obj_t *mapobj) {
2598 REQUIRE(mapobj != NULL && mapobj->type->rep == &cfg_rep_map);
2599 return (mapobj->value.map.id);
2600 }
2601
2602
2603 /* Parse an arbitrary token, storing its raw text representation. */
2604 static isc_result_t
2605 parse_token(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2606 cfg_obj_t *obj = NULL;
2607 isc_result_t result;
2608 isc_region_t r;
2609
2610 UNUSED(type);
2611
2612 CHECK(create_cfgobj(pctx, &cfg_type_token, &obj));
2613 CHECK(cfg_gettoken(pctx, QSTRING));
2614 if (pctx->token.type == isc_tokentype_eof) {
2615 cfg_ungettoken(pctx);
2616 result = ISC_R_EOF;
2617 goto cleanup;
2618 }
2619
2620 isc_lex_getlasttokentext(pctx->lexer, &pctx->token, &r);
2621
2622 obj->value.string.base = isc_mem_get(pctx->mctx, r.length + 1);
2623 obj->value.string.length = r.length;
2624 memcpy(obj->value.string.base, r.base, r.length);
2625 obj->value.string.base[r.length] = '\0';
2626 *ret = obj;
2627
2628 cleanup:
2629 return (result);
2630 }
2631
2632 static cfg_type_t cfg_type_token = {
2633 "token", parse_token, print_ustring, &cfg_rep_string, NULL };
2634
2635 /*
2636 * An unsupported option. This is just a list of tokens with balanced braces
2637 * ending in a semicolon.
2638 */
2639
2640 static isc_result_t
2641 parse_unsupported(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2642 cfg_obj_t *listobj = NULL;
2643 isc_result_t result;
2644 int braces = 0;
2645
2646 CHECK(create_list(pctx, type, &listobj));
2647
2648 for (;;) {
2649 cfg_listelt_t *elt = NULL;
2650
2651 CHECK(cfg_peektoken(pctx, 0));
2652 if (pctx->token.type == isc_tokentype_special) {
2653 if (pctx->token.value.as_char == '{')
2654 braces++;
2655 else if (pctx->token.value.as_char == '}')
2656 braces--;
2657 else if (pctx->token.value.as_char == ';')
2658 if (braces == 0)
2659 break;
2660 }
2661 if (pctx->token.type == isc_tokentype_eof || braces < 0) {
2662 parser_error(pctx, LOG_NEAR, "unexpected token");
2663 result = ISC_R_UNEXPECTEDTOKEN;
2664 goto cleanup;
2665 }
2666
2667 CHECK(parse_list_elt(pctx, &cfg_type_token, &elt));
2668 ISC_LIST_APPEND(listobj->value.list, elt, link);
2669 }
2670 INSIST(braces == 0);
2671 *ret = listobj;
2672 return (ISC_R_SUCCESS);
2673
2674 cleanup:
2675 CLEANUP_OBJ(listobj);
2676 return (result);
2677 }
2678
2679 static cfg_type_t cfg_type_unsupported = {
2680 "unsupported", parse_unsupported, print_spacelist,
2681 &cfg_rep_list, NULL
2682 };
2683
2684 /*
2685 * A "controls" statement is represented as a map with the multivalued
2686 * "inet" and "unix" clauses. Inet controls are tuples; unix controls
2687 * are cfg_unsupported_t objects.
2688 */
2689
2690 static keyword_type_t controls_allow_kw = {
2691 "allow", &cfg_type_bracketed_aml };
2692 static cfg_type_t cfg_type_controls_allow = {
2693 "controls_allow", parse_keyvalue,
2694 print_keyvalue, &cfg_rep_list, &controls_allow_kw
2695 };
2696
2697 static keyword_type_t controls_keys_kw = {
2698 "keys", &cfg_type_keylist };
2699 static cfg_type_t cfg_type_controls_keys = {
2700 "controls_keys", parse_optional_keyvalue,
2701 print_keyvalue, &cfg_rep_list, &controls_keys_kw
2702 };
2703
2704 static cfg_tuplefielddef_t inetcontrol_fields[] = {
2705 { "address", &cfg_type_controls_sockaddr, 0 },
2706 { "allow", &cfg_type_controls_allow, 0 },
2707 { "keys", &cfg_type_controls_keys, 0 },
2708 { NULL, NULL, 0 }
2709 };
2710 static cfg_type_t cfg_type_inetcontrol = {
2711 "inetcontrol", parse_tuple, print_tuple, &cfg_rep_tuple,
2712 inetcontrol_fields
2713 };
2714
2715 static cfg_clausedef_t
2716 controls_clauses[] = {
2717 { "inet", &cfg_type_inetcontrol, CFG_CLAUSEFLAG_MULTI },
2718 { "unix", &cfg_type_unsupported,
2719 CFG_CLAUSEFLAG_MULTI|CFG_CLAUSEFLAG_NOTIMP },
2720 { NULL, NULL, 0 }
2721 };
2722 static cfg_clausedef_t *
2723 controls_clausesets[] = {
2724 controls_clauses,
2725 NULL
2726 };
2727 static cfg_type_t cfg_type_controls = {
2728 "controls", parse_map, print_map, &cfg_rep_map, &controls_clausesets
2729 };
2730
2731 /*
2732 * An optional class, as used in view and zone statements.
2733 */
2734 static isc_result_t
2735 parse_optional_class(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2736 isc_result_t result;
2737 UNUSED(type);
2738 CHECK(cfg_peektoken(pctx, 0));
2739 if (pctx->token.type == isc_tokentype_string)
2740 CHECK(parse(pctx, &cfg_type_ustring, ret));
2741 else
2742 CHECK(parse(pctx, &cfg_type_void, ret));
2743 cleanup:
2744 return (result);
2745 }
2746
2747 static cfg_type_t cfg_type_optional_class = {
2748 "optional_class", parse_optional_class, NULL, NULL, NULL };
2749
2750
2751 /*
2752 * Try interpreting the current token as a network address.
2753 *
2754 * If WILDOK is set in flags, "*" can be used as a wildcard
2755 * and at least one of V4OK and V6OK must also be set. The
2756 * "*" is interpreted as the IPv4 wildcard address if V4OK is
2757 * set (including the case where V4OK and V6OK are both set),
2758 * and the IPv6 wildcard address otherwise.
2759 */
2760 static isc_result_t
2761 token_addr(cfg_parser_t *pctx, unsigned int flags, isc_netaddr_t *na) {
2762 char *s;
2763 struct in_addr in4a;
2764 struct in6_addr in6a;
2765
2766 if (pctx->token.type != isc_tokentype_string)
2767 return (ISC_R_UNEXPECTEDTOKEN);
2768
2769 s = pctx->token.value.as_pointer;
2770 if ((flags & WILDOK) != 0 && strcmp(s, "*") == 0) {
2771 if ((flags & V4OK) != 0) {
2772 isc_netaddr_any(na);
2773 return (ISC_R_SUCCESS);
2774 } else if ((flags & V6OK) != 0) {
2775 isc_netaddr_any6(na);
2776 return (ISC_R_SUCCESS);
2777 } else {
2778 INSIST(0);
2779 }
2780 } else {
2781 if ((flags & (V4OK | V4PREFIXOK)) != 0) {
2782 if (inet_pton(AF_INET, s, &in4a) == 1) {
2783 isc_netaddr_fromin(na, &in4a);
2784 return (ISC_R_SUCCESS);
2785 }
2786 }
2787 if ((flags & V4PREFIXOK) != 0 &&
2788 strlen(s) <= 15U) {
2789 char buf[64];
2790 int i;
2791
2792 strcpy(buf, s);
2793 for (i = 0; i < 3; i++) {
2794 strcat(buf, ".0");
2795 if (inet_pton(AF_INET, buf, &in4a) == 1) {
2796 isc_netaddr_fromin(na, &in4a);
2797 return (ISC_R_SUCCESS);
2798 }
2799 }
2800 }
2801 if (flags & V6OK) {
2802 if (inet_pton(AF_INET6, s, &in6a) == 1) {
2803 isc_netaddr_fromin6(na, &in6a);
2804 return (ISC_R_SUCCESS);
2805 }
2806 }
2807 }
2808 return (ISC_R_UNEXPECTEDTOKEN);
2809 }
2810
2811 static isc_result_t
2812 get_addr(cfg_parser_t *pctx, unsigned int flags, isc_netaddr_t *na) {
2813 isc_result_t result;
2814 CHECK(cfg_gettoken(pctx, 0));
2815 result = token_addr(pctx, flags, na);
2816 if (result == ISC_R_UNEXPECTEDTOKEN)
2817 parser_error(pctx, LOG_NEAR, "expected IP address");
2818 cleanup:
2819 return (result);
2820 }
2821
2822 static isc_boolean_t
2823 looking_at_netaddr(cfg_parser_t *pctx, unsigned int flags) {
2824 isc_result_t result;
2825 isc_netaddr_t na_dummy;
2826 result = token_addr(pctx, flags, &na_dummy);
2827 return (ISC_TF(result == ISC_R_SUCCESS));
2828 }
2829
2830 static isc_result_t
2831 get_port(cfg_parser_t *pctx, unsigned int flags, in_port_t *port) {
2832 isc_result_t result;
2833
2834 CHECK(cfg_gettoken(pctx, ISC_LEXOPT_NUMBER));
2835
2836 if ((flags & WILDOK) != 0 &&
2837 pctx->token.type == isc_tokentype_string &&
2838 strcmp(pctx->token.value.as_pointer, "*") == 0) {
2839 *port = 0;
2840 return (ISC_R_SUCCESS);
2841 }
2842 if (pctx->token.type != isc_tokentype_number) {
2843 parser_error(pctx, LOG_NEAR,
2844 "expected port number or '*'");
2845 return (ISC_R_UNEXPECTEDTOKEN);
2846 }
2847 if (pctx->token.value.as_ulong >= 65536U) {
2848 parser_error(pctx, LOG_NEAR,
2849 "port number out of range");
2850 return (ISC_R_UNEXPECTEDTOKEN);
2851 }
2852 *port = (in_port_t)(pctx->token.value.as_ulong);
2853 return (ISC_R_SUCCESS);
2854 cleanup:
2855 return (result);
2856 }
2857
2858 static isc_result_t
2859 parse_querysource(cfg_parser_t *pctx, int flags, cfg_obj_t **ret) {
2860 isc_result_t result;
2861 cfg_obj_t *obj = NULL;
2862 isc_netaddr_t netaddr;
2863 in_port_t port;
2864 unsigned int have_address = 0;
2865 unsigned int have_port = 0;
2866
2867 if ((flags & V4OK) != 0)
2868 isc_netaddr_any(&netaddr);
2869 else if ((flags & V6OK) != 0)
2870 isc_netaddr_any6(&netaddr);
2871 else
2872 INSIST(0);
2873
2874 port = 0;
2875
2876 CHECK(create_cfgobj(pctx, &cfg_type_querysource, &obj));
2877 for (;;) {
2878 CHECK(cfg_peektoken(pctx, 0));
2879 if (pctx->token.type == isc_tokentype_string) {
2880 if (strcasecmp(pctx->token.value.as_pointer,
2881 "address") == 0)
2882 {
2883 /* read "address" */
2884 CHECK(cfg_gettoken(pctx, 0));
2885 CHECK(get_addr(pctx, flags|WILDOK, &netaddr));
2886 have_address++;
2887 } else if (strcasecmp(pctx->token.value.as_pointer,
2888 "port") == 0)
2889 {
2890 /* read "port" */
2891 CHECK(cfg_gettoken(pctx, 0));
2892 CHECK(get_port(pctx, WILDOK, &port));
2893 have_port++;
2894 } else {
2895 parser_error(pctx, LOG_NEAR,
2896 "expected 'address' or 'port'");
2897 return (ISC_R_UNEXPECTEDTOKEN);
2898 }
2899 } else
2900 break;
2901 }
2902 if (have_address > 1 || have_port > 1 ||
2903 have_address + have_port == 0) {
2904 parser_error(pctx, 0, "expected one address and/or port");
2905 return (ISC_R_UNEXPECTEDTOKEN);
2906 }
2907
2908 isc_sockaddr_fromnetaddr(&obj->value.sockaddr, &netaddr, port);
2909 *ret = obj;
2910 return (ISC_R_SUCCESS);
2911
2912 cleanup:
2913 parser_error(pctx, LOG_NEAR, "invalid query source");
2914 CLEANUP_OBJ(obj);
2915 return (result);
2916 }
2917
2918 static isc_result_t
2919 parse_querysource4(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2920 UNUSED(type);
2921 return (parse_querysource(pctx, V4OK, ret));
2922 }
2923
2924 static isc_result_t
2925 parse_querysource6(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2926 UNUSED(type);
2927 return (parse_querysource(pctx, V6OK, ret));
2928 }
2929
2930 static void
2931 print_isc_netaddr(cfg_printer_t *pctx, isc_netaddr_t *na) {
2932 isc_result_t result;
2933 char text[128];
2934 isc_buffer_t buf;
2935
2936 isc_buffer_init(&buf, text, sizeof(text));
2937 result = isc_netaddr_totext(na, &buf);
2938 RUNTIME_CHECK(result == ISC_R_SUCCESS);
2939 print(pctx, isc_buffer_base(&buf), isc_buffer_usedlength(&buf));
2940 }
2941
2942 static void
2943 print_querysource(cfg_printer_t *pctx, cfg_obj_t *obj) {
2944 isc_netaddr_t na;
2945 isc_netaddr_fromsockaddr(&na, &obj->value.sockaddr);
2946 print(pctx, "address ", 8);
2947 print_isc_netaddr(pctx, &na);
2948 print(pctx, " port ", 6);
2949 print_uint(pctx, isc_sockaddr_getport(&obj->value.sockaddr));
2950 }
2951
2952 static cfg_type_t cfg_type_querysource4 = {
2953 "querysource4", parse_querysource4, NULL, NULL, NULL };
2954 static cfg_type_t cfg_type_querysource6 = {
2955 "querysource6", parse_querysource6, NULL, NULL, NULL };
2956 static cfg_type_t cfg_type_querysource = {
2957 "querysource", NULL, print_querysource, &cfg_rep_sockaddr, NULL };
2958
2959 /* netaddr */
2960
2961 static isc_result_t
2962 parse_netaddr(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2963 isc_result_t result;
2964 cfg_obj_t *obj = NULL;
2965 isc_netaddr_t netaddr;
2966 UNUSED(type);
2967 CHECK(create_cfgobj(pctx, type, &obj));
2968 CHECK(get_addr(pctx, V4OK|V6OK, &netaddr));
2969 isc_sockaddr_fromnetaddr(&obj->value.sockaddr, &netaddr, 0);
2970 *ret = obj;
2971 return (ISC_R_SUCCESS);
2972 cleanup:
2973 CLEANUP_OBJ(obj);
2974 return (result);
2975 }
2976
2977 static cfg_type_t cfg_type_netaddr = {
2978 "netaddr", parse_netaddr, print_sockaddr, &cfg_rep_sockaddr, NULL };
2979
2980 /* netprefix */
2981
2982 static isc_result_t
2983 parse_netprefix(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
2984 cfg_obj_t *obj = NULL;
2985 isc_result_t result;
2986 isc_netaddr_t netaddr;
2987 unsigned int addrlen, prefixlen;
2988 UNUSED(type);
2989
2990 CHECK(get_addr(pctx, V4OK|V4PREFIXOK|V6OK, &netaddr));
2991 switch (netaddr.family) {
2992 case AF_INET:
2993 addrlen = 32;
2994 break;
2995 case AF_INET6:
2996 addrlen = 128;
2997 break;
2998 default:
2999 addrlen = 0;
3000 INSIST(0);
3001 break;
3002 }
3003 CHECK(cfg_peektoken(pctx, 0));
3004 if (pctx->token.type == isc_tokentype_special &&
3005 pctx->token.value.as_char == '/') {
3006 CHECK(cfg_gettoken(pctx, 0)); /* read "/" */
3007 CHECK(cfg_gettoken(pctx, ISC_LEXOPT_NUMBER));
3008 if (pctx->token.type != isc_tokentype_number) {
3009 parser_error(pctx, LOG_NEAR,
3010 "expected prefix length");
3011 return (ISC_R_UNEXPECTEDTOKEN);
3012 }
3013 prefixlen = pctx->token.value.as_ulong;
3014 if (prefixlen > addrlen) {
3015 parser_error(pctx, LOG_NOPREP,
3016 "invalid prefix length");
3017 return (ISC_R_RANGE);
3018 }
3019 } else {
3020 prefixlen = addrlen;
3021 }
3022 CHECK(create_cfgobj(pctx, &cfg_type_netprefix, &obj));
3023 obj->value.netprefix.address = netaddr;
3024 obj->value.netprefix.prefixlen = prefixlen;
3025 *ret = obj;
3026 return (ISC_R_SUCCESS);
3027 cleanup:
3028 parser_error(pctx, LOG_NEAR, "expected network prefix");
3029 return (result);
3030 }
3031
3032 static void
3033 print_netprefix(cfg_printer_t *pctx, cfg_obj_t *obj) {
3034 cfg_netprefix_t *p = &obj->value.netprefix;
3035 print_isc_netaddr(pctx, &p->address);
3036 print(pctx, "/", 1);
3037 print_uint(pctx, p->prefixlen);
3038 }
3039
3040 isc_boolean_t
3041 cfg_obj_isnetprefix(cfg_obj_t *obj) {
3042 REQUIRE(obj != NULL);
3043 return (ISC_TF(obj->type->rep == &cfg_rep_netprefix));
3044 }
3045
3046 void
3047 cfg_obj_asnetprefix(cfg_obj_t *obj, isc_netaddr_t *netaddr,
3048 unsigned int *prefixlen) {
3049 REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_netprefix);
3050 *netaddr = obj->value.netprefix.address;
3051 *prefixlen = obj->value.netprefix.prefixlen;
3052 }
3053
3054 static cfg_type_t cfg_type_netprefix = {
3055 "netprefix", parse_netprefix, print_netprefix, &cfg_rep_netprefix, NULL };
3056
3057 /* addrmatchelt */
3058
3059 static isc_result_t
3060 parse_addrmatchelt(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
3061 isc_result_t result;
3062 UNUSED(type);
3063
3064 CHECK(cfg_peektoken(pctx, QSTRING));
3065
3066 if (pctx->token.type == isc_tokentype_string ||
3067 pctx->token.type == isc_tokentype_qstring) {
3068 if (pctx->token.type == isc_tokentype_string &&
3069 (strcasecmp(pctx->token.value.as_pointer, "key") == 0)) {
3070 CHECK(parse(pctx, &cfg_type_keyref, ret));
3071 } else {
3072 if (looking_at_netaddr(pctx, V4OK|V4PREFIXOK|V6OK)) {
3073 CHECK(parse_netprefix(pctx, NULL, ret));
3074 } else {
3075 CHECK(parse_astring(pctx, NULL, ret));
3076 }
3077 }
3078 } else if (pctx->token.type == isc_tokentype_special) {
3079 if (pctx->token.value.as_char == '{') {
3080 /* Nested match list. */
3081 CHECK(parse(pctx, &cfg_type_bracketed_aml, ret));
3082 } else if (pctx->token.value.as_char == '!') {
3083 CHECK(cfg_gettoken(pctx, 0)); /* read "!" */
3084 CHECK(parse(pctx, &cfg_type_negated, ret));
3085 } else {
3086 goto bad;
3087 }
3088 } else {
3089 bad:
3090 parser_error(pctx, LOG_NEAR,
3091 "expected IP match list element");
3092 return (ISC_R_UNEXPECTEDTOKEN);
3093 }
3094 cleanup:
3095 return (result);
3096 }
3097
3098 /*
3099 * A negated address match list element (like "! 10.0.0.1").
3100 * Somewhat sneakily, the caller is expected to parse the
3101 * "!", but not to print it.
3102 */
3103
3104 static cfg_tuplefielddef_t negated_fields[] = {
3105 { "value", &cfg_type_addrmatchelt, 0 },
3106 { NULL, NULL, 0 }
3107 };
3108
3109 static void
3110 print_negated(cfg_printer_t *pctx, cfg_obj_t *obj) {
3111 print(pctx, "!", 1);
3112 print_tuple(pctx, obj);
3113 }
3114
3115 static cfg_type_t cfg_type_negated = {
3116 "negated", parse_tuple, print_negated, &cfg_rep_tuple,
3117 &negated_fields
3118 };
3119
3120 /* an address match list element */
3121
3122 static cfg_type_t cfg_type_addrmatchelt = {
3123 "address_match_element", parse_addrmatchelt, NULL, NULL, NULL };
3124 static cfg_type_t cfg_type_bracketed_aml = {
3125 "bracketed_aml", parse_bracketed_list, print_bracketed_list,
3126 &cfg_rep_list, &cfg_type_addrmatchelt
3127 };
3128
3129 static isc_result_t
3130 parse_sockaddrsub(cfg_parser_t *pctx, const cfg_type_t *type,
3131 int flags, cfg_obj_t **ret)
3132 {
3133 isc_result_t result;
3134 isc_netaddr_t netaddr;
3135 in_port_t port = 0;
3136 cfg_obj_t *obj = NULL;
3137
3138 CHECK(create_cfgobj(pctx, type, &obj));
3139 CHECK(get_addr(pctx, flags, &netaddr));
3140 CHECK(cfg_peektoken(pctx, 0));
3141 if (pctx->token.type == isc_tokentype_string &&
3142 strcasecmp(pctx->token.value.as_pointer, "port") == 0) {
3143 CHECK(cfg_gettoken(pctx, 0)); /* read "port" */
3144 CHECK(get_port(pctx, flags, &port));
3145 }
3146 isc_sockaddr_fromnetaddr(&obj->value.sockaddr, &netaddr, port);
3147 *ret = obj;
3148 return (ISC_R_SUCCESS);
3149
3150 cleanup:
3151 CLEANUP_OBJ(obj);
3152 return (result);
3153 }
3154
3155 static isc_result_t
3156 parse_sockaddr(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
3157 const unsigned int *flagp = type->of;
3158 return (parse_sockaddrsub(pctx, &cfg_type_sockaddr4wild, *flagp, ret));
3159 }
3160
3161 static void
3162 print_sockaddr(cfg_printer_t *pctx, cfg_obj_t *obj) {
3163 isc_netaddr_t netaddr;
3164 in_port_t port;
3165 char buf[ISC_NETADDR_FORMATSIZE];
3166
3167 isc_netaddr_fromsockaddr(&netaddr, &obj->value.sockaddr);
3168 isc_netaddr_format(&netaddr, buf, sizeof(buf));
3169 print_cstr(pctx, buf);
3170 port = isc_sockaddr_getport(&obj->value.sockaddr);
3171 if (port != 0) {
3172 print(pctx, " port ", 6);
3173 print_uint(pctx, port);
3174 }
3175 }
3176
3177 isc_boolean_t
3178 cfg_obj_issockaddr(cfg_obj_t *obj) {
3179 REQUIRE(obj != NULL);
3180 return (ISC_TF(obj->type->rep == &cfg_rep_sockaddr));
3181 }
3182
3183 isc_sockaddr_t *
3184 cfg_obj_assockaddr(cfg_obj_t *obj) {
3185 REQUIRE(obj != NULL && obj->type->rep == &cfg_rep_sockaddr);
3186 return (&obj->value.sockaddr);
3187 }
3188
3189 /* An IPv4/IPv6 address with optional port, "*" accepted as wildcard. */
3190 static unsigned int sockaddr4wild_flags = WILDOK|V4OK;
3191 static cfg_type_t cfg_type_sockaddr4wild = {
3192 "sockaddr4wild", parse_sockaddr, print_sockaddr,
3193 &cfg_rep_sockaddr, &sockaddr4wild_flags
3194 };
3195
3196 static unsigned int sockaddr6wild_flags = WILDOK|V6OK;
3197 static cfg_type_t cfg_type_sockaddr6wild = {
3198 "v6addrportwild", parse_sockaddr, print_sockaddr,
3199 &cfg_rep_sockaddr, &sockaddr6wild_flags
3200 };
3201
3202 static unsigned int sockaddr_flags = V4OK|V6OK;
3203 static cfg_type_t cfg_type_sockaddr = {
3204 "sockaddr", parse_sockaddr, print_sockaddr,
3205 &cfg_rep_sockaddr, &sockaddr_flags
3206 };
3207
3208 /*
3209 * The socket address syntax in the "controls" statement is silly.
3210 * It allows both socket address families, but also allows "*",
3211 * whis is gratuitously interpreted as the IPv4 wildcard address.
3212 */
3213 static unsigned int controls_sockaddr_flags = V4OK|V6OK|WILDOK;
3214 static cfg_type_t cfg_type_controls_sockaddr = {
3215 "controls_sockaddr", parse_sockaddr, print_sockaddr,
3216 &cfg_rep_sockaddr, &controls_sockaddr_flags };
3217
3218
3219 /*
3220 * Handle the special kludge syntax of the "keys" clause in the "server"
3221 * statement, which takes a single key with our without braces and semicolon.
3222 */
3223 static isc_result_t
3224 parse_server_key_kludge(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
3225 {
3226 isc_result_t result;
3227 isc_boolean_t braces = ISC_FALSE;
3228 UNUSED(type);
3229
3230 /* Allow opening brace. */
3231 CHECK(cfg_peektoken(pctx, 0));
3232 if (pctx->token.type == isc_tokentype_special &&
3233 pctx->token.value.as_char == '{') {
3234 result = cfg_gettoken(pctx, 0);
3235 braces = ISC_TRUE;
3236 }
3237
3238 CHECK(parse(pctx, &cfg_type_astring, ret));
3239
3240 if (braces) {
3241 /* Skip semicolon if present. */
3242 CHECK(cfg_peektoken(pctx, 0));
3243 if (pctx->token.type == isc_tokentype_special &&
3244 pctx->token.value.as_char == ';')
3245 CHECK(cfg_gettoken(pctx, 0));
3246
3247 CHECK(parse_special(pctx, '}'));
3248 }
3249 cleanup:
3250 return (result);
3251 }
3252 static cfg_type_t cfg_type_server_key_kludge = {
3253 "server_key", parse_server_key_kludge, NULL, NULL, NULL };
3254
3255
3256 /*
3257 * An optional logging facility.
3258 */
3259
3260 static isc_result_t
3261 parse_optional_facility(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret)
3262 {
3263 isc_result_t result;
3264 UNUSED(type);
3265
3266 CHECK(cfg_peektoken(pctx, QSTRING));
3267 if (pctx->token.type == isc_tokentype_string ||
3268 pctx->token.type == isc_tokentype_qstring) {
3269 CHECK(parse(pctx, &cfg_type_astring, ret));
3270 } else {
3271 CHECK(parse(pctx, &cfg_type_void, ret));
3272 }
3273 cleanup:
3274 return (result);
3275 }
3276
3277 static cfg_type_t cfg_type_optional_facility = {
3278 "optional_facility", parse_optional_facility, NULL, NULL, NULL };
3279
3280
3281 /*
3282 * A log severity. Return as a string, except "debug N",
3283 * which is returned as a keyword object.
3284 */
3285
3286 static keyword_type_t debug_kw = { "debug", &cfg_type_uint32 };
3287 static cfg_type_t cfg_type_debuglevel = {
3288 "debuglevel", parse_keyvalue,
3289 print_keyvalue, &cfg_rep_uint32, &debug_kw
3290 };
3291
3292 static isc_result_t
3293 parse_logseverity(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
3294 isc_result_t result;
3295 UNUSED(type);
3296
3297 CHECK(cfg_peektoken(pctx, 0));
3298 if (pctx->token.type == isc_tokentype_string &&
3299 strcasecmp(pctx->token.value.as_pointer, "debug") == 0) {
3300 CHECK(cfg_gettoken(pctx, 0)); /* read "debug" */
3301 CHECK(cfg_peektoken(pctx, ISC_LEXOPT_NUMBER));
3302 if (pctx->token.type == isc_tokentype_number) {
3303 CHECK(parse_uint32(pctx, NULL, ret));
3304 } else {
3305 /*
3306 * The debug level is optional and defaults to 1.
3307 * This makes little sense, but we support it for
3308 * compatibility with BIND 8.
3309 */
3310 CHECK(create_cfgobj(pctx, &cfg_type_uint32, ret));
3311 (*ret)->value.uint32 = 1;
3312 }
3313 (*ret)->type = &cfg_type_debuglevel; /* XXX kludge */
3314 } else {
3315 CHECK(parse(pctx, &cfg_type_loglevel, ret));
3316 }
3317 cleanup:
3318 return (result);
3319 }
3320
3321 static cfg_type_t cfg_type_logseverity = {
3322 "logseverity", parse_logseverity, NULL, NULL, NULL };
3323
3324 /*
3325 * The "file" clause of the "channel" statement.
3326 * This is yet another special case.
3327 */
3328
3329 static const char *logversions_enums[] = { "unlimited", NULL };
3330 static isc_result_t
3331 parse_logversions(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
3332 return (parse_enum_or_other(pctx, type, &cfg_type_uint32, ret));
3333 }
3334 static cfg_type_t cfg_type_logversions = {
3335 "logversions", parse_logversions, print_ustring,
3336 &cfg_rep_string, logversions_enums
3337 };
3338
3339 static cfg_tuplefielddef_t logfile_fields[] = {
3340 { "file", &cfg_type_qstring, 0 },
3341 { "versions", &cfg_type_logversions, 0 },
3342 { "size", &cfg_type_size, 0 },
3343 { NULL, NULL, 0 }
3344 };
3345
3346 static isc_result_t
3347 parse_logfile(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
3348 isc_result_t result;
3349 cfg_obj_t *obj = NULL;
3350 const cfg_tuplefielddef_t *fields = type->of;
3351
3352 CHECK(create_tuple(pctx, type, &obj));
3353
3354 /* Parse the mandatory "file" field */
3355 CHECK(parse(pctx, fields[0].type, &obj->value.tuple[0]));
3356
3357 /* Parse "versions" and "size" fields in any order. */
3358 for (;;) {
3359 CHECK(cfg_peektoken(pctx, 0));
3360 if (pctx->token.type == isc_tokentype_string) {
3361 CHECK(cfg_gettoken(pctx, 0));
3362 if (strcasecmp(pctx->token.value.as_pointer,
3363 "versions") == 0 &&
3364 obj->value.tuple[1] == NULL) {
3365 CHECK(parse(pctx, fields[1].type,
3366 &obj->value.tuple[1]));
3367 } else if (strcasecmp(pctx->token.value.as_pointer,
3368 "size") == 0 &&
3369 obj->value.tuple[2] == NULL) {
3370 CHECK(parse(pctx, fields[2].type,
3371 &obj->value.tuple[2]));
3372 } else {
3373 break;
3374 }
3375 } else {
3376 break;
3377 }
3378 }
3379
3380 /* Create void objects for missing optional values. */
3381 if (obj->value.tuple[1] == NULL)
3382 CHECK(parse_void(pctx, NULL, &obj->value.tuple[1]));
3383 if (obj->value.tuple[2] == NULL)
3384 CHECK(parse_void(pctx, NULL, &obj->value.tuple[2]));
3385
3386 *ret = obj;
3387 return (ISC_R_SUCCESS);
3388
3389 cleanup:
3390 CLEANUP_OBJ(obj);
3391 return (result);
3392 }
3393
3394 static void
3395 print_logfile(cfg_printer_t *pctx, cfg_obj_t *obj) {
3396 print_obj(pctx, obj->value.tuple[0]); /* file */
3397 if (obj->value.tuple[1]->type->print != print_void) {
3398 print(pctx, " versions ", 10);
3399 print_obj(pctx, obj->value.tuple[1]);
3400 }
3401 if (obj->value.tuple[2]->type->print != print_void) {
3402 print(pctx, " size ", 6);
3403 print_obj(pctx, obj->value.tuple[2]);
3404 }
3405 }
3406
3407 static cfg_type_t cfg_type_logfile = {
3408 "logfile", parse_logfile, print_logfile, &cfg_rep_tuple,
3409 logfile_fields
3410 };
3411
3412
3413 /*
3414 * lwres
3415 */
3416
3417 static cfg_tuplefielddef_t lwres_view_fields[] = {
3418 { "name", &cfg_type_astring, 0 },
3419 { "class", &cfg_type_optional_class, 0 },
3420 { NULL, NULL, 0 }
3421 };
3422 static cfg_type_t cfg_type_lwres_view = {
3423 "lwres_view", parse_tuple, print_tuple, &cfg_rep_tuple,
3424 lwres_view_fields
3425 };
3426
3427 static cfg_type_t cfg_type_lwres_searchlist = {
3428 "lwres_searchlist", parse_bracketed_list, print_bracketed_list,
3429 &cfg_rep_list, &cfg_type_astring };
3430
3431 static cfg_clausedef_t
3432 lwres_clauses[] = {
3433 { "listen-on", &cfg_type_portiplist, 0 },
3434 { "view", &cfg_type_lwres_view, 0 },
3435 { "search", &cfg_type_lwres_searchlist, 0 },
3436 { "ndots", &cfg_type_uint32, 0 },
3437 { NULL, NULL, 0 }
3438 };
3439
3440 static cfg_clausedef_t *
3441 lwres_clausesets[] = {
3442 lwres_clauses,
3443 NULL
3444 };
3445 static cfg_type_t cfg_type_lwres = {
3446 "lwres", parse_map, print_map, &cfg_rep_map, lwres_clausesets };
3447
3448 /*
3449 * rndc
3450 */
3451
3452 static cfg_clausedef_t
3453 rndcconf_options_clauses[] = {
3454 { "default-server", &cfg_type_astring, 0 },
3455 { "default-key", &cfg_type_astring, 0 },
3456 { "default-port", &cfg_type_uint32, 0 },
3457 { NULL, NULL, 0 }
3458 };
3459
3460 static cfg_clausedef_t *
3461 rndcconf_options_clausesets[] = {
3462 rndcconf_options_clauses,
3463 NULL
3464 };
3465
3466 static cfg_type_t cfg_type_rndcconf_options = {
3467 "rndcconf_options", parse_map, print_map, &cfg_rep_map,
3468 rndcconf_options_clausesets
3469 };
3470
3471 static cfg_clausedef_t
3472 rndcconf_server_clauses[] = {
3473 { "key", &cfg_type_astring, 0 },
3474 { "port", &cfg_type_uint32, 0 },
3475 { NULL, NULL, 0 }
3476 };
3477
3478 static cfg_clausedef_t *
3479 rndcconf_server_clausesets[] = {
3480 rndcconf_server_clauses,
3481 NULL
3482 };
3483
3484 static cfg_type_t cfg_type_rndcconf_server = {
3485 "rndcconf_server", parse_named_map, print_map, &cfg_rep_map,
3486 rndcconf_server_clausesets
3487 };
3488
3489 static cfg_clausedef_t
3490 rndcconf_clauses[] = {
3491 { "key", &cfg_type_key, CFG_CLAUSEFLAG_MULTI },
3492 { "server", &cfg_type_rndcconf_server, CFG_CLAUSEFLAG_MULTI },
3493 { "options", &cfg_type_rndcconf_options, 0 },
3494 { NULL, NULL, 0 }
3495 };
3496
3497 static cfg_clausedef_t *
3498 rndcconf_clausesets[] = {
3499 rndcconf_clauses,
3500 NULL
3501 };
3502
3503 LIBISCCFG_EXTERNAL_DATA cfg_type_t cfg_type_rndcconf = {
3504 "rndcconf", parse_mapbody, print_mapbody, &cfg_rep_map,
3505 rndcconf_clausesets
3506 };
3507
3508 static cfg_clausedef_t
3509 rndckey_clauses[] = {
3510 { "key", &cfg_type_key, 0 },
3511 { NULL, NULL, 0 }
3512 };
3513
3514 static cfg_clausedef_t *
3515 rndckey_clausesets[] = {
3516 rndckey_clauses,
3517 NULL
3518 };
3519
3520 LIBISCCFG_EXTERNAL_DATA cfg_type_t cfg_type_rndckey = {
3521 "rndckey", parse_mapbody, print_mapbody, &cfg_rep_map,
3522 rndckey_clausesets
3523 };
3524
3525
3526 static isc_result_t
3527 cfg_gettoken(cfg_parser_t *pctx, int options) {
3528 isc_result_t result;
3529
3530 if (pctx->seen_eof)
3531 return (ISC_R_SUCCESS);
3532
3533 options |= (ISC_LEXOPT_EOF | ISC_LEXOPT_NOMORE);
3534
3535 redo:
3536 pctx->token.type = isc_tokentype_unknown;
3537 result = isc_lex_gettoken(pctx->lexer, options, &pctx->token);
3538 pctx->ungotten = ISC_FALSE;
3539 pctx->line = isc_lex_getsourceline(pctx->lexer);
3540
3541 switch (result) {
3542 case ISC_R_SUCCESS:
3543 if (pctx->token.type == isc_tokentype_eof) {
3544 result = isc_lex_close(pctx->lexer);
3545 INSIST(result == ISC_R_NOMORE ||
3546 result == ISC_R_SUCCESS);
3547
3548 if (isc_lex_getsourcename(pctx->lexer) != NULL) {
3549 /*
3550 * Closed an included file, not the main file.
3551 */
3552 cfg_listelt_t *elt;
3553 elt = ISC_LIST_TAIL(pctx->open_files->
3554 value.list);
3555 INSIST(elt != NULL);
3556 ISC_LIST_UNLINK(pctx->open_files->
3557 value.list, elt, link);
3558 ISC_LIST_APPEND(pctx->closed_files->
3559 value.list, elt, link);
3560 goto redo;
3561 }
3562 pctx->seen_eof = ISC_TRUE;
3563 }
3564 break;
3565
3566 case ISC_R_NOSPACE:
3567 /* More understandable than "ran out of space". */
3568 parser_error(pctx, LOG_NEAR, "token too big");
3569 break;
3570
3571 case ISC_R_IOERROR:
3572 parser_error(pctx, 0, "%s",
3573 isc_result_totext(result));
3574 break;
3575
3576 default:
3577 parser_error(pctx, LOG_NEAR, "%s",
3578 isc_result_totext(result));
3579 break;
3580 }
3581 return (result);
3582 }
3583
3584 static void
3585 cfg_ungettoken(cfg_parser_t *pctx) {
3586 if (pctx->seen_eof)
3587 return;
3588 isc_lex_ungettoken(pctx->lexer, &pctx->token);
3589 pctx->ungotten = ISC_TRUE;
3590 }
3591
3592 static isc_result_t
3593 cfg_peektoken(cfg_parser_t *pctx, int options) {
3594 isc_result_t result;
3595 CHECK(cfg_gettoken(pctx, options));
3596 cfg_ungettoken(pctx);
3597 cleanup:
3598 return (result);
3599 }
3600
3601 /*
3602 * Get a string token, accepting both the quoted and the unquoted form.
3603 * Log an error if the next token is not a string.
3604 */
3605 static isc_result_t
3606 cfg_getstringtoken(cfg_parser_t *pctx) {
3607 isc_result_t result;
3608
3609 result = cfg_gettoken(pctx, QSTRING);
3610 if (result != ISC_R_SUCCESS)
3611 return (result);
3612
3613 if (pctx->token.type != isc_tokentype_string &&
3614 pctx->token.type != isc_tokentype_qstring) {
3615 parser_error(pctx, LOG_NEAR, "expected string");
3616 return (ISC_R_UNEXPECTEDTOKEN);
3617 }
3618 return (ISC_R_SUCCESS);
3619 }
3620
3621 static void
3622 parser_error(cfg_parser_t *pctx, unsigned int flags, const char *fmt, ...) {
3623 va_list args;
3624 va_start(args, fmt);
3625 parser_complain(pctx, ISC_FALSE, flags, fmt, args);
3626 va_end(args);
3627 pctx->errors++;
3628 }
3629
3630 static void
3631 parser_warning(cfg_parser_t *pctx, unsigned int flags, const char *fmt, ...) {
3632 va_list args;
3633 va_start(args, fmt);
3634 parser_complain(pctx, ISC_TRUE, flags, fmt, args);
3635 va_end(args);
3636 pctx->warnings++;
3637 }
3638
3639 #define MAX_LOG_TOKEN 30 /* How much of a token to quote in log messages. */
3640
3641 static char *
3642 current_file(cfg_parser_t *pctx) {
3643 static char none[] = "none";
3644 cfg_listelt_t *elt;
3645 cfg_obj_t *fileobj;
3646
3647 if (pctx->open_files == NULL)
3648 return (none);
3649 elt = ISC_LIST_TAIL(pctx->open_files->value.list);
3650 if (elt == NULL)
3651 return (none);
3652
3653 fileobj = elt->obj;
3654 INSIST(fileobj->type == &cfg_type_qstring);
3655 return (fileobj->value.string.base);
3656 }
3657
3658 static void
3659 parser_complain(cfg_parser_t *pctx, isc_boolean_t is_warning,
3660 unsigned int flags, const char *format,
3661 va_list args)
3662 {
3663 char tokenbuf[MAX_LOG_TOKEN + 10];
3664 static char where[ISC_DIR_PATHMAX + 100];
3665 static char message[2048];
3666 int level = ISC_LOG_ERROR;
3667 const char *prep = "";
3668
3669 if (is_warning)
3670 level = ISC_LOG_WARNING;
3671
3672 sprintf(where, "%s:%u: ", current_file(pctx), pctx->line);
3673
3674 if ((unsigned int)vsprintf(message, format, args) >= sizeof message)
3675 FATAL_ERROR(__FILE__, __LINE__,
3676 "error message would overflow");
3677
3678 if ((flags & (LOG_NEAR|LOG_BEFORE|LOG_NOPREP)) != 0) {
3679 isc_region_t r;
3680
3681 if (pctx->ungotten)
3682 (void)cfg_gettoken(pctx, 0);
3683
3684 if (pctx->token.type == isc_tokentype_eof) {
3685 snprintf(tokenbuf, sizeof(tokenbuf), "end of file");
3686 } else if (pctx->token.type == isc_tokentype_unknown) {
3687 flags = 0;
3688 tokenbuf[0] = '\0';
3689 } else {
3690 isc_lex_getlasttokentext(pctx->lexer,
3691 &pctx->token, &r);
3692 if (r.length > MAX_LOG_TOKEN)
3693 snprintf(tokenbuf, sizeof(tokenbuf),
3694 "'%.*s...'", MAX_LOG_TOKEN, r.base);
3695 else
3696 snprintf(tokenbuf, sizeof(tokenbuf),
3697 "'%.*s'", (int)r.length, r.base);
3698 }
3699
3700 /* Choose a preposition. */
3701 if (flags & LOG_NEAR)
3702 prep = " near ";
3703 else if (flags & LOG_BEFORE)
3704 prep = " before ";
3705 else
3706 prep = " ";
3707 } else {
3708 tokenbuf[0] = '\0';
3709 }
3710 isc_log_write(pctx->lctx, CAT, MOD, level,
3711 "%s%s%s%s", where, message, prep, tokenbuf);
3712 }
3713
3714 void
3715 cfg_obj_log(cfg_obj_t *obj, isc_log_t *lctx, int level, const char *fmt, ...) {
3716 va_list ap;
3717 char msgbuf[2048];
3718
3719 if (! isc_log_wouldlog(lctx, level))
3720 return;
3721
3722 va_start(ap, fmt);
3723
3724 vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
3725 isc_log_write(lctx, CAT, MOD, level,
3726 "%s:%u: %s",
3727 obj->file == NULL ? "<unknown file>" : obj->file,
3728 obj->line, msgbuf);
3729 va_end(ap);
3730 }
3731
3732 static isc_result_t
3733 create_cfgobj(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
3734 cfg_obj_t *obj;
3735
3736 obj = isc_mem_get(pctx->mctx, sizeof(cfg_obj_t));
3737 if (obj == NULL)
3738 return (ISC_R_NOMEMORY);
3739 obj->type = type;
3740 obj->file = current_file(pctx);
3741 obj->line = pctx->line;
3742 *ret = obj;
3743 return (ISC_R_SUCCESS);
3744 }
3745
3746 static void
3747 map_symtabitem_destroy(char *key, unsigned int type,
3748 isc_symvalue_t symval, void *userarg)
3749 {
3750 cfg_obj_t *obj = symval.as_pointer;
3751 cfg_parser_t *pctx = (cfg_parser_t *)userarg;
3752
3753 UNUSED(key);
3754 UNUSED(type);
3755
3756 cfg_obj_destroy(pctx, &obj);
3757 }
3758
3759
3760 static isc_result_t
3761 create_map(cfg_parser_t *pctx, const cfg_type_t *type, cfg_obj_t **ret) {
3762 isc_result_t result;
3763 isc_symtab_t *symtab = NULL;
3764 cfg_obj_t *obj = NULL;
3765
3766 CHECK(create_cfgobj(pctx, type, &obj));
3767 CHECK(isc_symtab_create(pctx->mctx, 5, /* XXX */
3768 map_symtabitem_destroy,
3769 pctx, ISC_FALSE, &symtab));
3770
3771 obj->value.map.symtab = symtab;
3772 obj->value.map.id = NULL;
3773
3774 *ret = obj;
3775 return (ISC_R_SUCCESS);
3776
3777 cleanup:
3778 if (obj != NULL)
3779 isc_mem_put(pctx->mctx, obj, sizeof(*obj));
3780 return (result);
3781 }
3782
3783 static void
3784 free_map(cfg_parser_t *pctx, cfg_obj_t *obj) {
3785 CLEANUP_OBJ(obj->value.map.id);
3786 isc_symtab_destroy(&obj->value.map.symtab);
3787 }
3788
3789 isc_boolean_t
3790 cfg_obj_istype(cfg_obj_t *obj, const cfg_type_t *type) {
3791 return (ISC_TF(obj->type == type));
3792 }
3793
3794 /*
3795 * Destroy 'obj', a configuration object created in 'pctx'.
3796 */
3797 void
3798 cfg_obj_destroy(cfg_parser_t *pctx, cfg_obj_t **objp) {
3799 cfg_obj_t *obj = *objp;
3800 obj->type->rep->free(pctx, obj);
3801 isc_mem_put(pctx->mctx, obj, sizeof(cfg_obj_t));
3802 *objp = NULL;
3803 }
3804
3805 static void
3806 free_noop(cfg_parser_t *pctx, cfg_obj_t *obj) {
3807 UNUSED(pctx);
3808 UNUSED(obj);
3809 }
3810
3811 /*
3812 * Data and functions for printing grammar summaries.
3813 */
3814 static struct flagtext {
3815 unsigned int flag;
3816 const char *text;
3817 } flagtexts[] = {
3818 { CFG_CLAUSEFLAG_NOTIMP, "not implemented" },
3819 { CFG_CLAUSEFLAG_NYI, "not yet implemented" },
3820 { CFG_CLAUSEFLAG_OBSOLETE, "obsolete" },
3821 { CFG_CLAUSEFLAG_NEWDEFAULT, "default changed" },
3822 { 0, NULL }
3823 };
3824
3825 static void
3826 print_clause_flags(cfg_printer_t *pctx, unsigned int flags) {
3827 struct flagtext *p;
3828 isc_boolean_t first = ISC_TRUE;
3829 for (p = flagtexts; p->flag != 0; p++) {
3830 if ((flags & p->flag) != 0) {
3831 if (first)
3832 print(pctx, " // ", 4);
3833 else
3834 print(pctx, ", ", 2);
3835 print_cstr(pctx, p->text);
3836 first = ISC_FALSE;
3837 }
3838 }
3839 }
3840
3841 static void
3842 print_grammar(cfg_printer_t *pctx, const cfg_type_t *type) {
3843 if (type->print == print_mapbody) {
3844 const cfg_clausedef_t * const *clauseset;
3845 const cfg_clausedef_t *clause;
3846
3847 for (clauseset = type->of; *clauseset != NULL; clauseset++) {
3848 for (clause = *clauseset;
3849 clause->name != NULL;
3850 clause++) {
3851 print_cstr(pctx, clause->name);
3852 print(pctx, " ", 1);
3853 print_grammar(pctx, clause->type);
3854 print(pctx, ";", 1);
3855 /* XXX print flags here? */
3856 print(pctx, "\n\n", 2);
3857 }
3858 }
3859 } else if (type->print == print_map) {
3860 const cfg_clausedef_t * const *clauseset;
3861 const cfg_clausedef_t *clause;
3862
3863 if (type->parse == parse_named_map) {
3864 print_grammar(pctx, &cfg_type_astring);
3865 print(pctx, " ", 1);
3866 } else if (type->parse == parse_addressed_map) {
3867 print_grammar(pctx, &cfg_type_netaddr);
3868 print(pctx, " ", 1);
3869 }
3870
3871 print_open(pctx);
3872
3873 for (clauseset = type->of; *clauseset != NULL; clauseset++) {
3874 for (clause = *clauseset;
3875 clause->name != NULL;
3876 clause++) {
3877 print_indent(pctx);
3878 print_cstr(pctx, clause->name);
3879 if (clause->type->print != print_void)
3880 print(pctx, " ", 1);
3881 print_grammar(pctx, clause->type);
3882 print(pctx, ";", 1);
3883 print_clause_flags(pctx, clause->flags);
3884 print(pctx, "\n", 1);
3885 }
3886 }
3887 print_close(pctx);
3888 } else if (type->print == print_tuple) {
3889 const cfg_tuplefielddef_t *fields = type->of;
3890 const cfg_tuplefielddef_t *f;
3891 isc_boolean_t need_space = ISC_FALSE;
3892
3893 for (f = fields; f->name != NULL; f++) {
3894 if (need_space)
3895 print(pctx, " ", 1);
3896 print_grammar(pctx, f->type);
3897 need_space = ISC_TF(f->type->print != print_void);
3898 }
3899 } else if (type->parse == parse_enum) {
3900 const char * const *p;
3901 print(pctx, "( ", 2);
3902 for (p = type->of; *p != NULL; p++) {
3903 print_cstr(pctx, *p);
3904 if (p[1] != NULL)
3905 print(pctx, " | ", 3);
3906 }
3907 print(pctx, " )", 2);
3908 } else if (type->print == print_bracketed_list) {
3909 print(pctx, "{ ", 2);
3910 print_grammar(pctx, type->of);
3911 print(pctx, "; ... }", 7);
3912 } else if (type->parse == parse_keyvalue) {
3913 const keyword_type_t *kw = type->of;
3914 print_cstr(pctx, kw->name);
3915 print(pctx, " ", 1);
3916 print_grammar(pctx, kw->type);
3917 } else if (type->parse == parse_optional_keyvalue) {
3918 const keyword_type_t *kw = type->of;
3919 print(pctx, "[ ", 2);
3920 print_cstr(pctx, kw->name);
3921 print(pctx, " ", 1);
3922 print_grammar(pctx, kw->type);
3923 print(pctx, " ]", 2);
3924 } else if (type->parse == parse_sockaddr) {
3925 const unsigned int *flagp = type->of;
3926 int n = 0;
3927 print(pctx, "( ", 2);
3928 if (*flagp & V4OK) {
3929 if (n != 0)
3930 print(pctx, " | ", 3);
3931 print_cstr(pctx, "<ipv4_address>");
3932 n++;
3933 }
3934 if (*flagp & V6OK) {
3935 if (n != 0)
3936 print(pctx, " | ", 3);
3937 print_cstr(pctx, "<ipv6_address>");
3938 n++;
3939 }
3940 if (*flagp & WILDOK) {
3941 if (n != 0)
3942 print(pctx, " | ", 3);
3943 print(pctx, "*", 1);
3944 n++;
3945 }
3946 print(pctx, " ) ", 3);
3947 if (*flagp & WILDOK) {
3948 print_cstr(pctx, "[ port ( <integer> | * ) ]");
3949 } else {
3950 print_cstr(pctx, "[ port <integer> ]");
3951 }
3952 } else if (type->print == print_void) {
3953 /* Print nothing. */
3954 } else {
3955 print(pctx, "<", 1);
3956 print_cstr(pctx, type->name);
3957 print(pctx, ">", 1);
3958 }
3959 }
3960
3961 void
3962 cfg_print_grammar(const cfg_type_t *type,
3963 void (*f)(void *closure, const char *text, int textlen),
3964 void *closure)
3965 {
3966 cfg_printer_t pctx;
3967 pctx.f = f;
3968 pctx.closure = closure;
3969 pctx.indent = 0;
3970 print_grammar(&pctx, type);
3971 }
DragonFly BSD