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