serf-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rhuij...@apache.org
Subject svn commit: r1709415 - in /serf/trunk: connection_request.c outgoing.c serf_private.h
Date Mon, 19 Oct 2015 14:00:40 GMT
Author: rhuijben
Date: Mon Oct 19 14:00:40 2015
New Revision: 1709415

URL: http://svn.apache.org/viewvc?rev=1709415&view=rev
Log:
Extract the request specific functions from outgoing.c to a separate
C file. This adds a tiny bit of abstraction towards separate protocols.

This patch should have no behaviour changes, but changes function names
of several functions.

* connection_request.c
  New file, copied from outgoing.c
  (clean_resp,
   serf__link_requests,
   serf__destroy_request,
   serf__cancel_request,
   serf__req_list_length,
   serf__setup_request,
   serf__handle_response,
   serf__provide_credentials,
   create_request,
   serf_connection_request_create,
   priority_request_create,
   serf__ssltunnel_request_create,
   serf__request_requeue,
   serf_request_cancel,
   serf_request_is_written,
   serf_request_get_pool,
   serf_request_get_alloc,
   serf_request_get_conn,
   serf_request_set_handler,
   serf_request_bucket_request_create): Moved here. Changed into internal API
     where necessary.

* outgoing.c
  (clean_resp,
   link_requests,
   destroy_request,
   cancel_request,
   req_list_length): Removed here.
  (reset_connection): Update caller.
  (setup_request): Removed here.
  (write_to_connection): Update caller.
  (handle_response,
   serf__provide_credentials): Removed here.
  (read_from_connection,
   serf_connection_close): Update caller.

  (serf_connection_request_create,
   priority_request_create,
   serf_connection_priority_request_create,
   serf__ssltunnel_request_create,
   serf__request_requeue,
   serf_request_cancel,
   serf_request_is_written,
   serf_request_get_pool,
   serf_request_get_alloc,
   serf_request_get_conn,
   serf_request_set_handler,
   serf_request_bucket_request_create): Remove here.

* serf_private.h
  (void serf__link_requests,
   serf__destroy_request,
   serf__cancel_request,
   serf__req_list_length,
   serf__setup_request,
   serf__link_requests): New functions.

Added:
    serf/trunk/connection_request.c
      - copied, changed from r1709385, serf/trunk/outgoing.c
Modified:
    serf/trunk/outgoing.c
    serf/trunk/serf_private.h

Copied: serf/trunk/connection_request.c (from r1709385, serf/trunk/outgoing.c)
URL: http://svn.apache.org/viewvc/serf/trunk/connection_request.c?p2=serf/trunk/connection_request.c&p1=serf/trunk/outgoing.c&r1=1709385&r2=1709415&rev=1709415&view=diff
==============================================================================
--- serf/trunk/outgoing.c (original)
+++ serf/trunk/connection_request.c Mon Oct 19 14:00:40 2015
@@ -29,29 +29,6 @@
 
 #include "serf_private.h"
 
-/* forward definitions */
-static apr_status_t read_from_connection(serf_connection_t *conn);
-static apr_status_t write_to_connection(serf_connection_t *conn);
-static apr_status_t hangup_connection(serf_connection_t *conn);
-
-/* 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) {
-        status = apr_socket_close(conn->skt);
-        conn->skt = NULL;
-        serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                  "closed socket, status %d\n", status);
-        serf_config_remove_value(conn->config, SERF_CONFIG_CONN_LOCALIP);
-        serf_config_remove_value(conn->config, SERF_CONFIG_CONN_REMOTEIP);
-    }
-
-    return status;
-}
-
 static apr_status_t clean_resp(void *data)
 {
     serf_request_t *request = data;
@@ -82,468 +59,8 @@ static apr_status_t clean_resp(void *dat
     return APR_SUCCESS;
 }
 
-/* cleanup for conns */
-static apr_status_t clean_conn(void *data)
-{
-    serf_connection_t *conn = data;
-
-    serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-              "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)
-{
-    int reqs_in_progress;
-
-    reqs_in_progress = conn->completed_requests - conn->completed_responses;
-
-    /* Prepare the next request */
-    if (conn->framing_type != SERF_CONNECTION_FRAMING_TYPE_NONE
-        && (conn->pipelining || (!conn->pipelining && reqs_in_progress == 0)))
-    {
-        /* Skip all requests that have been written completely but we're still
-         waiting for a response. */
-        serf_request_t *request = conn->unwritten_reqs;
-
-        if (next_req)
-            *next_req = request;
-
-        if (request != NULL) {
-            return 1;
-        }
-    }
-
-    if (next_req)
-        *next_req = NULL;
-
-    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(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                      "Extra data to be written after sending complete requests.\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->written_reqs || conn->unwritten_reqs) &&
-        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) {
-
-            /* 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->framing_type != SERF_CONNECTION_FRAMING_TYPE_HTTP1
-        || 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;
-
-    /* ### dunno what the hell this is about. this latency stuff got
-       ### added, and who knows whether it should stay...  */
-    conn->latency = apr_time_now() - conn->connect_time;
-
-    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;
-    }
-
-    /* Share the configuration with all the buckets in the newly created output
-     chain (see PLAIN or ENCRYPTED scenario's), including the request buckets
-     created by the application (ostream_tail will handle this for us). */
-    serf_bucket_set_config(conn->ostream_head, conn->config);
-
-    /* Share the configuration with the ssl_decrypt and socket buckets. The
-     response buckets wrapping the ssl_decrypt/socket buckets won't get the
-     config automatically because they are upstream. */
-    serf_bucket_set_config(conn->stream, conn->config);
-
-    serf_bucket_aggregate_append(conn->ostream_head,
-                                 ostream);
-
-    /* We typically have one of two scenarios, based on whether the
-       application decided to encrypt this connection:
-
-       PLAIN:
-
-         conn->stream = SOCKET(skt)
-         conn->ostream_head = AGGREGATE(ostream_tail)
-         conn->ostream_tail = STREAM(<detect_eof>, REQ1, REQ2, ...)
-
-       ENCRYPTED:
-
-         conn->stream = DECRYPT(SOCKET(skt))
-         conn->ostream_head = AGGREGATE(ENCRYPT(ostream_tail))
-         conn->ostream_tail = STREAM(<detect_eof>, REQ1, REQ2, ...)
-
-       where STREAM is an internal variant of AGGREGATE.
-    */
-
-    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 **ostreamt,
-                                         serf_bucket_t **ostreamh)
-{
-    apr_status_t status;
-
-    /* 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;
-    } else {
-        /* state == SERF_CONN_SETUP_SSLTUNNEL  */
-
-        /* SSL tunnel needed and not set up yet, get a direct unencrypted
-         stream for this socket */
-        if (conn->stream == NULL) {
-            conn->stream = serf_context_bucket_socket_create(conn->ctx,
-                                                             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;
-}
-
-static void store_ipaddresses_in_config(serf_config_t *config,
-                                        apr_socket_t *skt)
-{
-     apr_sockaddr_t *sa;
-
-    if (apr_socket_addr_get(&sa, APR_LOCAL, skt) == APR_SUCCESS) {
-        char buf[32];
-        apr_sockaddr_ip_getbuf(buf, 32, sa);
-        serf_config_set_stringf(config, SERF_CONFIG_CONN_LOCALIP,
-                                "%s:%d", buf, sa->port);
-    }
-    if (apr_socket_addr_get(&sa, APR_REMOTE, skt) == APR_SUCCESS) {
-        char buf[32];
-        apr_sockaddr_ip_getbuf(buf, 32, sa);
-        serf_config_set_stringf(config, SERF_CONFIG_CONN_REMOTEIP,
-                               "%s:%d", buf, sa->port);
-    }
-}
-
-/* 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);
-        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->unwritten_reqs == NULL) {
-            continue;
-        }
-
-        apr_pool_clear(conn->skt_pool);
-        apr_pool_cleanup_register(conn->skt_pool, conn, clean_skt,
-                                  apr_pool_cleanup_null);
-
-        status = apr_socket_create(&skt, conn->address->family,
-                                   SOCK_STREAM,
-#if APR_MAJOR_VERSION > 0
-                                   APR_PROTO_TCP,
-#endif
-                                   conn->skt_pool);
-        serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                  "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);
-        store_ipaddresses_in_config(conn->config, skt);
-
-        serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                  "connected socket for conn 0x%x, status %d\n", conn, status);
-        if (status != APR_SUCCESS) {
-            if (!APR_STATUS_IS_EINPROGRESS(status))
-                return status;
-        }
-
-        status = serf_config_set_string(conn->config,
-                     SERF_CONFIG_CONN_PIPELINING,
-                     (conn->max_outstanding_requests != 1 &&
-                      conn->pipelining == 1) ? "Y" : "N");
-        if (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) {
-            status = serf__auth_setup_connection(PROXY, conn);
-            if (status){
-                return status;
-            }
-        }
-
-        status = serf__auth_setup_connection(HOST, conn);
-        if (status)
-            return status;
-
-        /* 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 {
-            conn->state = SERF_CONN_CONNECTED;
-            status = do_conn_setup(conn);
-            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(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-              "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)
+void serf__link_requests(serf_request_t **list, serf_request_t **tail,
+                         serf_request_t *request)
 {
     if (*list == NULL) {
         *list = request;
@@ -555,7 +72,7 @@ static void link_requests(serf_request_t
     }
 }
 
-static apr_status_t destroy_request(serf_request_t *request)
+apr_status_t serf__destroy_request(serf_request_t *request)
 {
     serf_connection_t *conn = request->conn;
 
@@ -584,9 +101,9 @@ static apr_status_t destroy_request(serf
     return APR_SUCCESS;
 }
 
-static apr_status_t cancel_request(serf_request_t *request,
-                                   serf_request_t **list,
-                                   int notify_request)
+apr_status_t serf__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) {
@@ -611,11 +128,11 @@ static apr_status_t cancel_request(serf_
         }
     }
 
-    return destroy_request(request);
+    return serf__destroy_request(request);
 }
 
 /* Calculate the length of a linked list of requests. */
-static unsigned int req_list_length(serf_request_t *req)
+unsigned int serf__req_list_length(serf_request_t *req)
 {
     unsigned int length = 0;
 
@@ -627,205 +144,7 @@ static unsigned int req_list_length(serf
     return length;
 }
 
-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;
-
-    serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-              "reset connection 0x%x\n", conn);
-
-    conn->probable_keepalive_limit = conn->completed_responses;
-    conn->completed_requests = 0;
-    conn->completed_responses = 0;
-
-    /* Clear the unwritten_reqs queue, so the application can requeue cancelled
-       requests on it for the new socket. */
-    old_reqs = conn->unwritten_reqs;
-    conn->unwritten_reqs = NULL;
-    conn->unwritten_reqs_tail = NULL;
-
-    /* First, cancel all written requests for which we haven't received a 
-       response yet. Inform the application that the request is cancelled, 
-       so it can requeue them if needed. */
-    while (conn->written_reqs) {
-        cancel_request(conn->written_reqs, &conn->written_reqs,
-                       requeue_requests);
-    }
-    conn->written_reqs_tail = NULL;
-
-    /* Handle all outstanding unwritten requests.
-       TODO: what about a partially written request? */
-    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->unwritten_reqs, &conn->unwritten_reqs_tail,
-                          req);
-        }
-        else {
-            /* We don't want to requeue the request or this request was partially
-               written. 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 = clean_skt(conn);
-        if (conn->closed != NULL) {
-            handle_conn_closed(conn, status);
-        }
-    }
-
-    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;
-    conn->write_now = 0;
-    /* conn->pipelining */
-
-    conn->framing_type = SERF_CONNECTION_FRAMING_TYPE_HTTP1;
-
-    if (conn->protocol_baton) {
-        conn->perform_teardown(conn);
-        conn->protocol_baton = NULL;
-    }
-
-    conn->perform_read = read_from_connection;
-    conn->perform_write = write_to_connection;
-    conn->perform_hangup = hangup_connection;
-    conn->perform_teardown = NULL;
-
-    conn->status = APR_SUCCESS;
-
-    /* Let our context know that we've 'reset' the socket already. */
-    conn->seen_in_pollset |= APR_POLLHUP;
-
-    /* Recalculate the current list length */
-    conn->nr_of_written_reqs = 0;
-    conn->nr_of_unwritten_reqs = req_list_length(conn->unwritten_reqs);
-
-    /* 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(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                  "socket_sendv error %d\n", status);
-
-    /* did we write everything? */
-    if (written) {
-        apr_size_t len = 0;
-        int i;
-
-        serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                  "--- socket_sendv: %d bytes. --\n", written);
-
-        for (i = 0; i < conn->vec_len; i++) {
-            len += conn->vec[i].iov_len;
-            if (written < len) {
-                serf__log_nopref(LOGLVL_DEBUG, LOGCOMP_RAWMSG, conn->config,
-                                 "%.*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(LOGLVL_DEBUG, LOGCOMP_RAWMSG, conn->config,
-                                 "%.*s",
-                                 conn->vec[i].iov_len, conn->vec[i].iov_base);
-            }
-        }
-        if (len == written) {
-            conn->vec_len = 0;
-        }
-        serf__log_nopref(LOGLVL_DEBUG, LOGCOMP_RAWMSG, conn->config, "\n");
-
-        /* Log progress information */
-        serf__context_progress_delta(conn->ctx, 0, written);
-    }
-
-    return status;
-}
-
-apr_status_t serf__connection_flush(serf_connection_t *conn)
-{
-    apr_status_t status = APR_SUCCESS;
-
-    while (conn->vec_len && !status) {
-        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_EPIPE(status)
-            || APR_STATUS_IS_ECONNRESET(status)
-            || APR_STATUS_IS_ECONNABORTED(status))
-            return no_more_writes(conn);
-
-    }
-    return status;
-}
-
-static apr_status_t setup_request(serf_request_t *request)
+apr_status_t serf__setup_request(serf_request_t *request)
 {
     serf_connection_t *conn = request->conn;
     apr_status_t status;
@@ -848,198 +167,10 @@ static apr_status_t setup_request(serf_r
     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 reqs_in_progress;
-
-        reqs_in_progress = conn->completed_requests - conn->completed_responses;
-
-        /* 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_SETUP_SSLTUNNEL && reqs_in_progress > 0)
-        {
-            return APR_SUCCESS;
-        }
-
-        /* We try to limit the number of in-flight requests so that we
-           don't have to repeat too many if the connection drops.  */
-        if (conn->max_outstanding_requests
-            && (reqs_in_progress >= conn->max_outstanding_requests))
-        {
-            /* backoff for now. */
-            return APR_SUCCESS;
-        }
-
-        /* If we have unwritten data, then write what we can. */
-        status = serf__connection_flush(conn);
-        if (APR_STATUS_IS_EAGAIN(status))
-            return APR_SUCCESS;
-        else 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, &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? */
-        status = serf__connection_flush(conn);
-        if (APR_STATUS_IS_EAGAIN(status))
-            return APR_SUCCESS;
-        else 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:
-             * - if there are remaining bytes they will be written, and as the 
-             * request bucket will be completely read it will be destroyed then.
-             * - we'll see if there are other requests that need to be sent 
-             * ("pipelining").
-             */
-            conn->hit_eof = 0;
-            serf_bucket_destroy(request->req_bkt);
-            request->req_bkt = NULL;
-
-            /* Move the request to the written queue */
-            link_requests(&conn->written_reqs, &conn->written_reqs_tail,
-                          request);
-            conn->nr_of_written_reqs++;
-            conn->unwritten_reqs = conn->unwritten_reqs->next;
-            conn->nr_of_unwritten_reqs--;
-            request->next = NULL;
-
-            /* If our connection has async responses enabled, we're not
-             * going to get a reply back, so kill the request.
-             */
-            if (conn->async_responses) {
-                conn->unwritten_reqs = request->next;
-                conn->nr_of_unwritten_reqs--;
-                destroy_request(request);
-            }
-
-            conn->completed_requests++;
-
-            if (conn->probable_keepalive_limit &&
-                conn->completed_requests > conn->probable_keepalive_limit) {
-                /* backoff for now. */
-                stop_reading = 1;
-            }
-        }
-
-        if (stop_reading) {
-            return APR_SUCCESS;
-        }
-    }
-    /* NOTREACHED */
-}
-
 /* A response message was received from the server, so call
    the handler as specified on the original request. */
-static apr_status_t handle_response(serf_request_t *request,
-                                    apr_pool_t *pool)
+apr_status_t serf__handle_response(serf_request_t *request,
+                                   apr_pool_t *pool)
 {
     int consumed_response = 0;
 
@@ -1120,31 +251,6 @@ static apr_status_t handle_response(serf
     return APR_SUCCESS;
 }
 
-/* An async response message was received from the server. */
-static apr_status_t handle_async_response(serf_connection_t *conn,
-                                          apr_pool_t *pool)
-{
-    apr_status_t status;
-
-    if (conn->current_async_response == NULL) {
-        conn->current_async_response =
-            (*conn->async_acceptor)(NULL, conn->stream,
-                                    conn->async_acceptor_baton, pool);
-    }
-
-    status = (*conn->async_handler)(NULL, conn->current_async_response,
-                                    conn->async_handler_baton, pool);
-
-    if (APR_STATUS_IS_EOF(status)) {
-        serf_bucket_destroy(conn->current_async_response);
-        conn->current_async_response = NULL;
-        status = APR_SUCCESS;
-    }
-
-    return status;
-}
-
-
 apr_status_t
 serf__provide_credentials(serf_context_t *ctx,
                           char **username,
@@ -1181,7 +287,7 @@ serf__provide_credentials(serf_context_t
         if (!authn_req->req_bkt) {
             apr_status_t status;
 
-            status = setup_request(authn_req);
+            status = serf__setup_request(authn_req);
             /* If we can't setup a request, don't bother setting up the
                ssl tunnel. */
             if (status)
@@ -1199,627 +305,6 @@ serf__provide_credentials(serf_context_t
     return APR_SUCCESS;
 }
 
-/* read data from the connection */
-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;
-
-    /* Whatever is coming in on the socket corresponds to the first request
-     * on our chain.
-     */
-    serf_request_t *request = conn->written_reqs;
-    if (!request) {
-        /* Request wasn't completely written yet! */
-        request = conn->unwritten_reqs;
-    }
-
-    /* If the stop_writing flag was set on the connection, reset it now because
-       there is some data to read. */
-    if (conn->stop_writing) {
-        conn->stop_writing = 0;
-        conn->dirty_conn = 1;
-        conn->ctx->dirty_pollset = 1;
-    }
-
-    /* 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_bucket_t *dummy1, *dummy2;
-
-        apr_pool_clear(tmppool);
-
-        /* Only interested in the input stream here. */
-        status = prepare_conn_streams(conn, &dummy1, &dummy2);
-        if (status) {
-            goto error;
-        }
-
-        /* 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_started) {
-            const char *data;
-            apr_size_t len;
-
-            status = serf_bucket_peek(conn->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) {
-                status = write_to_connection(conn);
-
-                if (!SERF_BUCKET_READ_ERROR(status))
-                    status = APR_SUCCESS;
-            }
-        }
-
-        if (conn->framing_type == SERF_CONNECTION_FRAMING_TYPE_NONE)
-            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->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 = handle_response(request, tmppool);
-
-        /* If we received APR_SUCCESS, run this loop again. */
-        if (!status) {
-            continue;
-        }
-
-        /* Some systems will not generate a HUP poll event so we have to
-         * handle the ECONNRESET issue and ECONNABORT here.
-         */
-        if (APR_STATUS_IS_ECONNRESET(status) ||
-            APR_STATUS_IS_ECONNABORTED(status) ||
-            status == SERF_ERROR_REQUEST_LOST) {
-            /* If the connection had ever been 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;
-            }
-            goto error;
-        }
-
-        /* 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. */
-        if (status == SERF_ERROR_SSL_NEGOTIATE_IN_PROGRESS) {
-            serf__log(LOGLVL_WARNING, LOGCOMP_CONN, __FILE__, conn->config,
-                      "The server requested renegotiation. Disable HTTP "
-                      "pipelining and reset the connection.\n", conn);
-
-            serf__connection_set_pipelining(conn, 0);
-            reset_connection(conn, 1);
-            status = APR_SUCCESS;
-            goto error;
-        }
-
-        /* 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) {
-                conn->dirty_conn = 1;
-                conn->ctx->dirty_pollset = 1;
-            }
-            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--;
-        }
-
-        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) {
-            conn->dirty_conn = 1;
-            conn->ctx->dirty_pollset = 1;
-        }
-
-        /* 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_started) {
-            conn->dirty_conn = 1;
-            conn->ctx->dirty_pollset = 1;
-            status = APR_SUCCESS;
-            goto error;
-        }
-    }
-
-error:
-    apr_pool_destroy(tmppool);
-    return status;
-}
-
-/* The connection got reset by the server. On Windows this can happen
-   when all data is read, so just cleanup the connection and open a new one.
-
-   If we haven't had any successful responses on this connection,
-   then error out as it is likely a server issue. */
-static apr_status_t hangup_connection(serf_connection_t *conn)
-{
-    if (conn->completed_responses) {
-        return reset_connection(conn, 1);
-    }
-
-    return SERF_ERROR_ABORTED_CONNECTION;
-}
-
-/* process all events on the connection */
-apr_status_t serf__process_connection(serf_connection_t *conn,
-                                      apr_int16_t events)
-{
-    apr_status_t status;
-
-    /* POLLHUP/ERR should come after POLLIN so if there's an error message or
-     * the like sitting on the connection, we give the app a chance to read
-     * it before we trigger a reset condition.
-     */
-    if ((events & APR_POLLIN) != 0) {
-        if ((status = conn->perform_read(conn)) != APR_SUCCESS)
-            return status;
-
-        /* If we decided to reset our connection, return now as we don't
-         * want to write.
-         */
-        if ((conn->seen_in_pollset & APR_POLLHUP) != 0) {
-            return APR_SUCCESS;
-        }
-    }
-    if ((events & APR_POLLHUP) != 0) {
-        /* The connection got reset by the server. */
-        return conn->perform_hangup(conn);
-    }
-    if ((events & APR_POLLERR) != 0) {
-        /* We might be talking to a buggy HTTP server that doesn't
-         * do lingering-close.  (httpd < 2.1.8 does this.)
-         *
-         * See:
-         *
-         * http://issues.apache.org/bugzilla/show_bug.cgi?id=35292
-         */
-        if (conn->completed_requests && !conn->probable_keepalive_limit) {
-            return reset_connection(conn, 1);
-        }
-#ifdef SO_ERROR
-        /* If possible, get the error from the platform's socket layer and
-           convert it to an APR status code. */
-        {
-            apr_os_sock_t osskt;
-            if (!apr_os_sock_get(&osskt, conn->skt)) {
-                int error;
-                apr_socklen_t l = sizeof(error);
-
-                if (!getsockopt(osskt, SOL_SOCKET, SO_ERROR, (char*)&error,
-                                &l)) {
-                    status = APR_FROM_OS_ERROR(error);
-
-                    /* Handle fallback for multi-homed servers.
-                     
-                       ### Improve algorithm to find better than just 'next'?
-
-                       Current Windows versions already handle re-ordering for
-                       api users by using statistics on the recently failed
-                       connections to order the list of addresses. */
-                    if (conn->completed_requests == 0
-                        && conn->address->next != NULL
-                        && (APR_STATUS_IS_ECONNREFUSED(status)
-                            || APR_STATUS_IS_TIMEUP(status)
-                            || APR_STATUS_IS_ENETUNREACH(status))) {
-
-                        conn->address = conn->address->next;
-                        return reset_connection(conn, 1);
-                    }
-
-                    return status;
-                  }
-            }
-        }
-#endif
-        return APR_EGENERAL;
-    }
-    if ((events & APR_POLLOUT) != 0) {
-        if ((status = conn->perform_write(conn)) != APR_SUCCESS)
-            return status;
-    }
-    return APR_SUCCESS;
-}
-
-serf_connection_t *serf_connection_create(
-    serf_context_t *ctx,
-    apr_sockaddr_t *address,
-    serf_connection_setup_t setup,
-    void *setup_baton,
-    serf_connection_closed_t closed,
-    void *closed_baton,
-    apr_pool_t *pool)
-{
-    serf_connection_t *conn = apr_pcalloc(pool, sizeof(*conn));
-
-    conn->ctx = ctx;
-    conn->status = APR_SUCCESS;
-    /* Ignore server address if proxy was specified. */
-    conn->address = ctx->proxy_address ? ctx->proxy_address : address;
-    conn->setup = setup;
-    conn->setup_baton = setup_baton;
-    conn->closed = closed;
-    conn->closed_baton = closed_baton;
-    conn->pool = pool;
-    conn->allocator = serf_bucket_allocator_create(pool, NULL, NULL);
-    conn->stream = NULL;
-    conn->ostream_head = NULL;
-    conn->ostream_tail = NULL;
-    conn->baton.type = SERF_IO_CONN;
-    conn->baton.u.conn = conn;
-    conn->hit_eof = 0;
-    conn->state = SERF_CONN_INIT;
-    conn->latency = -1; /* unknown */
-    conn->stop_writing = 0;
-    conn->write_now = 0;
-    conn->pipelining = 1;
-    conn->framing_type = SERF_CONNECTION_FRAMING_TYPE_HTTP1;
-    conn->perform_read = read_from_connection;
-    conn->perform_write = write_to_connection;
-    conn->perform_hangup = hangup_connection;
-    conn->perform_teardown = NULL;
-    conn->protocol_baton = NULL;
-
-    /* Create a subpool for our connection. */
-    apr_pool_create(&conn->skt_pool, conn->pool);
-
-    /* register a cleanup */
-    apr_pool_cleanup_register(conn->pool, conn, clean_conn,
-                              apr_pool_cleanup_null);
-
-    /* Add the connection to the context. */
-    *(serf_connection_t **)apr_array_push(ctx->conns) = conn;
-
-    return conn;
-}
-
-apr_status_t serf_connection_create2(
-    serf_connection_t **conn,
-    serf_context_t *ctx,
-    apr_uri_t host_info,
-    serf_connection_setup_t setup,
-    void *setup_baton,
-    serf_connection_closed_t closed,
-    void *closed_baton,
-    apr_pool_t *pool)
-{
-    apr_status_t status = APR_SUCCESS;
-    serf_config_t *config;
-    serf_connection_t *c;
-    apr_sockaddr_t *host_address = NULL;
-
-    /* Set the port number explicitly, needed to create the socket later. */
-    if (!host_info.port) {
-        host_info.port = apr_uri_port_of_scheme(host_info.scheme);
-    }
-
-    /* Only lookup the address of the server if no proxy server was
-       configured. */
-    if (!ctx->proxy_address) {
-        status = apr_sockaddr_info_get(&host_address,
-                                       host_info.hostname,
-                                       APR_UNSPEC, host_info.port, 0, pool);
-        if (status)
-            return status;
-    }
-
-    c = serf_connection_create(ctx, host_address, setup, setup_baton,
-                               closed, closed_baton, pool);
-
-    /* We're not interested in the path following the hostname. */
-    c->host_url = apr_uri_unparse(c->pool,
-                                  &host_info,
-                                  APR_URI_UNP_OMITPATHINFO |
-                                  APR_URI_UNP_OMITUSERINFO);
-
-    /* Store the host info without the path on the connection. */
-    (void)apr_uri_parse(c->pool, c->host_url, &(c->host_info));
-    if (!c->host_info.port) {
-        c->host_info.port = apr_uri_port_of_scheme(c->host_info.scheme);
-    }
-
-    /* Store the connection specific info in the configuration store */
-    status = serf__config_store_get_config(ctx, c, &config, pool);
-    if (status)
-        return status;
-    c->config = config;
-    serf_config_set_stringc(config, SERF_CONFIG_HOST_NAME,
-                            c->host_info.hostname);
-    serf_config_set_stringc(config, SERF_CONFIG_HOST_PORT,
-                           apr_itoa(ctx->pool, c->host_info.port));
-
-    *conn = c;
-
-    serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, c->config,
-              "created connection 0x%x\n", c);
-
-    return status;
-}
-
-apr_status_t serf_connection_reset(
-    serf_connection_t *conn)
-{
-    return reset_connection(conn, 0);
-}
-
-
-apr_status_t serf_connection_close(
-    serf_connection_t *conn)
-{
-    int i;
-    serf_context_t *ctx = conn->ctx;
-    apr_status_t status;
-
-    for (i = ctx->conns->nelts; i--; ) {
-        serf_connection_t *conn_seq = GET_CONN(ctx, i);
-
-        if (conn_seq == conn) {
-            /* The application asked to close the connection, no need to notify
-               it for each cancelled request. */
-            while (conn->written_reqs) {
-                cancel_request(conn->written_reqs, &conn->written_reqs, 0);
-            }
-            while (conn->unwritten_reqs) {
-                cancel_request(conn->unwritten_reqs, &conn->unwritten_reqs, 0);
-            }
-            if (conn->skt != NULL) {
-                remove_connection(ctx, conn);
-                status = clean_skt(conn);
-                if (conn->closed != NULL) {
-                    handle_conn_closed(conn, status);
-                }
-            }
-            if (conn->stream != NULL) {
-                serf_bucket_destroy(conn->stream);
-                conn->stream = NULL;
-            }
-
-            destroy_ostream(conn);
-
-            if (conn->protocol_baton) {
-                conn->perform_teardown(conn);
-                conn->protocol_baton = NULL;
-            }
-
-            /* Remove the connection from the context. We don't want to
-             * deal with it any more.
-             */
-            if (i < ctx->conns->nelts - 1) {
-                /* move later connections over this one. */
-                memmove(
-                    &GET_CONN(ctx, i),
-                    &GET_CONN(ctx, i + 1),
-                    (ctx->conns->nelts - i - 1) * sizeof(serf_connection_t *));
-            }
-            --ctx->conns->nelts;
-
-            serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                      "closed connection 0x%x\n", conn);
-
-            /* Found the connection. Closed it. All done. */
-            return APR_SUCCESS;
-        }
-    }
-
-    /* We didn't find the specified connection. */
-    /* ### doc talks about this w.r.t poll structures. use something else? */
-    return APR_NOTFOUND;
-}
-
-
-void serf_connection_set_max_outstanding_requests(
-    serf_connection_t *conn,
-    unsigned int max_requests)
-{
-    if (max_requests == 0)
-        serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                  "Set max. nr. of outstanding requests for this "
-                  "connection to unlimited.\n");
-    else
-        serf__log(LOGLVL_DEBUG, LOGCOMP_CONN, __FILE__, conn->config,
-                  "Limit max. nr. of outstanding requests for this "
-                  "connection to %u.\n", max_requests);
-
-    conn->max_outstanding_requests = max_requests;
-}
-
-/* Disable HTTP pipelining, ensure that only one request is outstanding at a 
-   time. This is an internal method, an application that wants to disable
-   HTTP pipelining can achieve this by calling:
-     serf_connection_set_max_outstanding_requests(conn, 1) .
- */
-void serf__connection_set_pipelining(serf_connection_t *conn, int enabled)
-{
-    conn->pipelining = enabled;
-}
-
-void serf_connection_set_async_responses(
-    serf_connection_t *conn,
-    serf_response_acceptor_t acceptor,
-    void *acceptor_baton,
-    serf_response_handler_t handler,
-    void *handler_baton)
-{
-    conn->async_responses = 1;
-    conn->async_acceptor = acceptor;
-    conn->async_acceptor_baton = acceptor_baton;
-    conn->async_handler = handler;
-    conn->async_handler_baton = handler_baton;
-}
-
-void serf_connection_set_framing_type(
-    serf_connection_t *conn,
-    serf_connection_framing_type_t framing_type)
-{
-    conn->framing_type = framing_type;
-
-    if (conn->skt) {
-        conn->dirty_conn = 1;
-        conn->ctx->dirty_pollset = 1;
-        conn->stop_writing = 0;
-        conn->write_now = 1;
-
-        /* Close down existing protocol */
-        if (conn->protocol_baton) {
-            conn->perform_teardown(conn);
-            conn->protocol_baton = NULL;
-        }
-
-        /* Reset to default */
-        conn->perform_read = read_from_connection;
-        conn->perform_write = write_to_connection;
-        conn->perform_hangup = hangup_connection;
-        conn->perform_teardown = NULL;
-
-        switch (framing_type) {
-            case SERF_CONNECTION_FRAMING_TYPE_HTTP2:
-                serf__http2_protocol_init(conn);
-                break;
-            default:
-                break;
-        }
-    }
-}
-
 static serf_request_t *
 create_request(serf_connection_t *conn,
                serf_request_setup_t setup,
@@ -1858,7 +343,7 @@ serf_request_t *serf_connection_request_
                              0  /* ssl tunnel */);
 
     /* Link the request to the end of the request chain. */
-    link_requests(&conn->unwritten_reqs, &conn->unwritten_reqs_tail, request);
+    serf__link_requests(&conn->unwritten_reqs, &conn->unwritten_reqs_tail, request);
     conn->nr_of_unwritten_reqs++;
 
     /* Ensure our pollset becomes writable in context run */
@@ -1961,9 +446,9 @@ apr_status_t serf_request_cancel(serf_re
         tmp = tmp->next;
 
     if (tmp)
-        return cancel_request(request, &conn->unwritten_reqs, 0);
+        return serf__cancel_request(request, &conn->unwritten_reqs, 0);
     else
-        return cancel_request(request, &conn->written_reqs, 0);
+        return serf__cancel_request(request, &conn->written_reqs, 0);
 
 }
 
@@ -2045,24 +530,3 @@ serf_bucket_t *serf_request_bucket_reque
 
     return req_bkt;
 }
-
-apr_interval_time_t serf_connection_get_latency(serf_connection_t *conn)
-{
-    if (conn->ctx->proxy_address) {
-        /* Detecting network latency for proxied connection is not implemented
-           yet. */
-        return -1;
-    }
-
-    return conn->latency;
-}
-
-unsigned int serf_connection_queued_requests(serf_connection_t *conn)
-{
-    return conn->nr_of_unwritten_reqs;
-}
-
-unsigned int serf_connection_pending_requests(serf_connection_t *conn)
-{
-    return conn->nr_of_unwritten_reqs + conn->nr_of_written_reqs;
-}

Modified: serf/trunk/outgoing.c
URL: http://svn.apache.org/viewvc/serf/trunk/outgoing.c?rev=1709415&r1=1709414&r2=1709415&view=diff
==============================================================================
--- serf/trunk/outgoing.c (original)
+++ serf/trunk/outgoing.c Mon Oct 19 14:00:40 2015
@@ -52,36 +52,6 @@ static apr_status_t clean_skt(void *data
     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)
 {
@@ -542,91 +512,6 @@ static apr_status_t is_conn_closing(serf
     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;
-    }
-
-    if (request->respool) {
-        serf_debug__bucket_alloc_check(request->allocator);
-
-        /* ### 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);
-}
-
-/* Calculate the length of a linked list of requests. */
-static unsigned int req_list_length(serf_request_t *req)
-{
-    unsigned int length = 0;
-
-    while (req) {
-        length++;
-        req = req->next;
-    }
-
-    return length;
-}
-
 static apr_status_t remove_connection(serf_context_t *ctx,
                                       serf_connection_t *conn)
 {
@@ -671,8 +556,8 @@ static apr_status_t reset_connection(ser
        response yet. Inform the application that the request is cancelled, 
        so it can requeue them if needed. */
     while (conn->written_reqs) {
-        cancel_request(conn->written_reqs, &conn->written_reqs,
-                       requeue_requests);
+        serf__cancel_request(conn->written_reqs, &conn->written_reqs,
+                             requeue_requests);
     }
     conn->written_reqs_tail = NULL;
 
@@ -690,13 +575,14 @@ static apr_status_t reset_connection(ser
             serf_request_t *req = old_reqs;
             old_reqs = old_reqs->next;
             req->next = NULL;
-            link_requests(&conn->unwritten_reqs, &conn->unwritten_reqs_tail,
-                          req);
+            serf__link_requests(&conn->unwritten_reqs,
+                                &conn->unwritten_reqs_tail,
+                                req);
         }
         else {
             /* We don't want to requeue the request or this request was partially
                written. Inform the application that the request is cancelled. */
-            cancel_request(old_reqs, &old_reqs, requeue_requests);
+            serf__cancel_request(old_reqs, &old_reqs, requeue_requests);
         }
     }
 
@@ -749,7 +635,7 @@ static apr_status_t reset_connection(ser
 
     /* Recalculate the current list length */
     conn->nr_of_written_reqs = 0;
-    conn->nr_of_unwritten_reqs = req_list_length(conn->unwritten_reqs);
+    conn->nr_of_unwritten_reqs = serf__req_list_length(conn->unwritten_reqs);
 
     /* Found the connection. Closed it. All done. */
     return APR_SUCCESS;
@@ -825,29 +711,6 @@ apr_status_t serf__connection_flush(serf
     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, apr_pool_cleanup_null);
-
-    /* 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)
 {
@@ -925,7 +788,7 @@ static apr_status_t write_to_connection(
 
         if (request) {
             if (request->req_bkt == NULL) {
-                read_status = setup_request(request);
+                read_status = serf__setup_request(request);
                 if (read_status) {
                     /* Something bad happened. Propagate any errors. */
                     return read_status;
@@ -1004,8 +867,8 @@ static apr_status_t write_to_connection(
             request->req_bkt = NULL;
 
             /* Move the request to the written queue */
-            link_requests(&conn->written_reqs, &conn->written_reqs_tail,
-                          request);
+            serf__link_requests(&conn->written_reqs, &conn->written_reqs_tail,
+                                request);
             conn->nr_of_written_reqs++;
             conn->unwritten_reqs = conn->unwritten_reqs->next;
             conn->nr_of_unwritten_reqs--;
@@ -1017,7 +880,7 @@ static apr_status_t write_to_connection(
             if (conn->async_responses) {
                 conn->unwritten_reqs = request->next;
                 conn->nr_of_unwritten_reqs--;
-                destroy_request(request);
+                serf__destroy_request(request);
             }
 
             conn->completed_requests++;
@@ -1036,89 +899,7 @@ static apr_status_t write_to_connection(
     /* NOTREACHED */
 }
 
-/* A response message was received from the server, so call
-   the handler as specified on the original request. */
-static apr_status_t handle_response(serf_request_t *request,
-                                    apr_pool_t *pool)
-{
-    int consumed_response = 0;
-
-    /* Only enable the new authentication framework if the program has
-     * registered an authentication credential callback.
-     *
-     * This permits older Serf apps to still handle authentication
-     * themselves by not registering credential callbacks.
-     */
-    if (request->conn->ctx->cred_cb) {
-        apr_status_t status;
-
-        status = serf__handle_auth_response(&consumed_response,
-                                            request,
-                                            request->resp_bkt,
-                                            pool);
-
-        if (SERF_BUCKET_READ_ERROR(status)) {
-
-            /* There was an error while checking the authentication headers of
-               the response. We need to inform the application - which
-               hasn't seen this response yet - of the error.
-             
-               These are the possible causes of the error:
-
-               1. A communication error while reading the response status line,
-                  headers or while discarding the response body: pass the
-                  response unchanged to the application, it will see the same
-                  error as serf did.
-             
-               2. A 401/407 response status for a supported authn scheme that
-                  resulted in authn failure:
-                  Pass the response as received to the application, the response
-                  body can contain an error description. Terminate the response
-                  body with the AUTHN error instead of APR_EOF.
-
-               3. A 401/407 response status for a supported authn scheme that
-                  resulted in an unknown error returned by the application in
-                  the credentials callback (Basic/Digest):
-                  Handle the same as 2.
-
-               4. A 2xx response status for a supported authn scheme that
-                  resulted in authn failure:
-                  Pass the response headers to the application. The response
-                  body is untrusted, so we should drop it and return the AUTHN
-                  error instead of APR_EOF.
-             
-                  serf__handle_auth_response will already discard the response
-                  body, so we can handle this case the same as 2.
-
-               In summary, all these cases can be handled in the same way: call
-               the application's response handler with the response bucket, but
-               make sure that the application sees error code STATUS instead of
-               APR_EOF after reading the response body.
-            */
-
-            serf__bucket_response_set_error_on_eof(request->resp_bkt, status);
-
-            /* Ignore the application's status code here, use the error status
-               from serf__handle_auth_response. */
-            (void)(*request->handler)(request,
-                                      request->resp_bkt,
-                                      request->handler_baton,
-                                      pool);
-        }
-
-        if (status)
-            return status;
-    }
-
-    if (!consumed_response) {
-        return (*request->handler)(request,
-                                   request->resp_bkt,
-                                   request->handler_baton,
-                                   pool);
-    }
 
-    return APR_SUCCESS;
-}
 
 /* An async response message was received from the server. */
 static apr_status_t handle_async_response(serf_connection_t *conn,
@@ -1144,61 +925,6 @@ static apr_status_t handle_async_respons
     return status;
 }
 
-
-apr_status_t
-serf__provide_credentials(serf_context_t *ctx,
-                          char **username,
-                          char **password,
-                          serf_request_t *request,
-                          int code, const char *authn_type,
-                          const char *realm,
-                          apr_pool_t *pool)
-{
-    serf_connection_t *conn = request->conn;
-    serf_request_t *authn_req = request;
-    apr_status_t status;
-
-    if (request->ssltunnel == 1 &&
-        conn->state == SERF_CONN_SETUP_SSLTUNNEL) {
-        /* This is a CONNECT request to set up an SSL tunnel over a proxy.
-           This request is created by serf, so if the proxy requires
-           authentication, we can't ask the application for credentials with
-           this request.
-
-           Solution: setup the first request created by the application on
-           this connection, and use that request and its handler_baton to
-           call back to the application. */
-
-        /* request->next will be NULL if this was the last request written */
-        authn_req = request->next;
-        if (!authn_req)
-            authn_req = conn->unwritten_reqs;
-
-        /* assert: app_request != NULL */
-        if (!authn_req)
-            return APR_EGENERAL;
-
-        if (!authn_req->req_bkt) {
-            apr_status_t status;
-
-            status = setup_request(authn_req);
-            /* If we can't setup a request, don't bother setting up the
-               ssl tunnel. */
-            if (status)
-                return status;
-        }
-    }
-
-    /* Ask the application. */
-    status = (*ctx->cred_cb)(username, password,
-                             authn_req, authn_req->handler_baton,
-                             code, authn_type, realm, pool);
-    if (status)
-        return status;
-
-    return APR_SUCCESS;
-}
-
 /* read data from the connection */
 static apr_status_t read_from_connection(serf_connection_t *conn)
 {
@@ -1325,7 +1051,7 @@ static apr_status_t read_from_connection
             serf_bucket_set_config(request->resp_bkt, conn->config);
         }
 
-        status = handle_response(request, tmppool);
+        status = serf__handle_response(request, tmppool);
 
         /* If we received APR_SUCCESS, run this loop again. */
         if (!status) {
@@ -1409,7 +1135,7 @@ static apr_status_t read_from_connection
             conn->nr_of_unwritten_reqs--;
         }
 
-        destroy_request(request);
+        serf__destroy_request(request);
 
         request = conn->written_reqs;
         if (!request) {
@@ -1696,10 +1422,10 @@ apr_status_t serf_connection_close(
             /* The application asked to close the connection, no need to notify
                it for each cancelled request. */
             while (conn->written_reqs) {
-                cancel_request(conn->written_reqs, &conn->written_reqs, 0);
+                serf__cancel_request(conn->written_reqs, &conn->written_reqs, 0);
             }
             while (conn->unwritten_reqs) {
-                cancel_request(conn->unwritten_reqs, &conn->unwritten_reqs, 0);
+                serf__cancel_request(conn->unwritten_reqs, &conn->unwritten_reqs, 0);
             }
             if (conn->skt != NULL) {
                 remove_connection(ctx, conn);
@@ -1846,205 +1572,6 @@ create_request(serf_connection_t *conn,
     return request;
 }
 
-serf_request_t *serf_connection_request_create(
-    serf_connection_t *conn,
-    serf_request_setup_t setup,
-    void *setup_baton)
-{
-    serf_request_t *request;
-
-    request = create_request(conn, setup, setup_baton,
-                             0, /* priority */
-                             0  /* ssl tunnel */);
-
-    /* Link the request to the end of the request chain. */
-    link_requests(&conn->unwritten_reqs, &conn->unwritten_reqs_tail, request);
-    conn->nr_of_unwritten_reqs++;
-
-    /* Ensure our pollset becomes writable in context run */
-    conn->ctx->dirty_pollset = 1;
-    conn->dirty_conn = 1;
-
-    return request;
-}
-
-static serf_request_t *
-priority_request_create(serf_connection_t *conn,
-                        int ssltunnelreq,
-                        serf_request_setup_t setup,
-                        void *setup_baton)
-{
-    serf_request_t *request;
-    serf_request_t *iter, *prev;
-
-    request = create_request(conn, setup, setup_baton,
-                             1, /* priority */
-                             ssltunnelreq);
-
-    /* Link the new request after the last written request. */
-    iter = conn->unwritten_reqs;
-    prev = NULL;
-
-    /* TODO: what if a request is partially written? */
-    /* Find a request that has data which needs to be delivered. */
-    while (iter != NULL && iter->req_bkt == NULL && iter->writing_started) {
-        prev = iter;
-        iter = iter->next;
-    }
-
-    /* A CONNECT request to setup an ssltunnel has absolute priority over all
-       other requests on the connection, so:
-       a. add it first to the queue 
-       b. ensure that other priority requests are added after the CONNECT
-          request */
-    if (!request->ssltunnel) {
-        /* Advance to next non priority request */
-        while (iter != NULL && iter->priority) {
-            prev = iter;
-            iter = iter->next;
-        }
-    }
-
-    if (prev) {
-        request->next = iter;
-        prev->next = request;
-    } else {
-        request->next = iter;
-        conn->unwritten_reqs = request;
-    }
-    conn->nr_of_unwritten_reqs++;
-
-    /* Ensure our pollset becomes writable in context run */
-    conn->ctx->dirty_pollset = 1;
-    conn->dirty_conn = 1;
-
-    return request;
-}
-
-serf_request_t *serf_connection_priority_request_create(
-    serf_connection_t *conn,
-    serf_request_setup_t setup,
-    void *setup_baton)
-{
-    return priority_request_create(conn,
-                                   0, /* not a ssltunnel CONNECT request */
-                                   setup, setup_baton);
-}
-
-serf_request_t *serf__ssltunnel_request_create(serf_connection_t *conn,
-                                               serf_request_setup_t setup,
-                                               void *setup_baton)
-{
-    return priority_request_create(conn,
-                                   1, /* This is a ssltunnel CONNECT request */
-                                   setup, setup_baton);
-}
-
-
-serf_request_t *serf__request_requeue(const serf_request_t *request)
-{
-    /* ### in the future, maybe we could reset REQUEST and try again?  */
-    return priority_request_create(request->conn,
-                                   request->ssltunnel,
-                                   request->setup,
-                                   request->setup_baton);
-}
-
-
-apr_status_t serf_request_cancel(serf_request_t *request)
-{
-    serf_connection_t *conn = request->conn;
-    serf_request_t *tmp = conn->unwritten_reqs;
-
-    /* Find out which queue holds the request */
-    while (tmp != NULL && tmp != request)
-        tmp = tmp->next;
-
-    if (tmp)
-        return cancel_request(request, &conn->unwritten_reqs, 0);
-    else
-        return cancel_request(request, &conn->written_reqs, 0);
-
-}
-
-apr_status_t serf_request_is_written(serf_request_t *request)
-{
-    if (request->writing_started && !request->req_bkt)
-        return APR_SUCCESS;
-
-    return APR_EBUSY;
-}
-
-apr_pool_t *serf_request_get_pool(const serf_request_t *request)
-{
-    return request->respool;
-}
-
-
-serf_bucket_alloc_t *serf_request_get_alloc(
-    const serf_request_t *request)
-{
-    return request->allocator;
-}
-
-
-serf_connection_t *serf_request_get_conn(
-    const serf_request_t *request)
-{
-    return request->conn;
-}
-
-
-void serf_request_set_handler(
-    serf_request_t *request,
-    const serf_response_handler_t handler,
-    const void **handler_baton)
-{
-    request->handler = handler;
-    request->handler_baton = handler_baton;
-}
-
-
-serf_bucket_t *serf_request_bucket_request_create(
-    serf_request_t *request,
-    const char *method,
-    const char *uri,
-    serf_bucket_t *body,
-    serf_bucket_alloc_t *allocator)
-{
-    serf_bucket_t *req_bkt;
-    serf_bucket_t *hdrs_bkt;
-    serf_connection_t *conn = request->conn;
-    serf_context_t *ctx = conn->ctx;
-    int tunneled;
-
-    tunneled = ctx->proxy_address
-               && (strcmp(conn->host_info.scheme, "https") == 0);
-
-    req_bkt = serf_bucket_request_create(method, uri, body, allocator);
-    hdrs_bkt = serf_bucket_request_get_headers(req_bkt);
-
-    /* Use absolute uri's in requests to a proxy. USe relative uri's in
-       requests directly to a server or sent through an SSL tunnel. */
-    if (ctx->proxy_address && conn->host_url && !tunneled)
-    {
-        serf_bucket_request_set_root(req_bkt, conn->host_url);
-    }
-
-    if (conn->host_info.hostinfo)
-    {
-        serf_bucket_headers_setn(hdrs_bkt, "Host",  conn->host_info.hostinfo);
-    }
-
-    /* Setup server authentication headers.  */
-    serf__auth_setup_request(HOST, request, method, uri, hdrs_bkt);
-
-    /* Setup proxy authentication headers, unless we're tunneling.  */
-    if (!tunneled)
-        serf__auth_setup_request(PROXY, request, method, uri, hdrs_bkt);
-
-    return req_bkt;
-}
 
 apr_interval_time_t serf_connection_get_latency(serf_connection_t *conn)
 {

Modified: serf/trunk/serf_private.h
URL: http://svn.apache.org/viewvc/serf/trunk/serf_private.h?rev=1709415&r1=1709414&r2=1709415&view=diff
==============================================================================
--- serf/trunk/serf_private.h (original)
+++ serf/trunk/serf_private.h Mon Oct 19 14:00:40 2015
@@ -536,6 +536,17 @@ apr_status_t serf__hpack_huffman_encode(
                                         unsigned char *encoded,
                                         apr_size_t *encoded_len);
 
+/* From connection_request.c */
+void serf__link_requests(serf_request_t **list, serf_request_t **tail,
+                         serf_request_t *request);
+apr_status_t serf__destroy_request(serf_request_t *request);
+apr_status_t serf__cancel_request(serf_request_t *request,
+                                  serf_request_t **list,
+                                  int notify_request);
+unsigned int serf__req_list_length(serf_request_t *req);
+apr_status_t serf__setup_request(serf_request_t *request);
+void serf__link_requests(serf_request_t **list, serf_request_t **tail,
+                         serf_request_t *request);
 
 /** Logging functions. **/
 



Mime
View raw message