1 /* 2 * Copyright (C) 2004-2009, 2011-2013 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.80 2011/03/20 02:31:53 marka 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 #include <dns/message.h> 99 100 ISC_LANG_BEGINDECLS 101 102 103 /*** 104 *** Types 105 ***/ 106 107 /*% 108 ***** An 'rdata' is a handle to a binary region. The handle has an RR 109 ***** class and type, and the data in the binary region is in the format 110 ***** of the given class and type. 111 *****/ 112 /*% 113 * Clients are strongly discouraged from using this type directly, with 114 * the exception of the 'link' field which may be used directly for whatever 115 * purpose the client desires. 116 */ 117 struct dns_rdata { 118 unsigned char * data; 119 unsigned int length; 120 dns_rdataclass_t rdclass; 121 dns_rdatatype_t type; 122 unsigned int flags; 123 ISC_LINK(dns_rdata_t) link; 124 }; 125 126 #define DNS_RDATA_INIT { NULL, 0, 0, 0, 0, {(void*)(-1), (void *)(-1)}} 127 128 #define DNS_RDATA_CHECKINITIALIZED 129 #ifdef DNS_RDATA_CHECKINITIALIZED 130 #define DNS_RDATA_INITIALIZED(rdata) \ 131 ((rdata)->data == NULL && (rdata)->length == 0 && \ 132 (rdata)->rdclass == 0 && (rdata)->type == 0 && (rdata)->flags == 0 && \ 133 !ISC_LINK_LINKED((rdata), link)) 134 #else 135 #ifdef ISC_LIST_CHECKINIT 136 #define DNS_RDATA_INITIALIZED(rdata) \ 137 (!ISC_LINK_LINKED((rdata), link)) 138 #else 139 #define DNS_RDATA_INITIALIZED(rdata) ISC_TRUE 140 #endif 141 #endif 142 143 #define DNS_RDATA_UPDATE 0x0001 /*%< update pseudo record. */ 144 #define DNS_RDATA_OFFLINE 0x0002 /*%< RRSIG has a offline key. */ 145 146 #define DNS_RDATA_VALIDFLAGS(rdata) \ 147 (((rdata)->flags & ~(DNS_RDATA_UPDATE|DNS_RDATA_OFFLINE)) == 0) 148 149 /* 150 * The maximum length of a RDATA that can be sent on the wire. 151 * Max packet size (65535) less header (12), less name (1), type (2), 152 * class (2), ttl(4), length (2). 153 * 154 * None of the defined types that support name compression can exceed 155 * this and all new types are to be sent uncompressed. 156 */ 157 158 #define DNS_RDATA_MAXLENGTH 65512U 159 160 /* 161 * Flags affecting rdata formatting style. Flags 0xFFFF0000 162 * are used by masterfile-level formatting and defined elsewhere. 163 * See additional comments at dns_rdata_tofmttext(). 164 */ 165 166 /*% Split the rdata into multiple lines to try to keep it 167 within the "width". */ 168 #define DNS_STYLEFLAG_MULTILINE 0x00000001U 169 170 /*% Output explanatory comments. */ 171 #define DNS_STYLEFLAG_COMMENT 0x00000002U 172 #define DNS_STYLEFLAG_RRCOMMENT 0x00000004U 173 174 /*% Output KEYDATA in human readable format. */ 175 #define DNS_STYLEFLAG_KEYDATA 0x00000008U 176 177 #define DNS_RDATA_DOWNCASE DNS_NAME_DOWNCASE 178 #define DNS_RDATA_CHECKNAMES DNS_NAME_CHECKNAMES 179 #define DNS_RDATA_CHECKNAMESFAIL DNS_NAME_CHECKNAMESFAIL 180 #define DNS_RDATA_CHECKREVERSE DNS_NAME_CHECKREVERSE 181 #define DNS_RDATA_CHECKMX DNS_NAME_CHECKMX 182 #define DNS_RDATA_CHECKMXFAIL DNS_NAME_CHECKMXFAIL 183 #define DNS_RDATA_UNKNOWNESCAPE 0x80000000 184 185 /*** 186 *** Initialization 187 ***/ 188 189 void 190 dns_rdata_init(dns_rdata_t *rdata); 191 /*%< 192 * Make 'rdata' empty. 193 * 194 * Requires: 195 * 'rdata' is a valid rdata (i.e. not NULL, points to a struct dns_rdata) 196 */ 197 198 void 199 dns_rdata_reset(dns_rdata_t *rdata); 200 /*%< 201 * Make 'rdata' empty. 202 * 203 * Requires: 204 *\li 'rdata' is a previously initialized rdata and is not linked. 205 */ 206 207 void 208 dns_rdata_clone(const dns_rdata_t *src, dns_rdata_t *target); 209 /*%< 210 * Clone 'target' from 'src'. 211 * 212 * Requires: 213 *\li 'src' to be initialized. 214 *\li 'target' to be initialized. 215 */ 216 217 /*** 218 *** Comparisons 219 ***/ 220 221 int 222 dns_rdata_compare(const dns_rdata_t *rdata1, const dns_rdata_t *rdata2); 223 /*%< 224 * Determine the relative ordering under the DNSSEC order relation of 225 * 'rdata1' and 'rdata2'. 226 * 227 * Requires: 228 * 229 *\li 'rdata1' is a valid, non-empty rdata 230 * 231 *\li 'rdata2' is a valid, non-empty rdata 232 * 233 * Returns: 234 *\li < 0 'rdata1' is less than 'rdata2' 235 *\li 0 'rdata1' is equal to 'rdata2' 236 *\li > 0 'rdata1' is greater than 'rdata2' 237 */ 238 239 int 240 dns_rdata_casecompare(const dns_rdata_t *rdata1, const dns_rdata_t *rdata2); 241 /*%< 242 * dns_rdata_casecompare() is similar to dns_rdata_compare() but also 243 * compares domain names case insensitively in known rdata types that 244 * are treated as opaque data by dns_rdata_compare(). 245 * 246 * Requires: 247 * 248 *\li 'rdata1' is a valid, non-empty rdata 249 * 250 *\li 'rdata2' is a valid, non-empty rdata 251 * 252 * Returns: 253 *\li < 0 'rdata1' is less than 'rdata2' 254 *\li 0 'rdata1' is equal to 'rdata2' 255 *\li > 0 'rdata1' is greater than 'rdata2' 256 */ 257 258 /*** 259 *** Conversions 260 ***/ 261 262 void 263 dns_rdata_fromregion(dns_rdata_t *rdata, dns_rdataclass_t rdclass, 264 dns_rdatatype_t type, isc_region_t *r); 265 /*%< 266 * Make 'rdata' refer to region 'r'. 267 * 268 * Requires: 269 * 270 *\li The data in 'r' is properly formatted for whatever type it is. 271 */ 272 273 void 274 dns_rdata_toregion(const dns_rdata_t *rdata, isc_region_t *r); 275 /*%< 276 * Make 'r' refer to 'rdata'. 277 */ 278 279 isc_result_t 280 dns_rdata_fromwire(dns_rdata_t *rdata, dns_rdataclass_t rdclass, 281 dns_rdatatype_t type, isc_buffer_t *source, 282 dns_decompress_t *dctx, unsigned int options, 283 isc_buffer_t *target); 284 /*%< 285 * Copy the possibly-compressed rdata at source into the target region. 286 * 287 * Notes: 288 *\li Name decompression policy is controlled by 'dctx'. 289 * 290 * 'options' 291 *\li DNS_RDATA_DOWNCASE downcase domain names when they are copied 292 * into target. 293 * 294 * Requires: 295 * 296 *\li 'rdclass' and 'type' are valid. 297 * 298 *\li 'source' is a valid buffer, and the active region of 'source' 299 * references the rdata to be processed. 300 * 301 *\li 'target' is a valid buffer. 302 * 303 *\li 'dctx' is a valid decompression context. 304 * 305 * Ensures, 306 * if result is success: 307 * \li If 'rdata' is not NULL, it is attached to the target. 308 * \li The conditions dns_name_fromwire() ensures for names hold 309 * for all names in the rdata. 310 * \li The current location in source is advanced, and the used space 311 * in target is updated. 312 * 313 * Result: 314 *\li Success 315 *\li Any non-success status from dns_name_fromwire() 316 *\li Various 'Bad Form' class failures depending on class and type 317 *\li Bad Form: Input too short 318 *\li Resource Limit: Not enough space 319 */ 320 321 isc_result_t 322 dns_rdata_towire(dns_rdata_t *rdata, dns_compress_t *cctx, 323 isc_buffer_t *target); 324 /*%< 325 * Convert 'rdata' into wire format, compressing it as specified by the 326 * compression context 'cctx', and storing the result in 'target'. 327 * 328 * Notes: 329 *\li If the compression context allows global compression, then the 330 * global compression table may be updated. 331 * 332 * Requires: 333 *\li 'rdata' is a valid, non-empty rdata 334 * 335 *\li target is a valid buffer 336 * 337 *\li Any offsets specified in a global compression table are valid 338 * for target. 339 * 340 * Ensures, 341 * if the result is success: 342 * \li The used space in target is updated. 343 * 344 * Returns: 345 *\li Success 346 *\li Any non-success status from dns_name_towire() 347 *\li Resource Limit: Not enough space 348 */ 349 350 isc_result_t 351 dns_rdata_fromtext(dns_rdata_t *rdata, dns_rdataclass_t rdclass, 352 dns_rdatatype_t type, isc_lex_t *lexer, dns_name_t *origin, 353 unsigned int options, isc_mem_t *mctx, 354 isc_buffer_t *target, dns_rdatacallbacks_t *callbacks); 355 /*%< 356 * Convert the textual representation of a DNS rdata into uncompressed wire 357 * form stored in the target region. Tokens constituting the text of the rdata 358 * are taken from 'lexer'. 359 * 360 * Notes: 361 *\li Relative domain names in the rdata will have 'origin' appended to them. 362 * A NULL origin implies "origin == dns_rootname". 363 * 364 * 365 * 'options' 366 *\li DNS_RDATA_DOWNCASE downcase domain names when they are copied 367 * into target. 368 *\li DNS_RDATA_CHECKNAMES perform checknames checks. 369 *\li DNS_RDATA_CHECKNAMESFAIL fail if the checknames check fail. If 370 * not set a warning will be issued. 371 *\li DNS_RDATA_CHECKREVERSE this should set if the owner name ends 372 * in IP6.ARPA, IP6.INT or IN-ADDR.ARPA. 373 * 374 * Requires: 375 * 376 *\li 'rdclass' and 'type' are valid. 377 * 378 *\li 'lexer' is a valid isc_lex_t. 379 * 380 *\li 'mctx' is a valid isc_mem_t. 381 * 382 *\li 'target' is a valid region. 383 * 384 *\li 'origin' if non NULL it must be absolute. 385 * 386 *\li 'callbacks' to be NULL or callbacks->warn and callbacks->error be 387 * initialized. 388 * 389 * Ensures, 390 * if result is success: 391 *\li If 'rdata' is not NULL, it is attached to the target. 392 393 *\li The conditions dns_name_fromtext() ensures for names hold 394 * for all names in the rdata. 395 396 *\li The used space in target is updated. 397 * 398 * Result: 399 *\li Success 400 *\li Translated result codes from isc_lex_gettoken 401 *\li Various 'Bad Form' class failures depending on class and type 402 *\li Bad Form: Input too short 403 *\li Resource Limit: Not enough space 404 *\li Resource Limit: Not enough memory 405 */ 406 407 isc_result_t 408 dns_rdata_totext(dns_rdata_t *rdata, dns_name_t *origin, isc_buffer_t *target); 409 /*%< 410 * Convert 'rdata' into text format, storing the result in 'target'. 411 * The text will consist of a single line, with fields separated by 412 * single spaces. 413 * 414 * Notes: 415 *\li If 'origin' is not NULL, then any names in the rdata that are 416 * subdomains of 'origin' will be made relative it. 417 * 418 *\li XXX Do we *really* want to support 'origin'? I'm inclined towards "no" 419 * at the moment. 420 * 421 * Requires: 422 * 423 *\li 'rdata' is a valid, non-empty rdata 424 * 425 *\li 'origin' is NULL, or is a valid name 426 * 427 *\li 'target' is a valid text buffer 428 * 429 * Ensures, 430 * if the result is success: 431 * 432 * \li The used space in target is updated. 433 * 434 * Returns: 435 *\li Success 436 *\li Any non-success status from dns_name_totext() 437 *\li Resource Limit: Not enough space 438 */ 439 440 isc_result_t 441 dns_rdata_tofmttext(dns_rdata_t *rdata, dns_name_t *origin, unsigned int flags, 442 unsigned int width, unsigned int split_width, 443 const char *linebreak, isc_buffer_t *target); 444 /*%< 445 * Like dns_rdata_totext, but do formatted output suitable for 446 * database dumps. This is intended for use by dns_db_dump(); 447 * library users are discouraged from calling it directly. 448 * 449 * If (flags & #DNS_STYLEFLAG_MULTILINE) != 0, attempt to stay 450 * within 'width' by breaking the text into multiple lines. 451 * The string 'linebreak' is inserted between lines, and parentheses 452 * are added when necessary. Because RRs contain unbreakable elements 453 * such as domain names whose length is variable, unpredictable, and 454 * potentially large, there is no guarantee that the lines will 455 * not exceed 'width' anyway. 456 * 457 * If (flags & #DNS_STYLEFLAG_MULTILINE) == 0, the rdata is always 458 * printed as a single line, and no parentheses are used. 459 * The 'width' and 'linebreak' arguments are ignored. 460 * 461 * If (flags & #DNS_STYLEFLAG_COMMENT) != 0, output explanatory 462 * comments next to things like the SOA timer fields. Some 463 * comments (e.g., the SOA ones) are only printed when multiline 464 * output is selected. 465 * 466 * base64 rdata text (e.g., DNSKEY records) will be split into chunks 467 * of 'split_width' characters. If split_width == 0, the text will 468 * not be split at all. If split_width == UINT_MAX (0xffffffff), then 469 * it is undefined and falls back to the default value of 'width' 470 */ 471 472 isc_result_t 473 dns_rdata_fromstruct(dns_rdata_t *rdata, dns_rdataclass_t rdclass, 474 dns_rdatatype_t type, void *source, isc_buffer_t *target); 475 /*%< 476 * Convert the C structure representation of an rdata into uncompressed wire 477 * format in 'target'. 478 * 479 * XXX Should we have a 'size' parameter as a sanity check on target? 480 * 481 * Requires: 482 * 483 *\li 'rdclass' and 'type' are valid. 484 * 485 *\li 'source' points to a valid C struct for the class and type. 486 * 487 *\li 'target' is a valid buffer. 488 * 489 *\li All structure pointers to memory blocks should be NULL if their 490 * corresponding length values are zero. 491 * 492 * Ensures, 493 * if result is success: 494 * \li If 'rdata' is not NULL, it is attached to the target. 495 * 496 * \li The used space in 'target' is updated. 497 * 498 * Result: 499 *\li Success 500 *\li Various 'Bad Form' class failures depending on class and type 501 *\li Resource Limit: Not enough space 502 */ 503 504 isc_result_t 505 dns_rdata_tostruct(dns_rdata_t *rdata, void *target, isc_mem_t *mctx); 506 /*%< 507 * Convert an rdata into its C structure representation. 508 * 509 * If 'mctx' is NULL then 'rdata' must persist while 'target' is being used. 510 * 511 * If 'mctx' is non NULL then memory will be allocated if required. 512 * 513 * Requires: 514 * 515 *\li 'rdata' is a valid, non-empty rdata. 516 * 517 *\li 'target' to point to a valid pointer for the type and class. 518 * 519 * Result: 520 *\li Success 521 *\li Resource Limit: Not enough memory 522 */ 523 524 void 525 dns_rdata_freestruct(void *source); 526 /*%< 527 * Free dynamic memory attached to 'source' (if any). 528 * 529 * Requires: 530 * 531 *\li 'source' to point to the structure previously filled in by 532 * dns_rdata_tostruct(). 533 */ 534 535 isc_boolean_t 536 dns_rdatatype_ismeta(dns_rdatatype_t type); 537 /*%< 538 * Return true iff the rdata type 'type' is a meta-type 539 * like ANY or AXFR. 540 */ 541 542 isc_boolean_t 543 dns_rdatatype_issingleton(dns_rdatatype_t type); 544 /*%< 545 * Return true iff the rdata type 'type' is a singleton type, 546 * like CNAME or SOA. 547 * 548 * Requires: 549 * \li 'type' is a valid rdata type. 550 * 551 */ 552 553 isc_boolean_t 554 dns_rdataclass_ismeta(dns_rdataclass_t rdclass); 555 /*%< 556 * Return true iff the rdata class 'rdclass' is a meta-class 557 * like ANY or NONE. 558 */ 559 560 isc_boolean_t 561 dns_rdatatype_isdnssec(dns_rdatatype_t type); 562 /*%< 563 * Return true iff 'type' is one of the DNSSEC 564 * rdata types that may exist alongside a CNAME record. 565 * 566 * Requires: 567 * \li 'type' is a valid rdata type. 568 */ 569 570 isc_boolean_t 571 dns_rdatatype_iszonecutauth(dns_rdatatype_t type); 572 /*%< 573 * Return true iff rdata of type 'type' is considered authoritative 574 * data (not glue) in the NSEC chain when it occurs in the parent zone 575 * at a zone cut. 576 * 577 * Requires: 578 * \li 'type' is a valid rdata type. 579 * 580 */ 581 582 isc_boolean_t 583 dns_rdatatype_isknown(dns_rdatatype_t type); 584 /*%< 585 * Return true iff the rdata type 'type' is known. 586 * 587 * Requires: 588 * \li 'type' is a valid rdata type. 589 * 590 */ 591 592 593 isc_result_t 594 dns_rdata_additionaldata(dns_rdata_t *rdata, dns_additionaldatafunc_t add, 595 void *arg); 596 /*%< 597 * Call 'add' for each name and type from 'rdata' which is subject to 598 * additional section processing. 599 * 600 * Requires: 601 * 602 *\li 'rdata' is a valid, non-empty rdata. 603 * 604 *\li 'add' is a valid dns_additionalfunc_t. 605 * 606 * Ensures: 607 * 608 *\li If successful, then add() will have been called for each name 609 * and type subject to additional section processing. 610 * 611 *\li If add() returns something other than #ISC_R_SUCCESS, that result 612 * will be returned as the result of dns_rdata_additionaldata(). 613 * 614 * Returns: 615 * 616 *\li ISC_R_SUCCESS 617 * 618 *\li Many other results are possible if not successful. 619 */ 620 621 isc_result_t 622 dns_rdata_digest(dns_rdata_t *rdata, dns_digestfunc_t digest, void *arg); 623 /*%< 624 * Send 'rdata' in DNSSEC canonical form to 'digest'. 625 * 626 * Note: 627 *\li 'digest' may be called more than once by dns_rdata_digest(). The 628 * concatenation of all the regions, in the order they were given 629 * to 'digest', will be the DNSSEC canonical form of 'rdata'. 630 * 631 * Requires: 632 * 633 *\li 'rdata' is a valid, non-empty rdata. 634 * 635 *\li 'digest' is a valid dns_digestfunc_t. 636 * 637 * Ensures: 638 * 639 *\li If successful, then all of the rdata's data has been sent, in 640 * DNSSEC canonical form, to 'digest'. 641 * 642 *\li If digest() returns something other than ISC_R_SUCCESS, that result 643 * will be returned as the result of dns_rdata_digest(). 644 * 645 * Returns: 646 * 647 *\li ISC_R_SUCCESS 648 * 649 *\li Many other results are possible if not successful. 650 */ 651 652 isc_boolean_t 653 dns_rdatatype_questiononly(dns_rdatatype_t type); 654 /*%< 655 * Return true iff rdata of type 'type' can only appear in the question 656 * section of a properly formatted message. 657 * 658 * Requires: 659 * \li 'type' is a valid rdata type. 660 * 661 */ 662 663 isc_boolean_t 664 dns_rdatatype_notquestion(dns_rdatatype_t type); 665 /*%< 666 * Return true iff rdata of type 'type' can not appear in the question 667 * section of a properly formatted message. 668 * 669 * Requires: 670 * \li 'type' is a valid rdata type. 671 * 672 */ 673 674 isc_boolean_t 675 dns_rdatatype_atparent(dns_rdatatype_t type); 676 /*%< 677 * Return true iff rdata of type 'type' should appear at the parent of 678 * a zone cut. 679 * 680 * Requires: 681 * \li 'type' is a valid rdata type. 682 * 683 */ 684 685 unsigned int 686 dns_rdatatype_attributes(dns_rdatatype_t rdtype); 687 /*%< 688 * Return attributes for the given type. 689 * 690 * Requires: 691 *\li 'rdtype' are known. 692 * 693 * Returns: 694 *\li a bitmask consisting of the following flags. 695 */ 696 697 /*% only one may exist for a name */ 698 #define DNS_RDATATYPEATTR_SINGLETON 0x00000001U 699 /*% requires no other data be present */ 700 #define DNS_RDATATYPEATTR_EXCLUSIVE 0x00000002U 701 /*% Is a meta type */ 702 #define DNS_RDATATYPEATTR_META 0x00000004U 703 /*% Is a DNSSEC type, like RRSIG or NSEC */ 704 #define DNS_RDATATYPEATTR_DNSSEC 0x00000008U 705 /*% Is a zone cut authority type */ 706 #define DNS_RDATATYPEATTR_ZONECUTAUTH 0x00000010U 707 /*% Is reserved (unusable) */ 708 #define DNS_RDATATYPEATTR_RESERVED 0x00000020U 709 /*% Is an unknown type */ 710 #define DNS_RDATATYPEATTR_UNKNOWN 0x00000040U 711 /*% Is META, and can only be in a question section */ 712 #define DNS_RDATATYPEATTR_QUESTIONONLY 0x00000080U 713 /*% is META, and can NOT be in a question section */ 714 #define DNS_RDATATYPEATTR_NOTQUESTION 0x00000100U 715 /*% Is present at zone cuts in the parent, not the child */ 716 #define DNS_RDATATYPEATTR_ATPARENT 0x00000200U 717 718 dns_rdatatype_t 719 dns_rdata_covers(dns_rdata_t *rdata); 720 /*%< 721 * Return the rdatatype that this type covers. 722 * 723 * Requires: 724 *\li 'rdata' is a valid, non-empty rdata. 725 * 726 *\li 'rdata' is a type that covers other rdata types. 727 * 728 * Returns: 729 *\li The type covered. 730 */ 731 732 isc_boolean_t 733 dns_rdata_checkowner(dns_name_t* name, dns_rdataclass_t rdclass, 734 dns_rdatatype_t type, isc_boolean_t wildcard); 735 /* 736 * Returns whether this is a valid ownername for this <type,class>. 737 * If wildcard is true allow the first label to be a wildcard if 738 * appropriate. 739 * 740 * Requires: 741 * 'name' is a valid name. 742 */ 743 744 isc_boolean_t 745 dns_rdata_checknames(dns_rdata_t *rdata, dns_name_t *owner, dns_name_t *bad); 746 /* 747 * Returns whether 'rdata' contains valid domain names. The checks are 748 * sensitive to the owner name. 749 * 750 * If 'bad' is non-NULL and a domain name fails the check the 751 * the offending name will be return in 'bad' by cloning from 752 * the 'rdata' contents. 753 * 754 * Requires: 755 * 'rdata' to be valid. 756 * 'owner' to be valid. 757 * 'bad' to be NULL or valid. 758 */ 759 760 void 761 dns_rdata_exists(dns_rdata_t *rdata, dns_rdatatype_t type); 762 763 void 764 dns_rdata_notexist(dns_rdata_t *rdata, dns_rdatatype_t type); 765 766 void 767 dns_rdata_deleterrset(dns_rdata_t *rdata, dns_rdatatype_t type); 768 769 void 770 dns_rdata_makedelete(dns_rdata_t *rdata); 771 772 const char * 773 dns_rdata_updateop(dns_rdata_t *rdata, dns_section_t section); 774 775 ISC_LANG_ENDDECLS 776 777 #endif /* DNS_RDATA_H */ 778