only wire2host.h has non prefixed LDNS_ stuff in it

diff --git a/dname.c b/dname.c
index 37ad611d85163eac1324fd55e23129684a550399..696b73905b62a39c7e24df2613175dd9a67654ec 100644 (file)
--- a/dname.c
+++ b/dname.c
@@ -127,6 +127,6 @@ ldns_dname2canonical(const ldns_rdf *rd)
 
        rdd = (uint8_t*)ldns_rdf_data(rd);
        for (i = 0; i < ldns_rdf_size(rd); i++, rdd++) {
-               *rdd = (uint8_t)DNAME_NORMALIZE((int)*rdd);
+               *rdd = (uint8_t)LDNS_DNAME_NORMALIZE((int)*rdd);
        }
 }

diff --git a/dnssec.c b/dnssec.c
index 9f089eaca82a945f2501d573b1b83a2a4aa4b638..b96899619fb732f950ccd5818d19bcf28d56e35d 100644 (file)
--- a/dnssec.c
+++ b/dnssec.c
@@ -38,7 +38,7 @@ ldns_calc_keytag(ldns_rr *key)
 
        /* rdata to buf - only put the rdata in a buffer */
        /* XXX waaayyy too much */
-       keybuf = ldns_buffer_new(MAX_PACKETLEN);
+       keybuf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        if (!keybuf) {
                return 0;
        }
@@ -122,8 +122,8 @@ ldns_verify_rrsig(ldns_rr_list *rrset, ldns_rr *rrsig, ldns_rr_list *keys)
        rrset_clone = ldns_rr_list_deep_clone(rrset);
        
        /* create the buffers which will certainly hold the raw data */
-       rawsig_buf = ldns_buffer_new(MAX_PACKETLEN);
-       verify_buf  = ldns_buffer_new(MAX_PACKETLEN);
+       rawsig_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
+       verify_buf  = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        
        sig_algo = ldns_rdf2native_int8(ldns_rr_rdf(rrsig, 1));
        result = false;
@@ -167,7 +167,7 @@ ldns_verify_rrsig(ldns_rr_list *rrset, ldns_rr *rrsig, ldns_rr_list *keys)
 
        for(i = 0; i < ldns_rr_list_rr_count(keys); i++) {
                current_key = ldns_rr_list_rr(keys, i);
-               key_buf = ldns_buffer_new(MAX_PACKETLEN);
+               key_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
                /* put the key-data in a buffer, that's the third rdf, with
                 * the base64 encoded key data */
                if (ldns_rdf2buffer_wire(key_buf,
@@ -516,7 +516,7 @@ ldns_create_tsig_mac(
        /* 
         * prepare the digestable information
         */
-       data_buffer = ldns_buffer_new(MAX_PACKETLEN);
+       data_buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        /* if orig_mac is not NULL, add it too */
        if (orig_mac_rdf) {
                (void) ldns_rdf2buffer_wire(data_buffer, orig_mac_rdf);
@@ -784,7 +784,7 @@ ldns_key_rr2ds(const ldns_rr *key)
                 return NULL;
         }
 
-        data_buf = ldns_buffer_new(MAX_PACKETLEN);
+        data_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
         if (!data_buf) {
                 return NULL;
         }
@@ -871,7 +871,7 @@ ldns_sign_public(ldns_rr_list *rrset, ldns_key_list *keys)
        
        for (key_count = 0; key_count < ldns_key_list_key_count(keys); key_count++) {
 
-               sign_buf = ldns_buffer_new(MAX_PACKETLEN);
+               sign_buf = ldns_buffer_new(LDNS_MAX_PACKETLEN);
                b64rdf = NULL;
 
                current_key = ldns_key_list_key(keys, key_count);
@@ -970,7 +970,7 @@ ldns_sign_public_dsa(ldns_buffer *to_sign, DSA *key)
        ldns_rdf *sigdata_rdf;
        ldns_buffer *b64sig;
 
-       b64sig = ldns_buffer_new(MAX_PACKETLEN);
+       b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        if (!b64sig) {
                return NULL;
        }
@@ -1001,7 +1001,7 @@ ldns_sign_public_rsasha1(ldns_buffer *to_sign, RSA *key)
        ldns_buffer *b64sig;
 
        siglen = 0;
-       b64sig = ldns_buffer_new(MAX_PACKETLEN);
+       b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        if (!b64sig) {
                return NULL;
        }
@@ -1030,7 +1030,7 @@ ldns_sign_public_rsamd5(ldns_buffer *to_sign, RSA *key)
        ldns_rdf *sigdata_rdf;
        ldns_buffer *b64sig;
 
-       b64sig = ldns_buffer_new(MAX_PACKETLEN);
+       b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        if (!b64sig) {
                return NULL;
        }

diff --git a/higher.c b/higher.c
index 84564927cc11fdad420a91ead557f77bb5054bf8..e20ea90234122de0166fd03ab18e2d45283c0cb0 100644 (file)
--- a/higher.c
+++ b/higher.c
@@ -99,13 +99,13 @@ ldns_get_rr_list_hosts_frm_fp(FILE *fp)
        ldns_rr_list *list;
        bool ip6;
 
-       linebuf = ldns_buffer_new(MAXLINE_LEN);
+       linebuf = ldns_buffer_new(LDNS_MAX_LINELEN);
 
        /* duh duh duh !!!!! */
-       line = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
-       word = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
-       addr = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
-       rr_str = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
+       line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
+       word = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
+       addr = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
+       rr_str = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
        ip6 = false;
        list = ldns_rr_list_new();
        rr = NULL;
@@ -143,9 +143,9 @@ ldns_get_rr_list_hosts_frm_fp(FILE *fp)
                        } else {
                                /* la al la la */
                                if (ip6) {
-                                       snprintf(rr_str, MAXLINE_LEN, "%s IN AAAA %s", word, addr);
+                                       snprintf(rr_str, LDNS_MAX_LINELEN, "%s IN AAAA %s", word, addr);
                                } else {
-                                       snprintf(rr_str, MAXLINE_LEN, "%s IN A %s", word, addr);
+                                       snprintf(rr_str, LDNS_MAX_LINELEN, "%s IN A %s", word, addr);
                                }
                                rr = ldns_rr_new_frm_str(rr_str);
                        }
@@ -169,7 +169,7 @@ ldns_get_rr_list_hosts_frm_file(char *filename)
        FILE *fp;
 
        if (!filename) {
-                fp = fopen(RESOLV_HOSTS, "r");
+                fp = fopen(LDNS_RESOLV_HOSTS, "r");
         
         } else {
                 fp = fopen(filename, "r");

diff --git a/host2str.c b/host2str.c
index 1efdf88e7be6d2aa0f5bf6ada81ca453e4f50045..579883865d6f125a1c29a2e0281a935df62c056a 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -1046,7 +1046,7 @@ char *
 ldns_rdf2str(ldns_rdf *rdf)
 {
        char *result = NULL;
-       ldns_buffer *tmp_buffer = ldns_buffer_new(MIN_BUFLEN);
+       ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
 
        if (ldns_rdf2buffer_str(tmp_buffer, rdf) == LDNS_STATUS_OK) {
                /* export and return string, destroy rest */
@@ -1061,7 +1061,7 @@ char *
 ldns_rr2str(ldns_rr *rr)
 {
        char *result = NULL;
-       ldns_buffer *tmp_buffer = ldns_buffer_new(MIN_BUFLEN);
+       ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
 
        if (ldns_rr2buffer_str(tmp_buffer, rr) == LDNS_STATUS_OK) {
                /* export and return string, destroy rest */
@@ -1076,7 +1076,7 @@ char *
 ldns_pkt2str(ldns_pkt *pkt)
 {
        char *result = NULL;
-       ldns_buffer *tmp_buffer = ldns_buffer_new(MIN_BUFLEN);
+       ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
 
        if (ldns_pkt2buffer_str(tmp_buffer, pkt) == LDNS_STATUS_OK) {
                /* export and return string, destroy rest */
@@ -1091,7 +1091,7 @@ char *
 ldns_rr_list2str(ldns_rr_list *list)
 {
        char *result = NULL;
-       ldns_buffer *tmp_buffer = ldns_buffer_new(MIN_BUFLEN); 
+       ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN); 
 
        if (list) {
                if (ldns_rr_list2buffer_str(tmp_buffer, list) == LDNS_STATUS_OK) {

diff --git a/host2wire.c b/host2wire.c
index 35fd76b21d5a3b6edf9b489fcf9b59227471557c..f718a3b45b618eb2a7e1930377ebb6fd11aed36d 100644 (file)
--- a/host2wire.c
+++ b/host2wire.c
@@ -258,7 +258,7 @@ ldns_pkt2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet)
 ldns_status
 ldns_rdf2wire(uint8_t **dest, const ldns_rdf *rdf, size_t *result_size)
 {
-       ldns_buffer *buffer = ldns_buffer_new(MAX_PACKETLEN);
+       ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        uint8_t *result = NULL;
        ldns_status status;
        *result_size = 0;
@@ -284,7 +284,7 @@ ldns_rdf2wire(uint8_t **dest, const ldns_rdf *rdf, size_t *result_size)
 ldns_status
 ldns_rr2wire(uint8_t **dest, const ldns_rr *rr, int section, size_t *result_size)
 {
-       ldns_buffer *buffer = ldns_buffer_new(MAX_PACKETLEN);
+       ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        uint8_t *result = NULL;
        ldns_status status;
        *result_size = 0;
@@ -310,7 +310,7 @@ ldns_rr2wire(uint8_t **dest, const ldns_rr *rr, int section, size_t *result_size
 ldns_status
 ldns_pkt2wire(uint8_t **dest, const ldns_pkt *packet, size_t *result_size)
 {
-       ldns_buffer *buffer = ldns_buffer_new(MAX_PACKETLEN);
+       ldns_buffer *buffer = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        uint8_t *result = NULL;
        ldns_status status;
        *result_size = 0;

diff --git a/keys.c b/keys.c
index 1f47a1b1a14eab9dd501317716d52317ba580d93..0e95a59cde3a527ef2f59cbeaaba6784d702aed4 100644 (file)
--- a/keys.c
+++ b/keys.c
@@ -345,7 +345,7 @@ ldns_key2rr(ldns_key *k)
                return NULL;
        }
 
-       bin = LDNS_XMALLOC(unsigned char, MAX_KEYLEN);
+       bin = LDNS_XMALLOC(unsigned char, LDNS_MAX_KEYLEN);
        if (!bin) {
                return NULL;
        }
@@ -357,7 +357,7 @@ ldns_key2rr(ldns_key *k)
                                ldns_key_flags(k)));
        /* first - proto */
        ldns_rr_push_rdf(pubkey, 
-                       ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, DNSSEC_KEYPROTO));
+                       ldns_native2rdf_int8(LDNS_RDF_TYPE_INT8, LDNS_DNSSEC_KEYPROTO));
        
        ldns_rr_set_owner(pubkey, ldns_key_pubkey_owner(k));
 

diff --git a/ldns/buffer.h b/ldns/buffer.h
index 137af3c811231519a231c5417207eed8fed3586c..810c9496d82ce5fab4f7b14af266a52b83c757ef 100644 (file)
--- a/ldns/buffer.h
+++ b/ldns/buffer.h
@@ -26,7 +26,7 @@
  * number of initial bytes in buffer of
  * which we cannot tell the size before hand
  */
-#define MIN_BUFLEN     256
+#define LDNS_MIN_BUFLEN        256
 
 typedef struct buffer ldns_buffer;
 

diff --git a/ldns/dname.h b/ldns/dname.h
index 1fd4bd1ad6ad61b99021c85c71c7e02b3f16e721..0d17f1194fe99d7b29c6736e3e7fc5df67d03bab 100644 (file)
--- a/ldns/dname.h
+++ b/ldns/dname.h
@@ -17,7 +17,7 @@
 #include <ldns/common.h>
 #include <ldns/rdata.h>
 
-#define DNAME_NORMALIZE        tolower
+#define LDNS_DNAME_NORMALIZE        tolower
 
 /**
  * concatenate two dnames together

diff --git a/ldns/dnssec.h b/ldns/dnssec.h
index 479335549c225d33a8dddbdc4b34bd8a0ee483d0..8d8b53d5047e2c7d22f0ef56a014a1e5c7a7dcaf 100644 (file)
--- a/ldns/dnssec.h
+++ b/ldns/dnssec.h
@@ -18,8 +18,8 @@
 #include <ldns/packet.h>
 #include <ldns/keys.h>
 
-#define MAX_KEYLEN     2048
-#define DNSSEC_KEYPROTO        3
+#define LDNS_MAX_KEYLEN                2048
+#define LDNS_DNSSEC_KEYPROTO   3
 
 #if 0
 /**

diff --git a/ldns/packet.h b/ldns/packet.h
index 33955f45efbf8e7ffe1a7c1a8dd23d6aeacee846..453d302a184ed7e3fbad74883e4c34a332778c7c 100644 (file)
--- a/ldns/packet.h
+++ b/ldns/packet.h
@@ -245,7 +245,7 @@ ldns_pkt *ldns_pkt_query_new_frm_str(const char *rr_name, ldns_rr_type rr_type,
  */
 ldns_pkt *ldns_pkt_query_new(ldns_rdf *rr_name, ldns_rr_type rr_type, ldns_rr_class rr_class, uint16_t flags);
 
-#define MAX_PACKETLEN         65535
+#define LDNS_MAX_PACKETLEN         65535
 
 /* allow flags to be given to mk_query */
 #define LDNS_QR                1

diff --git a/ldns/parse.h b/ldns/parse.h
index abc6fabf29a3833cd2a20ec49c492d2b36d783d8..505a376cfe27c48f41580932618887d6f331cff2 100644 (file)
--- a/ldns/parse.h
+++ b/ldns/parse.h
@@ -17,8 +17,8 @@
 #define LDNS_PARSE_SKIP_SPACE          "\f\n\r\v"
 #define LDNS_PARSE_NORMAL              " \f\n\r\t\v"
 #define LDNS_PARSE_NO_NL               " \t"
-#define MAXLINE_LEN            512
-#define MAXKEYWORD_LEN         32
+#define LDNS_MAX_LINELEN               512
+#define LDNS_MAX_KEYWORDLEN            32
 
 /** 
  * Get a token/char from the stream F.

diff --git a/ldns/rdata.h b/ldns/rdata.h
index 3aad0c91fb1749274dd04f63f74bb52322a99f9c..83acc9a4da5a33dfd834d6425aca290da5273444 100644 (file)
--- a/ldns/rdata.h
+++ b/ldns/rdata.h
@@ -17,7 +17,7 @@
 #include <ldns/common.h>
 #include <ldns/error.h>
 
-#define MAX_RDFLEN     65535
+#define LDNS_MAX_RDFLEN        65535
 
 /**
  * The different types of RDATA fields.

diff --git a/ldns/resolver.h b/ldns/resolver.h
index d9b0b2e5ac595d794e8d5c3964adf8b0ce0499b3..2cf4072feae7b01130535fca8fad809679455b38 100644 (file)
--- a/ldns/resolver.h
+++ b/ldns/resolver.h
@@ -21,12 +21,12 @@
 #include <sys/time.h>
 
 /** \brief where to find the resolv.conf file */
-#define RESOLV_CONF    "/etc/resolv.conf"
-#define RESOLV_HOSTS   "/etc/hosts"
+#define LDNS_RESOLV_CONF       "/etc/resolv.conf"
+#define LDNS_RESOLV_HOSTS      "/etc/hosts"
 
-#define RESOLV_KEYWORD         0
-#define RESOLV_DEFDOMAIN       1
-#define RESOLV_NAMESERVER      2
+#define LDNS_RESOLV_KEYWORD            0
+#define LDNS_RESOLV_DEFDOMAIN  1
+#define LDNS_RESOLV_NAMESERVER 2
 
 #define LDNS_RESOLV_INETANY            0
 #define LDNS_RESOLV_INET               1

diff --git a/ldns/rr.h b/ldns/rr.h
index 270a6fff8f29d729c8a572d1b99454afc4ccb8f7..2ba82ec5f5e1f0627b1f416379828e9e543bcb43 100644 (file)
--- a/ldns/rr.h
+++ b/ldns/rr.h
@@ -19,15 +19,15 @@
 #include <ldns/error.h>
 
 /** Maximum length of a dname label */
-#define MAX_LABELLEN     63
+#define LDNS_MAX_LABELLEN     63
 /** Maximum length of a complete dname */
-#define MAX_DOMAINLEN    255
+#define LDNS_MAX_DOMAINLEN    255
 /** Maximum number of pointers in 1 dname */
-#define MAX_POINTERS   65535
+#define LDNS_MAX_POINTERS      65535
 /** Maximum number of rr's in a rr_list */
-#define MAX_RR         65535
+#define LDNS_MAX_RR            65535
 /** The bytes TTL, CLASS and length use up in an rr */
-#define RR_OVERHEAD    10
+#define LDNS_RR_OVERHEAD       10
 
 
 /**

diff --git a/ldns/util.h b/ldns/util.h
index 3095e12625e17fb6d950b9d6f046ace47bdaa137..ee6d527196c084c307f223ea6e9ba953e806a3f3 100644 (file)
--- a/ldns/util.h
+++ b/ldns/util.h
@@ -40,7 +40,7 @@
 #define LDNS_FREE(ptr) \
        do { free((ptr)); (ptr) = NULL; } while (0)
 
-#define DEP     printf("DEPRECATED FUNCTION!\n");
+#define LDNS_DEP     printf("DEPRECATED FUNCTION!\n");
 
 /*
  * Copy data allowing for unaligned accesses in network byte order

diff --git a/libdns.vim b/libdns.vim
index 793b4567528d3af0e0a32d1c699e7a5a47f82eb6..300be4939681b64e57a61b533ffafcb3e5331ae9 100644 (file)
--- a/libdns.vim
+++ b/libdns.vim
@@ -9,7 +9,7 @@ syn keyword  ldnsMacro LDNS_XMALLOC
 syn keyword  ldnsMacro LDNS_REALLOC
 syn keyword  ldnsMacro LDNS_XREALLOC
 syn keyword  ldnsMacro LDNS_FREE
-syn keyword  ldnsMacro DEP  
+syn keyword  ldnsMacro LDNS_DEP  
 
 " ldns/rdata.h
 syn keyword  ldnsType           ldns_rdf
@@ -46,7 +46,7 @@ syn keyword  ldnsConstant     LDNS_RDF_TYPE_SERVICE
 syn keyword  ldnsConstant      LDNS_RDF_TYPE_LOC
 syn keyword  ldnsConstant      LDNS_RDF_TYPE_WKS
 syn keyword  ldnsConstant      LDNS_RDF_TYPE_NSAP
-syn keyword  ldnsConstant      MAX_RDFLEN
+syn keyword  ldnsConstant      LDNS_MAX_RDFLEN
 
 " ldns/dns.h
 syn keyword  ldnsConstant      LDNS_PORT
@@ -72,7 +72,7 @@ syn keyword  ldnsConstant     LDNS_SECTION_ANSWER
 syn keyword  ldnsConstant      LDNS_SECTION_AUTHORITY
 syn keyword  ldnsConstant      LDNS_SECTION_ADDITIONAL
 syn keyword  ldnsConstant      LDNS_SECTION_ANY
-syn keyword  ldnsConstant      MAX_PACKETLEN
+syn keyword  ldnsConstant      LDNS_MAX_PACKETLEN
 
 
 " dns/error.h
@@ -162,8 +162,8 @@ syn keyword  ldnsConstant LDNS_RR_TYPE_AXFR
 syn keyword  ldnsConstant LDNS_RR_TYPE_MAILB      
 syn keyword  ldnsConstant LDNS_RR_TYPE_MAILA      
 syn keyword  ldnsConstant LDNS_RR_TYPE_ANY        
-syn keyword  ldnsConstant MAX_LABELLEN     
-syn keyword  ldnsConstant MAX_DOMAINLEN
+syn keyword  ldnsConstant LDNS_MAX_LABELLEN     
+syn keyword  ldnsConstant LDNS_MAX_DOMAINLEN
 syn keyword  ldnsConstant LDNS_RR_COMPRESS
 syn keyword  ldnsConstant LDNS_RR_NO_COMPRESS
 
@@ -228,7 +228,7 @@ syn keyword  ldnsMacro      ARCOUNT
 
 " ldns/buffer.h
 syn keyword  ldnsType          ldns_buffer
-syn keyword  ldnsConstant      MIN_BUFLEN
+syn keyword  ldnsConstant      LDNS_MIN_BUFLEN
 
 " ldns/host2str.h
 syn keyword  ldnsType  ldns_lookup_table
@@ -239,7 +239,7 @@ syn keyword  ldnsType   ldns_key_list
 syn keyword  ldnsType   ldns_signing_algorithm
 
 " ldns/dnssec.h
-syn keyword  ldnsConstant      MAX_KEYLEN
+syn keyword  ldnsConstant      LDNS_MAX_KEYLEN
 
 
 

diff --git a/net.c b/net.c
index c1f2d07fec169c1ea21b8b1a5c35b3b8e7d5bdef..3c032e93643ba287d70f0b016dc460dbabd6e6da 100644 (file)
--- a/net.c
+++ b/net.c
@@ -48,7 +48,7 @@ ldns_send(ldns_pkt **result, ldns_resolver *r, ldns_pkt *query_pkt)
        ns_array = ldns_resolver_nameservers(r);
        reply = NULL; ns_len = 0;
        
-       qb = ldns_buffer_new(MAX_PACKETLEN);
+       qb = ldns_buffer_new(LDNS_MAX_PACKETLEN);
 
        if (ldns_pkt_tsig(query_pkt)) {
                tsig_mac = ldns_rr_rdf(ldns_pkt_tsig(query_pkt), 3);
@@ -196,13 +196,13 @@ ldns_send_udp(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage
        }
        
        /* wait for an response*/
-       answer = LDNS_XMALLOC(uint8_t, MAX_PACKETLEN);
+       answer = LDNS_XMALLOC(uint8_t, LDNS_MAX_PACKETLEN);
        if (!answer) {
                dprintf("%s", "respons alloc error\n");
                return LDNS_STATUS_ERR;
        }
 
-       bytes = recv(sockfd, answer, MAX_PACKETLEN, 0);
+       bytes = recv(sockfd, answer, LDNS_MAX_PACKETLEN, 0);
 
        close(sockfd);
 

diff --git a/parse.c b/parse.c
index 13cbf6f322de8d214f04e6716d54851840345988..bc5fdfcdf34deb85e3a7f0c6f5f63c371a639754 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -21,7 +21,7 @@ ldns_fget_keyword_data(FILE *f, const char *keyword, const char *k_del, char *da
        char *fkeyword;
        ssize_t i;
 
-       fkeyword = LDNS_XMALLOC(char, MAXKEYWORD_LEN);
+       fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN);
        i = 0;
 
        i = ldns_fget_token(f, fkeyword, k_del, 0);
@@ -144,7 +144,7 @@ ldns_bget_keyword_data(ldns_buffer *b, const char *keyword, const char *k_del, c
        char *fkeyword;
        ssize_t i;
 
-       fkeyword = LDNS_XMALLOC(char, MAXKEYWORD_LEN);
+       fkeyword = LDNS_XMALLOC(char, LDNS_MAX_KEYWORDLEN);
        i = 0;
 
        i = ldns_bget_token(b, fkeyword, k_del, 0);

diff --git a/rdata.c b/rdata.c
index 79556a38f7f2f235aec00ddb54cf6ef5b289dcb7..399e3f0c24e170dc82586b1d5324c3bde2b35f06 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -331,7 +331,7 @@ ldns_rdf_new_frm_fp(ldns_rdf_type type, FILE *fp)
        ldns_rdf *r;
        ssize_t t;
 
-       line = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
+       line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
        if (!line) {
                return NULL;
        }

diff --git a/resolver.c b/resolver.c
index f8e47071b17dd6817fe920be4f30d3730c2e0069..297d0fb4d7aa38bf11c253838b08dc3258b6ca24 100644 (file)
--- a/resolver.c
+++ b/resolver.c
@@ -451,8 +451,8 @@ ldns_resolver_new_frm_fp(FILE *fp)
        /* recognized keywords */
        keyword[0] = "domain";
        keyword[1] = "nameserver";
-       word = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
-       expect = RESOLV_KEYWORD;
+       word = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
+       expect = LDNS_RESOLV_KEYWORD;
 
        r = ldns_resolver_new();
        if (!r) {
@@ -462,7 +462,7 @@ ldns_resolver_new_frm_fp(FILE *fp)
        while (gtr > 0) {
                /* do something */
                switch(expect) {
-                       case RESOLV_KEYWORD:
+                       case LDNS_RESOLV_KEYWORD:
                                /* keyword */
                                for(i = 0; i < 2; i++) {
                                        if (strcasecmp(keyword[i], word) == 0) {
@@ -478,17 +478,17 @@ ldns_resolver_new_frm_fp(FILE *fp)
                                                dprintf("[%s] unreg keyword\n", word); 
                                }
                                break;
-                       case RESOLV_DEFDOMAIN:
+                       case LDNS_RESOLV_DEFDOMAIN:
                                /* default domain dname */
                                tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, word);
                                if (!tmp) {
-                                       expect = RESOLV_KEYWORD;
+                                       expect = LDNS_RESOLV_KEYWORD;
                                        break;
                                }
                                ldns_resolver_set_domain(r, tmp);
-                               expect = RESOLV_KEYWORD;
+                               expect = LDNS_RESOLV_KEYWORD;
                                break;
-                       case RESOLV_NAMESERVER:
+                       case LDNS_RESOLV_NAMESERVER:
                                /* NS aaaa or a record */
                                tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, word);
                                if (!tmp) {
@@ -496,16 +496,16 @@ ldns_resolver_new_frm_fp(FILE *fp)
                                        tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, word);
                                }
                                if (!tmp) {
-                                       expect = RESOLV_KEYWORD;
+                                       expect = LDNS_RESOLV_KEYWORD;
                                        break;
                                }
                                (void)ldns_resolver_push_nameserver(r, tmp);
-                               expect = RESOLV_KEYWORD;
+                               expect = LDNS_RESOLV_KEYWORD;
                                break;
                        default:
                                /* huh?! */
                                dprintf("%s", "BIG FAT WARNING should never reach this\n");
-                               expect = RESOLV_KEYWORD;
+                               expect = LDNS_RESOLV_KEYWORD;
                                break;
                }
                gtr = ldns_fget_token(fp, word, LDNS_PARSE_NORMAL, 0);
@@ -522,7 +522,7 @@ ldns_resolver_new_frm_file(const char *filename)
        FILE *fp;
 
        if (!filename) {
-               fp = fopen(RESOLV_CONF, "r");
+               fp = fopen(LDNS_RESOLV_CONF, "r");
 
        } else {
                fp = fopen(filename, "r");
@@ -781,7 +781,7 @@ ldns_axfr_start(ldns_resolver *resolver,
        /* Convert the query to a buffer
         * Is this necessary?
         */
-       query_wire = ldns_buffer_new(MAX_PACKETLEN);
+       query_wire = ldns_buffer_new(LDNS_MAX_PACKETLEN);
        status = ldns_pkt2buffer_wire(query_wire, query);
        if (status != LDNS_STATUS_OK) {
                        ldns_pkt_free(query);

diff --git a/rr.c b/rr.c
index 3936b1879605ef6481909586c7cb84d99484d2c3..6989251efb9e774bd3b2822b56ebeaa190bcd700 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -115,14 +115,14 @@ ldns_rr_new_frm_str(const char *str)
 
        new = ldns_rr_new();
 
-       owner = LDNS_XMALLOC(char, MAX_DOMAINLEN + 1);
+       owner = LDNS_XMALLOC(char, LDNS_MAX_DOMAINLEN + 1);
        ttl = LDNS_XMALLOC(char, 21);
        clas = LDNS_XMALLOC(char, 11);
        type = LDNS_XMALLOC(char, 10);
-       rdata = LDNS_XMALLOC(char, MAX_PACKETLEN + 1);
+       rdata = LDNS_XMALLOC(char, LDNS_MAX_PACKETLEN + 1);
        rr_buf = LDNS_MALLOC(ldns_buffer);
        rd_buf = LDNS_MALLOC(ldns_buffer);
-       rd = LDNS_XMALLOC(char, MAX_RDFLEN);
+       rd = LDNS_XMALLOC(char, LDNS_MAX_RDFLEN);
        if (!owner || !ttl || !clas || !type || !rdata ||
                        !rr_buf || !rd_buf || !rd) {
                return NULL;
@@ -136,7 +136,7 @@ ldns_rr_new_frm_str(const char *str)
        ldns_buffer_new_frm_data(rr_buf, no_comment_str, strlen(no_comment_str));
        
        /* split the rr in its parts -1 signals trouble */
-       if (ldns_bget_token(rr_buf, owner, "\t\n ", MAX_DOMAINLEN) == -1) {
+       if (ldns_bget_token(rr_buf, owner, "\t\n ", LDNS_MAX_DOMAINLEN) == -1) {
                LDNS_FREE(owner); 
                LDNS_FREE(ttl); 
                LDNS_FREE(clas); 
@@ -191,7 +191,7 @@ ldns_rr_new_frm_str(const char *str)
                ldns_buffer_free(rr_buf);
                return NULL;
        }
-       if (ldns_bget_token(rr_buf, rdata, "\0", MAX_PACKETLEN) == -1) {
+       if (ldns_bget_token(rr_buf, rdata, "\0", LDNS_MAX_PACKETLEN) == -1) {
                LDNS_FREE(owner); 
                LDNS_FREE(ttl); 
                LDNS_FREE(clas); 
@@ -231,7 +231,7 @@ ldns_rr_new_frm_str(const char *str)
                        /* blalba do something different */
                        break;
                default:
-                       while((c = ldns_bget_token(rd_buf, rd, "\t\n ", MAX_RDFLEN)) != -1) {
+                       while((c = ldns_bget_token(rd_buf, rd, "\t\n ", LDNS_MAX_RDFLEN)) != -1) {
                                r = ldns_rdf_new_frm_str(
                                                ldns_rr_descriptor_field_type(desc, r_cnt),
                                                rd);
@@ -249,13 +249,13 @@ ldns_rr_new_frm_fp(FILE *fp)
 {
         char *line;
 
-        line = LDNS_XMALLOC(char, MAXLINE_LEN + 1);
+        line = LDNS_XMALLOC(char, LDNS_MAX_LINELEN + 1);
         if (!line) {
                 return NULL;
         }
 
         /* read an entire line in from the file */
-        if (ldns_fget_token(fp, line, LDNS_PARSE_SKIP_SPACE, MAXLINE_LEN) == -1) {
+        if (ldns_fget_token(fp, line, LDNS_PARSE_SKIP_SPACE, LDNS_MAX_LINELEN) == -1) {
                 return NULL;
         }
         return ldns_rr_new_frm_str((const char*) line);
@@ -465,7 +465,7 @@ ldns_rr_list_cat(ldns_rr_list *left, ldns_rr_list *right)
                r_rr_count = ldns_rr_list_rr_count(right);
        }
        
-       if (l_rr_count + r_rr_count > MAX_RR ) {
+       if (l_rr_count + r_rr_count > LDNS_MAX_RR ) {
                /* overflow error */
                return NULL;
        }
@@ -782,7 +782,7 @@ ldns_rr_uncompressed_size(const ldns_rr *r)
        }
        /* ownername */
        rrsize += ldns_rdf_size(ldns_rr_owner(r));
-       rrsize += RR_OVERHEAD;
+       rrsize += LDNS_RR_OVERHEAD;
        return rrsize;
 }
 
@@ -1256,13 +1256,13 @@ static ldns_rr_descriptor rdata_field_descriptors[] = {
  * \def RDATA_FIELD_DESCRIPTORS_COUNT
  * computes the number of rdata fields
  */
-#define RDATA_FIELD_DESCRIPTORS_COUNT \
+#define LDNS_RDATA_FIELD_DESCRIPTORS_COUNT \
        (sizeof(rdata_field_descriptors)/sizeof(rdata_field_descriptors[0]))
 
 const ldns_rr_descriptor *
 ldns_rr_descript(uint16_t type)
 {
-       if (type < RDATA_FIELD_DESCRIPTORS_COUNT) {
+       if (type < LDNS_RDATA_FIELD_DESCRIPTORS_COUNT) {
                return &rdata_field_descriptors[type];
        } else {
                return &rdata_field_descriptors[0];
@@ -1313,7 +1313,7 @@ ldns_get_rr_type_by_name(const char *name)
        }
 
        /* Normal types */
-       for (i = 0; i < (unsigned int) RDATA_FIELD_DESCRIPTORS_COUNT; i++) {
+       for (i = 0; i < (unsigned int) LDNS_RDATA_FIELD_DESCRIPTORS_COUNT; i++) {
                desc = ldns_rr_descript(i);
                desc_name = desc->_name;
                if(desc_name &&

diff --git a/run-test0.c b/run-test0.c
index d03136a90b0e2b7d9d413772ec8411d92c096741..1ab97df18693ab5c874b847c100b62fce6af17fd 100644 (file)
--- a/run-test0.c
+++ b/run-test0.c
@@ -52,7 +52,7 @@ main(void)
        
        rr = ldns_rr_new();
 
-       rdf_data = (uint8_t *) LDNS_XMALLOC(char, MAX_DOMAINLEN);
+       rdf_data = (uint8_t *) LDNS_XMALLOC(char, LDNS_MAX_DOMAINLEN);
        rdf_data[0] = 3;
        memcpy(rdf_data+1, "www", 3);
        rdf_data[4] = 4;

diff --git a/str2host.c b/str2host.c
index 2d97553ac0a767485a970d8912ecf4edbc400564..dc49949ead667809b200244c4452ed21b202ff90 100644 (file)
--- a/str2host.c
+++ b/str2host.c
@@ -152,11 +152,11 @@ ldns_str2rdf_dname(ldns_rdf **d, const char *str)
        size_t len;
 
        uint8_t *s,*p,*q, *pq, val, label_len;
-       uint8_t buf[MAX_DOMAINLEN + 1];
+       uint8_t buf[LDNS_MAX_DOMAINLEN + 1];
        *d = NULL;
        
        len = strlen((char*)str);
-       if (len > MAX_DOMAINLEN) {
+       if (len > LDNS_MAX_DOMAINLEN) {
                return LDNS_STATUS_DOMAINNAME_OVERFLOW;
        }
        if (0 == len) {
@@ -184,7 +184,7 @@ ldns_str2rdf_dname(ldns_rdf **d, const char *str)
                switch (*s) {
                case '.':
                        /* todo: check length (overflow und <1 */
-                       if (label_len > MAX_LABELLEN) {
+                       if (label_len > LDNS_MAX_LABELLEN) {
                                return LDNS_STATUS_LABEL_OVERFLOW;
                        }
                        if (label_len == 0) {
@@ -310,7 +310,7 @@ ldns_str2rdf_hex(ldns_rdf **rd, const char *str)
 
         if (len % 2 != 0) {
                 return LDNS_STATUS_INVALID_HEX;
-        } else if (len > MAX_RDFLEN * 2) {
+        } else if (len > LDNS_MAX_RDFLEN * 2) {
                return LDNS_STATUS_LABEL_OVERFLOW;
         } else {
                t = LDNS_XMALLOC(uint8_t, (len / 2));

diff --git a/wire2host.c b/wire2host.c
index b561bd28b345a1c95b7292ec20ff7d9d4b0a9031..69cc41a4c3b407b4ab86cfaecbfcc7bb76609152 100644 (file)
--- a/wire2host.c
+++ b/wire2host.c
@@ -59,7 +59,7 @@ ldns_wire2dname(ldns_rdf **dname, const uint8_t *wire, size_t max, size_t *pos)
        size_t dname_pos = 0;
        size_t uncompressed_length = 0;
        size_t compression_pos = 0;
-       uint8_t tmp_dname[MAX_DOMAINLEN];
+       uint8_t tmp_dname[LDNS_MAX_DOMAINLEN];
        uint8_t *dname_ar;
        unsigned int pointer_count = 0;
        
@@ -86,13 +86,13 @@ ldns_wire2dname(ldns_rdf **dname, const uint8_t *wire, size_t max, size_t *pos)
                                return LDNS_STATUS_INVALID_POINTER;
                        } else if (pointer_target > max) {
                                return LDNS_STATUS_INVALID_POINTER;
-                       } else if (pointer_count > MAX_POINTERS) {
+                       } else if (pointer_count > LDNS_MAX_POINTERS) {
                                return LDNS_STATUS_INVALID_POINTER;
                        }
                        *pos = pointer_target;
                        label_size = wire[*pos];
                }
-               if (label_size > MAX_LABELLEN) {
+               if (label_size > LDNS_MAX_LABELLEN) {
                        return LDNS_STATUS_LABEL_OVERFLOW;
                }
                if (*pos + label_size > max) {
@@ -137,8 +137,8 @@ ldns_wire2dname(ldns_rdf **dname, const uint8_t *wire, size_t max, size_t *pos)
 }
 
 /* maybe make this a goto error so data can be freed or something/ */
-#define STATUS_CHECK_RETURN(st) {if (st != LDNS_STATUS_OK) { printf("STR %d\n", __LINE__); return st; }}
-#define STATUS_CHECK_GOTO(st, label) {if (st != LDNS_STATUS_OK) { printf("STG %s:%d: status code %d\n", __FILE__, __LINE__, st);  goto label; }}
+#define LDNS_STATUS_CHECK_RETURN(st) {if (st != LDNS_STATUS_OK) { printf("STR %d\n", __LINE__); return st; }}
+#define LDNS_STATUS_CHECK_GOTO(st, label) {if (st != LDNS_STATUS_OK) { printf("STG %s:%d: status code %d\n", __FILE__, __LINE__, st);  goto label; }}
 
 ldns_status
 ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire,
@@ -186,7 +186,7 @@ ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire,
                case LDNS_RDF_TYPE_DNAME:
                        status = ldns_wire2dname(&cur_rdf, wire, max,
                                                 pos);
-                       STATUS_CHECK_RETURN(status);
+                       LDNS_STATUS_CHECK_RETURN(status);
                        break;
                case LDNS_RDF_TYPE_CLASS:
                case LDNS_RDF_TYPE_ALG:
@@ -275,7 +275,7 @@ ldns_wire2rr(ldns_rr **rr_p, const uint8_t *wire, size_t max,
        ldns_status status;
        
        status = ldns_wire2dname(&owner, wire, max, pos);
-       STATUS_CHECK_GOTO(status, status_error);
+       LDNS_STATUS_CHECK_GOTO(status, status_error);
 
        ldns_rr_set_owner(rr, owner);
        
@@ -290,7 +290,7 @@ ldns_wire2rr(ldns_rr **rr_p, const uint8_t *wire, size_t max,
                ldns_rr_set_ttl(rr, read_uint32(&wire[*pos]));  
                *pos = *pos + 4;
                status = ldns_wire2rdf(rr, wire, max, pos);
-               STATUS_CHECK_GOTO(status, status_error);
+               LDNS_STATUS_CHECK_GOTO(status, status_error);
        }
        
        *rr_p = rr;
@@ -346,7 +346,7 @@ ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
        uint8_t data[4];
        
        status = ldns_wire2pkt_hdr(packet, wire, max, &pos);
-       STATUS_CHECK_GOTO(status, status_error);
+       LDNS_STATUS_CHECK_GOTO(status, status_error);
        
        for (i = 0; i < ldns_pkt_qdcount(packet); i++) {
                status = ldns_wire2rr(&rr, wire, max, &pos,
@@ -354,7 +354,7 @@ ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
                if (!ldns_rr_list_push_rr(ldns_pkt_question(packet), rr)) {
                        return LDNS_STATUS_INTERNAL_ERR;
                }
-               STATUS_CHECK_GOTO(status, status_error);
+               LDNS_STATUS_CHECK_GOTO(status, status_error);
        }
        for (i = 0; i < ldns_pkt_ancount(packet); i++) {
                status = ldns_wire2rr(&rr, wire, max, &pos,
@@ -362,7 +362,7 @@ ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
                if (!ldns_rr_list_push_rr(ldns_pkt_answer(packet), rr)) {
                        return LDNS_STATUS_INTERNAL_ERR;
                }
-               STATUS_CHECK_GOTO(status, status_error);
+               LDNS_STATUS_CHECK_GOTO(status, status_error);
        }
        for (i = 0; i < ldns_pkt_nscount(packet); i++) {
                status = ldns_wire2rr(&rr, wire, max, &pos,
@@ -370,7 +370,7 @@ ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
                if (!ldns_rr_list_push_rr(ldns_pkt_authority(packet), rr)) {
                        return LDNS_STATUS_INTERNAL_ERR;
                }
-               STATUS_CHECK_GOTO(status, status_error);
+               LDNS_STATUS_CHECK_GOTO(status, status_error);
        }
        for (i = 0; i < ldns_pkt_arcount(packet); i++) {
                status = ldns_wire2rr(&rr, wire, max, &pos,
@@ -390,7 +390,7 @@ ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
                } else if (!ldns_rr_list_push_rr(ldns_pkt_additional(packet), rr)) {
                        return LDNS_STATUS_INTERNAL_ERR;
                }
-               STATUS_CHECK_GOTO(status, status_error);
+               LDNS_STATUS_CHECK_GOTO(status, status_error);
        }
 
        *packet_p = packet;