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
50static dns_rdatatype_t
51rdata_covers(dns_rdata_t *rdata) {
52	return (rdata->type == dns_rdatatype_rrsig ? dns_rdata_covers(rdata)
53						   : 0);
54}
55
56isc_result_t
57dns_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
107void
108dns_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
122isc_result_t
123dns_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
128void
129dns_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
135void
136dns_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
146void
147dns_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
154void
155dns_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
196static isc_stdtime_t
197setresign(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
232static void
233getownercase(dns_rdataset_t *rdataset, dns_name_t *name) {
234	if (dns_rdataset_isassociated(rdataset)) {
235		dns_rdataset_getownercase(rdataset, name);
236	}
237}
238
239static void
240setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
241	if (dns_rdataset_isassociated(rdataset)) {
242		dns_rdataset_setownercase(rdataset, name);
243	}
244}
245
246static const char *
247optotext(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
262static isc_result_t
263diff_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
492failure:
493	if (node != NULL) {
494		dns_db_detachnode(db, &node);
495	}
496	return (result);
497}
498
499isc_result_t
500dns_diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver) {
501	return (diff_apply(diff, db, ver, true));
502}
503
504isc_result_t
505dns_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
511isc_result_t
512dns_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;
575failure:
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 */
583isc_result_t
584dns_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
620static isc_result_t
621diff_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
638isc_result_t
639dns_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;
717cleanup:
718	if (mem != NULL) {
719		isc_mem_put(diff->mctx, mem, size);
720	}
721	return (result);
722}
723