/* ====================================================================
 *    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 <stdlib.h>

#include <apr_pools.h>
#include <apr_poll.h>
#include <apr_version.h>
#include <apr_portable.h>
#include <apr_strings.h>

#include "serf.h"
#include "serf_bucket_util.h"

#include "serf_private.h"

static apr_status_t clean_resp(void *data)
{
    serf_request_t *request = data;
    apr_pool_t *respool = request->respool;

    /* Note that this function must handle rehooking several
       variables to a different request!

       See serf_connection__request_requeue() */

    request->respool = NULL;

    /* The request's RESPOOL is being cleared.  */
    if (respool && request->writing >= SERF_WRITING_STARTED
                && request->writing < SERF_WRITING_FINISHED) {

        /* HOUSTON, WE HAVE A PROBLEM.

           We created buckets inside the pool that is now cleaned and
           stored them in an aggregate that still lives on.

           This happens when the application decides that it doesn't
           need the connection any more and clears the pool of the
           connection, of which the request pool is a subpool.

           Let's ask the connection to take care of things */
        serf__connection_pre_cleanup(request->conn);
    }

#ifdef SERF_DEBUG_BUCKET_USE
    if (respool && request->allocator) {
        serf_debug__closed_conn(request->allocator);
    }
#endif

    /* 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) {
        if (request->writing == SERF_WRITING_NONE)
            serf_bucket_destroy(request->req_bkt);
        request->req_bkt = NULL;
    }

#ifdef SERF_DEBUG_BUCKET_USE
    if (respool && request->allocator) {
        serf_debug__bucket_alloc_check(request->allocator);
    }
#endif

    request->allocator = NULL;

    return APR_SUCCESS;
}

void serf__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;
    }
}

apr_status_t serf__destroy_request(serf_request_t *request)
{
    serf_connection_t *conn = request->conn;

    if (request->depends_first && request->depends_on) {
        apr_uint64_t total = 0;
        serf_request_t *r, **pr;
        apr_uint64_t rqd = request->dep_priority;

        /* Calculate total priority of descendants */
        for (r = request->depends_first; r; r = r->depends_next) {
            total += r->dep_priority;
        }

        /* Apply now, as if they depend on the parent */
        for (r = request->depends_first; r; r = r->depends_next) {
            if (total) {

                r->dep_priority = (apr_uint16_t)(rqd * r->dep_priority
                                                 / total);
            }
            else
                r->dep_priority = 0;

            r->depends_on = request->depends_on;
        }

        /* Remove us from parent */
        pr = &request->depends_on->depends_first;
        while (*pr) {
            if (*pr == request) {
                *pr = request->depends_next;
                break;
            }

            pr = &(*pr)->depends_next;
        }

        /* And append all our descendants */
        *pr = request->depends_first;

        request->depends_on = NULL;
        request->depends_first = NULL;
        request->depends_next = NULL;
    }
    else if (request->depends_first) {
        /* Dependencies will lose their parent */
        serf_request_t *r, *next;

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

            r->depends_on = NULL;
            r->depends_next = NULL;
        }
        request->depends_first = NULL;
    }
    else if (request->depends_on) {
        serf_request_t **pr;

        /* Remove us from parent */
        pr = &request->depends_on->depends_first;
        while (*pr) {
            if (*pr == request) {
                *pr = request->depends_next;
                break;
            }

            pr = &(*pr)->depends_next;
        }
        request->depends_on = NULL;
    }

    if (request->writing >= SERF_WRITING_STARTED
        && request->writing < SERF_WRITING_FINISHED) {

        /* Schedule for destroy when it is safe again.

           Destroying now will destroy memory of buckets that we
           may still need.
        */
        serf__link_requests(&conn->done_reqs, &conn->done_reqs_tail,
                            request);
    }
    else {

        if (request->respool) {
          apr_pool_t *pool = request->respool;

          apr_pool_cleanup_run(pool, request, clean_resp);
          apr_pool_destroy(pool);
        }

        serf_bucket_mem_free(conn->allocator, request);
    }

    return APR_SUCCESS;
}

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) {
        /* We actually don't care what the handler returns.
         * We have bigger matters at hand.
         */
        (void)request->handler(request, NULL, request->handler_baton,
                               request->respool);

        request->handler = NULL;
    }

    if (request->conn && request->conn->perform_cancel_request) {
        request->conn->perform_cancel_request(request,
                                              SERF_ERROR_HTTP2_CANCEL);
    }

    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 serf__destroy_request(request);
}

/* Calculate the length of a linked list of requests. */
unsigned int serf__req_list_length(serf_request_t *req)
{
    unsigned int length = 0;

    while (req) {
        length++;
        req = req->next;
    }

    return length;
}

apr_status_t serf__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;
}

/* A response message was received from the server, so call
   the handler as specified on the original request. */
apr_status_t serf__handle_response(serf_request_t *request,
                                   apr_pool_t *pool)
{
    bool consumed_response = false;

    /* 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->auth_done && request->conn->ctx->cred_cb) {
        apr_status_t status;

        if (!SERF_BUCKET_IS_RESPONSE(request->resp_bkt)) {
            request->auth_done = true;
            status = APR_SUCCESS;
        }
        else
            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;
}

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) {
            status = serf__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;
}

static serf_request_t *
create_request(serf_connection_t *conn,
               serf_request_setup_t setup,
               void *setup_baton,
               bool priority,
               bool ssltunnel)
{
    serf_request_t *request;

    request = serf_bucket_mem_alloc(conn->allocator, sizeof(*request));
    request->conn = conn;
    request->setup = setup;
    request->setup_baton = setup_baton;
    request->handler = NULL;
    request->acceptor = NULL;
    request->respool = NULL;
    request->req_bkt = NULL;
    request->resp_bkt = NULL;
    request->priority = priority;
    request->writing = SERF_WRITING_NONE;
    request->ssltunnel = ssltunnel;
    request->auth_done = FALSE;
    request->next = NULL;
    request->auth_baton = NULL;
    request->protocol_baton = NULL;
    request->depends_on = NULL;
    request->depends_next = NULL;
    request->depends_first = NULL;
    request->dep_priority = SERF_REQUEST_PRIORITY_DEFAULT;

    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,
                             false /* priority */,
                             false /* ssl tunnel */);

    /* Link the request to the end of the request chain. */
    serf__link_requests(&conn->unwritten_reqs, &conn->unwritten_reqs_tail, request);
    conn->nr_of_unwritten_reqs++;

    /* Ensure our pollset becomes writable in context run */
    serf_io__set_pollset_dirty(&conn->io);

    return request;
}

static void
insert_priority_request(serf_request_t *request)
{
    serf_request_t *iter, *prev;
    serf_connection_t *conn = request->conn;

    /* 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 >= SERF_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 */
    serf_io__set_pollset_dirty(&conn->io);
}

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;

    request = create_request(conn, setup, setup_baton,
                             true /* priority */,
                             ssltunnelreq);

    insert_priority_request(request);

    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_handler_t to discard a request */
static apr_status_t discard_response_handler(serf_request_t *request,
                                             serf_bucket_t *response,
                                             void *handler_baton,
                                             apr_pool_t *pool)
{
    apr_status_t status;
    apr_size_t len;

    do
    {
        const char *data;

        status = serf_bucket_read(response, SERF_READ_ALL_AVAIL, &data, &len);
    } while (!status && len);

    return status;
}

apr_status_t serf_connection__request_requeue(serf_request_t *request)
{
    serf_request_t *discard;
    serf_request_t **pr;

    /* For some reason, somebody wants to restart this request, that was
       at least partially written and partially read. Most likely to
       slightly change it. (E.g. to add auth headers).

       To handle this we have to do two things: we have to handle remaining
       incoming data on the existing request. And we have to make the request
       ready to write it again.. preferably as the first new request.
     */

    /* Setup a new request to handle discarding the remaining body */
    discard = create_request(request->conn,
                             NULL, NULL,
                             request->priority,
                             request->ssltunnel);

    discard->respool = request->respool;
    discard->allocator = request->allocator;
    discard->req_bkt = request->req_bkt;
    discard->resp_bkt = request->resp_bkt;

    discard->setup = NULL;  /* Already setup */
    discard->setup_baton = NULL;

    discard->acceptor = NULL;
    discard->acceptor_baton = NULL; /* Already accepted */

    discard->handler = discard_response_handler;
    discard->handler_baton = NULL;

    discard->protocol_baton = request->protocol_baton;
    discard->auth_done = request->auth_done;
    discard->auth_baton = request->auth_baton;

    discard->writing = request->writing;

    if (discard->respool) {
        apr_pool_cleanup_kill(discard->respool, request, clean_resp);
        apr_pool_cleanup_register(discard->respool, discard,
                                  clean_resp, apr_pool_cleanup_null);
    }

    if (request->depends_on) {
        /* Update request dependencies */
        discard->depends_on = request->depends_on;

        for (pr = &discard->depends_on->depends_first;
             *pr;
             pr = &(*pr)->depends_next)
        {
            if (*pr == request) {
                *pr = discard;
                discard->depends_next = request->depends_next;
                request->depends_next = NULL;
                request->depends_on = NULL;
                break;
            }
        }
    }
    if (request->depends_first) {
        serf_request_t *r;

        for (r = request->depends_first; r; r = r->depends_next) {
            r->depends_on = discard;
        }
        discard->depends_first = request->depends_first;
        request->depends_first = NULL;
    }

    /* And now make the discard request take the place of the old request */
    for (pr = &request->conn->written_reqs; *pr; pr = &(*pr)->next) {
        if (*pr == request) {
            *pr = discard;
            discard->next = request->next;
            request->next = NULL;

            if (!discard->next)
                request->conn->written_reqs_tail = discard;
            break;
        }
    }

    /* Tell the protocol handler (if any) that we are no longer looking at the
       request */

    if (request->conn->perform_cancel_request)
        request->conn->perform_cancel_request(discard, SERF_ERROR_HTTP2_CANCEL);

    /* And now unhook the existing request */
    request->allocator = NULL;
    request->respool = NULL;
    request->req_bkt = NULL;
    request->resp_bkt = NULL;
    request->writing = SERF_WRITING_NONE;
    request->auth_baton = NULL;
    request->protocol_baton = NULL;

    request->acceptor = NULL;
    request->acceptor_baton = NULL;
    request->handler = NULL;
    request->handler_baton = NULL;
    request->auth_done = false;

    if (discard->depends_first || discard->depends_on) {
        serf_connection_request_prioritize(request, discard, 0xFFFF,
                                           TRUE);
    }

    insert_priority_request(request);

    return APR_SUCCESS;
}

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 serf__cancel_request(request, &conn->unwritten_reqs, 0);
    else
        return serf__cancel_request(request, &conn->written_reqs, 0);

}

void serf_connection_request_prioritize(serf_request_t *request,
                                        serf_request_t *depends_on,
                                        apr_uint16_t priority,
                                        int exclusive)
{
    if (request->depends_on != depends_on) {
        serf_request_t *r;

        if (depends_on->conn != request->conn || depends_on == request)
            abort();

        /* If we are indirectly made dependent on ourself, we first
           reprioritize the descendant on our current parent. See
           https://tools.ietf.org/html/rfc7540#section-5.3.3

           If a stream is made dependent on one of its own dependencies, the
           formerly dependent stream is first moved to be dependent on the
           reprioritized stream's previous parent.  The moved dependency
           retains its weight. */

        r = depends_on;

        while (r && r != request && r->depends_on)
            r = r->depends_on;

        if (r == request)
        {
            serf_connection_request_prioritize(depends_on,
                                               request->depends_on,
                                               depends_on->dep_priority,
                                               false /* exclusive */);
        }

        if (request->depends_on) {
        /* Ok, we can now update our dependency */

            serf_request_t **pr = &request->depends_on->depends_first;

            while (*pr) {
                if (*pr == request) {
                    *pr = request->depends_next;
                    break;
                }
                pr = &(*pr)->depends_next;
            }
        }

        request->depends_on = depends_on;

        if (depends_on) {
            if (exclusive) {
                r = depends_on->depends_first;

                while (r) {
                    r->depends_on = request;

                    if (r->depends_next)
                        r = r->depends_next;
                    else
                        break;
                }

                if (r) {
                    r->depends_next = request->depends_first;
                    r->depends_first = depends_on->depends_first;
                }
                request->depends_next = NULL;
            }
            else {
                request->depends_next = depends_on->depends_first;
            }
            depends_on->depends_first = request;
        }
        else
            request->depends_next = NULL;
    }

    if (priority)
        request->dep_priority = priority;

    /* And now tell the protocol about this */
    if (request->conn->perform_prioritize_request)
        request->conn->perform_prioritize_request(request, exclusive != 0);
}


apr_status_t serf_request_is_written(serf_request_t *request)
{
    if (request->writing >= SERF_WRITING_FINISHED)
        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;
}