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