added status flag in ldns_buffer, and removed all extra buffer_printf return checks...

(some choices could probably use some discussion :)

diff --git a/buffer.c b/buffer.c
index 3223cfcda4b49c015d69360169d03a24ff48ff3c..20e56f70f9a21155499eb3ada793a166d86cdbe8 100644 (file)
--- a/buffer.c
+++ b/buffer.c
@@ -29,6 +29,8 @@ ldns_buffer_new(size_t capacity)
        buffer->_position = 0;
        buffer->_limit = buffer->_capacity = capacity;
        buffer->_fixed = 0;
+       buffer->_status = LDNS_STATUS_OK;
+       
        ldns_buffer_invariant(buffer);
        
        return buffer;
@@ -43,6 +45,7 @@ ldns_buffer_new_from(ldns_buffer *buffer, void *data, size_t size)
        buffer->_limit = buffer->_capacity = size;
        buffer->_data = (uint8_t *) data;
        buffer->_fixed = 1;
+       buffer->_status = LDNS_STATUS_OK;
        
        ldns_buffer_invariant(buffer);
 }
@@ -52,6 +55,8 @@ ldns_buffer_clear(ldns_buffer *buffer)
 {
        ldns_buffer_invariant(buffer);
        
+       /* reset status here? */
+       
        buffer->_position = 0;
        buffer->_limit = buffer->_capacity;
 }
@@ -83,6 +88,7 @@ ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity)
 
        data = (uint8_t *) XREALLOC(buffer->_data, uint8_t, capacity);
        if (!data) {
+               buffer->_status = LDNS_STATUS_MEM_ERR;
                return false;
        } else {
                buffer->_data = data;
@@ -102,6 +108,7 @@ ldns_buffer_reserve(ldns_buffer *buffer, size_t amount)
                        new_capacity = buffer->_position + amount;
                }
                if (!ldns_buffer_set_capacity(buffer, new_capacity)) {
+                       buffer->_status = LDNS_STATUS_MEM_ERR;
                        return false;
                }
        }
@@ -113,33 +120,39 @@ int
 ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...)
 {
        va_list args;
-       int written;
+       int written = 0;
        size_t remaining;
        
-       ldns_buffer_invariant(buffer);
-       assert(buffer->_limit == buffer->_capacity);
-
-       remaining = ldns_buffer_remaining(buffer);
-       va_start(args, format);
-       written = vsnprintf((char *) ldns_buffer_current(buffer), remaining,
-                           format, args);
-       va_end(args);
-       if (written == -1) {
-               return -1;
-       } else if ((size_t) written >= remaining) {
-               if (!ldns_buffer_reserve(buffer, (size_t) written + 1)) {
-                       return -1;
-               }
+       if (ldns_buffer_status_ok(buffer)) {
+               ldns_buffer_invariant(buffer);
+               assert(buffer->_limit == buffer->_capacity);
+
+               remaining = ldns_buffer_remaining(buffer);
                va_start(args, format);
-               written = vsnprintf((char *) ldns_buffer_current(buffer),
-                                   ldns_buffer_remaining(buffer),
+               written = vsnprintf((char *) ldns_buffer_current(buffer), remaining,
                                    format, args);
                va_end(args);
                if (written == -1) {
+                       buffer->_status = LDNS_STATUS_INTERNAL_ERR;
                        return -1;
+               } else if ((size_t) written >= remaining) {
+                       if (!ldns_buffer_reserve(buffer, (size_t) written + 1)) {
+                               buffer->_status = LDNS_STATUS_MEM_ERR;
+                               return -1;
+                       }
+                       va_start(args, format);
+                       written = vsnprintf((char *) ldns_buffer_current(buffer),
+                                           ldns_buffer_remaining(buffer),
+                                           format, args);
+                       va_end(args);
+                       if (written == -1) {
+                               buffer->_status = LDNS_STATUS_INTERNAL_ERR;
+                               return -1;
+                       }
                }
+               buffer->_position += written;
        }
-       buffer->_position += written;
+
        return written;
 }
 

diff --git a/host2str.c b/host2str.c
index 8c207d5e3e5cc1cd775f4b1926225d215ac5fbde..5d01a917eeb1f4f1ecc7a9c9f8d29c6db8aa2128 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -88,52 +88,42 @@ ldns_rdf2buffer_dname(ldns_buffer *output, ldns_rdf *dname)
                ldns_buffer_write(output, &(dname->_data[src_pos]), len);
                src_pos += len;
                len = dname->_data[src_pos];
-               if (ldns_buffer_printf(output, ".") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, ".");
        }
        
-       return LDNS_STATUS_OK;
+       return ldns_buffer_status(output);
 }
 
 ldns_status
 ldns_rdf2buffer_int8(ldns_buffer *output, ldns_rdf *rdf)
 {
        uint8_t data = ldns_rdf_data(rdf)[0];
-       if (ldns_buffer_printf(output, "%lu", (unsigned long) data) < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       return LDNS_STATUS_OK;
+       ldns_buffer_printf(output, "%lu", (unsigned long) data);
+       return ldns_buffer_status(output);
 }
 
 ldns_status
 ldns_rdf2buffer_int16(ldns_buffer *output, ldns_rdf *rdf)
 {
        uint16_t data = read_uint16(ldns_rdf_data(rdf));
-       if (ldns_buffer_printf(output, "%lu", (unsigned long) data) < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       return LDNS_STATUS_OK;
+       ldns_buffer_printf(output, "%lu", (unsigned long) data);
+       return ldns_buffer_status(output);
 }
 
 ldns_status
 ldns_rdf2buffer_int32(ldns_buffer *output, ldns_rdf *rdf)
 {
        uint32_t data = read_uint32(ldns_rdf_data(rdf));
-       if (ldns_buffer_printf(output, "%lu", (unsigned long) data) < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       return LDNS_STATUS_OK;
+       ldns_buffer_printf(output, "%lu", (unsigned long) data);
+       return ldns_buffer_status(output);
 }
 
 ldns_status
 ldns_rdf2buffer_int48(ldns_buffer *output, ldns_rdf *rdf)
 {
        /* TODO */
-       if (ldns_buffer_printf(output, "INT48 TODO") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       return LDNS_STATUS_OK;
+       ldns_buffer_printf(output, "INT48 TODO");
+       return ldns_buffer_status(output);
 }
 
 /** 
@@ -145,11 +135,9 @@ ldns_rdf2buffer_a(ldns_buffer *output, ldns_rdf *rdf)
        char str[INET_ADDRSTRLEN];
        
        if (inet_ntop(AF_INET, ldns_rdf_data(rdf), str, INET_ADDRSTRLEN)) {
-               if (ldns_buffer_printf(output, "%s", str) < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "%s", str);
        }
-       return LDNS_STATUS_OK;
+       return ldns_buffer_status(output);
 }
 
 /** 
@@ -161,12 +149,10 @@ ldns_rdf2buffer_aaaa(ldns_buffer *output, ldns_rdf *rdf)
        char str[INET6_ADDRSTRLEN];
 
        if (inet_ntop(AF_INET6, ldns_rdf_data(rdf), str, sizeof(str))) {
-               if (ldns_buffer_printf(output, "%s", str) < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "%s", str);
        }
 
-       return LDNS_STATUS_OK;
+       return ldns_buffer_status(output);
 }
 
 ldns_status
@@ -176,31 +162,20 @@ ldns_rdf2buffer_str(ldns_buffer *output, ldns_rdf *rdf)
        uint8_t length = data[0];
        size_t i;
 
-       if (ldns_buffer_printf(output, "\"") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
+       ldns_buffer_printf(output, "\"");
        for (i = 1; i <= length; ++i) {
                char ch = (char) data[i];
                if (isprint(ch)) {
                        if (ch == '"' || ch == '\\') {
-                               if (ldns_buffer_printf(output, "\\") < 0) {
-                                       return LDNS_STATUS_MEM_ERR;
-                               }
-                       }
-                       if (ldns_buffer_printf(output, "%c", ch) < 0) {
-                               return LDNS_STATUS_MEM_ERR;
+                               ldns_buffer_printf(output, "\\");
                        }
+                       ldns_buffer_printf(output, "%c", ch);
                } else {
-                       if (ldns_buffer_printf(output, "\\%03u",
-                           (unsigned) ch) < 0) {
-                               return LDNS_STATUS_MEM_ERR;
-                       }
+                       ldns_buffer_printf(output, "\\%03u", (unsigned) ch);
                }
        }
-       if (ldns_buffer_printf(output, "\"") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       return LDNS_STATUS_OK;
+       ldns_buffer_printf(output, "\"");
+       return ldns_buffer_status(output);
 }
 
 /**
@@ -285,38 +260,26 @@ ldns_rr2buffer(ldns_buffer *output, ldns_rr *rr)
        
        lt = ldns_lookup_by_id(ldns_rr_classes, ldns_rr_get_class(rr));
        if (lt) {
-               if (ldns_buffer_printf(output, "\t%s\t", lt->name) < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "\t%s\t", lt->name);
        } else {
-               if (ldns_buffer_printf(output, "\tCLASS%d\t",
-                   ldns_rr_get_class(rr)) < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "\tCLASS%d\t", ldns_rr_get_class(rr));
        }
 
        descriptor = ldns_rr_descript(ldns_rr_get_type(rr));
 
        if (descriptor->_name) {
-               if (ldns_buffer_printf(output, "%s\t", descriptor->_name) < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "%s\t", descriptor->_name);
        } else {
-               if (ldns_buffer_printf(output, "TYPE%d\t",
-                   ldns_rr_get_type(rr)) < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "TYPE%d\t", ldns_rr_get_type(rr));
        }
        
 
        for (i = 0; i < ldns_rr_rd_count(rr); i++) {
                status = ldns_rdf2buffer(output, ldns_rr_rdf(rr, i));
-               if (ldns_buffer_printf(output, " ") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, " ");
        }
        
-       return status;
+       return ldns_buffer_status(output);
 }
 
 /**
@@ -343,72 +306,41 @@ ldns_pktheader2buffer(ldns_buffer *output, ldns_pkt *pkt)
                rcode_str = "??";
        }
        
-       if (
-           ldns_buffer_printf(output, ";; ->>HEADER<<- ") < 0 ||
-           ldns_buffer_printf(output, "opcode: %s, ", opcode_str
-                             ) < 0 ||
-           ldns_buffer_printf(output, "rcode: %s, ", rcode_str
-                             ) < 0 ||
-           ldns_buffer_printf(output, "id %lu\n", ldns_pkt_id(pkt)) < 0 ||
-           ldns_buffer_printf(output, ";; flags: ") < 0
-          )
-       {
-               return LDNS_STATUS_MEM_ERR;
-       }
+       ldns_buffer_printf(output, ";; ->>HEADER<<- ");
+       ldns_buffer_printf(output, "opcode: %s, ", opcode_str);
+       ldns_buffer_printf(output, "rcode: %s, ", rcode_str);
+       ldns_buffer_printf(output, "id %lu\n", ldns_pkt_id(pkt));
+       ldns_buffer_printf(output, ";; flags: ");
 
        if (ldns_pkt_qr(pkt)) {
-               if (ldns_buffer_printf(output, "qr ") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "qr ");
        }
        if (ldns_pkt_aa(pkt)) {
-               if (ldns_buffer_printf(output, "aa ") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "aa ");
        }
        if (ldns_pkt_tc(pkt)) {
-               if (ldns_buffer_printf(output, "tc ") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "tc ");
        }
        if (ldns_pkt_rd(pkt)) {
-               if (ldns_buffer_printf(output, "rd ") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "rd ");
        }
        if (ldns_pkt_cd(pkt)) {
-               if (ldns_buffer_printf(output, "cd ") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "cd ");
        }
        if (ldns_pkt_ra(pkt)) {
-               if (ldns_buffer_printf(output, "ra ") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
+               ldns_buffer_printf(output, "ra ");
        }
        if (ldns_pkt_ad(pkt)) {
-               if (ldns_buffer_printf(output, "ad ") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
-       }
-       if (ldns_buffer_printf(output, "; ") < 0) {
-               return LDNS_STATUS_MEM_ERR;
+               ldns_buffer_printf(output, "ad ");
        }
+       ldns_buffer_printf(output, "; ");
 
-       if (ldns_buffer_printf(output, "QUERY: %u, ", 
-                              ldns_pkt_qdcount(pkt)) < 0 ||
-           ldns_buffer_printf(output, "ANSWER: %u, ",
-                              ldns_pkt_ancount(pkt)) < 0 ||
-           ldns_buffer_printf(output, "AUTHORITY: %u, ",
-                              ldns_pkt_nscount(pkt)) < 0 ||
-           ldns_buffer_printf(output, "ADDITIONAL: %u, ",
-                              ldns_pkt_arcount(pkt)) < 0
-          )
-       {
-               return LDNS_STATUS_MEM_ERR;
-       }
+       ldns_buffer_printf(output, "QUERY: %u, ", ldns_pkt_qdcount(pkt));
+       ldns_buffer_printf(output, "ANSWER: %u, ", ldns_pkt_ancount(pkt));
+       ldns_buffer_printf(output, "AUTHORITY: %u, ", ldns_pkt_nscount(pkt));
+       ldns_buffer_printf(output, "ADDITIONAL: %u, ", ldns_pkt_arcount(pkt));
 
-       return LDNS_STATUS_OK;
+       return ldns_buffer_status(output);
 }
 /* TODO check status returns */
 
@@ -418,89 +350,67 @@ ldns_pkt2buffer(ldns_buffer *output, ldns_pkt *pkt)
        uint16_t i;
        ldns_status status = LDNS_STATUS_OK;
        
-       status = ldns_pktheader2buffer(output, pkt);
-       if (status != LDNS_STATUS_OK) {
-               /*printf("error in pkt2buf %d\n", status);*/
-               return status;
-       }
-       
-       if (ldns_buffer_printf(output, "\n") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       
-       if (ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-
-       for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
-               status = ldns_rr2buffer(output, 
-                              ldns_rr_list_rr(ldns_pkt_question(pkt), i));
-               if (status != LDNS_STATUS_OK) {
-                       return status;
-               }
-
-               if (ldns_buffer_printf(output, "\n") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
-               }
-       }
-       if (ldns_buffer_printf(output, "\n") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       
-       if (ldns_buffer_printf(output, ";; ANSWER SECTION:\n") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
-               status = ldns_rr2buffer(output, 
-                              ldns_rr_list_rr(ldns_pkt_answer(pkt), i));
+       if (ldns_buffer_status_ok(output)) {
+               status = ldns_pktheader2buffer(output, pkt);
                if (status != LDNS_STATUS_OK) {
+                       /*printf("error in pkt2buf %d\n", status);*/
                        return status;
                }
+               
+               ldns_buffer_printf(output, "\n");
+               
+               ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
+
+               for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
+                       status = ldns_rr2buffer(output, 
+                                      ldns_rr_list_rr(ldns_pkt_question(pkt), i));
+                       if (status != LDNS_STATUS_OK) {
+                               return status;
+                       }
 
-               if (ldns_buffer_printf(output, "\n") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
+                       ldns_buffer_printf(output, "\n");
                }
-       }
-       if (ldns_buffer_printf(output, "\n") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       
-       if (ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
+               ldns_buffer_printf(output, "\n");
+               
+               ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
+               for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
+                       status = ldns_rr2buffer(output, 
+                                      ldns_rr_list_rr(ldns_pkt_answer(pkt), i));
+                       if (status != LDNS_STATUS_OK) {
+                               return status;
+                       }
 
-       for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
-               status = ldns_rr2buffer(output, 
-                              ldns_rr_list_rr(ldns_pkt_authority(pkt), i));
-               if (status != LDNS_STATUS_OK) {
-                       return status;
-               }
-               if (ldns_buffer_printf(output, "\n") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
+                       ldns_buffer_printf(output, "\n");
                }
-       }
-       if (ldns_buffer_printf(output, "\n") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       
-       if (ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
-               status = ldns_rr2buffer(output, 
-                              ldns_rr_list_rr(ldns_pkt_additional(pkt), i));
-               if (status != LDNS_STATUS_OK) {
-                       return status;
+               ldns_buffer_printf(output, "\n");
+               
+               ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
+
+               for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
+                       status = ldns_rr2buffer(output, 
+                                      ldns_rr_list_rr(ldns_pkt_authority(pkt), i));
+                       if (status != LDNS_STATUS_OK) {
+                               return status;
+                       }
+                       ldns_buffer_printf(output, "\n");
                }
+               ldns_buffer_printf(output, "\n");
+               
+               ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
+               for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
+                       status = ldns_rr2buffer(output, 
+                                      ldns_rr_list_rr(ldns_pkt_additional(pkt), i));
+                       if (status != LDNS_STATUS_OK) {
+                               return status;
+                       }
 
-               if (ldns_buffer_printf(output, "\n") < 0) {
-                       return LDNS_STATUS_MEM_ERR;
+                       ldns_buffer_printf(output, "\n");
                }
+               ldns_buffer_printf(output, "\n");
+               
+       } else {
+               return ldns_buffer_status(output);
        }
-       if (ldns_buffer_printf(output, "\n") < 0) {
-               return LDNS_STATUS_MEM_ERR;
-       }
-       
        return status;
 }
 

diff --git a/ldns/buffer.h b/ldns/buffer.h
index 6925ad89514e097e14282ffbd6bd2852ba299307..136e22c7630f18b4b54a3bfdf34f1c6682bb0f39 100644 (file)
--- a/ldns/buffer.h
+++ b/ldns/buffer.h
@@ -47,6 +47,11 @@ struct buffer
         * If the buffer is fixed it cannot be resized.
         */
        unsigned _fixed : 1;
+
+       /*
+        * The current state of the buffer
+        */
+       ldns_status _status;
 };
 
 #ifdef NDEBUG
@@ -372,6 +377,22 @@ ldns_buffer_read_u32(ldns_buffer *buffer)
        return result;
 }
 
+INLINE ldns_status
+ldns_buffer_status(ldns_buffer *buffer)
+{
+       return buffer->_status;
+}
+
+INLINE bool
+ldns_buffer_status_ok(ldns_buffer *buffer)
+{
+       if (buffer) {
+               return ldns_buffer_status(buffer) == LDNS_STATUS_OK;
+       } else {
+               return false;
+       }
+}
+
 /*
  * Print to the buffer, increasing the capacity if required using
  * buffer_reserve(). The buffer's position is set to the terminating