1 files changed, 270 insertions, 175 deletions

diff --git a/src/interface.c b/src/interface.c
index dbec9b8a9..a75890ac4 100644
--- a/src/interface.c
+++ b/src/interface.c
@@ -24,7 +24,7 @@
 #include "listen.h"
 #include "playlist.h"
 #include "permission.h"
-#include "sig_handlers.h"
+#include "sllist.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -41,7 +41,7 @@
 #include <errno.h>
 #include <signal.h>
 
-#define GREETING 		"OK MPD"
+#define GREETING					"OK MPD " VERSION "\n"
 
 #define INTERFACE_MAX_BUFFER_LENGTH			(40960)
 #define INTERFACE_LIST_MODE_BEGIN			"command_list_begin"
@@ -61,26 +61,36 @@ static size_t interface_max_command_list_size =
 static size_t interface_max_output_buffer_size =
     INTERFACE_MAX_OUTPUT_BUFFER_SIZE_DEFAULT;
 
+/* maybe make conf option for this, or... 32 might be good enough */
+static long int interface_list_cache_size = 32;
+
+/* shared globally between all interfaces: */
+static struct strnode *list_cache = NULL;
+static struct strnode *list_cache_head = NULL;
+static struct strnode *list_cache_tail = NULL;
+
 typedef struct _Interface {
 	char buffer[INTERFACE_MAX_BUFFER_LENGTH];
 	int bufferLength;
 	int bufferPos;
 	int fd;	/* file descriptor */
-	FILE *fp;	/* file pointer */
-	int open;	/* open/used */
 	int permission;
 	time_t lastTime;
-	List *commandList;	/* for when in list mode */
-	int commandListOK;	/* print OK after each command execution */
-	size_t commandListSize;	/* mem commandList consumes */
-	List *bufferList;	/* for output if client is slow */
-	size_t outputBufferSize;	/* mem bufferList consumes */
+	struct strnode *cmd_list;	/* for when in list mode */
+	struct strnode *cmd_list_tail;	/* for when in list mode */
+	int cmd_list_OK;	/* print OK after each command execution */
+	int cmd_list_size;	/* mem cmd_list consumes */
+	int cmd_list_dup;	/* has the cmd_list been copied to private space? */
+	struct sllnode *deferred_send;	/* for output if client is slow */
+	int deferred_bytes;	/* mem deferred_send consumes */
 	int expired;	/* set whether this interface should be closed on next
 			   check of old interfaces */
 	int num;	/* interface number */
-	char *outBuffer;
-	int outBuflen;
-	int outBufSize;
+
+	char *send_buf;
+	int send_buf_used;	/* bytes used this instance */
+	int send_buf_size;	/* bytes usable this instance */
+	int send_buf_alloc;	/* bytes actually allocated */
 } Interface;
 
 static Interface *interfaces = NULL;
@@ -89,66 +99,150 @@ static void flushInterfaceBuffer(Interface * interface);
 
 static void printInterfaceOutBuffer(Interface * interface);
 
+#ifdef SO_SNDBUF
+static int get_default_snd_buf_size(Interface * interface)
+{
+	int new_size;
+	socklen_t sockOptLen = sizeof(int);
+
+	if (getsockopt(interface->fd, SOL_SOCKET, SO_SNDBUF,
+		       (char *)&new_size, &sockOptLen) < 0) {
+		DEBUG("problem getting sockets send buffer size\n");
+		return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
+	}
+	if (new_size > 0)
+		return new_size;
+	DEBUG("sockets send buffer size is not positive\n");
+	return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
+}
+#else /* !SO_SNDBUF */
+static int get_default_snd_buf_size(Interface * interface)
+{
+	return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
+}
+#endif /* !SO_SNDBUF */
+
+static void set_send_buf_size(Interface * interface)
+{
+	int new_size = get_default_snd_buf_size(interface);
+	if (interface->send_buf_size != new_size) {
+		interface->send_buf_size = new_size;
+		/* don't resize to get smaller, only bigger */
+		if (interface->send_buf_alloc < new_size) {
+			if (interface->send_buf)
+				free(interface->send_buf);
+			interface->send_buf = malloc(new_size);
+			interface->send_buf_alloc = new_size;
+		}
+	}
+}
+
 static void openInterface(Interface * interface, int fd)
 {
 	int flags;
 
-	assert(interface->open == 0);
+	assert(interface->fd < 0);
 
+	interface->cmd_list_size = 0;
+	interface->cmd_list_dup = 0;
+	interface->cmd_list_OK = -1;
 	interface->bufferLength = 0;
 	interface->bufferPos = 0;
 	interface->fd = fd;
-	/* fcntl(interface->fd,F_SETOWN,(int)getpid()); */
 	while ((flags = fcntl(fd, F_GETFL)) < 0 && errno == EINTR) ;
-	flags |= O_NONBLOCK;
-	while (fcntl(interface->fd, F_SETFL, flags) < 0 && errno == EINTR) ;
-	while ((interface->fp = fdopen(fd, "rw")) == NULL && errno == EINTR) ;
-	interface->open = 1;
+	while (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0 && errno == EINTR) ;
 	interface->lastTime = time(NULL);
-	interface->commandList = NULL;
-	interface->bufferList = NULL;
+	interface->cmd_list = NULL;
+	interface->cmd_list_tail = NULL;
+	interface->deferred_send = NULL;
 	interface->expired = 0;
-	interface->outputBufferSize = 0;
-	interface->outBuflen = 0;
+	interface->deferred_bytes = 0;
+	interface->send_buf_used = 0;
 
 	interface->permission = getDefaultPermissions();
+	set_send_buf_size(interface);
 
-	interface->outBufSize = INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
-#ifdef SO_SNDBUF
-	{
-		int getSize;
-		unsigned int sockOptLen = sizeof(int);
-
-		if (getsockopt(interface->fd, SOL_SOCKET, SO_SNDBUF,
-			       (char *)&getSize, &sockOptLen) < 0) {
-			DEBUG("problem getting sockets send buffer size\n");
-		} else if (getSize <= 0) {
-			DEBUG("sockets send buffer size is not positive\n");
+	xwrite(fd, GREETING, strlen(GREETING));
+}
+
+static void free_cmd_list(struct strnode *list)
+{
+	struct strnode *tmp = list;
+
+	while (tmp) {
+		struct strnode *next = tmp->next;
+		if (tmp >= list_cache_head && tmp <= list_cache_tail) {
+			/* inside list_cache[] array */
+			tmp->data = NULL;
+			tmp->next = NULL;
 		} else
-			interface->outBufSize = getSize;
+			free(tmp);
+		tmp = next;
 	}
-#endif
-	interface->outBuffer = malloc(interface->outBufSize);
+}
 
-	myfprintf(interface->fp, "%s %s\n", GREETING, VERSION);
-	printInterfaceOutBuffer(interface);
+static void cmd_list_clone(Interface * interface)
+{
+	struct strnode *new = dup_strlist(interface->cmd_list);
+	free_cmd_list(interface->cmd_list);
+	interface->cmd_list = new;
+	interface->cmd_list_dup = 1;
+
+	/* new tail */
+	while (new && new->next)
+		new = new->next;
+	interface->cmd_list_tail = new;
 }
 
-static void closeInterface(Interface * interface)
+static void new_cmd_list_ptr(Interface * interface, char *s, const int size)
 {
-	if (!interface->open)
-		return;
+	int i;
+	struct strnode *new;
+
+	if (!interface->cmd_list_dup) {
+		for (i = interface_list_cache_size - 1; i >= 0; --i) {
+			if (list_cache[i].data)
+				continue;
+			new = &(list_cache[i]);
+			new->data = s;
+			/* implied in free_cmd_list() and init: */
+			/* last->next->next = NULL; */
+			goto out;
+		}
+	}
 
-	interface->open = 0;
+	/* allocate from the heap */
+	new = interface->cmd_list_dup ? new_strnode_dup(s, size)
+	                              : new_strnode(s);
+out:
+	if (interface->cmd_list) {
+		interface->cmd_list_tail->next = new;
+		interface->cmd_list_tail = new;
+	} else
+		interface->cmd_list = interface->cmd_list_tail = new;
+}
 
-	while (fclose(interface->fp) && errno == EINTR) ;
+static void closeInterface(Interface * interface)
+{
+	struct sllnode *buf;
+	if (interface->fd < 0)
+		return;
+	xclose(interface->fd);
+	interface->fd = -1;
 
-	if (interface->commandList)
-		freeList(interface->commandList);
-	if (interface->bufferList)
-		freeList(interface->bufferList);
+	if (interface->cmd_list) {
+		free_cmd_list(interface->cmd_list);
+		interface->cmd_list = NULL;
+	}
 
-	free(interface->outBuffer);
+	if ((buf = interface->deferred_send)) {
+		do {
+			struct sllnode *prev = buf;
+			buf = buf->next;
+			free(prev);
+		} while (buf);
+		interface->deferred_send = NULL;
+	}
 
 	SECURE("interface %i: closed\n", interface->num);
 }
@@ -157,11 +251,12 @@ void openAInterface(int fd, struct sockaddr *addr)
 {
 	int i;
 
-	for (i = 0; i < interface_max_connections && interfaces[i].open; i++) ;
+	for (i = 0; i < interface_max_connections
+	     && interfaces[i].fd >= 0; i++) /* nothing */ ;
 
 	if (i == interface_max_connections) {
 		ERROR("Max Connections Reached!\n");
-		while (close(fd) && errno == EINTR) ;
+		xclose(fd);
 	} else {
 		SECURE("interface %i: opened from ", i);
 		switch (addr->sa_family) {
@@ -207,74 +302,60 @@ static int processLineOfInput(Interface * interface)
 	int ret = 1;
 	char *line = interface->buffer + interface->bufferPos;
 
-	if (interface->bufferLength - interface->bufferPos > 1) {
-		if (interface->buffer[interface->bufferLength - 2] == '\r') {
-			interface->buffer[interface->bufferLength - 2] = '\0';
-		}
-	}
-
-	if (interface->commandList) {
+	if (interface->cmd_list_OK >= 0) {
 		if (strcmp(line, INTERFACE_LIST_MODE_END) == 0) {
 			DEBUG("interface %i: process command "
 			      "list\n", interface->num);
-			ret = processListOfCommands(interface->fp,
+			ret = processListOfCommands(interface->fd,
 						    &(interface->permission),
 						    &(interface->expired),
-						    interface->commandListOK,
-						    interface->commandList);
+						    interface->cmd_list_OK,
+						    interface->cmd_list);
 			DEBUG("interface %i: process command "
 			      "list returned %i\n", interface->num, ret);
 			if (ret == 0)
-				commandSuccess(interface->fp);
+				commandSuccess(interface->fd);
 			else if (ret == COMMAND_RETURN_CLOSE
-				 || interface->expired) {
-
+				 || interface->expired)
 				closeInterface(interface);
-			}
-			printInterfaceOutBuffer(interface);
 
-			freeList(interface->commandList);
-			interface->commandList = NULL;
+			printInterfaceOutBuffer(interface);
+			free_cmd_list(interface->cmd_list);
+			interface->cmd_list = NULL;
+			interface->cmd_list_OK = -1;
 		} else {
-			interface->commandListSize += sizeof(ListNode);
-			interface->commandListSize += strlen(line) + 1;
-			if (interface->commandListSize >
+			size_t len = strlen(line) + 1;
+			interface->cmd_list_size += len;
+			if (interface->cmd_list_size >
 			    interface_max_command_list_size) {
 				ERROR("interface %i: command "
-				      "list size (%lli) is "
+				      "list size (%i) is "
 				      "larger than the max "
-				      "(%lli)\n",
+				      "(%i)\n",
 				      interface->num,
-				      (long long)interface->
-				      commandListSize, (long long)
+				      interface->cmd_list_size,
 				      interface_max_command_list_size);
 				closeInterface(interface);
 				ret = COMMAND_RETURN_CLOSE;
-			} else {
-				insertInListWithoutKey(interface->commandList,
-						       strdup(line));
-			}
+			} else
+				new_cmd_list_ptr(interface, line, len);
 		}
 	} else {
 		if (strcmp(line, INTERFACE_LIST_MODE_BEGIN) == 0) {
-			interface->commandList = makeList(free, 1);
-			interface->commandListSize = sizeof(List);
-			interface->commandListOK = 0;
+			interface->cmd_list_OK = 0;
 			ret = 1;
 		} else if (strcmp(line, INTERFACE_LIST_OK_MODE_BEGIN) == 0) {
-			interface->commandList = makeList(free, 1);
-			interface->commandListSize = sizeof(List);
-			interface->commandListOK = 1;
+			interface->cmd_list_OK = 1;
 			ret = 1;
 		} else {
 			DEBUG("interface %i: process command \"%s\"\n",
 			      interface->num, line);
-			ret = processCommand(interface->fp,
+			ret = processCommand(interface->fd,
 					     &(interface->permission), line);
 			DEBUG("interface %i: command returned %i\n",
 			      interface->num, ret);
 			if (ret == 0)
-				commandSuccess(interface->fp);
+				commandSuccess(interface->fd);
 			else if (ret == COMMAND_RETURN_CLOSE
 				 || interface->expired) {
 				closeInterface(interface);
@@ -289,12 +370,18 @@ static int processLineOfInput(Interface * interface)
 static int processBytesRead(Interface * interface, int bytesRead)
 {
 	int ret = 0;
+	char *buf_tail = &(interface->buffer[interface->bufferLength - 1]);
 
 	while (bytesRead > 0) {
 		interface->bufferLength++;
 		bytesRead--;
-		if (interface->buffer[interface->bufferLength - 1] == '\n') {
-			interface->buffer[interface->bufferLength - 1] = '\0';
+		buf_tail++;
+		if (*buf_tail == '\n') {
+			*buf_tail = '\0';
+			if (interface->bufferLength - interface->bufferPos > 1) {
+				if (*(buf_tail - 1) == '\r')
+					*(buf_tail - 1) = '\0';
+			}
 			ret = processLineOfInput(interface);
 			interface->bufferPos = interface->bufferLength;
 		}
@@ -305,6 +392,9 @@ static int processBytesRead(Interface * interface, int bytesRead)
 				closeInterface(interface);
 				return 1;
 			}
+			if (interface->cmd_list_OK >= 0 &&
+			    !interface->cmd_list_dup)
+				cmd_list_clone(interface);
 			interface->bufferLength -= interface->bufferPos;
 			memmove(interface->buffer,
 				interface->buffer + interface->bufferPos,
@@ -347,8 +437,8 @@ static void addInterfacesReadyToReadAndListenSocketToFdSet(fd_set * fds,
 	addListenSocketsToFdSet(fds, fdmax);
 
 	for (i = 0; i < interface_max_connections; i++) {
-		if (interfaces[i].open && !interfaces[i].expired
-		    && !interfaces[i].bufferList) {
+		if (interfaces[i].fd >= 0 && !interfaces[i].expired
+		    && !interfaces[i].deferred_send) {
 			FD_SET(interfaces[i].fd, fds);
 			if (*fdmax < interfaces[i].fd)
 				*fdmax = interfaces[i].fd;
@@ -363,8 +453,8 @@ static void addInterfacesForBufferFlushToFdSet(fd_set * fds, int *fdmax)
 	FD_ZERO(fds);
 
 	for (i = 0; i < interface_max_connections; i++) {
-		if (interfaces[i].open && !interfaces[i].expired
-		    && interfaces[i].bufferList) {
+		if (interfaces[i].fd >= 0 && !interfaces[i].expired
+		    && interfaces[i].deferred_send) {
 			FD_SET(interfaces[i].fd, fds);
 			if (*fdmax < interfaces[i].fd)
 				*fdmax = interfaces[i].fd;
@@ -382,7 +472,7 @@ static void closeNextErroredInterface(void)
 	tv.tv_usec = 0;
 
 	for (i = 0; i < interface_max_connections; i++) {
-		if (interfaces[i].open) {
+		if (interfaces[i].fd >= 0) {
 			FD_ZERO(&fds);
 			FD_SET(interfaces[i].fd, &fds);
 			if (select(FD_SETSIZE, &fds, NULL, NULL, &tv) < 0) {
@@ -424,7 +514,7 @@ int doIOForInterfaces(void)
 		getConnections(&rfds);
 
 		for (i = 0; i < interface_max_connections; i++) {
-			if (interfaces[i].open
+			if (interfaces[i].fd >= 0
 			    && FD_ISSET(interfaces[i].fd, &rfds)) {
 				if (COMMAND_RETURN_KILL ==
 				    interfaceReadInput(&(interfaces[i]))) {
@@ -432,7 +522,7 @@ int doIOForInterfaces(void)
 				}
 				interfaces[i].lastTime = time(NULL);
 			}
-			if (interfaces[i].open
+			if (interfaces[i].fd >= 0
 			    && FD_ISSET(interfaces[i].fd, &wfds)) {
 				flushInterfaceBuffer(&interfaces[i]);
 				interfaces[i].lastTime = time(NULL);
@@ -504,8 +594,15 @@ void initInterfaces(void)
 
 	interfaces = malloc(sizeof(Interface) * interface_max_connections);
 
+	list_cache = calloc(interface_list_cache_size, sizeof(struct strnode));
+	list_cache_head = &(list_cache[0]);
+	list_cache_tail = &(list_cache[interface_list_cache_size - 1]);
+
 	for (i = 0; i < interface_max_connections; i++) {
-		interfaces[i].open = 0;
+		interfaces[i].fd = -1;
+		interfaces[i].send_buf = NULL;
+		interfaces[i].send_buf_size = 0;
+		interfaces[i].send_buf_alloc = 0;
 		interfaces[i].num = i;
 	}
 }
@@ -514,13 +611,13 @@ static void closeAllInterfaces(void)
 {
 	int i;
 
-	fflush(NULL);
-
 	for (i = 0; i < interface_max_connections; i++) {
-		if (interfaces[i].open) {
+		if (interfaces[i].fd > 0)
 			closeInterface(&(interfaces[i]));
-		}
+		if (interfaces[i].send_buf)
+			free(interfaces[i].send_buf);
 	}
+	free(list_cache);
 }
 
 void freeAllInterfaces(void)
@@ -537,7 +634,7 @@ void closeOldInterfaces(void)
 	int i;
 
 	for (i = 0; i < interface_max_connections; i++) {
-		if (interfaces[i].open) {
+		if (interfaces[i].fd > 0) {
 			if (interfaces[i].expired) {
 				DEBUG("interface %i: expired\n", i);
 				closeInterface(&(interfaces[i]));
@@ -552,37 +649,45 @@ void closeOldInterfaces(void)
 
 static void flushInterfaceBuffer(Interface * interface)
 {
-	ListNode *node = NULL;
-	char *str;
+	struct sllnode *buf;
 	int ret = 0;
 
-	while ((node = interface->bufferList->firstNode)) {
-		str = (char *)node->data;
-		if ((ret = write(interface->fd, str, strlen(str))) < 0)
+	buf = interface->deferred_send;
+	while (buf) {
+		ret = write(interface->fd, buf->data, buf->size);
+		if (ret < 0)
 			break;
-		else if (ret < strlen(str)) {
-			interface->outputBufferSize -= ret;
-			str = strdup(&str[ret]);
-			free(node->data);
-			node->data = str;
+		else if (ret < buf->size) {
+			interface->deferred_bytes -= ret;
+			buf->data += ret;
+			buf->size -= ret;
 		} else {
-			interface->outputBufferSize -= strlen(str) + 1;
-			interface->outputBufferSize -= sizeof(ListNode);
-			deleteNodeFromList(interface->bufferList, node);
+			struct sllnode *tmp = buf;
+			interface->deferred_bytes -= (buf->size +
+						      sizeof(struct sllnode));
+			buf = buf->next;
+			free(tmp);
+			interface->deferred_send = buf;
 		}
 		interface->lastTime = time(NULL);
 	}
 
-	if (!interface->bufferList->firstNode) {
-		DEBUG("interface %i: buffer empty\n", interface->num);
-		freeList(interface->bufferList);
-		interface->bufferList = NULL;
+	if (!interface->deferred_send) {
+		DEBUG("interface %i: buffer empty %i\n", interface->num,
+		      interface->deferred_bytes);
+		assert(interface->deferred_bytes == 0);
 	} else if (ret < 0 && errno != EAGAIN && errno != EINTR) {
 		/* cause interface to close */
 		DEBUG("interface %i: problems flushing buffer\n",
 		      interface->num);
-		freeList(interface->bufferList);
-		interface->bufferList = NULL;
+		buf = interface->deferred_send;
+		do {
+			struct sllnode *prev = buf;
+			buf = buf->next;
+			free(prev);
+		} while (buf);
+		interface->deferred_send = NULL;
+		interface->deferred_bytes = 0;
 		interface->expired = 1;
 	}
 }
@@ -593,10 +698,12 @@ int interfacePrintWithFD(int fd, char *buffer, int buflen)
 	int copylen;
 	Interface *interface;
 
+	assert(fd > 0);
+
 	if (i >= interface_max_connections ||
-	    !interfaces[i].open || interfaces[i].fd != fd) {
+	    interfaces[i].fd < 0 || interfaces[i].fd != fd) {
 		for (i = 0; i < interface_max_connections; i++) {
-			if (interfaces[i].open && interfaces[i].fd == fd)
+			if (interfaces[i].fd == fd)
 				break;
 		}
 		if (i == interface_max_connections)
@@ -610,17 +717,15 @@ int interfacePrintWithFD(int fd, char *buffer, int buflen)
 	interface = interfaces + i;
 
 	while (buflen > 0 && !interface->expired) {
-		copylen = buflen >
-		    interface->outBufSize - interface->outBuflen ?
-		    interface->outBufSize - interface->outBuflen : buflen;
-		memcpy(interface->outBuffer + interface->outBuflen, buffer,
+		int left = interface->send_buf_size - interface->send_buf_used;
+		copylen = buflen > left ? left : buflen;
+		memcpy(interface->send_buf + interface->send_buf_used, buffer,
 		       copylen);
 		buflen -= copylen;
-		interface->outBuflen += copylen;
+		interface->send_buf_used += copylen;
 		buffer += copylen;
-		if (interface->outBuflen >= interface->outBufSize) {
+		if (interface->send_buf_used >= interface->send_buf_size)
 			printInterfaceOutBuffer(interface);
-		}
 	}
 
 	return 0;
@@ -628,73 +733,63 @@ int interfacePrintWithFD(int fd, char *buffer, int buflen)
 
 static void printInterfaceOutBuffer(Interface * interface)
 {
-	char *buffer;
 	int ret;
+	struct sllnode *buf;
 
-	if (!interface->open || interface->expired || !interface->outBuflen) {
+	if (interface->fd < 0 || interface->expired ||
+	    !interface->send_buf_used)
 		return;
-	}
 
-	if (interface->bufferList) {
-		interface->outputBufferSize += sizeof(ListNode);
-		interface->outputBufferSize += interface->outBuflen + 1;
-		if (interface->outputBufferSize >
+	if ((buf = interface->deferred_send)) {
+		interface->deferred_bytes += sizeof(struct sllnode)
+		                             + interface->send_buf_used;
+		if (interface->deferred_bytes >
 		    interface_max_output_buffer_size) {
-			ERROR("interface %i: output buffer size (%lli) is "
-			      "larger than the max (%lli)\n",
+			ERROR("interface %i: output buffer size (%li) is "
+			      "larger than the max (%li)\n",
 			      interface->num,
-			      (long long)interface->outputBufferSize,
-			      (long long)interface_max_output_buffer_size);
+			      (long)interface->deferred_bytes,
+			      (long)interface_max_output_buffer_size);
 			/* cause interface to close */
-			freeList(interface->bufferList);
-			interface->bufferList = NULL;
 			interface->expired = 1;
+			do {
+				struct sllnode *prev = buf;
+				buf = buf->next;
+				free(prev);
+			} while (buf);
+			interface->deferred_send = NULL;
+			interface->deferred_bytes = 0;
 		} else {
-			buffer = malloc(interface->outBuflen + 1);
-			memcpy(buffer, interface->outBuffer,
-			       interface->outBuflen);
-			buffer[interface->outBuflen] = '\0';
-			insertInListWithoutKey(interface->bufferList,
-					       (void *)buffer);
-			flushInterfaceBuffer(interface);
+			while (buf->next)
+				buf = buf->next;
+			buf->next = new_sllnode(interface->send_buf,
+						interface->send_buf_used);
 		}
 	} else {
-		if ((ret = write(interface->fd, interface->outBuffer,
-				 interface->outBuflen)) < 0) {
+		if ((ret = write(interface->fd, interface->send_buf,
+				 interface->send_buf_used)) < 0) {
 			if (errno == EAGAIN || errno == EINTR) {
-				buffer = malloc(interface->outBuflen + 1);
-				memcpy(buffer, interface->outBuffer,
-				       interface->outBuflen);
-				buffer[interface->outBuflen] = '\0';
-				interface->bufferList = makeList(free, 1);
-				insertInListWithoutKey(interface->bufferList,
-						       (void *)buffer);
+				interface->deferred_send =
+				    new_sllnode(interface->send_buf,
+						interface->send_buf_used);
 			} else {
 				DEBUG("interface %i: problems writing\n",
 				      interface->num);
 				interface->expired = 1;
 				return;
 			}
-		} else if (ret < interface->outBuflen) {
-			buffer = malloc(interface->outBuflen - ret + 1);
-			memcpy(buffer, interface->outBuffer + ret,
-			       interface->outBuflen - ret);
-			buffer[interface->outBuflen - ret] = '\0';
-			interface->bufferList = makeList(free, 1);
-			insertInListWithoutKey(interface->bufferList, buffer);
+		} else if (ret < interface->send_buf_used) {
+			interface->deferred_send =
+			    new_sllnode(interface->send_buf + ret,
+					interface->send_buf_used - ret);
 		}
-		/* if we needed to create buffer, initialize bufferSize info */
-		if (interface->bufferList) {
+		if (interface->deferred_send) {
 			DEBUG("interface %i: buffer created\n", interface->num);
-			interface->outputBufferSize = sizeof(List);
-			interface->outputBufferSize += sizeof(ListNode);
-			interface->outputBufferSize += strlen((char *)
-							      interface->
-							      bufferList->
-							      firstNode->data) +
-			    1;
+			interface->deferred_bytes =
+			    interface->deferred_send->size
+			    + sizeof(struct sllnode);
 		}
 	}
 
-	interface->outBuflen = 0;
+	interface->send_buf_used = 0;
 }