static liHandlerResult cache_etag_filter_miss(liVRequest *vr, liFilter *f) {
cache_etag_file *cfile = (cache_etag_file*) f->param;
ssize_t res;
gchar *buf;
off_t buflen;
liChunkIter citer = li_chunkqueue_iter(f->in);
UNUSED(vr);
if (0 == f->in->length) return LI_HANDLER_GO_ON;
if (!cfile) { /* somehow we lost the file */
li_chunkqueue_steal_all(f->out, f->in);
if (f->in->is_closed) f->out->is_closed = TRUE;
return LI_HANDLER_GO_ON;
}
if (LI_HANDLER_GO_ON != li_chunkiter_read(vr, citer, 0, 64*1024, &buf, &buflen)) {
VR_ERROR(vr, "%s", "Couldn't read data from chunkqueue");
cache_etag_file_free(cfile);
f->param = NULL;
li_chunkqueue_steal_all(f->out, f->in);
if (f->in->is_closed) f->out->is_closed = TRUE;
return LI_HANDLER_GO_ON;
}
res = write(cfile->fd, buf, buflen);
if (res < 0) {
switch (errno) {
case EINTR:
case EAGAIN:
break; /* come back later */
default:
VR_ERROR(vr, "Couldn't write to temporary cache file '%s': %s",
cfile->tmpfilename->str, g_strerror(errno));
cache_etag_file_free(cfile);
f->param = NULL;
li_chunkqueue_steal_all(f->out, f->in);
if (f->in->is_closed) f->out->is_closed = TRUE;
return LI_HANDLER_GO_ON;
}
} else {
li_chunkqueue_steal_len(f->out, f->in, res);
if (f->in->length == 0 && f->in->is_closed) {
cache_etag_file_finish(vr, cfile);
f->param = NULL;
f->out->is_closed = TRUE;
return LI_HANDLER_GO_ON;
}
}
return f->in->length ? LI_HANDLER_COMEBACK : LI_HANDLER_GO_ON;
}
static void mainvr_connection_upgrade(liVRequest *vr, liStream *backend_drain, liStream *backend_source) {
liConnection* con = li_connection_from_vrequest(vr);
LI_FORCE_ASSERT(NULL != con);
if (con->response_headers_sent || NULL != con->out.source) {
li_connection_error(con);
return;
}
if (CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "%s", "connection upgrade: write response headers");
}
con->response_headers_sent = TRUE;
con->info.keep_alive = FALSE;
li_response_send_headers(vr, con->out.out, NULL, TRUE);
con->state = LI_CON_STATE_UPGRADED;
vr->response.transfer_encoding = 0;
li_connection_update_io_wait(con);
li_stream_disconnect_dest(&con->in);
con->in.out->is_closed = FALSE;
li_stream_connect(&con->in, backend_drain);
li_stream_connect(backend_source, &con->out);
li_vrequest_reset(con->mainvr, TRUE);
if (NULL != con->in.source) {
li_chunkqueue_steal_all(con->out.out, backend_drain->out);
}
con->info.out_queue_length = con->out.out->length;
li_stream_notify(&con->out);
li_stream_notify(&con->in);
}
/* app -> ssl (plain) */
static void stream_plain_drain_cb(liStream *stream, liStreamEvent event) {
liGnuTLSFilter *f = LI_CONTAINER_OF(stream, liGnuTLSFilter, plain_drain);
switch (event) {
case LI_STREAM_NEW_DATA:
if (!stream->out->is_closed && NULL != stream->source) {
li_chunkqueue_steal_all(stream->out, stream->source->out);
stream->out->is_closed = stream->out->is_closed || stream->source->out->is_closed;
}
do_gnutls_write(f);
if (stream->out->is_closed) {
li_stream_disconnect(stream);
stream->out->is_closed = FALSE;
}
break;
case LI_STREAM_NEW_CQLIMIT:
break;
case LI_STREAM_CONNECTED_DEST: /* crypt_source */
break;
case LI_STREAM_CONNECTED_SOURCE: /* app */
break;
case LI_STREAM_DISCONNECTED_DEST:
if (!stream->out->is_closed || 0 != stream->out->length) {
f_abort_gnutls(f); /* didn't read everything */
}
break;
case LI_STREAM_DISCONNECTED_SOURCE:
if (!stream->out->is_closed) {
f_abort_gnutls(f); /* didn't get everything */
}
break;
case LI_STREAM_DESTROY:
f_release(f);
break;
}
}
/* io -> ssl crypted in */
static void stream_crypt_drain_cb(liStream *stream, liStreamEvent event) {
liGnuTLSFilter *f = LI_CONTAINER_OF(stream, liGnuTLSFilter, crypt_drain);
switch (event) {
case LI_STREAM_NEW_DATA:
if (!stream->out->is_closed && NULL != stream->source) {
li_chunkqueue_steal_all(stream->out, stream->source->out);
stream->out->is_closed = stream->out->is_closed || stream->source->out->is_closed;
li_stream_notify(stream); /* tell plain_source to do SSL_read */
}
if (stream->out->is_closed) {
li_stream_disconnect(stream);
}
break;
case LI_STREAM_NEW_CQLIMIT:
break;
case LI_STREAM_CONNECTED_DEST: /* plain_source */
break;
case LI_STREAM_CONNECTED_SOURCE: /* io in */
break;
case LI_STREAM_DISCONNECTED_DEST: /* plain_source */
if (!stream->out->is_closed || 0 != stream->out->length) {
f_abort_gnutls(f); /* didn't read everything */
}
break;
case LI_STREAM_DISCONNECTED_SOURCE: /* io in disconnect */
if (!stream->out->is_closed) {
f_abort_gnutls(f); /* conn aborted */
}
break;
case LI_STREAM_DESTROY:
f_release(f);
break;
}
}
static void stream_send_chunks(liChunkQueue *out, liChunkQueue *in) {
li_chunkqueue_steal_all(out, in);
if (in->is_closed && !out->is_closed) {
out->is_closed = TRUE;
}
}
/* stop buffering, forward everyting */
static void bod_stop(bod_state *state) {
bod_close(state);
if (NULL != state->stream.source && !state->stream.out->is_closed) {
li_chunkqueue_steal_all(state->stream.out, state->stream.source->out);
if (state->stream.source->out->is_closed) {
state->stream.out->is_closed = TRUE;
li_stream_disconnect(&state->stream);
}
li_stream_notify(&state->stream);
}
state->vr = NULL;
}
static int lua_chunkqueue_steal_all(lua_State *L) {
liChunkQueue *cq, *cq_from;
cq = li_lua_get_chunkqueue(L, 1);
cq_from = li_lua_get_chunkqueue(L, 2);
if (!cq_from) {
lua_pushliteral(L, "Expected source chunkqueue to steal from");
return lua_error(L);
}
li_chunkqueue_steal_all(cq, cq_from);
return 0;
}
liHandlerResult li_filter_chunked_encode(liVRequest *vr, liChunkQueue *out, liChunkQueue *in) {
UNUSED(vr);
if (in->length > 0) {
http_chunk_append_len(out, in->length);
li_chunkqueue_steal_all(out, in);
li_chunkqueue_append_mem(out, CONST_STR_LEN("\r\n"));
}
if (in->is_closed) {
if (!out->is_closed) {
li_chunkqueue_append_mem(out, CONST_STR_LEN("0\r\n\r\n"));
out->is_closed = TRUE;
}
return LI_HANDLER_GO_ON;
}
return LI_HANDLER_GO_ON;
}
static void stream_http_response_data(liStreamHttpResponse* shr) {
if (NULL == shr->stream.source) return;
if (!shr->response_headers_finished) {
switch (li_http_response_parse(shr->vr, &shr->parse_response_ctx)) {
case LI_HANDLER_GO_ON:
check_response_header(shr);
if (NULL == shr->stream.source) return;
break;
case LI_HANDLER_ERROR:
VR_ERROR(shr->vr, "%s", "Parsing response header failed");
li_vrequest_error(shr->vr);
return;
case LI_HANDLER_WAIT_FOR_EVENT:
if (shr->stream.source->out->is_closed) {
VR_ERROR(shr->vr, "%s", "Parsing response header failed (eos)");
li_vrequest_error(shr->vr);
}
return;
default:
return;
}
}
if (shr->transfer_encoding_chunked) {
if (!li_filter_chunked_decode(shr->vr, shr->stream.out, shr->stream.source->out, &shr->chunked_decode_state)) {
if (NULL != shr->vr) {
VR_ERROR(shr->vr, "%s", "Decoding chunks failed");
li_vrequest_error(shr->vr);
} else {
li_stream_reset(&shr->stream);
}
}
if (shr->stream.source->out->is_closed) {
li_stream_disconnect(&shr->stream);
}
} else {
li_chunkqueue_steal_all(shr->stream.out, shr->stream.source->out);
if (shr->stream.source->out->is_closed) {
shr->stream.out->is_closed = TRUE;
li_stream_disconnect(&shr->stream);
}
}
li_stream_notify(&shr->stream);
}
/* http response header/data -> tcp/ssl */
static void _connection_http_out_cb(liStream *stream, liStreamEvent event) {
liConnection *con = LI_CONTAINER_OF(stream, liConnection, out);
liChunkQueue *raw_out = stream->out, *out;
liVRequest *vr = con->mainvr;
switch (event) {
case LI_STREAM_NEW_DATA:
/* handle below */
break;
case LI_STREAM_CONNECTED_SOURCE:
/* also handle data immediately */
break;
case LI_STREAM_DISCONNECTED_SOURCE:
if (!con->out_has_all_data) li_connection_error(con);
return;
case LI_STREAM_DISCONNECTED_DEST:
if (!raw_out->is_closed || 0 != raw_out->length || NULL == con->con_sock.raw_out) {
li_connection_error(con);
} else {
connection_close(con);
}
return;
case LI_STREAM_DESTROY:
con->info.resp = NULL;
li_job_later(&con->wrk->loop.jobqueue, &con->job_reset);
return;
default:
return;
}
out = (NULL != stream->source) ? stream->source->out : NULL;
/* keep raw_out->is_closed = FALSE for keep-alive requests; instead set con->out_has_all_data = TRUE */
if (LI_CON_STATE_HANDLE_MAINVR <= con->state) {
if (NULL == stream->source) {
if (LI_CON_STATE_HANDLE_MAINVR == con->state) {
/* wait for vrequest to connect the stream as signal that the headers are ready */
return;
}
}
if (!con->response_headers_sent) {
if (CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "%s", "write response headers");
}
con->response_headers_sent = TRUE;
if (0 == CORE_OPTION(LI_CORE_OPTION_MAX_KEEP_ALIVE_IDLE).number) {
con->info.keep_alive = FALSE;
}
li_response_send_headers(vr, raw_out, out, FALSE);
}
if (!con->out_has_all_data && !raw_out->is_closed && NULL != out) {
if (vr->response.transfer_encoding & LI_HTTP_TRANSFER_ENCODING_CHUNKED) {
li_filter_chunked_encode(vr, raw_out, out);
} else {
li_chunkqueue_steal_all(raw_out, out);
}
}
if (raw_out->is_closed || NULL == out || out->is_closed) {
con->out_has_all_data = TRUE;
raw_out->is_closed = FALSE;
}
if (con->out_has_all_data) {
if (con->state < LI_CON_STATE_WRITE) {
con->state = LI_CON_STATE_WRITE;
li_connection_update_io_wait(con);
}
if (NULL != out) {
out = NULL;
li_stream_disconnect(stream);
}
}
con->info.out_queue_length = raw_out->length;
}
li_stream_notify(stream);
}
/* tcp/ssl -> http "parser" */
static void _connection_http_in_cb(liStream *stream, liStreamEvent event) {
liConnection *con = LI_CONTAINER_OF(stream, liConnection, in);
liChunkQueue *raw_in, *in;
liVRequest *vr = con->mainvr;
switch (event) {
case LI_STREAM_NEW_DATA:
/* handle below */
break;
case LI_STREAM_DISCONNECTED_SOURCE:
connection_close(con);
return;
case LI_STREAM_DESTROY:
con->info.req = NULL;
li_job_later(&con->wrk->loop.jobqueue, &con->job_reset);
return;
default:
return;
}
if (NULL == stream->source) return;
/* raw_in never gets closed normally - if we receive EOF from the client it means it cancelled the request */
raw_in = stream->source->out;
if (raw_in->is_closed) {
connection_close(con);
return;
}
/* always close "in" after request body end. reopen it on keep-alive */
in = con->in.out;
if (0 == raw_in->length) return; /* no (new) data */
if (LI_CON_STATE_UPGRADED == con->state) {
li_chunkqueue_steal_all(in, raw_in);
li_stream_notify(stream);
return;
}
if (con->state == LI_CON_STATE_KEEP_ALIVE) {
/* stop keep alive timeout watchers */
if (con->keep_alive_data.link) {
g_queue_delete_link(&con->wrk->keep_alive_queue, con->keep_alive_data.link);
con->keep_alive_data.link = NULL;
}
con->keep_alive_data.timeout = 0;
li_event_stop(&con->keep_alive_data.watcher);
con->keep_alive_requests++;
/* disable keep alive if limit is reached */
if (con->keep_alive_requests == CORE_OPTION(LI_CORE_OPTION_MAX_KEEP_ALIVE_REQUESTS).number)
con->info.keep_alive = FALSE;
/* reopen stream for request body */
li_chunkqueue_reset(in);
/* reset stuff from keep-alive and record timestamp */
li_vrequest_start(con->mainvr);
con->state = LI_CON_STATE_READ_REQUEST_HEADER;
/* put back in io timeout queue */
li_connection_update_io_wait(con);
} else if (con->state == LI_CON_STATE_REQUEST_START) {
con->state = LI_CON_STATE_READ_REQUEST_HEADER;
li_connection_update_io_wait(con);
}
if (con->state == LI_CON_STATE_READ_REQUEST_HEADER) {
liHandlerResult res;
if (CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "%s", "reading request header");
}
res = li_http_request_parse(vr, &con->req_parser_ctx);
/* max uri length 8 kilobytes */
/* TODO: check this and similar in request_parse and response_parse */
if (vr->request.uri.raw->len > 8*1024) {
VR_INFO(vr,
"request uri too large. limit: 8kb, received: %s",
li_counter_format(vr->request.uri.raw->len, COUNTER_BYTES, vr->wrk->tmp_str)->str
);
con->info.keep_alive = FALSE;
vr->response.http_status = 414; /* Request-URI Too Large */
con->state = LI_CON_STATE_WRITE;
li_connection_update_io_wait(con);
li_stream_again(&con->out);
return;
}
switch(res) {
case LI_HANDLER_GO_ON:
break; /* go on */
case LI_HANDLER_WAIT_FOR_EVENT:
return;
case LI_HANDLER_ERROR:
case LI_HANDLER_COMEBACK: /* unexpected */
/* unparsable header */
if (CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "%s", "parsing header failed");
}
con->wrk->stats.requests++;
con->info.keep_alive = FALSE;
/* set status 400 if not already set to e.g. 413 */
if (vr->response.http_status == 0)
vr->response.http_status = 400;
con->state = LI_CON_STATE_WRITE;
li_connection_update_io_wait(con);
li_stream_again(&con->out);
return;
}
con->wrk->stats.requests++;
/* headers ready */
if (CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "%s", "validating request header");
}
if (!li_request_validate_header(con)) {
/* set status 400 if not already set */
if (vr->response.http_status == 0)
vr->response.http_status = 400;
con->state = LI_CON_STATE_WRITE;
con->info.keep_alive = FALSE;
li_connection_update_io_wait(con);
li_stream_again(&con->out);
return;
}
/* When does a client ask for 100 Continue? probably not while trying to ddos us
* as post content probably goes to a dynamic backend anyway, we don't
* care about the rare cases we could determine that we don't want a request at all
* before sending it to a backend - so just send the stupid header
*/
if (con->expect_100_cont) {
if (CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "%s", "send 100 Continue");
}
li_chunkqueue_append_mem(con->out.out, CONST_STR_LEN("HTTP/1.1 100 Continue\r\n\r\n"));
con->expect_100_cont = FALSE;
li_stream_notify(&con->out);
}
con->state = LI_CON_STATE_HANDLE_MAINVR;
li_connection_update_io_wait(con);
li_action_enter(vr, con->srv->mainaction);
li_vrequest_handle_request_headers(vr);
}
if (con->state != LI_CON_STATE_READ_REQUEST_HEADER && !in->is_closed) {
goffset newbytes = 0;
if (-1 == vr->request.content_length) {
if (!in->is_closed) {
if (!li_filter_chunked_decode(vr, in, raw_in, &con->in_chunked_decode_state)) {
if (CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "%s", "failed decoding chunked request body");
}
li_connection_error(con);
return;
}
if (in->is_closed) vr->request.content_length = in->bytes_in;
newbytes = 1; /* always notify */
}
} else {
if (in->bytes_in < vr->request.content_length) {
newbytes = li_chunkqueue_steal_len(in, raw_in, vr->request.content_length - in->bytes_in);
}
if (in->bytes_in == vr->request.content_length) {
in->is_closed = TRUE;
}
}
if (newbytes > 0 || in->is_closed) {
li_stream_notify(&con->in);
}
}
}
static liHandlerResult memcache_store_filter(liVRequest *vr, liFilter *f) {
memcache_filter *mf = (memcache_filter*) f->param;
if (NULL == f->in) {
memcache_store_filter_free(vr, f);
/* didn't handle f->in->is_closed? abort forwarding */
if (!f->out->is_closed) li_stream_reset(&f->stream);
return LI_HANDLER_GO_ON;
}
if (NULL == mf) goto forward;
if (f->in->is_closed && 0 == f->in->length && f->out->is_closed) {
/* nothing to do anymore */
return LI_HANDLER_GO_ON;
}
/* check if size still fits into buffer */
if ((gssize) (f->in->length + mf->buf->used) > (gssize) mf->ctx->maxsize) {
/* response too big, switch to "forward" mode */
memcache_store_filter_free(vr, f);
goto forward;
}
while (0 < f->in->length) {
char *data;
off_t len;
liChunkIter ci;
liHandlerResult res;
GError *err = NULL;
ci = li_chunkqueue_iter(f->in);
if (LI_HANDLER_GO_ON != (res = li_chunkiter_read(ci, 0, 16*1024, &data, &len, &err))) {
if (NULL != err) {
VR_ERROR(vr, "Couldn't read data from chunkqueue: %s", err->message);
g_error_free(err);
}
return res;
}
if ((gssize) (len + mf->buf->used) > (gssize) mf->ctx->maxsize) {
/* response too big, switch to "forward" mode */
memcache_store_filter_free(vr, f);
goto forward;
}
memcpy(mf->buf->addr + mf->buf->used, data, len);
mf->buf->used += len;
if (!f->out->is_closed) {
li_chunkqueue_steal_len(f->out, f->in, len);
} else {
li_chunkqueue_skip(f->in, len);
}
}
if (f->in->is_closed) {
/* finally: store response in memcached */
liMemcachedCon *con;
GError *err = NULL;
liMemcachedRequest *req;
memcached_ctx *ctx = mf->ctx;
assert(0 == f->in->length);
f->out->is_closed = TRUE;
con = mc_ctx_prepare(ctx, vr->wrk);
mc_ctx_build_key(vr->wrk->tmp_str, ctx, vr);
if (NULL != vr && CORE_OPTION(LI_CORE_OPTION_DEBUG_REQUEST_HANDLING).boolean) {
VR_DEBUG(vr, "memcached.store: storing response for key '%s'", vr->wrk->tmp_str->str);
}
req = li_memcached_set(con, vr->wrk->tmp_str, ctx->flags, ctx->ttl, mf->buf, NULL, NULL, &err);
memcache_store_filter_free(vr, f);
if (NULL == req) {
if (NULL != err) {
if (NULL != vr && LI_MEMCACHED_DISABLED != err->code) {
VR_ERROR(vr, "memcached.store: set failed: %s", err->message);
}
g_clear_error(&err);
} else if (NULL != vr) {
VR_ERROR(vr, "memcached.store: set failed: %s", "Unkown error");
}
}
}
return LI_HANDLER_GO_ON;
forward:
if (f->out->is_closed) {
li_chunkqueue_skip_all(f->in);
li_stream_disconnect(&f->stream);
} else {
li_chunkqueue_steal_all(f->out, f->in);
if (f->in->is_closed) f->out->is_closed = f->in->is_closed;
}
return LI_HANDLER_GO_ON;
}
static void bod_handle_data(bod_state *state) {
liChunkQueue *out = state->stream.out;
liChunkQueue *in;
if (out->is_closed) {
li_stream_disconnect(&state->stream);
bod_close(state);
return;
}
in = (state->stream.source != NULL) ? state->stream.source->out : NULL;
if (NULL == in) goto out;
if (NULL == state->vr) {
li_chunkqueue_steal_all(out, in);
goto out;
}
while (in->length > 0) {
liChunk *c = li_chunkqueue_first_chunk(in);
liChunkIter ci;
off_t length, data_len;
char *data = NULL;
GError *err;
assert(UNUSED_CHUNK != c->type);
switch (c->type) {
case UNUSED_CHUNK:
/* shouldn't happen anyway, but stealing it is ok here too */
case FILE_CHUNK:
if (state->split_on_file_chunks) {
bod_close(state);
} else {
bod_flush(state);
}
li_chunkqueue_steal_chunk(out, in);
break;
case STRING_CHUNK:
case MEM_CHUNK:
case BUFFER_CHUNK:
if (!bod_open(state)) return;
length = li_chunk_length(c);
ci = li_chunkqueue_iter(in);
err = NULL;
if (LI_HANDLER_GO_ON != li_chunkiter_read(ci, 0, length, &data, &data_len, &err)) {
if (NULL != err) {
VR_ERROR(state->vr, "%s", err->message);
g_error_free(err);
}
bod_error(state);
return;
}
while ( data_len > 0 ) {
ssize_t r;
r = pwrite(state->tempfile->fd, data, data_len, state->write_pos);
if (r < 0) {
switch (errno) {
case EINTR: continue;
default: break;
}
VR_ERROR(state->vr, "pwrite failed: %s", g_strerror(errno));
bod_stop(state); /* write failures are not critical */
return;
}
data += r;
data_len -= r;
state->write_pos += r;
}
li_chunkqueue_skip(in, length);
break;
}
}
bod_autoflush(state);
out:
if (NULL == in || in->is_closed) {
out->is_closed = TRUE;
bod_close(state); /* close/flush ignores out->is_closed */
li_stream_notify(&state->stream); /* if no flush happened we still notify */
}
}
static void proxy_fd_cb(struct ev_loop *loop, ev_io *w, int revents) {
proxy_connection *pcon = (proxy_connection*) w->data;
if (pcon->state == SS_CONNECTING) {
if (LI_HANDLER_GO_ON != proxy_statemachine(pcon->vr, pcon)) {
li_vrequest_error(pcon->vr);
}
return;
}
if (revents & EV_READ) {
if (pcon->proxy_in->is_closed) {
li_ev_io_rem_events(loop, w, EV_READ);
} else {
switch (li_network_read(pcon->vr, w->fd, pcon->proxy_in, &pcon->proxy_in_buffer)) {
case LI_NETWORK_STATUS_SUCCESS:
break;
case LI_NETWORK_STATUS_FATAL_ERROR:
VR_ERROR(pcon->vr, "(%s) network read fatal error", pcon->ctx->socket_str->str);
li_vrequest_error(pcon->vr);
return;
case LI_NETWORK_STATUS_CONNECTION_CLOSE:
pcon->proxy_in->is_closed = TRUE;
ev_io_stop(loop, w);
close(pcon->fd);
pcon->fd = -1;
li_vrequest_backend_finished(pcon->vr);
break;
case LI_NETWORK_STATUS_WAIT_FOR_EVENT:
break;
}
}
}
if (pcon->fd != -1 && (revents & EV_WRITE)) {
if (pcon->proxy_out->length > 0) {
switch (li_network_write(pcon->vr, w->fd, pcon->proxy_out, 256*1024)) {
case LI_NETWORK_STATUS_SUCCESS:
break;
case LI_NETWORK_STATUS_FATAL_ERROR:
VR_ERROR(pcon->vr, "(%s) network write fatal error", pcon->ctx->socket_str->str);
li_vrequest_error(pcon->vr);
return;
case LI_NETWORK_STATUS_CONNECTION_CLOSE:
pcon->proxy_in->is_closed = TRUE;
ev_io_stop(loop, w);
close(pcon->fd);
pcon->fd = -1;
li_vrequest_backend_finished(pcon->vr);
break;
case LI_NETWORK_STATUS_WAIT_FOR_EVENT:
break;
}
}
if (pcon->proxy_out->length == 0) {
li_ev_io_rem_events(loop, w, EV_WRITE);
}
}
if (!pcon->response_headers_finished && LI_HANDLER_GO_ON == li_http_response_parse(pcon->vr, &pcon->parse_response_ctx)) {
/* "ignore" 1xx response headers */
if (!(pcon->vr->response.http_status >= 100 && pcon->vr->response.http_status < 200)) {
pcon->response_headers_finished = TRUE;
li_vrequest_handle_response_headers(pcon->vr);
}
}
if (pcon->response_headers_finished) {
li_chunkqueue_steal_all(pcon->vr->out, pcon->proxy_in);
pcon->vr->out->is_closed = pcon->proxy_in->is_closed;
li_vrequest_handle_response_body(pcon->vr);
}
/* only possible if we didn't found a header */
if (pcon->proxy_in->is_closed && !pcon->vr->out->is_closed) {
VR_ERROR(pcon->vr, "(%s) unexpected end-of-file (perhaps the proxy process died)", pcon->ctx->socket_str->str);
li_vrequest_error(pcon->vr);
}
}
static void fastcgi_fd_cb(struct ev_loop *loop, ev_io *w, int revents) {
fastcgi_connection *fcon = (fastcgi_connection*) w->data;
if (fcon->state == FS_CONNECTING) {
if (LI_HANDLER_GO_ON != fastcgi_statemachine(fcon->vr, fcon)) {
li_vrequest_error(fcon->vr);
}
return;
}
if (revents & EV_READ) {
if (fcon->fcgi_in->is_closed) {
li_ev_io_rem_events(loop, w, EV_READ);
} else {
switch (li_network_read(fcon->vr, w->fd, fcon->fcgi_in, &fcon->fcgi_in_buffer)) {
case LI_NETWORK_STATUS_SUCCESS:
break;
case LI_NETWORK_STATUS_FATAL_ERROR:
VR_ERROR(fcon->vr, "(%s) network read fatal error", fcon->ctx->socket_str->str);
li_vrequest_error(fcon->vr);
return;
case LI_NETWORK_STATUS_CONNECTION_CLOSE:
fcon->fcgi_in->is_closed = TRUE;
ev_io_stop(loop, w);
close(fcon->fd);
fcon->fd = -1;
li_vrequest_backend_finished(fcon->vr);
break;
case LI_NETWORK_STATUS_WAIT_FOR_EVENT:
break;
}
}
}
if (fcon->fd != -1 && (revents & EV_WRITE)) {
if (fcon->fcgi_out->length > 0) {
switch (li_network_write(fcon->vr, w->fd, fcon->fcgi_out, 256*1024)) {
case LI_NETWORK_STATUS_SUCCESS:
break;
case LI_NETWORK_STATUS_FATAL_ERROR:
VR_ERROR(fcon->vr, "(%s) network write fatal error", fcon->ctx->socket_str->str);
li_vrequest_error(fcon->vr);
return;
case LI_NETWORK_STATUS_CONNECTION_CLOSE:
fcon->fcgi_in->is_closed = TRUE;
ev_io_stop(loop, w);
close(fcon->fd);
fcon->fd = -1;
li_vrequest_backend_finished(fcon->vr);
break;
case LI_NETWORK_STATUS_WAIT_FOR_EVENT:
break;
}
}
if (fcon->fcgi_out->length == 0) {
li_ev_io_rem_events(loop, w, EV_WRITE);
}
}
if (!fastcgi_parse_response(fcon)) return;
if (!fcon->response_headers_finished) {
switch (li_http_response_parse(fcon->vr, &fcon->parse_response_ctx)) {
case LI_HANDLER_GO_ON:
fcon->response_headers_finished = TRUE;
li_vrequest_handle_response_headers(fcon->vr);
break;
case LI_HANDLER_ERROR:
VR_ERROR(fcon->vr, "Parsing response header failed for: %s", fcon->ctx->socket_str->str);
li_vrequest_error(fcon->vr);
break;
default:
break;
}
}
if (fcon->response_headers_finished) {
li_chunkqueue_steal_all(fcon->vr->out, fcon->stdout);
fcon->vr->out->is_closed = fcon->stdout->is_closed;
li_vrequest_handle_response_body(fcon->vr);
}
if (fcon->fcgi_in->is_closed && !fcon->vr->out->is_closed) {
VR_ERROR(fcon->vr, "(%s) unexpected end-of-file (perhaps the fastcgi process died)", fcon->ctx->socket_str->str);
li_vrequest_error(fcon->vr);
}
}
static liHandlerResult cache_etag_filter_miss(liVRequest *vr, liFilter *f) {
cache_etag_file *cfile = (cache_etag_file*) f->param;
ssize_t res;
gchar *buf;
off_t buflen;
liChunkIter citer;
GError *err = NULL;
if (NULL == f->in) {
cache_etag_filter_free(vr, f);
/* didn't handle f->in->is_closed? abort forwarding */
if (!f->out->is_closed) li_stream_reset(&f->stream);
return LI_HANDLER_GO_ON;
}
if (NULL == cfile) goto forward;
if (f->in->length > 0) {
citer = li_chunkqueue_iter(f->in);
if (LI_HANDLER_GO_ON != li_chunkiter_read(citer, 0, 64*1024, &buf, &buflen, &err)) {
if (NULL != err) {
if (NULL != vr) VR_ERROR(vr, "Couldn't read data from chunkqueue: %s", err->message);
g_error_free(err);
} else {
if (NULL != vr) VR_ERROR(vr, "%s", "Couldn't read data from chunkqueue");
}
cache_etag_filter_free(vr, f);
goto forward;
}
res = write(cfile->fd, buf, buflen);
if (res < 0) {
switch (errno) {
case EINTR:
case EAGAIN:
return LI_HANDLER_COMEBACK;
default:
if (NULL != vr) VR_ERROR(vr, "Couldn't write to temporary cache file '%s': %s",
cfile->tmpfilename->str, g_strerror(errno));
cache_etag_filter_free(vr, f);
goto forward;
}
} else {
if (!f->out->is_closed) {
li_chunkqueue_steal_len(f->out, f->in, res);
} else {
li_chunkqueue_skip(f->in, res);
}
}
}
if (0 == f->in->length && f->in->is_closed) {
f->out->is_closed = TRUE;
f->param = NULL;
cache_etag_file_finish(vr, cfile);
return LI_HANDLER_GO_ON;
}
return LI_HANDLER_GO_ON;
forward:
if (f->out->is_closed) {
li_chunkqueue_skip_all(f->in);
li_stream_disconnect(&f->stream);
} else {
li_chunkqueue_steal_all(f->out, f->in);
if (f->in->is_closed) f->out->is_closed = f->in->is_closed;
}
return LI_HANDLER_GO_ON;
}
