static void
socket_callback(
int socket_id,
void *cookie,
int read_ready,
int write_ready,
int error_seen)
{
char buf[2048];
int bytes_read;
printf("Socket callback called: id %d. rd %d. wr %d. er %d\n",
socket_id, read_ready, write_ready, error_seen);
socket_called = 1;
if (write_ready) {
sock_write_seen = 1;
send(socket_id, "x", 1, MSG_DONTWAIT);
ind_soc_data_out_clear(socket_id);
}
if (read_ready) {
printf("Reading from socket %d\n", socket_id);
bytes_read = read(socket_id, buf, 2048);
printf("Read in %d bytes\n", bytes_read);
sock_read_seen = 1;
ind_soc_data_out_ready(socket_id);
}
INDIGO_ASSERT(!error_seen);
}
static void
socket_callback(
int socket_id,
void *cookie,
int read_ready,
int write_ready,
int error_seen)
{
struct sock_counters *counters = cookie;
printf("Socket callback called: id %d. rd %d. wr %d. er %d\n",
socket_id, read_ready, write_ready, error_seen);
INDIGO_ASSERT(!error_seen);
if (write_ready) {
counters->write++;
if (write(socket_id, "x", 1) != 1) {
perror("write");
abort();
}
ind_soc_data_out_clear(socket_id);
}
if (read_ready) {
char buf;
counters->read++;
if (read(socket_id, &buf, 1) != 1) {
perror("read");
abort();
}
INDIGO_ASSERT(buf == 'x');
}
}
static void
client_callback(
int socket_id,
void *cookie,
int read_ready,
int write_ready,
int error_seen)
{
struct client *client = cookie;
AIM_ASSERT(socket_id == client->fd);
if (error_seen) {
int socket_error = 0;
socklen_t len = sizeof(socket_error);
getsockopt(socket_id, SOL_SOCKET, SO_ERROR, &socket_error, &len);
AIM_LOG_INFO("Error seen on CLI socket: %s", strerror(socket_error));
destroy_client(client);
return;
}
if (read_ready) {
int c;
if ((c = read(client->fd, client->read_buffer+client->read_buffer_offset,
READ_BUFFER_SIZE - client->read_buffer_offset)) < 0) {
AIM_LOG_ERROR("read failed: %s", strerror(errno));
return;
}
client->read_buffer_offset += c;
if (c == 0) {
/* Peer has shutdown their write side */
if (client->write_buffer_len == 0 &&
aim_pvs_buffer_size(client->write_pvs) == 0) {
destroy_client(client);
} else {
/* We'll destroy the client once we've finished writing to it */
ind_soc_data_in_pause(client->fd);
client->read_finished = true;
}
return;
}
/* Process each complete line */
char *newline;
char *start = client->read_buffer;
int remaining = client->read_buffer_offset;
while ((newline = memchr(start, '\n', remaining))) {
*newline = '\0';
ucli_dispatch_string(client->ucli, client->write_pvs, start);
remaining -= newline - start + 1;
start = newline + 1;
}
/* Move incomplete line (which may be empty) to the beginning of the read buffer */
if (client->read_buffer != start) {
memmove(client->read_buffer, start, remaining);
client->read_buffer_offset = remaining;
} else if (client->read_buffer_offset == READ_BUFFER_SIZE) {
AIM_LOG_WARN("Disconnecting CLI client due to too-long line");
destroy_client(client);
return;
}
if (aim_pvs_buffer_size(client->write_pvs) > 0) {
ind_soc_data_out_ready(socket_id);
}
}
if (write_ready) {
/* Copy PVS data into our write buffer and reset PVS */
if (client->write_buffer == NULL) {
client->write_buffer = aim_pvs_buffer_get(client->write_pvs);
client->write_buffer_len = aim_pvs_buffer_size(client->write_pvs);
client->write_buffer_offset = 0;
/* aim_pvs_buffer_reset has a bug, workaround it */
aim_pvs_destroy(client->write_pvs);
client->write_pvs = aim_pvs_buffer_create();
}
int c = send(client->fd,
client->write_buffer+client->write_buffer_offset,
client->write_buffer_len-client->write_buffer_offset,
MSG_NOSIGNAL);
if (c <= 0) {
AIM_LOG_ERROR("write failed: %s", strerror(errno));
destroy_client(client);
return;
}
client->write_buffer_offset += c;
/* Free our write buffer if we're finished with it */
if (client->write_buffer_len == client->write_buffer_offset) {
aim_free(client->write_buffer);
client->write_buffer_len = client->write_buffer_offset = 0;
client->write_buffer = NULL;
if (aim_pvs_buffer_size(client->write_pvs) == 0) {
ind_soc_data_out_clear(client->fd);
if (client->read_finished) {
destroy_client(client);
}
}
}
}
}