contrib/bind-9.5.2/lib/dns/include/dns/rdata.h

   1 /*
   2  * Copyright (C) 2004-2009  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1998-2003  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: rdata.h,v 1.67.128.4 2009/01/19 23:47:03 tbox Exp $ */
  19
  20 #ifndef DNS_RDATA_H
  21 #define DNS_RDATA_H 1
  22
  23 /*****
  24  ***** Module Info
  25  *****/
  26
  27 /*! \file dns/rdata.h
  28  * \brief
  29  * Provides facilities for manipulating DNS rdata, including conversions to
  30  * and from wire format and text format.
  31  *
  32  * Given the large amount of rdata possible in a nameserver, it was important
  33  * to come up with a very efficient way of storing rdata, but at the same
  34  * time allow it to be manipulated.
  35  *
  36  * The decision was to store rdata in uncompressed wire format,
  37  * and not to make it a fully abstracted object; i.e. certain parts of the
  38  * server know rdata is stored that way.  This saves a lot of memory, and
  39  * makes adding rdata to messages easy.  Having much of the server know
  40  * the representation would be perilous, and we certainly don't want each
  41  * user of rdata to be manipulating such a low-level structure.  This is
  42  * where the rdata module comes in.  The module allows rdata handles to be
  43  * created and attached to uncompressed wire format regions.  All rdata
  44  * operations and conversions are done through these handles.
  45  *
  46  * Implementation Notes:
  47  *
  48  *\li   The routines in this module are expected to be synthesized by the
  49  *      build process from a set of source files, one per rdata type.  For
  50  *      portability, it's probably best that the building be done by a C
  51  *      program.  Adding a new rdata type will be a simple matter of adding
  52  *      a file to a directory and rebuilding the server.  *All* knowledge of
  53  *      the format of a particular rdata type is in this file.
  54  *
  55  * MP:
  56  *\li   Clients of this module must impose any required synchronization.
  57  *
  58  * Reliability:
  59  *\li   This module deals with low-level byte streams.  Errors in any of
  60  *      the functions are likely to crash the server or corrupt memory.
  61  *
  62  *\li   Rdata is typed, and the caller must know what type of rdata it has.
  63  *      A caller that gets this wrong could crash the server.
  64  *
  65  *\li   The fromstruct() and tostruct() routines use a void * pointer to
  66  *      represent the structure.  The caller must ensure that it passes a
  67  *      pointer to the appropriate type, or the server could crash or memory
  68  *      could be corrupted.
  69  *
  70  * Resources:
  71  *\li   None.
  72  *
  73  * Security:
  74  *
  75  *\li   *** WARNING ***
  76  *      dns_rdata_fromwire() deals with raw network data.  An error in
  77  *      this routine could result in the failure or hijacking of the server.
  78  *
  79  * Standards:
  80  *\li   RFC1035
  81  *\li   Draft EDNS0 (0)
  82  *\li   Draft EDNS1 (0)
  83  *\li   Draft Binary Labels (2)
  84  *\li   Draft Local Compression (1)
  85  *\li   Various RFCs for particular types; these will be documented in the
  86  *       sources files of the types.
  87  *
  88  */
  89
  90 /***
  91  *** Imports
  92  ***/
  93
  94 #include <isc/lang.h>
  95
  96 #include <dns/types.h>
  97 #include <dns/name.h>
  98
  99 ISC_LANG_BEGINDECLS
 100
 101
 102 /***
 103  *** Types
 104  ***/
 105
 106 /*%
 107  ***** An 'rdata' is a handle to a binary region.  The handle has an RR
 108  ***** class and type, and the data in the binary region is in the format
 109  ***** of the given class and type.
 110  *****/
 111 /*%
 112  * Clients are strongly discouraged from using this type directly, with
 113  * the exception of the 'link' field which may be used directly for whatever
 114  * purpose the client desires.
 115  */
 116 struct dns_rdata {
 117         unsigned char *                 data;
 118         unsigned int                    length;
 119         dns_rdataclass_t                rdclass;
 120         dns_rdatatype_t                 type;
 121         unsigned int                    flags;
 122         ISC_LINK(dns_rdata_t)           link;
 123 };
 124
 125 #define DNS_RDATA_INIT { NULL, 0, 0, 0, 0, {(void*)(-1), (void *)(-1)}}
 126
 127 #define DNS_RDATA_UPDATE        0x0001          /*%< update pseudo record */
 128
 129 /*
 130  * Flags affecting rdata formatting style.  Flags 0xFFFF0000
 131  * are used by masterfile-level formatting and defined elsewhere.
 132  * See additional comments at dns_rdata_tofmttext().
 133  */
 134
 135 /*% Split the rdata into multiple lines to try to keep it
 136  within the "width". */
 137 #define DNS_STYLEFLAG_MULTILINE         0x00000001U
 138
 139 /*% Output explanatory comments. */
 140 #define DNS_STYLEFLAG_COMMENT           0x00000002U
 141
 142 #define DNS_RDATA_DOWNCASE              DNS_NAME_DOWNCASE
 143 #define DNS_RDATA_CHECKNAMES            DNS_NAME_CHECKNAMES
 144 #define DNS_RDATA_CHECKNAMESFAIL        DNS_NAME_CHECKNAMESFAIL
 145 #define DNS_RDATA_CHECKREVERSE          DNS_NAME_CHECKREVERSE
 146 #define DNS_RDATA_CHECKMX               DNS_NAME_CHECKMX
 147 #define DNS_RDATA_CHECKMXFAIL           DNS_NAME_CHECKMXFAIL
 148
 149 /***
 150  *** Initialization
 151  ***/
 152
 153 void
 154 dns_rdata_init(dns_rdata_t *rdata);
 155 /*%<
 156  * Make 'rdata' empty.
 157  *
 158  * Requires:
 159  *      'rdata' is a valid rdata (i.e. not NULL, points to a struct dns_rdata)
 160  */
 161
 162 void
 163 dns_rdata_reset(dns_rdata_t *rdata);
 164 /*%<
 165  * Make 'rdata' empty.
 166  *
 167  * Requires:
 168  *\li   'rdata' is a previously initialized rdata and is not linked.
 169  */
 170
 171 void
 172 dns_rdata_clone(const dns_rdata_t *src, dns_rdata_t *target);
 173 /*%<
 174  * Clone 'target' from 'src'.
 175  *
 176  * Requires:
 177  *\li   'src' to be initialized.
 178  *\li   'target' to be initialized.
 179  */
 180
 181 /***
 182  *** Comparisons
 183  ***/
 184
 185 int
 186 dns_rdata_compare(const dns_rdata_t *rdata1, const dns_rdata_t *rdata2);
 187 /*%<
 188  * Determine the relative ordering under the DNSSEC order relation of
 189  * 'rdata1' and 'rdata2'.
 190  *
 191  * Requires:
 192  *
 193  *\li   'rdata1' is a valid, non-empty rdata
 194  *
 195  *\li   'rdata2' is a valid, non-empty rdata
 196  *
 197  * Returns:
 198  *\li   < 0             'rdata1' is less than 'rdata2'
 199  *\li   0               'rdata1' is equal to 'rdata2'
 200  *\li   > 0             'rdata1' is greater than 'rdata2'
 201  */
 202
 203 /***
 204  *** Conversions
 205  ***/
 206
 207 void
 208 dns_rdata_fromregion(dns_rdata_t *rdata, dns_rdataclass_t rdclass,
 209                      dns_rdatatype_t type, isc_region_t *r);
 210 /*%<
 211  * Make 'rdata' refer to region 'r'.
 212  *
 213  * Requires:
 214  *
 215  *\li   The data in 'r' is properly formatted for whatever type it is.
 216  */
 217
 218 void
 219 dns_rdata_toregion(const dns_rdata_t *rdata, isc_region_t *r);
 220 /*%<
 221  * Make 'r' refer to 'rdata'.
 222  */
 223
 224 isc_result_t
 225 dns_rdata_fromwire(dns_rdata_t *rdata, dns_rdataclass_t rdclass,
 226                    dns_rdatatype_t type, isc_buffer_t *source,
 227                    dns_decompress_t *dctx, unsigned int options,
 228                    isc_buffer_t *target);
 229 /*%<
 230  * Copy the possibly-compressed rdata at source into the target region.
 231  *
 232  * Notes:
 233  *\li   Name decompression policy is controlled by 'dctx'.
 234  *
 235  *      'options'
 236  *\li   DNS_RDATA_DOWNCASE      downcase domain names when they are copied
 237  *                              into target.
 238  *
 239  * Requires:
 240  *
 241  *\li   'rdclass' and 'type' are valid.
 242  *
 243  *\li   'source' is a valid buffer, and the active region of 'source'
 244  *      references the rdata to be processed.
 245  *
 246  *\li   'target' is a valid buffer.
 247  *
 248  *\li   'dctx' is a valid decompression context.
 249  *
 250  * Ensures,
 251  *      if result is success:
 252  *      \li     If 'rdata' is not NULL, it is attached to the target.
 253  *      \li     The conditions dns_name_fromwire() ensures for names hold
 254  *              for all names in the rdata.
 255  *      \li     The current location in source is advanced, and the used space
 256  *              in target is updated.
 257  *
 258  * Result:
 259  *\li   Success
 260  *\li   Any non-success status from dns_name_fromwire()
 261  *\li   Various 'Bad Form' class failures depending on class and type
 262  *\li   Bad Form: Input too short
 263  *\li   Resource Limit: Not enough space
 264  */
 265
 266 isc_result_t
 267 dns_rdata_towire(dns_rdata_t *rdata, dns_compress_t *cctx,
 268                  isc_buffer_t *target);
 269 /*%<
 270  * Convert 'rdata' into wire format, compressing it as specified by the
 271  * compression context 'cctx', and storing the result in 'target'.
 272  *
 273  * Notes:
 274  *\li   If the compression context allows global compression, then the
 275  *      global compression table may be updated.
 276  *
 277  * Requires:
 278  *\li   'rdata' is a valid, non-empty rdata
 279  *
 280  *\li   target is a valid buffer
 281  *
 282  *\li   Any offsets specified in a global compression table are valid
 283  *      for target.
 284  *
 285  * Ensures,
 286  *      if the result is success:
 287  *      \li     The used space in target is updated.
 288  *
 289  * Returns:
 290  *\li   Success
 291  *\li   Any non-success status from dns_name_towire()
 292  *\li   Resource Limit: Not enough space
 293  */
 294
 295 isc_result_t
 296 dns_rdata_fromtext(dns_rdata_t *rdata, dns_rdataclass_t rdclass,
 297                    dns_rdatatype_t type, isc_lex_t *lexer, dns_name_t *origin,
 298                    unsigned int options, isc_mem_t *mctx,
 299                    isc_buffer_t *target, dns_rdatacallbacks_t *callbacks);
 300 /*%<
 301  * Convert the textual representation of a DNS rdata into uncompressed wire
 302  * form stored in the target region.  Tokens constituting the text of the rdata
 303  * are taken from 'lexer'.
 304  *
 305  * Notes:
 306  *\li   Relative domain names in the rdata will have 'origin' appended to them.
 307  *      A NULL origin implies "origin == dns_rootname".
 308  *
 309  *
 310  *      'options'
 311  *\li   DNS_RDATA_DOWNCASE      downcase domain names when they are copied
 312  *                              into target.
 313  *\li   DNS_RDATA_CHECKNAMES    perform checknames checks.
 314  *\li   DNS_RDATA_CHECKNAMESFAIL fail if the checknames check fail.  If
 315  *                              not set a warning will be issued.
 316  *\li   DNS_RDATA_CHECKREVERSE  this should set if the owner name ends
 317  *                              in IP6.ARPA, IP6.INT or IN-ADDR.ARPA.
 318  *
 319  * Requires:
 320  *
 321  *\li   'rdclass' and 'type' are valid.
 322  *
 323  *\li   'lexer' is a valid isc_lex_t.
 324  *
 325  *\li   'mctx' is a valid isc_mem_t.
 326  *
 327  *\li   'target' is a valid region.
 328  *
 329  *\li   'origin' if non NULL it must be absolute.
 330  *
 331  *\li   'callbacks' to be NULL or callbacks->warn and callbacks->error be
 332  *      initialized.
 333  *
 334  * Ensures,
 335  *      if result is success:
 336  *\li           If 'rdata' is not NULL, it is attached to the target.
 337
 338  *\li           The conditions dns_name_fromtext() ensures for names hold
 339  *              for all names in the rdata.
 340
 341  *\li           The used space in target is updated.
 342  *
 343  * Result:
 344  *\li   Success
 345  *\li   Translated result codes from isc_lex_gettoken
 346  *\li   Various 'Bad Form' class failures depending on class and type
 347  *\li   Bad Form: Input too short
 348  *\li   Resource Limit: Not enough space
 349  *\li   Resource Limit: Not enough memory
 350  */
 351
 352 isc_result_t
 353 dns_rdata_totext(dns_rdata_t *rdata, dns_name_t *origin, isc_buffer_t *target);
 354 /*%<
 355  * Convert 'rdata' into text format, storing the result in 'target'.
 356  * The text will consist of a single line, with fields separated by
 357  * single spaces.
 358  *
 359  * Notes:
 360  *\li   If 'origin' is not NULL, then any names in the rdata that are
 361  *      subdomains of 'origin' will be made relative it.
 362  *
 363  *\li   XXX Do we *really* want to support 'origin'?  I'm inclined towards "no"
 364  *      at the moment.
 365  *
 366  * Requires:
 367  *
 368  *\li   'rdata' is a valid, non-empty rdata
 369  *
 370  *\li   'origin' is NULL, or is a valid name
 371  *
 372  *\li   'target' is a valid text buffer
 373  *
 374  * Ensures,
 375  *      if the result is success:
 376  *
 377  *      \li     The used space in target is updated.
 378  *
 379  * Returns:
 380  *\li   Success
 381  *\li   Any non-success status from dns_name_totext()
 382  *\li   Resource Limit: Not enough space
 383  */
 384
 385 isc_result_t
 386 dns_rdata_tofmttext(dns_rdata_t *rdata, dns_name_t *origin, unsigned int flags,
 387                     unsigned int width, const char *linebreak,
 388                     isc_buffer_t *target);
 389 /*%<
 390  * Like dns_rdata_totext, but do formatted output suitable for
 391  * database dumps.  This is intended for use by dns_db_dump();
 392  * library users are discouraged from calling it directly.
 393  *
 394  * If (flags & #DNS_STYLEFLAG_MULTILINE) != 0, attempt to stay
 395  * within 'width' by breaking the text into multiple lines.
 396  * The string 'linebreak' is inserted between lines, and parentheses
 397  * are added when necessary.  Because RRs contain unbreakable elements
 398  * such as domain names whose length is variable, unpredictable, and
 399  * potentially large, there is no guarantee that the lines will
 400  * not exceed 'width' anyway.
 401  *
 402  * If (flags & #DNS_STYLEFLAG_MULTILINE) == 0, the rdata is always
 403  * printed as a single line, and no parentheses are used.
 404  * The 'width' and 'linebreak' arguments are ignored.
 405  *
 406  * If (flags & #DNS_STYLEFLAG_COMMENT) != 0, output explanatory
 407  * comments next to things like the SOA timer fields.  Some
 408  * comments (e.g., the SOA ones) are only printed when multiline
 409  * output is selected.
 410  */
 411
 412 isc_result_t
 413 dns_rdata_fromstruct(dns_rdata_t *rdata, dns_rdataclass_t rdclass,
 414                      dns_rdatatype_t type, void *source, isc_buffer_t *target);
 415 /*%<
 416  * Convert the C structure representation of an rdata into uncompressed wire
 417  * format in 'target'.
 418  *
 419  * XXX  Should we have a 'size' parameter as a sanity check on target?
 420  *
 421  * Requires:
 422  *
 423  *\li   'rdclass' and 'type' are valid.
 424  *
 425  *\li   'source' points to a valid C struct for the class and type.
 426  *
 427  *\li   'target' is a valid buffer.
 428  *
 429  *\li   All structure pointers to memory blocks should be NULL if their
 430  *      corresponding length values are zero.
 431  *
 432  * Ensures,
 433  *      if result is success:
 434  *      \li     If 'rdata' is not NULL, it is attached to the target.
 435  *
 436  *      \li     The used space in 'target' is updated.
 437  *
 438  * Result:
 439  *\li   Success
 440  *\li   Various 'Bad Form' class failures depending on class and type
 441  *\li   Resource Limit: Not enough space
 442  */
 443
 444 isc_result_t
 445 dns_rdata_tostruct(dns_rdata_t *rdata, void *target, isc_mem_t *mctx);
 446 /*%<
 447  * Convert an rdata into its C structure representation.
 448  *
 449  * If 'mctx' is NULL then 'rdata' must persist while 'target' is being used.
 450  *
 451  * If 'mctx' is non NULL then memory will be allocated if required.
 452  *
 453  * Requires:
 454  *
 455  *\li   'rdata' is a valid, non-empty rdata.
 456  *
 457  *\li   'target' to point to a valid pointer for the type and class.
 458  *
 459  * Result:
 460  *\li   Success
 461  *\li   Resource Limit: Not enough memory
 462  */
 463
 464 void
 465 dns_rdata_freestruct(void *source);
 466 /*%<
 467  * Free dynamic memory attached to 'source' (if any).
 468  *
 469  * Requires:
 470  *
 471  *\li   'source' to point to the structure previously filled in by
 472  *      dns_rdata_tostruct().
 473  */
 474
 475 isc_boolean_t
 476 dns_rdatatype_ismeta(dns_rdatatype_t type);
 477 /*%<
 478  * Return true iff the rdata type 'type' is a meta-type
 479  * like ANY or AXFR.
 480  */
 481
 482 isc_boolean_t
 483 dns_rdatatype_issingleton(dns_rdatatype_t type);
 484 /*%<
 485  * Return true iff the rdata type 'type' is a singleton type,
 486  * like CNAME or SOA.
 487  *
 488  * Requires:
 489  * \li  'type' is a valid rdata type.
 490  *
 491  */
 492
 493 isc_boolean_t
 494 dns_rdataclass_ismeta(dns_rdataclass_t rdclass);
 495 /*%<
 496  * Return true iff the rdata class 'rdclass' is a meta-class
 497  * like ANY or NONE.
 498  */
 499
 500 isc_boolean_t
 501 dns_rdatatype_isdnssec(dns_rdatatype_t type);
 502 /*%<
 503  * Return true iff 'type' is one of the DNSSEC
 504  * rdata types that may exist alongside a CNAME record.
 505  *
 506  * Requires:
 507  * \li  'type' is a valid rdata type.
 508  */
 509
 510 isc_boolean_t
 511 dns_rdatatype_iszonecutauth(dns_rdatatype_t type);
 512 /*%<
 513  * Return true iff rdata of type 'type' is considered authoritative
 514  * data (not glue) in the NSEC chain when it occurs in the parent zone
 515  * at a zone cut.
 516  *
 517  * Requires:
 518  * \li  'type' is a valid rdata type.
 519  *
 520  */
 521
 522 isc_boolean_t
 523 dns_rdatatype_isknown(dns_rdatatype_t type);
 524 /*%<
 525  * Return true iff the rdata type 'type' is known.
 526  *
 527  * Requires:
 528  * \li  'type' is a valid rdata type.
 529  *
 530  */
 531
 532
 533 isc_result_t
 534 dns_rdata_additionaldata(dns_rdata_t *rdata, dns_additionaldatafunc_t add,
 535                          void *arg);
 536 /*%<
 537  * Call 'add' for each name and type from 'rdata' which is subject to
 538  * additional section processing.
 539  *
 540  * Requires:
 541  *
 542  *\li   'rdata' is a valid, non-empty rdata.
 543  *
 544  *\li   'add' is a valid dns_additionalfunc_t.
 545  *
 546  * Ensures:
 547  *
 548  *\li   If successful, then add() will have been called for each name
 549  *      and type subject to additional section processing.
 550  *
 551  *\li   If add() returns something other than #ISC_R_SUCCESS, that result
 552  *      will be returned as the result of dns_rdata_additionaldata().
 553  *
 554  * Returns:
 555  *
 556  *\li   ISC_R_SUCCESS
 557  *
 558  *\li   Many other results are possible if not successful.
 559  */
 560
 561 isc_result_t
 562 dns_rdata_digest(dns_rdata_t *rdata, dns_digestfunc_t digest, void *arg);
 563 /*%<
 564  * Send 'rdata' in DNSSEC canonical form to 'digest'.
 565  *
 566  * Note:
 567  *\li   'digest' may be called more than once by dns_rdata_digest().  The
 568  *      concatenation of all the regions, in the order they were given
 569  *      to 'digest', will be the DNSSEC canonical form of 'rdata'.
 570  *
 571  * Requires:
 572  *
 573  *\li   'rdata' is a valid, non-empty rdata.
 574  *
 575  *\li   'digest' is a valid dns_digestfunc_t.
 576  *
 577  * Ensures:
 578  *
 579  *\li   If successful, then all of the rdata's data has been sent, in
 580  *      DNSSEC canonical form, to 'digest'.
 581  *
 582  *\li   If digest() returns something other than ISC_R_SUCCESS, that result
 583  *      will be returned as the result of dns_rdata_digest().
 584  *
 585  * Returns:
 586  *
 587  *\li   ISC_R_SUCCESS
 588  *
 589  *\li   Many other results are possible if not successful.
 590  */
 591
 592 isc_boolean_t
 593 dns_rdatatype_questiononly(dns_rdatatype_t type);
 594 /*%<
 595  * Return true iff rdata of type 'type' can only appear in the question
 596  * section of a properly formatted message.
 597  *
 598  * Requires:
 599  * \li  'type' is a valid rdata type.
 600  *
 601  */
 602
 603 isc_boolean_t
 604 dns_rdatatype_notquestion(dns_rdatatype_t type);
 605 /*%<
 606  * Return true iff rdata of type 'type' can not appear in the question
 607  * section of a properly formatted message.
 608  *
 609  * Requires:
 610  * \li  'type' is a valid rdata type.
 611  *
 612  */
 613
 614 isc_boolean_t
 615 dns_rdatatype_atparent(dns_rdatatype_t type);
 616 /*%<
 617  * Return true iff rdata of type 'type' should appear at the parent of
 618  * a zone cut.
 619  *
 620  * Requires:
 621  * \li  'type' is a valid rdata type.
 622  *
 623  */
 624
 625 unsigned int
 626 dns_rdatatype_attributes(dns_rdatatype_t rdtype);
 627 /*%<
 628  * Return attributes for the given type.
 629  *
 630  * Requires:
 631  *\li   'rdtype' are known.
 632  *
 633  * Returns:
 634  *\li   a bitmask consisting of the following flags.
 635  */
 636
 637 /*% only one may exist for a name */
 638 #define DNS_RDATATYPEATTR_SINGLETON             0x00000001U
 639 /*% requires no other data be present */
 640 #define DNS_RDATATYPEATTR_EXCLUSIVE             0x00000002U
 641 /*% Is a meta type */
 642 #define DNS_RDATATYPEATTR_META                  0x00000004U
 643 /*% Is a DNSSEC type, like RRSIG or NSEC */
 644 #define DNS_RDATATYPEATTR_DNSSEC                0x00000008U
 645 /*% Is a zone cut authority type */
 646 #define DNS_RDATATYPEATTR_ZONECUTAUTH           0x00000010U
 647 /*% Is reserved (unusable) */
 648 #define DNS_RDATATYPEATTR_RESERVED              0x00000020U
 649 /*% Is an unknown type */
 650 #define DNS_RDATATYPEATTR_UNKNOWN               0x00000040U
 651 /*% Is META, and can only be in a question section */
 652 #define DNS_RDATATYPEATTR_QUESTIONONLY          0x00000080U
 653 /*% is META, and can NOT be in a question section */
 654 #define DNS_RDATATYPEATTR_NOTQUESTION           0x00000100U
 655 /*% Is present at zone cuts in the parent, not the child */
 656 #define DNS_RDATATYPEATTR_ATPARENT              0x00000200U
 657
 658 dns_rdatatype_t
 659 dns_rdata_covers(dns_rdata_t *rdata);
 660 /*%<
 661  * Return the rdatatype that this type covers.
 662  *
 663  * Requires:
 664  *\li   'rdata' is a valid, non-empty rdata.
 665  *
 666  *\li   'rdata' is a type that covers other rdata types.
 667  *
 668  * Returns:
 669  *\li   The type covered.
 670  */
 671
 672 isc_boolean_t
 673 dns_rdata_checkowner(dns_name_t* name, dns_rdataclass_t rdclass,
 674                      dns_rdatatype_t type, isc_boolean_t wildcard);
 675 /*
 676  * Returns whether this is a valid ownername for this <type,class>.
 677  * If wildcard is true allow the first label to be a wildcard if
 678  * appropriate.
 679  *
 680  * Requires:
 681  *      'name' is a valid name.
 682  */
 683
 684 isc_boolean_t
 685 dns_rdata_checknames(dns_rdata_t *rdata, dns_name_t *owner, dns_name_t *bad);
 686 /*
 687  * Returns whether 'rdata' contains valid domain names.  The checks are
 688  * sensitive to the owner name.
 689  *
 690  * If 'bad' is non-NULL and a domain name fails the check the
 691  * the offending name will be return in 'bad' by cloning from
 692  * the 'rdata' contents.
 693  *
 694  * Requires:
 695  *      'rdata' to be valid.
 696  *      'owner' to be valid.
 697  *      'bad'   to be NULL or valid.
 698  */
 699
 700 ISC_LANG_ENDDECLS
 701
 702 #endif /* DNS_RDATA_H */