1 files changed, 209 insertions, 210 deletions

diff --git a/src/client.c b/src/client.c
index ce8d731a6..c3ed7fec5 100644
--- a/src/client.c
+++ b/src/client.c
@@ -87,17 +87,17 @@ struct client {
 static LIST_HEAD(clients);
 static unsigned num_clients;
 
-static void client_write_deferred(struct client *client);
+static void client_write_deferred(struct client *cl);
 
-static void client_write_output(struct client *client);
+static void client_write_output(struct client *cl);
 
 #ifdef SO_SNDBUF
-static size_t get_default_snd_buf_size(struct client *client)
+static size_t get_default_snd_buf_size(struct client *cl)
 {
 	int new_size;
 	socklen_t sockOptLen = sizeof(int);
 
-	if (getsockopt(client->fd, SOL_SOCKET, SO_SNDBUF,
+	if (getsockopt(cl->fd, SOL_SOCKET, SO_SNDBUF,
 		       (char *)&new_size, &sockOptLen) < 0) {
 		DEBUG("problem getting sockets send buffer size\n");
 		return CLIENT_DEFAULT_OUT_BUFFER_SIZE;
@@ -108,67 +108,67 @@ static size_t get_default_snd_buf_size(struct client *client)
 	return CLIENT_DEFAULT_OUT_BUFFER_SIZE;
 }
 #else /* !SO_SNDBUF */
-static size_t get_default_snd_buf_size(struct client *client)
+static size_t get_default_snd_buf_size(struct client *cl)
 {
 	return CLIENT_DEFAULT_OUT_BUFFER_SIZE;
 }
 #endif /* !SO_SNDBUF */
 
-static void set_send_buf_size(struct client *client)
+static void set_send_buf_size(struct client *cl)
 {
-	size_t new_size = get_default_snd_buf_size(client);
-	if (client->send_buf_size != new_size) {
-		client->send_buf_size = new_size;
+	size_t new_size = get_default_snd_buf_size(cl);
+	if (cl->send_buf_size != new_size) {
+		cl->send_buf_size = new_size;
 		/* don't resize to get smaller, only bigger */
-		if (client->send_buf_alloc < new_size) {
-			if (client->send_buf)
-				free(client->send_buf);
-			client->send_buf = xmalloc(new_size);
-			client->send_buf_alloc = new_size;
+		if (cl->send_buf_alloc < new_size) {
+			if (cl->send_buf)
+				free(cl->send_buf);
+			cl->send_buf = xmalloc(new_size);
+			cl->send_buf_alloc = new_size;
 		}
 	}
 }
 
-static inline int client_is_expired(const struct client *client)
+static inline int client_is_expired(const struct client *cl)
 {
-	return client->fd < 0;
+	return cl->fd < 0;
 }
 
 static int global_expired;
 
-static inline void client_set_expired(struct client *client)
+static inline void client_set_expired(struct client *cl)
 {
-	if (client->fd >= 0) {
-		xclose(client->fd);
-		client->fd = -1;
+	if (cl->fd >= 0) {
+		xclose(cl->fd);
+		cl->fd = -1;
 	}
 
 	global_expired = 1;
 }
 
-static void client_init(struct client *client, int fd)
+static void client_init(struct client *cl, int fd)
 {
 	static unsigned int next_client_num;
 
 	assert(fd >= 0);
 
-	client->cmd_list_size = 0;
-	client->cmd_list_dup = 0;
-	client->cmd_list_OK = -1;
-	client->bufferLength = 0;
-	client->bufferPos = 0;
-	client->fd = fd;
+	cl->cmd_list_size = 0;
+	cl->cmd_list_dup = 0;
+	cl->cmd_list_OK = -1;
+	cl->bufferLength = 0;
+	cl->bufferPos = 0;
+	cl->fd = fd;
 	set_nonblocking(fd);
-	client->lastTime = time(NULL);
-	client->cmd_list = NULL;
-	client->cmd_list_tail = NULL;
-	client->deferred_send = NULL;
-	client->deferred_bytes = 0;
-	client->num = next_client_num++;
-	client->send_buf_used = 0;
+	cl->lastTime = time(NULL);
+	cl->cmd_list = NULL;
+	cl->cmd_list_tail = NULL;
+	cl->deferred_send = NULL;
+	cl->deferred_bytes = 0;
+	cl->num = next_client_num++;
+	cl->send_buf_used = 0;
 
-	client->permission = getDefaultPermissions();
-	set_send_buf_size(client);
+	cl->permission = getDefaultPermissions();
+	set_send_buf_size(cl);
 
 	xwrite(fd, GREETING, strlen(GREETING));
 }
@@ -189,25 +189,25 @@ static void free_cmd_list(struct strnode *list)
 	}
 }
 
-static void cmd_list_clone(struct client *client)
+static void cmd_list_clone(struct client *cl)
 {
-	struct strnode *new = dup_strlist(client->cmd_list);
-	free_cmd_list(client->cmd_list);
-	client->cmd_list = new;
-	client->cmd_list_dup = 1;
+	struct strnode *new = dup_strlist(cl->cmd_list);
+	free_cmd_list(cl->cmd_list);
+	cl->cmd_list = new;
+	cl->cmd_list_dup = 1;
 
 	/* new tail */
 	while (new && new->next)
 		new = new->next;
-	client->cmd_list_tail = new;
+	cl->cmd_list_tail = new;
 }
 
-static void new_cmd_list_ptr(struct client *client, char *s, const int size)
+static void new_cmd_list_ptr(struct client *cl, char *s, const int size)
 {
 	int i;
 	struct strnode *new;
 
-	if (!client->cmd_list_dup) {
+	if (!cl->cmd_list_dup) {
 		for (i = client_list_cache_size - 1; i >= 0; --i) {
 			if (list_cache[i].data)
 				continue;
@@ -220,46 +220,46 @@ static void new_cmd_list_ptr(struct client *client, char *s, const int size)
 	}
 
 	/* allocate from the heap */
-	new = client->cmd_list_dup ? new_strnode_dup(s, size)
+	new = cl->cmd_list_dup ? new_strnode_dup(s, size)
 	                              : new_strnode(s);
 out:
-	if (client->cmd_list) {
-		client->cmd_list_tail->next = new;
-		client->cmd_list_tail = new;
+	if (cl->cmd_list) {
+		cl->cmd_list_tail->next = new;
+		cl->cmd_list_tail = new;
 	} else
-		client->cmd_list = client->cmd_list_tail = new;
+		cl->cmd_list = cl->cmd_list_tail = new;
 }
 
-static void client_close(struct client *client)
+static void client_close(struct client *cl)
 {
 	struct sllnode *buf;
 
 	assert(num_clients > 0);
 	assert(!list_empty(&clients));
-	list_del(&client->siblings);
+	list_del(&cl->siblings);
 	--num_clients;
 
-	client_set_expired(client);
+	client_set_expired(cl);
 
-	if (client->cmd_list) {
-		free_cmd_list(client->cmd_list);
-		client->cmd_list = NULL;
+	if (cl->cmd_list) {
+		free_cmd_list(cl->cmd_list);
+		cl->cmd_list = NULL;
 	}
 
-	if ((buf = client->deferred_send)) {
+	if ((buf = cl->deferred_send)) {
 		do {
 			struct sllnode *prev = buf;
 			buf = buf->next;
 			free(prev);
 		} while (buf);
-		client->deferred_send = NULL;
+		cl->deferred_send = NULL;
 	}
 
-	if (client->send_buf)
-		free(client->send_buf);
+	if (cl->send_buf)
+		free(cl->send_buf);
 
-	SECURE("client %i: closed\n", client->num);
-	free(client);
+	SECURE("client %i: closed\n", cl->num);
+	free(cl);
 }
 
 static const char *
@@ -306,7 +306,7 @@ sockaddr_to_tmp_string(const struct sockaddr *addr)
 
 void client_new(int fd, const struct sockaddr *addr)
 {
-	struct client *client;
+	struct client *cl;
 
 	if (num_clients >= client_max_connections) {
 		ERROR("Max Connections Reached!\n");
@@ -314,145 +314,145 @@ void client_new(int fd, const struct sockaddr *addr)
 		return;
 	}
 
-	client = xcalloc(1, sizeof(*client));
-	list_add(&client->siblings, &clients);
+	cl = xcalloc(1, sizeof(struct client));
+	list_add(&cl->siblings, &clients);
 	++num_clients;
-	client_init(client, fd);
-	SECURE("client %i: opened from %s\n", client->num,
+	client_init(cl, fd);
+	SECURE("client %i: opened from %s\n", cl->num,
 	       sockaddr_to_tmp_string(addr));
 }
 
-static int client_process_line(struct client *client)
+static int client_process_line(struct client *cl)
 {
 	int ret = 1;
-	char *line = client->buffer + client->bufferPos;
+	char *line = cl->buffer + cl->bufferPos;
 
-	if (client->cmd_list_OK >= 0) {
+	if (cl->cmd_list_OK >= 0) {
 		if (strcmp(line, CLIENT_LIST_MODE_END) == 0) {
 			DEBUG("client %i: process command "
-			      "list\n", client->num);
+			      "list\n", cl->num);
 
 			global_expired = 0;
-			ret = processListOfCommands(client->fd,
-						    &(client->permission),
+			ret = processListOfCommands(cl->fd,
+						    &(cl->permission),
 						    &global_expired,
-						    client->cmd_list_OK,
-						    client->cmd_list);
+						    cl->cmd_list_OK,
+						    cl->cmd_list);
 			DEBUG("client %i: process command "
-			      "list returned %i\n", client->num, ret);
+			      "list returned %i\n", cl->num, ret);
 
 			if (ret == COMMAND_RETURN_CLOSE ||
-			    client_is_expired(client))
+			    client_is_expired(cl))
 				return COMMAND_RETURN_CLOSE;
 
 			if (ret == 0)
-				commandSuccess(client->fd);
+				commandSuccess(cl->fd);
 
-			client_write_output(client);
-			free_cmd_list(client->cmd_list);
-			client->cmd_list = NULL;
-			client->cmd_list_OK = -1;
+			client_write_output(cl);
+			free_cmd_list(cl->cmd_list);
+			cl->cmd_list = NULL;
+			cl->cmd_list_OK = -1;
 		} else {
 			size_t len = strlen(line) + 1;
-			client->cmd_list_size += len;
-			if (client->cmd_list_size >
+			cl->cmd_list_size += len;
+			if (cl->cmd_list_size >
 			    client_max_command_list_size) {
 				ERROR("client %i: command "
 				      "list size (%lu) is "
 				      "larger than the max "
 				      "(%lu)\n",
-				      client->num,
-				      (unsigned long)client->cmd_list_size,
+				      cl->num,
+				      (unsigned long)cl->cmd_list_size,
 				      (unsigned long)
 				      client_max_command_list_size);
 				return COMMAND_RETURN_CLOSE;
 			} else
-				new_cmd_list_ptr(client, line, len);
+				new_cmd_list_ptr(cl, line, len);
 		}
 	} else {
 		if (strcmp(line, CLIENT_LIST_MODE_BEGIN) == 0) {
-			client->cmd_list_OK = 0;
+			cl->cmd_list_OK = 0;
 			ret = 1;
 		} else if (strcmp(line, CLIENT_LIST_OK_MODE_BEGIN) == 0) {
-			client->cmd_list_OK = 1;
+			cl->cmd_list_OK = 1;
 			ret = 1;
 		} else {
 			DEBUG("client %i: process command \"%s\"\n",
-			      client->num, line);
-			ret = processCommand(client->fd,
-					     &(client->permission), line);
+			      cl->num, line);
+			ret = processCommand(cl->fd,
+					     &(cl->permission), line);
 			DEBUG("client %i: command returned %i\n",
-			      client->num, ret);
+			      cl->num, ret);
 
 			if (ret == COMMAND_RETURN_CLOSE ||
-			    client_is_expired(client))
+			    client_is_expired(cl))
 				return COMMAND_RETURN_CLOSE;
 
 			if (ret == 0)
-				commandSuccess(client->fd);
+				commandSuccess(cl->fd);
 
-			client_write_output(client);
+			client_write_output(cl);
 		}
 	}
 
 	return ret;
 }
 
-static int client_input_received(struct client *client, int bytesRead)
+static int client_input_received(struct client *cl, int bytesRead)
 {
 	int ret;
-	char *buf_tail = &(client->buffer[client->bufferLength - 1]);
+	char *buf_tail = &(cl->buffer[cl->bufferLength - 1]);
 
 	while (bytesRead > 0) {
-		client->bufferLength++;
+		cl->bufferLength++;
 		bytesRead--;
 		buf_tail++;
 		if (*buf_tail == '\n') {
 			*buf_tail = '\0';
-			if (client->bufferLength > client->bufferPos) {
+			if (cl->bufferLength > cl->bufferPos) {
 				if (*(buf_tail - 1) == '\r')
 					*(buf_tail - 1) = '\0';
 			}
-			ret = client_process_line(client);
+			ret = client_process_line(cl);
 			if (ret == COMMAND_RETURN_KILL ||
 			    ret == COMMAND_RETURN_CLOSE)
 				return ret;
-			assert(!client_is_expired(client));
-			client->bufferPos = client->bufferLength;
+			assert(!client_is_expired(cl));
+			cl->bufferPos = cl->bufferLength;
 		}
-		if (client->bufferLength == CLIENT_MAX_BUFFER_LENGTH) {
-			if (client->bufferPos == 0) {
+		if (cl->bufferLength == CLIENT_MAX_BUFFER_LENGTH) {
+			if (cl->bufferPos == 0) {
 				ERROR("client %i: buffer overflow\n",
-				      client->num);
+				      cl->num);
 				return COMMAND_RETURN_CLOSE;
 			}
-			if (client->cmd_list_OK >= 0 &&
-			    client->cmd_list &&
-			    !client->cmd_list_dup)
-				cmd_list_clone(client);
-			assert(client->bufferLength >= client->bufferPos
+			if (cl->cmd_list_OK >= 0 &&
+			    cl->cmd_list &&
+			    !cl->cmd_list_dup)
+				cmd_list_clone(cl);
+			assert(cl->bufferLength >= cl->bufferPos
 			       && "bufferLength >= bufferPos");
-			client->bufferLength -= client->bufferPos;
-			memmove(client->buffer,
-				client->buffer + client->bufferPos,
-				client->bufferLength);
-			client->bufferPos = 0;
+			cl->bufferLength -= cl->bufferPos;
+			memmove(cl->buffer,
+				cl->buffer + cl->bufferPos,
+				cl->bufferLength);
+			cl->bufferPos = 0;
 		}
 	}
 
 	return 0;
 }
 
-static int client_read(struct client *client)
+static int client_read(struct client *cl)
 {
 	int bytesRead;
 
-	bytesRead = read(client->fd,
-			 client->buffer + client->bufferLength,
-			 CLIENT_MAX_BUFFER_LENGTH - client->bufferLength);
+	bytesRead = read(cl->fd,
+			 cl->buffer + cl->bufferLength,
+			 CLIENT_MAX_BUFFER_LENGTH - cl->bufferLength);
 
 	if (bytesRead > 0)
-		return client_input_received(client, bytesRead);
+		return client_input_received(cl, bytesRead);
 	else if (bytesRead < 0 && errno == EINTR)
 		/* try again later, after select() */
 		return 0;
@@ -463,32 +463,32 @@ static int client_read(struct client *client)
 
 static void client_manager_register_read_fd(fd_set * fds, int *fdmax)
 {
-	struct client *client;
+	struct client *cl;
 
 	FD_ZERO(fds);
 	addListenSocketsToFdSet(fds, fdmax);
 
-	list_for_each_entry(client, &clients, siblings) {
-		if (!client_is_expired(client) && !client->deferred_send) {
-			FD_SET(client->fd, fds);
-			if (*fdmax < client->fd)
-				*fdmax = client->fd;
+	list_for_each_entry(cl, &clients, siblings) {
+		if (!client_is_expired(cl) && !cl->deferred_send) {
+			FD_SET(cl->fd, fds);
+			if (*fdmax < cl->fd)
+				*fdmax = cl->fd;
 		}
 	}
 }
 
 static void client_manager_register_write_fd(fd_set * fds, int *fdmax)
 {
-	struct client *client;
+	struct client *cl;
 
 	FD_ZERO(fds);
 
-	list_for_each_entry(client, &clients, siblings) {
-		if (client->fd >= 0 && !client_is_expired(client)
-		    && client->deferred_send) {
-			FD_SET(client->fd, fds);
-			if (*fdmax < client->fd)
-				*fdmax = client->fd;
+	list_for_each_entry(cl, &clients, siblings) {
+		if (cl->fd >= 0 && !client_is_expired(cl)
+		    && cl->deferred_send) {
+			FD_SET(cl->fd, fds);
+			if (*fdmax < cl->fd)
+				*fdmax = cl->fd;
 		}
 	}
 }
@@ -498,7 +498,7 @@ int client_manager_io(void)
 	fd_set rfds;
 	fd_set wfds;
 	fd_set efds;
-	struct client *client, *n;
+	struct client *cl, *n;
 	int ret;
 	int fdmax = 0;
 
@@ -521,24 +521,24 @@ int client_manager_io(void)
 
 	getConnections(&rfds);
 
-	list_for_each_entry_safe(client, n, &clients, siblings) {
-		if (FD_ISSET(client->fd, &rfds)) {
-			ret = client_read(client);
+	list_for_each_entry_safe(cl, n, &clients, siblings) {
+		if (FD_ISSET(cl->fd, &rfds)) {
+			ret = client_read(cl);
 			if (ret == COMMAND_RETURN_KILL)
 				return COMMAND_RETURN_KILL;
 			if (ret == COMMAND_RETURN_CLOSE) {
-				client_close(client);
+				client_close(cl);
 				continue;
 			}
 
-			assert(!client_is_expired(client));
+			assert(!client_is_expired(cl));
 
-			client->lastTime = time(NULL);
+			cl->lastTime = time(NULL);
 		}
-		if (!client_is_expired(client) &&
-		    FD_ISSET(client->fd, &wfds)) {
-			client_write_deferred(client);
-			client->lastTime = time(NULL);
+		if (!client_is_expired(cl) &&
+		    FD_ISSET(cl->fd, &wfds)) {
+			client_write_deferred(cl);
+			cl->lastTime = time(NULL);
 		}
 	}
 
@@ -601,10 +601,10 @@ void client_manager_init(void)
 
 static void client_close_all(void)
 {
-	struct client *client, *n;
+	struct client *cl, *n;
 
-	list_for_each_entry_safe(client, n, &clients, siblings)
-		client_close(client);
+	list_for_each_entry_safe(cl, n, &clients, siblings)
+		client_close(cl);
 	num_clients = 0;
 
 	free(list_cache);
@@ -619,69 +619,69 @@ void client_manager_deinit(void)
 
 void client_manager_expire(void)
 {
-	struct client *client, *n;
+	struct client *cl, *n;
 
-	list_for_each_entry_safe(client, n, &clients, siblings) {
-		if (client_is_expired(client)) {
-			DEBUG("client %i: expired\n", client->num);
-			client_close(client);
-		} else if (time(NULL) - client->lastTime >
+	list_for_each_entry_safe(cl, n, &clients, siblings) {
+		if (client_is_expired(cl)) {
+			DEBUG("client %i: expired\n", cl->num);
+			client_close(cl);
+		} else if (time(NULL) - cl->lastTime >
 			   client_timeout) {
-			DEBUG("client %i: timeout\n", client->num);
-			client_close(client);
+			DEBUG("client %i: timeout\n", cl->num);
+			client_close(cl);
 		}
 	}
 }
 
-static void client_write_deferred(struct client *client)
+static void client_write_deferred(struct client *cl)
 {
 	struct sllnode *buf;
 	ssize_t ret = 0;
 
-	buf = client->deferred_send;
+	buf = cl->deferred_send;
 	while (buf) {
 		assert(buf->size > 0);
 
-		ret = write(client->fd, buf->data, buf->size);
+		ret = write(cl->fd, buf->data, buf->size);
 		if (ret < 0)
 			break;
 		else if ((size_t)ret < buf->size) {
-			assert(client->deferred_bytes >= (size_t)ret);
-			client->deferred_bytes -= ret;
+			assert(cl->deferred_bytes >= (size_t)ret);
+			cl->deferred_bytes -= ret;
 			buf->data = (char *)buf->data + ret;
 			buf->size -= ret;
 		} else {
 			struct sllnode *tmp = buf;
 			size_t decr = (buf->size + sizeof(struct sllnode));
 
-			assert(client->deferred_bytes >= decr);
-			client->deferred_bytes -= decr;
+			assert(cl->deferred_bytes >= decr);
+			cl->deferred_bytes -= decr;
 			buf = buf->next;
 			free(tmp);
-			client->deferred_send = buf;
+			cl->deferred_send = buf;
 		}
-		client->lastTime = time(NULL);
+		cl->lastTime = time(NULL);
 	}
 
-	if (!client->deferred_send) {
-		DEBUG("client %i: buffer empty %lu\n", client->num,
-		      (unsigned long)client->deferred_bytes);
-		assert(client->deferred_bytes == 0);
+	if (!cl->deferred_send) {
+		DEBUG("client %i: buffer empty %lu\n", cl->num,
+		      (unsigned long)cl->deferred_bytes);
+		assert(cl->deferred_bytes == 0);
 	} else if (ret < 0 && errno != EAGAIN && errno != EINTR) {
 		/* cause client to close */
 		DEBUG("client %i: problems flushing buffer\n",
-		      client->num);
-		client_set_expired(client);
+		      cl->num);
+		client_set_expired(cl);
 	}
 }
 
-static struct client *client_by_fd(int fd)
+static struct client * client_by_fd(int fd)
 {
-	struct client *client;
+	struct client *cl;
 
-	list_for_each_entry(client, &clients, siblings)
-		if (client->fd == fd)
-			return client;
+	list_for_each_entry(cl, &clients, siblings)
+		if (cl->fd == fd)
+			return cl;
 
 	return NULL;
 }
@@ -689,97 +689,96 @@ static struct client *client_by_fd(int fd)
 int client_print(int fd, const char *buffer, size_t buflen)
 {
 	size_t copylen;
-	struct client *client;
+	struct client *cl;
 
 	assert(fd >= 0);
 
-	client = client_by_fd(fd);
-	if (client == NULL)
+	cl = client_by_fd(fd);
+	if (cl == NULL)
 		return -1;
 
 	/* if fd isn't found or client is going to be closed, do nothing */
-	if (client_is_expired(client))
+	if (client_is_expired(cl))
 		return 0;
 
-	while (buflen > 0 && !client_is_expired(client)) {
+	while (buflen > 0 && !client_is_expired(cl)) {
 		size_t left;
 
-		assert(client->send_buf_size >= client->send_buf_used);
-		left = client->send_buf_size - client->send_buf_used;
+		assert(cl->send_buf_size >= cl->send_buf_used);
+		left = cl->send_buf_size - cl->send_buf_used;
 
 		copylen = buflen > left ? left : buflen;
-		memcpy(client->send_buf + client->send_buf_used, buffer,
+		memcpy(cl->send_buf + cl->send_buf_used, buffer,
 		       copylen);
 		buflen -= copylen;
-		client->send_buf_used += copylen;
+		cl->send_buf_used += copylen;
 		buffer += copylen;
-		if (client->send_buf_used >= client->send_buf_size)
-			client_write_output(client);
+		if (cl->send_buf_used >= cl->send_buf_size)
+			client_write_output(cl);
 	}
 
 	return 0;
 }
 
-static void client_defer_output(struct client *client,
+static void client_defer_output(struct client *cl,
 				const void *data, size_t length)
 {
 	struct sllnode **buf_r;
 
 	assert(length > 0);
 
-	client->deferred_bytes += sizeof(struct sllnode) + length;
-	if (client->deferred_bytes > client_max_output_buffer_size) {
+	cl->deferred_bytes += sizeof(struct sllnode) + length;
+	if (cl->deferred_bytes > client_max_output_buffer_size) {
 		ERROR("client %i: output buffer size (%lu) is "
 		      "larger than the max (%lu)\n",
-		      client->num,
-		      (unsigned long)client->deferred_bytes,
+		      cl->num,
+		      (unsigned long)cl->deferred_bytes,
 		      (unsigned long)client_max_output_buffer_size);
 		/* cause client to close */
-		client_set_expired(client);
+		client_set_expired(cl);
 		return;
 	}
 
-	buf_r = &client->deferred_send;
+	buf_r = &cl->deferred_send;
 	while (*buf_r != NULL)
 		buf_r = &(*buf_r)->next;
 	*buf_r = new_sllnode(data, length);
 }
 
-static void client_write(struct client *client,
+static void client_write(struct client *cl,
 			 const char *data, size_t length)
 {
 	ssize_t ret;
 
 	assert(length > 0);
-	assert(client->deferred_send == NULL);
+	assert(cl->deferred_send == NULL);
 
-	if ((ret = write(client->fd, data, length)) < 0) {
+	if ((ret = write(cl->fd, data, length)) < 0) {
 		if (errno == EAGAIN || errno == EINTR) {
-			client_defer_output(client, data, length);
+			client_defer_output(cl, data, length);
 		} else {
-			DEBUG("client %i: problems writing\n", client->num);
-			client_set_expired(client);
+			DEBUG("client %i: problems writing\n", cl->num);
+			client_set_expired(cl);
 			return;
 		}
-	} else if ((size_t)ret < client->send_buf_used) {
-		client_defer_output(client, data + ret, length - ret);
+	} else if ((size_t)ret < cl->send_buf_used) {
+		client_defer_output(cl, data + ret, length - ret);
 	}
 
-	if (client->deferred_send)
-		DEBUG("client %i: buffer created\n", client->num);
+	if (cl->deferred_send)
+		DEBUG("client %i: buffer created\n", cl->num);
 }
 
-static void client_write_output(struct client *client)
+static void client_write_output(struct client *cl)
 {
-	if (client_is_expired(client) || !client->send_buf_used)
+	if (client_is_expired(cl) || !cl->send_buf_used)
 		return;
 
-	if (client->deferred_send != NULL)
-		client_defer_output(client, client->send_buf,
-				    client->send_buf_used);
+	if (cl->deferred_send != NULL)
+		client_defer_output(cl, cl->send_buf, cl->send_buf_used);
 	else
-		client_write(client, client->send_buf, client->send_buf_used);
+		client_write(cl, cl->send_buf, cl->send_buf_used);
 
-	client->send_buf_used = 0;
+	cl->send_buf_used = 0;
 }