static void angel_connection_io_cb(liEventBase *watcher, int events) {
liAngelConnection *acon = LI_CONTAINER_OF(li_event_io_from(watcher), liAngelConnection, fd_watcher);
if (events | LI_EV_WRITE) {
GString *out_str;
int i;
ssize_t written, len;
gchar *data;
gboolean out_queue_empty;
angel_connection_send_item_t *send_item;
int fd = li_event_io_fd(&acon->fd_watcher);
g_mutex_lock(acon->mutex);
send_item = g_queue_peek_head(acon->out);
g_mutex_unlock(acon->mutex);
for (i = 0; send_item && (i < 10); i++) { /* don't send more than 10 chunks */
switch (send_item->type) {
case ANGEL_CONNECTION_ITEM_GSTRING:
out_str = send_item->value.string.buf;
written = send_item->value.string.pos;
data = out_str->str + written;
len = out_str->len - written;
while (len > 0) {
written = write(fd, data, len);
if (written < 0) {
switch (errno) {
case EINTR:
continue;
case EAGAIN:
#if EWOULDBLOCK != EAGAIN
case EWOULDBLOCK:
#endif
goto write_eagain;
default: /* Fatal error, connection has to be closed */
li_event_clear(&acon->out_notify_watcher);
li_event_clear(&acon->fd_watcher);
acon->close_cb(acon, NULL); /* TODO: set err */
return;
}
} else {
data += written;
len -= written;
send_item->value.string.pos += written;
}
}
break;
case ANGEL_CONNECTION_ITEM_FDS:
while (send_item->value.fds.pos < send_item->value.fds.fds->len) {
switch (li_send_fd(fd, g_array_index(send_item->value.fds.fds, int, send_item->value.fds.pos))) {
case 0:
send_item->value.fds.pos++;
continue;
case -1: /* Fatal error, connection has to be closed */
li_event_clear(&acon->out_notify_watcher);
li_event_clear(&acon->fd_watcher);
acon->close_cb(acon, NULL); /* TODO: set err */
return;
case -2: goto write_eagain;
}
}
break;
}
g_mutex_lock(acon->mutex);
send_queue_clean(acon->out);
send_item = g_queue_peek_head(acon->out);
g_mutex_unlock(acon->mutex);
}
write_eagain:
g_mutex_lock(acon->mutex);
send_queue_clean(acon->out);
out_queue_empty = (0 == acon->out->length);
g_mutex_unlock(acon->mutex);
if (out_queue_empty) li_event_io_rem_events(&acon->fd_watcher, LI_EV_WRITE);
}
static void memcached_io_cb(liEventBase *watcher, int events) {
liMemcachedCon *con = LI_CONTAINER_OF(li_event_io_from(watcher), liMemcachedCon, con_watcher);
if (1 == g_atomic_int_get(&con->refcount) && li_event_active(&con->con_watcher)) {
memcached_stop_io(con);
return;
}
if (-1 == con->fd) {
memcached_connect(con);
return;
}
li_memcached_con_acquire(con); /* make sure con isn't freed in the middle of something */
if (events & LI_EV_WRITE) {
int i;
ssize_t written, len;
gchar *data;
send_item *si;
si = g_queue_peek_head(&con->out);
for (i = 0; si && (i < 10); i++) { /* don't send more than 10 chunks */
data = si->buf->addr + si->pos;
len = si->len;
written = write(li_event_io_fd(&con->con_watcher), data, len);
if (written < 0) {
switch (errno) {
case EINTR:
continue;
case EAGAIN:
#if EWOULDBLOCK != EAGAIN
case EWOULDBLOCK:
#endif
goto write_eagain;
default: /* Fatal error, connection has to be closed */
g_clear_error(&con->err);
g_set_error(&con->err, LI_MEMCACHED_ERROR, LI_MEMCACHED_CONNECTION, "Couldn't write socket '%s': %s",
li_sockaddr_to_string(con->addr, con->tmpstr, TRUE)->str,
g_strerror(errno));
close_con(con);
goto out;
}
} else {
si->pos += written;
si->len -= written;
if (0 == si->len) {
send_queue_item_free(si);
g_queue_pop_head(&con->out);
si = g_queue_peek_head(&con->out);
}
}
}
write_eagain:
send_queue_clean(&con->out);
}
if (events & LI_EV_READ) {
do {
handle_read(con);
} while (con->remaining && con->remaining->used > 0);
}
out:
memcached_update_io(con);
li_memcached_con_release(con);
}
static void error_pipe_cb(liEventBase *watcher, int events) {
liErrorPipe *epipe = LI_CONTAINER_OF(li_event_io_from(watcher), liErrorPipe, fd_watcher);
UNUSED(events);
read_pipe(epipe->srv, epipe, FALSE);
}
