rr.c
Go to the documentation of this file.
00001 /* rr.c
00002  *
00003  * access functions for ldns_rr -
00004  * a Net::DNS like library for C
00005  * LibDNS Team @ NLnet Labs
00006  *
00007  * (c) NLnet Labs, 2004-2006
00008  * See the file LICENSE for the license
00009  */
00010 #include <ldns/config.h>
00011 
00012 #include <ldns/ldns.h>
00013 
00014 #include <strings.h>
00015 #include <limits.h>
00016 
00017 #include <errno.h>
00018 
00019 #define LDNS_SYNTAX_DATALEN 16
00020 #define LDNS_TTL_DATALEN    21
00021 #define LDNS_RRLIST_INIT    8
00022 
00023 ldns_rr *
00024 ldns_rr_new(void)
00025 {
00026         ldns_rr *rr;
00027         rr = LDNS_MALLOC(ldns_rr);
00028         if (!rr) {
00029                 return NULL;
00030         }
00031 
00032         ldns_rr_set_owner(rr, NULL);
00033         ldns_rr_set_question(rr, false);
00034         ldns_rr_set_rd_count(rr, 0);
00035         rr->_rdata_fields = NULL;
00036         ldns_rr_set_class(rr, LDNS_RR_CLASS_IN);
00037         ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL);
00038         return rr;
00039 }
00040 
00041 ldns_rr *
00042 ldns_rr_new_frm_type(ldns_rr_type t)
00043 {
00044         ldns_rr *rr;
00045         const ldns_rr_descriptor *desc;
00046         size_t i;
00047 
00048         rr = LDNS_MALLOC(ldns_rr);
00049         if (!rr) {
00050                 return NULL;
00051         }
00052 
00053         desc = ldns_rr_descript(t);
00054 
00055         rr->_rdata_fields = LDNS_XMALLOC(ldns_rdf *, ldns_rr_descriptor_minimum(desc));
00056         if(!rr->_rdata_fields) {
00057                 LDNS_FREE(rr);
00058                 return NULL;
00059         }
00060         for (i = 0; i < ldns_rr_descriptor_minimum(desc); i++) {
00061                 rr->_rdata_fields[i] = NULL;
00062         }
00063 
00064         ldns_rr_set_owner(rr, NULL);
00065         ldns_rr_set_question(rr, false);
00066         /* set the count to minimum */
00067         ldns_rr_set_rd_count(rr, ldns_rr_descriptor_minimum(desc));
00068         ldns_rr_set_class(rr, LDNS_RR_CLASS_IN);
00069         ldns_rr_set_ttl(rr, LDNS_DEFAULT_TTL);
00070         ldns_rr_set_type(rr, t);
00071         return rr;
00072 }
00073 
00074 void
00075 ldns_rr_free(ldns_rr *rr)
00076 {
00077         size_t i;
00078         if (rr) {
00079                 if (ldns_rr_owner(rr)) {
00080                         ldns_rdf_deep_free(ldns_rr_owner(rr));
00081                 }
00082                 for (i = 0; i < ldns_rr_rd_count(rr); i++) {
00083                         ldns_rdf_deep_free(ldns_rr_rdf(rr, i));
00084                 }
00085                 LDNS_FREE(rr->_rdata_fields);
00086                 LDNS_FREE(rr);
00087         }
00088 }
00089 
00090 /*
00091  * trailing spaces are allowed
00092  * leading spaces are not allowed
00093  * allow ttl to be optional
00094  * class is optional too
00095  * if ttl is missing, and default_ttl is 0, use DEF_TTL
00096  * allow ttl to be written as 1d3h
00097  * So the RR should look like. e.g.
00098  * miek.nl. 3600 IN MX 10 elektron.atoom.net
00099  * or
00100  * miek.nl. 1h IN MX 10 elektron.atoom.net
00101  * or
00102  * miek.nl. IN MX 10 elektron.atoom.net
00103  */
00104 static ldns_status
00105 ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str,
00106                              uint32_t default_ttl, ldns_rdf *origin,
00107                              ldns_rdf **prev, bool question)
00108 {
00109         ldns_rr *new;
00110         const ldns_rr_descriptor *desc;
00111         ldns_rr_type rr_type;
00112         ldns_buffer *rr_buf = NULL;
00113         ldns_buffer *rd_buf = NULL;
00114         uint32_t ttl_val;
00115         char  *owner = NULL;
00116         char  *ttl = NULL;
00117         ldns_rr_class clas_val;
00118         char  *clas = NULL;
00119         char  *type = NULL;
00120         char  *rdata = NULL;
00121         char  *rd = NULL;
00122         char  * b64 = NULL;
00123         size_t rd_strlen;
00124         const char *delimiters;
00125         ssize_t c;
00126         ldns_rdf *owner_dname;
00127         const char* endptr;
00128         int was_unknown_rr_format = 0;
00129         ldns_status status = LDNS_STATUS_OK;
00130 
00131         /* used for types with unknown number of rdatas */
00132         bool done;
00133         bool quoted;
00134 
00135         ldns_rdf *r = NULL;
00136         uint16_t r_cnt;
00137         uint16_t r_min;
00138         uint16_t r_max;
00139         size_t pre_data_pos;
00140 
00141         new = ldns_rr_new();
00142 
00143         owner = LDNS_XMALLOC(char, LDNS_MAX_DOMAINLEN + 1);
00144         ttl = LDNS_XMALLOC(char, LDNS_TTL_DATALEN);
00145         clas = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
00146         rdata = LDNS_XMALLOC(char, LDNS_MAX_PACKETLEN + 1);
00147         rr_buf = LDNS_MALLOC(ldns_buffer);
00148         rd_buf = LDNS_MALLOC(ldns_buffer);
00149         rd = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
00150         b64 = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
00151         if (!new || !owner || !ttl || !clas || !rdata || !rr_buf || !rd_buf || !rd || !b64 ) {
00152                 status = LDNS_STATUS_MEM_ERR;
00153                 LDNS_FREE(rr_buf);
00154                 goto ldnserror;
00155         }
00156 
00157         ldns_buffer_new_frm_data(rr_buf, (char*)str, strlen(str));
00158 
00159         /* split the rr in its parts -1 signals trouble */
00160         if (ldns_bget_token(rr_buf, owner, "\t\n ", LDNS_MAX_DOMAINLEN) == -1) {
00161                 status = LDNS_STATUS_SYNTAX_ERR;
00162                 ldns_buffer_free(rr_buf);
00163                 goto ldnserror;
00164         }
00165 
00166         if (ldns_bget_token(rr_buf, ttl, "\t\n ", LDNS_TTL_DATALEN) == -1) {
00167                 status = LDNS_STATUS_SYNTAX_TTL_ERR;
00168                 ldns_buffer_free(rr_buf);
00169                 goto ldnserror;
00170         }
00171         ttl_val = (uint32_t) ldns_str2period(ttl, &endptr);
00172 
00173         if (strlen(ttl) > 0 && !isdigit((int) ttl[0])) {
00174                 /* ah, it's not there or something */
00175                 if (default_ttl == 0) {
00176                         ttl_val = LDNS_DEFAULT_TTL;
00177                 } else {
00178                         ttl_val = default_ttl;
00179                 }
00180                 /* we not ASSUMING the TTL is missing and that
00181                  * the rest of the RR is still there. That is
00182                  * CLASS TYPE RDATA
00183                  * so ttl value we read is actually the class
00184                  */
00185                 clas_val = ldns_get_rr_class_by_name(ttl);
00186                 /* class can be left out too, assume IN, current
00187                  * token must be type
00188                  */
00189                 if (clas_val == 0) {
00190                         clas_val = LDNS_RR_CLASS_IN;
00191                         type = LDNS_XMALLOC(char, strlen(ttl) + 1);
00192                         if(!type) {
00193                                 status = LDNS_STATUS_MEM_ERR;
00194                                 ldns_buffer_free(rr_buf);
00195                                 goto ldnserror;
00196                         }
00197                         strncpy(type, ttl, strlen(ttl) + 1);
00198                 }
00199         } else {
00200                 if (ldns_bget_token(rr_buf, clas, "\t\n ", LDNS_SYNTAX_DATALEN) == -1) {
00201                         status = LDNS_STATUS_SYNTAX_CLASS_ERR;
00202                         ldns_buffer_free(rr_buf);
00203                         goto ldnserror;
00204                 }
00205                 clas_val = ldns_get_rr_class_by_name(clas);
00206                 /* class can be left out too, assume IN, current
00207                  * token must be type
00208                  */
00209                 if (clas_val == 0) {
00210                         clas_val = LDNS_RR_CLASS_IN;
00211                         type = LDNS_XMALLOC(char, strlen(clas) + 1);
00212                         if(!type) {
00213                                 status = LDNS_STATUS_MEM_ERR;
00214                                 ldns_buffer_free(rr_buf);
00215                                 goto ldnserror;
00216                         }
00217                         strncpy(type, clas, strlen(clas) + 1);
00218                 }
00219         }
00220         /* the rest should still be waiting for us */
00221 
00222         if (!type) {
00223                 type = LDNS_XMALLOC(char, LDNS_SYNTAX_DATALEN);
00224                 if(!type) {
00225                         status = LDNS_STATUS_MEM_ERR;
00226                         ldns_buffer_free(rr_buf);
00227                         goto ldnserror;
00228                 }
00229                 if (ldns_bget_token(rr_buf, type, "\t\n ", LDNS_SYNTAX_DATALEN) == -1) {
00230                         status = LDNS_STATUS_SYNTAX_TYPE_ERR;
00231                         ldns_buffer_free(rr_buf);
00232                         goto ldnserror;
00233                 }
00234         }
00235 
00236         if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) {
00237                 /* apparently we are done, and it's only a question RR
00238                  * so do not set status and go to ldnserror here
00239                 */
00240         }
00241 
00242         ldns_buffer_new_frm_data(rd_buf, rdata, strlen(rdata));
00243 
00244         if (strlen(owner) <= 1 && strncmp(owner, "@", 1) == 0) {
00245                 if (origin) {
00246                         ldns_rr_set_owner(new, ldns_rdf_clone(origin));
00247                 } else if (prev && *prev) {
00248                         ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
00249                 } else {
00250                         /* default to root */
00251                         ldns_rr_set_owner(new, ldns_dname_new_frm_str("."));
00252                 }
00253 
00254                 /* @ also overrides prev */
00255                 if (prev) {
00256                         ldns_rdf_deep_free(*prev);
00257                         *prev = ldns_rdf_clone(ldns_rr_owner(new));
00258                         if (!*prev) {
00259                                 status = LDNS_STATUS_MEM_ERR;
00260                                 ldns_buffer_free(rr_buf);
00261                                 goto ldnserror;
00262                         }
00263                 }
00264         } else {
00265                 if (strlen(owner) == 0) {
00266                         /* no ownername was given, try prev, if that fails
00267                          * origin, else default to root */
00268                         if (prev && *prev) {
00269                                 ldns_rr_set_owner(new, ldns_rdf_clone(*prev));
00270                         } else if (origin) {
00271                                 ldns_rr_set_owner(new, ldns_rdf_clone(origin));
00272                         } else {
00273                                 ldns_rr_set_owner(new, ldns_dname_new_frm_str("."));
00274                         }
00275                         if(!ldns_rr_owner(new)) {
00276                                 status = LDNS_STATUS_MEM_ERR;
00277                                 ldns_buffer_free(rr_buf);
00278                                 goto ldnserror;
00279                         }
00280                 } else {
00281                         owner_dname = ldns_dname_new_frm_str(owner);
00282                         if (!owner_dname) {
00283                                 status = LDNS_STATUS_SYNTAX_ERR;
00284                                 ldns_buffer_free(rr_buf);
00285                                 goto ldnserror;
00286                         }
00287 
00288                         ldns_rr_set_owner(new, owner_dname);
00289                         if (!ldns_dname_str_absolute(owner) && origin) {
00290                                 if(ldns_dname_cat(ldns_rr_owner(new),
00291                                                         origin) != LDNS_STATUS_OK) {
00292                                         status = LDNS_STATUS_SYNTAX_ERR;
00293                                         ldns_buffer_free(rr_buf);
00294                                         goto ldnserror;
00295                                 }
00296                         }
00297                         if (prev) {
00298                                 ldns_rdf_deep_free(*prev);
00299                                 *prev = ldns_rdf_clone(ldns_rr_owner(new));
00300                                 if(!*prev) {
00301                                         status = LDNS_STATUS_MEM_ERR;
00302                                         ldns_buffer_free(rr_buf);
00303                                         goto ldnserror;
00304                                 }
00305                         }
00306                 }
00307         }
00308         LDNS_FREE(owner);
00309         owner = NULL;
00310 
00311         ldns_rr_set_question(new, question);
00312 
00313         ldns_rr_set_ttl(new, ttl_val);
00314         LDNS_FREE(ttl);
00315         ttl = NULL;
00316 
00317         ldns_rr_set_class(new, clas_val);
00318         LDNS_FREE(clas);
00319         clas = NULL;
00320 
00321         rr_type = ldns_get_rr_type_by_name(type);
00322         LDNS_FREE(type);
00323         type = NULL;
00324 
00325         desc = ldns_rr_descript((uint16_t)rr_type);
00326         ldns_rr_set_type(new, rr_type);
00327         if (desc) {
00328                 /* only the rdata remains */
00329                 r_max = ldns_rr_descriptor_maximum(desc);
00330                 r_min = ldns_rr_descriptor_minimum(desc);
00331         } else {
00332                 r_min = 0;
00333                 r_max = 1;
00334         }
00335 
00336         /* depending on the rr_type we need to extract
00337          * the rdata differently, e.g. NSEC/NSEC3 */
00338         switch(rr_type) {
00339                 default:
00340                         done = false;
00341 
00342                         for (r_cnt = 0; !done && r_cnt < r_max; r_cnt++) {
00343                                 quoted = false;
00344                                 /* if type = B64, the field may contain spaces */
00345                                 if (ldns_rr_descriptor_field_type(desc,
00346                                             r_cnt) == LDNS_RDF_TYPE_B64 ||
00347                                     ldns_rr_descriptor_field_type(desc,
00348                                             r_cnt) == LDNS_RDF_TYPE_HEX ||
00349                                     ldns_rr_descriptor_field_type(desc,
00350                                             r_cnt) == LDNS_RDF_TYPE_LOC ||
00351                                     ldns_rr_descriptor_field_type(desc,
00352                                             r_cnt) == LDNS_RDF_TYPE_WKS ||
00353                                     ldns_rr_descriptor_field_type(desc,
00354                                             r_cnt) == LDNS_RDF_TYPE_IPSECKEY ||
00355                                     ldns_rr_descriptor_field_type(desc,
00356                                             r_cnt) == LDNS_RDF_TYPE_NSEC) {
00357                                         delimiters = "\n\t";
00358                                 } else {
00359                                         delimiters = "\n\t ";
00360                                 }
00361 
00362                                 if (ldns_rr_descriptor_field_type(desc,
00363                                                         r_cnt) == LDNS_RDF_TYPE_STR &&
00364                                                         ldns_buffer_remaining(rd_buf) > 0) {
00365                                         /* skip spaces */
00366                                         while (*(ldns_buffer_current(rd_buf)) == ' ') {
00367                                                 ldns_buffer_skip(rd_buf, 1);
00368                                         }
00369 
00370                                         if (*(ldns_buffer_current(rd_buf)) == '\"') {
00371                                                 delimiters = "\"\0";
00372                                                 ldns_buffer_skip(rd_buf, 1);
00373                                                 quoted = true;
00374                                         }
00375                                 }
00376 
00377                                 /* because number of fields can be variable, we can't
00378                                    rely on _maximum() only */
00379                                 /* skip spaces */
00380                                 while (ldns_buffer_position(rd_buf) < ldns_buffer_limit(rd_buf) &&
00381                                         *(ldns_buffer_current(rd_buf)) == ' ' && !quoted
00382                                       ) {
00383                                         ldns_buffer_skip(rd_buf, 1);
00384                                 }
00385 
00386                                 pre_data_pos = ldns_buffer_position(rd_buf);
00387                                 if ((c = ldns_bget_token(rd_buf, rd, delimiters,
00388                                                         LDNS_MAX_RDFLEN)) != -1) {
00389                                         /* hmmz, rfc3597 specifies that any type can be represented with
00390                                          * \# method, which can contain spaces...
00391                                          * it does specify size though...
00392                                          */
00393                                         rd_strlen = strlen(rd);
00394 
00395                                         /* unknown RR data */
00396                                         if (strncmp(rd, "\\#", 2) == 0 && !quoted && (rd_strlen == 2 || rd[2]==' ')) {
00397                                                 uint16_t hex_data_size;
00398                                                 char *hex_data_str;
00399                                                 uint16_t cur_hex_data_size;
00400 
00401                                                 was_unknown_rr_format = 1;
00402                                                 /* go back to before \# and skip it while setting delimiters better */
00403                                                 ldns_buffer_set_position(rd_buf, pre_data_pos);
00404                                                 delimiters = "\n\t ";
00405                                                 (void)ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN);
00406                                                 /* read rdata octet length */
00407                                                 c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN);
00408                                                 if (c == -1) {
00409                                                         /* something goes very wrong here */
00410                                                         LDNS_FREE(rd);
00411                                                         LDNS_FREE(b64);
00412                                                         ldns_buffer_free(rd_buf);
00413                                                         ldns_buffer_free(rr_buf);
00414                                                         LDNS_FREE(rdata);
00415                                                         ldns_rr_free(new);
00416                                                         return LDNS_STATUS_SYNTAX_RDATA_ERR;
00417                                                 }
00418                                                 hex_data_size = (uint16_t) atoi(rd);
00419                                                 /* copy the hex chars into hex str (which is 2 chars per byte) */
00420                                                 hex_data_str = LDNS_XMALLOC(char, 2 * hex_data_size + 1);
00421                                                 if (!hex_data_str) {
00422                                                         /* malloc error */
00423                                                         LDNS_FREE(rd);
00424                                                         LDNS_FREE(b64);
00425                                                         ldns_buffer_free(rd_buf);
00426                                                         ldns_buffer_free(rr_buf);
00427                                                         LDNS_FREE(rdata);
00428                                                         ldns_rr_free(new);
00429                                                         return LDNS_STATUS_SYNTAX_RDATA_ERR;
00430                                                 }
00431                                                 cur_hex_data_size = 0;
00432                                                 while(cur_hex_data_size < 2 * hex_data_size) {
00433                                                         c = ldns_bget_token(rd_buf, rd, delimiters, LDNS_MAX_RDFLEN);
00434                                                         if (c != -1) {
00435                                                                 rd_strlen = strlen(rd);
00436                                                         }
00437                                                         if (c == -1 || (size_t)cur_hex_data_size + rd_strlen > 2 * (size_t)hex_data_size) {
00438                                                                 LDNS_FREE(hex_data_str);
00439                                                                 LDNS_FREE(rd);
00440                                                                 LDNS_FREE(b64);
00441                                                                 ldns_buffer_free(rd_buf);
00442                                                                 ldns_buffer_free(rr_buf);
00443                                                                 LDNS_FREE(rdata);
00444                                                                 ldns_rr_free(new);
00445                                                                 return LDNS_STATUS_SYNTAX_RDATA_ERR;
00446                                                         }
00447                                                         strncpy(hex_data_str + cur_hex_data_size, rd, rd_strlen);
00448                                                         cur_hex_data_size += rd_strlen;
00449                                                 }
00450                                                 hex_data_str[cur_hex_data_size] = '\0';
00451 
00452                                                 /* correct the rdf type */
00453                                                 /* if *we* know the type, interpret it as wireformat */
00454                                                 if (desc) {
00455                                                         size_t hex_pos = 0;
00456                                                         uint8_t *hex_data = LDNS_XMALLOC(uint8_t, hex_data_size + 2);
00457                                                         ldns_status s;
00458                                                         if(!hex_data) {
00459                                                                 LDNS_FREE(hex_data_str);
00460                                                                 LDNS_FREE(rd);
00461                                                                 LDNS_FREE(b64);
00462                                                                 ldns_buffer_free(rd_buf);
00463                                                                 ldns_buffer_free(rr_buf);
00464                                                                 LDNS_FREE(rdata);
00465                                                                 ldns_rr_free(new);
00466                                                                 return LDNS_STATUS_MEM_ERR;
00467                                                         }
00468                                                         ldns_write_uint16(hex_data, hex_data_size);
00469                                                         ldns_hexstring_to_data(hex_data + 2, hex_data_str);
00470                                                         s = ldns_wire2rdf(new, hex_data,
00471                                                                          hex_data_size+2, &hex_pos);
00472                                                         if(s != LDNS_STATUS_OK) {
00473                                                                 LDNS_FREE(hex_data_str);
00474                                                                 LDNS_FREE(rd);
00475                                                                 LDNS_FREE(b64);
00476                                                                 ldns_buffer_free(rd_buf);
00477                                                                 ldns_buffer_free(rr_buf);
00478                                                                 LDNS_FREE(rdata);
00479                                                                 ldns_rr_free(new);
00480                                                                 LDNS_FREE(hex_data);
00481                                                                 return s;
00482                                                         }
00483                                                         LDNS_FREE(hex_data);
00484                                                 } else {
00485                                                         r = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_HEX, hex_data_str);
00486                                                         if(!r) {
00487                                                                 LDNS_FREE(hex_data_str);
00488                                                                 LDNS_FREE(rd);
00489                                                                 LDNS_FREE(b64);
00490                                                                 ldns_buffer_free(rd_buf);
00491                                                                 ldns_buffer_free(rr_buf);
00492                                                                 LDNS_FREE(rdata);
00493                                                                 ldns_rr_free(new);
00494                                                                 return LDNS_STATUS_MEM_ERR;
00495                                                         }
00496                                                         ldns_rdf_set_type(r, LDNS_RDF_TYPE_UNKNOWN);
00497                                                         if(!ldns_rr_push_rdf(new, r)) {
00498                                                                 LDNS_FREE(hex_data_str);
00499                                                                 LDNS_FREE(rd);
00500                                                                 LDNS_FREE(b64);
00501                                                                 ldns_buffer_free(rd_buf);
00502                                                                 ldns_buffer_free(rr_buf);
00503                                                                 LDNS_FREE(rdata);
00504                                                                 ldns_rr_free(new);
00505                                                                 return LDNS_STATUS_MEM_ERR;
00506                                                         }
00507                                                 }
00508                                                 LDNS_FREE(hex_data_str);
00509                                         } else {
00510                                                 /* Normal RR */
00511                                                 switch(ldns_rr_descriptor_field_type(desc, r_cnt)) {
00512                                                 case LDNS_RDF_TYPE_HEX:
00513                                                 case LDNS_RDF_TYPE_B64:
00514                                                         /* can have spaces, and will always be the last
00515                                                          * record of the rrdata. Read in the rest */
00516                                                         if ((c = ldns_bget_token(rd_buf,
00517                                                                                                 b64,
00518                                                                                                 "\n",
00519                                                                                                 LDNS_MAX_RDFLEN))
00520                                                             != -1) {
00521                                                                 rd = strncat(rd,
00522                                                                                    b64,
00523                                                                                    LDNS_MAX_RDFLEN
00524                                                                                    - strlen(rd) - 1);
00525                                                         }
00526                                                         r = ldns_rdf_new_frm_str(
00527                                                                         ldns_rr_descriptor_field_type(desc, r_cnt),
00528                                                                         rd);
00529                                                         break;
00530                                                 case LDNS_RDF_TYPE_DNAME:
00531                                                         r = ldns_rdf_new_frm_str(
00532                                                                         ldns_rr_descriptor_field_type(desc, r_cnt),
00533                                                                         rd);
00534 
00535                                                         /* check if the origin should be used or concatenated */
00536                                                         if (r && ldns_rdf_size(r) > 1 && ldns_rdf_data(r)[0] == 1
00537                                                                 && ldns_rdf_data(r)[1] == '@') {
00538                                                                 ldns_rdf_deep_free(r);
00539                                                                 if (origin) {
00540                                                                         r = ldns_rdf_clone(origin);
00541                                                                 } else {
00542                                                                      /* if this is the SOA, use its own owner name */
00543                                                                         if (rr_type == LDNS_RR_TYPE_SOA) {
00544                                                                                 r = ldns_rdf_clone(ldns_rr_owner(new));
00545                                                                         } else {
00546                                                                                 r = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, ".");
00547                                                                         }
00548                                                                 }
00549                                                         } else if (r && rd_strlen >= 1 && !ldns_dname_str_absolute(rd) && origin) {
00550                                                                 if (ldns_dname_cat(r, origin) != LDNS_STATUS_OK) {
00551                                                                         LDNS_FREE(rd);
00552                                                                         LDNS_FREE(b64);
00553                                                                         ldns_buffer_free(rd_buf);
00554                                                                         ldns_buffer_free(rr_buf);
00555                                                                         LDNS_FREE(rdata);
00556                                                                         ldns_rr_free(new);
00557                                                                         return LDNS_STATUS_ERR;
00558                                                                 }
00559                                                         }
00560                                                         break;
00561                                                 default:
00562                                                         r = ldns_rdf_new_frm_str(
00563                                                                         ldns_rr_descriptor_field_type(desc, r_cnt),
00564                                                                         rd);
00565                                                         break;
00566                                                 }
00567                                                 if (r) {
00568                                                         ldns_rr_push_rdf(new, r);
00569                                                 } else {
00570                                                         LDNS_FREE(rd);
00571                                                         LDNS_FREE(b64);
00572                                                         ldns_buffer_free(rd_buf);
00573                                                         ldns_buffer_free(rr_buf);
00574                                                         LDNS_FREE(rdata);
00575                                                         ldns_rr_free(new);
00576                                                         return LDNS_STATUS_SYNTAX_RDATA_ERR;
00577                                                 }
00578                                         }
00579                                         if (quoted) {
00580                                                 if (ldns_buffer_available(rd_buf, 1)) {
00581                                                         ldns_buffer_skip(rd_buf, 1);
00582                                                 } else {
00583                                                         done = true;
00584                                                 }
00585                                         }
00586                                 } else {
00587                                         done = true;
00588                                 }
00589                         }
00590         }
00591         LDNS_FREE(rd);
00592         LDNS_FREE(b64);
00593         ldns_buffer_free(rd_buf);
00594         ldns_buffer_free(rr_buf);
00595         LDNS_FREE(rdata);
00596 
00597         if (!question && desc && !was_unknown_rr_format && ldns_rr_rd_count(new) < r_min) {
00598                 ldns_rr_free(new);
00599                 return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
00600         }
00601 
00602         if (newrr) {
00603                 *newrr = new;
00604         } else {
00605                 /* Maybe the caller just wanted to see if it would parse? */
00606                 ldns_rr_free(new);
00607         }
00608         return LDNS_STATUS_OK;
00609 
00610 ldnserror:
00611         LDNS_FREE(type);
00612         LDNS_FREE(owner);
00613         LDNS_FREE(ttl);
00614         LDNS_FREE(clas);
00615         LDNS_FREE(rdata);
00616         LDNS_FREE(rd);
00617         LDNS_FREE(rd_buf);
00618         LDNS_FREE(b64);
00619         ldns_rr_free(new);
00620     return status;
00621 }
00622 
00623 ldns_status
00624 ldns_rr_new_frm_str(ldns_rr **newrr, const char *str,
00625                     uint32_t default_ttl, ldns_rdf *origin,
00626                     ldns_rdf **prev)
00627 {
00628         return ldns_rr_new_frm_str_internal(newrr,
00629                                             str,
00630                                             default_ttl,
00631                                             origin,
00632                                             prev,
00633                                             false);
00634 }
00635 
00636 ldns_status
00637 ldns_rr_new_question_frm_str(ldns_rr **newrr, const char *str,
00638                              ldns_rdf *origin, ldns_rdf **prev)
00639 {
00640         return ldns_rr_new_frm_str_internal(newrr,
00641                                             str,
00642                                             0,
00643                                             origin,
00644                                             prev,
00645                                             true);
00646 }
00647 
00648 ldns_status
00649 ldns_rr_new_frm_fp(ldns_rr **newrr, FILE *fp, uint32_t *ttl, ldns_rdf **origin, ldns_rdf **prev)
00650 {
00651         return ldns_rr_new_frm_fp_l(newrr, fp, ttl, origin, prev, NULL);
00652 }
00653 
00654 ldns_status
00655 ldns_rr_new_frm_fp_l(ldns_rr **newrr, FILE *fp, uint32_t *default_ttl, ldns_rdf **origin, ldns_rdf **prev, int *line_nr)
00656 {
00657         char *line;
00658         const char *endptr;  /* unused */
00659         ldns_rr *rr;
00660         uint32_t ttl;
00661         ldns_rdf *tmp;
00662         ldns_status s;
00663         ssize_t size;
00664         int offset = 0;
00665 
00666         if (default_ttl) {
00667                 ttl = *default_ttl;
00668         } else {
00669                 ttl = 0;
00670         }
00671 
00672         line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
00673         if (!line) {
00674                 return LDNS_STATUS_MEM_ERR;
00675         }
00676 
00677         /* read an entire line in from the file */
00678         if ((size = ldns_fget_token_l(fp, line, LDNS_PARSE_SKIP_SPACE, LDNS_MAX_LINELEN, line_nr)) == -1) {
00679                 LDNS_FREE(line);
00680                 /* if last line was empty, we are now at feof, which is not
00681                  * always a parse error (happens when for instance last line
00682                  * was a comment)
00683                  */
00684                 return LDNS_STATUS_SYNTAX_ERR;
00685         }
00686 
00687         /* we can have the situation, where we've read ok, but still got
00688          * no bytes to play with, in this case size is 0
00689          */
00690         if (size == 0) {
00691                 LDNS_FREE(line);
00692                 return LDNS_STATUS_SYNTAX_EMPTY;
00693         }
00694 
00695         if (strncmp(line, "$ORIGIN", 7) == 0 && isspace(line[7])) {
00696                 if (*origin) {
00697                         ldns_rdf_deep_free(*origin);
00698                         *origin = NULL;
00699                 }
00700                 offset = 8;
00701                 while (isspace(line[offset])) {
00702                         offset++;
00703                 }
00704                 tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, line + offset);
00705                 if (!tmp) {
00706                         /* could not parse what next to $ORIGIN */
00707                         LDNS_FREE(line);
00708                         return LDNS_STATUS_SYNTAX_DNAME_ERR;
00709                 }
00710                 *origin = tmp;
00711                 s = LDNS_STATUS_SYNTAX_ORIGIN;
00712         } else if (strncmp(line, "$TTL", 4) == 0 && isspace(line[4])) {
00713                 offset = 5;
00714                 while (isspace(line[offset])) {
00715                         offset++;
00716                 }
00717                 if (default_ttl) {
00718                         *default_ttl = ldns_str2period(line + offset, &endptr);
00719                 }
00720                 s = LDNS_STATUS_SYNTAX_TTL;
00721         } else if (strncmp(line, "$INCLUDE", 8) == 0) {
00722                 s = LDNS_STATUS_SYNTAX_INCLUDE;
00723         } else {
00724                 if (origin && *origin) {
00725                         s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, *origin, prev);
00726                 } else {
00727                         s = ldns_rr_new_frm_str(&rr, (const char*) line, ttl, NULL, prev);
00728                 }
00729         }
00730         LDNS_FREE(line);
00731         if (s == LDNS_STATUS_OK) {
00732                 if (newrr) {
00733                         *newrr = rr;
00734                 } else {
00735                         /* Just testing if it would parse? */
00736                         ldns_rr_free(rr);
00737                 }
00738         }
00739         return s;
00740 }
00741 
00742 void
00743 ldns_rr_set_owner(ldns_rr *rr, ldns_rdf *owner)
00744 {
00745         rr->_owner = owner;
00746 }
00747 
00748 void
00749 ldns_rr_set_question(ldns_rr *rr, bool question)
00750 {
00751    rr->_rr_question = question;
00752 }
00753 
00754 void
00755 ldns_rr_set_ttl(ldns_rr *rr, uint32_t ttl)
00756 {
00757         rr->_ttl = ttl;
00758 }
00759 
00760 void
00761 ldns_rr_set_rd_count(ldns_rr *rr, size_t count)
00762 {
00763         rr->_rd_count = count;
00764 }
00765 
00766 void
00767 ldns_rr_set_type(ldns_rr *rr, ldns_rr_type rr_type)
00768 {
00769         rr->_rr_type = rr_type;
00770 }
00771 
00772 void
00773 ldns_rr_set_class(ldns_rr *rr, ldns_rr_class rr_class)
00774 {
00775         rr->_rr_class = rr_class;
00776 }
00777 
00778 ldns_rdf *
00779 ldns_rr_set_rdf(ldns_rr *rr, const ldns_rdf *f, size_t position)
00780 {
00781         size_t rd_count;
00782         ldns_rdf *pop;
00783 
00784         rd_count = ldns_rr_rd_count(rr);
00785         if (position < rd_count) {
00786                 /* dicard the old one */
00787                 pop = rr->_rdata_fields[position];
00788                 rr->_rdata_fields[position] = (ldns_rdf*)f;
00789                 return pop;
00790         } else {
00791                 return NULL;
00792         }
00793 }
00794 
00795 bool
00796 ldns_rr_push_rdf(ldns_rr *rr, const ldns_rdf *f)
00797 {
00798         size_t rd_count;
00799         ldns_rdf **rdata_fields;
00800 
00801         rd_count = ldns_rr_rd_count(rr);
00802 
00803         /* grow the array */
00804         rdata_fields = LDNS_XREALLOC(
00805                 rr->_rdata_fields, ldns_rdf *, rd_count + 1);
00806         if (!rdata_fields) {
00807                 return false;
00808         }
00809 
00810         /* add the new member */
00811         rr->_rdata_fields = rdata_fields;
00812         rr->_rdata_fields[rd_count] = (ldns_rdf*)f;
00813 
00814         ldns_rr_set_rd_count(rr, rd_count + 1);
00815         return true;
00816 }
00817 
00818 ldns_rdf *
00819 ldns_rr_pop_rdf(ldns_rr *rr)
00820 {
00821         size_t rd_count;
00822         ldns_rdf *pop;
00823         ldns_rdf** newrd;
00824 
00825         rd_count = ldns_rr_rd_count(rr);
00826 
00827         if (rd_count == 0) {
00828                 return NULL;
00829         }
00830 
00831         pop = rr->_rdata_fields[rd_count - 1];
00832 
00833         /* try to shrink the array */
00834         if(rd_count > 1) {
00835                 newrd = LDNS_XREALLOC(
00836                         rr->_rdata_fields, ldns_rdf *, rd_count - 1);
00837                 if(newrd)
00838                         rr->_rdata_fields = newrd;
00839         } else {
00840                 LDNS_FREE(rr->_rdata_fields);
00841         }
00842 
00843         ldns_rr_set_rd_count(rr, rd_count - 1);
00844         return pop;
00845 }
00846 
00847 ldns_rdf *
00848 ldns_rr_rdf(const ldns_rr *rr, size_t nr)
00849 {
00850         if (rr && nr < ldns_rr_rd_count(rr)) {
00851                 return rr->_rdata_fields[nr];
00852         } else {
00853                 return NULL;
00854         }
00855 }
00856 
00857 ldns_rdf *
00858 ldns_rr_owner(const ldns_rr *rr)
00859 {
00860         return rr->_owner;
00861 }
00862 
00863 bool
00864 ldns_rr_is_question(const ldns_rr *rr)
00865 {
00866    return rr->_rr_question;
00867 }
00868 
00869 uint32_t
00870 ldns_rr_ttl(const ldns_rr *rr)
00871 {
00872         return rr->_ttl;
00873 }
00874 
00875 size_t
00876 ldns_rr_rd_count(const ldns_rr *rr)
00877 {
00878         return rr->_rd_count;
00879 }
00880 
00881 ldns_rr_type
00882 ldns_rr_get_type(const ldns_rr *rr)
00883 {
00884         return rr->_rr_type;
00885 }
00886 
00887 ldns_rr_class
00888 ldns_rr_get_class(const ldns_rr *rr)
00889 {
00890         return rr->_rr_class;
00891 }
00892 
00893 /* rr_lists */
00894 
00895 size_t
00896 ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
00897 {
00898         if (rr_list) {
00899                 return rr_list->_rr_count;
00900         } else {
00901                 return 0;
00902         }
00903 }
00904 
00905 ldns_rr *
00906 ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t count)
00907 {
00908         ldns_rr *old;
00909 
00910         if (count > ldns_rr_list_rr_count(rr_list)) {
00911                 return NULL;
00912         }
00913 
00914         old = ldns_rr_list_rr(rr_list, count);
00915 
00916         /* overwrite old's pointer */
00917         rr_list->_rrs[count] = (ldns_rr*)r;
00918         return old;
00919 }
00920 
00921 void
00922 ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count)
00923 {
00924         assert(count <= rr_list->_rr_capacity);
00925         rr_list->_rr_count = count;
00926 }
00927 
00928 ldns_rr *
00929 ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
00930 {
00931         if (nr < ldns_rr_list_rr_count(rr_list)) {
00932                 return rr_list->_rrs[nr];
00933         } else {
00934                 return NULL;
00935         }
00936 }
00937 
00938 ldns_rr_list *
00939 ldns_rr_list_new()
00940 {
00941         ldns_rr_list *rr_list = LDNS_MALLOC(ldns_rr_list);
00942         if(!rr_list) return NULL;
00943         rr_list->_rr_count = 0;
00944         rr_list->_rr_capacity = 0;
00945         rr_list->_rrs = NULL;
00946         return rr_list;
00947 }
00948 
00949 void
00950 ldns_rr_list_free(ldns_rr_list *rr_list)
00951 {
00952         if (rr_list) {
00953                 LDNS_FREE(rr_list->_rrs);
00954                 LDNS_FREE(rr_list);
00955         }
00956 }
00957 
00958 void
00959 ldns_rr_list_deep_free(ldns_rr_list *rr_list)
00960 {
00961         size_t i;
00962 
00963         if (rr_list) {
00964                 for (i=0; i < ldns_rr_list_rr_count(rr_list); i++) {
00965                         ldns_rr_free(ldns_rr_list_rr(rr_list, i));
00966                 }
00967                 LDNS_FREE(rr_list->_rrs);
00968                 LDNS_FREE(rr_list);
00969         }
00970 }
00971 
00972 
00973 /* add right to left. So we modify *left! */
00974 bool
00975 ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right)
00976 {
00977         size_t r_rr_count;
00978         size_t i;
00979 
00980         if (!left) {
00981                 return false;
00982         }
00983 
00984         if (right) {
00985                 r_rr_count = ldns_rr_list_rr_count(right);
00986         } else {
00987                 r_rr_count = 0;
00988         }
00989 
00990         /* push right to left */
00991         for(i = 0; i < r_rr_count; i++) {
00992                 ldns_rr_list_push_rr(left, ldns_rr_list_rr(right, i));
00993         }
00994         return true;
00995 }
00996 
00997 ldns_rr_list *
00998 ldns_rr_list_cat_clone(ldns_rr_list *left, ldns_rr_list *right)
00999 {
01000         size_t l_rr_count;
01001         size_t r_rr_count;
01002         size_t i;
01003         ldns_rr_list *cat;
01004 
01005         if (left) {
01006                 l_rr_count = ldns_rr_list_rr_count(left);
01007         } else {
01008                 return ldns_rr_list_clone(right);
01009         }
01010 
01011         if (right) {
01012                 r_rr_count = ldns_rr_list_rr_count(right);
01013         } else {
01014                 r_rr_count = 0;
01015         }
01016 
01017         cat = ldns_rr_list_new();
01018 
01019         if (!cat) {
01020                 return NULL;
01021         }
01022 
01023         /* left */
01024         for(i = 0; i < l_rr_count; i++) {
01025                 ldns_rr_list_push_rr(cat,
01026                                 ldns_rr_clone(ldns_rr_list_rr(left, i)));
01027         }
01028         /* right */
01029         for(i = 0; i < r_rr_count; i++) {
01030                 ldns_rr_list_push_rr(cat,
01031                                 ldns_rr_clone(ldns_rr_list_rr(right, i)));
01032         }
01033         return cat;
01034 }
01035 
01036 ldns_rr_list *
01037 ldns_rr_list_subtype_by_rdf(ldns_rr_list *l, ldns_rdf *r, size_t pos)
01038 {
01039         size_t i;
01040         ldns_rr_list *subtyped;
01041         ldns_rdf *list_rdf;
01042 
01043         subtyped = ldns_rr_list_new();
01044 
01045         for(i = 0; i < ldns_rr_list_rr_count(l); i++) {
01046                 list_rdf = ldns_rr_rdf(
01047                         ldns_rr_list_rr(l, i),
01048                         pos);
01049                 if (!list_rdf) {
01050                         /* pos is too large or any other error */
01051                         ldns_rr_list_deep_free(subtyped);
01052                         return NULL;
01053                 }
01054 
01055                 if (ldns_rdf_compare(list_rdf, r) == 0) {
01056                         /* a match */
01057                         ldns_rr_list_push_rr(subtyped,
01058                                         ldns_rr_clone(ldns_rr_list_rr(l, i)));
01059                 }
01060         }
01061 
01062         if (ldns_rr_list_rr_count(subtyped) > 0) {
01063                 return subtyped;
01064         } else {
01065                 ldns_rr_list_free(subtyped);
01066                 return NULL;
01067         }
01068 }
01069 
01070 bool
01071 ldns_rr_list_push_rr(ldns_rr_list *rr_list, const ldns_rr *rr)
01072 {
01073         size_t rr_count;
01074         size_t cap;
01075 
01076         rr_count = ldns_rr_list_rr_count(rr_list);
01077         cap = rr_list->_rr_capacity;
01078 
01079         /* grow the array */
01080         if(rr_count+1 > cap) {
01081                 ldns_rr **rrs;
01082 
01083                 if(cap == 0)
01084                         cap = LDNS_RRLIST_INIT;  /* initial list size */
01085                 else    cap *= 2;
01086                 rrs = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
01087                 if (!rrs) {
01088                         return false;
01089                 }
01090                 rr_list->_rrs = rrs;
01091                 rr_list->_rr_capacity = cap;
01092         }
01093 
01094         /* add the new member */
01095         rr_list->_rrs[rr_count] = (ldns_rr*)rr;
01096 
01097         ldns_rr_list_set_rr_count(rr_list, rr_count + 1);
01098         return true;
01099 }
01100 
01101 bool
01102 ldns_rr_list_push_rr_list(ldns_rr_list *rr_list, const ldns_rr_list *push_list)
01103 {
01104         size_t i;
01105 
01106         for(i = 0; i < ldns_rr_list_rr_count(push_list); i++) {
01107                 if (!ldns_rr_list_push_rr(rr_list,
01108                                 ldns_rr_list_rr(push_list, i))) {
01109                         return false;
01110                 }
01111         }
01112         return true;
01113 }
01114 
01115 ldns_rr *
01116 ldns_rr_list_pop_rr(ldns_rr_list *rr_list)
01117 {
01118         size_t rr_count;
01119         size_t cap;
01120         ldns_rr *pop;
01121 
01122         rr_count = ldns_rr_list_rr_count(rr_list);
01123 
01124         if (rr_count == 0) {
01125                 return NULL;
01126         }
01127 
01128         cap = rr_list->_rr_capacity;
01129         pop = ldns_rr_list_rr(rr_list, rr_count - 1);
01130 
01131         /* shrink the array */
01132         if(cap > LDNS_RRLIST_INIT && rr_count-1 <= cap/2) {
01133                 ldns_rr** a;
01134                 cap /= 2;
01135                 a = LDNS_XREALLOC(rr_list->_rrs, ldns_rr *, cap);
01136                 if(a) {
01137                         rr_list->_rrs = a;
01138                         rr_list->_rr_capacity = cap;
01139                 }
01140         }
01141 
01142         ldns_rr_list_set_rr_count(rr_list, rr_count - 1);
01143 
01144         return pop;
01145 }
01146 
01147 ldns_rr_list *
01148 ldns_rr_list_pop_rr_list(ldns_rr_list *rr_list, size_t howmany)
01149 {
01150         /* pop a number of rr's and put them in a rr_list */
01151         ldns_rr_list *popped;
01152         ldns_rr *p;
01153         size_t i = howmany;
01154 
01155         popped = ldns_rr_list_new();
01156 
01157         if (!popped) {
01158                 return NULL;
01159         }
01160 
01161 
01162         while(i > 0 &&
01163                         (p = ldns_rr_list_pop_rr(rr_list)) != NULL) {
01164                 ldns_rr_list_push_rr(popped, p);
01165                 i--;
01166         }
01167 
01168         if (i == howmany) { /* so i <= 0 */
01169                 ldns_rr_list_free(popped);
01170                 return NULL;
01171         } else {
01172                 return popped;
01173         }
01174 }
01175 
01176 
01177 bool
01178 ldns_rr_list_contains_rr(const ldns_rr_list *rr_list, ldns_rr *rr)
01179 {
01180         size_t i;
01181 
01182         if (!rr_list || !rr || ldns_rr_list_rr_count(rr_list) == 0) {
01183                 return false;
01184         }
01185 
01186         for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
01187                 if (rr == ldns_rr_list_rr(rr_list, i)) {
01188                         return true;
01189                 } else if (ldns_rr_compare(rr, ldns_rr_list_rr(rr_list, i)) == 0) {
01190                         return true;
01191                 }
01192         }
01193         return false;
01194 }
01195 
01196 bool
01197 ldns_is_rrset(ldns_rr_list *rr_list)
01198 {
01199         ldns_rr_type t;
01200         ldns_rr_class c;
01201         ldns_rdf *o;
01202         ldns_rr *tmp;
01203         size_t i;
01204 
01205         if (!rr_list || ldns_rr_list_rr_count(rr_list) == 0) {
01206                 return false;
01207         }
01208 
01209         tmp = ldns_rr_list_rr(rr_list, 0);
01210 
01211         t = ldns_rr_get_type(tmp);
01212         c = ldns_rr_get_class(tmp);
01213         o = ldns_rr_owner(tmp);
01214 
01215         /* compare these with the rest of the rr_list, start with 1 */
01216         for (i = 1; i < ldns_rr_list_rr_count(rr_list); i++) {
01217                 tmp = ldns_rr_list_rr(rr_list, i);
01218                 if (t != ldns_rr_get_type(tmp)) {
01219                         return false;
01220                 }
01221                 if (c != ldns_rr_get_class(tmp)) {
01222                         return false;
01223                 }
01224                 if (ldns_rdf_compare(o, ldns_rr_owner(tmp)) != 0) {
01225                         return false;
01226                 }
01227         }
01228         return true;
01229 }
01230 
01231 bool
01232 ldns_rr_set_push_rr(ldns_rr_list *rr_list, ldns_rr *rr)
01233 {
01234         size_t rr_count;
01235         size_t i;
01236         ldns_rr *last;
01237 
01238         assert(rr != NULL);
01239 
01240         rr_count = ldns_rr_list_rr_count(rr_list);
01241 
01242         if (rr_count == 0) {
01243                 /* nothing there, so checking it is
01244                  * not needed */
01245                 return ldns_rr_list_push_rr(rr_list, rr);
01246         } else {
01247                 /* check with the final rr in the rr_list */
01248                 last = ldns_rr_list_rr(rr_list, rr_count - 1);
01249 
01250                 if (ldns_rr_get_class(last) != ldns_rr_get_class(rr)) {
01251                         return false;
01252                 }
01253                 if (ldns_rr_get_type(last) != ldns_rr_get_type(rr)) {
01254                         return false;
01255                 }
01256                 /* only check if not equal to RRSIG */
01257                 if (ldns_rr_get_type(rr) != LDNS_RR_TYPE_RRSIG) {
01258                         if (ldns_rr_ttl(last) != ldns_rr_ttl(rr)) {
01259                                 return false;
01260                         }
01261                 }
01262                 if (ldns_rdf_compare(ldns_rr_owner(last),
01263                                         ldns_rr_owner(rr)) != 0) {
01264                         return false;
01265                 }
01266                 /* ok, still alive - check if the rr already
01267                  * exists - if so, dont' add it */
01268                 for(i = 0; i < rr_count; i++) {
01269                         if(ldns_rr_compare(
01270                                         ldns_rr_list_rr(rr_list, i), rr) == 0) {
01271                                 return false;
01272                         }
01273                 }
01274                 /* it's safe, push it */
01275                 return ldns_rr_list_push_rr(rr_list, rr);
01276         }
01277 }
01278 
01279 ldns_rr *
01280 ldns_rr_set_pop_rr(ldns_rr_list *rr_list)
01281 {
01282         return ldns_rr_list_pop_rr(rr_list);
01283 }
01284 
01285 ldns_rr_list *
01286 ldns_rr_list_pop_rrset(ldns_rr_list *rr_list)
01287 {
01288         ldns_rr_list *rrset;
01289         ldns_rr *last_rr = NULL;
01290         ldns_rr *next_rr;
01291 
01292         if (!rr_list) {
01293                 return NULL;
01294         }
01295 
01296         rrset = ldns_rr_list_new();
01297         if (!last_rr) {
01298                 last_rr = ldns_rr_list_pop_rr(rr_list);
01299                 if (!last_rr) {
01300                         ldns_rr_list_free(rrset);
01301                         return NULL;
01302                 } else {
01303                         ldns_rr_list_push_rr(rrset, last_rr);
01304                 }
01305         }
01306 
01307         if (ldns_rr_list_rr_count(rr_list) > 0) {
01308                 next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
01309         } else {
01310                 next_rr = NULL;
01311         }
01312 
01313         while (next_rr) {
01314                 if (
01315                         ldns_rdf_compare(ldns_rr_owner(next_rr),
01316                                          ldns_rr_owner(last_rr)) == 0
01317                         &&
01318                         ldns_rr_get_type(next_rr) == ldns_rr_get_type(last_rr)
01319                         &&
01320                         ldns_rr_get_class(next_rr) == ldns_rr_get_class(last_rr)
01321                    ) {
01322                         ldns_rr_list_push_rr(rrset, ldns_rr_list_pop_rr(rr_list));
01323                         if (ldns_rr_list_rr_count(rr_list) > 0) {
01324                                 last_rr = next_rr;
01325                                 next_rr = ldns_rr_list_rr(rr_list, ldns_rr_list_rr_count(rr_list) - 1);
01326                         } else {
01327                                 next_rr = NULL;
01328                         }
01329                 } else {
01330                         next_rr = NULL;
01331                 }
01332         }
01333 
01334         return rrset;
01335 }
01336 
01337 ldns_rr *
01338 ldns_rr_clone(const ldns_rr *rr)
01339 {
01340         size_t i;
01341         ldns_rr *new_rr;
01342 
01343         if (!rr) {
01344                 return NULL;
01345         }
01346 
01347         new_rr = ldns_rr_new();
01348         if (!new_rr) {
01349                 return NULL;
01350         }
01351         if (ldns_rr_owner(rr)) {
01352                 ldns_rr_set_owner(new_rr, ldns_rdf_clone(ldns_rr_owner(rr)));
01353         }
01354         ldns_rr_set_ttl(new_rr, ldns_rr_ttl(rr));
01355         ldns_rr_set_type(new_rr, ldns_rr_get_type(rr));
01356         ldns_rr_set_class(new_rr, ldns_rr_get_class(rr));
01357         ldns_rr_set_question(new_rr, ldns_rr_is_question(rr));
01358 
01359         for (i = 0; i < ldns_rr_rd_count(rr); i++) {
01360                 if (ldns_rr_rdf(rr,i)) {
01361                         ldns_rr_push_rdf(new_rr, ldns_rdf_clone(ldns_rr_rdf(rr, i)));
01362                 }
01363         }
01364 
01365         return new_rr;
01366 }
01367 
01368 ldns_rr_list *
01369 ldns_rr_list_clone(const ldns_rr_list *rrlist)
01370 {
01371         size_t i;
01372         ldns_rr_list *new_list;
01373         ldns_rr *r;
01374 
01375         if (!rrlist) {
01376                 return NULL;
01377         }
01378 
01379         new_list = ldns_rr_list_new();
01380         if (!new_list) {
01381                 return NULL;
01382         }
01383         for (i = 0; i < ldns_rr_list_rr_count(rrlist); i++) {
01384                 r = ldns_rr_clone(
01385                         ldns_rr_list_rr(rrlist, i)
01386                     );
01387                 if (!r) {
01388                         /* huh, failure in cloning */
01389                         ldns_rr_list_deep_free(new_list);
01390                         return NULL;
01391                 }
01392                 ldns_rr_list_push_rr(new_list, r);
01393         }
01394         return new_list;
01395 }
01396 
01397 
01398 int
01399 qsort_rr_compare(const void *a, const void *b)
01400 {
01401         const ldns_rr *rr1 = * (const ldns_rr **) a;
01402         const ldns_rr *rr2 = * (const ldns_rr **) b;
01403 
01404         if (rr1 == NULL && rr2 == NULL) {
01405                 return 0;
01406         }
01407         if (rr1 == NULL) {
01408                 return -1;
01409         }
01410         if (rr2 == NULL) {
01411                 return 1;
01412         }
01413         return ldns_rr_compare(rr1, rr2);
01414 }
01415 
01416 int
01417 qsort_schwartz_rr_compare(const void *a, const void *b)
01418 {
01419         int result = 0;
01420         ldns_rr *rr1, *rr2;
01421         ldns_buffer *rr1_buf, *rr2_buf;
01422         struct ldns_schwartzian_compare_struct *sa = *(struct ldns_schwartzian_compare_struct **) a;
01423         struct ldns_schwartzian_compare_struct *sb = *(struct ldns_schwartzian_compare_struct **) b;
01424         /* if we are doing 2wire, we need to do lowercasing on the dname (and maybe on the rdata)
01425          * this must be done for comparison only, so we need to have a temp var for both buffers,
01426          * which is only used when the transformed object value isn't there yet
01427          */
01428         ldns_rr *canonical_a, *canonical_b;
01429 
01430         rr1 = (ldns_rr *) sa->original_object;
01431         rr2 = (ldns_rr *) sb->original_object;
01432 
01433         result = ldns_rr_compare_no_rdata(rr1, rr2);
01434 
01435         if (result == 0) {
01436                 if (!sa->transformed_object) {
01437                         canonical_a = ldns_rr_clone(sa->original_object);
01438                         ldns_rr2canonical(canonical_a);
01439                         sa->transformed_object = ldns_buffer_new(ldns_rr_uncompressed_size(canonical_a));
01440                         if (ldns_rr2buffer_wire(sa->transformed_object, canonical_a, LDNS_SECTION_ANY) != LDNS_STATUS_OK) {
01441                                 ldns_buffer_free((ldns_buffer *)sa->transformed_object);
01442                                 sa->transformed_object = NULL;
01443                                 ldns_rr_free(canonical_a);
01444                                 return 0;
01445                         }
01446                         ldns_rr_free(canonical_a);
01447                 }
01448                 if (!sb->transformed_object) {
01449                         canonical_b = ldns_rr_clone(sb->original_object);
01450                         ldns_rr2canonical(canonical_b);
01451                         sb->transformed_object = ldns_buffer_new(ldns_rr_uncompressed_size(canonical_b));
01452                         if (ldns_rr2buffer_wire(sb->transformed_object, canonical_b, LDNS_SECTION_ANY) != LDNS_STATUS_OK) {
01453                                 ldns_buffer_free((ldns_buffer *)sa->transformed_object);
01454                                 ldns_buffer_free((ldns_buffer *)sb->transformed_object);
01455                                 sa->transformed_object = NULL;
01456                                 sb->transformed_object = NULL;
01457                                 ldns_rr_free(canonical_b);
01458                                 return 0;
01459                         }
01460                         ldns_rr_free(canonical_b);
01461                 }
01462                 rr1_buf = (ldns_buffer *) sa->transformed_object;
01463                 rr2_buf = (ldns_buffer *) sb->transformed_object;
01464 
01465                 result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
01466         }
01467 
01468         return result;
01469 }
01470 
01471 void
01472 ldns_rr_list_sort(ldns_rr_list *unsorted)
01473 {
01474         struct ldns_schwartzian_compare_struct **sortables;
01475         size_t item_count;
01476         size_t i;
01477 
01478         if (unsorted) {
01479                 item_count = ldns_rr_list_rr_count(unsorted);
01480 
01481                 sortables = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct *,
01482                                          item_count);
01483                 if(!sortables) return; /* no way to return error */
01484                 for (i = 0; i < item_count; i++) {
01485                         sortables[i] = LDNS_XMALLOC(struct ldns_schwartzian_compare_struct, 1);
01486                         if(!sortables[i]) {
01487                                 /* free the allocated parts */
01488                                 while(i>0) {
01489                                         i--;
01490                                         LDNS_FREE(sortables[i]);
01491                                 }
01492                                 /* no way to return error */
01493                                 LDNS_FREE(sortables);
01494                                 return;
01495                         }
01496                         sortables[i]->original_object = ldns_rr_list_rr(unsorted, i);
01497                         sortables[i]->transformed_object = NULL;
01498                 }
01499                 qsort(sortables,
01500                       item_count,
01501                       sizeof(struct ldns_schwartzian_compare_struct *),
01502                       qsort_schwartz_rr_compare);
01503                 for (i = 0; i < item_count; i++) {
01504                         unsorted->_rrs[i] = sortables[i]->original_object;
01505                         if (sortables[i]->transformed_object) {
01506                                 ldns_buffer_free(sortables[i]->transformed_object);
01507                         }
01508                         LDNS_FREE(sortables[i]);
01509                 }
01510                 LDNS_FREE(sortables);
01511         }
01512 }
01513 
01514 int
01515 ldns_rr_compare_no_rdata(const ldns_rr *rr1, const ldns_rr *rr2)
01516 {
01517         size_t rr1_len;
01518         size_t rr2_len;
01519         size_t offset;
01520 
01521         assert(rr1 != NULL);
01522         assert(rr2 != NULL);
01523 
01524         rr1_len = ldns_rr_uncompressed_size(rr1);
01525         rr2_len = ldns_rr_uncompressed_size(rr2);
01526 
01527         if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) < 0) {
01528                 return -1;
01529         } else if (ldns_dname_compare(ldns_rr_owner(rr1), ldns_rr_owner(rr2)) > 0) {
01530                 return 1;
01531         }
01532 
01533         /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
01534         if (ldns_rr_get_class(rr1) != ldns_rr_get_class(rr2)) {
01535             return ldns_rr_get_class(rr1) - ldns_rr_get_class(rr2);
01536         }
01537 
01538         /* should return -1 if rr1 comes before rr2, so need to do rr1 - rr2, not rr2 - rr1 */
01539         if (ldns_rr_get_type(rr1) != ldns_rr_get_type(rr2)) {
01540             return ldns_rr_get_type(rr1) - ldns_rr_get_type(rr2);
01541         }
01542 
01543         /* offset is the owername length + ttl + type + class + rdlen == start of wire format rdata */
01544         offset = ldns_rdf_size(ldns_rr_owner(rr1)) + 4 + 2 + 2 + 2;
01545         /* if either record doesn't have any RDATA... */
01546         if (offset > rr1_len || offset > rr2_len) {
01547             if (rr1_len == rr2_len) {
01548               return 0;
01549             }
01550             return ((int) rr2_len - (int) rr1_len);
01551         }
01552 
01553         return 0;
01554 }
01555 
01556 int ldns_rr_compare_wire(ldns_buffer *rr1_buf, ldns_buffer *rr2_buf)
01557 {
01558         size_t rr1_len, rr2_len, min_len, i, offset;
01559 
01560         rr1_len = ldns_buffer_capacity(rr1_buf);
01561         rr2_len = ldns_buffer_capacity(rr2_buf);
01562 
01563         /* jump past dname (checked in earlier part)
01564          * and especially past TTL */
01565         offset = 0;
01566         while (offset < rr1_len && *ldns_buffer_at(rr1_buf, offset) != 0) {
01567           offset += *ldns_buffer_at(rr1_buf, offset) + 1;
01568         }
01569         /* jump to rdata section (PAST the rdata length field, otherwise
01570            rrs with different lengths might be sorted erroneously */
01571         offset += 11;
01572            min_len = (rr1_len < rr2_len) ? rr1_len : rr2_len;
01573         /* Compare RRs RDATA byte for byte. */
01574         for(i = offset; i < min_len; i++) {
01575                 if (*ldns_buffer_at(rr1_buf,i) < *ldns_buffer_at(rr2_buf,i)) {
01576                         return -1;
01577                 } else if (*ldns_buffer_at(rr1_buf,i) > *ldns_buffer_at(rr2_buf,i)) {
01578                         return +1;
01579                 }
01580         }
01581 
01582         /* If both RDATAs are the same up to min_len, then the shorter one sorts first. */
01583         if (rr1_len < rr2_len) {
01584                 return -1;
01585         } else if (rr1_len > rr2_len) {
01586                 return +1;
01587         }
01588         /* The RDATAs are equal. */
01589         return 0;
01590 
01591 }
01592 
01593 int
01594 ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
01595 {
01596         int result;
01597         size_t rr1_len, rr2_len;
01598 
01599         ldns_buffer *rr1_buf;
01600         ldns_buffer *rr2_buf;
01601 
01602         result = ldns_rr_compare_no_rdata(rr1, rr2);
01603         if (result == 0) {
01604                 rr1_len = ldns_rr_uncompressed_size(rr1);
01605                 rr2_len = ldns_rr_uncompressed_size(rr2);
01606 
01607                 rr1_buf = ldns_buffer_new(rr1_len);
01608                 rr2_buf = ldns_buffer_new(rr2_len);
01609 
01610                 if (ldns_rr2buffer_wire_canonical(rr1_buf,
01611                                                                     rr1,
01612                                                                     LDNS_SECTION_ANY)
01613                     != LDNS_STATUS_OK) {
01614                         ldns_buffer_free(rr1_buf);
01615                         ldns_buffer_free(rr2_buf);
01616                         return 0;
01617                 }
01618                 if (ldns_rr2buffer_wire_canonical(rr2_buf,
01619                                                                     rr2,
01620                                                                     LDNS_SECTION_ANY)
01621                     != LDNS_STATUS_OK) {
01622                         ldns_buffer_free(rr1_buf);
01623                         ldns_buffer_free(rr2_buf);
01624                         return 0;
01625                 }
01626 
01627                 result = ldns_rr_compare_wire(rr1_buf, rr2_buf);
01628 
01629                 ldns_buffer_free(rr1_buf);
01630                 ldns_buffer_free(rr2_buf);
01631         }
01632 
01633         return result;
01634 }
01635 
01636 /* convert dnskey to a ds with the given algorithm,
01637  * then compare the result with the given ds */
01638 static int
01639 ldns_rr_compare_ds_dnskey(ldns_rr *ds,
01640                           ldns_rr *dnskey)
01641 {
01642         ldns_rr *ds_gen;
01643         bool result = false;
01644         ldns_hash algo;
01645 
01646         if (!dnskey || !ds ||
01647             ldns_rr_get_type(ds) != LDNS_RR_TYPE_DS ||
01648             ldns_rr_get_type(dnskey) != LDNS_RR_TYPE_DNSKEY) {
01649                 return false;
01650         }
01651 
01652         if (ldns_rr_rdf(ds, 2) == NULL) {
01653                 return false;
01654         }
01655         algo = ldns_rdf2native_int8(ldns_rr_rdf(ds, 2));
01656 
01657         ds_gen = ldns_key_rr2ds(dnskey, algo);
01658         if (ds_gen) {
01659                 result = ldns_rr_compare(ds, ds_gen) == 0;
01660                 ldns_rr_free(ds_gen);
01661         }
01662         return result;
01663 }
01664 
01665 bool
01666 ldns_rr_compare_ds(const ldns_rr *orr1, const ldns_rr *orr2)
01667 {
01668         bool result;
01669         ldns_rr *rr1 = ldns_rr_clone(orr1);
01670         ldns_rr *rr2 = ldns_rr_clone(orr2);
01671 
01672         /* set ttls to zero */
01673         ldns_rr_set_ttl(rr1, 0);
01674         ldns_rr_set_ttl(rr2, 0);
01675 
01676         if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DS &&
01677             ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DNSKEY) {
01678                 result = ldns_rr_compare_ds_dnskey(rr1, rr2);
01679         } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DNSKEY &&
01680             ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DS) {
01681                 result = ldns_rr_compare_ds_dnskey(rr2, rr1);
01682         } else {
01683                 result = (ldns_rr_compare(rr1, rr2) == 0);
01684         }
01685 
01686         ldns_rr_free(rr1);
01687         ldns_rr_free(rr2);
01688 
01689         return result;
01690 }
01691 
01692 int
01693 ldns_rr_list_compare(const ldns_rr_list *rrl1, const ldns_rr_list *rrl2)
01694 {
01695         size_t i = 0;
01696         int rr_cmp;
01697 
01698         assert(rrl1 != NULL);
01699         assert(rrl2 != NULL);
01700 
01701         for (i = 0; i < ldns_rr_list_rr_count(rrl1) && i < ldns_rr_list_rr_count(rrl2); i++) {
01702                 rr_cmp = ldns_rr_compare(ldns_rr_list_rr(rrl1, i), ldns_rr_list_rr(rrl2, i));
01703                 if (rr_cmp != 0) {
01704                         return rr_cmp;
01705                 }
01706         }
01707 
01708         if (i == ldns_rr_list_rr_count(rrl1) &&
01709             i != ldns_rr_list_rr_count(rrl2)) {
01710                 return 1;
01711         } else if (i == ldns_rr_list_rr_count(rrl2) &&
01712                    i != ldns_rr_list_rr_count(rrl1)) {
01713                 return -1;
01714         } else {
01715                 return 0;
01716         }
01717 }
01718 
01719 size_t
01720 ldns_rr_uncompressed_size(const ldns_rr *r)
01721 {
01722         size_t rrsize;
01723         size_t i;
01724 
01725         rrsize = 0;
01726         /* add all the rdf sizes */
01727         for(i = 0; i < ldns_rr_rd_count(r); i++) {
01728                 rrsize += ldns_rdf_size(ldns_rr_rdf(r, i));
01729         }
01730         /* ownername */
01731         rrsize += ldns_rdf_size(ldns_rr_owner(r));
01732         rrsize += LDNS_RR_OVERHEAD;
01733         return rrsize;
01734 }
01735 
01736 void
01737 ldns_rr2canonical(ldns_rr *rr)
01738 {
01739         uint16_t i;
01740 
01741         if (!rr) {
01742           return;
01743         }
01744 
01745         ldns_dname2canonical(ldns_rr_owner(rr));
01746 
01747         /*
01748          * lowercase the rdata dnames if the rr type is one
01749          * of the list in chapter 7 of RFC3597
01750          * Also added RRSIG, because a "Signer's Name" should be canonicalized
01751          * too. See dnssec-bis-updates-16. We can add it to this list because
01752          * the "Signer's Name"  is the only dname type rdata field in a RRSIG.
01753          */
01754         switch(ldns_rr_get_type(rr)) {
01755                 case LDNS_RR_TYPE_NS:
01756                 case LDNS_RR_TYPE_MD:
01757                 case LDNS_RR_TYPE_MF:
01758                 case LDNS_RR_TYPE_CNAME:
01759                 case LDNS_RR_TYPE_SOA:
01760                 case LDNS_RR_TYPE_MB:
01761                 case LDNS_RR_TYPE_MG:
01762                 case LDNS_RR_TYPE_MR:
01763                 case LDNS_RR_TYPE_PTR:
01764                 case LDNS_RR_TYPE_MINFO:
01765                 case LDNS_RR_TYPE_MX:
01766                 case LDNS_RR_TYPE_RP:
01767                 case LDNS_RR_TYPE_AFSDB:
01768                 case LDNS_RR_TYPE_RT:
01769                 case LDNS_RR_TYPE_SIG:
01770                 case LDNS_RR_TYPE_PX:
01771                 case LDNS_RR_TYPE_NXT:
01772                 case LDNS_RR_TYPE_NAPTR:
01773                 case LDNS_RR_TYPE_KX:
01774                 case LDNS_RR_TYPE_SRV:
01775                 case LDNS_RR_TYPE_DNAME:
01776                 case LDNS_RR_TYPE_A6:
01777                 case LDNS_RR_TYPE_RRSIG:
01778                         for (i = 0; i < ldns_rr_rd_count(rr); i++) {
01779                                 ldns_dname2canonical(ldns_rr_rdf(rr, i));
01780                         }
01781                         return;
01782                 default:
01783                         /* do nothing */
01784                         return;
01785         }
01786 }
01787 
01788 void
01789 ldns_rr_list2canonical(ldns_rr_list *rr_list)
01790 {
01791         size_t i;
01792         for (i = 0; i < ldns_rr_list_rr_count(rr_list); i++) {
01793                 ldns_rr2canonical(ldns_rr_list_rr(rr_list, i));
01794         }
01795 }
01796 
01797 uint8_t
01798 ldns_rr_label_count(ldns_rr *rr)
01799 {
01800         if (!rr) {
01801                 return 0;
01802         }
01803         return ldns_dname_label_count(
01804                         ldns_rr_owner(rr));
01805 }
01806 
01808 static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
01809 static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };
01810 static const ldns_rdf_type type_ns_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01811 static const ldns_rdf_type type_md_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01812 static const ldns_rdf_type type_mf_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01813 static const ldns_rdf_type type_cname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01814 static const ldns_rdf_type type_soa_wireformat[] = {
01815         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_INT32, 
01816         LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD, LDNS_RDF_TYPE_PERIOD,
01817         LDNS_RDF_TYPE_PERIOD
01818 };
01819 static const ldns_rdf_type type_mb_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01820 static const ldns_rdf_type type_mg_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01821 static const ldns_rdf_type type_mr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01822 static const ldns_rdf_type type_wks_wireformat[] = {
01823         LDNS_RDF_TYPE_A, LDNS_RDF_TYPE_WKS
01824 };
01825 static const ldns_rdf_type type_ptr_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01826 static const ldns_rdf_type type_hinfo_wireformat[] = {
01827         LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
01828 };
01829 static const ldns_rdf_type type_minfo_wireformat[] = {
01830         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
01831 };
01832 static const ldns_rdf_type type_mx_wireformat[] = {
01833         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
01834 };
01835 static const ldns_rdf_type type_rp_wireformat[] = {
01836         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
01837 };
01838 static const ldns_rdf_type type_afsdb_wireformat[] = {
01839         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
01840 };
01841 static const ldns_rdf_type type_x25_wireformat[] = { LDNS_RDF_TYPE_STR };
01842 static const ldns_rdf_type type_isdn_wireformat[] = {
01843         LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR
01844 };
01845 static const ldns_rdf_type type_rt_wireformat[] = {
01846         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
01847 };
01848 static const ldns_rdf_type type_nsap_wireformat[] = {
01849         LDNS_RDF_TYPE_NSAP
01850 };
01851 static const ldns_rdf_type type_nsap_ptr_wireformat[] = {
01852         LDNS_RDF_TYPE_STR
01853 };
01854 static const ldns_rdf_type type_sig_wireformat[] = {
01855         LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32,
01856         LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16,
01857         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64
01858 };
01859 static const ldns_rdf_type type_key_wireformat[] = {
01860         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64
01861 };
01862 static const ldns_rdf_type type_px_wireformat[] = {
01863         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
01864 };
01865 static const ldns_rdf_type type_gpos_wireformat[] = {
01866         LDNS_RDF_TYPE_STR,
01867         LDNS_RDF_TYPE_STR,
01868         LDNS_RDF_TYPE_STR
01869 };
01870 static const ldns_rdf_type type_aaaa_wireformat[] = { LDNS_RDF_TYPE_AAAA };
01871 static const ldns_rdf_type type_loc_wireformat[] = { LDNS_RDF_TYPE_LOC };
01872 static const ldns_rdf_type type_nxt_wireformat[] = {
01873         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_UNKNOWN
01874 };
01875 static const ldns_rdf_type type_eid_wireformat[] = {
01876         LDNS_RDF_TYPE_HEX
01877 };
01878 static const ldns_rdf_type type_nimloc_wireformat[] = {
01879         LDNS_RDF_TYPE_HEX
01880 };
01881 static const ldns_rdf_type type_srv_wireformat[] = {
01882         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
01883 };
01884 static const ldns_rdf_type type_atma_wireformat[] = {
01885         LDNS_RDF_TYPE_ATMA
01886 };
01887 static const ldns_rdf_type type_naptr_wireformat[] = {
01888         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_STR, LDNS_RDF_TYPE_DNAME
01889 };
01890 static const ldns_rdf_type type_kx_wireformat[] = {
01891         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME
01892 };
01893 static const ldns_rdf_type type_cert_wireformat[] = {
01894          LDNS_RDF_TYPE_CERT_ALG, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_B64
01895 };
01896 static const ldns_rdf_type type_a6_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
01897 static const ldns_rdf_type type_dname_wireformat[] = { LDNS_RDF_TYPE_DNAME };
01898 static const ldns_rdf_type type_sink_wireformat[] = { LDNS_RDF_TYPE_INT8,
01899         LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_B64
01900 };
01901 static const ldns_rdf_type type_apl_wireformat[] = {
01902         LDNS_RDF_TYPE_APL
01903 };
01904 static const ldns_rdf_type type_ds_wireformat[] = {
01905         LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
01906 };
01907 static const ldns_rdf_type type_sshfp_wireformat[] = {
01908         LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_HEX
01909 };
01910 static const ldns_rdf_type type_ipseckey_wireformat[] = {
01911         LDNS_RDF_TYPE_IPSECKEY
01912 };
01913 static const ldns_rdf_type type_rrsig_wireformat[] = {
01914         LDNS_RDF_TYPE_TYPE, LDNS_RDF_TYPE_ALG, LDNS_RDF_TYPE_INT8, LDNS_RDF_TYPE_INT32,
01915         LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_TIME, LDNS_RDF_TYPE_INT16, LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_B64
01916 };
01917 static const ldns_rdf_type type_nsec_wireformat[] = {
01918         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_NSEC
01919 };
01920 static const ldns_rdf_type type_dhcid_wireformat[] = {
01921         LDNS_RDF_TYPE_B64
01922 };
01923 static const ldns_rdf_type type_talink_wireformat[] = {
01924         LDNS_RDF_TYPE_DNAME, LDNS_RDF_TYPE_DNAME
01925 };
01926 /* nsec3 is some vars, followed by same type of data of nsec */
01927 static const ldns_rdf_type type_nsec3_wireformat[] = {
01928 /*      LDNS_RDF_TYPE_NSEC3_VARS, LDNS_RDF_TYPE_NSEC3_NEXT_OWNER, LDNS_RDF_TYPE_NSEC*/
01929         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
01930 };
01931 
01932 static const ldns_rdf_type type_nsec3param_wireformat[] = {
01933 /*      LDNS_RDF_TYPE_NSEC3_PARAMS_VARS*/
01934         LDNS_RDF_TYPE_INT8,
01935         LDNS_RDF_TYPE_INT8,
01936         LDNS_RDF_TYPE_INT16,
01937         LDNS_RDF_TYPE_NSEC3_SALT
01938 };
01939 
01940 static const ldns_rdf_type type_dnskey_wireformat[] = {
01941         LDNS_RDF_TYPE_INT16,
01942         LDNS_RDF_TYPE_INT8,
01943         LDNS_RDF_TYPE_ALG,
01944         LDNS_RDF_TYPE_B64
01945 };
01946 static const ldns_rdf_type type_tsig_wireformat[] = {
01947         LDNS_RDF_TYPE_DNAME,
01948         LDNS_RDF_TYPE_TSIGTIME,
01949         LDNS_RDF_TYPE_INT16,
01950         LDNS_RDF_TYPE_INT16_DATA,
01951         LDNS_RDF_TYPE_INT16,
01952         LDNS_RDF_TYPE_INT16,
01953         LDNS_RDF_TYPE_INT16_DATA
01954 };
01955 static const ldns_rdf_type type_tlsa_wireformat[] = {
01956         LDNS_RDF_TYPE_INT8,
01957         LDNS_RDF_TYPE_INT8,
01958         LDNS_RDF_TYPE_INT8,
01959         LDNS_RDF_TYPE_HEX
01960 };
01964 /* All RR's defined in 1035 are well known and can thus
01965  * be compressed. See RFC3597. These RR's are:
01966  * CNAME HINFO MB MD MF MG MINFO MR MX NULL NS PTR SOA TXT
01967  */
01968 static ldns_rr_descriptor rdata_field_descriptors[] = {
01969         /* 0 */
01970         { 0, NULL, 0, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
01971         /* 1 */
01972         {LDNS_RR_TYPE_A, "A", 1, 1, type_a_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
01973         /* 2 */
01974         {LDNS_RR_TYPE_NS, "NS", 1, 1, type_ns_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
01975         /* 3 */
01976         {LDNS_RR_TYPE_MD, "MD", 1, 1, type_md_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
01977         /* 4 */
01978         {LDNS_RR_TYPE_MF, "MF", 1, 1, type_mf_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
01979         /* 5 */
01980         {LDNS_RR_TYPE_CNAME, "CNAME", 1, 1, type_cname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
01981         /* 6 */
01982         {LDNS_RR_TYPE_SOA, "SOA", 7, 7, type_soa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
01983         /* 7 */
01984         {LDNS_RR_TYPE_MB, "MB", 1, 1, type_mb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
01985         /* 8 */
01986         {LDNS_RR_TYPE_MG, "MG", 1, 1, type_mg_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
01987         /* 9 */
01988         {LDNS_RR_TYPE_MR, "MR", 1, 1, type_mr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
01989         /* 10 */
01990         {LDNS_RR_TYPE_NULL, "NULL", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
01991         /* 11 */
01992         {LDNS_RR_TYPE_WKS, "WKS", 2, 2, type_wks_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
01993         /* 12 */
01994         {LDNS_RR_TYPE_PTR, "PTR", 1, 1, type_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
01995         /* 13 */
01996         {LDNS_RR_TYPE_HINFO, "HINFO", 2, 2, type_hinfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
01997         /* 14 */
01998         {LDNS_RR_TYPE_MINFO, "MINFO", 2, 2, type_minfo_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 2 },
01999         /* 15 */
02000         {LDNS_RR_TYPE_MX, "MX", 2, 2, type_mx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_COMPRESS, 1 },
02001         /* 16 */
02002         {LDNS_RR_TYPE_TXT, "TXT", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
02003         /* 17 */
02004         {LDNS_RR_TYPE_RP, "RP", 2, 2, type_rp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
02005         /* 18 */
02006         {LDNS_RR_TYPE_AFSDB, "AFSDB", 2, 2, type_afsdb_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02007         /* 19 */
02008         {LDNS_RR_TYPE_X25, "X25", 1, 1, type_x25_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02009         /* 20 */
02010         {LDNS_RR_TYPE_ISDN, "ISDN", 1, 2, type_isdn_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02011         /* 21 */
02012         {LDNS_RR_TYPE_RT, "RT", 2, 2, type_rt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02013         /* 22 */
02014         {LDNS_RR_TYPE_NSAP, "NSAP", 1, 1, type_nsap_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02015         /* 23 */
02016         {LDNS_RR_TYPE_NSAP_PTR, "NSAP-PTR", 1, 1, type_nsap_ptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02017         /* 24 */
02018         {LDNS_RR_TYPE_SIG, "SIG", 9, 9, type_sig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02019         /* 25 */
02020         {LDNS_RR_TYPE_KEY, "KEY", 4, 4, type_key_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02021         /* 26 */
02022         {LDNS_RR_TYPE_PX, "PX", 3, 3, type_px_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
02023         /* 27 */
02024         {LDNS_RR_TYPE_GPOS, "GPOS", 1, 1, type_gpos_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02025         /* 28 */
02026         {LDNS_RR_TYPE_AAAA, "AAAA", 1, 1, type_aaaa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02027         /* 29 */
02028         {LDNS_RR_TYPE_LOC, "LOC", 1, 1, type_loc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02029         /* 30 */
02030         {LDNS_RR_TYPE_NXT, "NXT", 2, 2, type_nxt_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02031         /* 31 */
02032         {LDNS_RR_TYPE_EID, "EID", 1, 1, type_eid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02033         /* 32 */
02034         {LDNS_RR_TYPE_NIMLOC, "NIMLOC", 1, 1, type_nimloc_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02035         /* 33 */
02036         {LDNS_RR_TYPE_SRV, "SRV", 4, 4, type_srv_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02037         /* 34 */
02038         {LDNS_RR_TYPE_ATMA, "ATMA", 1, 1, type_atma_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02039         /* 35 */
02040         {LDNS_RR_TYPE_NAPTR, "NAPTR", 6, 6, type_naptr_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02041         /* 36 */
02042         {LDNS_RR_TYPE_KX, "KX", 2, 2, type_kx_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02043         /* 37 */
02044         {LDNS_RR_TYPE_CERT, "CERT", 4, 4, type_cert_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02045         /* 38 */
02046         {LDNS_RR_TYPE_A6, "A6", 1, 1, type_a6_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02047         /* 39 */
02048         {LDNS_RR_TYPE_DNAME, "DNAME", 1, 1, type_dname_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02049         /* 40 */
02050         {LDNS_RR_TYPE_SINK, "SINK", 1, 1, type_sink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02051         /* 41 */
02052         {LDNS_RR_TYPE_OPT, "OPT", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02053         /* 42 */
02054         {LDNS_RR_TYPE_APL, "APL", 0, 0, type_apl_wireformat, LDNS_RDF_TYPE_APL, LDNS_RR_NO_COMPRESS, 0 },
02055         /* 43 */
02056         {LDNS_RR_TYPE_DS, "DS", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02057         /* 44 */
02058         {LDNS_RR_TYPE_SSHFP, "SSHFP", 3, 3, type_sshfp_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02059         /* 45 */
02060         {LDNS_RR_TYPE_IPSECKEY, "IPSECKEY", 1, 1, type_ipseckey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02061         /* 46 */
02062         {LDNS_RR_TYPE_RRSIG, "RRSIG", 9, 9, type_rrsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 1 },
02063         /* 47 */
02064         {LDNS_RR_TYPE_NSEC, "NSEC", 1, 2, type_nsec_wireformat, LDNS_RDF_TYPE_NSEC, LDNS_RR_NO_COMPRESS, 1 },
02065         /* 48 */
02066         {LDNS_RR_TYPE_DNSKEY, "DNSKEY", 4, 4, type_dnskey_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02067         /* 49 */
02068         {LDNS_RR_TYPE_DHCID, "DHCID", 1, 1, type_dhcid_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02069         /* 50 */
02070         {LDNS_RR_TYPE_NSEC3, "NSEC3", 5, 6, type_nsec3_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02071         /* 51 */
02072         {LDNS_RR_TYPE_NSEC3PARAM, "NSEC3PARAM", 4, 4, type_nsec3param_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02073         /* 52 */
02074         {LDNS_RR_TYPE_TLSA, "TLSA", 4, 4, type_tlsa_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02075 
02076 {LDNS_RR_TYPE_NULL, "TYPE53", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02077 {LDNS_RR_TYPE_NULL, "TYPE54", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02078 {LDNS_RR_TYPE_NULL, "TYPE55", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02079 {LDNS_RR_TYPE_NULL, "TYPE56", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02080 {LDNS_RR_TYPE_NULL, "TYPE57", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02081         /* 58 */
02082 {LDNS_RR_TYPE_TALINK, "TALINK", 2, 2, type_talink_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 2 },
02083 {LDNS_RR_TYPE_NULL, "TYPE59", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02084 {LDNS_RR_TYPE_NULL, "TYPE60", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02085 {LDNS_RR_TYPE_NULL, "TYPE61", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02086 {LDNS_RR_TYPE_NULL, "TYPE62", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02087 {LDNS_RR_TYPE_NULL, "TYPE63", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02088 {LDNS_RR_TYPE_NULL, "TYPE64", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02089 {LDNS_RR_TYPE_NULL, "TYPE65", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02090 {LDNS_RR_TYPE_NULL, "TYPE66", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02091 {LDNS_RR_TYPE_NULL, "TYPE67", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02092 {LDNS_RR_TYPE_NULL, "TYPE68", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02093 {LDNS_RR_TYPE_NULL, "TYPE69", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02094 {LDNS_RR_TYPE_NULL, "TYPE70", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02095 {LDNS_RR_TYPE_NULL, "TYPE71", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02096 {LDNS_RR_TYPE_NULL, "TYPE72", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02097 {LDNS_RR_TYPE_NULL, "TYPE73", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02098 {LDNS_RR_TYPE_NULL, "TYPE74", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02099 {LDNS_RR_TYPE_NULL, "TYPE75", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02100 {LDNS_RR_TYPE_NULL, "TYPE76", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02101 {LDNS_RR_TYPE_NULL, "TYPE77", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02102 {LDNS_RR_TYPE_NULL, "TYPE78", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02103 {LDNS_RR_TYPE_NULL, "TYPE79", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02104 {LDNS_RR_TYPE_NULL, "TYPE80", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02105 {LDNS_RR_TYPE_NULL, "TYPE81", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02106 {LDNS_RR_TYPE_NULL, "TYPE82", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02107 {LDNS_RR_TYPE_NULL, "TYPE83", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02108 {LDNS_RR_TYPE_NULL, "TYPE84", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02109 {LDNS_RR_TYPE_NULL, "TYPE85", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02110 {LDNS_RR_TYPE_NULL, "TYPE86", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02111 {LDNS_RR_TYPE_NULL, "TYPE87", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02112 {LDNS_RR_TYPE_NULL, "TYPE88", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02113 {LDNS_RR_TYPE_NULL, "TYPE89", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02114 {LDNS_RR_TYPE_NULL, "TYPE90", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02115 {LDNS_RR_TYPE_NULL, "TYPE91", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02116 {LDNS_RR_TYPE_NULL, "TYPE92", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02117 {LDNS_RR_TYPE_NULL, "TYPE93", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02118 {LDNS_RR_TYPE_NULL, "TYPE94", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02119 {LDNS_RR_TYPE_NULL, "TYPE95", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02120 {LDNS_RR_TYPE_NULL, "TYPE96", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02121 {LDNS_RR_TYPE_NULL, "TYPE97", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02122 {LDNS_RR_TYPE_NULL, "TYPE98", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02123 {LDNS_RR_TYPE_SPF,  "SPF", 1, 0, NULL, LDNS_RDF_TYPE_STR, LDNS_RR_NO_COMPRESS, 0 },
02124 {LDNS_RR_TYPE_NULL, "TYPE100", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02125 {LDNS_RR_TYPE_NULL, "TYPE101", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02126 {LDNS_RR_TYPE_NULL, "TYPE102", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02127 {LDNS_RR_TYPE_NULL, "TYPE103", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02128 {LDNS_RR_TYPE_NULL, "TYPE104", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02129 {LDNS_RR_TYPE_NULL, "TYPE105", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02130 {LDNS_RR_TYPE_NULL, "TYPE106", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02131 {LDNS_RR_TYPE_NULL, "TYPE107", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02132 {LDNS_RR_TYPE_NULL, "TYPE108", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02133 {LDNS_RR_TYPE_NULL, "TYPE109", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02134 {LDNS_RR_TYPE_NULL, "TYPE110", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02135 {LDNS_RR_TYPE_NULL, "TYPE111", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02136 {LDNS_RR_TYPE_NULL, "TYPE112", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02137 {LDNS_RR_TYPE_NULL, "TYPE113", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02138 {LDNS_RR_TYPE_NULL, "TYPE114", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02139 {LDNS_RR_TYPE_NULL, "TYPE115", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02140 {LDNS_RR_TYPE_NULL, "TYPE116", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02141 {LDNS_RR_TYPE_NULL, "TYPE117", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02142 {LDNS_RR_TYPE_NULL, "TYPE118", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02143 {LDNS_RR_TYPE_NULL, "TYPE119", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02144 {LDNS_RR_TYPE_NULL, "TYPE120", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02145 {LDNS_RR_TYPE_NULL, "TYPE121", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02146 {LDNS_RR_TYPE_NULL, "TYPE122", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02147 {LDNS_RR_TYPE_NULL, "TYPE123", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02148 {LDNS_RR_TYPE_NULL, "TYPE124", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02149 {LDNS_RR_TYPE_NULL, "TYPE125", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02150 {LDNS_RR_TYPE_NULL, "TYPE126", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02151 {LDNS_RR_TYPE_NULL, "TYPE127", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02152 {LDNS_RR_TYPE_NULL, "TYPE128", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02153 {LDNS_RR_TYPE_NULL, "TYPE129", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02154 {LDNS_RR_TYPE_NULL, "TYPE130", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02155 {LDNS_RR_TYPE_NULL, "TYPE131", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02156 {LDNS_RR_TYPE_NULL, "TYPE132", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02157 {LDNS_RR_TYPE_NULL, "TYPE133", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02158 {LDNS_RR_TYPE_NULL, "TYPE134", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02159 {LDNS_RR_TYPE_NULL, "TYPE135", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02160 {LDNS_RR_TYPE_NULL, "TYPE136", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02161 {LDNS_RR_TYPE_NULL, "TYPE137", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02162 {LDNS_RR_TYPE_NULL, "TYPE138", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02163 {LDNS_RR_TYPE_NULL, "TYPE139", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02164 {LDNS_RR_TYPE_NULL, "TYPE140", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02165 {LDNS_RR_TYPE_NULL, "TYPE141", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02166 {LDNS_RR_TYPE_NULL, "TYPE142", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02167 {LDNS_RR_TYPE_NULL, "TYPE143", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02168 {LDNS_RR_TYPE_NULL, "TYPE144", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02169 {LDNS_RR_TYPE_NULL, "TYPE145", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02170 {LDNS_RR_TYPE_NULL, "TYPE146", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02171 {LDNS_RR_TYPE_NULL, "TYPE147", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02172 {LDNS_RR_TYPE_NULL, "TYPE148", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02173 {LDNS_RR_TYPE_NULL, "TYPE149", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02174 {LDNS_RR_TYPE_NULL, "TYPE150", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02175 {LDNS_RR_TYPE_NULL, "TYPE151", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02176 {LDNS_RR_TYPE_NULL, "TYPE152", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02177 {LDNS_RR_TYPE_NULL, "TYPE153", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02178 {LDNS_RR_TYPE_NULL, "TYPE154", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02179 {LDNS_RR_TYPE_NULL, "TYPE155", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02180 {LDNS_RR_TYPE_NULL, "TYPE156", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02181 {LDNS_RR_TYPE_NULL, "TYPE157", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02182 {LDNS_RR_TYPE_NULL, "TYPE158", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02183 {LDNS_RR_TYPE_NULL, "TYPE159", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02184 {LDNS_RR_TYPE_NULL, "TYPE160", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02185 {LDNS_RR_TYPE_NULL, "TYPE161", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02186 {LDNS_RR_TYPE_NULL, "TYPE162", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02187 {LDNS_RR_TYPE_NULL, "TYPE163", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02188 {LDNS_RR_TYPE_NULL, "TYPE164", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02189 {LDNS_RR_TYPE_NULL, "TYPE165", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02190 {LDNS_RR_TYPE_NULL, "TYPE166", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02191 {LDNS_RR_TYPE_NULL, "TYPE167", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02192 {LDNS_RR_TYPE_NULL, "TYPE168", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02193 {LDNS_RR_TYPE_NULL, "TYPE169", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02194 {LDNS_RR_TYPE_NULL, "TYPE170", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02195 {LDNS_RR_TYPE_NULL, "TYPE171", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02196 {LDNS_RR_TYPE_NULL, "TYPE172", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02197 {LDNS_RR_TYPE_NULL, "TYPE173", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02198 {LDNS_RR_TYPE_NULL, "TYPE174", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02199 {LDNS_RR_TYPE_NULL, "TYPE175", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02200 {LDNS_RR_TYPE_NULL, "TYPE176", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02201 {LDNS_RR_TYPE_NULL, "TYPE177", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02202 {LDNS_RR_TYPE_NULL, "TYPE178", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02203 {LDNS_RR_TYPE_NULL, "TYPE179", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02204 {LDNS_RR_TYPE_NULL, "TYPE180", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02205 {LDNS_RR_TYPE_NULL, "TYPE181", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02206 {LDNS_RR_TYPE_NULL, "TYPE182", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02207 {LDNS_RR_TYPE_NULL, "TYPE183", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02208 {LDNS_RR_TYPE_NULL, "TYPE184", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02209 {LDNS_RR_TYPE_NULL, "TYPE185", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02210 {LDNS_RR_TYPE_NULL, "TYPE186", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02211 {LDNS_RR_TYPE_NULL, "TYPE187", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02212 {LDNS_RR_TYPE_NULL, "TYPE188", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02213 {LDNS_RR_TYPE_NULL, "TYPE189", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02214 {LDNS_RR_TYPE_NULL, "TYPE190", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02215 {LDNS_RR_TYPE_NULL, "TYPE191", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02216 {LDNS_RR_TYPE_NULL, "TYPE192", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02217 {LDNS_RR_TYPE_NULL, "TYPE193", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02218 {LDNS_RR_TYPE_NULL, "TYPE194", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02219 {LDNS_RR_TYPE_NULL, "TYPE195", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02220 {LDNS_RR_TYPE_NULL, "TYPE196", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02221 {LDNS_RR_TYPE_NULL, "TYPE197", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02222 {LDNS_RR_TYPE_NULL, "TYPE198", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02223 {LDNS_RR_TYPE_NULL, "TYPE199", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02224 {LDNS_RR_TYPE_NULL, "TYPE200", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02225 {LDNS_RR_TYPE_NULL, "TYPE201", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02226 {LDNS_RR_TYPE_NULL, "TYPE202", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02227 {LDNS_RR_TYPE_NULL, "TYPE203", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02228 {LDNS_RR_TYPE_NULL, "TYPE204", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02229 {LDNS_RR_TYPE_NULL, "TYPE205", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02230 {LDNS_RR_TYPE_NULL, "TYPE206", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02231 {LDNS_RR_TYPE_NULL, "TYPE207", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02232 {LDNS_RR_TYPE_NULL, "TYPE208", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02233 {LDNS_RR_TYPE_NULL, "TYPE209", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02234 {LDNS_RR_TYPE_NULL, "TYPE210", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02235 {LDNS_RR_TYPE_NULL, "TYPE211", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02236 {LDNS_RR_TYPE_NULL, "TYPE212", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02237 {LDNS_RR_TYPE_NULL, "TYPE213", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02238 {LDNS_RR_TYPE_NULL, "TYPE214", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02239 {LDNS_RR_TYPE_NULL, "TYPE215", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02240 {LDNS_RR_TYPE_NULL, "TYPE216", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02241 {LDNS_RR_TYPE_NULL, "TYPE217", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02242 {LDNS_RR_TYPE_NULL, "TYPE218", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02243 {LDNS_RR_TYPE_NULL, "TYPE219", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02244 {LDNS_RR_TYPE_NULL, "TYPE220", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02245 {LDNS_RR_TYPE_NULL, "TYPE221", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02246 {LDNS_RR_TYPE_NULL, "TYPE222", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02247 {LDNS_RR_TYPE_NULL, "TYPE223", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02248 {LDNS_RR_TYPE_NULL, "TYPE224", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02249 {LDNS_RR_TYPE_NULL, "TYPE225", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02250 {LDNS_RR_TYPE_NULL, "TYPE226", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02251 {LDNS_RR_TYPE_NULL, "TYPE227", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02252 {LDNS_RR_TYPE_NULL, "TYPE228", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02253 {LDNS_RR_TYPE_NULL, "TYPE229", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02254 {LDNS_RR_TYPE_NULL, "TYPE230", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02255 {LDNS_RR_TYPE_NULL, "TYPE231", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02256 {LDNS_RR_TYPE_NULL, "TYPE232", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02257 {LDNS_RR_TYPE_NULL, "TYPE233", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02258 {LDNS_RR_TYPE_NULL, "TYPE234", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02259 {LDNS_RR_TYPE_NULL, "TYPE235", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02260 {LDNS_RR_TYPE_NULL, "TYPE236", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02261 {LDNS_RR_TYPE_NULL, "TYPE237", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02262 {LDNS_RR_TYPE_NULL, "TYPE238", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02263 {LDNS_RR_TYPE_NULL, "TYPE239", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02264 {LDNS_RR_TYPE_NULL, "TYPE240", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02265 {LDNS_RR_TYPE_NULL, "TYPE241", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02266 {LDNS_RR_TYPE_NULL, "TYPE242", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02267 {LDNS_RR_TYPE_NULL, "TYPE243", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02268 {LDNS_RR_TYPE_NULL, "TYPE244", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02269 {LDNS_RR_TYPE_NULL, "TYPE245", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02270 {LDNS_RR_TYPE_NULL, "TYPE246", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02271 {LDNS_RR_TYPE_NULL, "TYPE247", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02272 {LDNS_RR_TYPE_NULL, "TYPE248", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02273 {LDNS_RR_TYPE_NULL, "TYPE249", 1, 1, type_0_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02274 /* LDNS_RDF_TYPE_INT16_DATA essentially takes two fields (length and data) and
02275  * makes them into one. So, while in rfc 2845 is specified that a TSIG may have 
02276  * 8 or 9 rdata fields, by this implementation, the min/max are 7 each. 
02277  */
02278 {LDNS_RR_TYPE_TSIG, "TSIG", 7, 7, type_tsig_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 },
02279 /* split in array, no longer contiguous */
02280 {LDNS_RR_TYPE_DLV, "DLV", 4, 4, type_ds_wireformat, LDNS_RDF_TYPE_NONE, LDNS_RR_NO_COMPRESS, 0 }
02281 };
02288 #define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \
02289         (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0]))
02290 
02291 const ldns_rr_descriptor *
02292 ldns_rr_descript(uint16_t type)
02293 {
02294         size_t i;
02295         if (type <= LDNS_RDATA_FIELD_DESCRIPTORS_COMMON) {
02296                 return &rdata_field_descriptors[type];
02297         } else {
02298                 /* because not all array index equals type code */
02299                 for (i = LDNS_RDATA_FIELD_DESCRIPTORS_COMMON;
02300                      i < LDNS_RDATA_FIELD_DESCRIPTORS_COUNT;
02301                      i++) {
02302                         if (rdata_field_descriptors[i]._type == type) {
02303                                 return &rdata_field_descriptors[i];
02304                         }
02305                 }
02306                 return &rdata_field_descriptors[0];
02307         }
02308 }
02309 
02310 size_t
02311 ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor)
02312 {
02313         if (descriptor) {
02314                 return descriptor->_minimum;
02315         } else {
02316                 return 0;
02317         }
02318 }
02319 
02320 size_t
02321 ldns_rr_descriptor_maximum(const ldns_rr_descriptor *descriptor)
02322 {
02323         if (descriptor) {
02324                 if (descriptor->_variable != LDNS_RDF_TYPE_NONE) {
02325                         /* Should really be SIZE_MAX... bad FreeBSD.  */
02326                         return UINT_MAX;
02327                 } else {
02328                         return descriptor->_maximum;
02329                 }
02330         } else {
02331                 return 0;
02332         }
02333 }
02334 
02335 ldns_rdf_type
02336 ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor,
02337                               size_t index)
02338 {
02339         assert(descriptor != NULL);
02340         assert(index < descriptor->_maximum
02341                || descriptor->_variable != LDNS_RDF_TYPE_NONE);
02342         if (index < descriptor->_maximum) {
02343                 return descriptor->_wireformat[index];
02344         } else {
02345                 return descriptor->_variable;
02346         }
02347 }
02348 
02349 ldns_rr_type
02350 ldns_get_rr_type_by_name(const char *name)
02351 {
02352         unsigned int i;
02353         const char *desc_name;
02354         const ldns_rr_descriptor *desc;
02355 
02356         /* TYPEXX representation */
02357         if (strlen(name) > 4 && strncasecmp(name, "TYPE", 4) == 0) {
02358                 return atoi(name + 4);
02359         }
02360 
02361         /* Normal types */
02362         for (i = 0; i < (unsigned int) LDNS_RDATA_FIELD_DESCRIPTORS_COUNT; i++) {
02363                 desc = &rdata_field_descriptors[i];
02364                 desc_name = desc->_name;
02365                 if(desc_name &&
02366                    strlen(name) == strlen(desc_name) &&
02367                    strncasecmp(name, desc_name, strlen(desc_name)) == 0) {
02368                         /* because not all array index equals type code */
02369                         return desc->_type;
02370                 }
02371         }
02372 
02373         /* special cases for query types */
02374         if (strlen(name) == 4 && strncasecmp(name, "IXFR", 4) == 0) {
02375                 return 251;
02376         } else if (strlen(name) == 4 && strncasecmp(name, "AXFR", 4) == 0) {
02377                 return 252;
02378         } else if (strlen(name) == 5 && strncasecmp(name, "MAILB", 5) == 0) {
02379                 return 253;
02380         } else if (strlen(name) == 5 && strncasecmp(name, "MAILA", 5) == 0) {
02381                 return 254;
02382         } else if (strlen(name) == 3 && strncasecmp(name, "ANY", 3) == 0) {
02383                 return 255;
02384         }
02385 
02386         return 0;
02387 }
02388 
02389 ldns_rr_class
02390 ldns_get_rr_class_by_name(const char *name)
02391 {
02392         ldns_lookup_table *lt;
02393 
02394         /* CLASSXX representation */
02395         if (strlen(name) > 5 && strncasecmp(name, "CLASS", 5) == 0) {
02396                 return atoi(name + 5);
02397         }
02398 
02399         /* Normal types */
02400         lt = ldns_lookup_by_name(ldns_rr_classes, name);
02401 
02402         if (lt) {
02403                 return lt->id;
02404         }
02405         return 0;
02406 }
02407 
02408 
02409 ldns_rr_type
02410 ldns_rdf2rr_type(const ldns_rdf *rd)
02411 {
02412         ldns_rr_type r;
02413 
02414         if (!rd) {
02415                 return 0;
02416         }
02417 
02418         if (ldns_rdf_get_type(rd) != LDNS_RDF_TYPE_TYPE) {
02419                 return 0;
02420         }
02421 
02422         r = (ldns_rr_type) ldns_rdf2native_int16(rd);
02423         return r;
02424 }
02425 
02426 ldns_rr_type
02427 ldns_rr_list_type(const ldns_rr_list *rr_list)
02428 {
02429         if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
02430                 return ldns_rr_get_type(ldns_rr_list_rr(rr_list, 0));
02431         } else {
02432                 return 0;
02433         }
02434 }
02435 
02436 ldns_rdf *
02437 ldns_rr_list_owner(const ldns_rr_list *rr_list)
02438 {
02439         if (rr_list && ldns_rr_list_rr_count(rr_list) > 0) {
02440                 return ldns_rr_owner(ldns_rr_list_rr(rr_list, 0));
02441         } else {
02442                 return NULL;
02443         }
02444 }