1 /* $NetBSD: diff.c,v 1.8 2023/01/25 21:43:30 christos Exp $ */
2
3 /*
4 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
5 *
6 * SPDX-License-Identifier: MPL-2.0
7 *
8 * This Source Code Form is subject to the terms of the Mozilla Public
9 * License, v. 2.0. If a copy of the MPL was not distributed with this
10 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
11 *
12 * See the COPYRIGHT file distributed with this work for additional
13 * information regarding copyright ownership.
14 */
15
16 /*! \file */
17
18 #include <inttypes.h>
19 #include <stdbool.h>
20 #include <stdlib.h>
21
22 #include <isc/buffer.h>
23 #include <isc/file.h>
24 #include <isc/mem.h>
25 #include <isc/print.h>
26 #include <isc/string.h>
27 #include <isc/util.h>
28
29 #include <dns/db.h>
30 #include <dns/diff.h>
31 #include <dns/log.h>
32 #include <dns/rdataclass.h>
33 #include <dns/rdatalist.h>
34 #include <dns/rdataset.h>
35 #include <dns/rdatastruct.h>
36 #include <dns/rdatatype.h>
37 #include <dns/result.h>
38 #include <dns/time.h>
39
40 #define CHECK(op) \
41 do { \
42 result = (op); \
43 if (result != ISC_R_SUCCESS) \
44 goto failure; \
45 } while (0)
46
47 #define DIFF_COMMON_LOGARGS \
48 dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_DIFF
49
50 static dns_rdatatype_t
rdata_covers(dns_rdata_t * rdata)51 rdata_covers(dns_rdata_t *rdata) {
52 return (rdata->type == dns_rdatatype_rrsig ? dns_rdata_covers(rdata)
53 : 0);
54 }
55
56 isc_result_t
dns_difftuple_create(isc_mem_t * mctx,dns_diffop_t op,const dns_name_t * name,dns_ttl_t ttl,dns_rdata_t * rdata,dns_difftuple_t ** tp)57 dns_difftuple_create(isc_mem_t *mctx, dns_diffop_t op, const dns_name_t *name,
58 dns_ttl_t ttl, dns_rdata_t *rdata, dns_difftuple_t **tp) {
59 dns_difftuple_t *t;
60 unsigned int size;
61 unsigned char *datap;
62
63 REQUIRE(tp != NULL && *tp == NULL);
64
65 /*
66 * Create a new tuple. The variable-size wire-format name data and
67 * rdata immediately follow the dns_difftuple_t structure
68 * in memory.
69 */
70 size = sizeof(*t) + name->length + rdata->length;
71 t = isc_mem_allocate(mctx, size);
72 t->mctx = NULL;
73 isc_mem_attach(mctx, &t->mctx);
74 t->op = op;
75
76 datap = (unsigned char *)(t + 1);
77
78 memmove(datap, name->ndata, name->length);
79 dns_name_init(&t->name, NULL);
80 dns_name_clone(name, &t->name);
81 t->name.ndata = datap;
82 datap += name->length;
83
84 t->ttl = ttl;
85
86 dns_rdata_init(&t->rdata);
87 dns_rdata_clone(rdata, &t->rdata);
88 if (rdata->data != NULL) {
89 memmove(datap, rdata->data, rdata->length);
90 t->rdata.data = datap;
91 datap += rdata->length;
92 } else {
93 t->rdata.data = NULL;
94 INSIST(rdata->length == 0);
95 }
96
97 ISC_LINK_INIT(&t->rdata, link);
98 ISC_LINK_INIT(t, link);
99 t->magic = DNS_DIFFTUPLE_MAGIC;
100
101 INSIST(datap == (unsigned char *)t + size);
102
103 *tp = t;
104 return (ISC_R_SUCCESS);
105 }
106
107 void
dns_difftuple_free(dns_difftuple_t ** tp)108 dns_difftuple_free(dns_difftuple_t **tp) {
109 dns_difftuple_t *t = *tp;
110 *tp = NULL;
111 isc_mem_t *mctx;
112
113 REQUIRE(DNS_DIFFTUPLE_VALID(t));
114
115 dns_name_invalidate(&t->name);
116 t->magic = 0;
117 mctx = t->mctx;
118 isc_mem_free(mctx, t);
119 isc_mem_detach(&mctx);
120 }
121
122 isc_result_t
dns_difftuple_copy(dns_difftuple_t * orig,dns_difftuple_t ** copyp)123 dns_difftuple_copy(dns_difftuple_t *orig, dns_difftuple_t **copyp) {
124 return (dns_difftuple_create(orig->mctx, orig->op, &orig->name,
125 orig->ttl, &orig->rdata, copyp));
126 }
127
128 void
dns_diff_init(isc_mem_t * mctx,dns_diff_t * diff)129 dns_diff_init(isc_mem_t *mctx, dns_diff_t *diff) {
130 diff->mctx = mctx;
131 ISC_LIST_INIT(diff->tuples);
132 diff->magic = DNS_DIFF_MAGIC;
133 }
134
135 void
dns_diff_clear(dns_diff_t * diff)136 dns_diff_clear(dns_diff_t *diff) {
137 dns_difftuple_t *t;
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);
142 }
143 ENSURE(ISC_LIST_EMPTY(diff->tuples));
144 }
145
146 void
dns_diff_append(dns_diff_t * diff,dns_difftuple_t ** tuplep)147 dns_diff_append(dns_diff_t *diff, dns_difftuple_t **tuplep) {
148 ISC_LIST_APPEND(diff->tuples, *tuplep, link);
149 *tuplep = NULL;
150 }
151
152 /* XXX this is O(N) */
153
154 void
dns_diff_appendminimal(dns_diff_t * diff,dns_difftuple_t ** tuplep)155 dns_diff_appendminimal(dns_diff_t *diff, dns_difftuple_t **tuplep) {
156 dns_difftuple_t *ot, *next_ot;
157
158 REQUIRE(DNS_DIFF_VALID(diff));
159 REQUIRE(DNS_DIFFTUPLE_VALID(*tuplep));
160
161 /*
162 * Look for an existing tuple with the same owner name,
163 * rdata, and TTL. If we are doing an addition and find a
164 * deletion or vice versa, remove both the old and the
165 * new tuple since they cancel each other out (assuming
166 * that we never delete nonexistent data or add existing
167 * data).
168 *
169 * If we find an old update of the same kind as
170 * the one we are doing, there must be a programming
171 * error. We report it but try to continue anyway.
172 */
173 for (ot = ISC_LIST_HEAD(diff->tuples); ot != NULL; ot = next_ot) {
174 next_ot = ISC_LIST_NEXT(ot, link);
175 if (dns_name_caseequal(&ot->name, &(*tuplep)->name) &&
176 dns_rdata_compare(&ot->rdata, &(*tuplep)->rdata) == 0 &&
177 ot->ttl == (*tuplep)->ttl)
178 {
179 ISC_LIST_UNLINK(diff->tuples, ot, link);
180 if ((*tuplep)->op == ot->op) {
181 UNEXPECTED_ERROR(__FILE__, __LINE__,
182 "unexpected non-minimal diff");
183 } else {
184 dns_difftuple_free(tuplep);
185 }
186 dns_difftuple_free(&ot);
187 break;
188 }
189 }
190
191 if (*tuplep != NULL) {
192 ISC_LIST_APPEND(diff->tuples, *tuplep, link);
193 *tuplep = NULL;
194 }
195 }
196
197 static isc_stdtime_t
setresign(dns_rdataset_t * modified)198 setresign(dns_rdataset_t *modified) {
199 dns_rdata_t rdata = DNS_RDATA_INIT;
200 dns_rdata_rrsig_t sig;
201 int64_t when;
202 isc_result_t result;
203
204 result = dns_rdataset_first(modified);
205 INSIST(result == ISC_R_SUCCESS);
206 dns_rdataset_current(modified, &rdata);
207 (void)dns_rdata_tostruct(&rdata, &sig, NULL);
208 if ((rdata.flags & DNS_RDATA_OFFLINE) != 0) {
209 when = 0;
210 } else {
211 when = dns_time64_from32(sig.timeexpire);
212 }
213 dns_rdata_reset(&rdata);
214
215 result = dns_rdataset_next(modified);
216 while (result == ISC_R_SUCCESS) {
217 dns_rdataset_current(modified, &rdata);
218 (void)dns_rdata_tostruct(&rdata, &sig, NULL);
219 if ((rdata.flags & DNS_RDATA_OFFLINE) != 0) {
220 goto next_rr;
221 }
222 if (when == 0 || dns_time64_from32(sig.timeexpire) < when) {
223 when = dns_time64_from32(sig.timeexpire);
224 }
225 next_rr:
226 dns_rdata_reset(&rdata);
227 result = dns_rdataset_next(modified);
228 }
229 INSIST(result == ISC_R_NOMORE);
230 return ((isc_stdtime_t)when);
231 }
232
233 static void
getownercase(dns_rdataset_t * rdataset,dns_name_t * name)234 getownercase(dns_rdataset_t *rdataset, dns_name_t *name) {
235 if (dns_rdataset_isassociated(rdataset)) {
236 dns_rdataset_getownercase(rdataset, name);
237 }
238 }
239
240 static void
setownercase(dns_rdataset_t * rdataset,const dns_name_t * name)241 setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
242 if (dns_rdataset_isassociated(rdataset)) {
243 dns_rdataset_setownercase(rdataset, name);
244 }
245 }
246
247 static isc_result_t
diff_apply(dns_diff_t * diff,dns_db_t * db,dns_dbversion_t * ver,bool warn)248 diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver, bool warn) {
249 dns_difftuple_t *t;
250 dns_dbnode_t *node = NULL;
251 isc_result_t result;
252 char namebuf[DNS_NAME_FORMATSIZE];
253 char typebuf[DNS_RDATATYPE_FORMATSIZE];
254 char classbuf[DNS_RDATACLASS_FORMATSIZE];
255
256 REQUIRE(DNS_DIFF_VALID(diff));
257 REQUIRE(DNS_DB_VALID(db));
258
259 t = ISC_LIST_HEAD(diff->tuples);
260 while (t != NULL) {
261 dns_name_t *name;
262
263 INSIST(node == NULL);
264 name = &t->name;
265 /*
266 * Find the node.
267 * We create the node if it does not exist.
268 * This will cause an empty node to be created if the diff
269 * contains a deletion of an RR at a nonexistent name,
270 * but such diffs should never be created in the first
271 * place.
272 */
273
274 while (t != NULL && dns_name_equal(&t->name, name)) {
275 dns_rdatatype_t type, covers;
276 dns_diffop_t op;
277 dns_rdatalist_t rdl;
278 dns_rdataset_t rds;
279 dns_rdataset_t ardataset;
280 unsigned int options;
281
282 op = t->op;
283 type = t->rdata.type;
284 covers = rdata_covers(&t->rdata);
285
286 /*
287 * Collect a contiguous set of updates with
288 * the same operation (add/delete) and RR type
289 * into a single rdatalist so that the
290 * database rrset merging/subtraction code
291 * can work more efficiently than if each
292 * RR were merged into / subtracted from
293 * the database separately.
294 *
295 * This is done by linking rdata structures from the
296 * diff into "rdatalist". This uses the rdata link
297 * field, not the diff link field, so the structure
298 * of the diff itself is not affected.
299 */
300
301 dns_rdatalist_init(&rdl);
302 rdl.type = type;
303 rdl.covers = covers;
304 rdl.rdclass = t->rdata.rdclass;
305 rdl.ttl = t->ttl;
306
307 node = NULL;
308 if (type != dns_rdatatype_nsec3 &&
309 covers != dns_rdatatype_nsec3)
310 {
311 CHECK(dns_db_findnode(db, name, true, &node));
312 } else {
313 CHECK(dns_db_findnsec3node(db, name, true,
314 &node));
315 }
316
317 while (t != NULL && dns_name_equal(&t->name, name) &&
318 t->op == op && t->rdata.type == type &&
319 rdata_covers(&t->rdata) == covers)
320 {
321 /*
322 * Remember the add name for
323 * dns_rdataset_setownercase.
324 */
325 name = &t->name;
326 if (t->ttl != rdl.ttl && warn) {
327 dns_name_format(name, namebuf,
328 sizeof(namebuf));
329 dns_rdatatype_format(t->rdata.type,
330 typebuf,
331 sizeof(typebuf));
332 dns_rdataclass_format(t->rdata.rdclass,
333 classbuf,
334 sizeof(classbuf));
335 isc_log_write(DIFF_COMMON_LOGARGS,
336 ISC_LOG_WARNING,
337 "'%s/%s/%s': TTL differs "
338 "in "
339 "rdataset, adjusting "
340 "%lu -> %lu",
341 namebuf, typebuf,
342 classbuf,
343 (unsigned long)t->ttl,
344 (unsigned long)rdl.ttl);
345 }
346 ISC_LIST_APPEND(rdl.rdata, &t->rdata, link);
347 t = ISC_LIST_NEXT(t, link);
348 }
349
350 /*
351 * Convert the rdatalist into a rdataset.
352 */
353 dns_rdataset_init(&rds);
354 dns_rdataset_init(&ardataset);
355 CHECK(dns_rdatalist_tordataset(&rdl, &rds));
356 rds.trust = dns_trust_ultimate;
357
358 /*
359 * Merge the rdataset into the database.
360 */
361 switch (op) {
362 case DNS_DIFFOP_ADD:
363 case DNS_DIFFOP_ADDRESIGN:
364 options = DNS_DBADD_MERGE | DNS_DBADD_EXACT |
365 DNS_DBADD_EXACTTTL;
366 result = dns_db_addrdataset(db, node, ver, 0,
367 &rds, options,
368 &ardataset);
369 break;
370 case DNS_DIFFOP_DEL:
371 case DNS_DIFFOP_DELRESIGN:
372 options = DNS_DBSUB_EXACT | DNS_DBSUB_WANTOLD;
373 result = dns_db_subtractrdataset(db, node, ver,
374 &rds, options,
375 &ardataset);
376 break;
377 default:
378 UNREACHABLE();
379 }
380
381 if (result == ISC_R_SUCCESS) {
382 if (rds.type == dns_rdatatype_rrsig &&
383 (op == DNS_DIFFOP_DELRESIGN ||
384 op == DNS_DIFFOP_ADDRESIGN))
385 {
386 isc_stdtime_t resign;
387 resign = setresign(&ardataset);
388 dns_db_setsigningtime(db, &ardataset,
389 resign);
390 }
391 if (op == DNS_DIFFOP_ADD ||
392 op == DNS_DIFFOP_ADDRESIGN)
393 {
394 setownercase(&ardataset, name);
395 }
396 if (op == DNS_DIFFOP_DEL ||
397 op == DNS_DIFFOP_DELRESIGN)
398 {
399 getownercase(&ardataset, name);
400 }
401 } else if (result == DNS_R_UNCHANGED) {
402 /*
403 * This will not happen when executing a
404 * dynamic update, because that code will
405 * generate strictly minimal diffs.
406 * It may happen when receiving an IXFR
407 * from a server that is not as careful.
408 * Issue a warning and continue.
409 */
410 if (warn) {
411 dns_name_format(dns_db_origin(db),
412 namebuf,
413 sizeof(namebuf));
414 dns_rdataclass_format(dns_db_class(db),
415 classbuf,
416 sizeof(classbuf));
417 isc_log_write(DIFF_COMMON_LOGARGS,
418 ISC_LOG_WARNING,
419 "%s/%s: dns_diff_apply: "
420 "update with no effect",
421 namebuf, classbuf);
422 }
423 if (op == DNS_DIFFOP_ADD ||
424 op == DNS_DIFFOP_ADDRESIGN)
425 {
426 setownercase(&ardataset, name);
427 }
428 if (op == DNS_DIFFOP_DEL ||
429 op == DNS_DIFFOP_DELRESIGN)
430 {
431 getownercase(&ardataset, name);
432 }
433 } else if (result == DNS_R_NXRRSET) {
434 /*
435 * OK.
436 */
437 if (op == DNS_DIFFOP_DEL ||
438 op == DNS_DIFFOP_DELRESIGN)
439 {
440 getownercase(&ardataset, name);
441 }
442 if (dns_rdataset_isassociated(&ardataset)) {
443 dns_rdataset_disassociate(&ardataset);
444 }
445 } else {
446 if (dns_rdataset_isassociated(&ardataset)) {
447 dns_rdataset_disassociate(&ardataset);
448 }
449 CHECK(result);
450 }
451 dns_db_detachnode(db, &node);
452 if (dns_rdataset_isassociated(&ardataset)) {
453 dns_rdataset_disassociate(&ardataset);
454 }
455 }
456 }
457 return (ISC_R_SUCCESS);
458
459 failure:
460 if (node != NULL) {
461 dns_db_detachnode(db, &node);
462 }
463 return (result);
464 }
465
466 isc_result_t
dns_diff_apply(dns_diff_t * diff,dns_db_t * db,dns_dbversion_t * ver)467 dns_diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) {
468 return (diff_apply(diff, db, ver, true));
469 }
470
471 isc_result_t
dns_diff_applysilently(dns_diff_t * diff,dns_db_t * db,dns_dbversion_t * ver)472 dns_diff_applysilently(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) {
473 return (diff_apply(diff, db, ver, false));
474 }
475
476 /* XXX this duplicates lots of code in diff_apply(). */
477
478 isc_result_t
dns_diff_load(dns_diff_t * diff,dns_addrdatasetfunc_t addfunc,void * add_private)479 dns_diff_load(dns_diff_t *diff, dns_addrdatasetfunc_t addfunc,
480 void *add_private) {
481 dns_difftuple_t *t;
482 isc_result_t result;
483
484 REQUIRE(DNS_DIFF_VALID(diff));
485
486 t = ISC_LIST_HEAD(diff->tuples);
487 while (t != NULL) {
488 dns_name_t *name;
489
490 name = &t->name;
491 while (t != NULL && dns_name_caseequal(&t->name, name)) {
492 dns_rdatatype_t type, covers;
493 dns_diffop_t op;
494 dns_rdatalist_t rdl;
495 dns_rdataset_t rds;
496
497 op = t->op;
498 type = t->rdata.type;
499 covers = rdata_covers(&t->rdata);
500
501 dns_rdatalist_init(&rdl);
502 rdl.type = type;
503 rdl.covers = covers;
504 rdl.rdclass = t->rdata.rdclass;
505 rdl.ttl = t->ttl;
506
507 while (t != NULL &&
508 dns_name_caseequal(&t->name, name) &&
509 t->op == op && t->rdata.type == type &&
510 rdata_covers(&t->rdata) == covers)
511 {
512 ISC_LIST_APPEND(rdl.rdata, &t->rdata, link);
513 t = ISC_LIST_NEXT(t, link);
514 }
515
516 /*
517 * Convert the rdatalist into a rdataset.
518 */
519 dns_rdataset_init(&rds);
520 CHECK(dns_rdatalist_tordataset(&rdl, &rds));
521 rds.trust = dns_trust_ultimate;
522
523 INSIST(op == DNS_DIFFOP_ADD);
524 result = (*addfunc)(add_private, name, &rds);
525 if (result == DNS_R_UNCHANGED) {
526 isc_log_write(DIFF_COMMON_LOGARGS,
527 ISC_LOG_WARNING,
528 "dns_diff_load: "
529 "update with no effect");
530 } else if (result == ISC_R_SUCCESS ||
531 result == DNS_R_NXRRSET)
532 {
533 /*
534 * OK.
535 */
536 } else {
537 CHECK(result);
538 }
539 }
540 }
541 result = ISC_R_SUCCESS;
542 failure:
543 return (result);
544 }
545
546 /*
547 * XXX uses qsort(); a merge sort would be more natural for lists,
548 * and perhaps safer wrt thread stack overflow.
549 */
550 isc_result_t
dns_diff_sort(dns_diff_t * diff,dns_diff_compare_func * compare)551 dns_diff_sort(dns_diff_t *diff, dns_diff_compare_func *compare) {
552 unsigned int length = 0;
553 unsigned int i;
554 dns_difftuple_t **v;
555 dns_difftuple_t *p;
556 REQUIRE(DNS_DIFF_VALID(diff));
557
558 for (p = ISC_LIST_HEAD(diff->tuples); p != NULL;
559 p = ISC_LIST_NEXT(p, link))
560 {
561 length++;
562 }
563 if (length == 0) {
564 return (ISC_R_SUCCESS);
565 }
566 v = isc_mem_get(diff->mctx, length * sizeof(dns_difftuple_t *));
567 for (i = 0; i < length; i++) {
568 p = ISC_LIST_HEAD(diff->tuples);
569 v[i] = p;
570 ISC_LIST_UNLINK(diff->tuples, p, link);
571 }
572 INSIST(ISC_LIST_HEAD(diff->tuples) == NULL);
573 qsort(v, length, sizeof(v[0]), compare);
574 for (i = 0; i < length; i++) {
575 ISC_LIST_APPEND(diff->tuples, v[i], link);
576 }
577 isc_mem_put(diff->mctx, v, length * sizeof(dns_difftuple_t *));
578 return (ISC_R_SUCCESS);
579 }
580
581 /*
582 * Create an rdataset containing the single RR of the given
583 * tuple. The caller must allocate the rdata, rdataset and
584 * an rdatalist structure for it to refer to.
585 */
586
587 static isc_result_t
diff_tuple_tordataset(dns_difftuple_t * t,dns_rdata_t * rdata,dns_rdatalist_t * rdl,dns_rdataset_t * rds)588 diff_tuple_tordataset(dns_difftuple_t *t, dns_rdata_t *rdata,
589 dns_rdatalist_t *rdl, dns_rdataset_t *rds) {
590 REQUIRE(DNS_DIFFTUPLE_VALID(t));
591 REQUIRE(rdl != NULL);
592 REQUIRE(rds != NULL);
593
594 dns_rdatalist_init(rdl);
595 rdl->type = t->rdata.type;
596 rdl->rdclass = t->rdata.rdclass;
597 rdl->ttl = t->ttl;
598 dns_rdataset_init(rds);
599 ISC_LINK_INIT(rdata, link);
600 dns_rdata_clone(&t->rdata, rdata);
601 ISC_LIST_APPEND(rdl->rdata, rdata, link);
602 return (dns_rdatalist_tordataset(rdl, rds));
603 }
604
605 isc_result_t
dns_diff_print(dns_diff_t * diff,FILE * file)606 dns_diff_print(dns_diff_t *diff, FILE *file) {
607 isc_result_t result;
608 dns_difftuple_t *t;
609 char *mem = NULL;
610 unsigned int size = 2048;
611 const char *op = NULL;
612
613 REQUIRE(DNS_DIFF_VALID(diff));
614
615 mem = isc_mem_get(diff->mctx, size);
616
617 for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
618 t = ISC_LIST_NEXT(t, link))
619 {
620 isc_buffer_t buf;
621 isc_region_t r;
622
623 dns_rdatalist_t rdl;
624 dns_rdataset_t rds;
625 dns_rdata_t rd = DNS_RDATA_INIT;
626
627 result = diff_tuple_tordataset(t, &rd, &rdl, &rds);
628 if (result != ISC_R_SUCCESS) {
629 UNEXPECTED_ERROR(__FILE__, __LINE__,
630 "diff_tuple_tordataset failed: %s",
631 dns_result_totext(result));
632 result = ISC_R_UNEXPECTED;
633 goto cleanup;
634 }
635 again:
636 isc_buffer_init(&buf, mem, size);
637 result = dns_rdataset_totext(&rds, &t->name, false, false,
638 &buf);
639
640 if (result == ISC_R_NOSPACE) {
641 isc_mem_put(diff->mctx, mem, size);
642 size += 1024;
643 mem = isc_mem_get(diff->mctx, size);
644 goto again;
645 }
646
647 if (result != ISC_R_SUCCESS) {
648 goto cleanup;
649 }
650 /*
651 * Get rid of final newline.
652 */
653 INSIST(buf.used >= 1 &&
654 ((char *)buf.base)[buf.used - 1] == '\n');
655 buf.used--;
656
657 isc_buffer_usedregion(&buf, &r);
658 switch (t->op) {
659 case DNS_DIFFOP_EXISTS:
660 op = "exists";
661 break;
662 case DNS_DIFFOP_ADD:
663 op = "add";
664 break;
665 case DNS_DIFFOP_DEL:
666 op = "del";
667 break;
668 case DNS_DIFFOP_ADDRESIGN:
669 op = "add re-sign";
670 break;
671 case DNS_DIFFOP_DELRESIGN:
672 op = "del re-sign";
673 break;
674 }
675 if (file != NULL) {
676 fprintf(file, "%s %.*s\n", op, (int)r.length,
677 (char *)r.base);
678 } else {
679 isc_log_write(DIFF_COMMON_LOGARGS, ISC_LOG_DEBUG(7),
680 "%s %.*s", op, (int)r.length,
681 (char *)r.base);
682 }
683 }
684 result = ISC_R_SUCCESS;
685 cleanup:
686 if (mem != NULL) {
687 isc_mem_put(diff->mctx, mem, size);
688 }
689 return (result);
690 }
691