/* ===================================================== */
void handle_message( const connection_ptr& con, const message& m )
{
try {
chan_data& cdat = get_channel_data(con);
ilog( "${msg_type}", ("msg_type", (bitname::message_type)m.msg_type ) );
switch( (bitname::message_type)m.msg_type )
{
case name_inv_msg:
handle_name_inv( con, cdat, m.as<name_inv_message>() );
break;
case block_inv_msg:
handle_block_inv( con, cdat, m.as<block_inv_message>() );
break;
case get_name_inv_msg:
handle_get_name_inv( con, cdat, m.as<get_name_inv_message>() );
break;
case get_headers_msg:
handle_get_headers( con, cdat, m.as<get_headers_message>() );
break;
case get_block_msg:
handle_get_block( con, cdat, m.as<get_block_message>() );
break;
case get_block_index_msg:
handle_get_block_index( con, cdat, m.as<get_block_index_message>() );
break;
case get_name_header_msg:
handle_get_name( con, cdat, m.as<get_name_header_message>() );
break;
case name_header_msg:
handle_name( con, cdat, m.as<name_header_message>() );
break;
case block_index_msg:
handle_block_index( con, cdat, m.as<block_index_message>() );
break;
case block_msg:
handle_block( con, cdat, m.as<block_message>() );
break;
case headers_msg:
handle_headers( con, cdat, m.as<headers_message>() );
break;
default:
FC_THROW_EXCEPTION( exception, "unknown bitname message type ${msg_type}", ("msg_type", m.msg_type ) );
}
}
catch ( fc::exception& e )
{
wlog( "${e} ${from}", ("e",e.to_detail_string())("from",con->remote_endpoint()) );
}
} // handle_message
static int open_request (struct neon_handle * handle, uint64_t startbyte)
{
int ret;
const ne_status * status;
ne_uri * rediruri;
if (handle->purl->query && * (handle->purl->query))
{
SCONCAT3 (tmp, handle->purl->path, "?", handle->purl->query);
handle->request = ne_request_create (handle->session, "GET", tmp);
}
else
handle->request = ne_request_create (handle->session, "GET", handle->purl->path);
if (startbyte > 0)
ne_print_request_header (handle->request, "Range", "bytes=%"PRIu64"-", startbyte);
ne_print_request_header (handle->request, "Icy-MetaData", "1");
/* Try to connect to the server. */
_DEBUG ("<%p> Connecting...", handle);
ret = ne_begin_request (handle->request);
status = ne_get_status (handle->request);
_DEBUG ("<%p> Return: %d, Status: %d", handle, ret, status->code);
if (ret == NE_OK)
{
switch (status->code)
{
case 401:
/* Authorization required. Reconnect to authenticate */
_DEBUG ("Reconnecting due to 401");
ne_end_request (handle->request);
ret = ne_begin_request (handle->request);
break;
case 301:
case 302:
case 303:
case 307:
/* Redirect encountered. Reconnect. */
ne_end_request (handle->request);
ret = NE_REDIRECT;
break;
case 407:
/* Proxy auth required. Reconnect to authenticate */
_DEBUG ("Reconnecting due to 407");
ne_end_request (handle->request);
ret = ne_begin_request (handle->request);
break;
}
}
switch (ret)
{
case NE_OK:
if (status->code > 199 && status->code < 300)
{
/* URL opened OK */
_DEBUG ("<%p> URL opened OK", handle);
handle->content_start = startbyte;
handle->pos = startbyte;
handle_headers (handle);
return 0;
}
break;
case NE_REDIRECT:
/* We hit a redirect. Handle it. */
_DEBUG ("<%p> Redirect encountered", handle);
handle->redircount += 1;
rediruri = (ne_uri *) ne_redirect_location (handle->session);
ne_request_destroy (handle->request);
handle->request = NULL;
if (! rediruri)
{
_ERROR ("<%p> Could not parse redirect response", (void *) handle);
return -1;
}
ne_uri_free (handle->purl);
ne_uri_copy (handle->purl, rediruri);
return 1;
}
/* Something went wrong. */
_ERROR ("<%p> Could not open URL: %d (%d)", (void *) handle, ret, status->code);
if (ret)
_ERROR ("<%p> neon error string: %s", (void *) handle, ne_get_error (handle->session));
ne_request_destroy (handle->request);
handle->request = NULL;
return -1;
}
static apr_status_t dispatch(proxy_conn_rec *conn, proxy_dir_conf *conf,
request_rec *r, apr_pool_t *setaside_pool,
apr_uint16_t request_id, const char **err,
int *bad_request, int *has_responded)
{
apr_bucket_brigade *ib, *ob;
int seen_end_of_headers = 0, done = 0, ignore_body = 0;
apr_status_t rv = APR_SUCCESS;
int script_error_status = HTTP_OK;
conn_rec *c = r->connection;
struct iovec vec[2];
ap_fcgi_header header;
unsigned char farray[AP_FCGI_HEADER_LEN];
apr_pollfd_t pfd;
int header_state = HDR_STATE_READING_HEADERS;
char stack_iobuf[AP_IOBUFSIZE];
apr_size_t iobuf_size = AP_IOBUFSIZE;
char *iobuf = stack_iobuf;
*err = NULL;
if (conn->worker->s->io_buffer_size_set) {
iobuf_size = conn->worker->s->io_buffer_size;
iobuf = apr_palloc(r->pool, iobuf_size);
}
pfd.desc_type = APR_POLL_SOCKET;
pfd.desc.s = conn->sock;
pfd.p = r->pool;
pfd.reqevents = APR_POLLIN | APR_POLLOUT;
ib = apr_brigade_create(r->pool, c->bucket_alloc);
ob = apr_brigade_create(r->pool, c->bucket_alloc);
while (! done) {
apr_interval_time_t timeout;
apr_size_t len;
int n;
/* We need SOME kind of timeout here, or virtually anything will
* cause timeout errors. */
apr_socket_timeout_get(conn->sock, &timeout);
rv = apr_poll(&pfd, 1, &n, timeout);
if (rv != APR_SUCCESS) {
if (APR_STATUS_IS_EINTR(rv)) {
continue;
}
*err = "polling";
break;
}
if (pfd.rtnevents & APR_POLLOUT) {
apr_size_t to_send, writebuflen;
int last_stdin = 0;
char *iobuf_cursor;
rv = ap_get_brigade(r->input_filters, ib,
AP_MODE_READBYTES, APR_BLOCK_READ,
iobuf_size);
if (rv != APR_SUCCESS) {
*err = "reading input brigade";
*bad_request = 1;
break;
}
if (APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(ib))) {
last_stdin = 1;
}
writebuflen = iobuf_size;
rv = apr_brigade_flatten(ib, iobuf, &writebuflen);
apr_brigade_cleanup(ib);
if (rv != APR_SUCCESS) {
*err = "flattening brigade";
break;
}
to_send = writebuflen;
iobuf_cursor = iobuf;
while (to_send > 0) {
int nvec = 0;
apr_size_t write_this_time;
write_this_time =
to_send < AP_FCGI_MAX_CONTENT_LEN ? to_send : AP_FCGI_MAX_CONTENT_LEN;
ap_fcgi_fill_in_header(&header, AP_FCGI_STDIN, request_id,
(apr_uint16_t)write_this_time, 0);
ap_fcgi_header_to_array(&header, farray);
vec[nvec].iov_base = (void *)farray;
vec[nvec].iov_len = sizeof(farray);
++nvec;
if (writebuflen) {
vec[nvec].iov_base = iobuf_cursor;
vec[nvec].iov_len = write_this_time;
++nvec;
}
rv = send_data(conn, vec, nvec, &len);
if (rv != APR_SUCCESS) {
*err = "sending stdin";
break;
}
to_send -= write_this_time;
iobuf_cursor += write_this_time;
}
if (rv != APR_SUCCESS) {
break;
}
if (last_stdin) {
pfd.reqevents = APR_POLLIN; /* Done with input data */
/* signal EOF (empty FCGI_STDIN) */
ap_fcgi_fill_in_header(&header, AP_FCGI_STDIN, request_id,
0, 0);
ap_fcgi_header_to_array(&header, farray);
vec[0].iov_base = (void *)farray;
vec[0].iov_len = sizeof(farray);
rv = send_data(conn, vec, 1, &len);
if (rv != APR_SUCCESS) {
*err = "sending empty stdin";
break;
}
}
}
if (pfd.rtnevents & APR_POLLIN) {
apr_size_t readbuflen;
apr_uint16_t clen, rid;
apr_bucket *b;
unsigned char plen;
unsigned char type, version;
/* First, we grab the header... */
rv = get_data_full(conn, (char *) farray, AP_FCGI_HEADER_LEN);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01067)
"Failed to read FastCGI header");
break;
}
ap_log_rdata(APLOG_MARK, APLOG_TRACE8, r, "FastCGI header",
farray, AP_FCGI_HEADER_LEN, 0);
ap_fcgi_header_fields_from_array(&version, &type, &rid,
&clen, &plen, farray);
if (version != AP_FCGI_VERSION_1) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01068)
"Got bogus version %d", (int)version);
rv = APR_EINVAL;
break;
}
if (rid != request_id) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01069)
"Got bogus rid %d, expected %d",
rid, request_id);
rv = APR_EINVAL;
break;
}
recv_again:
if (clen > iobuf_size) {
readbuflen = iobuf_size;
} else {
readbuflen = clen;
}
/* Now get the actual data. Yes it sucks to do this in a second
* recv call, this will eventually change when we move to real
* nonblocking recv calls. */
if (readbuflen != 0) {
rv = get_data(conn, iobuf, &readbuflen);
if (rv != APR_SUCCESS) {
*err = "reading response body";
break;
}
}
switch (type) {
case AP_FCGI_STDOUT:
if (clen != 0) {
b = apr_bucket_transient_create(iobuf,
readbuflen,
c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(ob, b);
if (! seen_end_of_headers) {
int st = handle_headers(r, &header_state,
iobuf, readbuflen);
if (st == 1) {
int status;
seen_end_of_headers = 1;
status = ap_scan_script_header_err_brigade_ex(r, ob,
NULL, APLOG_MODULE_INDEX);
/* suck in all the rest */
if (status != OK) {
apr_bucket *tmp_b;
apr_brigade_cleanup(ob);
tmp_b = apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(ob, tmp_b);
*has_responded = 1;
r->status = status;
rv = ap_pass_brigade(r->output_filters, ob);
if (rv != APR_SUCCESS) {
*err = "passing headers brigade to output filters";
}
else if (status == HTTP_NOT_MODIFIED) {
/* The 304 response MUST NOT contain
* a message-body, ignore it. */
ignore_body = 1;
}
else {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01070)
"Error parsing script headers");
rv = APR_EINVAL;
}
break;
}
if (conf->error_override &&
ap_is_HTTP_ERROR(r->status)) {
/*
* set script_error_status to discard
* everything after the headers
*/
script_error_status = r->status;
/*
* prevent ap_die() from treating this as a
* recursive error, initially:
*/
r->status = HTTP_OK;
}
if (script_error_status == HTTP_OK
&& !APR_BRIGADE_EMPTY(ob) && !ignore_body) {
/* Send the part of the body that we read while
* reading the headers.
*/
*has_responded = 1;
rv = ap_pass_brigade(r->output_filters, ob);
if (rv != APR_SUCCESS) {
*err = "passing brigade to output filters";
break;
}
}
apr_brigade_cleanup(ob);
apr_pool_clear(setaside_pool);
}
else {
/* We're still looking for the end of the
* headers, so this part of the data will need
* to persist. */
apr_bucket_setaside(b, setaside_pool);
}
} else {
/* we've already passed along the headers, so now pass
* through the content. we could simply continue to
* setaside the content and not pass until we see the
* 0 content-length (below, where we append the EOS),
* but that could be a huge amount of data; so we pass
* along smaller chunks
*/
if (script_error_status == HTTP_OK && !ignore_body) {
*has_responded = 1;
rv = ap_pass_brigade(r->output_filters, ob);
if (rv != APR_SUCCESS) {
*err = "passing brigade to output filters";
break;
}
}
apr_brigade_cleanup(ob);
}
/* If we didn't read all the data, go back and get the
* rest of it. */
if (clen > readbuflen) {
clen -= readbuflen;
goto recv_again;
}
} else {
/* XXX what if we haven't seen end of the headers yet? */
if (script_error_status == HTTP_OK) {
b = apr_bucket_eos_create(c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(ob, b);
*has_responded = 1;
rv = ap_pass_brigade(r->output_filters, ob);
if (rv != APR_SUCCESS) {
*err = "passing brigade to output filters";
break;
}
}
/* XXX Why don't we cleanup here? (logic from AJP) */
}
break;
case AP_FCGI_STDERR:
/* TODO: Should probably clean up this logging a bit... */
if (clen) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01071)
"Got error '%.*s'", (int)readbuflen, iobuf);
}
if (clen > readbuflen) {
clen -= readbuflen;
goto recv_again;
}
break;
case AP_FCGI_END_REQUEST:
done = 1;
break;
default:
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01072)
"Got bogus record %d", type);
break;
}
/* Leave on above switch's inner error. */
if (rv != APR_SUCCESS) {
break;
}
if (plen) {
rv = get_data_full(conn, iobuf, plen);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(02537)
"Error occurred reading padding");
break;
}
}
}
}
apr_brigade_destroy(ib);
apr_brigade_destroy(ob);
if (script_error_status != HTTP_OK) {
ap_die(script_error_status, r); /* send ErrorDocument */
*has_responded = 1;
}
return rv;
}
