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