2 * Copyright (C) 2004, 2005, 2007-2009, 2011, 2013 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000-2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
18 /* $Id: diff.c,v 1.26 2011/03/25 23:53:02 each Exp $ */
26 #include <isc/buffer.h>
29 #include <isc/string.h>
35 #include <dns/rdataclass.h>
36 #include <dns/rdatalist.h>
37 #include <dns/rdataset.h>
38 #include <dns/rdatastruct.h>
39 #include <dns/rdatatype.h>
40 #include <dns/result.h>
44 if (result != ISC_R_SUCCESS) goto failure; \
47 #define DIFF_COMMON_LOGARGS \
48 dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_DIFF
50 static dns_rdatatype_t
51 rdata_covers(dns_rdata_t *rdata) {
52 return (rdata->type == dns_rdatatype_rrsig ?
53 dns_rdata_covers(rdata) : 0);
57 dns_difftuple_create(isc_mem_t *mctx,
58 dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
59 dns_rdata_t *rdata, dns_difftuple_t **tp)
65 REQUIRE(tp != NULL && *tp == NULL);
68 * Create a new tuple. The variable-size wire-format name data and
69 * rdata immediately follow the dns_difftuple_t structure
72 size = sizeof(*t) + name->length + rdata->length;
73 t = isc_mem_allocate(mctx, size);
75 return (ISC_R_NOMEMORY);
77 isc_mem_attach(mctx, &t->mctx);
80 datap = (unsigned char *)(t + 1);
82 memcpy(datap, name->ndata, name->length);
83 dns_name_init(&t->name, NULL);
84 dns_name_clone(name, &t->name);
85 t->name.ndata = datap;
86 datap += name->length;
90 memcpy(datap, rdata->data, rdata->length);
91 dns_rdata_init(&t->rdata);
92 dns_rdata_clone(rdata, &t->rdata);
93 t->rdata.data = datap;
94 datap += rdata->length;
96 ISC_LINK_INIT(&t->rdata, link);
97 ISC_LINK_INIT(t, link);
98 t->magic = DNS_DIFFTUPLE_MAGIC;
100 INSIST(datap == (unsigned char *)t + size);
103 return (ISC_R_SUCCESS);
107 dns_difftuple_free(dns_difftuple_t **tp) {
108 dns_difftuple_t *t = *tp;
111 REQUIRE(DNS_DIFFTUPLE_VALID(t));
113 dns_name_invalidate(&t->name);
116 isc_mem_free(mctx, t);
117 isc_mem_detach(&mctx);
122 dns_difftuple_copy(dns_difftuple_t *orig, dns_difftuple_t **copyp) {
123 return (dns_difftuple_create(orig->mctx, orig->op, &orig->name,
124 orig->ttl, &orig->rdata, copyp));
128 dns_diff_init(isc_mem_t *mctx, dns_diff_t *diff) {
131 ISC_LIST_INIT(diff->tuples);
132 diff->magic = DNS_DIFF_MAGIC;
136 dns_diff_clear(dns_diff_t *diff) {
138 REQUIRE(DNS_DIFF_VALID(diff));
139 while ((t = ISC_LIST_HEAD(diff->tuples)) != NULL) {
140 ISC_LIST_UNLINK(diff->tuples, t, link);
141 dns_difftuple_free(&t);
143 ENSURE(ISC_LIST_EMPTY(diff->tuples));
147 dns_diff_append(dns_diff_t *diff, dns_difftuple_t **tuplep)
149 ISC_LIST_APPEND(diff->tuples, *tuplep, link);
153 /* XXX this is O(N) */
156 dns_diff_appendminimal(dns_diff_t *diff, dns_difftuple_t **tuplep)
158 dns_difftuple_t *ot, *next_ot;
160 REQUIRE(DNS_DIFF_VALID(diff));
161 REQUIRE(DNS_DIFFTUPLE_VALID(*tuplep));
164 * Look for an existing tuple with the same owner name,
165 * rdata, and TTL. If we are doing an addition and find a
166 * deletion or vice versa, remove both the old and the
167 * new tuple since they cancel each other out (assuming
168 * that we never delete nonexistent data or add existing
171 * If we find an old update of the same kind as
172 * the one we are doing, there must be a programming
173 * error. We report it but try to continue anyway.
175 for (ot = ISC_LIST_HEAD(diff->tuples); ot != NULL;
178 next_ot = ISC_LIST_NEXT(ot, link);
179 if (dns_name_equal(&ot->name, &(*tuplep)->name) &&
180 dns_rdata_compare(&ot->rdata, &(*tuplep)->rdata) == 0 &&
181 ot->ttl == (*tuplep)->ttl)
183 ISC_LIST_UNLINK(diff->tuples, ot, link);
184 if ((*tuplep)->op == ot->op) {
185 UNEXPECTED_ERROR(__FILE__, __LINE__,
186 "unexpected non-minimal diff");
188 dns_difftuple_free(tuplep);
190 dns_difftuple_free(&ot);
195 if (*tuplep != NULL) {
196 ISC_LIST_APPEND(diff->tuples, *tuplep, link);
200 ENSURE(*tuplep == NULL);
204 setresign(dns_rdataset_t *modified, isc_uint32_t delta) {
205 dns_rdata_t rdata = DNS_RDATA_INIT;
206 dns_rdata_rrsig_t sig;
210 result = dns_rdataset_first(modified);
211 INSIST(result == ISC_R_SUCCESS);
212 dns_rdataset_current(modified, &rdata);
213 (void)dns_rdata_tostruct(&rdata, &sig, NULL);
214 if ((rdata.flags & DNS_RDATA_OFFLINE) != 0)
217 when = sig.timeexpire - delta;
218 dns_rdata_reset(&rdata);
220 result = dns_rdataset_next(modified);
221 while (result == ISC_R_SUCCESS) {
222 dns_rdataset_current(modified, &rdata);
223 (void)dns_rdata_tostruct(&rdata, &sig, NULL);
224 if ((rdata.flags & DNS_RDATA_OFFLINE) != 0) {
227 if (when == 0 || sig.timeexpire - delta < when)
228 when = sig.timeexpire - delta;
230 dns_rdata_reset(&rdata);
231 result = dns_rdataset_next(modified);
233 INSIST(result == ISC_R_NOMORE);
238 diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver,
242 dns_dbnode_t *node = NULL;
244 char namebuf[DNS_NAME_FORMATSIZE];
245 char typebuf[DNS_RDATATYPE_FORMATSIZE];
246 char classbuf[DNS_RDATACLASS_FORMATSIZE];
248 REQUIRE(DNS_DIFF_VALID(diff));
249 REQUIRE(DNS_DB_VALID(db));
251 t = ISC_LIST_HEAD(diff->tuples);
255 INSIST(node == NULL);
259 * We create the node if it does not exist.
260 * This will cause an empty node to be created if the diff
261 * contains a deletion of an RR at a nonexistent name,
262 * but such diffs should never be created in the first
266 while (t != NULL && dns_name_equal(&t->name, name)) {
267 dns_rdatatype_t type, covers;
271 dns_rdataset_t ardataset;
272 dns_rdataset_t *modified = NULL;
275 type = t->rdata.type;
276 covers = rdata_covers(&t->rdata);
279 * Collect a contiguous set of updates with
280 * the same operation (add/delete) and RR type
281 * into a single rdatalist so that the
282 * database rrset merging/subtraction code
283 * can work more efficiently than if each
284 * RR were merged into / subtracted from
285 * the database separately.
287 * This is done by linking rdata structures from the
288 * diff into "rdatalist". This uses the rdata link
289 * field, not the diff link field, so the structure
290 * of the diff itself is not affected.
295 rdl.rdclass = t->rdata.rdclass;
297 ISC_LIST_INIT(rdl.rdata);
298 ISC_LINK_INIT(&rdl, link);
301 if (type != dns_rdatatype_nsec3 &&
302 covers != dns_rdatatype_nsec3)
303 CHECK(dns_db_findnode(db, name, ISC_TRUE,
306 CHECK(dns_db_findnsec3node(db, name, ISC_TRUE,
310 dns_name_equal(&t->name, name) &&
312 t->rdata.type == type &&
313 rdata_covers(&t->rdata) == covers)
315 dns_name_format(name, namebuf, sizeof(namebuf));
316 dns_rdatatype_format(t->rdata.type, typebuf,
318 dns_rdataclass_format(t->rdata.rdclass,
321 if (t->ttl != rdl.ttl && warn)
322 isc_log_write(DIFF_COMMON_LOGARGS,
324 "'%s/%s/%s': TTL differs in "
325 "rdataset, adjusting "
327 namebuf, typebuf, classbuf,
328 (unsigned long) t->ttl,
329 (unsigned long) rdl.ttl);
330 ISC_LIST_APPEND(rdl.rdata, &t->rdata, link);
331 t = ISC_LIST_NEXT(t, link);
335 * Convert the rdatalist into a rdataset.
337 dns_rdataset_init(&rds);
338 CHECK(dns_rdatalist_tordataset(&rdl, &rds));
339 if (rds.type == dns_rdatatype_rrsig)
341 case DNS_DIFFOP_ADDRESIGN:
342 case DNS_DIFFOP_DELRESIGN:
343 modified = &ardataset;
344 dns_rdataset_init(modified);
349 rds.trust = dns_trust_ultimate;
352 * Merge the rdataset into the database.
356 case DNS_DIFFOP_ADDRESIGN:
357 result = dns_db_addrdataset(db, node, ver,
365 case DNS_DIFFOP_DELRESIGN:
366 result = dns_db_subtractrdataset(db, node, ver,
375 if (result == ISC_R_SUCCESS) {
376 if (modified != NULL) {
377 isc_stdtime_t resign;
378 resign = setresign(modified,
380 dns_db_setsigningtime(db, modified,
382 if (diff->resign == 0 &&
383 (op == DNS_DIFFOP_ADDRESIGN ||
384 op == DNS_DIFFOP_DELRESIGN))
392 } else if (result == DNS_R_UNCHANGED) {
394 * This will not happen when executing a
395 * dynamic update, because that code will
396 * generate strictly minimal diffs.
397 * It may happen when receiving an IXFR
398 * from a server that is not as careful.
399 * Issue a warning and continue.
402 char classbuf[DNS_RDATATYPE_FORMATSIZE];
403 char namebuf[DNS_NAME_FORMATSIZE];
405 dns_name_format(dns_db_origin(db),
408 dns_rdataclass_format(dns_db_class(db),
411 isc_log_write(DIFF_COMMON_LOGARGS,
413 "%s/%s: dns_diff_apply: "
414 "update with no effect",
417 } else if (result == DNS_R_NXRRSET) {
422 if (modified != NULL &&
423 dns_rdataset_isassociated(modified))
424 dns_rdataset_disassociate(modified);
427 dns_db_detachnode(db, &node);
428 if (modified != NULL &&
429 dns_rdataset_isassociated(modified))
430 dns_rdataset_disassociate(modified);
433 return (ISC_R_SUCCESS);
437 dns_db_detachnode(db, &node);
442 dns_diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) {
443 return (diff_apply(diff, db, ver, ISC_TRUE));
447 dns_diff_applysilently(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) {
448 return (diff_apply(diff, db, ver, ISC_FALSE));
451 /* XXX this duplicates lots of code in diff_apply(). */
454 dns_diff_load(dns_diff_t *diff, dns_addrdatasetfunc_t addfunc,
460 REQUIRE(DNS_DIFF_VALID(diff));
462 t = ISC_LIST_HEAD(diff->tuples);
467 while (t != NULL && dns_name_equal(&t->name, name)) {
468 dns_rdatatype_t type, covers;
474 type = t->rdata.type;
475 covers = rdata_covers(&t->rdata);
479 rdl.rdclass = t->rdata.rdclass;
481 ISC_LIST_INIT(rdl.rdata);
482 ISC_LINK_INIT(&rdl, link);
484 while (t != NULL && dns_name_equal(&t->name, name) &&
485 t->op == op && t->rdata.type == type &&
486 rdata_covers(&t->rdata) == covers)
488 ISC_LIST_APPEND(rdl.rdata, &t->rdata, link);
489 t = ISC_LIST_NEXT(t, link);
493 * Convert the rdatalist into a rdataset.
495 dns_rdataset_init(&rds);
496 CHECK(dns_rdatalist_tordataset(&rdl, &rds));
497 rds.trust = dns_trust_ultimate;
499 INSIST(op == DNS_DIFFOP_ADD);
500 result = (*addfunc)(add_private, name, &rds);
501 if (result == DNS_R_UNCHANGED) {
502 isc_log_write(DIFF_COMMON_LOGARGS,
505 "update with no effect");
506 } else if (result == ISC_R_SUCCESS ||
507 result == DNS_R_NXRRSET) {
516 result = ISC_R_SUCCESS;
522 * XXX uses qsort(); a merge sort would be more natural for lists,
523 * and perhaps safer wrt thread stack overflow.
526 dns_diff_sort(dns_diff_t *diff, dns_diff_compare_func *compare) {
527 unsigned int length = 0;
531 REQUIRE(DNS_DIFF_VALID(diff));
533 for (p = ISC_LIST_HEAD(diff->tuples);
535 p = ISC_LIST_NEXT(p, link))
538 return (ISC_R_SUCCESS);
539 v = isc_mem_get(diff->mctx, length * sizeof(dns_difftuple_t *));
541 return (ISC_R_NOMEMORY);
542 for (i = 0; i < length; i++) {
543 p = ISC_LIST_HEAD(diff->tuples);
545 ISC_LIST_UNLINK(diff->tuples, p, link);
547 INSIST(ISC_LIST_HEAD(diff->tuples) == NULL);
548 qsort(v, length, sizeof(v[0]), compare);
549 for (i = 0; i < length; i++) {
550 ISC_LIST_APPEND(diff->tuples, v[i], link);
552 isc_mem_put(diff->mctx, v, length * sizeof(dns_difftuple_t *));
553 return (ISC_R_SUCCESS);
558 * Create an rdataset containing the single RR of the given
559 * tuple. The caller must allocate the rdata, rdataset and
560 * an rdatalist structure for it to refer to.
564 diff_tuple_tordataset(dns_difftuple_t *t, dns_rdata_t *rdata,
565 dns_rdatalist_t *rdl, dns_rdataset_t *rds)
567 REQUIRE(DNS_DIFFTUPLE_VALID(t));
568 REQUIRE(rdl != NULL);
569 REQUIRE(rds != NULL);
571 rdl->type = t->rdata.type;
572 rdl->rdclass = t->rdata.rdclass;
574 ISC_LIST_INIT(rdl->rdata);
575 ISC_LINK_INIT(rdl, link);
576 dns_rdataset_init(rds);
577 ISC_LINK_INIT(rdata, link);
578 dns_rdata_clone(&t->rdata, rdata);
579 ISC_LIST_APPEND(rdl->rdata, rdata, link);
580 return (dns_rdatalist_tordataset(rdl, rds));
584 dns_diff_print(dns_diff_t *diff, FILE *file) {
588 unsigned int size = 2048;
589 const char *op = NULL;
591 REQUIRE(DNS_DIFF_VALID(diff));
593 mem = isc_mem_get(diff->mctx, size);
595 return (ISC_R_NOMEMORY);
597 for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
598 t = ISC_LIST_NEXT(t, link))
605 dns_rdata_t rd = DNS_RDATA_INIT;
607 result = diff_tuple_tordataset(t, &rd, &rdl, &rds);
608 if (result != ISC_R_SUCCESS) {
609 UNEXPECTED_ERROR(__FILE__, __LINE__,
610 "diff_tuple_tordataset failed: %s",
611 dns_result_totext(result));
612 result = ISC_R_UNEXPECTED;
616 isc_buffer_init(&buf, mem, size);
617 result = dns_rdataset_totext(&rds, &t->name,
618 ISC_FALSE, ISC_FALSE, &buf);
620 if (result == ISC_R_NOSPACE) {
621 isc_mem_put(diff->mctx, mem, size);
623 mem = isc_mem_get(diff->mctx, size);
625 result = ISC_R_NOMEMORY;
631 if (result != ISC_R_SUCCESS)
634 * Get rid of final newline.
636 INSIST(buf.used >= 1 &&
637 ((char *) buf.base)[buf.used-1] == '\n');
640 isc_buffer_usedregion(&buf, &r);
642 case DNS_DIFFOP_EXISTS: op = "exists"; break;
643 case DNS_DIFFOP_ADD: op = "add"; break;
644 case DNS_DIFFOP_DEL: op = "del"; break;
645 case DNS_DIFFOP_ADDRESIGN: op = "add re-sign"; break;
646 case DNS_DIFFOP_DELRESIGN: op = "del re-sign"; break;
649 fprintf(file, "%s %.*s\n", op, (int) r.length,
652 isc_log_write(DIFF_COMMON_LOGARGS, ISC_LOG_DEBUG(7),
653 "%s %.*s", op, (int) r.length,
656 result = ISC_R_SUCCESS;
659 isc_mem_put(diff->mctx, mem, size);