in src/outgoing.c [797:1046]
static apr_status_t read_from_connection(serf_connection_t *conn)
{
apr_status_t status;
apr_pool_t *tmppool;
apr_status_t close_connection = APR_SUCCESS;
/* assert: request != NULL */
if ((status = apr_pool_create(&tmppool, conn->pool)) != APR_SUCCESS)
return status;
/* Invoke response handlers until we have no more work. */
while (1) {
serf_request_t *request;
apr_pool_clear(tmppool);
/* Whatever is coming in on the socket corresponds to the first request
* on our chain.
*/
request = conn->written_reqs;
if (!request) {
/* Request wasn't completely written yet! */
request = conn->unwritten_reqs;
}
/* We have a different codepath when we can have async responses. */
if (conn->async_responses) {
/* TODO What about socket errors? */
status = handle_async_response(conn, tmppool);
if (APR_STATUS_IS_EAGAIN(status)) {
status = APR_SUCCESS;
goto error;
}
if (status) {
goto error;
}
continue;
}
/* We are reading a response for a request we haven't
* written yet!
*
* This shouldn't normally happen EXCEPT:
*
* 1) when the other end has closed the socket and we're
* pending an EOF return.
* 2) Doing the initial SSL handshake - we'll get EAGAIN
* as the SSL buckets will hide the handshake from us
* but not return any data.
* 3) When the server sends us an SSL alert.
*
* In these cases, we should not receive any actual user data.
*
* 4) When the server sends a error response, like 408 Request timeout.
* This response should be passed to the application.
*
* If we see an EOF (due to either an expired timeout or the server
* sending the SSL 'close notify' shutdown alert), we'll reset the
* connection and open a new one.
*/
if (request->req_bkt || request->writing == SERF_WRITING_NONE) {
const char *data;
apr_size_t len;
status = serf_bucket_peek(conn->pump.stream, &data, &len);
if (APR_STATUS_IS_EOF(status)) {
reset_connection(conn, 1);
status = APR_SUCCESS;
goto error;
}
else if (APR_STATUS_IS_EAGAIN(status) && !len) {
status = APR_SUCCESS;
goto error;
} else if (status && !APR_STATUS_IS_EAGAIN(status)) {
/* Read error */
goto error;
}
/* Unexpected response from the server */
if (conn->write_now) {
conn->write_now = false;
status = conn->perform_write(conn);
if (!SERF_BUCKET_READ_ERROR(status))
status = APR_SUCCESS;
}
}
if (conn->framing_type != SERF_CONNECTION_FRAMING_TYPE_HTTP1)
break;
/* If the request doesn't have a response bucket, then call the
* acceptor to get one created.
*/
if (request->resp_bkt == NULL) {
if (! request->acceptor) {
/* Request wasn't even setup.
Server replying before it received anything? */
return SERF_ERROR_BAD_HTTP_RESPONSE;
}
request->resp_bkt = (*request->acceptor)(request, conn->pump.stream,
request->acceptor_baton,
tmppool);
apr_pool_clear(tmppool);
/* Share the configuration with the response bucket(s) */
serf_bucket_set_config(request->resp_bkt, conn->config);
}
status = serf__handle_response(request, tmppool);
/* If we received APR_SUCCESS, run this loop again. */
if (!status) {
continue;
}
/* If our response handler says it can't do anything more, we now
* treat that as a success.
*/
if (APR_STATUS_IS_EAGAIN(status)) {
/* It is possible that while reading the response, the ssl layer
has prepared some data to send. If this was the last request,
serf will not check for socket writability, so force this here.
*/
if (request_or_data_pending(&request, conn) && !request) {
serf_io__set_pollset_dirty(&conn->io);
}
status = APR_SUCCESS;
goto error;
}
close_connection = is_conn_closing(request->resp_bkt);
if (!APR_STATUS_IS_EOF(status) &&
close_connection != SERF_ERROR_CLOSING) {
/* Whether success, or an error, there is no more to do unless
* this request has been completed.
*/
goto error;
}
/* The response has been fully-read, so that means the request has
* either been fully-delivered (most likely), or that we don't need to
* write the rest of it anymore, e.g. when a 408 Request timeout was
$ received.
* Remove it from our queue and loop to read another response.
*/
if (request == conn->written_reqs) {
conn->written_reqs = request->next;
conn->nr_of_written_reqs--;
} else {
conn->unwritten_reqs = request->next;
conn->nr_of_unwritten_reqs--;
}
serf__destroy_request(request);
request = conn->written_reqs;
if (!request) {
/* Received responses for all written requests */
conn->written_reqs_tail = NULL;
/* Request wasn't completely written yet! */
request = conn->unwritten_reqs;
if (!request)
conn->unwritten_reqs_tail = NULL;
}
conn->completed_responses++;
/* We have received a response. If there are no more outstanding
requests on this connection, we should stop polling for READ events
for now. */
if (!conn->written_reqs && !conn->unwritten_reqs) {
serf_io__set_pollset_dirty(&conn->io);
}
/* This means that we're being advised that the connection is done. */
if (close_connection == SERF_ERROR_CLOSING) {
reset_connection(conn, 1);
if (APR_STATUS_IS_EOF(status))
status = APR_SUCCESS;
goto error;
}
/* The server is suddenly deciding to serve more responses than we've
* seen before.
*
* Let our requests go.
*/
if (conn->probable_keepalive_limit &&
conn->completed_responses >= conn->probable_keepalive_limit) {
conn->probable_keepalive_limit = 0;
}
/* If we just ran out of requests or have unwritten requests, then
* update the pollset. We don't want to read from this socket any
* more. We are definitely done with this loop, too.
*/
if (request == NULL || request->writing == SERF_WRITING_NONE) {
serf_io__set_pollset_dirty(&conn->io);
status = APR_SUCCESS;
goto error;
}
}
error:
/* ### This code handles some specific errors as a retry.
Eventually we should move to a handling where the application
can tell us if this is really a good idea for specific requests */
if (status == SERF_ERROR_SSL_NEGOTIATE_IN_PROGRESS) {
/* This connection uses HTTP pipelining and the server asked for a
renegotiation (e.g. to access the requested resource a specific
client certificate is required).
Because of a known problem in OpenSSL this won't work most of the
time, so as a workaround, when the server asks for a renegotiation
on a connection using HTTP pipelining, we reset the connection,
disable pipelining and reconnect to the server. */
serf__log(LOGLVL_WARNING, LOGCOMP_CONN, __FILE__, conn->config,
"The server requested renegotiation. Disable HTTP "
"pipelining and reset the connection 0x%p.\n", conn);
serf__connection_set_pipelining(conn, 0);
reset_connection(conn, 1);
status = APR_SUCCESS;
}
else if (status == SERF_ERROR_REQUEST_LOST
|| APR_STATUS_IS_ECONNRESET(status)
|| APR_STATUS_IS_ECONNABORTED(status)) {
/* Some systems will not generate a HUP poll event for these errors
so we handle the ECONNRESET issue and ECONNABORT here. */
/* If the connection was ever good, be optimistic & try again.
If it has never tried again (incl. a retry), fail. */
if (conn->completed_responses) {
reset_connection(conn, 1);
status = APR_SUCCESS;
}
else if (status == SERF_ERROR_REQUEST_LOST) {
status = SERF_ERROR_ABORTED_CONNECTION;
}
}
apr_pool_destroy(tmppool);
return status;
}