/* ====================================================================

 *    Licensed to the Apache Software Foundation (ASF) under one

 *    or more contributor license agreements.  See the NOTICE file

 *    distributed with this work for additional information

 *    regarding copyright ownership.  The ASF licenses this file

 *    to you under the Apache License, Version 2.0 (the

 *    "License"); you may not use this file except in compliance

 *    with the License.  You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 *    Unless required by applicable law or agreed to in writing,

 *    software distributed under the License is distributed on an

 *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

 *    KIND, either express or implied.  See the License for the

 *    specific language governing permissions and limitations

 *    under the License.

 * ====================================================================

 */

#include <apr_pools.h>

#include <apr_poll.h>

#include <apr_version.h>

#include <apr_portable.h>

#include "serf.h"

#include "serf_bucket_util.h"

#include "serf_private.h"

/* cleanup for sockets */

static apr_status_t clean_skt(void *data)

{

    serf_connection_t *conn = data;

    apr_status_t status = APR_SUCCESS;

    if (conn->skt) {

        serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt, "cleanup - ");

        status = apr_socket_close(conn->skt);

        conn->skt = NULL;

        serf__log_nopref(SOCK_VERBOSE, "closed socket, status %d\n", status);

    }

    return status;

}

static apr_status_t clean_resp(void *data)

{

    serf_request_t *request = data;

    /* The request's RESPOOL is being cleared.  */

    /* If the response has allocated some buckets, then destroy them (since

       the bucket may hold resources other than memory in RESPOOL). Also

       make sure to set their fields to NULL so connection closure does

       not attempt to free them again.  */

    if (request->resp_bkt) {

        serf_bucket_destroy(request->resp_bkt);

        request->resp_bkt = NULL;

    }

    if (request->req_bkt) {

        serf_bucket_destroy(request->req_bkt);

        request->req_bkt = NULL;

    }

    /* ### should we worry about debug stuff, like that performed in

       ### destroy_request()? should we worry about calling req->handler

       ### to notify this "cancellation" due to pool clearing?  */

    /* This pool just got cleared/destroyed. Don't try to destroy the pool

       (again) when the request is canceled.  */

    request->respool = NULL;

    return APR_SUCCESS;

}

/* cleanup for conns */

static apr_status_t clean_conn(void *data)

{

    serf_connection_t *conn = data;

    serf__log(CONN_VERBOSE, __FILE__, "cleaning up connection 0x%x\n",

              conn);

    serf_connection_close(conn);

    return APR_SUCCESS;

}

/* Check if there is data waiting to be sent over the socket. This can happen

   in two situations:

   - The connection queue has atleast one request with unwritten data.

   - All requests are written and the ssl layer wrote some data while reading

     the response. This can happen when the server triggers a renegotiation,

     e.g. after the first and only request on that connection was received.

   Returns 1 if data is pending on CONN, NULL if not.

   If NEXT_REQ is not NULL, it will be filled in with the next available request

   with unwritten data. */

static int

request_or_data_pending(serf_request_t **next_req, serf_connection_t *conn)

{

    serf_request_t *request = conn->requests;

    while (request != NULL && request->req_bkt == NULL &&

           request->writing_started)

        request = request->next;

    if (next_req)

        *next_req = request;

    if (request != NULL) {

        return 1;

    } else if (conn->ostream_head) {

        const char *dummy;

        apr_size_t len;

        apr_status_t status;

        status = serf_bucket_peek(conn->ostream_head, &dummy,

                                  &len;;

        if (!SERF_BUCKET_READ_ERROR(status) && len) {

            serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,

                          "All requests written but still data pending.\n");

            return 1;

        }

    }

    return 0;

}

/* Update the pollset for this connection. We tweak the pollset based on

 * whether we want to read and/or write, given conditions within the

 * connection. If the connection is not (yet) in the pollset, then it

 * will be added.

 */

apr_status_t serf__conn_update_pollset(serf_connection_t *conn)

{

    serf_context_t *ctx = conn->ctx;

    apr_status_t status;

    apr_pollfd_t desc = { 0 };

    if (!conn->skt) {

        return APR_SUCCESS;

    }

    /* Remove the socket from the poll set. */

    desc.desc_type = APR_POLL_SOCKET;

    desc.desc.s = conn->skt;

    desc.reqevents = conn->reqevents;

    status = ctx->pollset_rm(ctx->pollset_baton,

                             &desc, &conn->baton);

    if (status && !APR_STATUS_IS_NOTFOUND(status))

        return status;

    /* Now put it back in with the correct read/write values. */

    desc.reqevents = APR_POLLHUP | APR_POLLERR;

    if (conn->requests &&

        conn->state != SERF_CONN_INIT) {

        /* If there are any outstanding events, then we want to read. */

        /* ### not true. we only want to read IF we have sent some data */

        desc.reqevents |= APR_POLLIN;

        /* Don't write if OpenSSL told us that it needs to read data first. */

        if (conn->stop_writing != 1) {

            /* If the connection is not closing down and

             *   has unwritten data or

             *   there are any requests that still have buckets to write out,

             *     then we want to write.

             */

            if (conn->vec_len &&

                conn->state != SERF_CONN_CLOSING)

                desc.reqevents |= APR_POLLOUT;

            else {

                if ((conn->probable_keepalive_limit &&

                     conn->completed_requests > conn->probable_keepalive_limit) ||

                    (conn->max_outstanding_requests &&

                     conn->completed_requests - conn->completed_responses >=

                     conn->max_outstanding_requests)) {

                        /* we wouldn't try to write any way right now. */

                }

                else if (request_or_data_pending(NULL, conn)) {

                    desc.reqevents |= APR_POLLOUT;

                }

            }

        }

    }

    /* If we can have async responses, always look for something to read. */

    if (conn->async_responses) {

        desc.reqevents |= APR_POLLIN;

    }

    /* save our reqevents, so we can pass it in to remove later. */

    conn->reqevents = desc.reqevents;

    /* Note: even if we don't want to read/write this socket, we still

     * want to poll it for hangups and errors.

     */

    return ctx->pollset_add(ctx->pollset_baton,

                            &desc, &conn->baton);

}

#ifdef SERF_DEBUG_BUCKET_USE

/* Make sure all response buckets were drained. */

static void check_buckets_drained(serf_connection_t *conn)

{

    serf_request_t *request = conn->requests;

    for ( ; request ; request = request->next ) {

        if (request->resp_bkt != NULL) {

            /* ### crap. can't do this. this allocator may have un-drained

             * ### REQUEST buckets.

             */

            /* serf_debug__entered_loop(request->resp_bkt->allocator); */

            /* ### for now, pretend we closed the conn (resets the tracking) */

            serf_debug__closed_conn(request->resp_bkt->allocator);

        }

    }

}

#endif

static void destroy_ostream(serf_connection_t *conn)

{

    if (conn->ostream_head != NULL) {

        serf_bucket_destroy(conn->ostream_head);

        conn->ostream_head = NULL;

        conn->ostream_tail = NULL;

    }

}

static apr_status_t detect_eof(void *baton, serf_bucket_t *aggregate_bucket)

{

    serf_connection_t *conn = baton;

    conn->hit_eof = 1;

    return APR_EAGAIN;

}

static apr_status_t do_conn_setup(serf_connection_t *conn)

{

    apr_status_t status;

    serf_bucket_t *ostream;

    if (conn->ostream_head == NULL) {

        conn->ostream_head = serf_bucket_aggregate_create(conn->allocator);

    }

    if (conn->ostream_tail == NULL) {

        conn->ostream_tail = serf__bucket_stream_create(conn->allocator,

                                                        detect_eof,

                                                        conn);

    }

    ostream = conn->ostream_tail;

    status = (*conn->setup)(conn->skt,

                            &conn->stream,

                            &ostream,

                            conn->setup_baton,

                            conn->pool);

    if (status) {

        /* extra destroy here since it wasn't added to the head bucket yet. */

        serf_bucket_destroy(conn->ostream_tail);

        destroy_ostream(conn);

        return status;

    }

    serf_bucket_aggregate_append(conn->ostream_head,

                                 ostream);

    return status;

}

/* Set up the input and output stream buckets.

 When a tunnel over an http proxy is needed, create a socket bucket and

 empty aggregate bucket for sending and receiving unencrypted requests

 over the socket.

 After the tunnel is there, or no tunnel was needed, ask the application

 to create the input and output buckets, which should take care of the

 [en/de]cryption.

 */

static apr_status_t prepare_conn_streams(serf_connection_t *conn,

                                         serf_bucket_t **istream,

                                         serf_bucket_t **ostreamt,

                                         serf_bucket_t **ostreamh)

{

    apr_status_t status;

    if (conn->stream == NULL) {

        conn->latency = apr_time_now() - conn->connect_time;

    }

    /* Do we need a SSL tunnel first? */

    if (conn->state == SERF_CONN_CONNECTED) {

        /* If the connection does not have an associated bucket, then

         * call the setup callback to get one.

         */

        if (conn->stream == NULL) {

            status = do_conn_setup(conn);

            if (status) {

                return status;

            }

        }

        *ostreamt = conn->ostream_tail;

        *ostreamh = conn->ostream_head;

        *istream = conn->stream;

    } else {

        /* SSL tunnel needed and not set up yet, get a direct unencrypted

         stream for this socket */

        if (conn->stream == NULL) {

            *istream = serf_bucket_socket_create(conn->skt,

                                                 conn->allocator);

        }

        /* Don't create the ostream bucket chain including the ssl_encrypt

         bucket yet. This ensure the CONNECT request is sent unencrypted

         to the proxy. */

        *ostreamt = *ostreamh = conn->ssltunnel_ostream;

    }

    return APR_SUCCESS;

}

/* Create and connect sockets for any connections which don't have them

 * yet. This is the core of our lazy-connect behavior.

 */

apr_status_t serf__open_connections(serf_context_t *ctx)

{

    int i;

    for (i = ctx->conns->nelts; i--; ) {

        serf_connection_t *conn = GET_CONN(ctx, i);

        serf__authn_info_t *authn_info;

        apr_status_t status;

        apr_socket_t *skt;

        conn->seen_in_pollset = 0;

        if (conn->skt != NULL) {

#ifdef SERF_DEBUG_BUCKET_USE

            check_buckets_drained(conn);

#endif

            continue;

        }

        /* Delay opening until we have something to deliver! */

        if (conn->requests == NULL) {

            continue;

        }

        apr_pool_clear(conn->skt_pool);

        apr_pool_cleanup_register(conn->skt_pool, conn, clean_skt, clean_skt);

        status = apr_socket_create(&skt, conn->address->family,

                                   SOCK_STREAM,

#if APR_MAJOR_VERSION > 0

                                   APR_PROTO_TCP,

#endif

                                   conn->skt_pool);

        serf__log(SOCK_VERBOSE, __FILE__,

                  "created socket for conn 0x%x, status %d\n", conn, status);

        if (status != APR_SUCCESS)

            return status;

        /* Set the socket to be non-blocking */

        if ((status = apr_socket_timeout_set(skt, 0)) != APR_SUCCESS)

            return status;

        /* Disable Nagle's algorithm */

        if ((status = apr_socket_opt_set(skt,

                                         APR_TCP_NODELAY, 1)) != APR_SUCCESS)

            return status;

        /* Configured. Store it into the connection now. */

        conn->skt = skt;

        /* Remember time when we started connecting to server to calculate

           network latency. */

        conn->connect_time = apr_time_now();

        /* Now that the socket is set up, let's connect it. This should

         * return immediately.

         */

        status = apr_socket_connect(skt, conn->address);

        serf__log_skt(SOCK_VERBOSE, __FILE__, skt,

                      "connected socket for conn 0x%x, status %d\n",

                      conn, status);

        if (status != APR_SUCCESS) {

            if (!APR_STATUS_IS_EINPROGRESS(status))

                return status;

        }

        /* Flag our pollset as dirty now that we have a new socket. */

        conn->dirty_conn = 1;

        ctx->dirty_pollset = 1;

        /* If the authentication was already started on another connection,

           prepare this connection (it might be possible to skip some

           part of the handshaking). */

        if (ctx->proxy_address) {

            authn_info = &ctx->proxy_authn_info;

            if (authn_info->scheme) {

                authn_info->scheme->init_conn_func(authn_info->scheme, 407,

                                                   conn, conn->pool);

            }

        }

        authn_info = serf__get_authn_info_for_server(conn);

        if (authn_info->scheme) {

            authn_info->scheme->init_conn_func(authn_info->scheme, 401,

                                               conn, conn->pool);

        }

        /* Does this connection require a SSL tunnel over the proxy? */

        if (ctx->proxy_address && strcmp(conn->host_info.scheme, "https") == 0)

            serf__ssltunnel_connect(conn);

        else {

            serf_bucket_t *dummy1, *dummy2;

            conn->state = SERF_CONN_CONNECTED;

            status = prepare_conn_streams(conn, &conn->stream,

                                          &dummy1, &dummy2);

            if (status) {

                return status;

            }

        }

    }

    return APR_SUCCESS;

}

static apr_status_t no_more_writes(serf_connection_t *conn)

{

    /* Note that we should hold new requests until we open our new socket. */

    conn->state = SERF_CONN_CLOSING;

    serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,

                  "stop writing on conn 0x%x\n", conn);

    /* Clear our iovec. */

    conn->vec_len = 0;

    /* Update the pollset to know we don't want to write on this socket any

     * more.

     */

    conn->dirty_conn = 1;

    conn->ctx->dirty_pollset = 1;

    return APR_SUCCESS;

}

/* Read the 'Connection' header from the response. Return SERF_ERROR_CLOSING if

 * the header contains value 'close' indicating the server is closing the

 * connection right after this response.

 * Otherwise returns APR_SUCCESS.

 */

static apr_status_t is_conn_closing(serf_bucket_t *response)

{

    serf_bucket_t *hdrs;

    const char *val;

    hdrs = serf_bucket_response_get_headers(response);

    val = serf_bucket_headers_get(hdrs, "Connection");

    if (val && strcasecmp("close", val) == 0)

        {

            return SERF_ERROR_CLOSING;

        }

    return APR_SUCCESS;

}

static void link_requests(serf_request_t **list, serf_request_t **tail,

                          serf_request_t *request)

{

    if (*list == NULL) {

        *list = request;

        *tail = request;

    }

    else {

        (*tail)->next = request;

        *tail = request;

    }

}

static apr_status_t destroy_request(serf_request_t *request)

{

    serf_connection_t *conn = request->conn;

    /* The request and response buckets are no longer needed,

       nor is the request's pool.  */

    if (request->resp_bkt) {

        serf_debug__closed_conn(request->resp_bkt->allocator);

        serf_bucket_destroy(request->resp_bkt);

        request->resp_bkt = NULL;

    }

    if (request->req_bkt) {

        serf_debug__closed_conn(request->req_bkt->allocator);

        serf_bucket_destroy(request->req_bkt);

        request->req_bkt = NULL;

    }

    serf_debug__bucket_alloc_check(request->allocator);

    if (request->respool) {

        /* ### unregister the pool cleanup for self?  */

        apr_pool_destroy(request->respool);

    }

    serf_bucket_mem_free(conn->allocator, request);

    return APR_SUCCESS;

}

static apr_status_t cancel_request(serf_request_t *request,

                                   serf_request_t **list,

                                   int notify_request)

{

    /* If we haven't run setup, then we won't have a handler to call. */

    if (request->handler && notify_request) {

        /* We actually don't care what the handler returns.

         * We have bigger matters at hand.

         */

        (*request->handler)(request, NULL, request->handler_baton,

                            request->respool);

    }

    if (*list == request) {

        *list = request->next;

    }

    else {

        serf_request_t *scan = *list;

        while (scan->next && scan->next != request)

            scan = scan->next;

        if (scan->next) {

            scan->next = scan->next->next;

        }

    }

    return destroy_request(request);

}

static apr_status_t remove_connection(serf_context_t *ctx,

                                      serf_connection_t *conn)

{

    apr_pollfd_t desc = { 0 };

    desc.desc_type = APR_POLL_SOCKET;

    desc.desc.s = conn->skt;

    desc.reqevents = conn->reqevents;

    return ctx->pollset_rm(ctx->pollset_baton,

                           &desc, &conn->baton);

}

/* A socket was closed, inform the application. */

static void handle_conn_closed(serf_connection_t *conn, apr_status_t status)

{

    (*conn->closed)(conn, conn->closed_baton, status,

                    conn->pool);

}

static apr_status_t reset_connection(serf_connection_t *conn,

                                     int requeue_requests)

{

    serf_context_t *ctx = conn->ctx;

    apr_status_t status;

    serf_request_t *old_reqs;

    conn->probable_keepalive_limit = conn->completed_responses;

    conn->completed_requests = 0;

    conn->completed_responses = 0;

    old_reqs = conn->requests;

    conn->requests = NULL;

    conn->requests_tail = NULL;

    /* Handle all outstanding requests. These have either not been written yet,

       or have been written but the expected reply wasn't received yet. */

    while (old_reqs) {

        /* If we haven't started to write the connection, bring it over

         * unchanged to our new socket.

         * Do not copy a CONNECT request to the new connection, the ssl tunnel

         * setup code will create a new CONNECT request already.

         */

        if (requeue_requests && !old_reqs->writing_started &&

            !old_reqs->ssltunnel) {

            serf_request_t *req = old_reqs;

            old_reqs = old_reqs->next;

            req->next = NULL;

            link_requests(&conn->requests, &conn->requests_tail, req);

        }

        else {

            /* Request has been consumed, or we don't want to requeue the

               request. Either way, inform the application that the request

               is cancelled. */

            cancel_request(old_reqs, &old_reqs, requeue_requests);

        }

    }

    /* Requests queue has been prepared for a new socket, close the old one. */

    if (conn->skt != NULL) {

        remove_connection(ctx, conn);

        status = apr_socket_close(conn->skt);

        serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,

                      "closed socket, status %d\n", status);

        if (conn->closed != NULL) {

            handle_conn_closed(conn, status);

        }

        conn->skt = NULL;

    }

    if (conn->stream != NULL) {

        serf_bucket_destroy(conn->stream);

        conn->stream = NULL;

    }

    destroy_ostream(conn);

    /* Don't try to resume any writes */

    conn->vec_len = 0;

    conn->dirty_conn = 1;

    conn->ctx->dirty_pollset = 1;

    conn->state = SERF_CONN_INIT;

    conn->hit_eof = 0;

    conn->connect_time = 0;

    conn->latency = -1;

    conn->stop_writing = 0;

    serf__log(CONN_VERBOSE, __FILE__, "reset connection 0x%x\n", conn);

    conn->status = APR_SUCCESS;

    /* Let our context know that we've 'reset' the socket already. */

    conn->seen_in_pollset |= APR_POLLHUP;

    /* Found the connection. Closed it. All done. */

    return APR_SUCCESS;

}

static apr_status_t socket_writev(serf_connection_t *conn)

{

    apr_size_t written;

    apr_status_t status;

    status = apr_socket_sendv(conn->skt, conn->vec,

                              conn->vec_len, &written);

    if (status && !APR_STATUS_IS_EAGAIN(status))

        serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,

                      "socket_sendv error %d\n", status);

    /* did we write everything? */

    if (written) {

        apr_size_t len = 0;

        int i;

        serf__log_skt(SOCK_MSG_VERBOSE, __FILE__, conn->skt,

                      "--- socket_sendv:\n");

        for (i = 0; i < conn->vec_len; i++) {

            len += conn->vec[i].iov_len;

            if (written < len) {

                serf__log_nopref(SOCK_MSG_VERBOSE, "%.*s",

                                   conn->vec[i].iov_len - (len - written),

                                   conn->vec[i].iov_base);

                if (i) {

                    memmove(conn->vec, &conn->vec[i],

                            sizeof(struct iovec) * (conn->vec_len - i));

                    conn->vec_len -= i;

                }

                conn->vec[0].iov_base = (char *)conn->vec[0].iov_base + (conn->vec[0].iov_len - (len - written));

                conn->vec[0].iov_len = len - written;

                break;

            } else {

                serf__log_nopref(SOCK_MSG_VERBOSE, "%.*s",

                                   conn->vec[i].iov_len, conn->vec[i].iov_base);

            }

        }

        if (len == written) {

            conn->vec_len = 0;

        }

        serf__log_nopref(SOCK_MSG_VERBOSE, "-(%d)-\n", written);

        /* Log progress information */

        serf__context_progress_delta(conn->ctx, 0, written);

    }

    return status;

}

static apr_status_t setup_request(serf_request_t *request)

{

    serf_connection_t *conn = request->conn;

    apr_status_t status;

    /* Now that we are about to serve the request, allocate a pool. */

    apr_pool_create(&request->respool, conn->pool);

    request->allocator = serf_bucket_allocator_create(request->respool,

                                                      NULL, NULL);

    apr_pool_cleanup_register(request->respool, request,

                              clean_resp, clean_resp);

    /* Fill in the rest of the values for the request. */

    status = request->setup(request, request->setup_baton,

                            &request->req_bkt,

                            &request->acceptor,

                            &request->acceptor_baton,

                            &request->handler,

                            &request->handler_baton,

                            request->respool);

    return status;

}

/* write data out to the connection */

static apr_status_t write_to_connection(serf_connection_t *conn)

{

    if (conn->probable_keepalive_limit &&

        conn->completed_requests > conn->probable_keepalive_limit) {

        conn->dirty_conn = 1;

        conn->ctx->dirty_pollset = 1;

        /* backoff for now. */

        return APR_SUCCESS;

    }

    /* Keep reading and sending until we run out of stuff to read, or

     * writing would block.

     */

    while (1) {

        serf_request_t *request;

        int stop_reading = 0;

        apr_status_t status;

        apr_status_t read_status;

        serf_bucket_t *ostreamt;

        serf_bucket_t *ostreamh;

        int max_outstanding_requests = conn->max_outstanding_requests;

        /* If we're setting up an ssl tunnel, we can't send real requests

           at yet, as they need to be encrypted and our encrypt buckets

           aren't created yet as we still need to read the unencrypted

           response of the CONNECT request. */

        if (conn->state != SERF_CONN_CONNECTED)

            max_outstanding_requests = 1;

        if (max_outstanding_requests &&

            conn->completed_requests -

                conn->completed_responses >= max_outstanding_requests) {

            /* backoff for now. */

            return APR_SUCCESS;

        }

        /* If we have unwritten data, then write what we can. */

        while (conn->vec_len) {

            status = socket_writev(conn);

            /* If the write would have blocked, then we're done. Don't try

             * to write anything else to the socket.

             */

            if (APR_STATUS_IS_EAGAIN(status))

                return APR_SUCCESS;

            if (APR_STATUS_IS_EPIPE(status) ||

                APR_STATUS_IS_ECONNRESET(status) ||

                APR_STATUS_IS_ECONNABORTED(status))

                return no_more_writes(conn);

            if (status)

                return status;

        }

        /* ### can we have a short write, yet no EAGAIN? a short write

           ### would imply unwritten_len > 0 ... */

        /* assert: unwritten_len == 0. */

        /* We may need to move forward to a request which has something

         * to write.

         */

        if (!request_or_data_pending(&request, conn)) {

            /* No more requests (with data) are registered with the

             * connection, and no data is pending on the outgoing stream.

             * Let's update the pollset so that we don't try to write to this

             * socket again.

             */

            conn->dirty_conn = 1;

            conn->ctx->dirty_pollset = 1;

            return APR_SUCCESS;

        }

        status = prepare_conn_streams(conn, &conn->stream, &ostreamt, &ostreamh);

        if (status) {

            return status;

        }

        if (request) {

            if (request->req_bkt == NULL) {

                read_status = setup_request(request);

                if (read_status) {

                    /* Something bad happened. Propagate any errors. */

                    return read_status;

                }

            }

            if (!request->writing_started) {

                request->writing_started = 1;

                serf_bucket_aggregate_append(ostreamt, request->req_bkt);

            }

        }

        /* ### optimize at some point by using read_for_sendfile */

        /* TODO: now that read_iovec will effectively try to return as much

           data as available, we probably don't want to read ALL_AVAIL, but

           a lower number, like the size of one or a few TCP packets, the

           available TCP buffer size ... */

        read_status = serf_bucket_read_iovec(ostreamh,

                                             SERF_READ_ALL_AVAIL,

                                             IOV_MAX,

                                             conn->vec,

                                             &conn->vec_len);

        if (!conn->hit_eof) {

            if (APR_STATUS_IS_EAGAIN(read_status)) {

                /* We read some stuff, but should not try to read again. */

                stop_reading = 1;

            }

            else if (read_status == SERF_ERROR_WAIT_CONN) {

                /* The bucket told us that it can't provide more data until

                   more data is read from the socket. This normally happens

                   during a SSL handshake.

                   We should avoid looking for writability for a while so

                   that (hopefully) something will appear in the bucket so

                   we can actually write something. otherwise, we could

                   end up in a CPU spin: socket wants something, but we

                   don't have anything (and keep returning EAGAIN)

                 */

                conn->stop_writing = 1;

                conn->dirty_conn = 1;

                conn->ctx->dirty_pollset = 1;

            }

            else if (read_status && !APR_STATUS_IS_EOF(read_status)) {

                /* Something bad happened. Propagate any errors. */

                return read_status;

            }

        }

        /* If we got some data, then deliver it. */

        /* ### what to do if we got no data?? is that a problem? */

        if (conn->vec_len > 0) {

            status = socket_writev(conn);

            /* If we can't write any more, or an error occurred, then

             * we're done here.

             */

            if (APR_STATUS_IS_EAGAIN(status))

                return APR_SUCCESS;

            if (APR_STATUS_IS_EPIPE(status))

                return no_more_writes(conn);

            if (APR_STATUS_IS_ECONNRESET(status) ||

                APR_STATUS_IS_ECONNABORTED(status)) {

                return no_more_writes(conn);

            }

            if (status)

                return status;

        }

        if (read_status == SERF_ERROR_WAIT_CONN) {

            stop_reading = 1;

            conn->stop_writing = 1;

            conn->dirty_conn = 1;

            conn->ctx->dirty_pollset = 1;

        }

        else if (request && read_status && conn->hit_eof &&

                 conn->vec_len == 0) {

            /* If we hit the end of the request bucket and all of its data has

             * been written, then clear it out to signify that we're done

             * sending the request. On the next iteration through this loop: