1 /* $NetBSD: diff.c,v 1.9 2024/02/21 22:52:06 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/result.h> 27 #include <isc/string.h> 28 #include <isc/util.h> 29 30 #include <dns/db.h> 31 #include <dns/diff.h> 32 #include <dns/log.h> 33 #include <dns/rdataclass.h> 34 #include <dns/rdatalist.h> 35 #include <dns/rdataset.h> 36 #include <dns/rdatastruct.h> 37 #include <dns/rdatatype.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 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 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 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 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 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 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 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 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("unexpected non-minimal diff"); 182 } else { 183 dns_difftuple_free(tuplep); 184 } 185 dns_difftuple_free(&ot); 186 break; 187 } 188 } 189 190 if (*tuplep != NULL) { 191 ISC_LIST_APPEND(diff->tuples, *tuplep, link); 192 *tuplep = NULL; 193 } 194 } 195 196 static isc_stdtime_t 197 setresign(dns_rdataset_t *modified) { 198 dns_rdata_t rdata = DNS_RDATA_INIT; 199 dns_rdata_rrsig_t sig; 200 int64_t when; 201 isc_result_t result; 202 203 result = dns_rdataset_first(modified); 204 INSIST(result == ISC_R_SUCCESS); 205 dns_rdataset_current(modified, &rdata); 206 (void)dns_rdata_tostruct(&rdata, &sig, NULL); 207 if ((rdata.flags & DNS_RDATA_OFFLINE) != 0) { 208 when = 0; 209 } else { 210 when = dns_time64_from32(sig.timeexpire); 211 } 212 dns_rdata_reset(&rdata); 213 214 result = dns_rdataset_next(modified); 215 while (result == ISC_R_SUCCESS) { 216 dns_rdataset_current(modified, &rdata); 217 (void)dns_rdata_tostruct(&rdata, &sig, NULL); 218 if ((rdata.flags & DNS_RDATA_OFFLINE) != 0) { 219 goto next_rr; 220 } 221 if (when == 0 || dns_time64_from32(sig.timeexpire) < when) { 222 when = dns_time64_from32(sig.timeexpire); 223 } 224 next_rr: 225 dns_rdata_reset(&rdata); 226 result = dns_rdataset_next(modified); 227 } 228 INSIST(result == ISC_R_NOMORE); 229 return ((isc_stdtime_t)when); 230 } 231 232 static void 233 getownercase(dns_rdataset_t *rdataset, dns_name_t *name) { 234 if (dns_rdataset_isassociated(rdataset)) { 235 dns_rdataset_getownercase(rdataset, name); 236 } 237 } 238 239 static void 240 setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) { 241 if (dns_rdataset_isassociated(rdataset)) { 242 dns_rdataset_setownercase(rdataset, name); 243 } 244 } 245 246 static const char * 247 optotext(dns_diffop_t op) { 248 switch (op) { 249 case DNS_DIFFOP_ADD: 250 return ("add"); 251 case DNS_DIFFOP_ADDRESIGN: 252 return ("add-resign"); 253 case DNS_DIFFOP_DEL: 254 return ("del"); 255 case DNS_DIFFOP_DELRESIGN: 256 return ("del-resign"); 257 default: 258 return ("unknown"); 259 } 260 } 261 262 static isc_result_t 263 diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver, bool warn) { 264 dns_difftuple_t *t; 265 dns_dbnode_t *node = NULL; 266 isc_result_t result; 267 char namebuf[DNS_NAME_FORMATSIZE]; 268 char typebuf[DNS_RDATATYPE_FORMATSIZE]; 269 char classbuf[DNS_RDATACLASS_FORMATSIZE]; 270 271 REQUIRE(DNS_DIFF_VALID(diff)); 272 REQUIRE(DNS_DB_VALID(db)); 273 274 t = ISC_LIST_HEAD(diff->tuples); 275 while (t != NULL) { 276 dns_name_t *name; 277 278 INSIST(node == NULL); 279 name = &t->name; 280 /* 281 * Find the node. 282 * We create the node if it does not exist. 283 * This will cause an empty node to be created if the diff 284 * contains a deletion of an RR at a nonexistent name, 285 * but such diffs should never be created in the first 286 * place. 287 */ 288 289 while (t != NULL && dns_name_equal(&t->name, name)) { 290 dns_rdatatype_t type, covers; 291 dns_rdataclass_t rdclass; 292 dns_diffop_t op; 293 dns_rdatalist_t rdl; 294 dns_rdataset_t rds; 295 dns_rdataset_t ardataset; 296 unsigned int options; 297 298 op = t->op; 299 type = t->rdata.type; 300 rdclass = t->rdata.rdclass; 301 covers = rdata_covers(&t->rdata); 302 303 /* 304 * Collect a contiguous set of updates with 305 * the same operation (add/delete) and RR type 306 * into a single rdatalist so that the 307 * database rrset merging/subtraction code 308 * can work more efficiently than if each 309 * RR were merged into / subtracted from 310 * the database separately. 311 * 312 * This is done by linking rdata structures from the 313 * diff into "rdatalist". This uses the rdata link 314 * field, not the diff link field, so the structure 315 * of the diff itself is not affected. 316 */ 317 318 dns_rdatalist_init(&rdl); 319 rdl.type = type; 320 rdl.covers = covers; 321 rdl.rdclass = t->rdata.rdclass; 322 rdl.ttl = t->ttl; 323 324 node = NULL; 325 if (type != dns_rdatatype_nsec3 && 326 covers != dns_rdatatype_nsec3) 327 { 328 CHECK(dns_db_findnode(db, name, true, &node)); 329 } else { 330 CHECK(dns_db_findnsec3node(db, name, true, 331 &node)); 332 } 333 334 while (t != NULL && dns_name_equal(&t->name, name) && 335 t->op == op && t->rdata.type == type && 336 rdata_covers(&t->rdata) == covers) 337 { 338 /* 339 * Remember the add name for 340 * dns_rdataset_setownercase. 341 */ 342 name = &t->name; 343 if (t->ttl != rdl.ttl && warn) { 344 dns_name_format(name, namebuf, 345 sizeof(namebuf)); 346 dns_rdatatype_format(t->rdata.type, 347 typebuf, 348 sizeof(typebuf)); 349 dns_rdataclass_format(t->rdata.rdclass, 350 classbuf, 351 sizeof(classbuf)); 352 isc_log_write(DIFF_COMMON_LOGARGS, 353 ISC_LOG_WARNING, 354 "'%s/%s/%s': TTL differs " 355 "in " 356 "rdataset, adjusting " 357 "%lu -> %lu", 358 namebuf, typebuf, 359 classbuf, 360 (unsigned long)t->ttl, 361 (unsigned long)rdl.ttl); 362 } 363 ISC_LIST_APPEND(rdl.rdata, &t->rdata, link); 364 t = ISC_LIST_NEXT(t, link); 365 } 366 367 /* 368 * Convert the rdatalist into a rdataset. 369 */ 370 dns_rdataset_init(&rds); 371 dns_rdataset_init(&ardataset); 372 CHECK(dns_rdatalist_tordataset(&rdl, &rds)); 373 rds.trust = dns_trust_ultimate; 374 375 /* 376 * Merge the rdataset into the database. 377 */ 378 switch (op) { 379 case DNS_DIFFOP_ADD: 380 case DNS_DIFFOP_ADDRESIGN: 381 options = DNS_DBADD_MERGE | DNS_DBADD_EXACT | 382 DNS_DBADD_EXACTTTL; 383 result = dns_db_addrdataset(db, node, ver, 0, 384 &rds, options, 385 &ardataset); 386 break; 387 case DNS_DIFFOP_DEL: 388 case DNS_DIFFOP_DELRESIGN: 389 options = DNS_DBSUB_EXACT | DNS_DBSUB_WANTOLD; 390 result = dns_db_subtractrdataset(db, node, ver, 391 &rds, options, 392 &ardataset); 393 break; 394 default: 395 UNREACHABLE(); 396 } 397 398 if (result == ISC_R_SUCCESS) { 399 if (rds.type == dns_rdatatype_rrsig && 400 (op == DNS_DIFFOP_DELRESIGN || 401 op == DNS_DIFFOP_ADDRESIGN)) 402 { 403 isc_stdtime_t resign; 404 resign = setresign(&ardataset); 405 dns_db_setsigningtime(db, &ardataset, 406 resign); 407 } 408 if (op == DNS_DIFFOP_ADD || 409 op == DNS_DIFFOP_ADDRESIGN) 410 { 411 setownercase(&ardataset, name); 412 } 413 if (op == DNS_DIFFOP_DEL || 414 op == DNS_DIFFOP_DELRESIGN) 415 { 416 getownercase(&ardataset, name); 417 } 418 } else if (result == DNS_R_UNCHANGED) { 419 /* 420 * This will not happen when executing a 421 * dynamic update, because that code will 422 * generate strictly minimal diffs. 423 * It may happen when receiving an IXFR 424 * from a server that is not as careful. 425 * Issue a warning and continue. 426 */ 427 if (warn) { 428 dns_name_format(dns_db_origin(db), 429 namebuf, 430 sizeof(namebuf)); 431 dns_rdataclass_format(dns_db_class(db), 432 classbuf, 433 sizeof(classbuf)); 434 isc_log_write(DIFF_COMMON_LOGARGS, 435 ISC_LOG_WARNING, 436 "%s/%s: dns_diff_apply: " 437 "update with no effect", 438 namebuf, classbuf); 439 } 440 if (op == DNS_DIFFOP_ADD || 441 op == DNS_DIFFOP_ADDRESIGN) 442 { 443 setownercase(&ardataset, name); 444 } 445 if (op == DNS_DIFFOP_DEL || 446 op == DNS_DIFFOP_DELRESIGN) 447 { 448 getownercase(&ardataset, name); 449 } 450 } else if (result == DNS_R_NXRRSET) { 451 /* 452 * OK. 453 */ 454 if (op == DNS_DIFFOP_DEL || 455 op == DNS_DIFFOP_DELRESIGN) 456 { 457 getownercase(&ardataset, name); 458 } 459 if (dns_rdataset_isassociated(&ardataset)) { 460 dns_rdataset_disassociate(&ardataset); 461 } 462 } else { 463 if (result == DNS_R_NOTEXACT) { 464 dns_name_format(name, namebuf, 465 sizeof(namebuf)); 466 dns_rdatatype_format(type, typebuf, 467 sizeof(typebuf)); 468 dns_rdataclass_format(rdclass, classbuf, 469 sizeof(classbuf)); 470 isc_log_write( 471 DIFF_COMMON_LOGARGS, 472 ISC_LOG_ERROR, 473 "dns_diff_apply: %s/%s/%s: %s " 474 "%s", 475 namebuf, typebuf, classbuf, 476 optotext(op), 477 isc_result_totext(result)); 478 } 479 if (dns_rdataset_isassociated(&ardataset)) { 480 dns_rdataset_disassociate(&ardataset); 481 } 482 CHECK(result); 483 } 484 dns_db_detachnode(db, &node); 485 if (dns_rdataset_isassociated(&ardataset)) { 486 dns_rdataset_disassociate(&ardataset); 487 } 488 } 489 } 490 return (ISC_R_SUCCESS); 491 492 failure: 493 if (node != NULL) { 494 dns_db_detachnode(db, &node); 495 } 496 return (result); 497 } 498 499 isc_result_t 500 dns_diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) { 501 return (diff_apply(diff, db, ver, true)); 502 } 503 504 isc_result_t 505 dns_diff_applysilently(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) { 506 return (diff_apply(diff, db, ver, false)); 507 } 508 509 /* XXX this duplicates lots of code in diff_apply(). */ 510 511 isc_result_t 512 dns_diff_load(dns_diff_t *diff, dns_addrdatasetfunc_t addfunc, 513 void *add_private) { 514 dns_difftuple_t *t; 515 isc_result_t result; 516 517 REQUIRE(DNS_DIFF_VALID(diff)); 518 519 t = ISC_LIST_HEAD(diff->tuples); 520 while (t != NULL) { 521 dns_name_t *name; 522 523 name = &t->name; 524 while (t != NULL && dns_name_caseequal(&t->name, name)) { 525 dns_rdatatype_t type, covers; 526 dns_diffop_t op; 527 dns_rdatalist_t rdl; 528 dns_rdataset_t rds; 529 530 op = t->op; 531 type = t->rdata.type; 532 covers = rdata_covers(&t->rdata); 533 534 dns_rdatalist_init(&rdl); 535 rdl.type = type; 536 rdl.covers = covers; 537 rdl.rdclass = t->rdata.rdclass; 538 rdl.ttl = t->ttl; 539 540 while (t != NULL && 541 dns_name_caseequal(&t->name, name) && 542 t->op == op && t->rdata.type == type && 543 rdata_covers(&t->rdata) == covers) 544 { 545 ISC_LIST_APPEND(rdl.rdata, &t->rdata, link); 546 t = ISC_LIST_NEXT(t, link); 547 } 548 549 /* 550 * Convert the rdatalist into a rdataset. 551 */ 552 dns_rdataset_init(&rds); 553 CHECK(dns_rdatalist_tordataset(&rdl, &rds)); 554 rds.trust = dns_trust_ultimate; 555 556 INSIST(op == DNS_DIFFOP_ADD); 557 result = (*addfunc)(add_private, name, &rds); 558 if (result == DNS_R_UNCHANGED) { 559 isc_log_write(DIFF_COMMON_LOGARGS, 560 ISC_LOG_WARNING, 561 "dns_diff_load: " 562 "update with no effect"); 563 } else if (result == ISC_R_SUCCESS || 564 result == DNS_R_NXRRSET) 565 { 566 /* 567 * OK. 568 */ 569 } else { 570 CHECK(result); 571 } 572 } 573 } 574 result = ISC_R_SUCCESS; 575 failure: 576 return (result); 577 } 578 579 /* 580 * XXX uses qsort(); a merge sort would be more natural for lists, 581 * and perhaps safer wrt thread stack overflow. 582 */ 583 isc_result_t 584 dns_diff_sort(dns_diff_t *diff, dns_diff_compare_func *compare) { 585 unsigned int length = 0; 586 unsigned int i; 587 dns_difftuple_t **v; 588 dns_difftuple_t *p; 589 REQUIRE(DNS_DIFF_VALID(diff)); 590 591 for (p = ISC_LIST_HEAD(diff->tuples); p != NULL; 592 p = ISC_LIST_NEXT(p, link)) 593 { 594 length++; 595 } 596 if (length == 0) { 597 return (ISC_R_SUCCESS); 598 } 599 v = isc_mem_get(diff->mctx, length * sizeof(dns_difftuple_t *)); 600 for (i = 0; i < length; i++) { 601 p = ISC_LIST_HEAD(diff->tuples); 602 v[i] = p; 603 ISC_LIST_UNLINK(diff->tuples, p, link); 604 } 605 INSIST(ISC_LIST_HEAD(diff->tuples) == NULL); 606 qsort(v, length, sizeof(v[0]), compare); 607 for (i = 0; i < length; i++) { 608 ISC_LIST_APPEND(diff->tuples, v[i], link); 609 } 610 isc_mem_put(diff->mctx, v, length * sizeof(dns_difftuple_t *)); 611 return (ISC_R_SUCCESS); 612 } 613 614 /* 615 * Create an rdataset containing the single RR of the given 616 * tuple. The caller must allocate the rdata, rdataset and 617 * an rdatalist structure for it to refer to. 618 */ 619 620 static isc_result_t 621 diff_tuple_tordataset(dns_difftuple_t *t, dns_rdata_t *rdata, 622 dns_rdatalist_t *rdl, dns_rdataset_t *rds) { 623 REQUIRE(DNS_DIFFTUPLE_VALID(t)); 624 REQUIRE(rdl != NULL); 625 REQUIRE(rds != NULL); 626 627 dns_rdatalist_init(rdl); 628 rdl->type = t->rdata.type; 629 rdl->rdclass = t->rdata.rdclass; 630 rdl->ttl = t->ttl; 631 dns_rdataset_init(rds); 632 ISC_LINK_INIT(rdata, link); 633 dns_rdata_clone(&t->rdata, rdata); 634 ISC_LIST_APPEND(rdl->rdata, rdata, link); 635 return (dns_rdatalist_tordataset(rdl, rds)); 636 } 637 638 isc_result_t 639 dns_diff_print(dns_diff_t *diff, FILE *file) { 640 isc_result_t result; 641 dns_difftuple_t *t; 642 char *mem = NULL; 643 unsigned int size = 2048; 644 const char *op = NULL; 645 646 REQUIRE(DNS_DIFF_VALID(diff)); 647 648 mem = isc_mem_get(diff->mctx, size); 649 650 for (t = ISC_LIST_HEAD(diff->tuples); t != NULL; 651 t = ISC_LIST_NEXT(t, link)) 652 { 653 isc_buffer_t buf; 654 isc_region_t r; 655 656 dns_rdatalist_t rdl; 657 dns_rdataset_t rds; 658 dns_rdata_t rd = DNS_RDATA_INIT; 659 660 result = diff_tuple_tordataset(t, &rd, &rdl, &rds); 661 if (result != ISC_R_SUCCESS) { 662 UNEXPECTED_ERROR("diff_tuple_tordataset failed: %s", 663 isc_result_totext(result)); 664 result = ISC_R_UNEXPECTED; 665 goto cleanup; 666 } 667 again: 668 isc_buffer_init(&buf, mem, size); 669 result = dns_rdataset_totext(&rds, &t->name, false, false, 670 &buf); 671 672 if (result == ISC_R_NOSPACE) { 673 isc_mem_put(diff->mctx, mem, size); 674 size += 1024; 675 mem = isc_mem_get(diff->mctx, size); 676 goto again; 677 } 678 679 if (result != ISC_R_SUCCESS) { 680 goto cleanup; 681 } 682 /* 683 * Get rid of final newline. 684 */ 685 INSIST(buf.used >= 1 && 686 ((char *)buf.base)[buf.used - 1] == '\n'); 687 buf.used--; 688 689 isc_buffer_usedregion(&buf, &r); 690 switch (t->op) { 691 case DNS_DIFFOP_EXISTS: 692 op = "exists"; 693 break; 694 case DNS_DIFFOP_ADD: 695 op = "add"; 696 break; 697 case DNS_DIFFOP_DEL: 698 op = "del"; 699 break; 700 case DNS_DIFFOP_ADDRESIGN: 701 op = "add re-sign"; 702 break; 703 case DNS_DIFFOP_DELRESIGN: 704 op = "del re-sign"; 705 break; 706 } 707 if (file != NULL) { 708 fprintf(file, "%s %.*s\n", op, (int)r.length, 709 (char *)r.base); 710 } else { 711 isc_log_write(DIFF_COMMON_LOGARGS, ISC_LOG_DEBUG(7), 712 "%s %.*s", op, (int)r.length, 713 (char *)r.base); 714 } 715 } 716 result = ISC_R_SUCCESS; 717 cleanup: 718 if (mem != NULL) { 719 isc_mem_put(diff->mctx, mem, size); 720 } 721 return (result); 722 } 723