liErrorPipe* li_error_pipe_new(liServer *srv, liErrorPipeCB cb, gpointer ctx) {
liErrorPipe *epipe;
int fds[2];
if (-1 == pipe(fds)) {
ERROR(srv, "Couldn't create pipe: %s", g_strerror(errno));
return NULL;
}
epipe = g_slice_new0(liErrorPipe);
epipe->srv = srv;
epipe->cb = cb;
epipe->ctx = ctx;
li_event_io_init(&srv->loop, &epipe->fd_watcher, error_pipe_cb, fds[0], LI_EV_READ);
epipe->fds[0] = fds[0];
epipe->fds[1] = fds[1];
li_fd_init(fds[0]);
return epipe;
}
static void memcached_connect(liMemcachedCon *con) {
int s;
struct sockaddr addr;
socklen_t len;
li_tstamp now = li_event_now(li_event_get_loop(&con->con_watcher));
if (-1 != con->fd) return;
s = li_event_io_fd(&con->con_watcher);
if (-1 == s) {
/* reconnect limit */
if (now < con->last_con_start + 1) {
if (con->err) {
con->err->code = LI_MEMCACHED_DISABLED;
} else {
g_set_error(&con->err, LI_MEMCACHED_ERROR, LI_MEMCACHED_DISABLED, "Disabled right now");
}
return;
}
con->last_con_start = now;
do {
s = socket(con->addr.addr->plain.sa_family, SOCK_STREAM, 0);
} while (-1 == s && errno == EINTR);
if (-1 == s) {
g_clear_error(&con->err);
g_set_error(&con->err, LI_MEMCACHED_ERROR, LI_MEMCACHED_CONNECTION, "Couldn't open socket: %s", g_strerror(errno));
return;
}
li_fd_init(s);
li_event_io_set_fd(&con->con_watcher, s);
if (-1 == connect(s, &con->addr.addr->plain, con->addr.len)) {
switch (errno) {
case EINPROGRESS:
case EALREADY:
case EINTR:
memcached_start_io(con);
li_event_io_add_events(&con->con_watcher, LI_EV_READ | LI_EV_WRITE);
break;
case EISCONN:
break;
default:
g_clear_error(&con->err);
g_set_error(&con->err, LI_MEMCACHED_ERROR, LI_MEMCACHED_CONNECTION, "Couldn't connect to '%s': %s",
li_sockaddr_to_string(con->addr, con->tmpstr, TRUE)->str,
g_strerror(errno));
close(s);
li_event_io_set_fd(&con->con_watcher, -1);
break;
}
} else {
/* connect succeeded */
con->fd = s;
g_clear_error(&con->err);
memcached_update_io(con);
}
return;
}
/* create new connection:
* see http://www.cyberconf.org/~cynbe/ref/nonblocking-connects.html
*/
/* Check to see if we can determine our peer's address. */
len = sizeof(addr);
if (getpeername(s, &addr, &len) == -1) {
/* connect failed; find out why */
int err;
len = sizeof(err);
#ifdef SO_ERROR
if (-1 == getsockopt(s, SOL_SOCKET, SO_ERROR, (void*)&err, &len)) {
err = errno;
}
#else
{
char ch;
errno = 0;
read(s, &ch, 1);
err = errno;
}
#endif
g_clear_error(&con->err);
g_set_error(&con->err, LI_MEMCACHED_ERROR, LI_MEMCACHED_CONNECTION, "Couldn't connect socket to '%s': %s",
li_sockaddr_to_string(con->addr, con->tmpstr, TRUE)->str,
g_strerror(err));
close(s);
memcached_stop_io(con);
li_event_io_set_fd(&con->con_watcher, -1);
} else {
/* connect succeeded */
con->fd = s;
g_clear_error(&con->err);
memcached_update_io(con);
}
}
static liHandlerResult proxy_statemachine(liVRequest *vr, proxy_connection *pcon) {
liPlugin *p = pcon->ctx->plugin;
switch (pcon->state) {
case SS_WAIT_FOR_REQUEST:
/* do *not* wait until we have all data */
pcon->state = SS_CONNECT;
/* fall through */
case SS_CONNECT:
do {
pcon->fd = socket(pcon->ctx->socket.addr->plain.sa_family, SOCK_STREAM, 0);
} while (-1 == pcon->fd && errno == EINTR);
if (-1 == pcon->fd) {
if (errno == EMFILE) {
li_server_out_of_fds(vr->wrk->srv);
}
VR_ERROR(vr, "Couldn't open socket: %s", g_strerror(errno));
return LI_HANDLER_ERROR;
}
li_fd_init(pcon->fd);
ev_io_set(&pcon->fd_watcher, pcon->fd, EV_READ | EV_WRITE);
ev_io_start(vr->wrk->loop, &pcon->fd_watcher);
/* fall through */
case SS_CONNECTING:
if (-1 == connect(pcon->fd, &pcon->ctx->socket.addr->plain, pcon->ctx->socket.len)) {
switch (errno) {
case EINPROGRESS:
case EALREADY:
case EINTR:
pcon->state = SS_CONNECTING;
return LI_HANDLER_GO_ON;
case EAGAIN: /* backend overloaded */
proxy_close(vr, p);
li_vrequest_backend_overloaded(vr);
return LI_HANDLER_GO_ON;
case EISCONN:
break;
default:
VR_ERROR(vr, "Couldn't connect to '%s': %s",
li_sockaddr_to_string(pcon->ctx->socket, vr->wrk->tmp_str, TRUE)->str,
g_strerror(errno));
proxy_close(vr, p);
li_vrequest_backend_dead(vr);
return LI_HANDLER_GO_ON;
}
}
pcon->state = SS_CONNECTED;
/* prepare stream */
proxy_send_headers(vr, pcon);
/* fall through */
case SS_CONNECTED:
proxy_forward_request(vr, pcon);
break;
case SS_DONE:
break;
}
return LI_HANDLER_GO_ON;
}
static liHandlerResult fastcgi_statemachine(liVRequest *vr, fastcgi_connection *fcon) {
liPlugin *p = fcon->ctx->plugin;
switch (fcon->state) {
case FS_WAIT_FOR_REQUEST:
/* wait until we have either all data or the cqlimit is full */
if (-1 == vr->request.content_length || vr->request.content_length != vr->in->length) {
if (0 != li_chunkqueue_limit_available(vr->in))
return LI_HANDLER_GO_ON;
}
fcon->state = FS_CONNECT;
/* fall through */
case FS_CONNECT:
do {
fcon->fd = socket(fcon->ctx->socket.addr->plain.sa_family, SOCK_STREAM, 0);
} while (-1 == fcon->fd && errno == EINTR);
if (-1 == fcon->fd) {
if (errno == EMFILE) {
li_server_out_of_fds(vr->wrk->srv);
} else if (errno != g_atomic_int_get(&fcon->ctx->last_errno)) {
g_atomic_int_set(&fcon->ctx->last_errno, errno);
VR_ERROR(vr, "Couldn't open socket: %s", g_strerror(errno));
}
return LI_HANDLER_ERROR;
}
li_fd_init(fcon->fd);
ev_io_set(&fcon->fd_watcher, fcon->fd, EV_READ | EV_WRITE);
ev_io_start(vr->wrk->loop, &fcon->fd_watcher);
/* fall through */
case FS_CONNECTING:
if (-1 == connect(fcon->fd, &fcon->ctx->socket.addr->plain, fcon->ctx->socket.len)) {
switch (errno) {
case EINPROGRESS:
case EALREADY:
case EINTR:
fcon->state = FS_CONNECTING;
return LI_HANDLER_GO_ON;
case EAGAIN: /* backend overloaded */
fastcgi_close(vr, p);
li_vrequest_backend_overloaded(vr);
return LI_HANDLER_GO_ON;
case EISCONN:
break;
default:
if (errno != g_atomic_int_get(&fcon->ctx->last_errno)) {
g_atomic_int_set(&fcon->ctx->last_errno, errno);
VR_ERROR(vr, "Couldn't connect to '%s': %s",
li_sockaddr_to_string(fcon->ctx->socket, vr->wrk->tmp_str, TRUE)->str,
g_strerror(errno));
}
fastcgi_close(vr, p);
li_vrequest_backend_dead(vr);
return LI_HANDLER_GO_ON;
}
}
g_atomic_int_set(&fcon->ctx->last_errno, 0);
fcon->state = FS_CONNECTED;
/* prepare stream */
fastcgi_send_begin(fcon);
fastcgi_send_env(vr, fcon);
/* fall through */
case FS_CONNECTED:
fastcgi_forward_request(vr, fcon);
break;
case FS_DONE:
break;
}
return LI_HANDLER_GO_ON;
}