aboutsummaryrefslogtreecommitdiffstats
path: root/src/client.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/client.c')
-rw-r--r--src/client.c593
1 files changed, 296 insertions, 297 deletions
diff --git a/src/client.c b/src/client.c
index 378a513c8..0251b7ba1 100644
--- a/src/client.c
+++ b/src/client.c
@@ -33,34 +33,34 @@
#define GREETING "OK MPD " PROTOCOL_VERSION "\n"
-#define INTERFACE_MAX_BUFFER_LENGTH (40960)
-#define INTERFACE_LIST_MODE_BEGIN "command_list_begin"
-#define INTERFACE_LIST_OK_MODE_BEGIN "command_list_ok_begin"
-#define INTERFACE_LIST_MODE_END "command_list_end"
-#define INTERFACE_DEFAULT_OUT_BUFFER_SIZE (4096)
-#define INTERFACE_TIMEOUT_DEFAULT (60)
-#define INTERFACE_MAX_CONNECTIONS_DEFAULT (10)
-#define INTERFACE_MAX_COMMAND_LIST_DEFAULT (2048*1024)
-#define INTERFACE_MAX_OUTPUT_BUFFER_SIZE_DEFAULT (8192*1024)
-
-/* set this to zero to indicate we have no possible interfaces */
-static unsigned int interface_max_connections; /*INTERFACE_MAX_CONNECTIONS_DEFAULT; */
-static int interface_timeout = INTERFACE_TIMEOUT_DEFAULT;
-static size_t interface_max_command_list_size =
- INTERFACE_MAX_COMMAND_LIST_DEFAULT;
-static size_t interface_max_output_buffer_size =
- INTERFACE_MAX_OUTPUT_BUFFER_SIZE_DEFAULT;
+#define CLIENT_MAX_BUFFER_LENGTH (40960)
+#define CLIENT_LIST_MODE_BEGIN "command_list_begin"
+#define CLIENT_LIST_OK_MODE_BEGIN "command_list_ok_begin"
+#define CLIENT_LIST_MODE_END "command_list_end"
+#define CLIENT_DEFAULT_OUT_BUFFER_SIZE (4096)
+#define CLIENT_TIMEOUT_DEFAULT (60)
+#define CLIENT_MAX_CONNECTIONS_DEFAULT (10)
+#define CLIENT_MAX_COMMAND_LIST_DEFAULT (2048*1024)
+#define CLIENT_MAX_OUTPUT_BUFFER_SIZE_DEFAULT (8192*1024)
+
+/* set this to zero to indicate we have no possible clients */
+static unsigned int client_max_connections; /*CLIENT_MAX_CONNECTIONS_DEFAULT; */
+static int client_timeout = CLIENT_TIMEOUT_DEFAULT;
+static size_t client_max_command_list_size =
+ CLIENT_MAX_COMMAND_LIST_DEFAULT;
+static size_t client_max_output_buffer_size =
+ CLIENT_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;
+static long int client_list_cache_size = 32;
-/* shared globally between all interfaces: */
+/* shared globally between all clients: */
static struct strnode *list_cache;
static struct strnode *list_cache_head;
static struct strnode *list_cache_tail;
struct client {
- char buffer[INTERFACE_MAX_BUFFER_LENGTH];
+ char buffer[CLIENT_MAX_BUFFER_LENGTH];
size_t bufferLength;
size_t bufferPos;
int fd; /* file descriptor */
@@ -73,9 +73,9 @@ struct client {
int cmd_list_dup; /* has the cmd_list been copied to private space? */
struct sllnode *deferred_send; /* for output if client is slow */
size_t deferred_bytes; /* mem deferred_send consumes */
- int expired; /* set whether this interface should be closed on next
- check of old interfaces */
- unsigned int num; /* interface number */
+ int expired; /* set whether this client should be closed on next
+ check of old clients */
+ unsigned int num; /* client number */
char *send_buf;
size_t send_buf_used; /* bytes used this instance */
@@ -83,71 +83,71 @@ struct client {
size_t send_buf_alloc; /* bytes actually allocated */
};
-static struct client *interfaces;
+static struct client *clients;
-static void flushInterfaceBuffer(struct client *interface);
+static void client_write_deferred(struct client *client);
-static void printInterfaceOutBuffer(struct client *interface);
+static void client_write_output(struct client *client);
#ifdef SO_SNDBUF
-static size_t get_default_snd_buf_size(struct client *interface)
+static size_t get_default_snd_buf_size(struct client *client)
{
int new_size;
socklen_t sockOptLen = sizeof(int);
- if (getsockopt(interface->fd, SOL_SOCKET, SO_SNDBUF,
+ if (getsockopt(client->fd, SOL_SOCKET, SO_SNDBUF,
(char *)&new_size, &sockOptLen) < 0) {
DEBUG("problem getting sockets send buffer size\n");
- return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
+ return CLIENT_DEFAULT_OUT_BUFFER_SIZE;
}
if (new_size > 0)
return (size_t)new_size;
DEBUG("sockets send buffer size is not positive\n");
- return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
+ return CLIENT_DEFAULT_OUT_BUFFER_SIZE;
}
#else /* !SO_SNDBUF */
-static size_t get_default_snd_buf_size(struct client *interface)
+static size_t get_default_snd_buf_size(struct client *client)
{
- return INTERFACE_DEFAULT_OUT_BUFFER_SIZE;
+ return CLIENT_DEFAULT_OUT_BUFFER_SIZE;
}
#endif /* !SO_SNDBUF */
-static void set_send_buf_size(struct client *interface)
+static void set_send_buf_size(struct client *client)
{
- size_t new_size = get_default_snd_buf_size(interface);
- if (interface->send_buf_size != new_size) {
- interface->send_buf_size = new_size;
+ size_t new_size = get_default_snd_buf_size(client);
+ if (client->send_buf_size != new_size) {
+ client->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 = xmalloc(new_size);
- interface->send_buf_alloc = new_size;
+ 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;
}
}
}
-static void openInterface(struct client *interface, int fd)
+static void client_init(struct client *client, int fd)
{
- 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;
+ assert(client->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;
set_nonblocking(fd);
- interface->lastTime = time(NULL);
- interface->cmd_list = NULL;
- interface->cmd_list_tail = NULL;
- interface->deferred_send = NULL;
- interface->expired = 0;
- interface->deferred_bytes = 0;
- interface->send_buf_used = 0;
+ client->lastTime = time(NULL);
+ client->cmd_list = NULL;
+ client->cmd_list_tail = NULL;
+ client->deferred_send = NULL;
+ client->expired = 0;
+ client->deferred_bytes = 0;
+ client->send_buf_used = 0;
- interface->permission = getDefaultPermissions();
- set_send_buf_size(interface);
+ client->permission = getDefaultPermissions();
+ set_send_buf_size(client);
xwrite(fd, GREETING, strlen(GREETING));
}
@@ -168,26 +168,26 @@ static void free_cmd_list(struct strnode *list)
}
}
-static void cmd_list_clone(struct client *interface)
+static void cmd_list_clone(struct client *client)
{
- struct strnode *new = dup_strlist(interface->cmd_list);
- free_cmd_list(interface->cmd_list);
- interface->cmd_list = new;
- interface->cmd_list_dup = 1;
+ struct strnode *new = dup_strlist(client->cmd_list);
+ free_cmd_list(client->cmd_list);
+ client->cmd_list = new;
+ client->cmd_list_dup = 1;
/* new tail */
while (new && new->next)
new = new->next;
- interface->cmd_list_tail = new;
+ client->cmd_list_tail = new;
}
-static void new_cmd_list_ptr(struct client *interface, char *s, const int size)
+static void new_cmd_list_ptr(struct client *client, char *s, const int size)
{
int i;
struct strnode *new;
- if (!interface->cmd_list_dup) {
- for (i = interface_list_cache_size - 1; i >= 0; --i) {
+ if (!client->cmd_list_dup) {
+ for (i = client_list_cache_size - 1; i >= 0; --i) {
if (list_cache[i].data)
continue;
new = &(list_cache[i]);
@@ -199,49 +199,49 @@ static void new_cmd_list_ptr(struct client *interface, char *s, const int size)
}
/* allocate from the heap */
- new = interface->cmd_list_dup ? new_strnode_dup(s, size)
+ new = client->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;
+ if (client->cmd_list) {
+ client->cmd_list_tail->next = new;
+ client->cmd_list_tail = new;
} else
- interface->cmd_list = interface->cmd_list_tail = new;
+ client->cmd_list = client->cmd_list_tail = new;
}
-static void closeInterface(struct client *interface)
+static void client_close(struct client *client)
{
struct sllnode *buf;
- if (interface->fd < 0)
+ if (client->fd < 0)
return;
- xclose(interface->fd);
- interface->fd = -1;
+ xclose(client->fd);
+ client->fd = -1;
- if (interface->cmd_list) {
- free_cmd_list(interface->cmd_list);
- interface->cmd_list = NULL;
+ if (client->cmd_list) {
+ free_cmd_list(client->cmd_list);
+ client->cmd_list = NULL;
}
- if ((buf = interface->deferred_send)) {
+ if ((buf = client->deferred_send)) {
do {
struct sllnode *prev = buf;
buf = buf->next;
free(prev);
} while (buf);
- interface->deferred_send = NULL;
+ client->deferred_send = NULL;
}
- SECURE("interface %i: closed\n", interface->num);
+ SECURE("client %i: closed\n", client->num);
}
void openAInterface(int fd, const struct sockaddr *addr)
{
unsigned int i;
- for (i = 0; i < interface_max_connections
- && interfaces[i].fd >= 0; i++) /* nothing */ ;
+ for (i = 0; i < client_max_connections
+ && clients[i].fd >= 0; i++) /* nothing */ ;
- if (i == interface_max_connections) {
+ if (i == client_max_connections) {
ERROR("Max Connections Reached!\n");
xclose(fd);
} else {
@@ -279,120 +279,120 @@ void openAInterface(int fd, const struct sockaddr *addr)
default:
hostname = "unknown";
}
- SECURE("interface %i: opened from %s\n", i, hostname);
- openInterface(&(interfaces[i]), fd);
+ SECURE("client %i: opened from %s\n", i, hostname);
+ client_init(&(clients[i]), fd);
}
}
-static int processLineOfInput(struct client *interface)
+static int client_process_line(struct client *client)
{
int ret = 1;
- char *line = interface->buffer + interface->bufferPos;
-
- 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->fd,
- &(interface->permission),
- &(interface->expired),
- interface->cmd_list_OK,
- interface->cmd_list);
- DEBUG("interface %i: process command "
- "list returned %i\n", interface->num, ret);
+ char *line = client->buffer + client->bufferPos;
+
+ if (client->cmd_list_OK >= 0) {
+ if (strcmp(line, CLIENT_LIST_MODE_END) == 0) {
+ DEBUG("client %i: process command "
+ "list\n", client->num);
+ ret = processListOfCommands(client->fd,
+ &(client->permission),
+ &(client->expired),
+ client->cmd_list_OK,
+ client->cmd_list);
+ DEBUG("client %i: process command "
+ "list returned %i\n", client->num, ret);
if (ret == 0)
- commandSuccess(interface->fd);
+ commandSuccess(client->fd);
else if (ret == COMMAND_RETURN_CLOSE
- || interface->expired)
- closeInterface(interface);
+ || client->expired)
+ client_close(client);
- printInterfaceOutBuffer(interface);
- free_cmd_list(interface->cmd_list);
- interface->cmd_list = NULL;
- interface->cmd_list_OK = -1;
+ client_write_output(client);
+ free_cmd_list(client->cmd_list);
+ client->cmd_list = NULL;
+ client->cmd_list_OK = -1;
} else {
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 "
+ client->cmd_list_size += len;
+ if (client->cmd_list_size >
+ client_max_command_list_size) {
+ ERROR("client %i: command "
"list size (%lu) is "
"larger than the max "
"(%lu)\n",
- interface->num,
- (unsigned long)interface->cmd_list_size,
+ client->num,
+ (unsigned long)client->cmd_list_size,
(unsigned long)
- interface_max_command_list_size);
- closeInterface(interface);
+ client_max_command_list_size);
+ client_close(client);
ret = COMMAND_RETURN_CLOSE;
} else
- new_cmd_list_ptr(interface, line, len);
+ new_cmd_list_ptr(client, line, len);
}
} else {
- if (strcmp(line, INTERFACE_LIST_MODE_BEGIN) == 0) {
- interface->cmd_list_OK = 0;
+ if (strcmp(line, CLIENT_LIST_MODE_BEGIN) == 0) {
+ client->cmd_list_OK = 0;
ret = 1;
- } else if (strcmp(line, INTERFACE_LIST_OK_MODE_BEGIN) == 0) {
- interface->cmd_list_OK = 1;
+ } else if (strcmp(line, CLIENT_LIST_OK_MODE_BEGIN) == 0) {
+ client->cmd_list_OK = 1;
ret = 1;
} else {
- DEBUG("interface %i: process command \"%s\"\n",
- interface->num, line);
- ret = processCommand(interface->fd,
- &(interface->permission), line);
- DEBUG("interface %i: command returned %i\n",
- interface->num, ret);
+ DEBUG("client %i: process command \"%s\"\n",
+ client->num, line);
+ ret = processCommand(client->fd,
+ &(client->permission), line);
+ DEBUG("client %i: command returned %i\n",
+ client->num, ret);
if (ret == 0)
- commandSuccess(interface->fd);
+ commandSuccess(client->fd);
else if (ret == COMMAND_RETURN_CLOSE
- || interface->expired) {
- closeInterface(interface);
+ || client->expired) {
+ client_close(client);
}
- printInterfaceOutBuffer(interface);
+ client_write_output(client);
}
}
return ret;
}
-static int processBytesRead(struct client *interface, int bytesRead)
+static int client_input_received(struct client *client, int bytesRead)
{
int ret = 0;
- char *buf_tail = &(interface->buffer[interface->bufferLength - 1]);
+ char *buf_tail = &(client->buffer[client->bufferLength - 1]);
while (bytesRead > 0) {
- interface->bufferLength++;
+ client->bufferLength++;
bytesRead--;
buf_tail++;
if (*buf_tail == '\n') {
*buf_tail = '\0';
- if (interface->bufferLength > interface->bufferPos) {
+ if (client->bufferLength > client->bufferPos) {
if (*(buf_tail - 1) == '\r')
*(buf_tail - 1) = '\0';
}
- ret = processLineOfInput(interface);
- if (interface->expired)
+ ret = client_process_line(client);
+ if (client->expired)
return ret;
- interface->bufferPos = interface->bufferLength;
+ client->bufferPos = client->bufferLength;
}
- if (interface->bufferLength == INTERFACE_MAX_BUFFER_LENGTH) {
- if (interface->bufferPos == 0) {
- ERROR("interface %i: buffer overflow\n",
- interface->num);
- closeInterface(interface);
+ if (client->bufferLength == CLIENT_MAX_BUFFER_LENGTH) {
+ if (client->bufferPos == 0) {
+ ERROR("client %i: buffer overflow\n",
+ client->num);
+ client_close(client);
return 1;
}
- if (interface->cmd_list_OK >= 0 &&
- interface->cmd_list &&
- !interface->cmd_list_dup)
- cmd_list_clone(interface);
- assert(interface->bufferLength >= interface->bufferPos
+ if (client->cmd_list_OK >= 0 &&
+ client->cmd_list &&
+ !client->cmd_list_dup)
+ cmd_list_clone(client);
+ assert(client->bufferLength >= client->bufferPos
&& "bufferLength >= bufferPos");
- interface->bufferLength -= interface->bufferPos;
- memmove(interface->buffer,
- interface->buffer + interface->bufferPos,
- interface->bufferLength);
- interface->bufferPos = 0;
+ client->bufferLength -= client->bufferPos;
+ memmove(client->buffer,
+ client->buffer + client->bufferPos,
+ client->bufferLength);
+ client->bufferPos = 0;
}
if (ret == COMMAND_RETURN_KILL || ret == COMMAND_RETURN_CLOSE) {
return ret;
@@ -403,54 +403,53 @@ static int processBytesRead(struct client *interface, int bytesRead)
return ret;
}
-static int interfaceReadInput(struct client *interface)
+static int client_read(struct client *client)
{
int bytesRead;
- bytesRead = read(interface->fd,
- interface->buffer + interface->bufferLength,
- INTERFACE_MAX_BUFFER_LENGTH - interface->bufferLength);
+ bytesRead = read(client->fd,
+ client->buffer + client->bufferLength,
+ CLIENT_MAX_BUFFER_LENGTH - client->bufferLength);
if (bytesRead > 0)
- return processBytesRead(interface, bytesRead);
+ return client_input_received(client, bytesRead);
else if (bytesRead == 0 || (bytesRead < 0 && errno != EINTR)) {
- closeInterface(interface);
+ client_close(client);
} else
return 0;
return 1;
}
-static void addInterfacesReadyToReadAndListenSocketToFdSet(fd_set * fds,
- int *fdmax)
+static void client_manager_register_read_fd(fd_set * fds, int *fdmax)
{
unsigned int i;
FD_ZERO(fds);
addListenSocketsToFdSet(fds, fdmax);
- for (i = 0; i < interface_max_connections; i++) {
- 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;
+ for (i = 0; i < client_max_connections; i++) {
+ if (clients[i].fd >= 0 && !clients[i].expired
+ && !clients[i].deferred_send) {
+ FD_SET(clients[i].fd, fds);
+ if (*fdmax < clients[i].fd)
+ *fdmax = clients[i].fd;
}
}
}
-static void addInterfacesForBufferFlushToFdSet(fd_set * fds, int *fdmax)
+static void client_manager_register_write_fd(fd_set * fds, int *fdmax)
{
unsigned int i;
FD_ZERO(fds);
- for (i = 0; i < interface_max_connections; i++) {
- 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;
+ for (i = 0; i < client_max_connections; i++) {
+ if (clients[i].fd >= 0 && !clients[i].expired
+ && clients[i].deferred_send) {
+ FD_SET(clients[i].fd, fds);
+ if (*fdmax < clients[i].fd)
+ *fdmax = clients[i].fd;
}
}
}
@@ -464,13 +463,13 @@ static void closeNextErroredInterface(void)
tv.tv_sec = 0;
tv.tv_usec = 0;
- for (i = 0; i < interface_max_connections; i++) {
- if (interfaces[i].fd >= 0) {
+ for (i = 0; i < client_max_connections; i++) {
+ if (clients[i].fd >= 0) {
FD_ZERO(&fds);
- FD_SET(interfaces[i].fd, &fds);
- if (select(interfaces[i].fd + 1,
+ FD_SET(clients[i].fd, &fds);
+ if (select(clients[i].fd + 1,
&fds, NULL, NULL, &tv) < 0) {
- closeInterface(&interfaces[i]);
+ client_close(&clients[i]);
return;
}
}
@@ -490,8 +489,8 @@ int doIOForInterfaces(void)
fdmax = 0;
FD_ZERO( &efds );
- addInterfacesReadyToReadAndListenSocketToFdSet(&rfds, &fdmax);
- addInterfacesForBufferFlushToFdSet(&wfds, &fdmax);
+ client_manager_register_read_fd(&rfds, &fdmax);
+ client_manager_register_write_fd(&wfds, &fdmax);
registered_IO_add_fds(&fdmax, &rfds, &wfds, &efds);
@@ -514,19 +513,19 @@ int doIOForInterfaces(void)
getConnections(&rfds);
- for (i = 0; i < interface_max_connections; i++) {
- if (interfaces[i].fd >= 0
- && FD_ISSET(interfaces[i].fd, &rfds)) {
+ for (i = 0; i < client_max_connections; i++) {
+ if (clients[i].fd >= 0
+ && FD_ISSET(clients[i].fd, &rfds)) {
if (COMMAND_RETURN_KILL ==
- interfaceReadInput(&(interfaces[i]))) {
+ client_read(&(clients[i]))) {
return COMMAND_RETURN_KILL;
}
- interfaces[i].lastTime = time(NULL);
+ clients[i].lastTime = time(NULL);
}
- if (interfaces[i].fd >= 0
- && FD_ISSET(interfaces[i].fd, &wfds)) {
- flushInterfaceBuffer(&interfaces[i]);
- interfaces[i].lastTime = time(NULL);
+ if (clients[i].fd >= 0
+ && FD_ISSET(clients[i].fd, &wfds)) {
+ client_write_deferred(&clients[i]);
+ clients[i].lastTime = time(NULL);
}
}
@@ -545,8 +544,8 @@ void initInterfaces(void)
param = getConfigParam(CONF_CONN_TIMEOUT);
if (param) {
- interface_timeout = strtol(param->value, &test, 10);
- if (*test != '\0' || interface_timeout <= 0) {
+ client_timeout = strtol(param->value, &test, 10);
+ if (*test != '\0' || client_timeout <= 0) {
FATAL("connection timeout \"%s\" is not a positive "
"integer, line %i\n", CONF_CONN_TIMEOUT,
param->line);
@@ -556,13 +555,13 @@ void initInterfaces(void)
param = getConfigParam(CONF_MAX_CONN);
if (param) {
- interface_max_connections = strtol(param->value, &test, 10);
- if (*test != '\0' || interface_max_connections <= 0) {
+ client_max_connections = strtol(param->value, &test, 10);
+ if (*test != '\0' || client_max_connections <= 0) {
FATAL("max connections \"%s\" is not a positive integer"
", line %i\n", param->value, param->line);
}
} else
- interface_max_connections = INTERFACE_MAX_CONNECTIONS_DEFAULT;
+ client_max_connections = CLIENT_MAX_CONNECTIONS_DEFAULT;
param = getConfigParam(CONF_MAX_COMMAND_LIST_SIZE);
@@ -572,7 +571,7 @@ void initInterfaces(void)
FATAL("max command list size \"%s\" is not a positive "
"integer, line %i\n", param->value, param->line);
}
- interface_max_command_list_size = tmp * 1024;
+ client_max_command_list_size = tmp * 1024;
}
param = getConfigParam(CONF_MAX_OUTPUT_BUFFER_SIZE);
@@ -583,109 +582,109 @@ void initInterfaces(void)
FATAL("max output buffer size \"%s\" is not a positive "
"integer, line %i\n", param->value, param->line);
}
- interface_max_output_buffer_size = tmp * 1024;
+ client_max_output_buffer_size = tmp * 1024;
}
- interfaces = xmalloc(sizeof(interfaces[0]) * interface_max_connections);
+ clients = xmalloc(sizeof(clients[0]) * client_max_connections);
- list_cache = xcalloc(interface_list_cache_size, sizeof(struct strnode));
+ list_cache = xcalloc(client_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].fd = -1;
- interfaces[i].send_buf = NULL;
- interfaces[i].send_buf_size = 0;
- interfaces[i].send_buf_alloc = 0;
- interfaces[i].num = i;
+ list_cache_tail = &(list_cache[client_list_cache_size - 1]);
+
+ for (i = 0; i < client_max_connections; i++) {
+ clients[i].fd = -1;
+ clients[i].send_buf = NULL;
+ clients[i].send_buf_size = 0;
+ clients[i].send_buf_alloc = 0;
+ clients[i].num = i;
}
}
-static void closeAllInterfaces(void)
+static void client_close_all(void)
{
unsigned int i;
- for (i = 0; i < interface_max_connections; i++) {
- if (interfaces[i].fd >= 0)
- closeInterface(&(interfaces[i]));
- if (interfaces[i].send_buf)
- free(interfaces[i].send_buf);
+ for (i = 0; i < client_max_connections; i++) {
+ if (clients[i].fd >= 0)
+ client_close(&(clients[i]));
+ if (clients[i].send_buf)
+ free(clients[i].send_buf);
}
free(list_cache);
}
void freeAllInterfaces(void)
{
- closeAllInterfaces();
+ client_close_all();
- free(interfaces);
+ free(clients);
- interface_max_connections = 0;
+ client_max_connections = 0;
}
void closeOldInterfaces(void)
{
unsigned int i;
- for (i = 0; i < interface_max_connections; i++) {
- if (interfaces[i].fd >= 0) {
- if (interfaces[i].expired) {
- DEBUG("interface %i: expired\n", i);
- closeInterface(&(interfaces[i]));
- } else if (time(NULL) - interfaces[i].lastTime >
- interface_timeout) {
- DEBUG("interface %i: timeout\n", i);
- closeInterface(&(interfaces[i]));
+ for (i = 0; i < client_max_connections; i++) {
+ if (clients[i].fd >= 0) {
+ if (clients[i].expired) {
+ DEBUG("client %i: expired\n", i);
+ client_close(&(clients[i]));
+ } else if (time(NULL) - clients[i].lastTime >
+ client_timeout) {
+ DEBUG("client %i: timeout\n", i);
+ client_close(&(clients[i]));
}
}
}
}
-static void flushInterfaceBuffer(struct client *interface)
+static void client_write_deferred(struct client *client)
{
struct sllnode *buf;
ssize_t ret = 0;
- buf = interface->deferred_send;
+ buf = client->deferred_send;
while (buf) {
- ret = write(interface->fd, buf->data, buf->size);
+ ret = write(client->fd, buf->data, buf->size);
if (ret < 0)
break;
else if ((size_t)ret < buf->size) {
- assert(interface->deferred_bytes >= (size_t)ret);
- interface->deferred_bytes -= ret;
+ assert(client->deferred_bytes >= (size_t)ret);
+ client->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(interface->deferred_bytes >= decr);
- interface->deferred_bytes -= decr;
+ assert(client->deferred_bytes >= decr);
+ client->deferred_bytes -= decr;
buf = buf->next;
free(tmp);
- interface->deferred_send = buf;
+ client->deferred_send = buf;
}
- interface->lastTime = time(NULL);
+ client->lastTime = time(NULL);
}
- if (!interface->deferred_send) {
- DEBUG("interface %i: buffer empty %lu\n", interface->num,
- (unsigned long)interface->deferred_bytes);
- assert(interface->deferred_bytes == 0);
+ if (!client->deferred_send) {
+ DEBUG("client %i: buffer empty %lu\n", client->num,
+ (unsigned long)client->deferred_bytes);
+ assert(client->deferred_bytes == 0);
} else if (ret < 0 && errno != EAGAIN && errno != EINTR) {
- /* cause interface to close */
- DEBUG("interface %i: problems flushing buffer\n",
- interface->num);
- buf = interface->deferred_send;
+ /* cause client to close */
+ DEBUG("client %i: problems flushing buffer\n",
+ client->num);
+ buf = client->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;
+ client->deferred_send = NULL;
+ client->deferred_bytes = 0;
+ client->expired = 1;
}
}
@@ -693,105 +692,105 @@ int interfacePrintWithFD(int fd, const char *buffer, size_t buflen)
{
static unsigned int i;
size_t copylen;
- struct client *interface;
+ struct client *client;
assert(fd >= 0);
- if (i >= interface_max_connections ||
- interfaces[i].fd < 0 || interfaces[i].fd != fd) {
- for (i = 0; i < interface_max_connections; i++) {
- if (interfaces[i].fd == fd)
+ if (i >= client_max_connections ||
+ clients[i].fd < 0 || clients[i].fd != fd) {
+ for (i = 0; i < client_max_connections; i++) {
+ if (clients[i].fd == fd)
break;
}
- if (i == interface_max_connections)
+ if (i == client_max_connections)
return -1;
}
- /* if fd isn't found or interfaces is going to be closed, do nothing */
- if (interfaces[i].expired)
+ /* if fd isn't found or client is going to be closed, do nothing */
+ if (clients[i].expired)
return 0;
- interface = interfaces + i;
+ client = clients + i;
- while (buflen > 0 && !interface->expired) {
+ while (buflen > 0 && !client->expired) {
size_t left;
- assert(interface->send_buf_size >= interface->send_buf_used);
- left = interface->send_buf_size - interface->send_buf_used;
+ assert(client->send_buf_size >= client->send_buf_used);
+ left = client->send_buf_size - client->send_buf_used;
copylen = buflen > left ? left : buflen;
- memcpy(interface->send_buf + interface->send_buf_used, buffer,
+ memcpy(client->send_buf + client->send_buf_used, buffer,
copylen);
buflen -= copylen;
- interface->send_buf_used += copylen;
+ client->send_buf_used += copylen;
buffer += copylen;
- if (interface->send_buf_used >= interface->send_buf_size)
- printInterfaceOutBuffer(interface);
+ if (client->send_buf_used >= client->send_buf_size)
+ client_write_output(client);
}
return 0;
}
-static void printInterfaceOutBuffer(struct client *interface)
+static void client_write_output(struct client *client)
{
ssize_t ret;
struct sllnode *buf;
- if (interface->fd < 0 || interface->expired ||
- !interface->send_buf_used)
+ if (client->fd < 0 || client->expired ||
+ !client->send_buf_used)
return;
- 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 (%lu) is "
+ if ((buf = client->deferred_send)) {
+ client->deferred_bytes += sizeof(struct sllnode)
+ + client->send_buf_used;
+ if (client->deferred_bytes >
+ client_max_output_buffer_size) {
+ ERROR("client %i: output buffer size (%lu) is "
"larger than the max (%lu)\n",
- interface->num,
- (unsigned long)interface->deferred_bytes,
- (unsigned long)interface_max_output_buffer_size);
- /* cause interface to close */
- interface->expired = 1;
+ client->num,
+ (unsigned long)client->deferred_bytes,
+ (unsigned long)client_max_output_buffer_size);
+ /* cause client to close */
+ client->expired = 1;
do {
struct sllnode *prev = buf;
buf = buf->next;
free(prev);
} while (buf);
- interface->deferred_send = NULL;
- interface->deferred_bytes = 0;
+ client->deferred_send = NULL;
+ client->deferred_bytes = 0;
} else {
while (buf->next)
buf = buf->next;
- buf->next = new_sllnode(interface->send_buf,
- interface->send_buf_used);
+ buf->next = new_sllnode(client->send_buf,
+ client->send_buf_used);
}
} else {
- if ((ret = write(interface->fd, interface->send_buf,
- interface->send_buf_used)) < 0) {
+ if ((ret = write(client->fd, client->send_buf,
+ client->send_buf_used)) < 0) {
if (errno == EAGAIN || errno == EINTR) {
- interface->deferred_send =
- new_sllnode(interface->send_buf,
- interface->send_buf_used);
+ client->deferred_send =
+ new_sllnode(client->send_buf,
+ client->send_buf_used);
} else {
- DEBUG("interface %i: problems writing\n",
- interface->num);
- interface->expired = 1;
+ DEBUG("client %i: problems writing\n",
+ client->num);
+ client->expired = 1;
return;
}
- } else if ((size_t)ret < interface->send_buf_used) {
- interface->deferred_send =
- new_sllnode(interface->send_buf + ret,
- interface->send_buf_used - ret);
+ } else if ((size_t)ret < client->send_buf_used) {
+ client->deferred_send =
+ new_sllnode(client->send_buf + ret,
+ client->send_buf_used - ret);
}
- if (interface->deferred_send) {
- DEBUG("interface %i: buffer created\n", interface->num);
- interface->deferred_bytes =
- interface->deferred_send->size
+ if (client->deferred_send) {
+ DEBUG("client %i: buffer created\n", client->num);
+ client->deferred_bytes =
+ client->deferred_send->size
+ sizeof(struct sllnode);
}
}
- interface->send_buf_used = 0;
+ client->send_buf_used = 0;
}