1 /*
2 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
3 *
4 * SPDX-License-Identifier: MPL-2.0
5 *
6 * This Source Code Form is subject to the terms of the Mozilla Public
7 * License, v. 2.0. If a copy of the MPL was not distributed with this
8 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
9 *
10 * See the COPYRIGHT file distributed with this work for additional
11 * information regarding copyright ownership.
12 */
13
14 /*! \file */
15
16 #include <inttypes.h>
17 #include <stdbool.h>
18
19 #include <isc/atomic.h>
20 #include <isc/event.h>
21 #include <isc/lex.h>
22 #include <isc/magic.h>
23 #include <isc/mem.h>
24 #include <isc/print.h>
25 #include <isc/refcount.h>
26 #include <isc/serial.h>
27 #include <isc/stdio.h>
28 #include <isc/stdtime.h>
29 #include <isc/string.h>
30 #include <isc/task.h>
31 #include <isc/util.h>
32
33 #include <dns/callbacks.h>
34 #include <dns/events.h>
35 #include <dns/fixedname.h>
36 #include <dns/master.h>
37 #include <dns/name.h>
38 #include <dns/rdata.h>
39 #include <dns/rdataclass.h>
40 #include <dns/rdatalist.h>
41 #include <dns/rdataset.h>
42 #include <dns/rdatastruct.h>
43 #include <dns/rdatatype.h>
44 #include <dns/result.h>
45 #include <dns/soa.h>
46 #include <dns/time.h>
47 #include <dns/ttl.h>
48
49 /*!
50 * Grow the number of dns_rdatalist_t (#RDLSZ) and dns_rdata_t (#RDSZ)
51 * structures by these sizes when we need to.
52 *
53 */
54 /*% RDLSZ reflects the number of different types with the same name expected. */
55 #define RDLSZ 32
56 /*%
57 * RDSZ reflects the number of rdata expected at a give name that can fit into
58 * 64k.
59 */
60 #define RDSZ 512
61
62 #define NBUFS 4
63 #define MAXWIRESZ 255
64
65 /*%
66 * Target buffer size and minimum target size.
67 * MINTSIZ must be big enough to hold the largest rdata record.
68 * \brief
69 * TSIZ >= MINTSIZ
70 */
71 #define TSIZ (128 * 1024)
72 /*%
73 * max message size - header - root - type - class - ttl - rdlen
74 */
75 #define MINTSIZ DNS_RDATA_MAXLENGTH
76 /*%
77 * Size for tokens in the presentation format,
78 * The largest tokens are the base64 blocks in KEY and CERT records,
79 * Largest key allowed is about 1372 bytes but
80 * there is no fixed upper bound on CERT records.
81 * 2K is too small for some X.509s, 8K is overkill.
82 */
83 #define TOKENSIZ (8 * 1024)
84
85 /*%
86 * Buffers sizes for $GENERATE.
87 */
88 #define DNS_MASTER_LHS 2048
89 #define DNS_MASTER_RHS MINTSIZ
90
91 #define CHECKNAMESFAIL(x) (((x)&DNS_MASTER_CHECKNAMESFAIL) != 0)
92
93 typedef ISC_LIST(dns_rdatalist_t) rdatalist_head_t;
94
95 typedef struct dns_incctx dns_incctx_t;
96
97 /*%
98 * Master file load state.
99 */
100
101 struct dns_loadctx {
102 unsigned int magic;
103 isc_mem_t *mctx;
104 dns_masterformat_t format;
105
106 dns_rdatacallbacks_t *callbacks;
107 isc_task_t *task;
108 dns_loaddonefunc_t done;
109 void *done_arg;
110
111 /* Common methods */
112 isc_result_t (*openfile)(dns_loadctx_t *lctx, const char *filename);
113 isc_result_t (*load)(dns_loadctx_t *lctx);
114
115 /* Members used by all formats */
116 uint32_t maxttl;
117
118 /* Members specific to the text format: */
119 isc_lex_t *lex;
120 bool keep_lex;
121 unsigned int options;
122 bool ttl_known;
123 bool default_ttl_known;
124 bool warn_1035;
125 bool warn_tcr;
126 bool warn_sigexpired;
127 bool seen_include;
128 uint32_t ttl;
129 uint32_t default_ttl;
130 dns_rdataclass_t zclass;
131 dns_fixedname_t fixed_top;
132 dns_name_t *top; /*%< top of zone */
133
134 /* Members specific to the raw format: */
135 FILE *f;
136 bool first;
137 dns_masterrawheader_t header;
138
139 /* Which fixed buffers we are using? */
140 unsigned int loop_cnt; /*% records per quantum,
141 * 0 => all. */
142 isc_result_t result;
143
144 /* Atomic */
145 isc_refcount_t references;
146 atomic_bool canceled;
147
148 /* locked by lock */
149 dns_incctx_t *inc;
150 uint32_t resign;
151 isc_stdtime_t now;
152
153 dns_masterincludecb_t include_cb;
154 void *include_arg;
155 };
156
157 struct dns_incctx {
158 dns_incctx_t *parent;
159 dns_name_t *origin;
160 dns_name_t *current;
161 dns_name_t *glue;
162 dns_fixedname_t fixed[NBUFS]; /* working buffers */
163 unsigned int in_use[NBUFS]; /* covert to bitmap? */
164 int glue_in_use;
165 int current_in_use;
166 int origin_in_use;
167 bool origin_changed;
168 bool drop;
169 unsigned int glue_line;
170 unsigned int current_line;
171 };
172
173 #define DNS_LCTX_MAGIC ISC_MAGIC('L', 'c', 't', 'x')
174 #define DNS_LCTX_VALID(lctx) ISC_MAGIC_VALID(lctx, DNS_LCTX_MAGIC)
175
176 #define DNS_AS_STR(t) ((t).value.as_textregion.base)
177
178 static isc_result_t
179 openfile_text(dns_loadctx_t *lctx, const char *master_file);
180
181 static isc_result_t
182 load_text(dns_loadctx_t *lctx);
183
184 static isc_result_t
185 openfile_raw(dns_loadctx_t *lctx, const char *master_file);
186
187 static isc_result_t
188 load_raw(dns_loadctx_t *lctx);
189
190 static isc_result_t
191 openfile_map(dns_loadctx_t *lctx, const char *master_file);
192
193 static isc_result_t
194 load_map(dns_loadctx_t *lctx);
195
196 static isc_result_t
197 pushfile(const char *master_file, dns_name_t *origin, dns_loadctx_t *lctx);
198
199 static isc_result_t
200 commit(dns_rdatacallbacks_t *, dns_loadctx_t *, rdatalist_head_t *,
201 dns_name_t *, const char *, unsigned int);
202
203 static bool
204 is_glue(rdatalist_head_t *, dns_name_t *);
205
206 static dns_rdatalist_t *
207 grow_rdatalist(int, dns_rdatalist_t *, int, rdatalist_head_t *,
208 rdatalist_head_t *, isc_mem_t *mctx);
209
210 static dns_rdata_t *
211 grow_rdata(int, dns_rdata_t *, int, rdatalist_head_t *, rdatalist_head_t *,
212 isc_mem_t *);
213
214 static void
215 load_quantum(isc_task_t *task, isc_event_t *event);
216
217 static isc_result_t
218 task_send(dns_loadctx_t *lctx);
219
220 static void
221 loadctx_destroy(dns_loadctx_t *lctx);
222
223 #define GETTOKENERR(lexer, options, token, eol, err) \
224 do { \
225 result = gettoken(lexer, options, token, eol, callbacks); \
226 switch (result) { \
227 case ISC_R_SUCCESS: \
228 break; \
229 case ISC_R_UNEXPECTED: \
230 goto insist_and_cleanup; \
231 default: \
232 if (MANYERRS(lctx, result)) { \
233 SETRESULT(lctx, result); \
234 LOGIT(result); \
235 read_till_eol = true; \
236 err goto next_line; \
237 } else \
238 goto log_and_cleanup; \
239 } \
240 if ((token)->type == isc_tokentype_special) { \
241 result = DNS_R_SYNTAX; \
242 if (MANYERRS(lctx, result)) { \
243 SETRESULT(lctx, result); \
244 LOGIT(result); \
245 read_till_eol = true; \
246 goto next_line; \
247 } else \
248 goto log_and_cleanup; \
249 } \
250 } while (0)
251 #define GETTOKEN(lexer, options, token, eol) \
252 GETTOKENERR(lexer, options, token, eol, {})
253
254 #define COMMITALL \
255 do { \
256 result = commit(callbacks, lctx, ¤t_list, ictx->current, \
257 source, ictx->current_line); \
258 if (MANYERRS(lctx, result)) { \
259 SETRESULT(lctx, result); \
260 } else if (result != ISC_R_SUCCESS) \
261 goto insist_and_cleanup; \
262 result = commit(callbacks, lctx, &glue_list, ictx->glue, \
263 source, ictx->glue_line); \
264 if (MANYERRS(lctx, result)) { \
265 SETRESULT(lctx, result); \
266 } else if (result != ISC_R_SUCCESS) \
267 goto insist_and_cleanup; \
268 rdcount = 0; \
269 rdlcount = 0; \
270 isc_buffer_init(&target, target_mem, target_size); \
271 rdcount_save = rdcount; \
272 rdlcount_save = rdlcount; \
273 } while (0)
274
275 #define WARNUNEXPECTEDEOF(lexer) \
276 do { \
277 if (isc_lex_isfile(lexer)) \
278 (*callbacks->warn)(callbacks, \
279 "%s: file does not end with " \
280 "newline", \
281 source); \
282 } while (0)
283
284 #define EXPECTEOL \
285 do { \
286 GETTOKEN(lctx->lex, 0, &token, true); \
287 if (token.type != isc_tokentype_eol) { \
288 isc_lex_ungettoken(lctx->lex, &token); \
289 result = DNS_R_EXTRATOKEN; \
290 if (MANYERRS(lctx, result)) { \
291 SETRESULT(lctx, result); \
292 LOGIT(result); \
293 read_till_eol = true; \
294 break; \
295 } else if (result != ISC_R_SUCCESS) \
296 goto log_and_cleanup; \
297 } \
298 } while (0)
299
300 #define MANYERRS(lctx, result) \
301 ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \
302 ((lctx)->options & DNS_MASTER_MANYERRORS) != 0)
303
304 #define SETRESULT(lctx, r) \
305 do { \
306 if ((lctx)->result == ISC_R_SUCCESS) \
307 (lctx)->result = r; \
308 } while (0)
309
310 #define LOGITFILE(result, filename) \
311 if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \
312 result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \
313 result == ISC_R_NOPERM) \
314 (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \
315 "dns_master_load", source, line, filename, \
316 dns_result_totext(result)); \
317 else \
318 LOGIT(result)
319
320 #define LOGIT(result) \
321 if (result == ISC_R_NOMEMORY) \
322 (*callbacks->error)(callbacks, "dns_master_load: %s", \
323 dns_result_totext(result)); \
324 else \
325 (*callbacks->error)(callbacks, "%s: %s:%lu: %s", \
326 "dns_master_load", source, line, \
327 dns_result_totext(result))
328
329 static unsigned char in_addr_arpa_data[] = "\007IN-ADDR\004ARPA";
330 static unsigned char in_addr_arpa_offsets[] = { 0, 8, 13 };
331 static dns_name_t const in_addr_arpa =
332 DNS_NAME_INITABSOLUTE(in_addr_arpa_data, in_addr_arpa_offsets);
333
334 static unsigned char ip6_int_data[] = "\003IP6\003INT";
335 static unsigned char ip6_int_offsets[] = { 0, 4, 8 };
336 static dns_name_t const ip6_int = DNS_NAME_INITABSOLUTE(ip6_int_data,
337 ip6_int_offsets);
338
339 static unsigned char ip6_arpa_data[] = "\003IP6\004ARPA";
340 static unsigned char ip6_arpa_offsets[] = { 0, 4, 9 };
341 static dns_name_t const ip6_arpa = DNS_NAME_INITABSOLUTE(ip6_arpa_data,
342 ip6_arpa_offsets);
343
344 static inline bool
dns_master_isprimary(dns_loadctx_t * lctx)345 dns_master_isprimary(dns_loadctx_t *lctx) {
346 return ((lctx->options & DNS_MASTER_ZONE) != 0 &&
347 (lctx->options & DNS_MASTER_SLAVE) == 0 &&
348 (lctx->options & DNS_MASTER_KEY) == 0);
349 }
350
351 static inline isc_result_t
gettoken(isc_lex_t * lex,unsigned int options,isc_token_t * token,bool eol,dns_rdatacallbacks_t * callbacks)352 gettoken(isc_lex_t *lex, unsigned int options, isc_token_t *token, bool eol,
353 dns_rdatacallbacks_t *callbacks) {
354 isc_result_t result;
355
356 options |= ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ISC_LEXOPT_DNSMULTILINE |
357 ISC_LEXOPT_ESCAPE;
358 result = isc_lex_gettoken(lex, options, token);
359 if (result != ISC_R_SUCCESS) {
360 switch (result) {
361 case ISC_R_NOMEMORY:
362 return (ISC_R_NOMEMORY);
363 default:
364 (*callbacks->error)(callbacks,
365 "dns_master_load: %s:%lu:"
366 " isc_lex_gettoken() failed: %s",
367 isc_lex_getsourcename(lex),
368 isc_lex_getsourceline(lex),
369 isc_result_totext(result));
370 return (result);
371 }
372 /*NOTREACHED*/
373 }
374 if (eol != true) {
375 if (token->type == isc_tokentype_eol ||
376 token->type == isc_tokentype_eof) {
377 {
378 unsigned long int line;
379 const char *what;
380 const char *file;
381 file = isc_lex_getsourcename(lex);
382 line = isc_lex_getsourceline(lex);
383 if (token->type == isc_tokentype_eol) {
384 line--;
385 what = "line";
386 } else {
387 what = "file";
388 }
389 (*callbacks->error)(callbacks,
390 "dns_master_load: %s:%lu: "
391 "unexpected end of %s",
392 file, line, what);
393 return (ISC_R_UNEXPECTEDEND);
394 }
395 }
396 }
397 return (ISC_R_SUCCESS);
398 }
399
400 void
dns_loadctx_attach(dns_loadctx_t * source,dns_loadctx_t ** target)401 dns_loadctx_attach(dns_loadctx_t *source, dns_loadctx_t **target) {
402 REQUIRE(target != NULL && *target == NULL);
403 REQUIRE(DNS_LCTX_VALID(source));
404
405 isc_refcount_increment(&source->references);
406
407 *target = source;
408 }
409
410 void
dns_loadctx_detach(dns_loadctx_t ** lctxp)411 dns_loadctx_detach(dns_loadctx_t **lctxp) {
412 dns_loadctx_t *lctx;
413
414 REQUIRE(lctxp != NULL);
415 lctx = *lctxp;
416 *lctxp = NULL;
417 REQUIRE(DNS_LCTX_VALID(lctx));
418
419 if (isc_refcount_decrement(&lctx->references) == 1) {
420 loadctx_destroy(lctx);
421 }
422 }
423
424 static void
incctx_destroy(isc_mem_t * mctx,dns_incctx_t * ictx)425 incctx_destroy(isc_mem_t *mctx, dns_incctx_t *ictx) {
426 dns_incctx_t *parent;
427
428 again:
429 parent = ictx->parent;
430 ictx->parent = NULL;
431
432 isc_mem_put(mctx, ictx, sizeof(*ictx));
433
434 if (parent != NULL) {
435 ictx = parent;
436 goto again;
437 }
438 }
439
440 static void
loadctx_destroy(dns_loadctx_t * lctx)441 loadctx_destroy(dns_loadctx_t *lctx) {
442 REQUIRE(DNS_LCTX_VALID(lctx));
443
444 isc_refcount_destroy(&lctx->references);
445
446 lctx->magic = 0;
447 if (lctx->inc != NULL) {
448 incctx_destroy(lctx->mctx, lctx->inc);
449 }
450
451 if (lctx->f != NULL) {
452 isc_result_t result = isc_stdio_close(lctx->f);
453 if (result != ISC_R_SUCCESS) {
454 UNEXPECTED_ERROR(__FILE__, __LINE__,
455 "isc_stdio_close() failed: %s",
456 isc_result_totext(result));
457 }
458 }
459
460 /* isc_lex_destroy() will close all open streams */
461 if (lctx->lex != NULL && !lctx->keep_lex) {
462 isc_lex_destroy(&lctx->lex);
463 }
464
465 if (lctx->task != NULL) {
466 isc_task_detach(&lctx->task);
467 }
468
469 isc_mem_putanddetach(&lctx->mctx, lctx, sizeof(*lctx));
470 }
471
472 static isc_result_t
incctx_create(isc_mem_t * mctx,dns_name_t * origin,dns_incctx_t ** ictxp)473 incctx_create(isc_mem_t *mctx, dns_name_t *origin, dns_incctx_t **ictxp) {
474 dns_incctx_t *ictx;
475 isc_region_t r;
476 int i;
477
478 ictx = isc_mem_get(mctx, sizeof(*ictx));
479
480 for (i = 0; i < NBUFS; i++) {
481 dns_fixedname_init(&ictx->fixed[i]);
482 ictx->in_use[i] = false;
483 }
484
485 ictx->origin_in_use = 0;
486 ictx->origin = dns_fixedname_name(&ictx->fixed[ictx->origin_in_use]);
487 ictx->in_use[ictx->origin_in_use] = true;
488 dns_name_toregion(origin, &r);
489 dns_name_fromregion(ictx->origin, &r);
490
491 ictx->glue = NULL;
492 ictx->current = NULL;
493 ictx->glue_in_use = -1;
494 ictx->current_in_use = -1;
495 ictx->parent = NULL;
496 ictx->drop = false;
497 ictx->glue_line = 0;
498 ictx->current_line = 0;
499 ictx->origin_changed = true;
500
501 *ictxp = ictx;
502 return (ISC_R_SUCCESS);
503 }
504
505 static isc_result_t
loadctx_create(dns_masterformat_t format,isc_mem_t * mctx,unsigned int options,uint32_t resign,dns_name_t * top,dns_rdataclass_t zclass,dns_name_t * origin,dns_rdatacallbacks_t * callbacks,isc_task_t * task,dns_loaddonefunc_t done,void * done_arg,dns_masterincludecb_t include_cb,void * include_arg,isc_lex_t * lex,dns_loadctx_t ** lctxp)506 loadctx_create(dns_masterformat_t format, isc_mem_t *mctx, unsigned int options,
507 uint32_t resign, dns_name_t *top, dns_rdataclass_t zclass,
508 dns_name_t *origin, dns_rdatacallbacks_t *callbacks,
509 isc_task_t *task, dns_loaddonefunc_t done, void *done_arg,
510 dns_masterincludecb_t include_cb, void *include_arg,
511 isc_lex_t *lex, dns_loadctx_t **lctxp) {
512 dns_loadctx_t *lctx;
513 isc_result_t result;
514 isc_region_t r;
515 isc_lexspecials_t specials;
516
517 REQUIRE(lctxp != NULL && *lctxp == NULL);
518 REQUIRE(callbacks != NULL);
519 REQUIRE(callbacks->add != NULL);
520 REQUIRE(callbacks->error != NULL);
521 REQUIRE(callbacks->warn != NULL);
522 REQUIRE(mctx != NULL);
523 REQUIRE(dns_name_isabsolute(top));
524 REQUIRE(dns_name_isabsolute(origin));
525 REQUIRE((task == NULL && done == NULL) ||
526 (task != NULL && done != NULL));
527
528 lctx = isc_mem_get(mctx, sizeof(*lctx));
529
530 lctx->inc = NULL;
531 result = incctx_create(mctx, origin, &lctx->inc);
532 if (result != ISC_R_SUCCESS) {
533 goto cleanup_ctx;
534 }
535
536 lctx->maxttl = 0;
537
538 lctx->format = format;
539 switch (format) {
540 case dns_masterformat_text:
541 lctx->openfile = openfile_text;
542 lctx->load = load_text;
543 break;
544 case dns_masterformat_raw:
545 lctx->openfile = openfile_raw;
546 lctx->load = load_raw;
547 break;
548 case dns_masterformat_map:
549 lctx->openfile = openfile_map;
550 lctx->load = load_map;
551 break;
552 default:
553 INSIST(0);
554 ISC_UNREACHABLE();
555 }
556
557 if (lex != NULL) {
558 lctx->lex = lex;
559 lctx->keep_lex = true;
560 } else {
561 lctx->lex = NULL;
562 result = isc_lex_create(mctx, TOKENSIZ, &lctx->lex);
563 if (result != ISC_R_SUCCESS) {
564 goto cleanup_inc;
565 }
566 lctx->keep_lex = false;
567 /*
568 * If specials change update dns_test_rdatafromstring()
569 * in lib/dns/tests/dnstest.c.
570 */
571 memset(specials, 0, sizeof(specials));
572 specials[0] = 1;
573 specials['('] = 1;
574 specials[')'] = 1;
575 specials['"'] = 1;
576 isc_lex_setspecials(lctx->lex, specials);
577 isc_lex_setcomments(lctx->lex, ISC_LEXCOMMENT_DNSMASTERFILE);
578 }
579
580 lctx->ttl_known = ((options & DNS_MASTER_NOTTL) != 0);
581 lctx->ttl = 0;
582 lctx->default_ttl_known = lctx->ttl_known;
583 lctx->default_ttl = 0;
584 lctx->warn_1035 = true; /* XXX Argument? */
585 lctx->warn_tcr = true; /* XXX Argument? */
586 lctx->warn_sigexpired = true; /* XXX Argument? */
587 lctx->options = options;
588 lctx->seen_include = false;
589 lctx->zclass = zclass;
590 lctx->resign = resign;
591 lctx->result = ISC_R_SUCCESS;
592 lctx->include_cb = include_cb;
593 lctx->include_arg = include_arg;
594 isc_stdtime_get(&lctx->now);
595
596 lctx->top = dns_fixedname_initname(&lctx->fixed_top);
597 dns_name_toregion(top, &r);
598 dns_name_fromregion(lctx->top, &r);
599
600 lctx->f = NULL;
601 lctx->first = true;
602 dns_master_initrawheader(&lctx->header);
603
604 lctx->loop_cnt = (done != NULL) ? 100 : 0;
605 lctx->callbacks = callbacks;
606 lctx->task = NULL;
607 if (task != NULL) {
608 isc_task_attach(task, &lctx->task);
609 }
610 lctx->done = done;
611 lctx->done_arg = done_arg;
612 atomic_init(&lctx->canceled, false);
613 lctx->mctx = NULL;
614 isc_mem_attach(mctx, &lctx->mctx);
615
616 isc_refcount_init(&lctx->references, 1); /* Implicit attach. */
617
618 lctx->magic = DNS_LCTX_MAGIC;
619 *lctxp = lctx;
620 return (ISC_R_SUCCESS);
621
622 cleanup_inc:
623 incctx_destroy(mctx, lctx->inc);
624 cleanup_ctx:
625 isc_mem_put(mctx, lctx, sizeof(*lctx));
626 return (result);
627 }
628
629 static const char *hex = "0123456789abcdef0123456789ABCDEF";
630
631 /*%
632 * Convert value into a nibble sequence from least significant to most
633 * significant nibble. Zero fill upper most significant nibbles if
634 * required to make the width.
635 *
636 * Returns the number of characters that should have been written without
637 * counting the terminating NUL.
638 */
639 static unsigned int
nibbles(char * numbuf,size_t length,unsigned int width,char mode,int value)640 nibbles(char *numbuf, size_t length, unsigned int width, char mode, int value) {
641 unsigned int count = 0;
642
643 /*
644 * This reserve space for the NUL string terminator.
645 */
646 if (length > 0U) {
647 *numbuf = '\0';
648 length--;
649 }
650 do {
651 char val = hex[(value & 0x0f) + ((mode == 'n') ? 0 : 16)];
652 value >>= 4;
653 if (length > 0U) {
654 *numbuf++ = val;
655 *numbuf = '\0';
656 length--;
657 }
658 if (width > 0) {
659 width--;
660 }
661 count++;
662 /*
663 * If width is non zero then we need to add a label separator.
664 * If value is non zero then we need to add another label and
665 * that requires a label separator.
666 */
667 if (width > 0 || value != 0) {
668 if (length > 0U) {
669 *numbuf++ = '.';
670 *numbuf = '\0';
671 length--;
672 }
673 if (width > 0) {
674 width--;
675 }
676 count++;
677 }
678 } while (value != 0 || width > 0);
679 return (count);
680 }
681
682 static isc_result_t
genname(char * name,int it,char * buffer,size_t length)683 genname(char *name, int it, char *buffer, size_t length) {
684 char fmt[sizeof("%04000000000d")];
685 char numbuf[128];
686 char *cp;
687 char mode[2];
688 int delta = 0;
689 isc_textregion_t r;
690 unsigned int n;
691 unsigned int width;
692 bool nibblemode;
693
694 r.base = buffer;
695 r.length = (unsigned int)length;
696
697 while (*name != '\0') {
698 if (*name == '$') {
699 name++;
700 if (*name == '$') {
701 if (r.length == 0) {
702 return (ISC_R_NOSPACE);
703 }
704 r.base[0] = *name++;
705 isc_textregion_consume(&r, 1);
706 continue;
707 }
708 nibblemode = false;
709 strlcpy(fmt, "%d", sizeof(fmt));
710 /* Get format specifier. */
711 if (*name == '{') {
712 n = sscanf(name, "{%d,%u,%1[doxXnN]}", &delta,
713 &width, mode);
714 switch (n) {
715 case 1:
716 break;
717 case 2:
718 n = snprintf(fmt, sizeof(fmt), "%%0%ud",
719 width);
720 break;
721 case 3:
722 if (mode[0] == 'n' || mode[0] == 'N') {
723 nibblemode = true;
724 }
725 n = snprintf(fmt, sizeof(fmt),
726 "%%0%u%c", width, mode[0]);
727 break;
728 default:
729 return (DNS_R_SYNTAX);
730 }
731 if (n >= sizeof(fmt)) {
732 return (ISC_R_NOSPACE);
733 }
734 /* Skip past closing brace. */
735 while (*name != '\0' && *name++ != '}') {
736 continue;
737 }
738 }
739 if (nibblemode) {
740 n = nibbles(numbuf, sizeof(numbuf), width,
741 mode[0], it + delta);
742 } else {
743 n = snprintf(numbuf, sizeof(numbuf), fmt,
744 it + delta);
745 }
746 if (n >= sizeof(numbuf)) {
747 return (ISC_R_NOSPACE);
748 }
749 cp = numbuf;
750 while (*cp != '\0') {
751 if (r.length == 0) {
752 return (ISC_R_NOSPACE);
753 }
754 r.base[0] = *cp++;
755 isc_textregion_consume(&r, 1);
756 }
757 } else if (*name == '\\') {
758 if (r.length == 0) {
759 return (ISC_R_NOSPACE);
760 }
761 r.base[0] = *name++;
762 isc_textregion_consume(&r, 1);
763 if (*name == '\0') {
764 continue;
765 }
766 if (r.length == 0) {
767 return (ISC_R_NOSPACE);
768 }
769 r.base[0] = *name++;
770 isc_textregion_consume(&r, 1);
771 } else {
772 if (r.length == 0) {
773 return (ISC_R_NOSPACE);
774 }
775 r.base[0] = *name++;
776 isc_textregion_consume(&r, 1);
777 }
778 }
779 if (r.length == 0) {
780 return (ISC_R_NOSPACE);
781 }
782 r.base[0] = '\0';
783 return (ISC_R_SUCCESS);
784 }
785
786 static isc_result_t
generate(dns_loadctx_t * lctx,char * range,char * lhs,char * gtype,char * rhs,const char * source,unsigned int line)787 generate(dns_loadctx_t *lctx, char *range, char *lhs, char *gtype, char *rhs,
788 const char *source, unsigned int line) {
789 char *target_mem = NULL;
790 char *lhsbuf = NULL;
791 char *rhsbuf = NULL;
792 dns_fixedname_t ownerfixed;
793 dns_name_t *owner;
794 dns_rdata_t rdata = DNS_RDATA_INIT;
795 dns_rdatacallbacks_t *callbacks;
796 dns_rdatalist_t rdatalist;
797 dns_rdatatype_t type;
798 rdatalist_head_t head;
799 int target_size = MINTSIZ; /* only one rdata at a time */
800 isc_buffer_t buffer;
801 isc_buffer_t target;
802 isc_result_t result;
803 isc_textregion_t r;
804 int i, n, start, stop, step = 0;
805 dns_incctx_t *ictx;
806 char dummy[2];
807
808 ictx = lctx->inc;
809 callbacks = lctx->callbacks;
810 owner = dns_fixedname_initname(&ownerfixed);
811 ISC_LIST_INIT(head);
812
813 target_mem = isc_mem_get(lctx->mctx, target_size);
814 rhsbuf = isc_mem_get(lctx->mctx, DNS_MASTER_RHS);
815 lhsbuf = isc_mem_get(lctx->mctx, DNS_MASTER_LHS);
816 if (target_mem == NULL || rhsbuf == NULL || lhsbuf == NULL) {
817 result = ISC_R_NOMEMORY;
818 goto error_cleanup;
819 }
820 isc_buffer_init(&target, target_mem, target_size);
821
822 n = sscanf(range, "%d-%d%1[/]%d", &start, &stop, dummy, &step);
823 if ((n != 2 && n != 4) || (start < 0) || (stop < 0) ||
824 (n == 4 && step < 1) || (stop < start))
825 {
826 (*callbacks->error)(callbacks, "%s: %s:%lu: invalid range '%s'",
827 "$GENERATE", source, line, range);
828 result = DNS_R_SYNTAX;
829 goto insist_cleanup;
830 }
831 if (n == 2) {
832 step = 1;
833 }
834
835 /*
836 * Get type.
837 */
838 r.base = gtype;
839 r.length = strlen(gtype);
840 result = dns_rdatatype_fromtext(&type, &r);
841 if (result != ISC_R_SUCCESS) {
842 (*callbacks->error)(callbacks,
843 "%s: %s:%lu: unknown RR type '%s'",
844 "$GENERATE", source, line, gtype);
845 goto insist_cleanup;
846 }
847
848 /*
849 * RFC2930: TKEY and TSIG are not allowed to be loaded
850 * from master files.
851 */
852 if (dns_master_isprimary(lctx) && dns_rdatatype_ismeta(type)) {
853 (*callbacks->error)(callbacks, "%s: %s:%lu: meta RR type '%s'",
854 "$GENERATE", source, line, gtype);
855 result = DNS_R_METATYPE;
856 goto insist_cleanup;
857 }
858
859 for (i = start; i <= stop; i += step) {
860 result = genname(lhs, i, lhsbuf, DNS_MASTER_LHS);
861 if (result != ISC_R_SUCCESS) {
862 goto error_cleanup;
863 }
864 result = genname(rhs, i, rhsbuf, DNS_MASTER_RHS);
865 if (result != ISC_R_SUCCESS) {
866 goto error_cleanup;
867 }
868
869 isc_buffer_init(&buffer, lhsbuf, strlen(lhsbuf));
870 isc_buffer_add(&buffer, strlen(lhsbuf));
871 isc_buffer_setactive(&buffer, strlen(lhsbuf));
872 result = dns_name_fromtext(owner, &buffer, ictx->origin, 0,
873 NULL);
874 if (result != ISC_R_SUCCESS) {
875 goto error_cleanup;
876 }
877
878 if (dns_master_isprimary(lctx) &&
879 !dns_name_issubdomain(owner, lctx->top)) {
880 char namebuf[DNS_NAME_FORMATSIZE];
881 dns_name_format(owner, namebuf, sizeof(namebuf));
882 /*
883 * Ignore out-of-zone data.
884 */
885 (*callbacks->warn)(callbacks,
886 "%s:%lu: "
887 "ignoring out-of-zone data (%s)",
888 source, line, namebuf);
889 continue;
890 }
891
892 isc_buffer_init(&buffer, rhsbuf, strlen(rhsbuf));
893 isc_buffer_add(&buffer, strlen(rhsbuf));
894 isc_buffer_setactive(&buffer, strlen(rhsbuf));
895
896 result = isc_lex_openbuffer(lctx->lex, &buffer);
897 if (result != ISC_R_SUCCESS) {
898 goto error_cleanup;
899 }
900
901 isc_buffer_init(&target, target_mem, target_size);
902 result = dns_rdata_fromtext(&rdata, lctx->zclass, type,
903 lctx->lex, ictx->origin, 0,
904 lctx->mctx, &target, callbacks);
905 RUNTIME_CHECK(isc_lex_close(lctx->lex) == ISC_R_SUCCESS);
906 if (result != ISC_R_SUCCESS) {
907 goto error_cleanup;
908 }
909
910 dns_rdatalist_init(&rdatalist);
911 rdatalist.type = type;
912 rdatalist.rdclass = lctx->zclass;
913 rdatalist.ttl = lctx->ttl;
914 ISC_LIST_PREPEND(head, &rdatalist, link);
915 ISC_LIST_APPEND(rdatalist.rdata, &rdata, link);
916 result = commit(callbacks, lctx, &head, owner, source, line);
917 ISC_LIST_UNLINK(rdatalist.rdata, &rdata, link);
918 if (result != ISC_R_SUCCESS) {
919 goto error_cleanup;
920 }
921 dns_rdata_reset(&rdata);
922 }
923 result = ISC_R_SUCCESS;
924 goto cleanup;
925
926 error_cleanup:
927 if (result == ISC_R_NOMEMORY) {
928 (*callbacks->error)(callbacks, "$GENERATE: %s",
929 dns_result_totext(result));
930 } else {
931 (*callbacks->error)(callbacks, "$GENERATE: %s:%lu: %s", source,
932 line, dns_result_totext(result));
933 }
934
935 insist_cleanup:
936 INSIST(result != ISC_R_SUCCESS);
937
938 cleanup:
939 if (target_mem != NULL) {
940 isc_mem_put(lctx->mctx, target_mem, target_size);
941 }
942 if (lhsbuf != NULL) {
943 isc_mem_put(lctx->mctx, lhsbuf, DNS_MASTER_LHS);
944 }
945 if (rhsbuf != NULL) {
946 isc_mem_put(lctx->mctx, rhsbuf, DNS_MASTER_RHS);
947 }
948 return (result);
949 }
950
951 static void
limit_ttl(dns_rdatacallbacks_t * callbacks,const char * source,unsigned int line,uint32_t * ttlp)952 limit_ttl(dns_rdatacallbacks_t *callbacks, const char *source,
953 unsigned int line, uint32_t *ttlp) {
954 if (*ttlp > 0x7fffffffUL) {
955 (callbacks->warn)(callbacks,
956 "%s: %s:%lu: "
957 "$TTL %lu > MAXTTL, "
958 "setting $TTL to 0",
959 "dns_master_load", source, line, *ttlp);
960 *ttlp = 0;
961 }
962 }
963
964 static isc_result_t
check_ns(dns_loadctx_t * lctx,isc_token_t * token,const char * source,unsigned long line)965 check_ns(dns_loadctx_t *lctx, isc_token_t *token, const char *source,
966 unsigned long line) {
967 char *tmp = NULL;
968 isc_result_t result = ISC_R_SUCCESS;
969 void (*callback)(struct dns_rdatacallbacks *, const char *, ...);
970
971 if ((lctx->options & DNS_MASTER_FATALNS) != 0) {
972 callback = lctx->callbacks->error;
973 } else {
974 callback = lctx->callbacks->warn;
975 }
976
977 if (token->type == isc_tokentype_string) {
978 struct in_addr addr;
979 struct in6_addr addr6;
980
981 tmp = isc_mem_strdup(lctx->mctx, DNS_AS_STR(*token));
982 /*
983 * Catch both "1.2.3.4" and "1.2.3.4."
984 */
985 if (tmp[strlen(tmp) - 1] == '.') {
986 tmp[strlen(tmp) - 1] = '\0';
987 }
988 if (inet_pton(AF_INET, tmp, &addr) == 1 ||
989 inet_pton(AF_INET6, tmp, &addr6) == 1)
990 {
991 result = DNS_R_NSISADDRESS;
992 }
993 }
994 if (result != ISC_R_SUCCESS) {
995 (*callback)(lctx->callbacks,
996 "%s:%lu: NS record '%s' "
997 "appears to be an address",
998 source, line, DNS_AS_STR(*token));
999 }
1000 if (tmp != NULL) {
1001 isc_mem_free(lctx->mctx, tmp);
1002 }
1003 return (result);
1004 }
1005
1006 static void
check_wildcard(dns_incctx_t * ictx,const char * source,unsigned long line,dns_rdatacallbacks_t * callbacks)1007 check_wildcard(dns_incctx_t *ictx, const char *source, unsigned long line,
1008 dns_rdatacallbacks_t *callbacks) {
1009 dns_name_t *name;
1010
1011 name = (ictx->glue != NULL) ? ictx->glue : ictx->current;
1012 if (dns_name_internalwildcard(name)) {
1013 char namebuf[DNS_NAME_FORMATSIZE];
1014
1015 dns_name_format(name, namebuf, sizeof(namebuf));
1016 (*callbacks->warn)(callbacks,
1017 "%s:%lu: warning: ownername "
1018 "'%s' contains an non-terminal wildcard",
1019 source, line, namebuf);
1020 }
1021 }
1022
1023 static isc_result_t
openfile_text(dns_loadctx_t * lctx,const char * master_file)1024 openfile_text(dns_loadctx_t *lctx, const char *master_file) {
1025 return (isc_lex_openfile(lctx->lex, master_file));
1026 }
1027
1028 static int
find_free_name(dns_incctx_t * incctx)1029 find_free_name(dns_incctx_t *incctx) {
1030 int i;
1031
1032 for (i = 0; i < (NBUFS - 1); i++) {
1033 if (!incctx->in_use[i]) {
1034 break;
1035 }
1036 }
1037 INSIST(!incctx->in_use[i]);
1038 return (i);
1039 }
1040
1041 static isc_result_t
load_text(dns_loadctx_t * lctx)1042 load_text(dns_loadctx_t *lctx) {
1043 dns_rdataclass_t rdclass;
1044 dns_rdatatype_t type, covers;
1045 uint32_t ttl_offset = 0;
1046 dns_name_t *new_name;
1047 bool current_has_delegation = false;
1048 bool done = false;
1049 bool finish_origin = false;
1050 bool finish_include = false;
1051 bool read_till_eol = false;
1052 bool initialws;
1053 char *include_file = NULL;
1054 isc_token_t token;
1055 isc_result_t result = ISC_R_UNEXPECTED;
1056 rdatalist_head_t glue_list;
1057 rdatalist_head_t current_list;
1058 dns_rdatalist_t *this;
1059 dns_rdatalist_t *rdatalist = NULL;
1060 dns_rdatalist_t *new_rdatalist;
1061 int rdlcount = 0;
1062 int rdlcount_save = 0;
1063 int rdatalist_size = 0;
1064 isc_buffer_t buffer;
1065 isc_buffer_t target;
1066 isc_buffer_t target_ft;
1067 isc_buffer_t target_save;
1068 dns_rdata_t *rdata = NULL;
1069 dns_rdata_t *new_rdata;
1070 int rdcount = 0;
1071 int rdcount_save = 0;
1072 int rdata_size = 0;
1073 unsigned char *target_mem = NULL;
1074 int target_size = TSIZ;
1075 int new_in_use;
1076 unsigned int loop_cnt = 0;
1077 isc_mem_t *mctx;
1078 dns_rdatacallbacks_t *callbacks;
1079 dns_incctx_t *ictx;
1080 char *range = NULL;
1081 char *lhs = NULL;
1082 char *gtype = NULL;
1083 char *rhs = NULL;
1084 const char *source = "";
1085 unsigned long line = 0;
1086 bool explicit_ttl;
1087 char classname1[DNS_RDATACLASS_FORMATSIZE];
1088 char classname2[DNS_RDATACLASS_FORMATSIZE];
1089 unsigned int options = 0;
1090
1091 REQUIRE(DNS_LCTX_VALID(lctx));
1092 callbacks = lctx->callbacks;
1093 mctx = lctx->mctx;
1094 ictx = lctx->inc;
1095
1096 ISC_LIST_INIT(glue_list);
1097 ISC_LIST_INIT(current_list);
1098
1099 /*
1100 * Allocate target_size of buffer space. This is greater than twice
1101 * the maximum individual RR data size.
1102 */
1103 target_mem = isc_mem_get(mctx, target_size);
1104 isc_buffer_init(&target, target_mem, target_size);
1105 target_save = target;
1106
1107 if ((lctx->options & DNS_MASTER_CHECKNAMES) != 0) {
1108 options |= DNS_RDATA_CHECKNAMES;
1109 }
1110 if ((lctx->options & DNS_MASTER_CHECKNAMESFAIL) != 0) {
1111 options |= DNS_RDATA_CHECKNAMESFAIL;
1112 }
1113 if ((lctx->options & DNS_MASTER_CHECKMX) != 0) {
1114 options |= DNS_RDATA_CHECKMX;
1115 }
1116 if ((lctx->options & DNS_MASTER_CHECKMXFAIL) != 0) {
1117 options |= DNS_RDATA_CHECKMXFAIL;
1118 }
1119 source = isc_lex_getsourcename(lctx->lex);
1120 do {
1121 initialws = false;
1122 line = isc_lex_getsourceline(lctx->lex);
1123 GETTOKEN(lctx->lex, ISC_LEXOPT_INITIALWS | ISC_LEXOPT_QSTRING,
1124 &token, true);
1125 line = isc_lex_getsourceline(lctx->lex);
1126
1127 if (token.type == isc_tokentype_eof) {
1128 if (read_till_eol) {
1129 WARNUNEXPECTEDEOF(lctx->lex);
1130 }
1131 /* Pop the include stack? */
1132 if (ictx->parent != NULL) {
1133 COMMITALL;
1134 lctx->inc = ictx->parent;
1135 ictx->parent = NULL;
1136 incctx_destroy(lctx->mctx, ictx);
1137 RUNTIME_CHECK(isc_lex_close(lctx->lex) ==
1138 ISC_R_SUCCESS);
1139 line = isc_lex_getsourceline(lctx->lex);
1140 POST(line);
1141 source = isc_lex_getsourcename(lctx->lex);
1142 ictx = lctx->inc;
1143 continue;
1144 }
1145 done = true;
1146 continue;
1147 }
1148
1149 if (token.type == isc_tokentype_eol) {
1150 read_till_eol = false;
1151 continue; /* blank line */
1152 }
1153
1154 if (read_till_eol) {
1155 continue;
1156 }
1157
1158 if (token.type == isc_tokentype_initialws) {
1159 /*
1160 * Still working on the same name.
1161 */
1162 initialws = true;
1163 } else if (token.type == isc_tokentype_string ||
1164 token.type == isc_tokentype_qstring)
1165 {
1166 /*
1167 * "$" Support.
1168 *
1169 * "$ORIGIN" and "$INCLUDE" can both take domain names.
1170 * The processing of "$ORIGIN" and "$INCLUDE" extends
1171 * across the normal domain name processing.
1172 */
1173
1174 if (strcasecmp(DNS_AS_STR(token), "$ORIGIN") == 0) {
1175 GETTOKEN(lctx->lex, 0, &token, false);
1176 finish_origin = true;
1177 } else if (strcasecmp(DNS_AS_STR(token), "$TTL") == 0) {
1178 GETTOKENERR(lctx->lex, 0, &token, false,
1179 lctx->ttl = 0;
1180 lctx->default_ttl_known = true;);
1181 result = dns_ttl_fromtext(
1182 &token.value.as_textregion, &lctx->ttl);
1183 if (MANYERRS(lctx, result)) {
1184 SETRESULT(lctx, result);
1185 lctx->ttl = 0;
1186 } else if (result != ISC_R_SUCCESS) {
1187 goto insist_and_cleanup;
1188 }
1189 limit_ttl(callbacks, source, line, &lctx->ttl);
1190 lctx->default_ttl = lctx->ttl;
1191 lctx->default_ttl_known = true;
1192 EXPECTEOL;
1193 continue;
1194 } else if (strcasecmp(DNS_AS_STR(token), "$INCLUDE") ==
1195 0) {
1196 COMMITALL;
1197 if ((lctx->options & DNS_MASTER_NOINCLUDE) != 0)
1198 {
1199 (callbacks->error)(callbacks,
1200 "%s: %s:%lu: "
1201 "$INCLUDE not "
1202 "allowed",
1203 "dns_master_load",
1204 source, line);
1205 result = DNS_R_REFUSED;
1206 goto insist_and_cleanup;
1207 }
1208 if (ttl_offset != 0) {
1209 (callbacks->error)(callbacks,
1210 "%s: %s:%lu: "
1211 "$INCLUDE "
1212 "may not be used "
1213 "with $DATE",
1214 "dns_master_load",
1215 source, line);
1216 result = DNS_R_SYNTAX;
1217 goto insist_and_cleanup;
1218 }
1219 GETTOKEN(lctx->lex, ISC_LEXOPT_QSTRING, &token,
1220 false);
1221 if (include_file != NULL) {
1222 isc_mem_free(mctx, include_file);
1223 }
1224 include_file =
1225 isc_mem_strdup(mctx, DNS_AS_STR(token));
1226 GETTOKEN(lctx->lex, 0, &token, true);
1227
1228 if (token.type == isc_tokentype_eol ||
1229 token.type == isc_tokentype_eof) {
1230 if (token.type == isc_tokentype_eof) {
1231 WARNUNEXPECTEDEOF(lctx->lex);
1232 }
1233 /*
1234 * No origin field.
1235 */
1236 result = pushfile(include_file,
1237 ictx->origin, lctx);
1238 if (MANYERRS(lctx, result)) {
1239 SETRESULT(lctx, result);
1240 LOGITFILE(result, include_file);
1241 continue;
1242 } else if (result != ISC_R_SUCCESS) {
1243 LOGITFILE(result, include_file);
1244 goto insist_and_cleanup;
1245 }
1246 ictx = lctx->inc;
1247 source = isc_lex_getsourcename(
1248 lctx->lex);
1249 line = isc_lex_getsourceline(lctx->lex);
1250 POST(line);
1251 continue;
1252 }
1253 /*
1254 * There is an origin field. Fall through
1255 * to domain name processing code and do
1256 * the actual inclusion later.
1257 */
1258 finish_include = true;
1259 } else if (strcasecmp(DNS_AS_STR(token), "$DATE") == 0)
1260 {
1261 int64_t dump_time64;
1262 isc_stdtime_t dump_time, current_time;
1263 GETTOKEN(lctx->lex, 0, &token, false);
1264 isc_stdtime_get(¤t_time);
1265 result = dns_time64_fromtext(DNS_AS_STR(token),
1266 &dump_time64);
1267 if (MANYERRS(lctx, result)) {
1268 SETRESULT(lctx, result);
1269 LOGIT(result);
1270 dump_time64 = 0;
1271 } else if (result != ISC_R_SUCCESS) {
1272 goto log_and_cleanup;
1273 }
1274 dump_time = (isc_stdtime_t)dump_time64;
1275 if (dump_time != dump_time64) {
1276 UNEXPECTED_ERROR(__FILE__, __LINE__,
1277 "%s: %s:%lu: $DATE "
1278 "outside epoch",
1279 "dns_master_load",
1280 source, line);
1281 result = ISC_R_UNEXPECTED;
1282 goto insist_and_cleanup;
1283 }
1284 if (dump_time > current_time) {
1285 UNEXPECTED_ERROR(__FILE__, __LINE__,
1286 "%s: %s:%lu: "
1287 "$DATE in future, "
1288 "using current date",
1289 "dns_master_load",
1290 source, line);
1291 dump_time = current_time;
1292 }
1293 ttl_offset = current_time - dump_time;
1294 EXPECTEOL;
1295 continue;
1296 } else if (strcasecmp(DNS_AS_STR(token), "$GENERATE") ==
1297 0) {
1298 /*
1299 * Lazy cleanup.
1300 */
1301 if (range != NULL) {
1302 isc_mem_free(mctx, range);
1303 }
1304 if (lhs != NULL) {
1305 isc_mem_free(mctx, lhs);
1306 }
1307 if (gtype != NULL) {
1308 isc_mem_free(mctx, gtype);
1309 }
1310 if (rhs != NULL) {
1311 isc_mem_free(mctx, rhs);
1312 }
1313 range = lhs = gtype = rhs = NULL;
1314 /* RANGE */
1315 GETTOKEN(lctx->lex, 0, &token, false);
1316 range = isc_mem_strdup(mctx, DNS_AS_STR(token));
1317 /* LHS */
1318 GETTOKEN(lctx->lex, 0, &token, false);
1319 lhs = isc_mem_strdup(mctx, DNS_AS_STR(token));
1320 rdclass = 0;
1321 explicit_ttl = false;
1322 /* CLASS? */
1323 GETTOKEN(lctx->lex, 0, &token, false);
1324 if (dns_rdataclass_fromtext(
1325 &rdclass,
1326 &token.value.as_textregion) ==
1327 ISC_R_SUCCESS)
1328 {
1329 GETTOKEN(lctx->lex, 0, &token, false);
1330 }
1331 /* TTL? */
1332 if (dns_ttl_fromtext(&token.value.as_textregion,
1333 &lctx->ttl) ==
1334 ISC_R_SUCCESS) {
1335 limit_ttl(callbacks, source, line,
1336 &lctx->ttl);
1337 lctx->ttl_known = true;
1338 explicit_ttl = true;
1339 GETTOKEN(lctx->lex, 0, &token, false);
1340 }
1341 /* CLASS? */
1342 if (rdclass == 0 &&
1343 dns_rdataclass_fromtext(
1344 &rdclass,
1345 &token.value.as_textregion) ==
1346 ISC_R_SUCCESS)
1347 {
1348 GETTOKEN(lctx->lex, 0, &token, false);
1349 }
1350 /* TYPE */
1351 gtype = isc_mem_strdup(mctx, DNS_AS_STR(token));
1352 /* RHS */
1353 GETTOKEN(lctx->lex, ISC_LEXOPT_QSTRING, &token,
1354 false);
1355 rhs = isc_mem_strdup(mctx, DNS_AS_STR(token));
1356 if (!lctx->ttl_known &&
1357 !lctx->default_ttl_known) {
1358 (*callbacks->error)(callbacks,
1359 "%s: %s:%lu: no "
1360 "TTL specified",
1361 "dns_master_load",
1362 source, line);
1363 result = DNS_R_NOTTL;
1364 if (MANYERRS(lctx, result)) {
1365 SETRESULT(lctx, result);
1366 lctx->ttl = 0;
1367 } else {
1368 goto insist_and_cleanup;
1369 }
1370 } else if (!explicit_ttl &&
1371 lctx->default_ttl_known) {
1372 lctx->ttl = lctx->default_ttl;
1373 }
1374 /*
1375 * If the class specified does not match the
1376 * zone's class print out a error message and
1377 * exit.
1378 */
1379 if (rdclass != 0 && rdclass != lctx->zclass) {
1380 goto bad_class;
1381 }
1382 result = generate(lctx, range, lhs, gtype, rhs,
1383 source, line);
1384 if (MANYERRS(lctx, result)) {
1385 SETRESULT(lctx, result);
1386 } else if (result != ISC_R_SUCCESS) {
1387 goto insist_and_cleanup;
1388 }
1389 EXPECTEOL;
1390 continue;
1391 } else if (strncasecmp(DNS_AS_STR(token), "$", 1) == 0)
1392 {
1393 (callbacks->error)(callbacks,
1394 "%s: %s:%lu: "
1395 "unknown $ directive '%s'",
1396 "dns_master_load", source,
1397 line, DNS_AS_STR(token));
1398 result = DNS_R_SYNTAX;
1399 if (MANYERRS(lctx, result)) {
1400 SETRESULT(lctx, result);
1401 } else {
1402 goto insist_and_cleanup;
1403 }
1404 }
1405
1406 /*
1407 * Normal processing resumes.
1408 */
1409 new_in_use = find_free_name(ictx);
1410 new_name = dns_fixedname_initname(
1411 &ictx->fixed[new_in_use]);
1412 isc_buffer_init(&buffer, token.value.as_region.base,
1413 token.value.as_region.length);
1414 isc_buffer_add(&buffer, token.value.as_region.length);
1415 isc_buffer_setactive(&buffer,
1416 token.value.as_region.length);
1417 result = dns_name_fromtext(new_name, &buffer,
1418 ictx->origin, 0, NULL);
1419 if (MANYERRS(lctx, result)) {
1420 SETRESULT(lctx, result);
1421 LOGIT(result);
1422 read_till_eol = true;
1423 continue;
1424 } else if (result != ISC_R_SUCCESS) {
1425 goto log_and_cleanup;
1426 }
1427
1428 /*
1429 * Finish $ORIGIN / $INCLUDE processing if required.
1430 */
1431 if (finish_origin) {
1432 if (ictx->origin_in_use != -1) {
1433 ictx->in_use[ictx->origin_in_use] =
1434 false;
1435 }
1436 ictx->origin_in_use = new_in_use;
1437 ictx->in_use[ictx->origin_in_use] = true;
1438 ictx->origin = new_name;
1439 ictx->origin_changed = true;
1440 finish_origin = false;
1441 EXPECTEOL;
1442 continue;
1443 }
1444 if (finish_include) {
1445 finish_include = false;
1446 EXPECTEOL;
1447 result = pushfile(include_file, new_name, lctx);
1448 if (MANYERRS(lctx, result)) {
1449 SETRESULT(lctx, result);
1450 LOGITFILE(result, include_file);
1451 continue;
1452 } else if (result != ISC_R_SUCCESS) {
1453 LOGITFILE(result, include_file);
1454 goto insist_and_cleanup;
1455 }
1456 ictx = lctx->inc;
1457 ictx->origin_changed = true;
1458 source = isc_lex_getsourcename(lctx->lex);
1459 line = isc_lex_getsourceline(lctx->lex);
1460 POST(line);
1461 continue;
1462 }
1463
1464 /*
1465 * "$" Processing Finished
1466 */
1467
1468 /*
1469 * If we are processing glue and the new name does
1470 * not match the current glue name, commit the glue
1471 * and pop stacks leaving us in 'normal' processing
1472 * state. Linked lists are undone by commit().
1473 */
1474 if (ictx->glue != NULL &&
1475 !dns_name_caseequal(ictx->glue, new_name)) {
1476 result = commit(callbacks, lctx, &glue_list,
1477 ictx->glue, source,
1478 ictx->glue_line);
1479 if (MANYERRS(lctx, result)) {
1480 SETRESULT(lctx, result);
1481 } else if (result != ISC_R_SUCCESS) {
1482 goto insist_and_cleanup;
1483 }
1484 if (ictx->glue_in_use != -1) {
1485 ictx->in_use[ictx->glue_in_use] = false;
1486 }
1487 ictx->glue_in_use = -1;
1488 ictx->glue = NULL;
1489 rdcount = rdcount_save;
1490 rdlcount = rdlcount_save;
1491 target = target_save;
1492 }
1493
1494 /*
1495 * If we are in 'normal' processing state and the new
1496 * name does not match the current name, see if the
1497 * new name is for glue and treat it as such,
1498 * otherwise we have a new name so commit what we
1499 * have.
1500 */
1501 if ((ictx->glue == NULL) &&
1502 (ictx->current == NULL ||
1503 !dns_name_caseequal(ictx->current, new_name)))
1504 {
1505 if (current_has_delegation &&
1506 is_glue(¤t_list, new_name)) {
1507 rdcount_save = rdcount;
1508 rdlcount_save = rdlcount;
1509 target_save = target;
1510 ictx->glue = new_name;
1511 ictx->glue_in_use = new_in_use;
1512 ictx->in_use[ictx->glue_in_use] = true;
1513 } else {
1514 result = commit(callbacks, lctx,
1515 ¤t_list,
1516 ictx->current, source,
1517 ictx->current_line);
1518 if (MANYERRS(lctx, result)) {
1519 SETRESULT(lctx, result);
1520 } else if (result != ISC_R_SUCCESS) {
1521 goto insist_and_cleanup;
1522 }
1523 rdcount = 0;
1524 rdlcount = 0;
1525 if (ictx->current_in_use != -1) {
1526 ictx->in_use
1527 [ictx->current_in_use] =
1528 false;
1529 }
1530 ictx->current_in_use = new_in_use;
1531 ictx->in_use[ictx->current_in_use] =
1532 true;
1533 ictx->current = new_name;
1534 current_has_delegation = false;
1535 isc_buffer_init(&target, target_mem,
1536 target_size);
1537 }
1538 /*
1539 * Check for internal wildcards.
1540 */
1541 if ((lctx->options &
1542 DNS_MASTER_CHECKWILDCARD) != 0) {
1543 check_wildcard(ictx, source, line,
1544 callbacks);
1545 }
1546 }
1547 if (dns_master_isprimary(lctx) &&
1548 !dns_name_issubdomain(new_name, lctx->top)) {
1549 char namebuf[DNS_NAME_FORMATSIZE];
1550 dns_name_format(new_name, namebuf,
1551 sizeof(namebuf));
1552 /*
1553 * Ignore out-of-zone data.
1554 */
1555 (*callbacks->warn)(callbacks,
1556 "%s:%lu: "
1557 "ignoring out-of-zone data "
1558 "(%s)",
1559 source, line, namebuf);
1560 ictx->drop = true;
1561 } else {
1562 ictx->drop = false;
1563 }
1564 } else {
1565 UNEXPECTED_ERROR(__FILE__, __LINE__,
1566 "%s:%lu: isc_lex_gettoken() returned "
1567 "unexpected token type (%d)",
1568 source, line, token.type);
1569 result = ISC_R_UNEXPECTED;
1570 if (MANYERRS(lctx, result)) {
1571 SETRESULT(lctx, result);
1572 LOGIT(result);
1573 continue;
1574 } else {
1575 goto insist_and_cleanup;
1576 }
1577 }
1578
1579 /*
1580 * Find TTL, class and type. Both TTL and class are optional
1581 * and may occur in any order if they exist. TTL and class
1582 * come before type which must exist.
1583 *
1584 * [<TTL>] [<class>] <type> <RDATA>
1585 * [<class>] [<TTL>] <type> <RDATA>
1586 */
1587
1588 type = 0;
1589 rdclass = 0;
1590
1591 GETTOKEN(lctx->lex, 0, &token, initialws);
1592
1593 if (initialws) {
1594 if (token.type == isc_tokentype_eol) {
1595 read_till_eol = false;
1596 continue; /* blank line */
1597 }
1598
1599 if (token.type == isc_tokentype_eof) {
1600 WARNUNEXPECTEDEOF(lctx->lex);
1601 read_till_eol = false;
1602 isc_lex_ungettoken(lctx->lex, &token);
1603 continue;
1604 }
1605
1606 if (ictx->current == NULL) {
1607 (*callbacks->error)(callbacks,
1608 "%s:%lu: no current owner "
1609 "name",
1610 source, line);
1611 result = DNS_R_NOOWNER;
1612 if (MANYERRS(lctx, result)) {
1613 SETRESULT(lctx, result);
1614 read_till_eol = true;
1615 continue;
1616 } else {
1617 goto insist_and_cleanup;
1618 }
1619 }
1620
1621 if (ictx->origin_changed) {
1622 char cbuf[DNS_NAME_FORMATSIZE];
1623 char obuf[DNS_NAME_FORMATSIZE];
1624 dns_name_format(ictx->current, cbuf,
1625 sizeof(cbuf));
1626 dns_name_format(ictx->origin, obuf,
1627 sizeof(obuf));
1628 (*callbacks->warn)(callbacks,
1629 "%s:%lu: record with "
1630 "inherited "
1631 "owner (%s) immediately "
1632 "after "
1633 "$ORIGIN (%s)",
1634 source, line, cbuf, obuf);
1635 }
1636 }
1637
1638 ictx->origin_changed = false;
1639
1640 if (dns_rdataclass_fromtext(&rdclass,
1641 &token.value.as_textregion) ==
1642 ISC_R_SUCCESS)
1643 {
1644 GETTOKEN(lctx->lex, 0, &token, false);
1645 }
1646
1647 explicit_ttl = false;
1648 result = dns_ttl_fromtext(&token.value.as_textregion,
1649 &lctx->ttl);
1650 if (result == ISC_R_SUCCESS) {
1651 limit_ttl(callbacks, source, line, &lctx->ttl);
1652 explicit_ttl = true;
1653 lctx->ttl_known = true;
1654 GETTOKEN(lctx->lex, 0, &token, false);
1655 }
1656
1657 if (token.type != isc_tokentype_string) {
1658 UNEXPECTED_ERROR(__FILE__, __LINE__,
1659 "isc_lex_gettoken() returned "
1660 "unexpected token type");
1661 result = ISC_R_UNEXPECTED;
1662 if (MANYERRS(lctx, result)) {
1663 SETRESULT(lctx, result);
1664 read_till_eol = true;
1665 continue;
1666 } else {
1667 goto insist_and_cleanup;
1668 }
1669 }
1670
1671 if (rdclass == 0 &&
1672 dns_rdataclass_fromtext(&rdclass,
1673 &token.value.as_textregion) ==
1674 ISC_R_SUCCESS)
1675 {
1676 GETTOKEN(lctx->lex, 0, &token, false);
1677 }
1678
1679 if (token.type != isc_tokentype_string) {
1680 UNEXPECTED_ERROR(__FILE__, __LINE__,
1681 "isc_lex_gettoken() returned "
1682 "unexpected token type");
1683 result = ISC_R_UNEXPECTED;
1684 if (MANYERRS(lctx, result)) {
1685 SETRESULT(lctx, result);
1686 read_till_eol = true;
1687 continue;
1688 } else {
1689 goto insist_and_cleanup;
1690 }
1691 }
1692
1693 result = dns_rdatatype_fromtext(&type,
1694 &token.value.as_textregion);
1695 if (result != ISC_R_SUCCESS) {
1696 (*callbacks->warn)(
1697 callbacks, "%s:%lu: unknown RR type '%.*s'",
1698 source, line, token.value.as_textregion.length,
1699 token.value.as_textregion.base);
1700 if (MANYERRS(lctx, result)) {
1701 SETRESULT(lctx, result);
1702 read_till_eol = true;
1703 continue;
1704 } else if (result != ISC_R_SUCCESS) {
1705 goto insist_and_cleanup;
1706 }
1707 }
1708
1709 /*
1710 * If the class specified does not match the zone's class
1711 * print out a error message and exit.
1712 */
1713 if (rdclass != 0 && rdclass != lctx->zclass) {
1714 bad_class:
1715
1716 dns_rdataclass_format(rdclass, classname1,
1717 sizeof(classname1));
1718 dns_rdataclass_format(lctx->zclass, classname2,
1719 sizeof(classname2));
1720 (*callbacks->error)(callbacks,
1721 "%s:%lu: class '%s' != "
1722 "zone class '%s'",
1723 source, line, classname1,
1724 classname2);
1725 result = DNS_R_BADCLASS;
1726 if (MANYERRS(lctx, result)) {
1727 SETRESULT(lctx, result);
1728 read_till_eol = true;
1729 continue;
1730 } else {
1731 goto insist_and_cleanup;
1732 }
1733 }
1734
1735 if (type == dns_rdatatype_ns && ictx->glue == NULL) {
1736 current_has_delegation = true;
1737 }
1738
1739 /*
1740 * RFC1123: MD and MF are not allowed to be loaded from
1741 * master files.
1742 */
1743 if (dns_master_isprimary(lctx) &&
1744 (type == dns_rdatatype_md || type == dns_rdatatype_mf))
1745 {
1746 char typebuf[DNS_RDATATYPE_FORMATSIZE];
1747
1748 result = DNS_R_OBSOLETE;
1749
1750 dns_rdatatype_format(type, typebuf, sizeof(typebuf));
1751 (*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s",
1752 source, line, "type", typebuf,
1753 dns_result_totext(result));
1754 if (MANYERRS(lctx, result)) {
1755 SETRESULT(lctx, result);
1756 } else {
1757 goto insist_and_cleanup;
1758 }
1759 }
1760
1761 /*
1762 * RFC2930: TKEY and TSIG are not allowed to be loaded
1763 * from master files.
1764 */
1765 if (dns_master_isprimary(lctx) && dns_rdatatype_ismeta(type)) {
1766 char typebuf[DNS_RDATATYPE_FORMATSIZE];
1767
1768 result = DNS_R_METATYPE;
1769
1770 dns_rdatatype_format(type, typebuf, sizeof(typebuf));
1771 (*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s",
1772 source, line, "type", typebuf,
1773 dns_result_totext(result));
1774 if (MANYERRS(lctx, result)) {
1775 SETRESULT(lctx, result);
1776 } else {
1777 goto insist_and_cleanup;
1778 }
1779 }
1780
1781 /*
1782 * Find a rdata structure.
1783 */
1784 if (rdcount == rdata_size) {
1785 new_rdata = grow_rdata(rdata_size + RDSZ, rdata,
1786 rdata_size, ¤t_list,
1787 &glue_list, mctx);
1788 if (new_rdata == NULL) {
1789 result = ISC_R_NOMEMORY;
1790 goto log_and_cleanup;
1791 }
1792 rdata_size += RDSZ;
1793 rdata = new_rdata;
1794 }
1795
1796 /*
1797 * Peek at the NS record.
1798 */
1799 if (type == dns_rdatatype_ns &&
1800 lctx->zclass == dns_rdataclass_in &&
1801 (lctx->options & DNS_MASTER_CHECKNS) != 0)
1802 {
1803 GETTOKEN(lctx->lex, 0, &token, false);
1804 result = check_ns(lctx, &token, source, line);
1805 isc_lex_ungettoken(lctx->lex, &token);
1806 if ((lctx->options & DNS_MASTER_FATALNS) != 0) {
1807 if (MANYERRS(lctx, result)) {
1808 SETRESULT(lctx, result);
1809 } else if (result != ISC_R_SUCCESS) {
1810 goto insist_and_cleanup;
1811 }
1812 }
1813 }
1814
1815 /*
1816 * Check owner name.
1817 */
1818 options &= ~DNS_RDATA_CHECKREVERSE;
1819 if ((lctx->options & DNS_MASTER_CHECKNAMES) != 0) {
1820 bool ok;
1821 dns_name_t *name;
1822
1823 name = (ictx->glue != NULL) ? ictx->glue
1824 : ictx->current;
1825 ok = dns_rdata_checkowner(name, lctx->zclass, type,
1826 true);
1827 if (!ok) {
1828 char namebuf[DNS_NAME_FORMATSIZE];
1829 const char *desc;
1830 dns_name_format(name, namebuf, sizeof(namebuf));
1831 result = DNS_R_BADOWNERNAME;
1832 desc = dns_result_totext(result);
1833 if (CHECKNAMESFAIL(lctx->options) ||
1834 type == dns_rdatatype_nsec3) {
1835 (*callbacks->error)(
1836 callbacks, "%s:%lu: %s: %s",
1837 source, line, namebuf, desc);
1838 if (MANYERRS(lctx, result)) {
1839 SETRESULT(lctx, result);
1840 } else {
1841 goto cleanup;
1842 }
1843 } else {
1844 (*callbacks->warn)(
1845 callbacks, "%s:%lu: %s: %s",
1846 source, line, namebuf, desc);
1847 }
1848 }
1849 if (type == dns_rdatatype_ptr &&
1850 !dns_name_isdnssd(name) &&
1851 (dns_name_issubdomain(name, &in_addr_arpa) ||
1852 dns_name_issubdomain(name, &ip6_arpa) ||
1853 dns_name_issubdomain(name, &ip6_int)))
1854 {
1855 options |= DNS_RDATA_CHECKREVERSE;
1856 }
1857 }
1858
1859 /*
1860 * Read rdata contents.
1861 */
1862 dns_rdata_init(&rdata[rdcount]);
1863 target_ft = target;
1864 result = dns_rdata_fromtext(&rdata[rdcount], lctx->zclass, type,
1865 lctx->lex, ictx->origin, options,
1866 lctx->mctx, &target, callbacks);
1867 if (MANYERRS(lctx, result)) {
1868 SETRESULT(lctx, result);
1869 continue;
1870 } else if (result != ISC_R_SUCCESS) {
1871 goto insist_and_cleanup;
1872 }
1873
1874 if (ictx->drop) {
1875 target = target_ft;
1876 continue;
1877 }
1878
1879 if (type == dns_rdatatype_soa &&
1880 (lctx->options & DNS_MASTER_ZONE) != 0 &&
1881 !dns_name_equal(ictx->current, lctx->top))
1882 {
1883 char namebuf[DNS_NAME_FORMATSIZE];
1884 dns_name_format(ictx->current, namebuf,
1885 sizeof(namebuf));
1886 (*callbacks->error)(callbacks,
1887 "%s:%lu: SOA "
1888 "record not at top of zone (%s)",
1889 source, line, namebuf);
1890 result = DNS_R_NOTZONETOP;
1891 if (MANYERRS(lctx, result)) {
1892 SETRESULT(lctx, result);
1893 read_till_eol = true;
1894 target = target_ft;
1895 continue;
1896 } else {
1897 goto insist_and_cleanup;
1898 }
1899 }
1900
1901 if (dns_rdatatype_atparent(type) &&
1902 dns_master_isprimary(lctx) &&
1903 dns_name_equal(ictx->current, lctx->top))
1904 {
1905 char namebuf[DNS_NAME_FORMATSIZE];
1906 char typebuf[DNS_RDATATYPE_FORMATSIZE];
1907
1908 dns_name_format(ictx->current, namebuf,
1909 sizeof(namebuf));
1910 dns_rdatatype_format(type, typebuf, sizeof(typebuf));
1911 (*callbacks->error)(
1912 callbacks,
1913 "%s:%lu: %s record at top of zone (%s)", source,
1914 line, typebuf, namebuf);
1915 result = DNS_R_ATZONETOP;
1916 if (MANYERRS(lctx, result)) {
1917 SETRESULT(lctx, result);
1918 target = target_ft;
1919 continue;
1920 } else {
1921 goto insist_and_cleanup;
1922 }
1923 }
1924
1925 if (type == dns_rdatatype_rrsig || type == dns_rdatatype_sig) {
1926 covers = dns_rdata_covers(&rdata[rdcount]);
1927 } else {
1928 covers = 0;
1929 }
1930
1931 if (!lctx->ttl_known && !lctx->default_ttl_known) {
1932 if (type == dns_rdatatype_soa) {
1933 (*callbacks->warn)(callbacks,
1934 "%s:%lu: no TTL specified; "
1935 "using SOA MINTTL instead",
1936 source, line);
1937 lctx->ttl = dns_soa_getminimum(&rdata[rdcount]);
1938 limit_ttl(callbacks, source, line, &lctx->ttl);
1939 lctx->default_ttl = lctx->ttl;
1940 lctx->default_ttl_known = true;
1941 } else if ((lctx->options & DNS_MASTER_HINT) != 0) {
1942 /*
1943 * Zero TTL's are fine for hints.
1944 */
1945 lctx->ttl = 0;
1946 lctx->default_ttl = lctx->ttl;
1947 lctx->default_ttl_known = true;
1948 } else {
1949 (*callbacks->warn)(callbacks,
1950 "%s:%lu: no TTL specified; "
1951 "zone rejected",
1952 source, line);
1953 result = DNS_R_NOTTL;
1954 if (MANYERRS(lctx, result)) {
1955 SETRESULT(lctx, result);
1956 lctx->ttl = 0;
1957 } else {
1958 goto insist_and_cleanup;
1959 }
1960 }
1961 } else if (!explicit_ttl && lctx->default_ttl_known) {
1962 lctx->ttl = lctx->default_ttl;
1963 } else if (!explicit_ttl && lctx->warn_1035) {
1964 (*callbacks->warn)(callbacks,
1965 "%s:%lu: "
1966 "using RFC1035 TTL semantics",
1967 source, line);
1968 lctx->warn_1035 = false;
1969 }
1970
1971 if (type == dns_rdatatype_rrsig && lctx->warn_sigexpired) {
1972 dns_rdata_rrsig_t sig;
1973 result = dns_rdata_tostruct(&rdata[rdcount], &sig,
1974 NULL);
1975 RUNTIME_CHECK(result == ISC_R_SUCCESS);
1976 if (isc_serial_lt(sig.timeexpire, lctx->now)) {
1977 (*callbacks->warn)(callbacks,
1978 "%s:%lu: "
1979 "signature has expired",
1980 source, line);
1981 lctx->warn_sigexpired = false;
1982 }
1983 }
1984
1985 if ((type == dns_rdatatype_sig || type == dns_rdatatype_nxt) &&
1986 lctx->warn_tcr && dns_master_isprimary(lctx))
1987 {
1988 (*callbacks->warn)(callbacks,
1989 "%s:%lu: old style DNSSEC "
1990 " zone detected",
1991 source, line);
1992 lctx->warn_tcr = false;
1993 }
1994
1995 if ((lctx->options & DNS_MASTER_AGETTL) != 0) {
1996 /*
1997 * Adjust the TTL for $DATE. If the RR has
1998 * already expired, set its TTL to 0. This
1999 * should be okay even if the TTL stretching
2000 * feature is not in effect, because it will
2001 * just be quickly expired by the cache, and the
2002 * way this was written before the patch it
2003 * could potentially add 0 TTLs anyway.
2004 */
2005 if (lctx->ttl < ttl_offset) {
2006 lctx->ttl = 0;
2007 } else {
2008 lctx->ttl -= ttl_offset;
2009 }
2010 }
2011
2012 /*
2013 * Find type in rdatalist.
2014 * If it does not exist create new one and prepend to list
2015 * as this will minimise list traversal.
2016 */
2017 if (ictx->glue != NULL) {
2018 this = ISC_LIST_HEAD(glue_list);
2019 } else {
2020 this = ISC_LIST_HEAD(current_list);
2021 }
2022
2023 while (this != NULL) {
2024 if (this->type == type && this->covers == covers) {
2025 break;
2026 }
2027 this = ISC_LIST_NEXT(this, link);
2028 }
2029
2030 if (this == NULL) {
2031 if (rdlcount == rdatalist_size) {
2032 new_rdatalist = grow_rdatalist(
2033 rdatalist_size + RDLSZ, rdatalist,
2034 rdatalist_size, ¤t_list,
2035 &glue_list, mctx);
2036 if (new_rdatalist == NULL) {
2037 result = ISC_R_NOMEMORY;
2038 goto log_and_cleanup;
2039 }
2040 rdatalist = new_rdatalist;
2041 rdatalist_size += RDLSZ;
2042 }
2043 this = &rdatalist[rdlcount++];
2044 dns_rdatalist_init(this);
2045 this->type = type;
2046 this->covers = covers;
2047 this->rdclass = lctx->zclass;
2048 this->ttl = lctx->ttl;
2049 if (ictx->glue != NULL) {
2050 ISC_LIST_INITANDPREPEND(glue_list, this, link);
2051 } else {
2052 ISC_LIST_INITANDPREPEND(current_list, this,
2053 link);
2054 }
2055 } else if (this->ttl != lctx->ttl) {
2056 (*callbacks->warn)(callbacks,
2057 "%s:%lu: "
2058 "TTL set to prior TTL (%lu)",
2059 source, line, this->ttl);
2060 lctx->ttl = this->ttl;
2061 }
2062
2063 if ((lctx->options & DNS_MASTER_CHECKTTL) != 0 &&
2064 lctx->ttl > lctx->maxttl) {
2065 (callbacks->error)(callbacks,
2066 "dns_master_load: %s:%lu: "
2067 "TTL %d exceeds configured "
2068 "max-zone-ttl %d",
2069 source, line, lctx->ttl,
2070 lctx->maxttl);
2071 result = ISC_R_RANGE;
2072 goto log_and_cleanup;
2073 }
2074
2075 ISC_LIST_APPEND(this->rdata, &rdata[rdcount], link);
2076 if (ictx->glue != NULL) {
2077 ictx->glue_line = line;
2078 } else {
2079 ictx->current_line = line;
2080 }
2081 rdcount++;
2082
2083 /*
2084 * We must have at least 64k as rdlen is 16 bits.
2085 * If we don't commit everything we have so far.
2086 */
2087 if ((target.length - target.used) < MINTSIZ) {
2088 COMMITALL;
2089 }
2090 next_line:;
2091 } while (!done && (lctx->loop_cnt == 0 || loop_cnt++ < lctx->loop_cnt));
2092
2093 /*
2094 * Commit what has not yet been committed.
2095 */
2096 result = commit(callbacks, lctx, ¤t_list, ictx->current, source,
2097 ictx->current_line);
2098 if (MANYERRS(lctx, result)) {
2099 SETRESULT(lctx, result);
2100 } else if (result != ISC_R_SUCCESS) {
2101 goto insist_and_cleanup;
2102 }
2103 result = commit(callbacks, lctx, &glue_list, ictx->glue, source,
2104 ictx->glue_line);
2105 if (MANYERRS(lctx, result)) {
2106 SETRESULT(lctx, result);
2107 } else if (result != ISC_R_SUCCESS) {
2108 goto insist_and_cleanup;
2109 }
2110
2111 if (!done) {
2112 INSIST(lctx->done != NULL && lctx->task != NULL);
2113 result = DNS_R_CONTINUE;
2114 } else if (result == ISC_R_SUCCESS && lctx->result != ISC_R_SUCCESS) {
2115 result = lctx->result;
2116 } else if (result == ISC_R_SUCCESS && lctx->seen_include) {
2117 result = DNS_R_SEENINCLUDE;
2118 }
2119 goto cleanup;
2120
2121 log_and_cleanup:
2122 LOGIT(result);
2123
2124 insist_and_cleanup:
2125 INSIST(result != ISC_R_SUCCESS);
2126
2127 cleanup:
2128 while ((this = ISC_LIST_HEAD(current_list)) != NULL) {
2129 ISC_LIST_UNLINK(current_list, this, link);
2130 }
2131 while ((this = ISC_LIST_HEAD(glue_list)) != NULL) {
2132 ISC_LIST_UNLINK(glue_list, this, link);
2133 }
2134 if (rdatalist != NULL) {
2135 isc_mem_put(mctx, rdatalist,
2136 rdatalist_size * sizeof(*rdatalist));
2137 }
2138 if (rdata != NULL) {
2139 isc_mem_put(mctx, rdata, rdata_size * sizeof(*rdata));
2140 }
2141 if (target_mem != NULL) {
2142 isc_mem_put(mctx, target_mem, target_size);
2143 }
2144 if (include_file != NULL) {
2145 isc_mem_free(mctx, include_file);
2146 }
2147 if (range != NULL) {
2148 isc_mem_free(mctx, range);
2149 }
2150 if (lhs != NULL) {
2151 isc_mem_free(mctx, lhs);
2152 }
2153 if (gtype != NULL) {
2154 isc_mem_free(mctx, gtype);
2155 }
2156 if (rhs != NULL) {
2157 isc_mem_free(mctx, rhs);
2158 }
2159 return (result);
2160 }
2161
2162 static isc_result_t
pushfile(const char * master_file,dns_name_t * origin,dns_loadctx_t * lctx)2163 pushfile(const char *master_file, dns_name_t *origin, dns_loadctx_t *lctx) {
2164 isc_result_t result;
2165 dns_incctx_t *ictx;
2166 dns_incctx_t *newctx = NULL;
2167 isc_region_t r;
2168
2169 REQUIRE(master_file != NULL);
2170 REQUIRE(DNS_LCTX_VALID(lctx));
2171
2172 ictx = lctx->inc;
2173 lctx->seen_include = true;
2174
2175 result = incctx_create(lctx->mctx, origin, &newctx);
2176 if (result != ISC_R_SUCCESS) {
2177 return (result);
2178 }
2179
2180 /*
2181 * Push origin_changed.
2182 */
2183 newctx->origin_changed = ictx->origin_changed;
2184
2185 /* Set current domain. */
2186 if (ictx->glue != NULL || ictx->current != NULL) {
2187 newctx->current_in_use = find_free_name(newctx);
2188 newctx->current = dns_fixedname_name(
2189 &newctx->fixed[newctx->current_in_use]);
2190 newctx->in_use[newctx->current_in_use] = true;
2191 dns_name_toregion(
2192 (ictx->glue != NULL) ? ictx->glue : ictx->current, &r);
2193 dns_name_fromregion(newctx->current, &r);
2194 newctx->drop = ictx->drop;
2195 }
2196
2197 result = (lctx->openfile)(lctx, master_file);
2198 if (result != ISC_R_SUCCESS) {
2199 goto cleanup;
2200 }
2201 newctx->parent = ictx;
2202 lctx->inc = newctx;
2203
2204 if (lctx->include_cb != NULL) {
2205 lctx->include_cb(master_file, lctx->include_arg);
2206 }
2207 return (ISC_R_SUCCESS);
2208
2209 cleanup:
2210 incctx_destroy(lctx->mctx, newctx);
2211 return (result);
2212 }
2213
2214 /*
2215 * Fill/check exists buffer with 'len' bytes. Track remaining bytes to be
2216 * read when incrementally filling the buffer.
2217 */
2218 static inline isc_result_t
read_and_check(bool do_read,isc_buffer_t * buffer,size_t len,FILE * f,uint32_t * totallen)2219 read_and_check(bool do_read, isc_buffer_t *buffer, size_t len, FILE *f,
2220 uint32_t *totallen) {
2221 isc_result_t result;
2222
2223 REQUIRE(totallen != NULL);
2224
2225 if (do_read) {
2226 INSIST(isc_buffer_availablelength(buffer) >= len);
2227 result = isc_stdio_read(isc_buffer_used(buffer), 1, len, f,
2228 NULL);
2229 if (result != ISC_R_SUCCESS) {
2230 return (result);
2231 }
2232 isc_buffer_add(buffer, (unsigned int)len);
2233 if (*totallen < len) {
2234 return (ISC_R_RANGE);
2235 }
2236 *totallen -= (uint32_t)len;
2237 } else if (isc_buffer_remaininglength(buffer) < len) {
2238 return (ISC_R_RANGE);
2239 }
2240
2241 return (ISC_R_SUCCESS);
2242 }
2243
2244 static isc_result_t
load_header(dns_loadctx_t * lctx)2245 load_header(dns_loadctx_t *lctx) {
2246 isc_result_t result = ISC_R_SUCCESS;
2247 dns_masterrawheader_t header;
2248 dns_rdatacallbacks_t *callbacks;
2249 size_t commonlen = sizeof(header.format) + sizeof(header.version);
2250 size_t remainder;
2251 unsigned char data[sizeof(header)];
2252 isc_buffer_t target;
2253
2254 REQUIRE(DNS_LCTX_VALID(lctx));
2255
2256 if (lctx->format != dns_masterformat_raw &&
2257 lctx->format != dns_masterformat_map)
2258 {
2259 return (ISC_R_NOTIMPLEMENTED);
2260 }
2261
2262 callbacks = lctx->callbacks;
2263 dns_master_initrawheader(&header);
2264
2265 INSIST(commonlen <= sizeof(header));
2266 isc_buffer_init(&target, data, sizeof(data));
2267
2268 result = isc_stdio_read(data, 1, commonlen, lctx->f, NULL);
2269 if (result != ISC_R_SUCCESS) {
2270 UNEXPECTED_ERROR(__FILE__, __LINE__,
2271 "isc_stdio_read failed: %s",
2272 isc_result_totext(result));
2273 return (result);
2274 }
2275
2276 isc_buffer_add(&target, (unsigned int)commonlen);
2277 header.format = isc_buffer_getuint32(&target);
2278 if (header.format != lctx->format) {
2279 (*callbacks->error)(callbacks,
2280 "dns_master_load: "
2281 "file format mismatch (not %s)",
2282 lctx->format == dns_masterformat_map ? "map"
2283 : "ra"
2284 "w");
2285 return (ISC_R_NOTIMPLEMENTED);
2286 }
2287
2288 header.version = isc_buffer_getuint32(&target);
2289
2290 switch (header.version) {
2291 case 0:
2292 remainder = sizeof(header.dumptime);
2293 break;
2294 case DNS_RAWFORMAT_VERSION:
2295 remainder = sizeof(header) - commonlen;
2296 break;
2297 default:
2298 (*callbacks->error)(callbacks, "dns_master_load: "
2299 "unsupported file format "
2300 "version");
2301 return (ISC_R_NOTIMPLEMENTED);
2302 }
2303
2304 result = isc_stdio_read(data + commonlen, 1, remainder, lctx->f, NULL);
2305 if (result != ISC_R_SUCCESS) {
2306 UNEXPECTED_ERROR(__FILE__, __LINE__,
2307 "isc_stdio_read failed: %s",
2308 isc_result_totext(result));
2309 return (result);
2310 }
2311
2312 isc_buffer_add(&target, (unsigned int)remainder);
2313 header.dumptime = isc_buffer_getuint32(&target);
2314 if (header.version == DNS_RAWFORMAT_VERSION) {
2315 header.flags = isc_buffer_getuint32(&target);
2316 header.sourceserial = isc_buffer_getuint32(&target);
2317 header.lastxfrin = isc_buffer_getuint32(&target);
2318 }
2319
2320 lctx->first = false;
2321 lctx->header = header;
2322
2323 return (ISC_R_SUCCESS);
2324 }
2325
2326 static isc_result_t
openfile_map(dns_loadctx_t * lctx,const char * master_file)2327 openfile_map(dns_loadctx_t *lctx, const char *master_file) {
2328 isc_result_t result;
2329
2330 result = isc_stdio_open(master_file, "rb", &lctx->f);
2331 if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
2332 UNEXPECTED_ERROR(__FILE__, __LINE__,
2333 "isc_stdio_open() failed: %s",
2334 isc_result_totext(result));
2335 }
2336
2337 return (result);
2338 }
2339
2340 /*
2341 * Load a map format file, using mmap() to access RBT trees directly
2342 */
2343 static isc_result_t
load_map(dns_loadctx_t * lctx)2344 load_map(dns_loadctx_t *lctx) {
2345 isc_result_t result = ISC_R_SUCCESS;
2346 dns_rdatacallbacks_t *callbacks;
2347
2348 REQUIRE(DNS_LCTX_VALID(lctx));
2349
2350 callbacks = lctx->callbacks;
2351
2352 if (lctx->first) {
2353 result = load_header(lctx);
2354 if (result != ISC_R_SUCCESS) {
2355 return (result);
2356 }
2357
2358 result = (*callbacks->deserialize)(
2359 callbacks->deserialize_private, lctx->f,
2360 sizeof(dns_masterrawheader_t));
2361 }
2362
2363 return (result);
2364 }
2365
2366 static isc_result_t
openfile_raw(dns_loadctx_t * lctx,const char * master_file)2367 openfile_raw(dns_loadctx_t *lctx, const char *master_file) {
2368 isc_result_t result;
2369
2370 result = isc_stdio_open(master_file, "rb", &lctx->f);
2371 if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
2372 UNEXPECTED_ERROR(__FILE__, __LINE__,
2373 "isc_stdio_open() failed: %s",
2374 isc_result_totext(result));
2375 }
2376
2377 return (result);
2378 }
2379
2380 static isc_result_t
load_raw(dns_loadctx_t * lctx)2381 load_raw(dns_loadctx_t *lctx) {
2382 isc_result_t result = ISC_R_SUCCESS;
2383 bool done = false;
2384 unsigned int loop_cnt = 0;
2385 dns_rdatacallbacks_t *callbacks;
2386 unsigned char namebuf[DNS_NAME_MAXWIRE];
2387 dns_fixedname_t fixed;
2388 dns_name_t *name;
2389 rdatalist_head_t head, dummy;
2390 dns_rdatalist_t rdatalist;
2391 isc_mem_t *mctx = lctx->mctx;
2392 dns_rdata_t *rdata = NULL;
2393 unsigned int rdata_size = 0;
2394 int target_size = TSIZ;
2395 isc_buffer_t target, buf;
2396 unsigned char *target_mem = NULL;
2397 dns_decompress_t dctx;
2398
2399 callbacks = lctx->callbacks;
2400 dns_decompress_init(&dctx, -1, DNS_DECOMPRESS_NONE);
2401
2402 if (lctx->first) {
2403 result = load_header(lctx);
2404 if (result != ISC_R_SUCCESS) {
2405 return (result);
2406 }
2407 }
2408
2409 ISC_LIST_INIT(head);
2410 ISC_LIST_INIT(dummy);
2411
2412 /*
2413 * Allocate target_size of buffer space. This is greater than twice
2414 * the maximum individual RR data size.
2415 */
2416 target_mem = isc_mem_get(mctx, target_size);
2417 isc_buffer_init(&target, target_mem, target_size);
2418
2419 name = dns_fixedname_initname(&fixed);
2420
2421 /*
2422 * In the following loop, we regard any error fatal regardless of
2423 * whether "MANYERRORS" is set in the context option. This is because
2424 * normal errors should already have been checked at creation time.
2425 * Besides, it is very unlikely that we can recover from an error
2426 * in this format, and so trying to continue parsing erroneous data
2427 * does not really make sense.
2428 */
2429 for (loop_cnt = 0; (lctx->loop_cnt == 0 || loop_cnt < lctx->loop_cnt);
2430 loop_cnt++)
2431 {
2432 unsigned int i, rdcount;
2433 uint16_t namelen;
2434 uint32_t totallen;
2435 size_t minlen, readlen;
2436 bool sequential_read = false;
2437
2438 /* Read the data length */
2439 isc_buffer_clear(&target);
2440 INSIST(isc_buffer_availablelength(&target) >= sizeof(totallen));
2441 result = isc_stdio_read(target.base, 1, sizeof(totallen),
2442 lctx->f, NULL);
2443 if (result == ISC_R_EOF) {
2444 result = ISC_R_SUCCESS;
2445 done = true;
2446 break;
2447 }
2448 if (result != ISC_R_SUCCESS) {
2449 goto cleanup;
2450 }
2451 isc_buffer_add(&target, sizeof(totallen));
2452 totallen = isc_buffer_getuint32(&target);
2453
2454 /*
2455 * Validation: the input data must at least contain the common
2456 * header.
2457 */
2458 minlen = sizeof(totallen) + sizeof(uint16_t) +
2459 sizeof(uint16_t) + sizeof(uint16_t) +
2460 sizeof(uint32_t) + sizeof(uint32_t);
2461 if (totallen < minlen) {
2462 result = ISC_R_RANGE;
2463 goto cleanup;
2464 }
2465 totallen -= sizeof(totallen);
2466
2467 isc_buffer_clear(&target);
2468 if (totallen > isc_buffer_availablelength(&target)) {
2469 /*
2470 * The default buffer size should typically be large
2471 * enough to store the entire RRset. We could try to
2472 * allocate enough space if this is not the case, but
2473 * it might cause a hazardous result when "totallen"
2474 * is forged. Thus, we'd rather take an inefficient
2475 * but robust approach in this atypical case: read
2476 * data step by step, and commit partial data when
2477 * necessary. Note that the buffer must be large
2478 * enough to store the "header part", owner name, and
2479 * at least one rdata (however large it is).
2480 */
2481 sequential_read = true;
2482 readlen = minlen - sizeof(totallen);
2483 } else {
2484 /*
2485 * Typical case. We can read the whole RRset at once
2486 * with the default buffer.
2487 */
2488 readlen = totallen;
2489 }
2490 result = isc_stdio_read(target.base, 1, readlen, lctx->f, NULL);
2491 if (result != ISC_R_SUCCESS) {
2492 goto cleanup;
2493 }
2494 isc_buffer_add(&target, (unsigned int)readlen);
2495 totallen -= (uint32_t)readlen;
2496
2497 /* Construct RRset headers */
2498 dns_rdatalist_init(&rdatalist);
2499 rdatalist.rdclass = isc_buffer_getuint16(&target);
2500 if (lctx->zclass != rdatalist.rdclass) {
2501 result = DNS_R_BADCLASS;
2502 goto cleanup;
2503 }
2504 rdatalist.type = isc_buffer_getuint16(&target);
2505 rdatalist.covers = isc_buffer_getuint16(&target);
2506 rdatalist.ttl = isc_buffer_getuint32(&target);
2507 rdcount = isc_buffer_getuint32(&target);
2508 if (rdcount == 0 || rdcount > 0xffff) {
2509 result = ISC_R_RANGE;
2510 goto cleanup;
2511 }
2512 INSIST(isc_buffer_consumedlength(&target) <= readlen);
2513
2514 /* Owner name: length followed by name */
2515 result = read_and_check(sequential_read, &target,
2516 sizeof(namelen), lctx->f, &totallen);
2517 if (result != ISC_R_SUCCESS) {
2518 goto cleanup;
2519 }
2520 namelen = isc_buffer_getuint16(&target);
2521 if (namelen > sizeof(namebuf)) {
2522 result = ISC_R_RANGE;
2523 goto cleanup;
2524 }
2525
2526 result = read_and_check(sequential_read, &target, namelen,
2527 lctx->f, &totallen);
2528 if (result != ISC_R_SUCCESS) {
2529 goto cleanup;
2530 }
2531
2532 isc_buffer_setactive(&target, (unsigned int)namelen);
2533 result = dns_name_fromwire(name, &target, &dctx, 0, NULL);
2534 if (result != ISC_R_SUCCESS) {
2535 goto cleanup;
2536 }
2537
2538 if ((lctx->options & DNS_MASTER_CHECKTTL) != 0 &&
2539 rdatalist.ttl > lctx->maxttl) {
2540 (callbacks->error)(callbacks,
2541 "dns_master_load: "
2542 "TTL %d exceeds configured "
2543 "max-zone-ttl %d",
2544 rdatalist.ttl, lctx->maxttl);
2545 result = ISC_R_RANGE;
2546 goto cleanup;
2547 }
2548
2549 /* Rdata contents. */
2550 if (rdcount > rdata_size) {
2551 dns_rdata_t *new_rdata = NULL;
2552
2553 new_rdata = grow_rdata(rdcount + RDSZ, rdata,
2554 rdata_size, &head, &dummy, mctx);
2555 if (new_rdata == NULL) {
2556 result = ISC_R_NOMEMORY;
2557 goto cleanup;
2558 }
2559 rdata_size = rdcount + RDSZ;
2560 rdata = new_rdata;
2561 }
2562
2563 continue_read:
2564 for (i = 0; i < rdcount; i++) {
2565 uint16_t rdlen;
2566
2567 dns_rdata_init(&rdata[i]);
2568
2569 if (sequential_read &&
2570 isc_buffer_availablelength(&target) < MINTSIZ) {
2571 unsigned int j;
2572
2573 INSIST(i > 0); /* detect an infinite loop */
2574
2575 /* Partial Commit. */
2576 ISC_LIST_APPEND(head, &rdatalist, link);
2577 result = commit(callbacks, lctx, &head, name,
2578 NULL, 0);
2579 for (j = 0; j < i; j++) {
2580 ISC_LIST_UNLINK(rdatalist.rdata,
2581 &rdata[j], link);
2582 dns_rdata_reset(&rdata[j]);
2583 }
2584 if (result != ISC_R_SUCCESS) {
2585 goto cleanup;
2586 }
2587
2588 /* Rewind the buffer and continue */
2589 isc_buffer_clear(&target);
2590
2591 rdcount -= i;
2592
2593 goto continue_read;
2594 }
2595
2596 /* rdata length */
2597 result = read_and_check(sequential_read, &target,
2598 sizeof(rdlen), lctx->f,
2599 &totallen);
2600 if (result != ISC_R_SUCCESS) {
2601 goto cleanup;
2602 }
2603 rdlen = isc_buffer_getuint16(&target);
2604
2605 /* rdata */
2606 result = read_and_check(sequential_read, &target, rdlen,
2607 lctx->f, &totallen);
2608 if (result != ISC_R_SUCCESS) {
2609 goto cleanup;
2610 }
2611 isc_buffer_setactive(&target, (unsigned int)rdlen);
2612 /*
2613 * It is safe to have the source active region and
2614 * the target available region be the same if
2615 * decompression is disabled (see dctx above) and we
2616 * are not downcasing names (options == 0).
2617 */
2618 isc_buffer_init(&buf, isc_buffer_current(&target),
2619 (unsigned int)rdlen);
2620 result = dns_rdata_fromwire(
2621 &rdata[i], rdatalist.rdclass, rdatalist.type,
2622 &target, &dctx, 0, &buf);
2623 if (result != ISC_R_SUCCESS) {
2624 goto cleanup;
2625 }
2626 ISC_LIST_APPEND(rdatalist.rdata, &rdata[i], link);
2627 }
2628
2629 /*
2630 * Sanity check. Still having remaining space is not
2631 * necessarily critical, but it very likely indicates broken
2632 * or malformed data.
2633 */
2634 if (isc_buffer_remaininglength(&target) != 0 || totallen != 0) {
2635 result = ISC_R_RANGE;
2636 goto cleanup;
2637 }
2638
2639 ISC_LIST_APPEND(head, &rdatalist, link);
2640
2641 /* Commit this RRset. rdatalist will be unlinked. */
2642 result = commit(callbacks, lctx, &head, name, NULL, 0);
2643
2644 for (i = 0; i < rdcount; i++) {
2645 ISC_LIST_UNLINK(rdatalist.rdata, &rdata[i], link);
2646 dns_rdata_reset(&rdata[i]);
2647 }
2648
2649 if (result != ISC_R_SUCCESS) {
2650 goto cleanup;
2651 }
2652 }
2653
2654 if (!done) {
2655 INSIST(lctx->done != NULL && lctx->task != NULL);
2656 result = DNS_R_CONTINUE;
2657 } else if (result == ISC_R_SUCCESS && lctx->result != ISC_R_SUCCESS) {
2658 result = lctx->result;
2659 }
2660
2661 if (result == ISC_R_SUCCESS && callbacks->rawdata != NULL) {
2662 (*callbacks->rawdata)(callbacks->zone, &lctx->header);
2663 }
2664
2665 cleanup:
2666 if (rdata != NULL) {
2667 isc_mem_put(mctx, rdata, rdata_size * sizeof(*rdata));
2668 }
2669 if (target_mem != NULL) {
2670 isc_mem_put(mctx, target_mem, target_size);
2671 }
2672 if (result != ISC_R_SUCCESS && result != DNS_R_CONTINUE) {
2673 (*callbacks->error)(callbacks, "dns_master_load: %s",
2674 dns_result_totext(result));
2675 }
2676
2677 return (result);
2678 }
2679
2680 isc_result_t
dns_master_loadfile(const char * master_file,dns_name_t * top,dns_name_t * origin,dns_rdataclass_t zclass,unsigned int options,uint32_t resign,dns_rdatacallbacks_t * callbacks,dns_masterincludecb_t include_cb,void * include_arg,isc_mem_t * mctx,dns_masterformat_t format,dns_ttl_t maxttl)2681 dns_master_loadfile(const char *master_file, dns_name_t *top,
2682 dns_name_t *origin, dns_rdataclass_t zclass,
2683 unsigned int options, uint32_t resign,
2684 dns_rdatacallbacks_t *callbacks,
2685 dns_masterincludecb_t include_cb, void *include_arg,
2686 isc_mem_t *mctx, dns_masterformat_t format,
2687 dns_ttl_t maxttl) {
2688 dns_loadctx_t *lctx = NULL;
2689 isc_result_t result;
2690
2691 result = loadctx_create(format, mctx, options, resign, top, zclass,
2692 origin, callbacks, NULL, NULL, NULL, include_cb,
2693 include_arg, NULL, &lctx);
2694 if (result != ISC_R_SUCCESS) {
2695 return (result);
2696 }
2697
2698 lctx->maxttl = maxttl;
2699
2700 result = (lctx->openfile)(lctx, master_file);
2701 if (result != ISC_R_SUCCESS) {
2702 goto cleanup;
2703 }
2704
2705 result = (lctx->load)(lctx);
2706 INSIST(result != DNS_R_CONTINUE);
2707
2708 cleanup:
2709 dns_loadctx_detach(&lctx);
2710 return (result);
2711 }
2712
2713 isc_result_t
dns_master_loadfileinc(const char * master_file,dns_name_t * top,dns_name_t * origin,dns_rdataclass_t zclass,unsigned int options,uint32_t resign,dns_rdatacallbacks_t * callbacks,isc_task_t * task,dns_loaddonefunc_t done,void * done_arg,dns_loadctx_t ** lctxp,dns_masterincludecb_t include_cb,void * include_arg,isc_mem_t * mctx,dns_masterformat_t format,uint32_t maxttl)2714 dns_master_loadfileinc(const char *master_file, dns_name_t *top,
2715 dns_name_t *origin, dns_rdataclass_t zclass,
2716 unsigned int options, uint32_t resign,
2717 dns_rdatacallbacks_t *callbacks, isc_task_t *task,
2718 dns_loaddonefunc_t done, void *done_arg,
2719 dns_loadctx_t **lctxp, dns_masterincludecb_t include_cb,
2720 void *include_arg, isc_mem_t *mctx,
2721 dns_masterformat_t format, uint32_t maxttl) {
2722 dns_loadctx_t *lctx = NULL;
2723 isc_result_t result;
2724
2725 REQUIRE(task != NULL);
2726 REQUIRE(done != NULL);
2727
2728 result = loadctx_create(format, mctx, options, resign, top, zclass,
2729 origin, callbacks, task, done, done_arg,
2730 include_cb, include_arg, NULL, &lctx);
2731 if (result != ISC_R_SUCCESS) {
2732 return (result);
2733 }
2734
2735 lctx->maxttl = maxttl;
2736
2737 result = (lctx->openfile)(lctx, master_file);
2738 if (result != ISC_R_SUCCESS) {
2739 goto cleanup;
2740 }
2741
2742 result = task_send(lctx);
2743 if (result == ISC_R_SUCCESS) {
2744 dns_loadctx_attach(lctx, lctxp);
2745 return (DNS_R_CONTINUE);
2746 }
2747
2748 cleanup:
2749 dns_loadctx_detach(&lctx);
2750 return (result);
2751 }
2752
2753 isc_result_t
dns_master_loadstream(FILE * stream,dns_name_t * top,dns_name_t * origin,dns_rdataclass_t zclass,unsigned int options,dns_rdatacallbacks_t * callbacks,isc_mem_t * mctx)2754 dns_master_loadstream(FILE *stream, dns_name_t *top, dns_name_t *origin,
2755 dns_rdataclass_t zclass, unsigned int options,
2756 dns_rdatacallbacks_t *callbacks, isc_mem_t *mctx) {
2757 isc_result_t result;
2758 dns_loadctx_t *lctx = NULL;
2759
2760 REQUIRE(stream != NULL);
2761
2762 result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
2763 zclass, origin, callbacks, NULL, NULL, NULL,
2764 NULL, NULL, NULL, &lctx);
2765 if (result != ISC_R_SUCCESS) {
2766 goto cleanup;
2767 }
2768
2769 result = isc_lex_openstream(lctx->lex, stream);
2770 if (result != ISC_R_SUCCESS) {
2771 goto cleanup;
2772 }
2773
2774 result = (lctx->load)(lctx);
2775 INSIST(result != DNS_R_CONTINUE);
2776
2777 cleanup:
2778 if (lctx != NULL) {
2779 dns_loadctx_detach(&lctx);
2780 }
2781 return (result);
2782 }
2783
2784 isc_result_t
dns_master_loadstreaminc(FILE * stream,dns_name_t * top,dns_name_t * origin,dns_rdataclass_t zclass,unsigned int options,dns_rdatacallbacks_t * callbacks,isc_task_t * task,dns_loaddonefunc_t done,void * done_arg,dns_loadctx_t ** lctxp,isc_mem_t * mctx)2785 dns_master_loadstreaminc(FILE *stream, dns_name_t *top, dns_name_t *origin,
2786 dns_rdataclass_t zclass, unsigned int options,
2787 dns_rdatacallbacks_t *callbacks, isc_task_t *task,
2788 dns_loaddonefunc_t done, void *done_arg,
2789 dns_loadctx_t **lctxp, isc_mem_t *mctx) {
2790 isc_result_t result;
2791 dns_loadctx_t *lctx = NULL;
2792
2793 REQUIRE(stream != NULL);
2794 REQUIRE(task != NULL);
2795 REQUIRE(done != NULL);
2796
2797 result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
2798 zclass, origin, callbacks, task, done, done_arg,
2799 NULL, NULL, NULL, &lctx);
2800 if (result != ISC_R_SUCCESS) {
2801 goto cleanup;
2802 }
2803
2804 result = isc_lex_openstream(lctx->lex, stream);
2805 if (result != ISC_R_SUCCESS) {
2806 goto cleanup;
2807 }
2808
2809 result = task_send(lctx);
2810 if (result == ISC_R_SUCCESS) {
2811 dns_loadctx_attach(lctx, lctxp);
2812 return (DNS_R_CONTINUE);
2813 }
2814
2815 cleanup:
2816 if (lctx != NULL) {
2817 dns_loadctx_detach(&lctx);
2818 }
2819 return (result);
2820 }
2821
2822 isc_result_t
dns_master_loadbuffer(isc_buffer_t * buffer,dns_name_t * top,dns_name_t * origin,dns_rdataclass_t zclass,unsigned int options,dns_rdatacallbacks_t * callbacks,isc_mem_t * mctx)2823 dns_master_loadbuffer(isc_buffer_t *buffer, dns_name_t *top, dns_name_t *origin,
2824 dns_rdataclass_t zclass, unsigned int options,
2825 dns_rdatacallbacks_t *callbacks, isc_mem_t *mctx) {
2826 isc_result_t result;
2827 dns_loadctx_t *lctx = NULL;
2828
2829 REQUIRE(buffer != NULL);
2830
2831 result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
2832 zclass, origin, callbacks, NULL, NULL, NULL,
2833 NULL, NULL, NULL, &lctx);
2834 if (result != ISC_R_SUCCESS) {
2835 return (result);
2836 }
2837
2838 result = isc_lex_openbuffer(lctx->lex, buffer);
2839 if (result != ISC_R_SUCCESS) {
2840 goto cleanup;
2841 }
2842
2843 result = (lctx->load)(lctx);
2844 INSIST(result != DNS_R_CONTINUE);
2845
2846 cleanup:
2847 dns_loadctx_detach(&lctx);
2848 return (result);
2849 }
2850
2851 isc_result_t
dns_master_loadbufferinc(isc_buffer_t * buffer,dns_name_t * top,dns_name_t * origin,dns_rdataclass_t zclass,unsigned int options,dns_rdatacallbacks_t * callbacks,isc_task_t * task,dns_loaddonefunc_t done,void * done_arg,dns_loadctx_t ** lctxp,isc_mem_t * mctx)2852 dns_master_loadbufferinc(isc_buffer_t *buffer, dns_name_t *top,
2853 dns_name_t *origin, dns_rdataclass_t zclass,
2854 unsigned int options, dns_rdatacallbacks_t *callbacks,
2855 isc_task_t *task, dns_loaddonefunc_t done,
2856 void *done_arg, dns_loadctx_t **lctxp,
2857 isc_mem_t *mctx) {
2858 isc_result_t result;
2859 dns_loadctx_t *lctx = NULL;
2860
2861 REQUIRE(buffer != NULL);
2862 REQUIRE(task != NULL);
2863 REQUIRE(done != NULL);
2864
2865 result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
2866 zclass, origin, callbacks, task, done, done_arg,
2867 NULL, NULL, NULL, &lctx);
2868 if (result != ISC_R_SUCCESS) {
2869 return (result);
2870 }
2871
2872 result = isc_lex_openbuffer(lctx->lex, buffer);
2873 if (result != ISC_R_SUCCESS) {
2874 goto cleanup;
2875 }
2876
2877 result = task_send(lctx);
2878 if (result == ISC_R_SUCCESS) {
2879 dns_loadctx_attach(lctx, lctxp);
2880 return (DNS_R_CONTINUE);
2881 }
2882
2883 cleanup:
2884 dns_loadctx_detach(&lctx);
2885 return (result);
2886 }
2887
2888 isc_result_t
dns_master_loadlexer(isc_lex_t * lex,dns_name_t * top,dns_name_t * origin,dns_rdataclass_t zclass,unsigned int options,dns_rdatacallbacks_t * callbacks,isc_mem_t * mctx)2889 dns_master_loadlexer(isc_lex_t *lex, dns_name_t *top, dns_name_t *origin,
2890 dns_rdataclass_t zclass, unsigned int options,
2891 dns_rdatacallbacks_t *callbacks, isc_mem_t *mctx) {
2892 isc_result_t result;
2893 dns_loadctx_t *lctx = NULL;
2894
2895 REQUIRE(lex != NULL);
2896
2897 result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
2898 zclass, origin, callbacks, NULL, NULL, NULL,
2899 NULL, NULL, lex, &lctx);
2900 if (result != ISC_R_SUCCESS) {
2901 return (result);
2902 }
2903
2904 result = (lctx->load)(lctx);
2905 INSIST(result != DNS_R_CONTINUE);
2906
2907 dns_loadctx_detach(&lctx);
2908 return (result);
2909 }
2910
2911 isc_result_t
dns_master_loadlexerinc(isc_lex_t * lex,dns_name_t * top,dns_name_t * origin,dns_rdataclass_t zclass,unsigned int options,dns_rdatacallbacks_t * callbacks,isc_task_t * task,dns_loaddonefunc_t done,void * done_arg,dns_loadctx_t ** lctxp,isc_mem_t * mctx)2912 dns_master_loadlexerinc(isc_lex_t *lex, dns_name_t *top, dns_name_t *origin,
2913 dns_rdataclass_t zclass, unsigned int options,
2914 dns_rdatacallbacks_t *callbacks, isc_task_t *task,
2915 dns_loaddonefunc_t done, void *done_arg,
2916 dns_loadctx_t **lctxp, isc_mem_t *mctx) {
2917 isc_result_t result;
2918 dns_loadctx_t *lctx = NULL;
2919
2920 REQUIRE(lex != NULL);
2921 REQUIRE(task != NULL);
2922 REQUIRE(done != NULL);
2923
2924 result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
2925 zclass, origin, callbacks, task, done, done_arg,
2926 NULL, NULL, lex, &lctx);
2927 if (result != ISC_R_SUCCESS) {
2928 return (result);
2929 }
2930
2931 result = task_send(lctx);
2932 if (result == ISC_R_SUCCESS) {
2933 dns_loadctx_attach(lctx, lctxp);
2934 return (DNS_R_CONTINUE);
2935 }
2936
2937 dns_loadctx_detach(&lctx);
2938 return (result);
2939 }
2940
2941 /*
2942 * Grow the slab of dns_rdatalist_t structures.
2943 * Re-link glue and current list.
2944 */
2945 static dns_rdatalist_t *
grow_rdatalist(int new_len,dns_rdatalist_t * oldlist,int old_len,rdatalist_head_t * current,rdatalist_head_t * glue,isc_mem_t * mctx)2946 grow_rdatalist(int new_len, dns_rdatalist_t *oldlist, int old_len,
2947 rdatalist_head_t *current, rdatalist_head_t *glue,
2948 isc_mem_t *mctx) {
2949 dns_rdatalist_t *newlist;
2950 int rdlcount = 0;
2951 ISC_LIST(dns_rdatalist_t) save;
2952 dns_rdatalist_t *this;
2953
2954 newlist = isc_mem_get(mctx, new_len * sizeof(*newlist));
2955 if (newlist == NULL) {
2956 return (NULL);
2957 }
2958
2959 ISC_LIST_INIT(save);
2960 while ((this = ISC_LIST_HEAD(*current)) != NULL) {
2961 ISC_LIST_UNLINK(*current, this, link);
2962 ISC_LIST_APPEND(save, this, link);
2963 }
2964 while ((this = ISC_LIST_HEAD(save)) != NULL) {
2965 ISC_LIST_UNLINK(save, this, link);
2966 INSIST(rdlcount < new_len);
2967 newlist[rdlcount] = *this;
2968 ISC_LIST_APPEND(*current, &newlist[rdlcount], link);
2969 rdlcount++;
2970 }
2971
2972 ISC_LIST_INIT(save);
2973 while ((this = ISC_LIST_HEAD(*glue)) != NULL) {
2974 ISC_LIST_UNLINK(*glue, this, link);
2975 ISC_LIST_APPEND(save, this, link);
2976 }
2977 while ((this = ISC_LIST_HEAD(save)) != NULL) {
2978 ISC_LIST_UNLINK(save, this, link);
2979 INSIST(rdlcount < new_len);
2980 newlist[rdlcount] = *this;
2981 ISC_LIST_APPEND(*glue, &newlist[rdlcount], link);
2982 rdlcount++;
2983 }
2984
2985 INSIST(rdlcount == old_len);
2986 if (oldlist != NULL) {
2987 isc_mem_put(mctx, oldlist, old_len * sizeof(*oldlist));
2988 }
2989 return (newlist);
2990 }
2991
2992 /*
2993 * Grow the slab of rdata structs.
2994 * Re-link the current and glue chains.
2995 */
2996 static dns_rdata_t *
grow_rdata(int new_len,dns_rdata_t * oldlist,int old_len,rdatalist_head_t * current,rdatalist_head_t * glue,isc_mem_t * mctx)2997 grow_rdata(int new_len, dns_rdata_t *oldlist, int old_len,
2998 rdatalist_head_t *current, rdatalist_head_t *glue, isc_mem_t *mctx) {
2999 dns_rdata_t *newlist;
3000 int rdcount = 0;
3001 ISC_LIST(dns_rdata_t) save;
3002 dns_rdatalist_t *this;
3003 dns_rdata_t *rdata;
3004
3005 newlist = isc_mem_get(mctx, new_len * sizeof(*newlist));
3006 if (newlist == NULL) {
3007 return (NULL);
3008 }
3009 memset(newlist, 0, new_len * sizeof(*newlist));
3010
3011 /*
3012 * Copy current relinking.
3013 */
3014 this = ISC_LIST_HEAD(*current);
3015 while (this != NULL) {
3016 ISC_LIST_INIT(save);
3017 while ((rdata = ISC_LIST_HEAD(this->rdata)) != NULL) {
3018 ISC_LIST_UNLINK(this->rdata, rdata, link);
3019 ISC_LIST_APPEND(save, rdata, link);
3020 }
3021 while ((rdata = ISC_LIST_HEAD(save)) != NULL) {
3022 ISC_LIST_UNLINK(save, rdata, link);
3023 INSIST(rdcount < new_len);
3024 newlist[rdcount] = *rdata;
3025 ISC_LIST_APPEND(this->rdata, &newlist[rdcount], link);
3026 rdcount++;
3027 }
3028 this = ISC_LIST_NEXT(this, link);
3029 }
3030
3031 /*
3032 * Copy glue relinking.
3033 */
3034 this = ISC_LIST_HEAD(*glue);
3035 while (this != NULL) {
3036 ISC_LIST_INIT(save);
3037 while ((rdata = ISC_LIST_HEAD(this->rdata)) != NULL) {
3038 ISC_LIST_UNLINK(this->rdata, rdata, link);
3039 ISC_LIST_APPEND(save, rdata, link);
3040 }
3041 while ((rdata = ISC_LIST_HEAD(save)) != NULL) {
3042 ISC_LIST_UNLINK(save, rdata, link);
3043 INSIST(rdcount < new_len);
3044 newlist[rdcount] = *rdata;
3045 ISC_LIST_APPEND(this->rdata, &newlist[rdcount], link);
3046 rdcount++;
3047 }
3048 this = ISC_LIST_NEXT(this, link);
3049 }
3050 INSIST(rdcount == old_len || rdcount == 0);
3051 if (oldlist != NULL) {
3052 isc_mem_put(mctx, oldlist, old_len * sizeof(*oldlist));
3053 }
3054 return (newlist);
3055 }
3056
3057 static uint32_t
resign_fromlist(dns_rdatalist_t * this,dns_loadctx_t * lctx)3058 resign_fromlist(dns_rdatalist_t *this, dns_loadctx_t *lctx) {
3059 dns_rdata_t *rdata;
3060 dns_rdata_rrsig_t sig;
3061 uint32_t when;
3062
3063 rdata = ISC_LIST_HEAD(this->rdata);
3064 INSIST(rdata != NULL);
3065 (void)dns_rdata_tostruct(rdata, &sig, NULL);
3066 if (isc_serial_gt(sig.timesigned, lctx->now)) {
3067 when = lctx->now;
3068 } else {
3069 when = sig.timeexpire - lctx->resign;
3070 }
3071
3072 rdata = ISC_LIST_NEXT(rdata, link);
3073 while (rdata != NULL) {
3074 (void)dns_rdata_tostruct(rdata, &sig, NULL);
3075 if (isc_serial_gt(sig.timesigned, lctx->now)) {
3076 when = lctx->now;
3077 } else if (sig.timeexpire - lctx->resign < when) {
3078 when = sig.timeexpire - lctx->resign;
3079 }
3080 rdata = ISC_LIST_NEXT(rdata, link);
3081 }
3082 return (when);
3083 }
3084
3085 /*
3086 * Convert each element from a rdatalist_t to rdataset then call commit.
3087 * Unlink each element as we go.
3088 */
3089
3090 static isc_result_t
commit(dns_rdatacallbacks_t * callbacks,dns_loadctx_t * lctx,rdatalist_head_t * head,dns_name_t * owner,const char * source,unsigned int line)3091 commit(dns_rdatacallbacks_t *callbacks, dns_loadctx_t *lctx,
3092 rdatalist_head_t *head, dns_name_t *owner, const char *source,
3093 unsigned int line) {
3094 dns_rdatalist_t *this;
3095 dns_rdataset_t dataset;
3096 isc_result_t result;
3097 char namebuf[DNS_NAME_FORMATSIZE];
3098 void (*error)(struct dns_rdatacallbacks *, const char *, ...);
3099
3100 this = ISC_LIST_HEAD(*head);
3101 error = callbacks->error;
3102
3103 if (this == NULL) {
3104 return (ISC_R_SUCCESS);
3105 }
3106 do {
3107 dns_rdataset_init(&dataset);
3108 RUNTIME_CHECK(dns_rdatalist_tordataset(this, &dataset) ==
3109 ISC_R_SUCCESS);
3110 dataset.trust = dns_trust_ultimate;
3111 /*
3112 * If this is a secure dynamic zone set the re-signing time.
3113 */
3114 if (dataset.type == dns_rdatatype_rrsig &&
3115 (lctx->options & DNS_MASTER_RESIGN) != 0)
3116 {
3117 dataset.attributes |= DNS_RDATASETATTR_RESIGN;
3118 dataset.resign = resign_fromlist(this, lctx);
3119 }
3120 result = ((*callbacks->add)(callbacks->add_private, owner,
3121 &dataset));
3122 if (result == ISC_R_NOMEMORY) {
3123 (*error)(callbacks, "dns_master_load: %s",
3124 dns_result_totext(result));
3125 } else if (result != ISC_R_SUCCESS) {
3126 dns_name_format(owner, namebuf, sizeof(namebuf));
3127 if (source != NULL) {
3128 (*error)(callbacks, "%s: %s:%lu: %s: %s",
3129 "dns_master_load", source, line,
3130 namebuf, dns_result_totext(result));
3131 } else {
3132 (*error)(callbacks, "%s: %s: %s",
3133 "dns_master_load", namebuf,
3134 dns_result_totext(result));
3135 }
3136 }
3137 if (MANYERRS(lctx, result)) {
3138 SETRESULT(lctx, result);
3139 } else if (result != ISC_R_SUCCESS) {
3140 return (result);
3141 }
3142 ISC_LIST_UNLINK(*head, this, link);
3143 this = ISC_LIST_HEAD(*head);
3144 } while (this != NULL);
3145 return (ISC_R_SUCCESS);
3146 }
3147
3148 /*
3149 * Returns true if one of the NS rdata's contains 'owner'.
3150 */
3151
3152 static bool
is_glue(rdatalist_head_t * head,dns_name_t * owner)3153 is_glue(rdatalist_head_t *head, dns_name_t *owner) {
3154 dns_rdatalist_t *this;
3155 dns_rdata_t *rdata;
3156 isc_region_t region;
3157 dns_name_t name;
3158
3159 /*
3160 * Find NS rrset.
3161 */
3162 this = ISC_LIST_HEAD(*head);
3163 while (this != NULL) {
3164 if (this->type == dns_rdatatype_ns) {
3165 break;
3166 }
3167 this = ISC_LIST_NEXT(this, link);
3168 }
3169 if (this == NULL) {
3170 return (false);
3171 }
3172
3173 rdata = ISC_LIST_HEAD(this->rdata);
3174 while (rdata != NULL) {
3175 dns_name_init(&name, NULL);
3176 dns_rdata_toregion(rdata, ®ion);
3177 dns_name_fromregion(&name, ®ion);
3178 if (dns_name_equal(&name, owner)) {
3179 return (true);
3180 }
3181 rdata = ISC_LIST_NEXT(rdata, link);
3182 }
3183 return (false);
3184 }
3185
3186 static void
load_quantum(isc_task_t * task,isc_event_t * event)3187 load_quantum(isc_task_t *task, isc_event_t *event) {
3188 isc_result_t result;
3189 dns_loadctx_t *lctx;
3190
3191 REQUIRE(event != NULL);
3192 lctx = event->ev_arg;
3193 REQUIRE(DNS_LCTX_VALID(lctx));
3194
3195 if (atomic_load_acquire(&lctx->canceled)) {
3196 result = ISC_R_CANCELED;
3197 } else {
3198 result = (lctx->load)(lctx);
3199 }
3200 if (result == DNS_R_CONTINUE) {
3201 event->ev_arg = lctx;
3202 isc_task_send(task, &event);
3203 } else {
3204 (lctx->done)(lctx->done_arg, result);
3205 isc_event_free(&event);
3206 dns_loadctx_detach(&lctx);
3207 }
3208 }
3209
3210 static isc_result_t
task_send(dns_loadctx_t * lctx)3211 task_send(dns_loadctx_t *lctx) {
3212 isc_event_t *event;
3213
3214 event = isc_event_allocate(lctx->mctx, NULL, DNS_EVENT_MASTERQUANTUM,
3215 load_quantum, lctx, sizeof(*event));
3216 isc_task_send(lctx->task, &event);
3217 return (ISC_R_SUCCESS);
3218 }
3219
3220 void
dns_loadctx_cancel(dns_loadctx_t * lctx)3221 dns_loadctx_cancel(dns_loadctx_t *lctx) {
3222 REQUIRE(DNS_LCTX_VALID(lctx));
3223
3224 atomic_store_release(&lctx->canceled, true);
3225 }
3226
3227 void
dns_master_initrawheader(dns_masterrawheader_t * header)3228 dns_master_initrawheader(dns_masterrawheader_t *header) {
3229 memset(header, 0, sizeof(dns_masterrawheader_t));
3230 }
3231