contrib/ldns/rr.c

   1 /* rr.c
   2  *
   3  * access functions for ldns_rr -
   4  * a Net::DNS like library for C
   5  * LibDNS Team @ NLnet Labs
   6  *
   7  * (c) NLnet Labs, 2004-2006
   8  * See the file LICENSE for the license
   9  */
  10 #include <ldns/config.h>
  11
  12 #include <ldns/ldns.h>
  13
  14 #include <strings.h>
  15 #include <limits.h>
  16
  17 #include <errno.h>
  18
  19 #define LDNS_SYNTAX_DATALEN 16
  20 #define LDNS_TTL_DATALEN    21
  21 #define LDNS_RRLIST_INIT    8
  22
  23 ldns_rr *
  24 ldns_rr_new(void)
  25 {
  26         ldns_rr *rr;
  27         rr = LDNS_MALLOC(ldns_rr);
  28         if (!rr) {
  29                 return NULL;
  30         }
  31
  32         ldns_rr_set_owner(rr, NULL);
  33         ldns_rr_set_question(rr, false);
  34         ldns_rr_set_rd_count(rr, 0);
  35         rr->_rdata_fields = NULL;
  36         ldns_rr_set_class(rr, LDNS_RR_CLASS_IN);
  37         ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL);
  38         return rr;
  39 }
  40
  41 ldns_rr *
  42 ldns_rr_new_frm_type(ldns_rr_type t)
  43 {
  44         ldns_rr *rr;
  45         const ldns_rr_descriptor *desc;
  46         size_t i;
  47
  48         rr = LDNS_MALLOC(ldns_rr);
  49         if (!rr) {
  50                 return NULL;
  51         }
  52
  53         desc = ldns_rr_descript(t);
  54
  55         rr->_rdata_fields = LDNS_XMALLOC(ldns_rdf *, ldns_rr_descriptor_minimum(desc));
  56         for (i = 0; i < ldns_rr_descriptor_minimum(desc); i++) {
  57                 rr->_rdata_fields[i] = NULL;
  58         }
  59
  60         ldns_rr_set_owner(rr, NULL);
  61         ldns_rr_set_question(rr, false);
  62         /* set the count to minimum */
  63         ldns_rr_set_rd_count(rr, ldns_rr_descriptor_minimum(desc));
  64         ldns_rr_set_class(rr, LDNS_RR_CLASS_IN);
  65         ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL);
  66         ldns_rr_set_type(rr, t);
  67         return rr;
  68 }
  69
  70 void
  71 ldns_rr_free(ldns_rr *rr)
  72 {
  73         size_t i;
  74         if (rr) {
  75                 if (ldns_rr_owner(rr)) {
  76                         ldns_rdf_deep_free(ldns_rr_owner(rr));
  77                 }
  78                 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
  79                         ldns_rdf_deep_free(ldns_rr_rdf(rr, i));
  80                 }
  81                 LDNS_FREE(rr->_rdata_fields);
  82                 LDNS_FREE(rr);
  83         }
  84 }
  85
  86 /*
  87  * trailing spaces are allowed
  88  * leading spaces are not allowed
  89  * allow ttl to be optional
  90  * class is optional too
  91  * if ttl is missing, and default_ttl is 0, use DEF_TTL
  92  * allow ttl to be written as 1d3h
  93  * So the RR should look like. e.g.
  94  * miek.nl. 3600 IN MX 10 elektron.atoom.net
  95  * or
  96  * miek.nl. 1h IN MX 10 elektron.atoom.net
  97  * or
  98  * miek.nl. IN MX 10 elektron.atoom.net
  99  */
 100 static ldns_status
 101 ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str,
 102                              uint32_t default_ttl, ldns_rdf *origin,
 103                              ldns_rdf **prev, bool question)
 104 {
 105         ldns_rr *new;
 106         const ldns_rr_descriptor *desc;
 107         ldns_rr_type rr_type;
 108         ldns_buffer *rr_buf;
 109         ldns_buffer *rd_buf;
 110         uint32_t ttl_val;
 111         char  *owner;
 112         char  *ttl;
 113         ldns_rr_class clas_val;
 114         char  *clas;
 115         char  *type = NULL;
 116         char  *rdata;
 117         char  *rd;
 118         char  *b64;
 119         size_t rd_strlen;
 120         const char *delimiters;
 121         ssize_t c;
 122         ldns_rdf *owner_dname;
 123     const char* endptr;
 124
 125         /* used for types with unknown number of rdatas */
 126         bool done;
 127         bool quoted;
 128
 129         ldns_rdf *r = NULL;
 130         uint16_t r_cnt;
 131         uint16_t r_min;
 132         uint16_t r_max;
 133
 134         uint16_t hex_data_size;
 135         char *hex_data_str;
 136         uint16_t cur_hex_data_size;
 137         uint8_t *hex_data;
 138         size_t hex_pos;
 139
 140         new = ldns_rr_new();
 141
 142         owner = LDNS_XMALLOC(char, LDNS_MAX_DOMAINLEN + 1);
 143         ttl = LDNS_XMALLOC(char, LDNS_TTL_DATALEN);
 144         clas = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
 145         rdata = LDNS_XMALLOC(char, LDNS_MAX_PACKETLEN + 1);
 146         rr_buf = LDNS_MALLOC(ldns_buffer);
 147         rd_buf = LDNS_MALLOC(ldns_buffer);
 148         rd = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
 149         b64 = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
 150         if (!new || !owner || !ttl || !clas || !rdata || !rr_buf || !rd_buf || !rd || !b64 ) {
 151                 return LDNS_STATUS_MEM_ERR;
 152         }
 153         r_cnt = 0;
 154         ttl_val = 0;
 155         clas_val = 0;
 156
 157         ldns_buffer_new_frm_data(rr_buf, (char*)str, strlen(str));
 158
 159         /* split the rr in its parts -1 signals trouble */
 160         if (ldns_bget_token(rr_buf, owner, "\t\n ", LDNS_MAX_DOMAINLEN) == -1) {
 161                 LDNS_FREE(owner);
 162                 LDNS_FREE(ttl);
 163                 LDNS_FREE(clas);
 164                 LDNS_FREE(rdata);
 165                 LDNS_FREE(rd);
 166                 LDNS_FREE(rd_buf);
 167                 LDNS_FREE(b64);
 168                 ldns_buffer_free(rr_buf);
 169                 ldns_rr_free(new);
 170                 return LDNS_STATUS_SYNTAX_ERR;
 171         }
 172
 173         if (ldns_bget_token(rr_buf, ttl, "\t\n ", LDNS_TTL_DATALEN) == -1) {
 174                 LDNS_FREE(owner);
 175                 LDNS_FREE(ttl);
 176                 LDNS_FREE(clas);
 177                 LDNS_FREE(rdata);
 178                 LDNS_FREE(rd);
 179                 LDNS_FREE(rd_buf);
 180                 LDNS_FREE(b64);
 181                 ldns_buffer_free(rr_buf);
 182                 ldns_rr_free(new);
 183                 return LDNS_STATUS_SYNTAX_TTL_ERR;
 184         }
 185         ttl_val = (uint32_t) ldns_str2period(ttl, &endptr);
 186
 187         if (strlen(ttl) > 0 && !isdigit((int) ttl[0])) {
 188                 /* ah, it's not there or something */
 189                 if (default_ttl == 0) {
 190                         ttl_val = LDNS_DEFAULT_TTL;
 191                 } else {
 192                         ttl_val = default_ttl;
 193                 }
 194                 /* we not ASSUMING the TTL is missing and that
 195                  * the rest of the RR is still there. That is
 196                  * CLASS TYPE RDATA
 197                  * so ttl value we read is actually the class
 198                  */
 199                 clas_val = ldns_get_rr_class_by_name(ttl);
 200                 /* class can be left out too, assume IN, current
 201                  * token must be type
 202                  */
 203                 if (clas_val == 0) {
 204                         clas_val = LDNS_RR_CLASS_IN;
 205                         type = LDNS_XMALLOC(char, strlen(ttl) + 1);
 206                         strncpy(type, ttl, strlen(ttl) + 1);
 207                 }
 208         } else {
 209                 if (ldns_bget_token(rr_buf, clas, "\t\n ", LDNS_SYNTAX_DATALEN) == -1) {
 210                         LDNS_FREE(owner);
 211                         LDNS_FREE(ttl);
 212                         LDNS_FREE(clas);
 213                         LDNS_FREE(rdata);
 214                         LDNS_FREE(rd);
 215                         LDNS_FREE(rd_buf);
 216                         ldns_buffer_free(rr_buf);
 217                         ldns_rr_free(new);
 218                         return LDNS_STATUS_SYNTAX_CLASS_ERR;
 219                 }
 220                 clas_val = ldns_get_rr_class_by_name(clas);
 221                 /* class can be left out too, assume IN, current
 222                  * token must be type
 223                  */
 224                 if (clas_val == 0) {
 225                         clas_val = LDNS_RR_CLASS_IN;
 226                         type = LDNS_XMALLOC(char, strlen(clas) + 1);
 227                         strncpy(type, clas, strlen(clas) + 1);
 228                 }
 229         }
 230         /* the rest should still be waiting for us */
 231
 232         if (!type) {
 233                 type = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
 234                 if (ldns_bget_token(rr_buf, type, "\t\n ", LDNS_SYNTAX_DATALEN) == -1) {
 235                         LDNS_FREE(owner);
 236                         LDNS_FREE(ttl);
 237                         LDNS_FREE(clas);
 238                         LDNS_FREE(rdata);
 239                         LDNS_FREE(rd);
 240                         LDNS_FREE(rd_buf);
 241                         ldns_buffer_free(rr_buf);
 242                         ldns_rr_free(new);
 243                         return LDNS_STATUS_SYNTAX_TYPE_ERR;
 244                 }
 245         }
 246
 247         if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) {
 248                 /* apparently we are done, and it's only a question RR
 249                  * so do not free and error here
 250                 LDNS_FREE(owner);
 251                 LDNS_FREE(ttl);
 252                 LDNS_FREE(clas);
 253                 LDNS_FREE(type);
 254                 LDNS_FREE(rdata);
 255                 LDNS_FREE(rd);
 256                 LDNS_FREE(rd_buf);
 257                 ldns_buffer_free(rr_buf);
 258                 ldns_rr_free(new);
 259                 return NULL;
 260                 */
 261         }
 262
 263         ldns_buffer_new_frm_data(rd_buf, rdata, strlen(rdata));
 264
 265         if (strlen(owner) <= 1 && strncmp(owner, "@", 1) == 0) {
 266                 if (origin) {
 267                         ldns_rr_set_owner(new, ldns_rdf_clone(origin));
 268                 } else if (prev && *prev) {
 269                         ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
 270                 } else {
 271                         /* default to root */
 272                         ldns_rr_set_owner(new, ldns_dname_new_frm_str("."));
 273                 }
 274
 275                 /* @ also overrides prev */
 276                 if (prev) {
 277                         ldns_rdf_deep_free(*prev);
 278                         *prev = ldns_rdf_clone(ldns_rr_owner(new));
 279                 }
 280         } else {
 281                 if (strlen(owner) == 0) {
 282                         /* no ownername was given, try prev, if that fails
 283                          * origin, else default to root */
 284                         if (prev && *prev) {
 285                                 ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
 286                         } else if (origin) {
 287                                 ldns_rr_set_owner(new, ldns_rdf_clone(origin));
 288                         } else {
 289                                 ldns_rr_set_owner(new, ldns_dname_new_frm_str("."));
 290                         }
 291                 } else {
 292                         owner_dname = ldns_dname_new_frm_str(owner);
 293                         if (!owner_dname) {
 294                                         LDNS_FREE(owner);
 295                                         LDNS_FREE(ttl);
 296                                         LDNS_FREE(clas);
 297                                         LDNS_FREE(type);
 298                                         LDNS_FREE(rdata);
 299                                         LDNS_FREE(rd);
 300                                         LDNS_FREE(rd_buf);
 301                                         ldns_buffer_free(rr_buf);
 302                                         ldns_rr_free(new);
 303                                         return LDNS_STATUS_SYNTAX_ERR;
 304                         }
 305
 306                         ldns_rr_set_owner(new, owner_dname);
 307                         if (!ldns_dname_str_absolute(owner) && origin) {
 308                                 if(ldns_dname_cat(ldns_rr_owner(new),
 309                                                         origin) != LDNS_STATUS_OK) {
 310                                         LDNS_FREE(owner);
 311                                         LDNS_FREE(ttl);
 312                                         LDNS_FREE(clas);
 313                                         LDNS_FREE(type);
 314                                         LDNS_FREE(rdata);
 315                                         LDNS_FREE(rd);
 316                                         LDNS_FREE(rd_buf);
 317                                         ldns_buffer_free(rr_buf);
 318                                         ldns_rr_free(new);
 319                                         return LDNS_STATUS_SYNTAX_ERR;
 320                                 }
 321                         }
 322                         if (prev) {
 323                                 ldns_rdf_deep_free(*prev);
 324                                 *prev = ldns_rdf_clone(ldns_rr_owner(new));
 325                         }
 326                 }
 327         }
 328         LDNS_FREE(owner);
 329
 330         ldns_rr_set_question(new, question);
 331
 332         ldns_rr_set_ttl(new, ttl_val);
 333         LDNS_FREE(ttl);
 334
 335         ldns_rr_set_class(new, clas_val);
 336         LDNS_FREE(clas);
 337
 338         rr_type = ldns_get_rr_type_by_name(type);
 339         LDNS_FREE(type);
 340
 341         desc = ldns_rr_descript((uint16_t)rr_type);
 342         ldns_rr_set_type(new, rr_type);
 343         if (desc) {
 344                 /* only the rdata remains */
 345                 r_max = ldns_rr_descriptor_maximum(desc);
 346                 r_min = ldns_rr_descriptor_minimum(desc);
 347         } else {
 348                 r_min = 0;
 349                 r_max = 1;
 350         }
 351
 352         /* depending on the rr_type we need to extract
 353          * the rdata differently, e.g. NSEC/NSEC3 */
 354         switch(rr_type) {
 355                 default:
 356                         done = false;
 357
 358                         for (r_cnt = 0; !done && r_cnt < r_max; r_cnt++) {
 359                                 quoted = false;
 360                                 /* if type = B64, the field may contain spaces */
 361                                 if (ldns_rr_descriptor_field_type(desc,
 362                                             r_cnt) == LDNS_RDF_TYPE_B64 ||
 363                                     ldns_rr_descriptor_field_type(desc,
 364                                             r_cnt) == LDNS_RDF_TYPE_HEX ||
 365                                     ldns_rr_descriptor_field_type(desc,
 366                                             r_cnt) == LDNS_RDF_TYPE_LOC ||
 367                                     ldns_rr_descriptor_field_type(desc,
 368                                             r_cnt) == LDNS_RDF_TYPE_WKS ||
 369                                     ldns_rr_descriptor_field_type(desc,
 370                                             r_cnt) == LDNS_RDF_TYPE_IPSECKEY ||
 371                                     ldns_rr_descriptor_field_type(desc,
 372                                             r_cnt) == LDNS_RDF_TYPE_NSEC) {
 373                                         delimiters = "\n\t";
 374                                 } else {
 375                                         delimiters = "\n\t ";
 376                                 }
 377
 378                                 if (ldns_rr_descriptor_field_type(desc,
 379                                                         r_cnt) == LDNS_RDF_TYPE_STR &&
 380                                                         ldns_buffer_remaining(rd_buf) > 0) {
 381                                         /* skip spaces */
 382                                         while (*(ldns_buffer_current(rd_buf)) == ' ') {
 383                                                 ldns_buffer_skip(rd_buf, 1);
 384                                         }
 385
 386                                         if (*(ldns_buffer_current(rd_buf)) == '\"') {
 387                                                 delimiters = "\"\0";
 388                                                 ldns_buffer_skip(rd_buf, 1);
 389                                                 quoted = true;
 390                                         }
 391                                 }
 392
 393                                 /* because number of fields can be variable, we can't
 394                                    rely on _maximum() only */
 395                                 /* skip spaces */
 396                                 while (ldns_buffer_position(rd_buf) < ldns_buffer_limit(rd_buf) &&
 397                                         *(ldns_buffer_current(rd_buf)) == ' '
 398                                       ) {
 399                                         ldns_buffer_skip(rd_buf, 1);
 400                                 }
 401
 402                                 if ((c = ldns_bget_token(rd_buf, rd, delimiters,
 403                                                         LDNS_MAX_RDFLEN)) != -1) {
 404                                         /* hmmz, rfc3597 specifies that any type can be represented with
 405                                          * \# method, which can contain spaces...
 406                                          * it does specify size though...
 407                                          */
 408                                         rd_strlen = strlen(rd);
 409
 410                                         /* unknown RR data */
 411                                         if (rd_strlen == 2 && strncmp(rd, "\\#", 2) == 0 && !quoted) {
 412                                                 c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN);
 413                                                 if (c == -1) {
 414                                                         /* something goes very wrong here */
 415                                                         ldns_buffer_free(rd_buf);
 416                                                         LDNS_FREE(rd);
 417                                                         return LDNS_STATUS_SYNTAX_RDATA_ERR;
 418                                                 }
 419                                                 hex_data_size = (uint16_t) atoi(rd);
 420                                                 /* copy the hex chars into hex str (which is 2 chars per byte) */
 421                                                 hex_data_str = LDNS_XMALLOC(char, 2 * hex_data_size + 1);
 422                                                 if (!hex_data_str) {
 423                                                         /* malloc error */
 424                                                         ldns_buffer_free(rd_buf);
 425                                                         LDNS_FREE(rd);
 426                                                         return LDNS_STATUS_SYNTAX_RDATA_ERR;
 427                                                 }
 428                                                 cur_hex_data_size = 0;
 429                                                 while(cur_hex_data_size < 2 * hex_data_size) {
 430                                                         c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN);
 431                                                         rd_strlen = strlen(rd);
 432                                                         strncpy(hex_data_str + cur_hex_data_size, rd, rd_strlen);
 433                                                         cur_hex_data_size += rd_strlen;
 434                                                 }
 435                                                 hex_data_str[cur_hex_data_size] = '\0';
 436
 437                                                 /* correct the rdf type */
 438                                                 /* if *we* know the type, interpret it as wireformat */
 439                                                 if (desc) {
 440                                                         hex_data = LDNS_XMALLOC(uint8_t, hex_data_size + 2);
 441                                                         ldns_write_uint16(hex_data, hex_data_size);
 442                                                         ldns_hexstring_to_data(hex_data + 2, hex_data_str);
 443                                                         hex_pos = 0;
 444                                                         (void) ldns_wire2rdf(new, hex_data,
 445                                                                          hex_data_size+2, &hex_pos);
 446                                                         LDNS_FREE(hex_data);
 447                                                 } else {
 448                                                         r = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_HEX, hex_data_str);
 449                                                         ldns_rdf_set_type(r, LDNS_RDF_TYPE_UNKNOWN);
 450                                                         ldns_rr_push_rdf(new, r);
 451                                                 }
 452                                                 LDNS_FREE(hex_data_str);
 453                                         } else {
 454                                                 /* Normal RR */
 455                                                 switch(ldns_rr_descriptor_field_type(desc, r_cnt)) {
 456                                                 case LDNS_RDF_TYPE_HEX:
 457                                                 case LDNS_RDF_TYPE_B64:
 458                                                         /* can have spaces, and will always be the last
 459                                                          * record of the rrdata. Read in the rest */
 460                                                         if ((c = ldns_bget_token(rd_buf,
 461                                                                                                 b64,
 462                                                                                                 "\n",
 463                                                                                                 LDNS_MAX_RDFLEN))
 464                                                             != -1) {
 465                                                                 rd = strncat(rd,
 466                                                                                    b64,
 467                                                                                    LDNS_MAX_RDFLEN
 468                                                                                    - strlen(rd) - 1);
 469                                                         }
 470                                                         r = ldns_rdf_new_frm_str(
 471                                                                         ldns_rr_descriptor_field_type(desc, r_cnt),
 472                                                                         rd);
 473                                                         break;
 474                                                 case LDNS_RDF_TYPE_DNAME:
 475                                                         r = ldns_rdf_new_frm_str(
 476                                                                         ldns_rr_descriptor_field_type(desc, r_cnt),
 477                                                                         rd);
 478
 479                                                         /* check if the origin should be used or concatenated */
 480                                                         if (r && ldns_rdf_size(r) > 1 && ldns_rdf_data(r)[0] == 1
 481                                                                 && ldns_rdf_data(r)[1] == '@') {
 482                                                                 ldns_rdf_deep_free(r);
 483                                                                 if (origin) {
 484                                                                         r = ldns_rdf_clone(origin);
 485                                                                 } else {
 486                                                                      /* if this is the SOA, use its own owner name */
 487                                                                         if (rr_type == LDNS_RR_TYPE_SOA) {
 488                                                                                 r = ldns_rdf_clone(ldns_rr_owner(new));
 489                                                                         } else {
 490                                                                                 r = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, ".");
 491                                                                         }
 492                                                                 }
 493                                                         } else if (r && rd_strlen >= 1 && !ldns_dname_str_absolute(rd) && origin) {
 494                                                                 if (ldns_dname_cat(r, origin) != LDNS_STATUS_OK) {
 495                                                                         return LDNS_STATUS_ERR;
 496                                                                 }
 497                                                         }
 498                                                         break;
 499                                                 default:
 500                                                         r = ldns_rdf_new_frm_str(
 501                                                                         ldns_rr_descriptor_field_type(desc, r_cnt),
 502                                                                         rd);
 503                                                         break;
 504                                                 }
 505                                                 if (r) {
 506                                                         ldns_rr_push_rdf(new, r);
 507                                                 } else {
 508                                                         LDNS_FREE(rd);
 509                                                         LDNS_FREE(b64);
 510                                                         ldns_buffer_free(rd_buf);
 511                                                         ldns_buffer_free(rr_buf);
 512                                                         LDNS_FREE(rdata);
 513                                                         ldns_rr_free(new);
 514                                                         return LDNS_STATUS_SYNTAX_RDATA_ERR;
 515                                                 }
 516                                         }
 517                                         if (quoted) {
 518                                                 if (ldns_buffer_available(rd_buf, 1)) {
 519                                                         ldns_buffer_skip(rd_buf, 1);
 520                                                 } else {
 521                                                         done = true;
 522                                                 }
 523                                         }
 524                                 } else {
 525                                         done = true;
 526                                 }
 527                         }
 528         }
 529         LDNS_FREE(rd);
 530         LDNS_FREE(b64);
 531         ldns_buffer_free(rd_buf);
 532         ldns_buffer_free(rr_buf);
 533         LDNS_FREE(rdata);
 534
 535         if (!question && desc && ldns_rr_rd_count(new) < r_min) {
 536                 ldns_rr_free(new);
 537                 return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
 538         }
 539
 540         if (newrr) {
 541                 *newrr = new;
 542         }
 543         return LDNS_STATUS_OK;
 544 }
 545
 546 ldns_status
 547 ldns_rr_new_frm_str(ldns_rr **newrr, const char *str,
 548                     uint32_t default_ttl, ldns_rdf *origin,
 549                     ldns_rdf **prev)
 550 {
 551         return ldns_rr_new_frm_str_internal(newrr,
 552                                             str,
 553                                             default_ttl,
 554                                             origin,
 555                                             prev,
 556                                             false);
 557 }
 558
 559 ldns_status
 560 ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str,
 561                              ldns_rdf *origin, ldns_rdf **prev)
 562 {
 563         return ldns_rr_new_frm_str_internal(newrr,
 564                                             str,
 565                                             0,
 566                                             origin,
 567                                             prev,
 568                                             true);
 569 }
 570
 571 ldns_status
 572 ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev)
 573 {
 574         return ldns_rr_new_frm_fp_l(newrr, fp, ttl, origin, prev, NULL);
 575 }
 576
 577 ldns_status
 578 ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr)
 579 {
 580         char *line;
 581         const char *endptr;  /* unused */
 582         ldns_rr *rr;
 583         char *keyword;
 584         uint32_t ttl;
 585         ldns_rdf *tmp;
 586         ldns_status s;
 587         ssize_t size;
 588
 589         s = LDNS_STATUS_ERR;
 590         if (default_ttl) {
 591                 ttl = *default_ttl;
 592         } else {
 593                 ttl = 0;
 594         }
 595
 596         line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
 597         if (!line) {
 598                 return LDNS_STATUS_MEM_ERR;
 599         }
 600
 601         /* read an entire line in from the file */
 602         if ((size = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, LDNS_MAX_LINELEN, line_nr)) == -1) {
 603                 LDNS_FREE(line);
 604                 /* if last line was empty, we are now at feof, which is not
 605                  * always a parse error (happens when for instance last line
 606                  * was a comment)
 607                  */
 608                 return LDNS_STATUS_SYNTAX_ERR;
 609         }
 610
 611         /* we can have the situation, where we've read ok, but still got
 612          * no bytes to play with, in this case size is 0
 613          */
 614         if (size == 0) {
 615                 LDNS_FREE(line);
 616                 return LDNS_STATUS_SYNTAX_EMPTY;
 617         }
 618
 619         if ((keyword = strstr(line, "$ORIGIN "))) {
 620                 if (*origin) {
 621                         ldns_rdf_deep_free(*origin);
 622                         *origin = NULL;
 623                 }
 624                 tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, keyword + 8);
 625                 if (!tmp) {
 626                         /* could not parse what next to $ORIGIN */
 627                         LDNS_FREE(line);
 628                         return LDNS_STATUS_SYNTAX_DNAME_ERR;
 629                 }
 630                 *origin = tmp;
 631                 s = LDNS_STATUS_SYNTAX_ORIGIN;
 632         } else if ((keyword = strstr(line, "$TTL "))) {
 633                 if (default_ttl) {
 634                         *default_ttl = ldns_str2period(keyword + 5, &endptr);
 635                 }
 636                 s = LDNS_STATUS_SYNTAX_TTL;
 637         } else {
 638                 if (origin && *origin) {
 639                         s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, *origin, prev);
 640                 } else {
 641                         s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, NULL, prev);
 642                 }
 643         }
 644         LDNS_FREE(line);
 645         if (newrr && s == LDNS_STATUS_OK) {
 646                 *newrr = rr;
 647         }
 648         return s;
 649 }
 650
 651 void
 652 ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner)
 653 {
 654         rr->_owner = owner;
 655 }
 656
 657 void
 658 ldns_rr_set_question(ldns_rr *rr, bool question)
 659 {
 660    rr->_rr_question = question;
 661 }
 662
 663 void
 664 ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl)
 665 {
 666         rr->_ttl = ttl;
 667 }
 668
 669 void
 670 ldns_rr_set_rd_count(ldns_rr *rr, size_t count)
 671 {
 672         rr->_rd_count = count;
 673 }
 674
 675 void
 676 ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type)
 677 {
 678         rr->_rr_type = rr_type;
 679 }
 680
 681 void
 682 ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class)
 683 {
 684         rr->_rr_class = rr_class;
 685 }
 686
 687 ldns_rdf *
 688 ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position)
 689 {
 690         size_t rd_count;
 691         ldns_rdf *pop;
 692         ldns_rdf **rdata_fields;
 693
 694         rd_count = ldns_rr_rd_count(rr);
 695         if (position < rd_count) {
 696                 rdata_fields = rr->_rdata_fields;
 697                 /* dicard the old one */
 698                 pop = rr->_rdata_fields[position];
 699                 rr->_rdata_fields[position] = (ldns_rdf*)f;
 700                 return pop;
 701         } else {
 702                 return NULL;
 703         }
 704 }
 705
 706 bool
 707 ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f)
 708 {
 709         size_t rd_count;
 710         ldns_rdf **rdata_fields;
 711
 712         rd_count = ldns_rr_rd_count(rr);
 713
 714         /* grow the array */
 715         rdata_fields = LDNS_XREALLOC(
 716                 rr->_rdata_fields, ldns_rdf *, rd_count + 1);
 717         if (!rdata_fields) {
 718                 return false;
 719         }
 720
 721         /* add the new member */
 722         rr->_rdata_fields = rdata_fields;
 723         rr->_rdata_fields[rd_count] = (ldns_rdf*)f;
 724
 725         ldns_rr_set_rd_count(rr, rd_count + 1);
 726         return true;
 727 }
 728
 729 ldns_rdf *
 730 ldns_rr_pop_rdf(ldns_rr *rr)
 731 {
 732         size_t rd_count;
 733         ldns_rdf *pop;
 734
 735         rd_count = ldns_rr_rd_count(rr);
 736
 737         if (rd_count == 0) {
 738                 return NULL;
 739         }
 740
 741         pop = rr->_rdata_fields[rd_count - 1];
 742
 743         /* shrink the array */
 744         rr->_rdata_fields = LDNS_XREALLOC(
 745                 rr->_rdata_fields, ldns_rdf *, rd_count - 1);
 746
 747         ldns_rr_set_rd_count(rr, rd_count - 1);
 748         return pop;
 749 }
 750
 751 ldns_rdf *
 752 ldns_rr_rdf(const ldns_rr *rr, size_t nr)
 753 {
 754         if (nr < ldns_rr_rd_count(rr)) {
 755                 return rr->_rdata_fields[nr];
 756         } else {
 757                 return NULL;
 758         }
 759 }
 760
 761 ldns_rdf *
 762 ldns_rr_owner(const ldns_rr *rr)
 763 {
 764         return rr->_owner;
 765 }
 766
 767 bool
 768 ldns_rr_is_question(const ldns_rr *rr)
 769 {
 770    return rr->_rr_question;
 771 }
 772
 773 uint32_t
 774 ldns_rr_ttl(const ldns_rr *rr)
 775 {
 776         return rr->_ttl;
 777 }
 778
 779 size_t
 780 ldns_rr_rd_count(const ldns_rr *rr)
 781 {
 782         return rr->_rd_count;
 783 }
 784
 785 ldns_rr_type
 786 ldns_rr_get_type(const ldns_rr *rr)
 787 {
 788         return rr->_rr_type;
 789 }
 790
 791 ldns_rr_class
 792 ldns_rr_get_class(const ldns_rr *rr)
 793 {
 794         return rr->_rr_class;
 795 }
 796
 797 /* rr_lists */
 798
 799 size_t
 800 ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
 801 {
 802         if (rr_list) {
 803                 return rr_list->_rr_count;
 804         } else {
 805                 return 0;
 806         }
 807 }
 808
 809 ldns_rr *
 810 ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count)
 811 {
 812         ldns_rr *old;
 813
 814         if (count > ldns_rr_list_rr_count(rr_list)) {
 815                 return NULL;
 816         }
 817
 818         old = ldns_rr_list_rr(rr_list, count);
 819
 820         /* overwrite old's pointer */
 821         rr_list->_rrs[count] = (ldns_rr*)r;
 822         return old;
 823 }
 824
 825 void
 826 ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count)
 827 {
 828         assert(count <= rr_list->_rr_capacity);
 829         rr_list->_rr_count = count;
 830 }
 831
 832 ldns_rr *
 833 ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
 834 {
 835         if (nr < ldns_rr_list_rr_count(rr_list)) {
 836                 return rr_list->_rrs[nr];
 837         } else {
 838                 return NULL;
 839         }
 840 }
 841
 842 ldns_rr_list *
 843 ldns_rr_list_new()
 844 {
 845         ldns_rr_list *rr_list = LDNS_MALLOC(ldns_rr_list);
 846         rr_list->_rr_count = 0;
 847         rr_list->_rr_capacity = 0;
 848         rr_list->_rrs = NULL;
 849         return rr_list;
 850 }
 851
 852 void
 853 ldns_rr_list_free(ldns_rr_list *rr_list)
 854 {
 855         if (rr_list) {
 856                 LDNS_FREE(rr_list->_rrs);
 857                 LDNS_FREE(rr_list);
 858         }
 859 }
 860
 861 void
 862 ldns_rr_list_deep_free(ldns_rr_list *rr_list)
 863 {
 864         size_t i;
 865
 866         if (rr_list) {
 867                 for (i=0; i < ldns_rr_list_rr_count(rr_list); i++) {
 868                         ldns_rr_free(ldns_rr_list_rr(rr_list, i));
 869                 }
 870                 LDNS_FREE(rr_list->_rrs);
 871                 LDNS_FREE(rr_list);
 872         }
 873 }
 874
 875
 876 /* add right to left. So we modify *left! */
 877 bool
 878 ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right)
 879 {
 880         size_t r_rr_count;
 881         size_t l_rr_count;
 882         size_t i;
 883
 884         if (left) {
 885                 l_rr_count = ldns_rr_list_rr_count(left);
 886         } else {
 887                 return false;
 888         }
 889
 890         if (right) {
 891                 r_rr_count = ldns_rr_list_rr_count(right);
 892         } else {
 893                 r_rr_count = 0;
 894         }
 895
 896         /* push right to left */
 897         for(i = 0; i < r_rr_count; i++) {
 898                 ldns_rr_list_push_rr(left, ldns_rr_list_rr(right, i));
 899         }
 900         return true;
 901 }
 902
 903 ldns_rr_list *
 904 ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right)
 905 {
 906         size_t l_rr_count;
 907         size_t r_rr_count;
 908         size_t i;
 909         ldns_rr_list *cat;
 910
 911         l_rr_count = 0;
 912
 913         if (left) {
 914                 l_rr_count = ldns_rr_list_rr_count(left);
 915         } else {
 916                 return ldns_rr_list_clone(right);
 917         }
 918
 919         if (right) {
 920                 r_rr_count = ldns_rr_list_rr_count(right);
 921         } else {
 922                 r_rr_count = 0;
 923         }
 924
 925         cat = ldns_rr_list_new();
 926
 927         if (!cat) {
 928                 return NULL;
 929         }
 930
 931         /* left */
 932         for(i = 0; i < l_rr_count; i++) {
 933                 ldns_rr_list_push_rr(cat,
 934                                 ldns_rr_clone(ldns_rr_list_rr(left, i)));
 935         }
 936         /* right */
 937         for(i = 0; i < r_rr_count; i++) {
 938                 ldns_rr_list_push_rr(cat,
 939                                 ldns_rr_clone(ldns_rr_list_rr(right, i)));
 940         }
 941         return cat;
 942 }
 943
 944 ldns_rr_list *
 945 ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos)
 946 {
 947         size_t i;
 948         ldns_rr_list *subtyped;
 949         ldns_rdf *list_rdf;
 950
 951         subtyped = ldns_rr_list_new();
 952
 953         for(i = 0; i < ldns_rr_list_rr_count(l); i++) {
 954                 list_rdf = ldns_rr_rdf(
 955                         ldns_rr_list_rr(l, i),
 956                         pos);
 957                 if (!list_rdf) {
 958                         /* pos is too large or any other error */
 959                         ldns_rr_list_deep_free(subtyped);
 960                         return NULL;
 961                 }
 962
 963                 if (ldns_rdf_compare(list_rdf, r) == 0) {
 964                         /* a match */
 965                         ldns_rr_list_push_rr(subtyped,
 966                                         ldns_rr_clone(ldns_rr_list_rr(l, i)));
 967                 }
 968         }
 969
 970         if (ldns_rr_list_rr_count(subtyped) > 0) {
 971                 return subtyped;
 972         } else {
 973                 ldns_rr_list_free(subtyped);
 974                 return NULL;
 975         }
 976 }
 977
 978 bool
 979 ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr)
 980 {
 981         size_t rr_count;
 982         size_t cap;
 983
 984         rr_count = ldns_rr_list_rr_count(rr_list);
 985         cap = rr_list->_rr_capacity;
 986
 987         /* grow the array */
 988         if(rr_count+1 > cap) {
 989                 ldns_rr **rrs;
 990
 991                 if(cap == 0)
 992                         cap = LDNS_RRLIST_INIT;  /* initial list size */
 993                 else    cap *= 2;
 994                 rrs = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
 995                 if (!rrs) {
 996                         return false;
 997                 }
 998                 rr_list->_rrs = rrs;
 999                 rr_list->_rr_capacity = cap;
1000         }
1001
1002         /* add the new member */
1003         rr_list->_rrs[rr_count] = (ldns_rr*)rr;
1004
1005         ldns_rr_list_set_rr_count(rr_list, rr_count + 1);
1006         return true;
1007 }
1008
1009 bool
1010 ldns_rr_list_push_rr_list(ldns_rr_list *rr_list, const ldns_rr_list *push_list)
1011 {
1012         size_t i;
1013
1014         for(i = 0; i < ldns_rr_list_rr_count(push_list); i++) {
1015                 if (!ldns_rr_list_push_rr(rr_list,
1016                                 ldns_rr_list_rr(push_list, i))) {
1017                         return false;
1018                 }
1019         }
1020         return true;
1021 }
1022
1023 ldns_rr *
1024 ldns_rr_list_pop_rr(ldns_rr_list *rr_list)
1025 {
1026         size_t rr_count;
1027         size_t cap;
1028         ldns_rr *pop;
1029
1030         rr_count = ldns_rr_list_rr_count(rr_list);
1031
1032         if (rr_count == 0) {
1033                 return NULL;
1034         }
1035
1036         cap = rr_list->_rr_capacity;
1037         pop = ldns_rr_list_rr(rr_list, rr_count - 1);
1038
1039         /* shrink the array */
1040         if(cap > LDNS_RRLIST_INIT && rr_count-1 <= cap/2) {
1041                 cap /= 2;
1042                 rr_list->_rrs = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
1043                 rr_list->_rr_capacity = cap;
1044         }
1045
1046         ldns_rr_list_set_rr_count(rr_list, rr_count - 1);
1047
1048         return pop;
1049 }
1050
1051 ldns_rr_list *
1052 ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t howmany)
1053 {
1054         /* pop a number of rr's and put them in a rr_list */
1055         ldns_rr_list *popped;
1056         ldns_rr *p;
1057         size_t i = howmany;
1058
1059         popped = ldns_rr_list_new();
1060
1061         if (!popped) {
1062                 return NULL;
1063         }
1064
1065
1066         while(i > 0 &&
1067                         (p = ldns_rr_list_pop_rr(rr_list)) != NULL) {
1068                 ldns_rr_list_push_rr(popped, p);
1069                 i--;
1070         }
1071
1072         if (i == howmany) {
1073                 return NULL;
1074         } else {
1075                 return popped;
1076         }
1077 }
1078
1079
1080 bool
1081 ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr)
1082 {
1083         size_t i;
1084
1085         if (!rr_list || !rr || ldns_rr_list_rr_count(rr_list) == 0) {
1086                 return false;
1087         }
1088
1089         for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
1090                 if (rr == ldns_rr_list_rr(rr_list, i)) {
1091                         return true;
1092                 } else if (ldns_rr_compare(rr, ldns_rr_list_rr(rr_list, i)) == 0) {
1093                         return true;
1094                 }
1095         }
1096         return false;
1097 }
1098
1099 bool
1100 ldns_is_rrset(ldns_rr_list *rr_list)
1101 {
1102         ldns_rr_type t;
1103         ldns_rr_class c;
1104         ldns_rdf *o;
1105         ldns_rr *tmp;
1106         size_t i;
1107
1108         if (!rr_list || ldns_rr_list_rr_count(rr_list) == 0) {
1109                 return false;
1110         }
1111
1112         tmp = ldns_rr_list_rr(rr_list, 0);
1113
1114         t = ldns_rr_get_type(tmp);
1115         c = ldns_rr_get_class(tmp);
1116         o = ldns_rr_owner(tmp);
1117
1118         /* compare these with the rest of the rr_list, start with 1 */
1119         for (i = 1; i < ldns_rr_list_rr_count(rr_list); i++) {
1120                 tmp = ldns_rr_list_rr(rr_list, i);
1121                 if (t != ldns_rr_get_type(tmp)) {
1122                         return false;
1123                 }
1124                 if (c != ldns_rr_get_class(tmp)) {
1125                         return false;
1126                 }
1127                 if (ldns_rdf_compare(o, ldns_rr_owner(tmp)) != 0) {
1128                         return false;
1129                 }
1130         }
1131         return true;
1132 }
1133
1134 bool
1135 ldns_rr_set_push_rr(ldns_rr_list *rr_list, ldns_rr *rr)
1136 {
1137         size_t rr_count;
1138         size_t i;
1139         ldns_rr *last;
1140
1141         assert(rr != NULL);
1142
1143         rr_count = ldns_rr_list_rr_count(rr_list);
1144
1145         if (rr_count == 0) {
1146                 /* nothing there, so checking it is
1147                  * not needed */
1148                 return ldns_rr_list_push_rr(rr_list, rr);
1149         } else {
1150                 /* check with the final rr in the rr_list */
1151                 last = ldns_rr_list_rr(rr_list, rr_count - 1);
1152
1153                 if (ldns_rr_get_class(last) != ldns_rr_get_class(rr)) {
1154                         return false;
1155                 }
1156                 if (ldns_rr_get_type(last) != ldns_rr_get_type(rr)) {
1157                         return false;
1158                 }
1159                 /* only check if not equal to RRSIG */
1160                 if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) {
1161                         if (ldns_rr_ttl(last) != ldns_rr_ttl(rr)) {
1162                                 return false;
1163                         }
1164                 }
1165                 if (ldns_rdf_compare(ldns_rr_owner(last),
1166                                         ldns_rr_owner(rr)) != 0) {
1167                         return false;
1168                 }
1169                 /* ok, still alive - check if the rr already
1170                  * exists - if so, dont' add it */
1171                 for(i = 0; i < rr_count; i++) {
1172                         if(ldns_rr_compare(
1173                                         ldns_rr_list_rr(rr_list, i), rr) == 0) {
1174                                 return false;
1175                         }
1176                 }
1177                 /* it's safe, push it */
1178                 return ldns_rr_list_push_rr(rr_list, rr);
1179         }
1180 }
1181
1182 ldns_rr *
1183 ldns_rr_set_pop_rr(ldns_rr_list *rr_list)
1184 {
1185         return ldns_rr_list_pop_rr(rr_list);
1186 }
1187
1188 ldns_rr_list *
1189 ldns_rr_list_pop_rrset(ldns_rr_list *rr_list)
1190 {
1191         ldns_rr_list *rrset;
1192         ldns_rr *last_rr = NULL;
1193         ldns_rr *next_rr;
1194
1195         if (!rr_list) {
1196                 return NULL;
1197         }
1198
1199         rrset = ldns_rr_list_new();
1200         if (!last_rr) {
1201                 last_rr = ldns_rr_list_pop_rr(rr_list);
1202                 if (!last_rr) {
1203                         ldns_rr_list_free(rrset);
1204                         return NULL;
1205                 } else {
1206                         ldns_rr_list_push_rr(rrset, last_rr);
1207                 }
1208         }
1209
1210         if (ldns_rr_list_rr_count(rr_list) > 0) {
1211                 next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
1212         } else {
1213                 next_rr = NULL;
1214         }
1215
1216         while (next_rr) {
1217                 if (
1218                         ldns_rdf_compare(ldns_rr_owner(next_rr),
1219                                          ldns_rr_owner(last_rr)) == 0
1220                         &&
1221                         ldns_rr_get_type(next_rr) == ldns_rr_get_type(last_rr)
1222                         &&
1223                         ldns_rr_get_class(next_rr) == ldns_rr_get_class(last_rr)
1224                    ) {
1225                         ldns_rr_list_push_rr(rrset, ldns_rr_list_pop_rr(rr_list));
1226                         if (ldns_rr_list_rr_count(rr_list) > 0) {
1227                                 last_rr = next_rr;
1228                                 next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
1229                         } else {
1230                                 next_rr = NULL;
1231                         }
1232                 } else {
1233                         next_rr = NULL;
1234                 }
1235         }
1236
1237         return rrset;
1238 }
1239
1240 ldns_rr *
1241 ldns_rr_clone(const ldns_rr *rr)
1242 {
1243         size_t i;
1244         ldns_rr *new_rr;
1245
1246         if (!rr) {
1247                 return NULL;
1248         }
1249
1250         new_rr = ldns_rr_new();
1251         if (!new_rr) {
1252                 return NULL;
1253         }
1254         if (ldns_rr_owner(rr)) {
1255                 ldns_rr_set_owner(new_rr, ldns_rdf_clone(ldns_rr_owner(rr)));
1256         }
1257         ldns_rr_set_ttl(new_rr, ldns_rr_ttl(rr));
1258         ldns_rr_set_type(new_rr, ldns_rr_get_type(rr));
1259         ldns_rr_set_class(new_rr, ldns_rr_get_class(rr));
1260
1261         for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1262                 if (ldns_rr_rdf(rr,i)) {
1263                         ldns_rr_push_rdf(new_rr, ldns_rdf_clone(ldns_rr_rdf(rr, i)));
1264                 }
1265         }
1266
1267         return new_rr;
1268 }
1269
1270 ldns_rr_list *
1271 ldns_rr_list_clone(const ldns_rr_list *rrlist)
1272 {
1273         size_t i;
1274         ldns_rr_list *new_list;
1275         ldns_rr *r;
1276
1277         if (!rrlist) {
1278                 return NULL;
1279         }
1280
1281         new_list = ldns_rr_list_new();
1282         if (!new_list) {
1283                 return NULL;
1284         }
1285         for (i = 0; i < ldns_rr_list_rr_count(rrlist); i++) {
1286                 r = ldns_rr_clone(
1287                         ldns_rr_list_rr(rrlist, i)
1288                     );
1289                 if (!r) {
1290                         /* huh, failure in cloning */
1291                         ldns_rr_list_deep_free(new_list);
1292                         return NULL;
1293                 }
1294                 ldns_rr_list_push_rr(new_list, r);
1295         }
1296         return new_list;
1297 }
1298
1299
1300 int
1301 qsort_rr_compare(const void *a, const void *b)
1302 {
1303         const ldns_rr *rr1 = * (const ldns_rr **) a;
1304         const ldns_rr *rr2 = * (const ldns_rr **) b;
1305
1306         if (rr1 == NULL && rr2 == NULL) {
1307                 return 0;
1308         }
1309         if (rr1 == NULL) {
1310                 return -1;
1311         }
1312         if (rr2 == NULL) {
1313                 return 1;
1314         }
1315         return ldns_rr_compare(rr1, rr2);
1316 }
1317
1318 int
1319 qsort_schwartz_rr_compare(const void *a, const void *b)
1320 {
1321         int result = 0;
1322         ldns_rr *rr1, *rr2;
1323         ldns_buffer *rr1_buf, *rr2_buf;
1324         struct ldns_schwartzian_compare_struct *sa = *(struct ldns_schwartzian_compare_struct **) a;
1325         struct ldns_schwartzian_compare_struct *sb = *(struct ldns_schwartzian_compare_struct **) b;
1326         /* if we are doing 2wire, we need to do lowercasing on the dname (and maybe on the rdata)
1327          * this must be done for comparison only, so we need to have a temp var for both buffers,
1328          * which is only used when the transformed object value isn't there yet
1329          */
1330         ldns_rr *canonical_a, *canonical_b;
1331
1332         rr1 = (ldns_rr *) sa->original_object;
1333         rr2 = (ldns_rr *) sb->original_object;
1334
1335         result = ldns_rr_compare_no_rdata(rr1, rr2);
1336
1337         if (result == 0) {
1338                 if (!sa->transformed_object) {
1339                         canonical_a = ldns_rr_clone(sa->original_object);
1340                         ldns_rr2canonical(canonical_a);
1341                         sa->transformed_object = ldns_buffer_new(ldns_rr_uncompressed_size(canonical_a));
1342                         if (ldns_rr2buffer_wire(sa->transformed_object, canonical_a, LDNS_SECTION_ANY) != LDNS_STATUS_OK) {
1343                                 fprintf(stderr, "ERR!\n");
1344                                 ldns_rr_free(canonical_a);
1345                                 return 0;
1346                         }
1347                         ldns_rr_free(canonical_a);
1348                 }
1349                 if (!sb->transformed_object) {
1350                         canonical_b = ldns_rr_clone(sb->original_object);
1351                         ldns_rr2canonical(canonical_b);
1352                         sb->transformed_object = ldns_buffer_new(ldns_rr_uncompressed_size(canonical_b));
1353                         if (ldns_rr2buffer_wire(sb->transformed_object, canonical_b, LDNS_SECTION_ANY) != LDNS_STATUS_OK) {
1354                                 fprintf(stderr, "ERR!\n");
1355                                 ldns_rr_free(canonical_b);
1356                                 return 0;
1357                         }
1358                         ldns_rr_free(canonical_b);
1359                 }
1360                 rr1_buf = (ldns_buffer *) sa->transformed_object;
1361                 rr2_buf = (ldns_buffer *) sb->transformed_object;
1362
1363                 result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
1364         }
1365
1366         return result;
1367 }
1368
1369 void
1370 ldns_rr_list_sort(ldns_rr_list *unsorted)
1371 {
1372         struct ldns_schwartzian_compare_struct **sortables;
1373         size_t item_count;
1374         size_t i;
1375
1376         if (unsorted) {
1377                 item_count = ldns_rr_list_rr_count(unsorted);
1378
1379                 sortables = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct *,
1380                                          item_count);
1381                 for (i = 0; i < item_count; i++) {
1382                         sortables[i] = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct, 1);
1383                         sortables[i]->original_object = ldns_rr_list_rr(unsorted, i);
1384                         sortables[i]->transformed_object = NULL;
1385                 }
1386                 qsort(sortables,
1387                       item_count,
1388                       sizeof(struct ldns_schwartzian_compare_struct *),
1389                       qsort_schwartz_rr_compare);
1390                 for (i = 0; i < item_count; i++) {
1391                         unsorted->_rrs[i] = sortables[i]->original_object;
1392                         if (sortables[i]->transformed_object) {
1393                                 ldns_buffer_free(sortables[i]->transformed_object);
1394                         }
1395                         LDNS_FREE(sortables[i]);
1396                 }
1397                 LDNS_FREE(sortables);
1398         }
1399 }
1400
1401 int
1402 ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2)
1403 {
1404         size_t rr1_len;
1405         size_t rr2_len;
1406         size_t offset;
1407
1408         assert(rr1 != NULL);
1409         assert(rr2 != NULL);
1410
1411         rr1_len = ldns_rr_uncompressed_size(rr1);
1412         rr2_len = ldns_rr_uncompressed_size(rr2);
1413
1414         if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) < 0) {
1415                 return -1;
1416         } else if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) > 0) {
1417                 return 1;
1418         }
1419
1420         /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
1421         if (ldns_rr_get_class(rr1) != ldns_rr_get_class(rr2)) {
1422             return ldns_rr_get_class(rr1) - ldns_rr_get_class(rr2);
1423         }
1424
1425         /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
1426         if (ldns_rr_get_type(rr1) != ldns_rr_get_type(rr2)) {
1427             return ldns_rr_get_type(rr1) - ldns_rr_get_type(rr2);
1428         }
1429
1430         /* offset is the owername length + ttl + type + class + rdlen == start of wire format rdata */
1431         offset = ldns_rdf_size(ldns_rr_owner(rr1)) + 4 + 2 + 2 + 2;
1432         /* if either record doesn't have any RDATA... */
1433         if (offset > rr1_len || offset > rr2_len) {
1434             if (rr1_len == rr2_len) {
1435               return 0;
1436             }
1437             return ((int) rr2_len - (int) rr1_len);
1438         }
1439
1440         return 0;
1441 }
1442
1443 int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf)
1444 {
1445         size_t rr1_len, rr2_len, min_len, i, offset;
1446
1447         rr1_len = ldns_buffer_capacity(rr1_buf);
1448         rr2_len = ldns_buffer_capacity(rr2_buf);
1449
1450         /* jump past dname (checked in earlier part)
1451          * and especially past TTL */
1452         offset = 0;
1453         while (offset < rr1_len && *ldns_buffer_at(rr1_buf, offset) != 0) {
1454           offset += *ldns_buffer_at(rr1_buf, offset) + 1;
1455         }
1456         /* jump to rdata section (PAST the rdata length field, otherwise
1457            rrs with different lengths might be sorted erroneously */
1458         offset += 11;
1459            min_len = (rr1_len < rr2_len) ? rr1_len : rr2_len;
1460         /* Compare RRs RDATA byte for byte. */
1461         for(i = offset; i < min_len; i++) {
1462                 if (*ldns_buffer_at(rr1_buf,i) < *ldns_buffer_at(rr2_buf,i)) {
1463                         return -1;
1464                 } else if (*ldns_buffer_at(rr1_buf,i) > *ldns_buffer_at(rr2_buf,i)) {
1465                         return +1;
1466                 }
1467         }
1468
1469         /* If both RDATAs are the same up to min_len, then the shorter one sorts first. */
1470         if (rr1_len < rr2_len) {
1471                 return -1;
1472         } else if (rr1_len > rr2_len) {
1473                 return +1;
1474         }
1475         /* The RDATAs are equal. */
1476         return 0;
1477
1478 }
1479
1480 int
1481 ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
1482 {
1483         int result;
1484         size_t rr1_len, rr2_len;
1485
1486         ldns_buffer *rr1_buf;
1487         ldns_buffer *rr2_buf;
1488
1489         result = ldns_rr_compare_no_rdata(rr1, rr2);
1490         if (result == 0) {
1491                 rr1_len = ldns_rr_uncompressed_size(rr1);
1492                 rr2_len = ldns_rr_uncompressed_size(rr2);
1493
1494                 rr1_buf = ldns_buffer_new(rr1_len);
1495                 rr2_buf = ldns_buffer_new(rr2_len);
1496
1497                 if (ldns_rr2buffer_wire_canonical(rr1_buf,
1498                                                                     rr1,
1499                                                                     LDNS_SECTION_ANY)
1500                     != LDNS_STATUS_OK) {
1501                         ldns_buffer_free(rr1_buf);
1502                         ldns_buffer_free(rr2_buf);
1503                         return 0;
1504                 }
1505                 if (ldns_rr2buffer_wire_canonical(rr2_buf,
1506                                                                     rr2,
1507                                                                     LDNS_SECTION_ANY)
1508                     != LDNS_STATUS_OK) {
1509                         ldns_buffer_free(rr1_buf);
1510                         ldns_buffer_free(rr2_buf);
1511                         return 0;
1512                 }
1513
1514                 result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
1515
1516                 ldns_buffer_free(rr1_buf);
1517                 ldns_buffer_free(rr2_buf);
1518         }
1519
1520         return result;
1521 }
1522
1523 /* convert dnskey to a ds with the given algorithm,
1524  * then compare the result with the given ds */
1525 static int
1526 ldns_rr_compare_ds_dnskey(ldns_rr *ds,
1527                           ldns_rr *dnskey)
1528 {
1529         ldns_rr *ds_gen;
1530         bool result = false;
1531         ldns_hash algo;
1532
1533         if (!dnskey || !ds ||
1534             ldns_rr_get_type(ds) != LDNS_RR_TYPE_DS ||
1535             ldns_rr_get_type(dnskey) != LDNS_RR_TYPE_DNSKEY) {
1536                 return false;
1537         }
1538
1539 algo = ldns_rdf2native_int8(ldns_rr_rdf(ds, 2));
1540
1541         ds_gen = ldns_key_rr2ds(dnskey, algo);
1542         if (ds_gen) {
1543                 result = ldns_rr_compare(ds, ds_gen) == 0;
1544                 ldns_rr_free(ds_gen);
1545         }
1546         return result;
1547 }
1548
1549 bool
1550 ldns_rr_compare_ds(const ldns_rr *orr1, const ldns_rr *orr2)
1551 {
1552         bool result;
1553         ldns_rr *rr1 = ldns_rr_clone(orr1);
1554         ldns_rr *rr2 = ldns_rr_clone(orr2);
1555
1556         /* set ttls to zero */
1557         ldns_rr_set_ttl(rr1, 0);
1558         ldns_rr_set_ttl(rr2, 0);
1559
1560         if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DS &&
1561             ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DNSKEY) {
1562                 result = ldns_rr_compare_ds_dnskey(rr1, rr2);
1563         } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DNSKEY &&
1564             ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DS) {
1565                 result = ldns_rr_compare_ds_dnskey(rr2, rr1);
1566         } else {
1567                 result = (ldns_rr_compare(rr1, rr2) == 0);
1568         }
1569
1570         ldns_rr_free(rr1);
1571         ldns_rr_free(rr2);
1572
1573         return result;
1574 }
1575
1576 int
1577 ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2)
1578 {
1579         size_t i = 0;
1580         int rr_cmp;
1581
1582         assert(rrl1 != NULL);
1583         assert(rrl2 != NULL);
1584
1585         for (i = 0; i < ldns_rr_list_rr_count(rrl1) && i < ldns_rr_list_rr_count(rrl2); i++) {
1586                 rr_cmp = ldns_rr_compare(ldns_rr_list_rr(rrl1, i), ldns_rr_list_rr(rrl2, i));
1587                 if (rr_cmp != 0) {
1588                         return rr_cmp;
1589                 }
1590         }
1591
1592         if (i == ldns_rr_list_rr_count(rrl1) &&
1593             i != ldns_rr_list_rr_count(rrl2)) {
1594                 return 1;
1595         } else if (i == ldns_rr_list_rr_count(rrl2) &&
1596                    i != ldns_rr_list_rr_count(rrl1)) {
1597                 return -1;
1598         } else {
1599                 return 0;
1600         }
1601 }
1602
1603 size_t
1604 ldns_rr_uncompressed_size(const ldns_rr *r)
1605 {
1606         size_t rrsize;
1607         size_t i;
1608
1609         rrsize = 0;
1610         /* add all the rdf sizes */
1611         for(i = 0; i < ldns_rr_rd_count(r); i++) {
1612                 rrsize += ldns_rdf_size(ldns_rr_rdf(r, i));
1613         }
1614         /* ownername */
1615         rrsize += ldns_rdf_size(ldns_rr_owner(r));
1616         rrsize += LDNS_RR_OVERHEAD;
1617         return rrsize;
1618 }
1619
1620 void
1621 ldns_rr2canonical(ldns_rr *rr)
1622 {
1623         uint16_t i;
1624
1625         if (!rr) {
1626           return;
1627         }
1628
1629         ldns_dname2canonical(ldns_rr_owner(rr));
1630
1631         /*
1632          * lowercase the rdata dnames if the rr type is one
1633          * of the list in chapter 7 of RFC3597
1634          */
1635         switch(ldns_rr_get_type(rr)) {
1636                 case LDNS_RR_TYPE_NS:
1637                 case LDNS_RR_TYPE_MD:
1638                 case LDNS_RR_TYPE_MF:
1639                 case LDNS_RR_TYPE_CNAME:
1640                 case LDNS_RR_TYPE_SOA:
1641                 case LDNS_RR_TYPE_MB:
1642                 case LDNS_RR_TYPE_MG:
1643                 case LDNS_RR_TYPE_MR:
1644                 case LDNS_RR_TYPE_PTR:
1645                 case LDNS_RR_TYPE_HINFO:
1646                 case LDNS_RR_TYPE_MINFO:
1647                 case LDNS_RR_TYPE_MX:
1648                 case LDNS_RR_TYPE_RP:
1649                 case LDNS_RR_TYPE_AFSDB:
1650                 case LDNS_RR_TYPE_RT:
1651                 case LDNS_RR_TYPE_SIG:
1652                 case LDNS_RR_TYPE_PX:
1653                 case LDNS_RR_TYPE_NXT:
1654                 case LDNS_RR_TYPE_NAPTR:
1655                 case LDNS_RR_TYPE_KX:
1656                 case LDNS_RR_TYPE_SRV:
1657                 case LDNS_RR_TYPE_DNAME:
1658                 case LDNS_RR_TYPE_A6:
1659                         for (i = 0; i < ldns_rr_rd_count(rr); i++) {
1660                                 ldns_dname2canonical(ldns_rr_rdf(rr, i));
1661                         }
1662                         return;
1663                 default:
1664                         /* do nothing */
1665                         return;
1666         }
1667 }
1668
1669 void
1670 ldns_rr_list2canonical(ldns_rr_list *rr_list)
1671 {
1672         size_t i;
1673         for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
1674                 ldns_rr2canonical(ldns_rr_list_rr(rr_list, i));
1675         }
1676 }
1677
1678 uint8_t
1679 ldns_rr_label_count(ldns_rr *rr)
1680 {
1681         if (!rr) {
1682                 return 0;
1683         }
1684         return ldns_dname_label_count(
1685                         ldns_rr_owner(rr));
1686 }
1687
1688 /** \cond */
1689 static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
1690 static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };
1691 static const ldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1692 static const ldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1693 static const ldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1694 static const ldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1695 static const ldns_rdf_type type_soa_wireformat[] = {
1696         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_INT32,
1697         LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD,
1698         LDNS_RDF_TYPE_PERIOD
1699 };
1700 static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1701 static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1702 static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1703 static const ldns_rdf_type type_wks_wireformat[] = {
1704         LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_WKS
1705 };
1706 static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1707 static const ldns_rdf_type type_hinfo_wireformat[] = {
1708         LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
1709 };
1710 static const ldns_rdf_type type_minfo_wireformat[] = {
1711         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
1712 };
1713 static const ldns_rdf_type type_mx_wireformat[] = {
1714         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1715 };
1716 static const ldns_rdf_type type_rp_wireformat[] = {
1717         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
1718 };
1719 static const ldns_rdf_type type_afsdb_wireformat[] = {
1720         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1721 };
1722 static const ldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR };
1723 static const ldns_rdf_type type_isdn_wireformat[] = {
1724         LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
1725 };
1726 static const ldns_rdf_type type_rt_wireformat[] = {
1727         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1728 };
1729 static const ldns_rdf_type type_nsap_wireformat[] = {
1730         LDNS_RDF_TYPE_NSAP
1731 };
1732 static const ldns_rdf_type type_nsap_ptr_wireformat[] = {
1733         LDNS_RDF_TYPE_STR
1734 };
1735 static const ldns_rdf_type type_sig_wireformat[] = {
1736         LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32,
1737         LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16,
1738         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64
1739 };
1740 static const ldns_rdf_type type_key_wireformat[] = {
1741         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64
1742 };
1743 static const ldns_rdf_type type_px_wireformat[] = {
1744         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
1745 };
1746 static const ldns_rdf_type type_gpos_wireformat[] = {
1747         LDNS_RDF_TYPE_STR,
1748         LDNS_RDF_TYPE_STR,
1749         LDNS_RDF_TYPE_STR
1750 };
1751 static const ldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA };
1752 static const ldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC };
1753 static const ldns_rdf_type type_nxt_wireformat[] = {
1754         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_UNKNOWN
1755 };
1756 static const ldns_rdf_type type_eid_wireformat[] = {
1757         LDNS_RDF_TYPE_HEX
1758 };
1759 static const ldns_rdf_type type_nimloc_wireformat[] = {
1760         LDNS_RDF_TYPE_HEX
1761 };
1762 static const ldns_rdf_type type_srv_wireformat[] = {
1763         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1764 };
1765 static const ldns_rdf_type type_atma_wireformat[] = {
1766         LDNS_RDF_TYPE_ATMA
1767 };
1768 static const ldns_rdf_type type_naptr_wireformat[] = {
1769         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_DNAME
1770 };
1771 static const ldns_rdf_type type_kx_wireformat[] = {
1772         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
1773 };
1774 static const ldns_rdf_type type_cert_wireformat[] = {
1775          LDNS_RDF_TYPE_CERT_ALG, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_B64
1776 };
1777 static const ldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
1778 static const ldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
1779 static const ldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8,
1780         LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64
1781 };
1782 static const ldns_rdf_type type_apl_wireformat[] = {
1783         LDNS_RDF_TYPE_APL
1784 };
1785 static const ldns_rdf_type type_ds_wireformat[] = {
1786         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
1787 };
1788 static const ldns_rdf_type type_sshfp_wireformat[] = {
1789         LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
1790 };
1791 static const ldns_rdf_type type_ipseckey_wireformat[] = {
1792         LDNS_RDF_TYPE_IPSECKEY
1793 };
1794 static const ldns_rdf_type type_rrsig_wireformat[] = {
1795         LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32,
1796         LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64
1797 };
1798 static const ldns_rdf_type type_nsec_wireformat[] = {
1799         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_NSEC
1800 };
1801 static const ldns_rdf_type type_dhcid_wireformat[] = {
1802         LDNS_RDF_TYPE_B64
1803 };
1804 /* nsec3 is some vars, followed by same type of data of nsec */
1805 static const ldns_rdf_type type_nsec3_wireformat[] = {
1806 /*      LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/
1807         LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_NSEC3_SALT, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC
1808 };
1809
1810 static const ldns_rdf_type type_nsec3params_wireformat[] = {
1811 /*      LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/
1812         LDNS_RDF_TYPE_INT8,
1813         LDNS_RDF_TYPE_INT8,
1814         LDNS_RDF_TYPE_INT16,
1815         LDNS_RDF_TYPE_NSEC3_SALT
1816 };
1817
1818 static const ldns_rdf_type type_dnskey_wireformat[] = {
1819         LDNS_RDF_TYPE_INT16,
1820         LDNS_RDF_TYPE_INT8,
1821         LDNS_RDF_TYPE_ALG,
1822         LDNS_RDF_TYPE_B64
1823 };
1824 static const ldns_rdf_type type_tsig_wireformat[] = {
1825         LDNS_RDF_TYPE_DNAME,
1826         LDNS_RDF_TYPE_TSIGTIME,
1827         LDNS_RDF_TYPE_INT16,
1828         LDNS_RDF_TYPE_INT16_DATA,
1829         LDNS_RDF_TYPE_INT16,
1830         LDNS_RDF_TYPE_INT16,
1831         LDNS_RDF_TYPE_INT16_DATA
1832 };
1833 /** \endcond */
1834
1835 /** \cond */
1836 /* All RR's defined in 1035 are well known and can thus
1837  * be compressed. See RFC3597. These RR's are:
1838  * CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT
1839  */
1840 static ldns_rr_descriptor rdata_field_descriptors[] = {
1841         /* 0 */
1842         { 0, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1843         /* 1 */
1844         {LDNS_RR_TYPE_A, "A", 1, 1, type_a_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1845         /* 2 */
1846         {LDNS_RR_TYPE_NS, "NS", 1, 1, type_ns_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1847         /* 3 */
1848         {LDNS_RR_TYPE_MD, "MD", 1, 1, type_md_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1849         /* 4 */
1850         {LDNS_RR_TYPE_MF, "MF", 1, 1, type_mf_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1851         /* 5 */
1852         {LDNS_RR_TYPE_CNAME, "CNAME", 1, 1, type_cname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1853         /* 6 */
1854         {LDNS_RR_TYPE_SOA, "SOA", 7, 7, type_soa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
1855         /* 7 */
1856         {LDNS_RR_TYPE_MB, "MB", 1, 1, type_mb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1857         /* 8 */
1858         {LDNS_RR_TYPE_MG, "MG", 1, 1, type_mg_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1859         /* 9 */
1860         {LDNS_RR_TYPE_MR, "MR", 1, 1, type_mr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1861         /* 10 */
1862         {LDNS_RR_TYPE_NULL, "NULL", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1863         /* 11 */
1864         {LDNS_RR_TYPE_WKS, "WKS", 2, 2, type_wks_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1865         /* 12 */
1866         {LDNS_RR_TYPE_PTR, "PTR", 1, 1, type_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1867         /* 13 */
1868         {LDNS_RR_TYPE_HINFO, "HINFO", 2, 2, type_hinfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1869         /* 14 */
1870         {LDNS_RR_TYPE_MINFO, "MINFO", 2, 2, type_minfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
1871         /* 15 */
1872         {LDNS_RR_TYPE_MX, "MX", 2, 2, type_mx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
1873         /* 16 */
1874         {LDNS_RR_TYPE_TXT, "TXT", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
1875         /* 17 */
1876         {LDNS_RR_TYPE_RP, "RP", 2, 2, type_rp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
1877         /* 18 */
1878         {LDNS_RR_TYPE_AFSDB, "AFSDB", 2, 2, type_afsdb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1879         /* 19 */
1880         {LDNS_RR_TYPE_X25, "X25", 1, 1, type_x25_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1881         /* 20 */
1882         {LDNS_RR_TYPE_ISDN, "ISDN", 1, 2, type_isdn_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1883         /* 21 */
1884         {LDNS_RR_TYPE_RT, "RT", 2, 2, type_rt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1885         /* 22 */
1886         {LDNS_RR_TYPE_NSAP, "NSAP", 1, 1, type_nsap_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1887         /* 23 */
1888         {LDNS_RR_TYPE_NSAP_PTR, "NSAP-PTR", 1, 1, type_nsap_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1889         /* 24 */
1890         {LDNS_RR_TYPE_SIG, "SIG", 9, 9, type_sig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1891         /* 25 */
1892         {LDNS_RR_TYPE_KEY, "KEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1893         /* 26 */
1894         {LDNS_RR_TYPE_PX, "PX", 3, 3, type_px_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
1895         /* 27 */
1896         {LDNS_RR_TYPE_GPOS, "GPOS", 1, 1, type_gpos_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1897         /* 28 */
1898         {LDNS_RR_TYPE_AAAA, "AAAA", 1, 1, type_aaaa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1899         /* 29 */
1900         {LDNS_RR_TYPE_LOC, "LOC", 1, 1, type_loc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1901         /* 30 */
1902         {LDNS_RR_TYPE_NXT, "NXT", 2, 2, type_nxt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1903         /* 31 */
1904         {LDNS_RR_TYPE_EID, "EID", 1, 1, type_eid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1905         /* 32 */
1906         {LDNS_RR_TYPE_NIMLOC, "NIMLOC", 1, 1, type_nimloc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1907         /* 33 */
1908         {LDNS_RR_TYPE_SRV, "SRV", 4, 4, type_srv_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1909         /* 34 */
1910         {LDNS_RR_TYPE_ATMA, "ATMA", 1, 1, type_atma_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1911         /* 35 */
1912         {LDNS_RR_TYPE_NAPTR, "NAPTR", 6, 6, type_naptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1913         /* 36 */
1914         {LDNS_RR_TYPE_KX, "KX", 2, 2, type_kx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1915         /* 37 */
1916         {LDNS_RR_TYPE_CERT, "CERT", 4, 4, type_cert_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1917         /* 38 */
1918         {LDNS_RR_TYPE_A6, "A6", 1, 1, type_a6_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1919         /* 39 */
1920         {LDNS_RR_TYPE_DNAME, "DNAME", 1, 1, type_dname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1921         /* 40 */
1922         {LDNS_RR_TYPE_SINK, "SINK", 1, 1, type_sink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1923         /* 41 */
1924         {LDNS_RR_TYPE_OPT, "OPT", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1925         /* 42 */
1926         {LDNS_RR_TYPE_APL, "APL", 0, 0, type_apl_wireformat, LDNS_RDF_TYPE_APL, LDNS_RR_NO_COMPRESS, 0 },
1927         /* 43 */
1928         {LDNS_RR_TYPE_DS, "DS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1929         /* 44 */
1930         {LDNS_RR_TYPE_SSHFP, "SSHFP", 3, 3, type_sshfp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1931         /* 45 */
1932         {LDNS_RR_TYPE_IPSECKEY, "IPSECKEY", 1, 1, type_ipseckey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1933         /* 46 */
1934         {LDNS_RR_TYPE_RRSIG, "RRSIG", 9, 9, type_rrsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
1935         /* 47 */
1936         {LDNS_RR_TYPE_NSEC, "NSEC", 1, 2, type_nsec_wireformat, LDNS_RDF_TYPE_NSEC, LDNS_RR_NO_COMPRESS, 1 },
1937         /* 48 */
1938         {LDNS_RR_TYPE_DNSKEY, "DNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1939         /* 49 */
1940 {LDNS_RR_TYPE_DHCID, "DHCID", 1, 1, type_dhcid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1941         /* 50 */
1942         {LDNS_RR_TYPE_NSEC3, "NSEC3", 5, 6, type_nsec3_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1943         /* 51 */
1944 {LDNS_RR_TYPE_NSEC3PARAMS, "NSEC3PARAM", 4, 4, type_nsec3params_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1945         /* 52 */
1946 {LDNS_RR_TYPE_NULL, "TYPE52", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1947 {LDNS_RR_TYPE_NULL, "TYPE53", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1948 {LDNS_RR_TYPE_NULL, "TYPE54", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1949 {LDNS_RR_TYPE_NULL, "TYPE55", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1950 {LDNS_RR_TYPE_NULL, "TYPE56", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1951 {LDNS_RR_TYPE_NULL, "TYPE57", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1952 {LDNS_RR_TYPE_NULL, "TYPE58", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1953 {LDNS_RR_TYPE_NULL, "TYPE59", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1954 {LDNS_RR_TYPE_NULL, "TYPE60", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1955 {LDNS_RR_TYPE_NULL, "TYPE61", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1956 {LDNS_RR_TYPE_NULL, "TYPE62", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1957 {LDNS_RR_TYPE_NULL, "TYPE63", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1958 {LDNS_RR_TYPE_NULL, "TYPE64", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1959 {LDNS_RR_TYPE_NULL, "TYPE65", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1960 {LDNS_RR_TYPE_NULL, "TYPE66", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1961 {LDNS_RR_TYPE_NULL, "TYPE67", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1962 {LDNS_RR_TYPE_NULL, "TYPE68", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1963 {LDNS_RR_TYPE_NULL, "TYPE69", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1964 {LDNS_RR_TYPE_NULL, "TYPE70", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1965 {LDNS_RR_TYPE_NULL, "TYPE71", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1966 {LDNS_RR_TYPE_NULL, "TYPE72", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1967 {LDNS_RR_TYPE_NULL, "TYPE73", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1968 {LDNS_RR_TYPE_NULL, "TYPE74", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1969 {LDNS_RR_TYPE_NULL, "TYPE75", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1970 {LDNS_RR_TYPE_NULL, "TYPE76", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1971 {LDNS_RR_TYPE_NULL, "TYPE77", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1972 {LDNS_RR_TYPE_NULL, "TYPE78", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1973 {LDNS_RR_TYPE_NULL, "TYPE79", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1974 {LDNS_RR_TYPE_NULL, "TYPE80", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1975 {LDNS_RR_TYPE_NULL, "TYPE81", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1976 {LDNS_RR_TYPE_NULL, "TYPE82", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1977 {LDNS_RR_TYPE_NULL, "TYPE83", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1978 {LDNS_RR_TYPE_NULL, "TYPE84", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1979 {LDNS_RR_TYPE_NULL, "TYPE85", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1980 {LDNS_RR_TYPE_NULL, "TYPE86", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1981 {LDNS_RR_TYPE_NULL, "TYPE87", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1982 {LDNS_RR_TYPE_NULL, "TYPE88", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1983 {LDNS_RR_TYPE_NULL, "TYPE89", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1984 {LDNS_RR_TYPE_NULL, "TYPE90", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1985 {LDNS_RR_TYPE_NULL, "TYPE91", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1986 {LDNS_RR_TYPE_NULL, "TYPE92", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1987 {LDNS_RR_TYPE_NULL, "TYPE93", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1988 {LDNS_RR_TYPE_NULL, "TYPE94", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1989 {LDNS_RR_TYPE_NULL, "TYPE95", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1990 {LDNS_RR_TYPE_NULL, "TYPE96", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1991 {LDNS_RR_TYPE_NULL, "TYPE97", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1992 {LDNS_RR_TYPE_NULL, "TYPE98", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1993 {LDNS_RR_TYPE_SPF,  "SPF", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
1994 {LDNS_RR_TYPE_NULL, "TYPE100", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1995 {LDNS_RR_TYPE_NULL, "TYPE101", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1996 {LDNS_RR_TYPE_NULL, "TYPE102", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1997 {LDNS_RR_TYPE_NULL, "TYPE103", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1998 {LDNS_RR_TYPE_NULL, "TYPE104", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
1999 {LDNS_RR_TYPE_NULL, "TYPE105", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2000 {LDNS_RR_TYPE_NULL, "TYPE106", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2001 {LDNS_RR_TYPE_NULL, "TYPE107", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2002 {LDNS_RR_TYPE_NULL, "TYPE108", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2003 {LDNS_RR_TYPE_NULL, "TYPE109", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2004 {LDNS_RR_TYPE_NULL, "TYPE110", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2005 {LDNS_RR_TYPE_NULL, "TYPE111", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2006 {LDNS_RR_TYPE_NULL, "TYPE112", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2007 {LDNS_RR_TYPE_NULL, "TYPE113", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2008 {LDNS_RR_TYPE_NULL, "TYPE114", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2009 {LDNS_RR_TYPE_NULL, "TYPE115", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2010 {LDNS_RR_TYPE_NULL, "TYPE116", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2011 {LDNS_RR_TYPE_NULL, "TYPE117", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2012 {LDNS_RR_TYPE_NULL, "TYPE118", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2013 {LDNS_RR_TYPE_NULL, "TYPE119", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2014 {LDNS_RR_TYPE_NULL, "TYPE120", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2015 {LDNS_RR_TYPE_NULL, "TYPE121", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2016 {LDNS_RR_TYPE_NULL, "TYPE122", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2017 {LDNS_RR_TYPE_NULL, "TYPE123", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2018 {LDNS_RR_TYPE_NULL, "TYPE124", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2019 {LDNS_RR_TYPE_NULL, "TYPE125", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2020 {LDNS_RR_TYPE_NULL, "TYPE126", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2021 {LDNS_RR_TYPE_NULL, "TYPE127", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2022 {LDNS_RR_TYPE_NULL, "TYPE128", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2023 {LDNS_RR_TYPE_NULL, "TYPE129", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2024 {LDNS_RR_TYPE_NULL, "TYPE130", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2025 {LDNS_RR_TYPE_NULL, "TYPE131", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2026 {LDNS_RR_TYPE_NULL, "TYPE132", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2027 {LDNS_RR_TYPE_NULL, "TYPE133", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2028 {LDNS_RR_TYPE_NULL, "TYPE134", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2029 {LDNS_RR_TYPE_NULL, "TYPE135", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2030 {LDNS_RR_TYPE_NULL, "TYPE136", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2031 {LDNS_RR_TYPE_NULL, "TYPE137", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2032 {LDNS_RR_TYPE_NULL, "TYPE138", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2033 {LDNS_RR_TYPE_NULL, "TYPE139", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2034 {LDNS_RR_TYPE_NULL, "TYPE140", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2035 {LDNS_RR_TYPE_NULL, "TYPE141", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2036 {LDNS_RR_TYPE_NULL, "TYPE142", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2037 {LDNS_RR_TYPE_NULL, "TYPE143", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2038 {LDNS_RR_TYPE_NULL, "TYPE144", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2039 {LDNS_RR_TYPE_NULL, "TYPE145", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2040 {LDNS_RR_TYPE_NULL, "TYPE146", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2041 {LDNS_RR_TYPE_NULL, "TYPE147", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2042 {LDNS_RR_TYPE_NULL, "TYPE148", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2043 {LDNS_RR_TYPE_NULL, "TYPE149", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2044 {LDNS_RR_TYPE_NULL, "TYPE150", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2045 {LDNS_RR_TYPE_NULL, "TYPE151", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2046 {LDNS_RR_TYPE_NULL, "TYPE152", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2047 {LDNS_RR_TYPE_NULL, "TYPE153", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2048 {LDNS_RR_TYPE_NULL, "TYPE154", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2049 {LDNS_RR_TYPE_NULL, "TYPE155", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2050 {LDNS_RR_TYPE_NULL, "TYPE156", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2051 {LDNS_RR_TYPE_NULL, "TYPE157", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2052 {LDNS_RR_TYPE_NULL, "TYPE158", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2053 {LDNS_RR_TYPE_NULL, "TYPE159", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2054 {LDNS_RR_TYPE_NULL, "TYPE160", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2055 {LDNS_RR_TYPE_NULL, "TYPE161", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2056 {LDNS_RR_TYPE_NULL, "TYPE162", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2057 {LDNS_RR_TYPE_NULL, "TYPE163", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2058 {LDNS_RR_TYPE_NULL, "TYPE164", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2059 {LDNS_RR_TYPE_NULL, "TYPE165", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2060 {LDNS_RR_TYPE_NULL, "TYPE166", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2061 {LDNS_RR_TYPE_NULL, "TYPE167", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2062 {LDNS_RR_TYPE_NULL, "TYPE168", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2063 {LDNS_RR_TYPE_NULL, "TYPE169", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2064 {LDNS_RR_TYPE_NULL, "TYPE170", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2065 {LDNS_RR_TYPE_NULL, "TYPE171", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2066 {LDNS_RR_TYPE_NULL, "TYPE172", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2067 {LDNS_RR_TYPE_NULL, "TYPE173", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2068 {LDNS_RR_TYPE_NULL, "TYPE174", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2069 {LDNS_RR_TYPE_NULL, "TYPE175", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2070 {LDNS_RR_TYPE_NULL, "TYPE176", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2071 {LDNS_RR_TYPE_NULL, "TYPE177", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2072 {LDNS_RR_TYPE_NULL, "TYPE178", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2073 {LDNS_RR_TYPE_NULL, "TYPE179", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2074 {LDNS_RR_TYPE_NULL, "TYPE180", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2075 {LDNS_RR_TYPE_NULL, "TYPE181", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2076 {LDNS_RR_TYPE_NULL, "TYPE182", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2077 {LDNS_RR_TYPE_NULL, "TYPE183", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2078 {LDNS_RR_TYPE_NULL, "TYPE184", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2079 {LDNS_RR_TYPE_NULL, "TYPE185", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2080 {LDNS_RR_TYPE_NULL, "TYPE186", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2081 {LDNS_RR_TYPE_NULL, "TYPE187", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2082 {LDNS_RR_TYPE_NULL, "TYPE188", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2083 {LDNS_RR_TYPE_NULL, "TYPE189", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2084 {LDNS_RR_TYPE_NULL, "TYPE190", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2085 {LDNS_RR_TYPE_NULL, "TYPE191", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2086 {LDNS_RR_TYPE_NULL, "TYPE192", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2087 {LDNS_RR_TYPE_NULL, "TYPE193", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2088 {LDNS_RR_TYPE_NULL, "TYPE194", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2089 {LDNS_RR_TYPE_NULL, "TYPE195", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2090 {LDNS_RR_TYPE_NULL, "TYPE196", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2091 {LDNS_RR_TYPE_NULL, "TYPE197", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2092 {LDNS_RR_TYPE_NULL, "TYPE198", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2093 {LDNS_RR_TYPE_NULL, "TYPE199", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2094 {LDNS_RR_TYPE_NULL, "TYPE200", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2095 {LDNS_RR_TYPE_NULL, "TYPE201", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2096 {LDNS_RR_TYPE_NULL, "TYPE202", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2097 {LDNS_RR_TYPE_NULL, "TYPE203", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2098 {LDNS_RR_TYPE_NULL, "TYPE204", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2099 {LDNS_RR_TYPE_NULL, "TYPE205", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2100 {LDNS_RR_TYPE_NULL, "TYPE206", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2101 {LDNS_RR_TYPE_NULL, "TYPE207", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2102 {LDNS_RR_TYPE_NULL, "TYPE208", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2103 {LDNS_RR_TYPE_NULL, "TYPE209", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2104 {LDNS_RR_TYPE_NULL, "TYPE210", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2105 {LDNS_RR_TYPE_NULL, "TYPE211", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2106 {LDNS_RR_TYPE_NULL, "TYPE212", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2107 {LDNS_RR_TYPE_NULL, "TYPE213", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2108 {LDNS_RR_TYPE_NULL, "TYPE214", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2109 {LDNS_RR_TYPE_NULL, "TYPE215", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2110 {LDNS_RR_TYPE_NULL, "TYPE216", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2111 {LDNS_RR_TYPE_NULL, "TYPE217", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2112 {LDNS_RR_TYPE_NULL, "TYPE218", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2113 {LDNS_RR_TYPE_NULL, "TYPE219", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2114 {LDNS_RR_TYPE_NULL, "TYPE220", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2115 {LDNS_RR_TYPE_NULL, "TYPE221", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2116 {LDNS_RR_TYPE_NULL, "TYPE222", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2117 {LDNS_RR_TYPE_NULL, "TYPE223", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2118 {LDNS_RR_TYPE_NULL, "TYPE224", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2119 {LDNS_RR_TYPE_NULL, "TYPE225", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2120 {LDNS_RR_TYPE_NULL, "TYPE226", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2121 {LDNS_RR_TYPE_NULL, "TYPE227", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2122 {LDNS_RR_TYPE_NULL, "TYPE228", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2123 {LDNS_RR_TYPE_NULL, "TYPE229", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2124 {LDNS_RR_TYPE_NULL, "TYPE230", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2125 {LDNS_RR_TYPE_NULL, "TYPE231", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2126 {LDNS_RR_TYPE_NULL, "TYPE232", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2127 {LDNS_RR_TYPE_NULL, "TYPE233", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2128 {LDNS_RR_TYPE_NULL, "TYPE234", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2129 {LDNS_RR_TYPE_NULL, "TYPE235", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2130 {LDNS_RR_TYPE_NULL, "TYPE236", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2131 {LDNS_RR_TYPE_NULL, "TYPE237", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2132 {LDNS_RR_TYPE_NULL, "TYPE238", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2133 {LDNS_RR_TYPE_NULL, "TYPE239", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2134 {LDNS_RR_TYPE_NULL, "TYPE240", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2135 {LDNS_RR_TYPE_NULL, "TYPE241", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2136 {LDNS_RR_TYPE_NULL, "TYPE242", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2137 {LDNS_RR_TYPE_NULL, "TYPE243", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2138 {LDNS_RR_TYPE_NULL, "TYPE244", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2139 {LDNS_RR_TYPE_NULL, "TYPE245", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2140 {LDNS_RR_TYPE_NULL, "TYPE246", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2141 {LDNS_RR_TYPE_NULL, "TYPE247", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2142 {LDNS_RR_TYPE_NULL, "TYPE248", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2143 {LDNS_RR_TYPE_NULL, "TYPE249", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2144 {LDNS_RR_TYPE_TSIG, "TSIG", 8, 9, type_tsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
2145 /* split in array, no longer contiguous */
2146 {LDNS_RR_TYPE_DLV, "DLV", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }
2147 };
2148 /** \endcond */
2149
2150 /**
2151  * \def LDNS_RDATA_FIELD_DESCRIPTORS_COUNT
2152  * computes the number of rdata fields
2153  */
2154 #define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \
2155         (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0]))
2156
2157 const ldns_rr_descriptor *
2158 ldns_rr_descript(uint16_t type)
2159 {
2160         size_t i;
2161         if (type <= LDNS_RDATA_FIELD_DESCRIPTORS_COMMON) {
2162                 return &rdata_field_descriptors[type];
2163         } else {
2164                 /* because not all array index equals type code */
2165                 for (i = LDNS_RDATA_FIELD_DESCRIPTORS_COMMON;
2166                      i < LDNS_RDATA_FIELD_DESCRIPTORS_COUNT;
2167                      i++) {
2168                         if (rdata_field_descriptors[i]._type == type) {
2169                                 return &rdata_field_descriptors[i];
2170                         }
2171                 }
2172                 return &rdata_field_descriptors[0];
2173         }
2174 }
2175
2176 size_t
2177 ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor)
2178 {
2179         if (descriptor) {
2180                 return descriptor->_minimum;
2181         } else {
2182                 return 0;
2183         }
2184 }
2185
2186 size_t
2187 ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor)
2188 {
2189         if (descriptor) {
2190                 if (descriptor->_variable != LDNS_RDF_TYPE_NONE) {
2191                         /* Should really be SIZE_MAX... bad FreeBSD.  */
2192                         return UINT_MAX;
2193                 } else {
2194                         return descriptor->_maximum;
2195                 }
2196         } else {
2197                 return 0;
2198         }
2199 }
2200
2201 ldns_rdf_type
2202 ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor,
2203                               size_t index)
2204 {
2205         assert(descriptor != NULL);
2206         assert(index < descriptor->_maximum
2207                || descriptor->_variable != LDNS_RDF_TYPE_NONE);
2208         if (index < descriptor->_maximum) {
2209                 return descriptor->_wireformat[index];
2210         } else {
2211                 return descriptor->_variable;
2212         }
2213 }
2214
2215 ldns_rr_type
2216 ldns_get_rr_type_by_name(const char *name)
2217 {
2218         unsigned int i;
2219         const char *desc_name;
2220         const ldns_rr_descriptor *desc;
2221
2222         /* TYPEXX representation */
2223         if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) {
2224                 return atoi(name + 4);
2225         }
2226
2227         /* Normal types */
2228         for (i = 0; i < (unsigned int) LDNS_RDATA_FIELD_DESCRIPTORS_COUNT; i++) {
2229                 desc = &rdata_field_descriptors[i];
2230                 desc_name = desc->_name;
2231                 if(desc_name &&
2232                    strlen(name) == strlen(desc_name) &&
2233                    strncasecmp(name, desc_name, strlen(desc_name)) == 0) {
2234                         /* because not all array index equals type code */
2235                         return desc->_type;
2236                 }
2237         }
2238
2239         /* special cases for query types */
2240         if (strlen(name) == 4 && strncasecmp(name, "IXFR", 4) == 0) {
2241                 return 251;
2242         } else if (strlen(name) == 4 && strncasecmp(name, "AXFR", 4) == 0) {
2243                 return 252;
2244         } else if (strlen(name) == 5 && strncasecmp(name, "MAILB", 5) == 0) {
2245                 return 253;
2246         } else if (strlen(name) == 5 && strncasecmp(name, "MAILA", 5) == 0) {
2247                 return 254;
2248         } else if (strlen(name) == 3 && strncasecmp(name, "ANY", 3) == 0) {
2249                 return 255;
2250         }
2251
2252         return 0;
2253 }
2254
2255 ldns_rr_class
2256 ldns_get_rr_class_by_name(const char *name)
2257 {
2258         ldns_lookup_table *lt;
2259
2260         /* CLASSXX representation */
2261         if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) {
2262                 return atoi(name + 5);
2263         }
2264
2265         /* Normal types */
2266         lt = ldns_lookup_by_name(ldns_rr_classes, name);
2267
2268         if (lt) {
2269                 return lt->id;
2270         }
2271         return 0;
2272 }
2273
2274
2275 ldns_rr_type
2276 ldns_rdf2rr_type(const ldns_rdf *rd)
2277 {
2278         ldns_rr_type r;
2279
2280         if (!rd) {
2281                 return 0;
2282         }
2283
2284         if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_TYPE) {
2285                 return 0;
2286         }
2287
2288         r = (ldns_rr_type) ldns_rdf2native_int16(rd);
2289         return r;
2290 }
2291
2292 ldns_rr_type
2293 ldns_rr_list_type(const ldns_rr_list *rr_list)
2294 {
2295         if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
2296                 return ldns_rr_get_type(ldns_rr_list_rr(rr_list, 0));
2297         } else {
2298                 return 0;
2299         }
2300 }
2301
2302 ldns_rdf *
2303 ldns_rr_list_owner(const ldns_rr_list *rr_list)
2304 {
2305         if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
2306                 return ldns_rr_owner(ldns_rr_list_rr(rr_list, 0));
2307         } else {
2308                 return NULL;
2309         }
2310 }