Fix bug 274.

diff --git a/Changelog b/Changelog
index 5431d09c92327947fd735c8d36aac679cfb60c6a..917543c8f88bc4f410bb5981ab4fb59cf121d7ae 100644 (file)
--- a/Changelog
+++ b/Changelog
@@ -5,6 +5,7 @@
          Fix parse of '\(' and '\)' in names.  Also for file read. Also '\.'
        * Fix signature creation when TTLs are different for RRs in RRset.
        * bug273: fix so EDNS rdata is included in pkt to wire conversion.
+       * bug274: fix use of c++ keyword 'class' for RR class in the code.
 
 1.6.1   2009-09-14
        * --enable-gost : use the GOST algorithm (experimental).

diff --git a/ldns/resolver.h b/ldns/resolver.h
index 916d976ac1bbde701c99a65911bfd59b74d97fa0..7bc0412134ddba80320f273c004aa378b13ecc0f 100644 (file)
--- a/ldns/resolver.h
+++ b/ldns/resolver.h
@@ -610,13 +610,13 @@ ldns_status ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt
  * Send a query to a nameserver
  * \param[in] *r operate using this resolver
  * \param[in] *name query for this name
- * \param[in] *type query for this type (may be 0, defaults to A)
- * \param[in] *class query for this class (may be 0, default to IN)
+ * \param[in] *t query for this type (may be 0, defaults to A)
+ * \param[in] *c query for this class (may be 0, default to IN)
  * \param[in] flags the query flags
  * \return ldns_pkt* a packet with the reply from the nameserver
  * if _defnames is true the default domain will be added
  */
-ldns_pkt* ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type type, ldns_rr_class class, uint16_t flags);
+ldns_pkt* ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags);
 
 
 /** 

diff --git a/ldns/update.h b/ldns/update.h
index 43f80e691a7ca67969bca5c86286f654bd85fd31..2148dd3714b1ba2429f7ec973eabce0c71c2aa4a 100644 (file)
--- a/ldns/update.h
+++ b/ldns/update.h
@@ -97,11 +97,11 @@ void ldns_update_set_adcount(ldns_pkt *p, uint16_t c);
  * Not sure if we want to keep these like this, therefore
  * not documented
  */
-ldns_status ldns_update_soa_mname(ldns_rdf *zone, ldns_resolver *r, ldns_rr_class class, ldns_rdf **mname);
+ldns_status ldns_update_soa_mname(ldns_rdf *zone, ldns_resolver *r, ldns_rr_class c, ldns_rdf **mname);
 /* 
  * Not sure if we want to keep these like this, therefore
  * not documented
  */
-ldns_status ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r, ldns_rr_class class, ldns_rdf **zone_rdf, ldns_rdf **mname_rdf);
+ldns_status ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r, ldns_rr_class c, ldns_rdf **zone_rdf, ldns_rdf **mname_rdf);
 
 #endif  /* LDNS_UPDATE_H */

diff --git a/resolver.c b/resolver.c
index 84d68b38fc35ee29f9dc57eed9d206ed7d135671..00f84cc39287ddf61a5c6e2ad33bb5a33b37030f 100644 (file)
--- a/resolver.c
+++ b/resolver.c
@@ -864,8 +864,8 @@ ldns_resolver_deep_free(ldns_resolver *res)
 }
 
 ldns_pkt *
-ldns_resolver_search(const ldns_resolver *r,const  ldns_rdf *name, ldns_rr_type type, 
-                ldns_rr_class class, uint16_t flags)
+ldns_resolver_search(const ldns_resolver *r,const  ldns_rdf *name, 
+       ldns_rr_type t, ldns_rr_class c, uint16_t flags)
 {
 
        char *str_dname;
@@ -878,13 +878,13 @@ ldns_resolver_search(const ldns_resolver *r,const  ldns_rdf *name, ldns_rr_type
 
        if (ldns_dname_str_absolute(str_dname)) {
                /* query as-is */
-               return ldns_resolver_query(r, name, type, class, flags);
+               return ldns_resolver_query(r, name, t, c, flags);
        } else {
                search_list = ldns_resolver_searchlist(r);
                for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
                        new_name = ldns_dname_cat_clone(name, search_list[i]);
 
-                       p = ldns_resolver_query(r, new_name, type, class, flags);
+                       p = ldns_resolver_query(r, new_name, t, c, flags);
                        ldns_rdf_free(new_name);
                        if (p) {
                                return p;
@@ -895,8 +895,8 @@ ldns_resolver_search(const ldns_resolver *r,const  ldns_rdf *name, ldns_rr_type
 }
 
 ldns_pkt *
-ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type type, 
-               ldns_rr_class class, uint16_t flags)
+ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, 
+       ldns_rr_type t, ldns_rr_class c, uint16_t flags)
 {
        ldns_rdf *newname;
        ldns_pkt *pkt;
@@ -905,8 +905,8 @@ ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t
        pkt = NULL;
 
        if (!ldns_resolver_defnames(r)) {
-               status = ldns_resolver_send(&pkt, (ldns_resolver *)r, name, type, class, 
-                               flags);
+               status = ldns_resolver_send(&pkt, (ldns_resolver *)r, name, 
+                               t, c, flags);
                if (status == LDNS_STATUS_OK) {
                        return pkt;
                } else {
@@ -920,8 +920,8 @@ ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t
 
        if (!ldns_resolver_domain(r)) {
                /* _defnames is set, but the domain is not....?? */
-               status = ldns_resolver_send(&pkt, (ldns_resolver *)r, name, type, class, 
-                               flags);
+               status = ldns_resolver_send(&pkt, (ldns_resolver *)r, name, 
+                               t, c, flags);
                if (status == LDNS_STATUS_OK) {
                        return pkt;
                } else {
@@ -939,7 +939,7 @@ ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t
                }
                return NULL;
        }
-       status = ldns_resolver_send(&pkt, (ldns_resolver *)r, newname, type, class, 
+       status = ldns_resolver_send(&pkt, (ldns_resolver *)r, newname, t, c, 
                        flags);
 
        ldns_rdf_free(newname);
@@ -994,12 +994,12 @@ ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r,
 
 ldns_status
 ldns_resolver_prepare_query_pkt(ldns_pkt **query_pkt, ldns_resolver *r,
-                                const ldns_rdf *name, ldns_rr_type type, 
-                                ldns_rr_class class, uint16_t flags)
+                                const ldns_rdf *name, ldns_rr_type t, 
+                                ldns_rr_class c, uint16_t flags)
 {
        /* prepare a question pkt from the parameters
         * and then send this */
-       *query_pkt = ldns_pkt_query_new(ldns_rdf_clone(name), type, class, flags);
+       *query_pkt = ldns_pkt_query_new(ldns_rdf_clone(name), t, c, flags);
        if (!*query_pkt) {
                return LDNS_STATUS_ERR;
        }
@@ -1035,7 +1035,7 @@ ldns_resolver_prepare_query_pkt(ldns_pkt **query_pkt, ldns_resolver *r,
 
 ldns_status
 ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name, 
-               ldns_rr_type type, ldns_rr_class class, uint16_t flags)
+               ldns_rr_type t, ldns_rr_class c, uint16_t flags)
 {
        ldns_pkt *query_pkt;
        ldns_pkt *answer_pkt;
@@ -1049,11 +1049,11 @@ ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name,
        /* do all the preprocessing here, then fire of an query to 
         * the network */
 
-       if (0 == type) {
-               type = LDNS_RR_TYPE_A;
+       if (0 == t) {
+               t= LDNS_RR_TYPE_A;
        }
-       if (0 == class) {
-               class = LDNS_RR_CLASS_IN;
+       if (0 == c) {
+               c= LDNS_RR_CLASS_IN;
        }
        if (0 == ldns_resolver_nameserver_count(r)) {
                return LDNS_STATUS_RES_NO_NS;
@@ -1062,12 +1062,8 @@ ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name,
                return LDNS_STATUS_RES_QUERY;
        }
 
-       status = ldns_resolver_prepare_query_pkt(&query_pkt,
-                                                r,
-                                                name,
-                                                type,
-                                                class,
-                                                flags);
+       status = ldns_resolver_prepare_query_pkt(&query_pkt, r, name,
+                                                t, c, flags);
        if (status != LDNS_STATUS_OK) {
                return status;
        }

diff --git a/update.c b/update.c
index c6781a96c1ec639282ea01c85b1b6fca840fc3cd..01e67aa0691699a760934eeaa22e0a82a16ad000 100644 (file)
--- a/update.c
+++ b/update.c
@@ -24,7 +24,7 @@
  */
 
 ldns_pkt *
-ldns_update_pkt_new(ldns_rdf *zone_rdf, ldns_rr_class class,
+ldns_update_pkt_new(ldns_rdf *zone_rdf, ldns_rr_class c,
     ldns_rr_list *pr_rrlist, ldns_rr_list *up_rrlist, ldns_rr_list *ad_rrlist)
 {
        ldns_pkt *p;
@@ -33,12 +33,12 @@ ldns_update_pkt_new(ldns_rdf *zone_rdf, ldns_rr_class class,
                return NULL;
        }
 
-       if (class == 0) { 
-               class = LDNS_RR_CLASS_IN;
+       if (c == 0) { 
+               c = LDNS_RR_CLASS_IN;
        }
 
        /* Create packet, fill in Zone Section. */
-       p = ldns_pkt_query_new(zone_rdf, LDNS_RR_TYPE_SOA, class, LDNS_RD);
+       p = ldns_pkt_query_new(zone_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD);
        if (!p) {
                return NULL;
        }
@@ -88,14 +88,14 @@ ldns_update_pkt_tsig_add(ldns_pkt *p, ldns_resolver *r)
 /* XXX doc */
 ldns_status
 ldns_update_soa_mname(ldns_rdf *zone, ldns_resolver *r,
-    ldns_rr_class class, ldns_rdf **mname)
+    ldns_rr_class c, ldns_rdf **mname)
 {
        ldns_rr         *soa_rr;
        ldns_pkt        *query, *resp;
 
        /* Nondestructive, so clone 'zone' here */
        query = ldns_pkt_query_new(ldns_rdf_clone(zone), LDNS_RR_TYPE_SOA,
-           class, LDNS_RD);
+           c, LDNS_RD);
        if (!query) {
                return LDNS_STATUS_ERR;
        }
@@ -127,7 +127,7 @@ ldns_update_soa_mname(ldns_rdf *zone, ldns_resolver *r,
 /* Try to get zone and MNAME from SOA queries. */
 ldns_status
 ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r,
-    ldns_rr_class class, ldns_rdf **zone_rdf, ldns_rdf **mname_rdf)
+    ldns_rr_class c, ldns_rdf **zone_rdf, ldns_rdf **mname_rdf)
 {
        ldns_rr         *soa_rr, *rr;
        ldns_rdf        *soa_zone = NULL, *soa_mname = NULL;
@@ -143,7 +143,7 @@ ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r,
 
        /* Step 1 - first find a nameserver that should know *something* */
        fqdn_rdf = ldns_dname_new_frm_str(fqdn);
-       query = ldns_pkt_query_new(fqdn_rdf, LDNS_RR_TYPE_SOA, class, LDNS_RD);
+       query = ldns_pkt_query_new(fqdn_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD);
        if (!query) {
                return LDNS_STATUS_ERR;
        }
@@ -173,7 +173,7 @@ ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r,
        }
 
        /* Step 2 - find SOA MNAME IP address, add to resolver */
-       query = ldns_pkt_query_new(soa_mname, LDNS_RR_TYPE_A, class, LDNS_RD);
+       query = ldns_pkt_query_new(soa_mname, LDNS_RR_TYPE_A, c, LDNS_RD);
        if (!query) {
                return LDNS_STATUS_ERR;
        }
@@ -226,7 +226,7 @@ ldns_update_soa_zone_mname(const char *fqdn, ldns_resolver *r,
 
        /* Step 3 - Redo SOA query, sending to SOA MNAME directly. */
        fqdn_rdf = ldns_dname_new_frm_str(fqdn);
-       query = ldns_pkt_query_new(fqdn_rdf, LDNS_RR_TYPE_SOA, class, LDNS_RD);
+       query = ldns_pkt_query_new(fqdn_rdf, LDNS_RR_TYPE_SOA, c, LDNS_RD);
        if (!query) {
                return LDNS_STATUS_ERR;
        }