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

Generated on Thu Nov 29 14:15:00 2007 for ldns by  doxygen 1.5.1