s/aaaa_short/aaaa_half/gI

diff --git a/contrib/python/ldns_rdf.i b/contrib/python/ldns_rdf.i
index 57436b4026e9b48f4baf09e0f9d6798852c8cae4..b085d33b4ddd2e0c06a01079e241f2a828e495f8 100644 (file)
--- a/contrib/python/ldns_rdf.i
+++ b/contrib/python/ldns_rdf.i
@@ -216,7 +216,7 @@
                        case LDNS_RDF_TYPE_NSEC3_SALT: return "NSEC3_SALT";
                        case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
                            return "NSEC3_NEXT_OWNER";
-                       case LDNS_RDF_TYPE_AAAA_SHORT:   return "AAAA_SHORT";
+                       case LDNS_RDF_TYPE_AAAA_HALF:   return "AAAA_HALF";
                        }
                }
                return 0;

diff --git a/error.c b/error.c
index 1a7b474cb2c061c4d1f77da68649bdfb22962e7f..3fb3b5dc6fa5d64267164c5405899bd1b020660b 100644 (file)
--- a/error.c
+++ b/error.c
@@ -125,7 +125,7 @@ ldns_lookup_table ldns_error_str[] = {
        { LDNS_STATUS_DANE_PKIX_NO_SELF_SIGNED_TRUST_ANCHOR,
                "The validation path "
                "did not end in a self-signed certificate" },
-        { LDNS_STATUS_INVALID_AAAA_SHORT, 
+        { LDNS_STATUS_INVALID_AAAA_HALF, 
                "Conversion error, 4 colon seperated hex numbers expected" },
        { 0, NULL }
 };

diff --git a/host2str.c b/host2str.c
index 72b3b52c9b72dba22aded4c76fbd7c6d037a02f4..03a31bfe4975e94be4cf253656fbe5b75e7a93ee 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -1050,7 +1050,7 @@ ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_aaaa_short(ldns_buffer *output, const ldns_rdf *rdf)
+ldns_rdf2buffer_str_aaaa_half(ldns_buffer *output, const ldns_rdf *rdf)
 {
        ldns_buffer_printf(output,"%.4x:%.4x:%.4d:%.4x",
                                ldns_read_uint16(ldns_rdf_data(rdf)),
@@ -1158,8 +1158,8 @@ ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
                case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
                        res = ldns_rdf2buffer_str_b32_ext(buffer, rdf);
                        break;
-               case LDNS_RDF_TYPE_AAAA_SHORT:
-                       res = ldns_rdf2buffer_str_aaaa_short(buffer, rdf);
+               case LDNS_RDF_TYPE_AAAA_HALF:
+                       res = ldns_rdf2buffer_str_aaaa_half(buffer, rdf);
                        break;
                }
        } else {

diff --git a/ldns/error.h b/ldns/error.h
index e10fb7edf9c453d7e1ace2c707c1443a1dff33df..bd18564c17170c788323cff0d65ae42a59ec43a0 100644 (file)
--- a/ldns/error.h
+++ b/ldns/error.h
@@ -119,7 +119,7 @@ enum ldns_enum_status {
        LDNS_STATUS_DANE_PKIX_DID_NOT_VALIDATE,
        LDNS_STATUS_DANE_PKIX_NO_SELF_SIGNED_TRUST_ANCHOR,
        LDNS_STATUS_EXISTS_ERR,
-       LDNS_STATUS_INVALID_AAAA_SHORT
+       LDNS_STATUS_INVALID_AAAA_HALF
 };
 typedef enum ldns_enum_status ldns_status;
 

diff --git a/ldns/host2str.h b/ldns/host2str.h
index 1f1a3099fb29ee420d7b3e184e56558d1dbbe7d8..792248e384b6f8114122f3414ea15a1460201bea 100644 (file)
--- a/ldns/host2str.h
+++ b/ldns/host2str.h
@@ -519,13 +519,13 @@ ldns_status ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf);
 ldns_status ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
- * Converts an LDNS_RDF_TYPE_AAAA_SHORT rdata element to 4 hexadecimal numbers
+ * Converts an LDNS_RDF_TYPE_AAAA_HALF rdata element to 4 hexadecimal numbers
  * seperated by colons and adds it to the output buffer 
  * \param[in] *rdf The rdata to convert
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_aaaa_short(ldns_buffer *output,
+ldns_status ldns_rdf2buffer_str_aaaa_half(ldns_buffer *output,
                const ldns_rdf *rdf);
 
 /**

diff --git a/ldns/rdata.h b/ldns/rdata.h
index 8fb2efa90640040a25747cd210f7467d8fabef18..fd36bb4e0ac80d11e7e051e4332091a20a87ab23 100644 (file)
--- a/ldns/rdata.h
+++ b/ldns/rdata.h
@@ -107,7 +107,7 @@ enum ldns_enum_rdf_type
        /** nsec3 base32 string (with length byte on wire */
        LDNS_RDF_TYPE_NSEC3_NEXT_OWNER,
        /** 4 shorts represented as 4 * 16 bit hex numbers seperated by colons */
-       LDNS_RDF_TYPE_AAAA_SHORT
+       LDNS_RDF_TYPE_AAAA_HALF
 };
 typedef enum ldns_enum_rdf_type ldns_rdf_type;
 

diff --git a/ldns/str2host.h b/ldns/str2host.h
index e9186972af936c045fae64a48fb59a370166f954..f534d679a2b021d9f4d08f3372d9e9a58750a686 100644 (file)
--- a/ldns/str2host.h
+++ b/ldns/str2host.h
@@ -250,7 +250,7 @@ ldns_status ldns_str2rdf_dname(ldns_rdf **rd, const char *str);
  * \param[in] str the string to be converted
  * \return ldns_status
  */
-ldns_status ldns_str2rdf_aaaa_short(ldns_rdf **rd, const char *str);
+ldns_status ldns_str2rdf_aaaa_half(ldns_rdf **rd, const char *str);
 
 #ifdef __cplusplus
 }

diff --git a/rdata.c b/rdata.c
index cbc9a8d68730d84ce92226a5b4d6005eeeb33553..1ae1372d432204bc33a17f58d5af4ba39f34c4df 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -336,8 +336,8 @@ ldns_rdf_new_frm_str(ldns_rdf_type type, const char *str)
        case LDNS_RDF_TYPE_NSEC3_NEXT_OWNER:
                status = ldns_str2rdf_b32_ext(&rdf, str);
                break;
-       case LDNS_RDF_TYPE_AAAA_SHORT:
-               status = ldns_str2rdf_aaaa_short(&rdf, str);
+       case LDNS_RDF_TYPE_AAAA_HALF:
+               status = ldns_str2rdf_aaaa_half(&rdf, str);
                break;
        case LDNS_RDF_TYPE_NONE:
        default:

diff --git a/rr.c b/rr.c
index dc31d959418adb158416301267c1964e87a3717d..3b07b99329c848b6d758465a488e844789eb65b0 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -1960,7 +1960,7 @@ static const ldns_rdf_type type_tlsa_wireformat[] = {
 };
 static const ldns_rdf_type type_nid_wireformat[] = {
        LDNS_RDF_TYPE_INT16,
-       LDNS_RDF_TYPE_AAAA_SHORT
+       LDNS_RDF_TYPE_AAAA_HALF
 };
 static const ldns_rdf_type type_l32_wireformat[] = {
        LDNS_RDF_TYPE_INT16,
@@ -1968,7 +1968,7 @@ static const ldns_rdf_type type_l32_wireformat[] = {
 };
 static const ldns_rdf_type type_l64_wireformat[] = {
        LDNS_RDF_TYPE_INT16,
-       LDNS_RDF_TYPE_AAAA_SHORT
+       LDNS_RDF_TYPE_AAAA_HALF
 };
 static const ldns_rdf_type type_lp_wireformat[] = {
        LDNS_RDF_TYPE_INT16,

diff --git a/str2host.c b/str2host.c
index fcd23c291d2a8bfe2ebbada2e8eebcd391176265..ffeb07deb23e6c2c484c75121bd72a1fd561930a 100644 (file)
--- a/str2host.c
+++ b/str2host.c
@@ -1319,20 +1319,20 @@ ldns_str2rdf_ipseckey(ldns_rdf **rd, const char *str)
 }
 
 ldns_status
-ldns_str2rdf_aaaa_short(ldns_rdf **rd, const char *str)
+ldns_str2rdf_aaaa_half(ldns_rdf **rd, const char *str)
 {
        unsigned int a, b, c, d;
        uint16_t shorts[4];
 
        if (sscanf(str, "%x:%x:%x:%x", &a, &b, &c, &d) == EOF) {
-               return LDNS_STATUS_INVALID_AAAA_SHORT;
+               return LDNS_STATUS_INVALID_AAAA_HALF;
        } else {
                shorts[0] = htons(shorts[0]);
                shorts[1] = htons(shorts[1]);
                shorts[2] = htons(shorts[2]);
                shorts[3] = htons(shorts[3]);
                *rd = ldns_rdf_new_frm_data(
-                       LDNS_RDF_TYPE_AAAA_SHORT, 4 * sizeof(uint16_t), &shorts);
+                       LDNS_RDF_TYPE_AAAA_HALF, 4 * sizeof(uint16_t), &shorts);
        }
        return *rd ? LDNS_STATUS_OK : LDNS_STATUS_MEM_ERR;
 }

diff --git a/wire2host.c b/wire2host.c
index 8c38be5af0e9235a66f169b863548aa56062c53c..28dedede3baa3fdaba129d6baf5b2d1b5ddb2f3d 100644 (file)
--- a/wire2host.c
+++ b/wire2host.c
@@ -212,7 +212,7 @@ ldns_wire2rdf(ldns_rr *rr, const uint8_t *wire, size_t max, size_t *pos)
                case LDNS_RDF_TYPE_TSIGTIME:
                        cur_rdf_length = LDNS_RDF_SIZE_6BYTES;
                        break;
-               case LDNS_RDF_TYPE_AAAA_SHORT:
+               case LDNS_RDF_TYPE_AAAA_HALF:
                        cur_rdf_length = LDNS_RDF_SIZE_8BYTES;
                        break;
                case LDNS_RDF_TYPE_AAAA: