Use "char *" for text representation instead of "uint8_t *".

diff --git a/ldns/str2host.h b/ldns/str2host.h
index 9b5fd4e886ab3f6534eb50d590cfc6c2ac6b0d6c..3691550f4c5df04c7c5eaa65e668aa40b87d0002 100644 (file)
--- a/ldns/str2host.h
+++ b/ldns/str2host.h
@@ -10,28 +10,28 @@
 #include <ldns/buffer.h>
 #include <ctype.h>
 
-ldns_status ldns_str2rdf_int8(ldns_rdf **, const uint8_t *);
-ldns_status ldns_str2rdf_int16(ldns_rdf **, const uint8_t *);
-ldns_status ldns_str2rdf_int32(ldns_rdf **, const uint8_t *);
-ldns_status ldns_str2rdf_time(ldns_rdf **, const uint8_t *);
-ldns_status ldns_str2rdf_a(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_aaaa(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_str(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_apl(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_b64(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_hex(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_nsec(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_type(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_class(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_cert(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_alg(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_unknown(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_tsigtime(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_service(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_loc(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_wks(ldns_rdf **, const uint8_t*);
-ldns_status ldns_str2rdf_nsap(ldns_rdf **, const uint8_t*);
+ldns_status ldns_str2rdf_int8(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_int16(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_int32(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_time(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_a(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_aaaa(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_str(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_apl(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_b64(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_hex(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_nsec(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_type(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_class(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_cert(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_alg(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_unknown(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_tsigtime(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_service(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_loc(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_wks(ldns_rdf **, const char *);
+ldns_status ldns_str2rdf_nsap(ldns_rdf **, const char *);
 
-ldns_status ldns_str2rdf_dname(ldns_rdf **, const uint8_t*);
+ldns_status ldns_str2rdf_dname(ldns_rdf **, const char *);
 
 #endif

diff --git a/packet.c b/packet.c
index 6de2333a75627848936aa6b408095b6f5456e4c0..33ba6f46717605266e2be0e1a9bd31e5a9437336 100644 (file)
--- a/packet.c
+++ b/packet.c
@@ -426,7 +426,7 @@ ldns_pkt_query_new_frm_str(const char *name, ldns_rr_type rr_type, ldns_rr_class
                rr_class = LDNS_RR_CLASS_IN;
        }
 
-       if (ldns_str2rdf_dname(&name_rdf, (const uint8_t *) name) == LDNS_STATUS_OK) {
+       if (ldns_str2rdf_dname(&name_rdf, name) == LDNS_STATUS_OK) {
                ldns_rr_set_owner(question_rr, name_rdf);
                ldns_rr_set_type(question_rr, rr_type);
                ldns_rr_set_class(question_rr, rr_class);

diff --git a/rdata.c b/rdata.c
index f0be8b38d5114d59c4040399c3b6f412dc57982d..8dd738436d97e381ef6f8aeac83459547228b402 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -267,70 +267,70 @@ ldns_rdf_new_frm_str(const char *str, ldns_rdf_type type)
        
        switch (type) {
        case LDNS_RDF_TYPE_DNAME:
-               status = ldns_str2rdf_dname(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_dname(&rdf, str);
                break;
        case LDNS_RDF_TYPE_INT8:
-               status = ldns_str2rdf_int8(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_int8(&rdf, str);
                break;
        case LDNS_RDF_TYPE_INT16:
-               status = ldns_str2rdf_int16(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_int16(&rdf, str);
                break;
        case LDNS_RDF_TYPE_INT32:
-               status = ldns_str2rdf_int32(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_int32(&rdf, str);
                break;
        case LDNS_RDF_TYPE_A:
-               status = ldns_str2rdf_a(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_a(&rdf, str);
                break;
        case LDNS_RDF_TYPE_AAAA:
-               status = ldns_str2rdf_aaaa(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_aaaa(&rdf, str);
                break;
        case LDNS_RDF_TYPE_STR:
-               status = ldns_str2rdf_str(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_str(&rdf, str);
                break;
        case LDNS_RDF_TYPE_APL:
-               status = ldns_str2rdf_apl(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_apl(&rdf, str);
                break;
        case LDNS_RDF_TYPE_B64:
-               status = ldns_str2rdf_b64(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_b64(&rdf, str);
                break;
        case LDNS_RDF_TYPE_HEX:
-               status = ldns_str2rdf_hex(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_hex(&rdf, str);
                break;
        case LDNS_RDF_TYPE_NSEC:
-               status = ldns_str2rdf_nsec(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_nsec(&rdf, str);
                break;
        case LDNS_RDF_TYPE_TYPE:
-               status = ldns_str2rdf_type(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_type(&rdf, str);
                break;
        case LDNS_RDF_TYPE_CLASS:
-               status = ldns_str2rdf_class(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_class(&rdf, str);
                break;
        case LDNS_RDF_TYPE_CERT:
-               status = ldns_str2rdf_cert(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_cert(&rdf, str);
                break;
        case LDNS_RDF_TYPE_ALG:
-               status = ldns_str2rdf_alg(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_alg(&rdf, str);
                break;
        case LDNS_RDF_TYPE_UNKNOWN:
-               status = ldns_str2rdf_unknown(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_unknown(&rdf, str);
                break;
        case LDNS_RDF_TYPE_TIME:
-               status = ldns_str2rdf_time(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_time(&rdf, str);
                break;
        case LDNS_RDF_TYPE_TSIGTIME:
-               status = ldns_str2rdf_tsigtime(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_tsigtime(&rdf, str);
                break;
        case LDNS_RDF_TYPE_SERVICE:
-               status = ldns_str2rdf_service(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_service(&rdf, str);
                break;
        case LDNS_RDF_TYPE_LOC:
-               status = ldns_str2rdf_loc(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_loc(&rdf, str);
                break;
        case LDNS_RDF_TYPE_WKS:
-               status = ldns_str2rdf_wks(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_wks(&rdf, str);
                break;
        case LDNS_RDF_TYPE_NSAP:
-               status = ldns_str2rdf_nsap(&rdf, (const uint8_t*) str);
+               status = ldns_str2rdf_nsap(&rdf, str);
                break;
        case LDNS_RDF_TYPE_NONE:
        default:

diff --git a/run-test1.c b/run-test1.c
index ca712d31a5a47c04bf96a689f7e2c9e0836b0c3d..831404648ecd3426c6eb5948278563f308d322c4 100644 (file)
--- a/run-test1.c
+++ b/run-test1.c
@@ -45,7 +45,7 @@ doit(void)
        }
 
        printf("Setting 15242\n");
-       if (ldns_str2rdf_int16(&rdata, (uint8_t *) "15242") != LDNS_STATUS_OK) {
+       if (ldns_str2rdf_int16(&rdata, "15242") != LDNS_STATUS_OK) {
                printf("_short: ah man, shit hit the fan\n");
        }
        
@@ -90,11 +90,11 @@ int
 main(void)
 {
        ldns_rdf *bla;
-       if (ldns_str2rdf_int16(&bla, (uint8_t *) "15242") != LDNS_STATUS_OK) {
+       if (ldns_str2rdf_int16(&bla, "15242") != LDNS_STATUS_OK) {
                printf("_int16: ah man, shit hit the fan\n");
        }
        /* %Y%m%d%H%M%S */
-       if (ldns_str2rdf_time(&bla, (uint8_t *) "20041222134100") != LDNS_STATUS_OK) {
+       if (ldns_str2rdf_time(&bla, "20041222134100") != LDNS_STATUS_OK) {
                printf("_time: ah man, shit hit the fan\n");
        }
 

diff --git a/run-test3.c b/run-test3.c
index 37e70af4bcdca2ac2c9d4b3d9848d7c13c2948e3..c4e1eab5358b311f9e9b2435e12754412beef705 100644 (file)
--- a/run-test3.c
+++ b/run-test3.c
@@ -17,13 +17,13 @@ main(void)
        ldns_rdf *rd;
 
        fprintf(stdout, "www.\n");
-       (void) ldns_str2rdf_dname(&rd, (uint8_t *) "www.");
+       (void) ldns_str2rdf_dname(&rd, "www.");
        fprintf(stdout, "www.miek.nl\n");
-       (void) ldns_str2rdf_dname(&rd, (uint8_t *) "www.miek.nl");
+       (void) ldns_str2rdf_dname(&rd, "www.miek.nl");
        fprintf(stdout, "www\n");
-       (void) ldns_str2rdf_dname(&rd, (uint8_t *) "www");
+       (void) ldns_str2rdf_dname(&rd, "www");
        fprintf(stdout, "www.miek.nl..\n");
-       (void) ldns_str2rdf_dname(&rd, (uint8_t *) "www.miek.nl..");
+       (void) ldns_str2rdf_dname(&rd, "www.miek.nl..");
 
        return 0;
 }

diff --git a/str2host.c b/str2host.c
index 426a2796d79e4f036bedb5e517621e49a66a8f8e..1cf0f56df500066a1f2578c91d8321033aa98c9f 100644 (file)
--- a/str2host.c
+++ b/str2host.c
@@ -35,7 +35,7 @@
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_int16(ldns_rdf **rd, const uint8_t *shortstr)
+ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
 {
        char *end = NULL;    
        uint16_t *r;
@@ -59,7 +59,7 @@ ldns_str2rdf_int16(ldns_rdf **rd, const uint8_t *shortstr)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_time(ldns_rdf **rd, const uint8_t *time)
+ldns_str2rdf_time(ldns_rdf **rd, const char *time)
 {
        /* convert a time YYHM to wireformat */
        uint16_t *r = NULL;
@@ -87,7 +87,7 @@ ldns_str2rdf_time(ldns_rdf **rd, const uint8_t *time)
  * \return ldns_status
  */
 ldns_status 
-ldns_str2rdf_int32(ldns_rdf **rd, const uint8_t *longstr)
+ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
 {
        char *end;  
        uint16_t *r = NULL;
@@ -113,7 +113,7 @@ ldns_str2rdf_int32(ldns_rdf **rd, const uint8_t *longstr)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_int8(ldns_rdf **rd, const uint8_t *bytestr)
+ldns_str2rdf_int8(ldns_rdf **rd, const char *bytestr)
 {
        char *end;     
        uint8_t *r = NULL;
@@ -145,7 +145,7 @@ ldns_str2rdf_int8(ldns_rdf **rd, const uint8_t *bytestr)
  * label_chars2 is used for debugging. TODO: remove
  */
 ldns_status
-ldns_str2rdf_dname(ldns_rdf **d, const uint8_t* str)
+ldns_str2rdf_dname(ldns_rdf **d, const char *str)
 {
        unsigned int label_chars;
        unsigned int label_chars2;
@@ -227,7 +227,7 @@ ldns_str2rdf_dname(ldns_rdf **d, const uint8_t* str)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_a(ldns_rdf **rd, const uint8_t* str)
+ldns_str2rdf_a(ldns_rdf **rd, const char *str)
 {
        in_addr_t address;
         if (inet_pton(AF_INET, (char*)str, &address) != 1) {
@@ -245,7 +245,7 @@ ldns_str2rdf_a(ldns_rdf **rd, const uint8_t* str)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_aaaa(ldns_rdf **rd, const uint8_t* str)
+ldns_str2rdf_aaaa(ldns_rdf **rd, const char *str)
 {
        uint8_t address[LDNS_IP6ADDRLEN];
 
@@ -264,7 +264,7 @@ ldns_str2rdf_aaaa(ldns_rdf **rd, const uint8_t* str)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_str(ldns_rdf **rd, const uint8_t* str)
+ldns_str2rdf_str(ldns_rdf **rd, const char *str)
 {
        if (strlen((char *) str) > 255) {
                return LDNS_STATUS_INVALID_STR;
@@ -280,7 +280,7 @@ ldns_str2rdf_str(ldns_rdf **rd, const uint8_t* str)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_apl(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_apl(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -292,7 +292,7 @@ ldns_str2rdf_apl(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_b64(ldns_rdf **rd, const uint8_t* str)
+ldns_str2rdf_b64(ldns_rdf **rd, const char *str)
 {
        uint8_t buffer[B64BUFSIZE];
        int16_t i;
@@ -313,7 +313,7 @@ ldns_str2rdf_b64(ldns_rdf **rd, const uint8_t* str)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_hex(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_hex(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -325,7 +325,7 @@ ldns_str2rdf_hex(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_nsec(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_nsec(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -337,7 +337,7 @@ ldns_str2rdf_nsec(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_type(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_type(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -349,7 +349,7 @@ ldns_str2rdf_type(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_class(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_class(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -361,7 +361,7 @@ ldns_str2rdf_class(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_cert(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_cert(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -373,7 +373,7 @@ ldns_str2rdf_cert(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_alg(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_alg(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -385,7 +385,7 @@ ldns_str2rdf_alg(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_unknown(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_unknown(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -397,7 +397,7 @@ ldns_str2rdf_unknown(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_tsigtime(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_tsigtime(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -409,7 +409,7 @@ ldns_str2rdf_tsigtime(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_service(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_service(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -421,7 +421,7 @@ ldns_str2rdf_service(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str)
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_loc(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_loc(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -433,7 +433,7 @@ ldns_str2rdf_loc(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_wks(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_wks(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }
@@ -445,7 +445,7 @@ ldns_str2rdf_wks(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
  * \return ldns_status
  */
 ldns_status
-ldns_str2rdf_nsap(ldns_rdf **ATTR_UNUSED(rd), const uint8_t *ATTR_UNUSED(str))
+ldns_str2rdf_nsap(ldns_rdf **ATTR_UNUSED(rd), const char *ATTR_UNUSED(str))
 {
        abort();
 }