PageRenderTime 37ms CodeModel.GetById 13ms app.highlight 16ms RepoModel.GetById 1ms app.codeStats 1ms

/contrib/bind9/lib/dns/include/dns/diff.h

https://bitbucket.org/freebsd/freebsd-head/
C++ Header | 291 lines | 66 code | 34 blank | 191 comment | 0 complexity | 9ba717b02ad888393f9c37a3f9a17b0d MD5 | raw file
  1/*
  2 * Copyright (C) 2004-2010  Internet Systems Consortium, Inc. ("ISC")
  3 * Copyright (C) 2000, 2001  Internet Software Consortium.
  4 *
  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.
  8 *
  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.
 16 */
 17
 18/* $Id: diff.h,v 1.19 2010/06/04 23:51:14 tbox Exp $ */
 19
 20#ifndef DNS_DIFF_H
 21#define DNS_DIFF_H 1
 22
 23/*****
 24 ***** Module Info
 25 *****/
 26
 27/*! \file dns/diff.h
 28 * \brief
 29 * A diff is a convenience type representing a list of changes to be
 30 * made to a database.
 31 */
 32
 33/***
 34 *** Imports
 35 ***/
 36
 37#include <isc/lang.h>
 38#include <isc/magic.h>
 39
 40#include <dns/name.h>
 41#include <dns/rdata.h>
 42#include <dns/types.h>
 43
 44/***
 45 *** Types
 46 ***/
 47
 48/*%
 49 * A dns_difftuple_t represents a single RR being added or deleted.
 50 * The RR type and class are in the 'rdata' member; the class is always
 51 * the real one, not a DynDNS meta-class, so that the rdatas can be
 52 * compared using dns_rdata_compare().  The TTL is significant
 53 * even for deletions, because a deletion/addition pair cannot
 54 * be canceled out if the TTL differs (it might be an explicit
 55 * TTL update).
 56 *
 57 * Tuples are also used to represent complete RRs with owner
 58 * names for a couple of other purposes, such as the
 59 * individual RRs of a "RRset exists (value dependent)"
 60 * prerequisite set.  In this case, op==DNS_DIFFOP_EXISTS,
 61 * and the TTL is ignored.
 62 *
 63 * DNS_DIFFOP_*RESIGN will cause the 'resign' attribute of the resulting
 64 * RRset to be recomputed to be 'resign' seconds before the earliest RRSIG
 65 * timeexpire.
 66 */
 67
 68typedef enum {
 69	DNS_DIFFOP_ADD = 0,		/*%< Add an RR. */
 70	DNS_DIFFOP_DEL = 1,		/*%< Delete an RR. */
 71	DNS_DIFFOP_EXISTS = 2,		/*%< Assert RR existence. */
 72	DNS_DIFFOP_ADDRESIGN = 4,	/*%< ADD + RESIGN. */
 73	DNS_DIFFOP_DELRESIGN = 5	/*%< DEL + RESIGN. */
 74} dns_diffop_t;
 75
 76typedef struct dns_difftuple dns_difftuple_t;
 77
 78#define DNS_DIFFTUPLE_MAGIC	ISC_MAGIC('D','I','F','T')
 79#define DNS_DIFFTUPLE_VALID(t)	ISC_MAGIC_VALID(t, DNS_DIFFTUPLE_MAGIC)
 80
 81struct dns_difftuple {
 82	unsigned int			magic;
 83	isc_mem_t			*mctx;
 84	dns_diffop_t			op;
 85	dns_name_t			name;
 86	dns_ttl_t			ttl;
 87	dns_rdata_t			rdata;
 88	ISC_LINK(dns_difftuple_t)	link;
 89	/* Variable-size name data and rdata follows. */
 90};
 91
 92/*%
 93 * A dns_diff_t represents a set of changes being applied to
 94 * a zone.  Diffs are also used to represent "RRset exists
 95 * (value dependent)" prerequisites.
 96 */
 97typedef struct dns_diff dns_diff_t;
 98
 99#define DNS_DIFF_MAGIC		ISC_MAGIC('D','I','F','F')
100#define DNS_DIFF_VALID(t)	ISC_MAGIC_VALID(t, DNS_DIFF_MAGIC)
101
102struct dns_diff {
103	unsigned int			magic;
104	isc_mem_t *			mctx;
105	/*
106	 * Set the 'resign' attribute to this many second before the
107	 * earliest RRSIG timeexpire.
108	 */
109	isc_uint32_t			resign;
110	ISC_LIST(dns_difftuple_t)	tuples;
111};
112
113/* Type of comparison function for sorting diffs. */
114typedef int dns_diff_compare_func(const void *, const void *);
115
116/***
117 *** Functions
118 ***/
119
120ISC_LANG_BEGINDECLS
121
122/**************************************************************************/
123/*
124 * Manipulation of diffs and tuples.
125 */
126
127isc_result_t
128dns_difftuple_create(isc_mem_t *mctx,
129		     dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
130		     dns_rdata_t *rdata, dns_difftuple_t **tp);
131/*%<
132 * Create a tuple.  Deep copies are made of the name and rdata, so
133 * they need not remain valid after the call.
134 *
135 * Requires:
136 *\li	*tp != NULL && *tp == NULL.
137 *
138 * Returns:
139 *\li	ISC_R_SUCCESS
140 *  \li    ISC_R_NOMEMORY
141 */
142
143void
144dns_difftuple_free(dns_difftuple_t **tp);
145/*%<
146 * Free a tuple.
147 *
148 * Requires:
149 *    \li   **tp is a valid tuple.
150 *
151 * Ensures:
152 *     \li  *tp == NULL
153 *      \li All memory used by the tuple is freed.
154 */
155
156isc_result_t
157dns_difftuple_copy(dns_difftuple_t *orig, dns_difftuple_t **copyp);
158/*%<
159 * Copy a tuple.
160 *
161 * Requires:
162 * \li	'orig' points to a valid tuple
163 *\li	copyp != NULL && *copyp == NULL
164 */
165
166void
167dns_diff_init(isc_mem_t *mctx, dns_diff_t *diff);
168/*%<
169 * Initialize a diff.
170 *
171 * Requires:
172 * \li   'diff' points to an uninitialized dns_diff_t
173 *  \li  allocated by the caller.
174 *
175 * Ensures:
176 * \li   '*diff' is a valid, empty diff.
177 */
178
179void
180dns_diff_clear(dns_diff_t *diff);
181/*%<
182 * Clear a diff, destroying all its tuples.
183 *
184 * Requires:
185 * \li   'diff' points to a valid dns_diff_t.
186 *
187 * Ensures:
188 * \li    Any tuples in the diff are destroyed.
189 *     The diff now empty, but it is still valid
190 *     and may be reused without calling dns_diff_init
191 *     again.  The only memory used is that of the
192 *     dns_diff_t structure itself.
193 *
194 * Notes:
195 * \li    Managing the memory of the dns_diff_t structure itself
196 *     is the caller's responsibility.
197 */
198
199void
200dns_diff_append(dns_diff_t *diff, dns_difftuple_t **tuple);
201/*%<
202 * Append a single tuple to a diff.
203 *
204 *\li	'diff' is a valid diff.
205 * \li	'*tuple' is a valid tuple.
206 *
207 * Ensures:
208 *\li	*tuple is NULL.
209 *\li	The tuple has been freed, or will be freed when the diff is cleared.
210 */
211
212void
213dns_diff_appendminimal(dns_diff_t *diff, dns_difftuple_t **tuple);
214/*%<
215 * Append 'tuple' to 'diff', removing any duplicate
216 * or conflicting updates as needed to create a minimal diff.
217 *
218 * Requires:
219 *\li	'diff' is a minimal diff.
220 *
221 * Ensures:
222 *\li	'diff' is still a minimal diff.
223 *  \li 	*tuple is NULL.
224 *   \li	The tuple has been freed, or will be freed when the diff is cleared.
225 *
226 */
227
228isc_result_t
229dns_diff_sort(dns_diff_t *diff, dns_diff_compare_func *compare);
230/*%<
231 * Sort 'diff' in-place according to the comparison function 'compare'.
232 */
233
234isc_result_t
235dns_diff_apply(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver);
236isc_result_t
237dns_diff_applysilently(dns_diff_t *diff, dns_db_t *db, dns_dbversion_t *ver);
238/*%<
239 * Apply 'diff' to the database 'db'.
240 *
241 * dns_diff_apply() logs warnings about updates with no effect or
242 * with inconsistent TTLs; dns_diff_applysilently() does not.
243 *
244 * For efficiency, the diff should be sorted by owner name.
245 * If it is not sorted, operation will still be correct,
246 * but less efficient.
247 *
248 * Requires:
249 *\li	*diff is a valid diff (possibly empty), containing
250 *   	tuples of type #DNS_DIFFOP_ADD and/or
251 *  	For #DNS_DIFFOP_DEL tuples, the TTL is ignored.
252 *
253 */
254
255isc_result_t
256dns_diff_load(dns_diff_t *diff, dns_addrdatasetfunc_t addfunc,
257	      void *add_private);
258/*%<
259 * Like dns_diff_apply, but for use when loading a new database
260 * instead of modifying an existing one.  This bypasses the
261 * database transaction mechanisms.
262 *
263 * Requires:
264 *\li 	'addfunc' is a valid dns_addradatasetfunc_t obtained from
265 * 	dns_db_beginload()
266 *
267 *\li	'add_private' points to a corresponding dns_dbload_t *
268 *      (XXX why is it a void pointer, then?)
269 */
270
271isc_result_t
272dns_diff_print(dns_diff_t *diff, FILE *file);
273
274/*%<
275 * Print the differences to 'file' or if 'file' is NULL via the
276 * logging system.
277 *
278 * Require:
279 *\li	'diff' to be valid.
280 *\li	'file' to refer to a open file or NULL.
281 *
282 * Returns:
283 *\li	#ISC_R_SUCCESS
284 *\li	#ISC_R_NOMEMORY
285 *\li	#ISC_R_UNEXPECTED
286 *\li	any error from dns_rdataset_totext()
287 */
288
289ISC_LANG_ENDDECLS
290
291#endif /* DNS_DIFF_H */