added buffer_get_str() which allows to retrieve buffer contents as char *

include/pcp/buffer.h

@@ -57,12 +57,18 @@ Buffer *buffer_new(size_t blocksize, char *name);
 /* zero the buffer and free it, if allocated */
 void buffer_free(Buffer *b);
 
-/* zero the buffer, always called from buffer_free() */
+/* zero the buffer, reset counters, always called from buffer_free() */
 void buffer_clear(Buffer *b);
 
+/* put read offset to start */
+void buffer_rewind(Buffer *b);
+
 /* add data to the buffer, memorize end position */
 void buffer_add(Buffer *b, const void *data, size_t len);
 
+/* the same but use another buffer as source */
+void buffer_add_buf(Buffer *dst, Buffer *src);
+
 /* resize the buffer if necessary */
 void buffer_resize(Buffer *b, size_t len);
 
@@ -74,6 +80,10 @@ size_t buffer_get_chunk(Buffer *b, void *buf, size_t len);
 /* return the whole buffer contents */
 unsigned char *buffer_get(Buffer *b);
 
+/* access the buffer content as string (char *) the returned pointer
+   points to b->buf and should not be free'd directly*/
+char *buffer_get_str(Buffer *b);
+
 /* same as buffer_get() but fetch some data chunk from somewhere
    in the middle of the buffer */
 size_t buffer_extract(Buffer *b, void *buf, size_t offset, size_t len);

include/pcp/z85.h

@@ -26,6 +26,7 @@
 #include "defines.h"
 #include "zmq_z85.h"
 #include "mem.h"
+#include "buffer.h"
 
 /*  convert a binary stream to one which gets accepted by zmq_z85_encode */
 /*  we pad it with zeroes and put the number of zerores in front of it  */

libpcp/buffer.c

@@ -46,15 +46,24 @@ void buffer_free(Buffer *b) {
 
 void buffer_clear(Buffer *b) {
   b->offset = 0;
+  b->end = 0;
   memset(b->buf, 0, b->size);
 }
 
+void buffer_rewind(Buffer *b) {
+  b->offset = 0;
+}
+
 void buffer_add(Buffer *b, const void *data, size_t len) {
   buffer_resize(b, len);
   memcpy(b->buf + b->end, data, len);
   b->end += len;
 }
 
+void buffer_add_buf(Buffer *dst, Buffer *src) {
+  buffer_add(dst, buffer_get(src), buffer_size(src));
+}
+
 void buffer_resize(Buffer *b, size_t len) {
   if((b->end > 0 && b->end + len > b->size) || (b->end == 0 && len > b->size) ) {
     /* increase by buf blocksize */
@@ -83,6 +92,17 @@ size_t buffer_get_chunk(Buffer *b, void *buf, size_t len) {
   return len;
 }
 
+char *buffer_get_str(Buffer *b) {
+  buffer_resize(b, 1); /* make room for trailing zero */
+  return (char *)b->buf;
+  /*
+  char *out = ucmalloc(b->end+1);
+  memcpy(out, buffer_get(b), buffer_size(b));
+  out[buffer_size(b)] = '\0';
+  return out;
+  */
+}
+
 size_t buffer_extract(Buffer *b, void *buf, size_t offset, size_t len) {
   if(len > b->end) {
     fatal("[buffer %s] attempt to read %ld bytes past end of buffer at %ld\n", b->name, b->end - (b->offset + len), b->end);
@@ -182,18 +202,18 @@ void buffer_add64(Buffer *b, uint64_t v) {
 
 void buffer_add16be(Buffer *b, uint16_t v) {
   uint16_t e = v;
-  htobe16(e);
+  e = htobe16(e);
   buffer_add(b, &e, 2);
 }
 
 void buffer_add32be(Buffer *b, uint32_t v) {
   uint32_t e = v;
-  htobe32(e);
-  buffer_add(b, &v, 4);
+  e = htobe32(e);
+  buffer_add(b, &e, 4);
 }
 
 void buffer_add64be(Buffer *b, uint64_t v) {
   uint64_t e = v;
-  htobe64(e);
-  buffer_add(b, &v, 8);
+  e = htobe64(e);
+  buffer_add(b, &e, 8);
 }