Na}{

File Content: `diff.h`

/*
 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
 *
 * See the COPYRIGHT file distributed with this work for additional
 * information regarding copyright ownership.
 */

#ifndef DNS_DIFF_H
#define DNS_DIFF_H 1

/*****
***** Module Info
*****/

/*! \file dns/diff.h
 * \brief
 * A diff is a convenience type representing a list of changes to be
 * made to a database.
 */

/***
 *** Imports
 ***/

#include <isc/lang.h>
#include <isc/magic.h>

#include <dns/name.h>
#include <dns/rdata.h>
#include <dns/types.h>

/***
 *** Types
 ***/

/*%
 * A dns_difftuple_t represents a single RR being added or deleted.
 * The RR type and class are in the 'rdata' member; the class is always
 * the real one, not a DynDNS meta-class, so that the rdatas can be
 * compared using dns_rdata_compare().  The TTL is significant
 * even for deletions, because a deletion/addition pair cannot
 * be canceled out if the TTL differs (it might be an explicit
 * TTL update).
 *
 * Tuples are also used to represent complete RRs with owner
 * names for a couple of other purposes, such as the
 * individual RRs of a "RRset exists (value dependent)"
 * prerequisite set.  In this case, op==DNS_DIFFOP_EXISTS,
 * and the TTL is ignored.
 *
 * DNS_DIFFOP_*RESIGN will cause the 'resign' attribute of the resulting
 * RRset to be recomputed to be 'resign' seconds before the earliest RRSIG
 * timeexpire.
 */

typedef enum {
	DNS_DIFFOP_ADD = 0,	  /*%< Add an RR. */
	DNS_DIFFOP_DEL = 1,	  /*%< Delete an RR. */
	DNS_DIFFOP_EXISTS = 2,	  /*%< Assert RR existence. */
	DNS_DIFFOP_ADDRESIGN = 4, /*%< ADD + RESIGN. */
	DNS_DIFFOP_DELRESIGN = 5  /*%< DEL + RESIGN. */
} dns_diffop_t;

typedef struct dns_difftuple dns_difftuple_t;
typedef ISC_LIST(dns_difftuple_t) dns_difftuplelist_t;

#define DNS_DIFFTUPLE_MAGIC    ISC_MAGIC('D', 'I', 'F', 'T')
#define DNS_DIFFTUPLE_VALID(t) ISC_MAGIC_VALID(t, DNS_DIFFTUPLE_MAGIC)

struct dns_difftuple {
	unsigned int magic;
	isc_mem_t	  *mctx;
	dns_diffop_t op;
	dns_name_t   name;
	dns_ttl_t    ttl;
	dns_rdata_t  rdata;
	ISC_LINK(dns_difftuple_t) link;
	/* Variable-size name data and rdata follows. */
};

/*%
 * A dns_diff_t represents a set of changes being applied to
 * a zone.  Diffs are also used to represent "RRset exists
 * (value dependent)" prerequisites.
 */
typedef struct dns_diff dns_diff_t;

#define DNS_DIFF_MAGIC	  ISC_MAGIC('D', 'I', 'F', 'F')
#define DNS_DIFF_VALID(t) ISC_MAGIC_VALID(t, DNS_DIFF_MAGIC)

struct dns_diff {
	unsigned int	    magic;
	isc_mem_t	  *mctx;
	dns_difftuplelist_t tuples;
};

/* Type of comparison function for sorting diffs. */
typedef int
dns_diff_compare_func(const void *, const void *);

/***
 *** Functions
 ***/

ISC_LANG_BEGINDECLS

/**************************************************************************/
/*
 * Manipulation of diffs and tuples.
 */

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);
/*%<
 * Create a tuple.  Deep copies are made of the name and rdata, so
 * they need not remain valid after the call.
 *
 * Requires:
 *\li	*tp != NULL && *tp == NULL.
 *
 * Returns:
 *\li	ISC_R_SUCCESS
 *  \li    ISC_R_NOMEMORY
 */

void
dns_difftuple_free(dns_difftuple_t **tp);
/*%<
 * Free a tuple.
 *
 * Requires:
 *    \li   **tp is a valid tuple.
 *
 * Ensures:
 *     \li  *tp == NULL
 *      \li All memory used by the tuple is freed.
 */

isc_result_t
dns_difftuple_copy(dns_difftuple_t *orig, dns_difftuple_t **copyp);
/*%<
 * Copy a tuple.
 *
 * Requires:
 * \li	'orig' points to a valid tuple
 *\li	copyp != NULL && *copyp == NULL
 */

void
dns_diff_init(isc_mem_t *mctx, dns_diff_t *diff);
/*%<
 * Initialize a diff.
 *
 * Requires:
 * \li   'diff' points to an uninitialized dns_diff_t
 *  \li  allocated by the caller.
 *
 * Ensures:
 * \li   '*diff' is a valid, empty diff.
 */

void
dns_diff_clear(dns_diff_t *diff);
/*%<
 * Clear a diff, destroying all its tuples.
 *
 * Requires:
 * \li   'diff' points to a valid dns_diff_t.
 *
 * Ensures:
 * \li    Any tuples in the diff are destroyed.
 *     The diff now empty, but it is still valid
 *     and may be reused without calling dns_diff_init
 *     again.  The only memory used is that of the
 *     dns_diff_t structure itself.
 *
 * Notes:
 * \li    Managing the memory of the dns_diff_t structure itself
 *     is the caller's responsibility.
 */

void
dns_diff_append(dns_diff_t *diff, dns_difftuple_t **tuple);
/*%<
 * Append a single tuple to a diff.
 *
 *\li	'diff' is a valid diff.
 * \li	'*tuple' is a valid tuple.
 *
 * Ensures:
 *\li	*tuple is NULL.
 *\li	The tuple has been freed, or will be freed when the diff is cleared.
 */

void
dns_diff_appendminimal(dns_diff_t *diff, dns_difftuple_t **tuple);
/*%<
 * Append 'tuple' to 'diff', removing any duplicate
 * or conflicting updates as needed to create a minimal diff.
 *
 * Requires:
 *\li	'diff' is a minimal diff.
 *
 * Ensures:
 *\li	'diff' is still a minimal diff.
 *  \li 	*tuple is NULL.
 *   \li	The tuple has been freed, or will be freed when the diff is
 * cleared.
 *
 */

isc_result_t
dns_diff_sort(dns_diff_t *diff, dns_diff_compare_func *compare);
/*%<
 * Sort 'diff' in-place according to the comparison function 'compare'.
 */

isc_result_t
dns_diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver);
isc_result_t
dns_diff_applysilently(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver);
/*%<
 * Apply 'diff' to the database 'db'.
 *
 * dns_diff_apply() logs warnings about updates with no effect or
 * with inconsistent TTLs; dns_diff_applysilently() does not.
 *
 * For efficiency, the diff should be sorted by owner name.
 * If it is not sorted, operation will still be correct,
 * but less efficient.
 *
 * Requires:
 *\li	*diff is a valid diff (possibly empty), containing
 *   	tuples of type #DNS_DIFFOP_ADD and/or
 *  	For #DNS_DIFFOP_DEL tuples, the TTL is ignored.
 *
 */

isc_result_t
dns_diff_load(dns_diff_t *diff, dns_addrdatasetfunc_t addfunc,
	      void *add_private);
/*%<
 * Like dns_diff_apply, but for use when loading a new database
 * instead of modifying an existing one.  This bypasses the
 * database transaction mechanisms.
 *
 * Requires:
 *\li 	'addfunc' is a valid dns_addradatasetfunc_t obtained from
 * 	dns_db_beginload()
 *
 *\li	'add_private' points to a corresponding dns_dbload_t *
 *      (XXX why is it a void pointer, then?)
 */

isc_result_t
dns_diff_print(dns_diff_t *diff, FILE *file);

/*%<
 * Print the differences to 'file' or if 'file' is NULL via the
 * logging system.
 *
 * Require:
 *\li	'diff' to be valid.
 *\li	'file' to refer to a open file or NULL.
 *
 * Returns:
 *\li	#ISC_R_SUCCESS
 *\li	#ISC_R_NOMEMORY
 *\li	#ISC_R_UNEXPECTED
 *\li	any error from dns_rdataset_totext()
 */

ISC_LANG_ENDDECLS

#endif /* DNS_DIFF_H */

Name	Size	Permission
acl.h	6477 bytes	0644
adb.h	22267 bytes	0644
badcache.h	3387 bytes	0644
bit.h	798 bytes	0644
byaddr.h	3598 bytes	0644
cache.h	8730 bytes	0644
callbacks.h	2280 bytes	0644
catz.h	11881 bytes	0644
cert.h	1465 bytes	0644
client.h	14527 bytes	0644
clientinfo.h	2015 bytes	0644
compress.h	7047 bytes	0644
db.h	50446 bytes	0644
dbiterator.h	7385 bytes	0644
dbtable.h	3167 bytes	0644
diff.h	7039 bytes	0644
dispatch.h	15538 bytes	0644
dlz.h	10876 bytes	0644
dlz_dlopen.h	4394 bytes	0644
dns64.h	5720 bytes	0644
dnsrps.h	2572 bytes	0644
dnssec.h	12585 bytes	0644
dnstap.h	10193 bytes	0644
ds.h	1665 bytes	0644
dsdigest.h	1713 bytes	0644
dyndb.h	4869 bytes	0644
ecdb.h	806 bytes	0644
ecs.h	1250 bytes	0644
edns.h	783 bytes	0644
enumclass.h	1220 bytes	0644
enumtype.h	8485 bytes	0644
events.h	4451 bytes	0644
fixedname.h	1652 bytes	0644
forward.h	3060 bytes	0644
geoip.h	2340 bytes	0644
ipkeylist.h	2219 bytes	0644
iptable.h	1521 bytes	0644
journal.h	9712 bytes	0644
kasp.h	12124 bytes	0644
keydata.h	1047 bytes	0644
keyflags.h	1277 bytes	0644
keymgr.h	4107 bytes	0644
keytable.h	7871 bytes	0644
keyvalues.h	4083 bytes	0644
lib.h	993 bytes	0644
librpz.h	31401 bytes	0644
lmdb.h	779 bytes	0644
log.h	4029 bytes	0644
lookup.h	2921 bytes	0644
master.h	8786 bytes	0644
masterdump.h	10133 bytes	0644
message.h	39567 bytes	0644
name.h	37781 bytes	0644
ncache.h	4960 bytes	0644
nsec.h	3065 bytes	0644
nsec3.h	8258 bytes	0644
nta.h	4846 bytes	0644
opcode.h	1006 bytes	0644
order.h	2010 bytes	0644
peer.h	6475 bytes	0644
portlist.h	2101 bytes	0644
private.h	1962 bytes	0644
rbt.h	37484 bytes	0644
rcode.h	2472 bytes	0644
rdata.h	22564 bytes	0644
rdataclass.h	2248 bytes	0644
rdatalist.h	2557 bytes	0644
rdataset.h	18714 bytes	0644
rdatasetiter.h	3912 bytes	0644
rdataslab.h	4241 bytes	0644
rdatastruct.h	62703 bytes	0644
rdatatype.h	2290 bytes	0644
request.h	9187 bytes	0644
resolver.h	20152 bytes	0644
result.h	9196 bytes	0644
rootns.h	891 bytes	0644
rpz.h	12156 bytes	0644
rriterator.h	4214 bytes	0644
rrl.h	6959 bytes	0644
sdb.h	7350 bytes	0644
sdlz.h	14090 bytes	0644
secalg.h	1705 bytes	0644
secproto.h	1556 bytes	0644
soa.h	2179 bytes	0644
ssu.h	7182 bytes	0644
stats.h	24689 bytes	0644
tcpmsg.h	3128 bytes	0644
time.h	1693 bytes	0644
timer.h	1050 bytes	0644
tkey.h	7655 bytes	0644
tsec.h	2946 bytes	0644
tsig.h	8497 bytes	0644
ttl.h	1876 bytes	0644
types.h	14584 bytes	0644
update.h	2004 bytes	0644
validator.h	6679 bytes	0644
version.h	679 bytes	0644
view.h	35341 bytes	0644
xfrin.h	2314 bytes	0644
zone.h	65543 bytes	0644
zonekey.h	776 bytes	0644
zoneverify.h	1393 bytes	0644
zt.h	5241 bytes	0644

File Content: diff.h

File Content: `diff.h`