rr.c

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

Generated on Fri Jun 8 17:07:02 2012 for ldns by  doxygen 1.4.7