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

Generated on Fri Nov 23 00:48:29 2007 for ldns by  doxygen 1.5.3-20071008