buffer: refactor buffer to be dynamically-sized

src/async.c

@@ -79,8 +79,16 @@ mpd_async_new(int fd)
 	async->fd = fd;
 	mpd_error_init(&async->error);
 
-	mpd_buffer_init(&async->input);
-	mpd_buffer_init(&async->output);
+	if (mpd_buffer_init(&async->input) == NULL) {
+		async->output.data = NULL;
+		mpd_async_free(async);
+		return NULL;
+	}
+
+	if (mpd_buffer_init(&async->output) == NULL) {
+		mpd_async_free(async);
+		return NULL;
+	}
 
 	return async;
 }
@@ -92,6 +100,8 @@ mpd_async_free(struct mpd_async *async)
 
 	mpd_socket_close(async->fd);
 	mpd_error_deinit(&async->error);
+	mpd_buffer_end(&async->input);
+	mpd_buffer_end(&async->output);
 	free(async);
 }
 
@@ -179,14 +189,17 @@ mpd_async_read(struct mpd_async *async)
 {
 	size_t room;
 	ssize_t nbytes;
+	const size_t min_size = 256;
 
 	assert(async != NULL);
 	assert(async->fd != MPD_INVALID_SOCKET);
 	assert(!mpd_error_is_defined(&async->error));
 
+	if (!mpd_buffer_make_room(&async->input, min_size)) {
+		mpd_error_code(&async->error, MPD_ERROR_OOM);
+		return false;
+	}
 	room = mpd_buffer_room(&async->input);
-	if (room == 0)
-		return true;
 
 	nbytes = recv(async->fd, mpd_buffer_write(&async->input), room,
 		      MSG_DONTWAIT);
@@ -276,39 +289,25 @@ mpd_async_io(struct mpd_async *async, enum mpd_async_event events)
 	return true;
 }
 
-bool
-mpd_async_send_command_v(struct mpd_async *async, const char *command,
-			 va_list args)
+static bool
+quote_vargs(struct mpd_buffer *buffer, char *start, char **end_pos,
+	    va_list args)
 {
-	size_t room, length;
-	char *dest, *end, *p;
+	char *end, *p;
 	const char *arg;
 
-	assert(async != NULL);
-	assert(command != NULL);
-
-	if (mpd_error_is_defined(&async->error))
-		return false;
-
-	room = mpd_buffer_room(&async->output);
-	length = strlen(command);
-	if (room <= length)
-		return false;
-
-	dest = mpd_buffer_write(&async->output);
 	/* -1 because we reserve space for the \n character */
-	end = dest + room - 1;
-
-	/* copy the command (no quoting, we asumme it is "clean") */
-
-	memcpy(dest, command, length);
-	p = dest + length;
+	/**
+	 * mpd_async_send_command_v() guarantees that mpd_buffer_room() has at
+	 * least 1 position available (length + 1)
+	 */
+	assert(mpd_buffer_room(buffer) >= 1);
+	end = start + mpd_buffer_room(buffer) - 1;
+	p = start;
 
 	/* now append all arguments (quoted) */
-
 	while ((arg = va_arg(args, const char *)) != NULL) {
 		/* append a space separator */
-
 		if (p >= end)
 			return false;
 
@@ -317,17 +316,57 @@ mpd_async_send_command_v(struct mpd_async *async, const char *command,
 		/* quote the argument into the destination buffer */
 
 		p = quote(p, end, arg);
-		assert(p == NULL || (p >= dest && p <= end));
+		assert(p == NULL || (p >= start && p <= end));
 		if (p == NULL)
 			return false;
 	}
 
-
 	/* append the newline to finish this command */
-
 	*p++ = '\n';
+	*end_pos = p;
+	return true;
+}
+
+bool
+mpd_async_send_command_v(struct mpd_async *async, const char *command,
+			 va_list args)
+{
+	char *end_pos = NULL, *write_p;
+	bool success = false;
+	size_t length;
+	va_list cargs;
+
+	assert(async != NULL);
+	assert(command != NULL);
+
+	if (mpd_error_is_defined(&async->error))
+		return false;
+
+	length = strlen(command);
+	/* we need a '\n' at the end */
+	if (!mpd_buffer_make_room(&async->output, length + 1)) {
+		mpd_error_code(&async->error, MPD_ERROR_OOM);
+		return false;
+	}
+
+	/* copy the command (no quoting, we assume it is "clean") */
+	memcpy(mpd_buffer_write(&async->output), command, length);
+	mpd_buffer_expand(&async->output, length);
+
+	while (!success) {
+		va_copy(cargs, args);
+		write_p = mpd_buffer_write(&async->output);
+		success = quote_vargs(&async->output, write_p, &end_pos, cargs);
+		va_end(cargs);
+		if (!success) {
+			if (!mpd_buffer_double_buffer_size(&async->output)) {
+				mpd_error_code(&async->error, MPD_ERROR_OOM);
+				return false;
+			}
+		}
+	}
 
-	mpd_buffer_expand(&async->output, p - dest);
+	mpd_buffer_expand(&async->output, end_pos - write_p);
 	return true;
 }
 

src/buffer.h

@@ -32,10 +32,10 @@
 #include <assert.h>
 #include <string.h>
 #include <stdbool.h>
+#include <stdlib.h>
 
 /**
- * A fixed 4kB buffer which can be appended at the end, and consumed
- * at the beginning.
+ * A buffer which can be appended at the end, and consumed at the beginning.
  */
 struct mpd_buffer {
 	/** the next buffer position to write to */
@@ -45,17 +45,37 @@ struct mpd_buffer {
 	unsigned read;
 
 	/** the actual buffer */
-	unsigned char data[4096];
+	unsigned char *data;
+
+	/** size of buffer */
+	size_t data_len;
 };
 
 /**
  * Initialize an empty buffer.
  */
-static inline void
+static inline void *
 mpd_buffer_init(struct mpd_buffer *buffer)
 {
+	const size_t std_data_len = 4096;
+
 	buffer->read = 0;
 	buffer->write = 0;
+	buffer->data_len = std_data_len;
+	buffer->data = malloc(buffer->data_len);
+	if (buffer->data != NULL)
+		memset(buffer->data, 0, buffer->data_len);
+
+	return buffer->data;
+}
+
+/**
+ * Free the buffer area.
+ */
+static inline void
+mpd_buffer_end(struct mpd_buffer *buffer)
+{
+	free(buffer->data);
 }
 
 /**
@@ -79,12 +99,13 @@ mpd_buffer_move(struct mpd_buffer *buffer)
 static inline size_t
 mpd_buffer_room(const struct mpd_buffer *buffer)
 {
-	assert(buffer->write <= sizeof(buffer->data));
+	assert(buffer->write <= buffer->data_len);
 	assert(buffer->read <= buffer->write);
 
-	return sizeof(buffer->data) - (buffer->write - buffer->read);
+	return buffer->data_len - (buffer->write - buffer->read);
 }
 
+
 /**
  * Checks if the buffer is full, i.e. nothing can be written.
  */
@@ -125,7 +146,7 @@ mpd_buffer_expand(struct mpd_buffer *buffer, size_t nbytes)
 static inline size_t
 mpd_buffer_size(const struct mpd_buffer *buffer)
 {
-	assert(buffer->write <= sizeof(buffer->data));
+	assert(buffer->write <= buffer->data_len);
 	assert(buffer->read <= buffer->write);
 
 	return buffer->write - buffer->read;
@@ -154,4 +175,50 @@ mpd_buffer_consume(struct mpd_buffer *buffer, size_t nbytes)
 	buffer->read += nbytes;
 }
 
+/**
+ * Makes at least min_size bytes available for writing data.
+ * In other words, mpd_buffer_room() will be >= min_size if called after this
+ * function.
+ */
+static inline bool
+mpd_buffer_make_room(struct mpd_buffer *buffer, size_t min_avail_len)
+{
+	size_t newsize;
+
+	if (mpd_buffer_room(buffer) >= min_avail_len)
+		return true;
+
+	newsize = buffer->data_len * 2;
+	while (newsize < min_avail_len)
+		newsize *= 2;
+
+	/* empty buffer */
+	if (mpd_buffer_room(buffer) == buffer->data_len) {
+		free(buffer->data);
+		buffer->data = malloc(newsize);
+		if (buffer->data == NULL)
+			return false;
+		memset(buffer->data, 0, newsize);
+	} else {
+		buffer->data = realloc(buffer->data, newsize);
+		if (buffer->data == NULL)
+			return false;
+
+		/* clear region not committed and new region */
+		memset(mpd_buffer_write(buffer), 0,
+		       newsize - (buffer->data_len - mpd_buffer_room(buffer)));
+	}
+	buffer->data_len = newsize;
+	return true;
+}
+
+/**
+ * Double the buffer area.
+ */
+static inline bool
+mpd_buffer_double_buffer_size(struct mpd_buffer *buffer)
+{
+	return mpd_buffer_make_room(buffer, buffer->data_len * 2);
+}
+
 #endif

src/sync.c

@@ -100,27 +100,7 @@ bool
 mpd_sync_send_command_v(struct mpd_async *async, const struct timeval *tv0,
 			const char *command, va_list args)
 {
-	struct timeval tv, *tvp;
-	va_list copy;
-	bool success;
-
-	if (tv0 != NULL) {
-		tv = *tv0;
-		tvp = &tv;
-	} else
-		tvp = NULL;
-
-	while (true) {
-		va_copy(copy, args);
-		success = mpd_async_send_command_v(async, command, copy);
-		va_end(copy);
-
-		if (success)
-			return true;
-
-		if (!mpd_sync_io(async, tvp))
-			return false;
-	}
+	return mpd_async_send_command_v(async, command, args);
 }
 
 bool