client: shorten names of the struct client variables

Seeing the token "client" repeatedly in the same blocks of code
adds to mental fatigue and makes it harder to follow code
because there's fewer unique tokens to distinguish.

"cl" is unique within mpd and conveys enough information
to be useful to anybody reading the code.

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;
 }