Add dependency on libnul - use nul_buffer_t throughoutHEADmaster

7 files changed, 87 insertions, 444 deletions

diff --git a/configure.in b/configure.in
index c52175d..ec17d6b 100755
--- a/configure.in
+++ b/configure.in
@@ -140,7 +140,7 @@ AC_CHECK_FUNC(gethostbyname_r,
 ])
 
 dnl Checks for libraries.
-PKG_CHECK_MODULES(DEP, glib-2.0 gnutls >= 1.4)
+PKG_CHECK_MODULES(DEP, libnul glib-2.0 gnutls >= 1.4)
 
 LIBS="$LIBS $DEP_LIBS"
 CFLAGS="$CFLAGS $DEP_CFLAGS"
diff --git a/src/Makefile.am b/src/Makefile.am
index 8976d15..8674b15 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -11,7 +11,6 @@ liblac_1_la_SOURCES =		\
 	lacaddress.c		\
 	lacprimitives.c		\
 	lacwatch.c		\
-	lacbytequeue.c		\
 	lacdebug.c		\
 	lacdns-config.c		\
 	lacdns-query.c		\
diff --git a/src/lac.h b/src/lac.h
index 5a95248..7c2e3fd 100644
--- a/src/lac.h
+++ b/src/lac.h
@@ -24,6 +24,7 @@
 #define LAC_H
 
 #include <glib.h>
+#include <libnul.h>
 #include <sys/types.h>
 
 G_BEGIN_DECLS
@@ -183,36 +184,6 @@ gboolean lac_getpeername     (int                fd,
                               GError            **err);
 char *  lac_gethostname      (void);
 
-/* LacByteQueue */
-typedef struct LacByteQueue LacByteQueue;
-
-LacByteQueue *lac_byte_queue_new           (void);
-char        *lac_byte_queue_free          (LacByteQueue *queue,
-                                            gboolean      free_data);
-gsize	      lac_byte_queue_get_length    (LacByteQueue *queue);
-gboolean      lac_byte_queue_is_empty      (LacByteQueue *queue);
-const char  *lac_byte_queue_peek          (LacByteQueue *queue,
-                                            gsize        *n_bytes);
-char        *lac_byte_queue_steal         (LacByteQueue *queue,
-                                            gsize        *n_bytes);
-char        *lac_byte_queue_alloc_tail    (LacByteQueue *queue,
-                                            gsize	  size);
-void	      lac_byte_queue_append        (LacByteQueue *queue,
-                                            const char  *bytes,
-                                            gsize         n_bytes);
-void          lac_byte_queue_append_printf (LacByteQueue *queue,
-                                            const char  *fmt,
-                                            ...);
-void          lac_byte_queue_swap_content  (LacByteQueue *q1,
-                                            LacByteQueue *q2);
-void	      lac_byte_queue_transfer_data (LacByteQueue *dest,
-                                            LacByteQueue *src,
-                                            gssize        n_bytes);
-void          lac_byte_queue_delete_head   (LacByteQueue *queue,
-                                            gsize         size);
-void          lac_byte_queue_delete_tail   (LacByteQueue *queue,
-                                            gsize	   size);
-
 /*
  * Watching file descriptors
  */
@@ -253,7 +224,7 @@ typedef struct {
     LacConnectionEventType type;
     gpointer _lac_reserved0;
     gpointer _lac_reserved1;
-    LacByteQueue *byte_queue;
+    nul_buffer_t *buffer;
     const char *data;
     guint len;
 } LacConnectionReadEvent;
@@ -461,7 +432,7 @@ typedef struct {
 
 typedef struct {
     LacHttpEventType    type;
-    LacByteQueue *      byte_queue;
+    nul_buffer_t *      buffer;
     const guint8 *      data;
     gsize               length;
 
diff --git a/src/lacbytequeue.c b/src/lacbytequeue.c
deleted file mode 100644
index 504df0b..0000000
--- a/src/lacbytequeue.c
+++ /dev/null
@@ -1,325 +0,0 @@
-#include <stdarg.h>
-#include <string.h>
-#include <glib/gprintf.h>
-#include "lac.h"
-
-struct LacByteQueue
-{
-    gsize       segment_size;
-    gchar *	segment;
-    gchar *	start;
-    gchar *	end;
-};
-
-static void
-initialize (LacByteQueue *queue)
-{
-    queue->segment_size = 0;
-    queue->segment = NULL;
-    queue->start = NULL;
-    queue->end = NULL;
-}
-
-LacByteQueue *
-lac_byte_queue_new (void)
-{
-    LacByteQueue *queue = g_new0 (LacByteQueue, 1);
-
-    initialize (queue);
-    
-    return queue;
-}
-
-gsize
-lac_byte_queue_get_length (LacByteQueue *queue)
-{
-    return queue->end - queue->start;
-}
-
-gchar *
-lac_byte_queue_free (LacByteQueue *queue,
-		     gboolean   free_data)
-{    
-    gchar *result;
-    
-    if (free_data)
-    {
-	g_free (queue->segment);
-	
-	result = NULL;
-    }
-    else
-    {
-	result = lac_byte_queue_steal (queue, NULL);
-    }
-    
-    g_free (queue);
-    
-    return result;
-}
-
-/* The data returned is owned by the byte queue and becomes invalid
- * as soon as any method is called on the queue.
- */
-const gchar *
-lac_byte_queue_peek (LacByteQueue *queue,
-		     gsize        *n_bytes)
-{
-    if (n_bytes)
-	*n_bytes = queue->end - queue->start;
-
-    if (queue->start)
-    {
-	return queue->start;
-    }
-    else
-    {
-	/* The result of this function is guaranteed
-	 * to be NULL terminated, so if the queue is
-	 * empty, just return an empty string;
-	 */
-	return "";
-    }
-}
-
-gboolean
-lac_byte_queue_is_empty (LacByteQueue *queue)
-{
-    return queue->start == queue->end;
-}
-
-static gsize
-power_of_two_bigger_than (gsize n)
-{
-    gsize result = 1;
-    
-    while (result <= n)
-	result *= 2;
-    
-    return result;
-}
-
-static void
-null_terminate (LacByteQueue *queue)
-{
-    if (queue->end)
-	*(queue->end) = '\0';
-}
-
-static void
-ensure_room (LacByteQueue *queue,
-	     gsize      extra)
-{
-    gsize old_data_size = queue->end - queue->start;
-    gsize new_data_size = old_data_size + extra;
-    
-    if (queue->end + new_data_size + 1 > queue->segment + queue->segment_size)
-    {
-	gsize new_segment_size = power_of_two_bigger_than (2 * new_data_size);
-	
-	memmove (queue->segment, queue->start, old_data_size);
-	
-	if (new_segment_size > queue->segment_size)
-	{
-	    queue->segment_size = new_segment_size;
-	    queue->segment = g_realloc (queue->segment, new_segment_size);
-	}
-	
-	queue->start = queue->segment;
-	queue->end = queue->start + old_data_size;
-
-	null_terminate (queue);
-    }
-}
-
-/* This function appends uninitialized data of length @size
- * to the queue, then returns a pointer to the added data.
- * The intention is that the app can read() into this
- * memory, then use lac_byte_queue_pop_tail() to delete the
- * area that wasn't read into. Example
- *
- *        guint8 *area = lac_byte_queue_alloc_tail (queue, 8192);
- *
- *        n_read = read (fd, area, 8192);
- *
- *        lac_byte_queue_delete_tail (queue, 8192 - (n_read < 0)? 0 : n_read);
- *
- *        if (n_read < 0)
- *        {
- *	       lac_byte_queue_delete_tail (queue, 8192);
- *             handle_error();
- *             n_read = 0;
- *        }
- *        else
- *        {
- *	       lac_byte_queue_delete_tail (8192 - n_read);
- *
- *             // enjoy the new data in the queue
- *        }
- */
-gchar *
-lac_byte_queue_alloc_tail (LacByteQueue *queue,
-			   gsize	  size)
-{
-    ensure_room (queue, size);
-    
-    queue->end += size;
-
-    null_terminate (queue);
-    
-    return queue->end - size;
-}
-
-void
-lac_byte_queue_delete_head (LacByteQueue *queue,
-			    gsize	  size)
-{
-    if (queue->end - queue->start < size)
-	queue->start = queue->end = queue->segment;
-    else
-	queue->start += size;
-}
-
-void
-lac_byte_queue_delete_tail (LacByteQueue *queue,
-			    gsize	   size)
-{
-    if (queue->end - queue->start < size)
-	queue->start = queue->end = queue->segment;
-    else
-	queue->end -= size;
-
-    null_terminate (queue);
-}
-
-void
-lac_byte_queue_append (LacByteQueue *queue,
-		       const gchar  *bytes,
-		       gsize         n_bytes)
-{
-    if (n_bytes > 0)
-    {
-	gchar *tail = lac_byte_queue_alloc_tail (queue, n_bytes);
-    
-	memcpy (tail, bytes, n_bytes);
-    }
-}
-
-void
-lac_byte_queue_append_printf (LacByteQueue *queue,
-			      const gchar *fmt,
-			      ...)
-{
-    gint required;
-    va_list args;
-    gchar *buffer;
-
-    g_return_if_fail (fmt != NULL);
-    
-    va_start (args, fmt);
-
-    required = g_vsnprintf (NULL, 0, fmt, args) + 1;
-
-    buffer = lac_byte_queue_alloc_tail (queue, required);
-
-    g_vsprintf (buffer, fmt, args);
-    
-    va_end (args);
-}
-
-gchar *
-lac_byte_queue_steal (LacByteQueue *queue,
-		      gsize        *n_bytes)
-{
-    gchar *result;
-    
-    if (n_bytes)
-	*n_bytes = queue->end - queue->start;
-    
-    memmove (queue->segment, queue->start, queue->end - queue->start);
-    
-    result = queue->segment;
-
-    initialize (queue);
-
-    return result;
-}
-
-void
-lac_byte_queue_swap_content (LacByteQueue *queue1,
-			     LacByteQueue *queue2)
-{
-    gsize tmp1;
-    gchar *tmp2;
-    
-    tmp1 = queue1->segment_size;
-    queue1->segment_size = queue2->segment_size;
-    queue2->segment_size = tmp1;
-    
-    tmp2 = queue1->segment;
-    queue1->segment = queue2->segment;
-    queue2->segment = tmp2;
-    
-    tmp2 = queue1->start;
-    queue1->start = queue2->start;
-    queue2->start = tmp2;
-    
-    tmp2 = queue1->end;
-    queue1->end = queue2->end;
-    queue2->end = tmp2;
-}
-
-
-/* Transfer n_bytes data from the head of @src to tail of @dest,
- * if possible without copying. The data is appended to @dest's data
- * if @dest is not empty
- */
-void
-lac_byte_queue_transfer_data (LacByteQueue    *dest,
-			      LacByteQueue    *src,
-			      gssize	       n_bytes)
-{
-    gsize total = src->end - src->start;
-    if (n_bytes < 0 || n_bytes > total)
-	n_bytes = total;
-    
-    if (lac_byte_queue_is_empty (dest))
-    {
-	char *source = src->start;
-	gboolean swap_contents = FALSE;
-	
-	if (n_bytes > total / 2)
-	{
-	    source = src->start + n_bytes;
-	    n_bytes = total - n_bytes;
-	    swap_contents = TRUE;
-	}
-
-	lac_byte_queue_append (dest, source, n_bytes);
-
-	if (swap_contents)
-	{
-	    lac_byte_queue_delete_tail (src, n_bytes);
-	    lac_byte_queue_swap_content (dest, src);
-	}
-	else
-	{
-	    lac_byte_queue_delete_head (src, n_bytes);
-	}
-    }
-    else
-    {
-	/* FIXME:
-	 *
-	 *  check whether one of the strings fit in the other's segment.
-	 *  if both fit, copy the shortest, if only one, copy that one.
-	 *  if none, just append.
-	 */
-	lac_byte_queue_append (dest, src->start, src->end - src->start);
-
-	if (src->segment)
-	    g_free (src->segment);
-
-	initialize (src);
-    }
-}
diff --git a/src/lachttp.c b/src/lachttp.c
index f9a7661..d44fe24 100644
--- a/src/lachttp.c
+++ b/src/lachttp.c
@@ -114,7 +114,7 @@ struct _LacHttpRequest {
     
     GList *             headers;
     
-    LacByteQueue *      content;
+    nul_buffer_t *      content;
     
     HttpHost *          host;
     gboolean            canceled;
@@ -129,7 +129,7 @@ struct _LacHttpRequest {
     HttpTransport *     transport;
     
     /* parsing */
-    LacByteQueue *      unparsed;
+    nul_buffer_t *      unparsed;
     gsize               n_content_bytes;
     gsize               n_ignore_bytes;
     RequestParseState   parser_state;
@@ -155,7 +155,7 @@ static void            request_destroy                     (LacHttpRequest   *re
 static gchar *         request_serialize                   (LacHttpRequest   *request,
                                                             const gchar      *connection);
 static gboolean        request_parse_response              (LacHttpRequest   *request,
-                                                            LacByteQueue     *bytes);
+                                                            nul_buffer_t     *bytes);
 static void            request_parse_end_of_file           (LacHttpRequest   *request);
 static gboolean        request_done_parsing                (LacHttpRequest   *request);
 static gboolean        request_done_parsing_headers        (LacHttpRequest   *request);
@@ -180,7 +180,7 @@ static void            request_emit_begin_content          (LacHttpRequest   *re
                                                             gssize            total);
 static void            request_emit_content                (LacHttpRequest   *request,
                                                             gsize             n_bytes,
-                                                            LacByteQueue     *queue);
+                                                            nul_buffer_t     *buffer);
 static void            request_emit_end_content            (LacHttpRequest   *request);
 static void            request_emit_no_content             (LacHttpRequest   *request);
 static void            request_emit_error                  (LacHttpRequest   *request,
@@ -250,7 +250,7 @@ struct _HttpTransport {
     gboolean            pipelining;
     gboolean            broken_server;
     guint               successful_requests;
-    LacByteQueue *      write_buffer;
+    nul_buffer_t *      write_buffer;
     gint                write_timeout;
     gint                answer_timeout;
     gboolean            did_pipeline;           /* if TRUE, we did pipeline at some point,
@@ -279,7 +279,7 @@ static void           http_transport_cancel_request (HttpTransport  *connection,
 static void
 request_initialize_parser_state (LacHttpRequest *request)
 {
-    request->unparsed = lac_byte_queue_new ();
+    request->unparsed = nul_buffer_new ();
     request->parser_state = INITIAL;
     
     request->n_content_bytes = 0;
@@ -306,7 +306,7 @@ request_alloc (const LacUri *uri, LacHttpFunc func, gpointer data)
     
     request->headers = NULL;
     
-    request->content = lac_byte_queue_new ();
+    request->content = nul_buffer_new ();
     
     request->host = NULL;
     request->canceled = FALSE;
@@ -329,7 +329,7 @@ request_alloc (const LacUri *uri, LacHttpFunc func, gpointer data)
 static void
 request_restart_parsing (LacHttpRequest *request)
 {
-    lac_byte_queue_free (request->unparsed, TRUE);
+    nul_buffer_free (request->unparsed, TRUE);
     request_initialize_parser_state (request);
 }
 
@@ -352,7 +352,7 @@ http_event_free (LacHttpEvent *event)
         break;
         
     case LAC_HTTP_EVENT_CONTENT:
-        lac_byte_queue_free (event->content.byte_queue, TRUE);
+        nul_buffer_free (event->content.buffer, TRUE);
         break;
         
     case LAC_HTTP_EVENT_ERROR:
@@ -383,8 +383,8 @@ request_destroy (LacHttpRequest *request)
     }
     
     g_list_free (request->headers);
-    lac_byte_queue_free (request->content, TRUE);
-    lac_byte_queue_free (request->unparsed, TRUE);
+    nul_buffer_free (request->content, TRUE);
+    nul_buffer_free (request->unparsed, TRUE);
 
     while ((event = g_queue_pop_head (request->pending_events)))
         http_event_free (event);
@@ -505,7 +505,7 @@ request_serialize (LacHttpRequest *request, const gchar *connection)
      * and our caller calls strlen() on it. We need to return a GString
      * or something.
      */
-    content = lac_byte_queue_peek (request->content, &content_len);
+    content = nul_buffer_peek (request->content, &content_len);
     
     g_string_append_len (result, content, content_len);
 #endif
@@ -519,7 +519,7 @@ request_get_line (LacHttpRequest *request, gchar **result)
     gchar *lf_pos;
     gsize line_len;
     gsize n_bytes;
-    const gchar *unparsed = lac_byte_queue_peek (request->unparsed, &n_bytes);
+    const gchar *unparsed = nul_buffer_peek (request->unparsed, &n_bytes);
 
     lf_pos = strchr (unparsed, LF);
     
@@ -543,7 +543,7 @@ request_get_line (LacHttpRequest *request, gchar **result)
     *result = g_strstrip (g_strndup (unparsed, line_len));
     
     /* delete up to and including the LF */
-    lac_byte_queue_delete_head (request->unparsed, line_len + 1);
+    nul_buffer_delete_head (request->unparsed, line_len + 1);
 
     return OK;
 }
@@ -658,7 +658,7 @@ request_parse_status_line (LacHttpRequest *request)
     gchar *status_line;
     ParseResult result;
     gsize n_bytes;
-    const gchar *unparsed = lac_byte_queue_peek (request->unparsed, &n_bytes);
+    const gchar *unparsed = nul_buffer_peek (request->unparsed, &n_bytes);
     
     if (n_bytes < 4)
         return NEED_MORE_DATA;
@@ -882,7 +882,7 @@ static ParseResult
 request_parse_chunk_data (LacHttpRequest *request)
 {
     gsize n_bytes;
-    const gchar *unparsed = lac_byte_queue_peek (request->unparsed, &n_bytes);
+    const gchar *unparsed = nul_buffer_peek (request->unparsed, &n_bytes);
     
     g_assert (request->current_chunk_size > 0);
     
@@ -901,7 +901,7 @@ request_parse_chunk_data (LacHttpRequest *request)
                 request, request->current_chunk_size, request->unparsed);
 
             /* Delete the CRLF */
-            lac_byte_queue_delete_head (request->unparsed, 2);
+            nul_buffer_delete_head (request->unparsed, 2);
             
             request->parser_state = EXPECT_CHUNK_HEADER;
             return OK;
@@ -956,7 +956,7 @@ static ParseResult
 request_parse_length_delimited_body (LacHttpRequest *request)
 {
     gsize emit_size;
-    gsize n_bytes = lac_byte_queue_get_length (request->unparsed);
+    gsize n_bytes = nul_buffer_get_length (request->unparsed);
     
     g_assert (request->content_length > request->n_content_bytes);
     
@@ -988,7 +988,7 @@ static ParseResult
 request_parse_close_delimited_body (LacHttpRequest *request)
 {
     request_emit_content (
-        request, lac_byte_queue_get_length (request->unparsed),
+        request, nul_buffer_get_length (request->unparsed),
         request->unparsed);
     
     return NEED_MORE_DATA;
@@ -998,7 +998,7 @@ request_parse_close_delimited_body (LacHttpRequest *request)
  */
 static gboolean
 request_parse_response (LacHttpRequest  *request,
-                        LacByteQueue    *bytes)
+                        nul_buffer_t    *bytes)
 {
     ParseResult result;
     
@@ -1009,9 +1009,9 @@ request_parse_response (LacHttpRequest  *request,
     g_print ("received: %d\n", len);
 #endif
 
-    lac_byte_queue_transfer_data (request->unparsed, bytes, -1);
+    nul_buffer_transfer_data (request->unparsed, bytes, -1);
     
-    while (lac_byte_queue_get_length (request->unparsed) > 0)
+    while (nul_buffer_get_length (request->unparsed) > 0)
     {
         result = ERROR;
 
@@ -1063,9 +1063,9 @@ request_parse_response (LacHttpRequest  *request,
              * then this will be detected by the same invocation.
              */
 #if 0
-            g_assert (lac_byte_queue_get_length (request->unparsed) < len);
+            g_assert (nul_buffer_get_length (request->unparsed) < len);
 #endif
-            lac_byte_queue_transfer_data (bytes, request->unparsed, -1);
+            nul_buffer_transfer_data (bytes, request->unparsed, -1);
 
             return TRUE;
             break;
@@ -1095,7 +1095,7 @@ request_parse_end_of_file (LacHttpRequest *request)
     
     if (request->parser_state == EXPECT_CLOSE_DELIMITED_BODY)
     {
-        gsize n_bytes = lac_byte_queue_get_length (request->unparsed);
+        gsize n_bytes = nul_buffer_get_length (request->unparsed);
         
         if (n_bytes > 0)
             request_emit_content (request, n_bytes, request->unparsed);
@@ -1358,11 +1358,11 @@ request_emit_begin_content (LacHttpRequest     *request,
 static void
 request_emit_content (LacHttpRequest *request,
                       gsize           length,
-                      LacByteQueue   *queue)
+                      nul_buffer_t   *buffer)
 {
     LacHttpEvent *event = g_new (LacHttpEvent, 1);
     gssize bytes_to_ignore;
-    LacByteQueue *copy;
+    nul_buffer_t *copy;
     
     if (!request->sent_begin_content)
         request_emit_begin_content (request, -1);
@@ -1375,19 +1375,19 @@ request_emit_content (LacHttpRequest *request,
         if (bytes_to_ignore >= length)
             bytes_to_ignore = length;
 
-        lac_byte_queue_delete_head (queue, bytes_to_ignore);
+        nul_buffer_delete_head (buffer, bytes_to_ignore);
         length -= bytes_to_ignore;
     }
 
-    copy = lac_byte_queue_new ();
-    lac_byte_queue_transfer_data (copy, queue, length);
+    copy = nul_buffer_new ();
+    nul_buffer_transfer_data (copy, buffer, length);
 
     if (length > 0)
     {
         event->type = LAC_HTTP_EVENT_CONTENT;
         event->content.length = length;
-        event->content.byte_queue = copy;
-        event->content.data = lac_byte_queue_peek (copy, NULL);
+        event->content.buffer = copy;
+        event->content.data = nul_buffer_peek (copy, NULL);
         event->content.so_far = request->n_content_bytes;
         event->content.total = request->content_length;
         
@@ -1592,7 +1592,7 @@ lac_http_request_add_content (LacHttpRequest *request,
         request->type == PUT_REQUEST);
     g_return_if_fail (data != NULL);
     
-    lac_byte_queue_append (request->content, data, len);
+    nul_buffer_append (request->content, data, len);
 }
 
 void
@@ -1890,11 +1890,11 @@ http_host_cancel_request (HttpHost *host, LacHttpRequest *request)
 static void
 http_transport_delete_write_buffer (HttpTransport *transport)
 {
-    gsize n_bytes = lac_byte_queue_get_length (transport->write_buffer);
+    gsize n_bytes = nul_buffer_get_length (transport->write_buffer);
     
     if (n_bytes > 0)
     {
-        lac_byte_queue_delete_head (transport->write_buffer, n_bytes);
+        nul_buffer_delete_head (transport->write_buffer, n_bytes);
         
         if (transport->write_timeout)
         {
@@ -2035,14 +2035,14 @@ static void
 http_transport_flush_write_buffer (HttpTransport *transport)
 {
     gsize n_bytes;
-    const gchar *bytes = lac_byte_queue_peek (transport->write_buffer, &n_bytes);
+    const gchar *bytes = nul_buffer_peek (transport->write_buffer, &n_bytes);
     
     if (n_bytes > 0)
     {
         /* FIXME: should we have a lac_connection_write_byte_queue()? */
         lac_connection_write (transport->connection, bytes, n_bytes);
 
-        lac_byte_queue_delete_head (transport->write_buffer, n_bytes);
+        nul_buffer_delete_head (transport->write_buffer, n_bytes);
     }
 }
 
@@ -2100,7 +2100,7 @@ http_transport_transmit_request (HttpTransport *transport,
         transport->write_timeout = 0;
     }
 
-    lac_byte_queue_append (transport->write_buffer, serialized, strlen (serialized));
+    nul_buffer_append (transport->write_buffer, serialized, strlen (serialized));
     g_free (serialized);
 
 #if 0
@@ -2216,7 +2216,7 @@ http_transport_handle_read (HttpTransport                *transport,
     }    
 #endif
 
-    while (lac_byte_queue_get_length (read_event->byte_queue) > 0)
+    while (nul_buffer_get_length (read_event->buffer) > 0)
     {
         if (!transport->current)
         {
@@ -2235,8 +2235,7 @@ http_transport_handle_read (HttpTransport                *transport,
         
         g_assert (transport->current);
 
-        if (!request_parse_response (transport->current,
-                                     read_event->byte_queue))
+        if (!request_parse_response (transport->current, read_event->buffer))
         {
             GError *err = g_error_new (LAC_HTTP_ERROR,
                                        LAC_HTTP_ERROR_MALFORMED_RESPONSE,
@@ -2471,7 +2470,7 @@ transport_dump_spam (HttpTransport *transport)
     {
         gsize n_bytes;
         const gchar *unparsed =
-            lac_byte_queue_peek (transport->current->unparsed, &n_bytes);
+            nul_buffer_peek (transport->current->unparsed, &n_bytes);
         int i;
         g_print ("**** transport info: \n");
         g_print ("  transport->current->unparsed:    %d\n", n_bytes);
@@ -2553,7 +2552,7 @@ http_transport_new (HttpHost *host,
     transport->pipelining = pipelining;
     transport->broken_server = broken;
     transport->successful_requests = 0;
-    transport->write_buffer = lac_byte_queue_new ();
+    transport->write_buffer = nul_buffer_new ();
     transport->write_timeout = 0;
     
     transport->answer_timeout = 0;
@@ -2577,7 +2576,7 @@ http_transport_destroy (HttpTransport *transport)
     g_assert (g_queue_is_empty (transport->in_progress));
     g_queue_free (transport->in_progress);
 
-    lac_byte_queue_free (transport->write_buffer, TRUE);
+    nul_buffer_free (transport->write_buffer, TRUE);
 
     g_free (transport);
 }
diff --git a/src/lactcpconnection.c b/src/lactcpconnection.c
index d72fbd3..05f7a7b 100644
--- a/src/lactcpconnection.c
+++ b/src/lactcpconnection.c
@@ -41,7 +41,7 @@ struct _LacTcpConnection {
     GQueue *                    pending_events;
     
     ConnectionState             state;
-    LacByteQueue *              unwritten;
+    nul_buffer_t *              unwritten;
     
     gboolean                    has_fd;
     gboolean                    in_emit_events;
@@ -55,9 +55,9 @@ event_free (LacConnectionEvent *event)
     if (event->type == LAC_CONNECTION_EVENT_READ)
     {
         /* FIXME: at some point we should support pushing
-         * data back into the queue, ie., it must be kept alive
+         * data back into the buffer, ie., it must be kept alive
          */
-        lac_byte_queue_free (event->read.byte_queue, TRUE);
+        nul_buffer_free (event->read.buffer, TRUE);
     }
     else if (event->type == LAC_CONNECTION_EVENT_ERROR)
         g_error_free ((GError *)event->error.err);
@@ -76,13 +76,13 @@ queue_connect (LacTcpConnection *connection)
 }
 
 static void
-queue_read (LacTcpConnection *connection, LacByteQueue *queue)
+queue_read (LacTcpConnection *connection, nul_buffer_t *buffer)
 {
     LacConnectionEvent *event = g_new (LacConnectionEvent, 1);
     
     event->type = LAC_CONNECTION_EVENT_READ;
-    event->read.byte_queue = queue;
-    event->read.data = lac_byte_queue_peek (queue, &(event->read.len));
+    event->read.buffer = buffer;
+    event->read.data = nul_buffer_peek (buffer, &(event->read.len));
 
     g_queue_push_tail (connection->pending_events, event);
 }
@@ -181,20 +181,20 @@ lac_tcp_connection_do_reads (gpointer data)
     do
     {
         GError *err = NULL;
-        LacByteQueue *queue = lac_byte_queue_new ();
-        gchar *buf = lac_byte_queue_alloc_tail (queue, BUF_SIZE);
+        nul_buffer_t *buffer = nul_buffer_new ();
+        gchar *buf = nul_buffer_alloc_tail (buffer, BUF_SIZE);
         
         len = lac_recv (connection->fd, buf, BUF_SIZE, &err);
 
         if (len > 0)
         {
-            lac_byte_queue_delete_tail (queue, BUF_SIZE - len);
+            nul_buffer_delete_tail (buffer, BUF_SIZE - len);
         
-            queue_read (connection, queue);
+            queue_read (connection, buffer);
         }
         else
         {
-            lac_byte_queue_free (queue, TRUE);
+            nul_buffer_free (buffer, TRUE);
             
             if (len == 0)
             {
@@ -230,13 +230,13 @@ lac_tcp_connection_do_writes (LacTcpConnection *connection)
         return;
     }
     
-    while (lac_byte_queue_get_length (connection->unwritten) > 0)
+    while (nul_buffer_get_length (connection->unwritten) > 0)
     {
         GError       *err = NULL;
         const gchar  *unwritten;
         gsize         len, sent;
         
-        unwritten = lac_byte_queue_peek (connection->unwritten, &len);
+        unwritten = nul_buffer_peek (connection->unwritten, &len);
 
         sent = lac_send (connection->fd, unwritten, len, &err);
 
@@ -257,7 +257,7 @@ lac_tcp_connection_do_writes (LacTcpConnection *connection)
             return;
         }
 
-        lac_byte_queue_delete_head (connection->unwritten, sent);
+        nul_buffer_delete_head (connection->unwritten, sent);
         
         /* FIXME check that we haven't used too much time? */
     }
@@ -370,7 +370,7 @@ lac_tcp_connection_new (const LacAddress  *address,
     
     connection->state = UNDEFINED;
     connection->has_fd = FALSE;
-    connection->unwritten = lac_byte_queue_new ();
+    connection->unwritten = nul_buffer_new ();
     
     connection->in_emit_events = FALSE;
     connection->need_flush = FALSE;
@@ -425,9 +425,9 @@ lac_tcp_connection_write (LacTcpConnection  *connection,
     if (len == 0)
         return;
     
-    do_writes = (lac_byte_queue_get_length (connection->unwritten) == 0);
+    do_writes = (nul_buffer_get_length (connection->unwritten) == 0);
 
-    lac_byte_queue_append (connection->unwritten, data, len);
+    nul_buffer_append (connection->unwritten, data, len);
 
     if (do_writes)
     {
@@ -463,7 +463,7 @@ lac_tcp_connection_unref (LacTcpConnection     *connection)
         lac_tcp_connection_discard_pending_events (connection);
         g_queue_free (connection->pending_events);
 
-        lac_byte_queue_free (connection->unwritten, TRUE);
+        nul_buffer_free (connection->unwritten, TRUE);
         
         if (connection->has_fd)
         {
@@ -486,6 +486,6 @@ lac_tcp_connection_flush (LacTcpConnection     *connection)
 {
     connection->need_flush = TRUE;
 
-    if (lac_byte_queue_get_length (connection->unwritten) == 0)
+    if (nul_buffer_get_length (connection->unwritten) == 0)
         lac_tcp_connection_do_writes (connection);
 }
diff --git a/src/lactlsconnection.c b/src/lactlsconnection.c
index 9106f7a..b3648a4 100644
--- a/src/lactlsconnection.c
+++ b/src/lactlsconnection.c
@@ -31,8 +31,8 @@ struct _LacTlsConnection
     LacTlsConnectionFunc                callback;
     gpointer                            data;
     
-    LacByteQueue *                      buffer;
-    LacByteQueue *                      unwritten;
+    nul_buffer_t *                      buffer;
+    nul_buffer_t *                      unwritten;
     
     gnutls_certificate_credentials_t    xcred;
     gnutls_session_t                    session;
@@ -130,7 +130,7 @@ do_writes (LacTlsConnection *connection)
         
         n_written = 0;
         
-        buffer = lac_byte_queue_peek (connection->unwritten, &n_available);
+        buffer = nul_buffer_peek (connection->unwritten, &n_available);
         
         if (n_available > 0)
         {
@@ -149,7 +149,7 @@ do_writes (LacTlsConnection *connection)
             }
         }
         
-        lac_byte_queue_delete_head (connection->unwritten, n_written);
+        nul_buffer_delete_head (connection->unwritten, n_written);
     }
     while (n_written > 0);
     
@@ -168,8 +168,7 @@ static void
 handle_read (LacTlsConnection             *tls,
              const LacConnectionReadEvent *event)
 {
-    LacByteQueue *queue;
-    gchar *buffer;
+    nul_buffer_t *buffer;
     gssize n_read;
     enum { BUF_SIZE = 8192 };
     GError *err = NULL;
@@ -177,13 +176,13 @@ handle_read (LacTlsConnection             *tls,
     if (!tls->did_handshake)
         return;
     
-    queue = lac_byte_queue_new ();
+    buffer = nul_buffer_new ();
     
     do
     {
-        buffer = lac_byte_queue_alloc_tail (queue, BUF_SIZE);
+        gchar *tail = nul_buffer_alloc_tail (buffer, BUF_SIZE);
         
-        n_read = gnutls_record_recv (tls->session, buffer, BUF_SIZE);
+        n_read = gnutls_record_recv (tls->session, tail, BUF_SIZE);
         
         if (n_read < 0)
         {
@@ -196,18 +195,18 @@ handle_read (LacTlsConnection             *tls,
             n_read = 0;
         }
         
-        lac_byte_queue_delete_tail (queue, BUF_SIZE - n_read);
+        nul_buffer_delete_tail (buffer, BUF_SIZE - n_read);
     }
     while (n_read > 0);
     
-    if (!lac_byte_queue_is_empty (queue))
+    if (!nul_buffer_is_empty (buffer))
     {
         LacConnectionEvent read_event;
         gsize n_bytes;
         
         read_event.type = LAC_CONNECTION_EVENT_READ;
-        read_event.read.byte_queue = queue;
-        read_event.read.data = lac_byte_queue_peek (queue, &n_bytes);
+        read_event.read.buffer = buffer;
+        read_event.read.data = nul_buffer_peek (buffer, &n_bytes);
         read_event.read.len = n_bytes;
         
         tls->callback (tls, &read_event);
@@ -220,7 +219,7 @@ handle_read (LacTlsConnection             *tls,
         lac_connection_close (tls->tcp_connection);
     }
     
-    lac_byte_queue_free (queue, TRUE);
+    nul_buffer_free (buffer, TRUE);
 }
 
 static void
@@ -242,7 +241,7 @@ tcp_callback (LacConnection *connection,
 	break;
         
     case LAC_CONNECTION_EVENT_READ:
-        lac_byte_queue_append (tls->buffer, event->read.data, event->read.len);
+        nul_buffer_append (tls->buffer, event->read.data, event->read.len);
         do_handshake (tls);
         do_writes (tls);
     
@@ -272,7 +271,7 @@ tls_pull (gnutls_transport_ptr_t  tptr,
     const gchar *buf;
     gsize n_available;
     
-    buf = lac_byte_queue_peek (tls->buffer, &n_available);
+    buf = nul_buffer_peek (tls->buffer, &n_available);
     
     if (n_available > 0)
     {
@@ -282,7 +281,7 @@ tls_pull (gnutls_transport_ptr_t  tptr,
         
 	errno = 0;
         
-        lac_byte_queue_delete_head (tls->buffer, minimum);
+        nul_buffer_delete_head (tls->buffer, minimum);
         
 	return minimum;
     }
@@ -308,8 +307,8 @@ lac_tls_connection_new (const LacAddress       *address,
     tls->did_handshake = FALSE;
     tls->callback = callback;
     tls->data = data;
-    tls->buffer = lac_byte_queue_new ();
-    tls->unwritten = lac_byte_queue_new ();
+    tls->buffer = nul_buffer_new ();
+    tls->unwritten = nul_buffer_new ();
     
     gnutls_global_init ();
     
@@ -339,8 +338,8 @@ lac_tls_connection_free (LacTlsConnection *connection)
 {
     lac_connection_unref (connection->tcp_connection);
     
-    lac_byte_queue_free (connection->buffer, TRUE);
-    lac_byte_queue_free (connection->unwritten, TRUE);
+    nul_buffer_free (connection->buffer, TRUE);
+    nul_buffer_free (connection->unwritten, TRUE);
     gnutls_deinit (connection->session);
     
     gnutls_certificate_free_credentials (connection->xcred);
@@ -353,7 +352,7 @@ lac_tls_connection_write (LacTlsConnection *tls,
 			  const gchar      *data,
 			  guint             len)
 {
-    lac_byte_queue_append (tls->unwritten, data, len);
+    nul_buffer_append (tls->unwritten, data, len);
     
     do_writes (tls);
 }