/*

 *

 *   mod_auth_mellon.c: an authentication apache module

 *   Copyright © 2003-2007 UNINETT (http://www.uninett.no/)

 *

 *   This program is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 of the License, or

 *   (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "auth_mellon.h"

#include <curl/curl.h>

/* The size of the blocks we will allocate. */

#define AM_HC_BLOCK_SIZE 1000

#ifdef APLOG_USE_MODULE

APLOG_USE_MODULE(auth_mellon);

#endif

/* This structure describes a single-linked list of downloaded blocks. */

typedef struct am_hc_block_s {

    /* The next block we have allocated. */

    struct am_hc_block_s *next;

    /* The number of bytes written to this block. */

    apr_size_t used;

    /* The data stored in this block. */

    uint8_t data[AM_HC_BLOCK_SIZE];

} am_hc_block_t;

/* This structure describes a header for the block list. */

typedef struct {

    /* The pool we will allocate memory for new blocks from. */

    apr_pool_t *pool;

    /* The first block in the linked list of blocks. */

    am_hc_block_t *first;

    /* The last block in the linked list of blocks. */

    am_hc_block_t *last;

} am_hc_block_header_t;

/* This function allocates and initializes a block for data copying.

 *

 * Parameters:

 *  apr_pool_t *pool     The pool we should allocate the block from.

 *

 * Returns:

 *  The new block we allocated.

 */

static am_hc_block_t *am_hc_block_alloc(apr_pool_t *pool)

{

    am_hc_block_t *blk;

    blk = (am_hc_block_t *)apr_palloc(pool, sizeof(am_hc_block_t));

    blk->next = NULL;

    blk->used = 0;

    return blk;

}

/* This function adds data to the end of a block, and allocates new blocks

 * if the data doesn't fit in one block.

 *

 * Parameters:

 *  am_hc_block_t *block   The block we should begin by appending data to.

 *  apr_pool_t *pool       The pool we should allocate memory for new blocks

 *                         from.

 *  const uint8_t *data    The data we should append to the blocks.

 *  apr_size_t size        The length of the data we should append.

 *

 * Returns:

 *  The last block written to (i.e. the next block we should write to).

 */

static am_hc_block_t *am_hc_block_write(

    am_hc_block_t *block,

    apr_pool_t *pool,

    const uint8_t *data, apr_size_t size

    )

{

    apr_size_t num_cpy;

    while(size > 0) {

        /* Find the number of bytes we should write to this block. */

        num_cpy = AM_HC_BLOCK_SIZE - block->used;

        if(num_cpy == 0) {

            /* This block is full -- allocate a new block. */

            block->next = am_hc_block_alloc(pool);

            block = block->next;

            num_cpy = AM_HC_BLOCK_SIZE;

        }

        if(num_cpy > size) {

            num_cpy = size;

        }

        /* Copy data to this block. */

        memcpy(&block->data[block->used], data, num_cpy);

        block->used += num_cpy;

        size -= num_cpy;

        data += num_cpy;

    }

    /* The next write should be to this block. */

    return block;

}

/* This function initializes a am_hc_block_header_t structure, which

 * contains information about the linked list of data blocks.

 *

 * Parameters:

 *  am_hc_block_header_t *bh   Pointer to the data header whcih we

 *                             should initialize.

 *  apr_pool_t *pool           The pool we should allocate data from.

 *

 * Returns:

 *  Nothing.

 */

static void am_hc_block_header_init(am_hc_block_header_t *bh,

                                    apr_pool_t *pool)

{

    bh->pool = pool;

    bh->first = am_hc_block_alloc(pool);

    bh->last = bh->first;

}

/* This function writes data to the linked list of blocks identified by

 * the stream-parameter. It matches the prototype required by curl.

 *

 * Parameters:

 *  void *data           The data that should be written. It is size*nmemb

 *                       bytes long.

 *  size_t size          The size of each block of data that should

 *                       be written.

 *  size_t nmemb         The number of blocks of data that should be written.

 *  void *block_header   A pointer to a am_hc_block_header_t structure which

 *                       identifies the linked list we should store data in.

 *

 * Returns:

 *  The number of bytes that have been written.

 */

static size_t am_hc_data_write(void *data, size_t size, size_t nmemb,

                               void *data_header)

{

    am_hc_block_header_t *bh;

    bh = (am_hc_block_header_t *)data_header;

    bh->last = am_hc_block_write(bh->last, bh->pool, (const uint8_t *)data,

                                 size * nmemb);

    return size * nmemb;

}

/* This function fetches the data which was written to the databuffers

 * in the linked list which the am_hc_data_t structure keeps track of.

 *

 * Parameters:

 *  am_hc_block_header_t *bh   The header telling us which data buffers

 *                             we should extract data from.

 *  apr_pool_t *pool           The pool we should allocate the data

 *                             buffer from.

 *  void **buffer              A pointer to where we should store a pointer

 *                             to the data buffer we allocate. We will

 *                             always add a null-terminator to the end of

 *                             data buffer. This parameter can't be NULL.

 *  apr_size_t *size           This is a pointer to where we will store the

 *                             length of the data, not including the

 *                             null-terminator we add. This parameter can

 *                             be NULL.

 *

 * Returns:

 *  Nothing.

 */

static void am_hc_data_extract(am_hc_block_header_t *bh, apr_pool_t *pool,

                               void **buffer, apr_size_t *size)

{

    am_hc_block_t *blk;

    apr_size_t length;

    uint8_t *buf;

    apr_size_t pos;

    /* First we find the length of the data. */

    length = 0;

    for(blk = bh->first; blk != NULL; blk = blk->next) {

        length += blk->used;

    }

    /* Allocate memory for the data. Add one to the size in order to

     *  have space for the null-terminator.

     */

    buf = (uint8_t *)apr_palloc(pool, length + 1);

    /* Copy the data into the buffer. */

    pos = 0;

    for(blk = bh->first; blk != NULL; blk = blk->next) {

        memcpy(&buf[pos], blk->data, blk->used);

        pos += blk->used;

    }

    /* Add the null-terminator. */

    buf[length] = 0;

    /* Set up the return values. */

    *buffer = (void *)buf;

    if(size != NULL) {

        *size = length;

    }

}

/* This function creates a curl object and performs generic initialization

 * of it.

 *

 * Parameters:

 *  request_rec *r             The request we should log errors against.

 *  const char *uri            The URI we should request.

 *  am_hc_block_header_t *bh   The buffer curl will write response data to.

 *  char *curl_error           A buffer of size CURL_ERROR_SIZE where curl

 *                             will store error messages.

 *

 * Returns:

 *  A initialized curl object on succcess, or NULL on error.

 */

static CURL *am_httpclient_init_curl(request_rec *r, const char *uri,

                                     am_hc_block_header_t *bh,

                                     char *curl_error)

{

    am_dir_cfg_rec *cfg = am_get_dir_cfg(r);

    CURL *curl;

    CURLcode res;

    /* Initialize the curl object. */

    curl = curl_easy_init();

    if(curl == NULL) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to initialize a curl object.");

        return NULL;

    }

    /* Set up error reporting. */

    res = curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_error);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to set curl error buffer: [%u]\n", res);

        goto cleanup_fail;

    }

    /* Disable progress reporting. */

    res = curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to disable curl progress reporting: [%u] %s",

                      res, curl_error);

        goto cleanup_fail;

    }

    /* Disable use of signals. */

    res = curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to disable signals in curl: [%u] %s",

                      res, curl_error);

        goto cleanup_fail;

    }

    /* Set the timeout of the transfer. It is currently set to two minutes. */

    res = curl_easy_setopt(curl, CURLOPT_TIMEOUT, 120L);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to set the timeout of the curl download:"

                      " [%u] %s", res, curl_error);

        goto cleanup_fail;

    }

    /* If we have a CA configured, try to use it */

    if (cfg->idp_ca_file != NULL) {

        res = curl_easy_setopt(curl, CURLOPT_CAINFO, cfg->idp_ca_file->path);

        if(res != CURLE_OK) {

            AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                          "Failed to set SSL CA info %s:"

                          " [%u] %s", cfg->idp_ca_file->path, res, curl_error);

            goto cleanup_fail;

        }

    }

    /* Enable fail on http error. */

    res = curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to enable failure on http error: [%u] %s",

                      res, curl_error);

        goto cleanup_fail;

    }

    /* Select which uri we should download. */

    res = curl_easy_setopt(curl, CURLOPT_URL, uri);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to set curl download uri to \"%s\": [%u] %s",

                      uri, res, curl_error);

        goto cleanup_fail;

    }

    /* Set up data writing. */

    /* Set curl write function. */

    res = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, am_hc_data_write);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to set the curl write function: [%u] %s",

                      res, curl_error);

        goto cleanup_fail;

    }

    /* Set the curl write function parameter. */

    res = curl_easy_setopt(curl, CURLOPT_WRITEDATA, bh);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to set the curl write function data: [%u] %s",

                      res, curl_error);

        goto cleanup_fail;

    }

    return curl;

 cleanup_fail:

    curl_easy_cleanup(curl);

    return NULL;

}

/* This function downloads data from a specified URI, with specified timeout

 *

 * Parameters:

 *  request_rec *r       The apache request this download is associated

 *                       with. It is used for memory allocation and logging.

 *  const char *uri      The URI we should download.

 *  void **buffer        A pointer to where we should store a pointer to the

 *                       downloaded data. We will always add a null-terminator

 *                       to the data. This parameter can't be NULL.

 *  apr_size_t *size     This is a pointer to where we will store the length

 *                       of the downloaded data, not including the

 *                       null-terminator we add. This parameter can be NULL.

 *  int timeout          Timeout in seconds, 0 for no timeout.

 *  long *status         Pointer to HTTP status code. 

 *

 * Returns:

 *  OK on success, or HTTP_INTERNAL_SERVER_ERROR on failure. On failure we

 *  will write a log message describing the error.

 */

int am_httpclient_get(request_rec *r, const char *uri,

                      void **buffer, apr_size_t *size,

                      int timeout, long *status)

{

    am_hc_block_header_t bh;

    CURL *curl;

    char curl_error[CURL_ERROR_SIZE];

    CURLcode res;

    /* Initialize the data storage. */

    am_hc_block_header_init(&bh, r->pool);

    /* Initialize the curl object. */

    curl = am_httpclient_init_curl(r, uri, &bh, curl_error);

    if(curl == NULL) {

        return HTTP_INTERNAL_SERVER_ERROR;

    }

    res = curl_easy_setopt(curl, CURLOPT_TIMEOUT, (long)timeout);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to download data from the uri \"%s\", "

                      "cannot set timeout to %ld: [%u] %s",

                      uri, (long)timeout, res, curl_error);

        goto cleanup_fail;

    }

    res = curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, (long)timeout);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to download data from the uri \"%s\", "

                      "cannot set connect timeout to %ld: [%u] %s",

                      uri, (long)timeout,  res, curl_error);

        goto cleanup_fail;

    }

    /* Do the download. */

    res = curl_easy_perform(curl);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to download data from the uri \"%s\", "

                      "transaction aborted: [%u] %s",

                      uri, res, curl_error);

        goto cleanup_fail;

    }

    if (status != NULL) {

        res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, status);

        if(res != CURLE_OK) {

            AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                          "Failed to download data from the uri \"%s\", "

                          "no status report: [%u] %s",

                          uri, res, curl_error);

            goto cleanup_fail;

       }

    }

    /* Free the curl object. */

    curl_easy_cleanup(curl);

    /* Copy the data. */

    am_hc_data_extract(&bh, r->pool, buffer, size);

    return OK;

 cleanup_fail:

    curl_easy_cleanup(curl);

    return HTTP_INTERNAL_SERVER_ERROR;

}

/* This function downloads data from a specified URI by issuing a POST

 * request.

 *

 * Parameters:

 *  request_rec *r             The apache request this download is

 *                             associated with. It is used for memory

 *                             allocation and logging.

 *  const char *uri            The URI we should post data to.

 *  const void *post_data      The POST data we should send.

 *  apr_size_t post_length     The length of the POST data.

 *  const char *content_type   The content type of the POST data. This

 *                             parameter can be NULL, in which case the

 *                             content type will be

 *                             "application/x-www-form-urlencoded".

 *  void **buffer              A pointer to where we should store a pointer

 *                             to the downloaded data. We will always add a

 *                             null-terminator to the data. This parameter

 *                             can't be NULL.

 *  apr_size_t *size           This is a pointer to where we will store the

 *                             length of the downloaded data, not including

 *                             the null-terminator we add. This parameter

 *                             can be NULL.

 *

 * Returns:

 *  OK on success. On failure we will write a log message describing the

 *  error, and return HTTP_INTERNAL_SERVER_ERROR.

 */

int am_httpclient_post(request_rec *r, const char *uri,

                       const void *post_data, apr_size_t post_length,

                       const char *content_type,

                       void **buffer, apr_size_t *size)

{

    am_hc_block_header_t bh;

    CURL *curl;

    char curl_error[CURL_ERROR_SIZE];

    CURLcode res;

    struct curl_slist *ctheader;

    /* Initialize the data storage. */

    am_hc_block_header_init(&bh, r->pool);

    /* Initialize the curl object. */

    curl = am_httpclient_init_curl(r, uri, &bh, curl_error);

    if(curl == NULL) {

        return HTTP_INTERNAL_SERVER_ERROR;

    }

    /* Enable POST request. */

    res = curl_easy_setopt(curl, CURLOPT_POST, 1L);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to enable POST request: [%u] %s",

                      res, curl_error);

        goto cleanup_fail;

    }

    /* Set POST data size. */

    res = curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, post_length);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to set the POST data length: [%u] %s",

                      res, curl_error);

        goto cleanup_fail;

    }

    /* Set POST data. */

    res = curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post_data);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to set the POST data: [%u] %s",

                      res, curl_error);

        goto cleanup_fail;

    }

    /* Set the content-type header. */

    /* Set default content type if content_type is NULL. */

    if(content_type == NULL) {

        content_type = "application/x-www-form-urlencoded";

    }

    /* Create header list. */

    ctheader = NULL;

    ctheader = curl_slist_append(ctheader, apr_pstrcat(

                                     r->pool,

                                     "Content-Type: ",

                                     content_type,

                                     NULL

                                     ));

    /* Set headers. */

    res = curl_easy_setopt(curl, CURLOPT_HTTPHEADER, ctheader);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to set content-type header to \"%s\": [%u] %s",

                      content_type, res, curl_error);

        goto cleanup_fail;

    }

    /* Do the download. */

    res = curl_easy_perform(curl);

    if(res != CURLE_OK) {

        AM_LOG_RERROR(APLOG_MARK, APLOG_ERR, 0, r,

                      "Failed to download data from the uri \"%s\": [%u] %s",

                      uri, res, curl_error);

        goto cleanup_fail;

    }

    /* Free the curl object. */

    curl_easy_cleanup(curl);

    /* Free the content-type header. */

    curl_slist_free_all(ctheader);

    /* Copy the data. */

    am_hc_data_extract(&bh, r->pool, buffer, size);

    return OK;

 cleanup_fail:

    curl_easy_cleanup(curl);

    return HTTP_INTERNAL_SERVER_ERROR;

}

/* This function downloads data from a specified URI by issuing a POST

 * request.

 *

 * Parameters:

 *  request_rec *r             The apache request this download is

 *                             associated with. It is used for memory

 *                             allocation and logging.

 *  const char *uri            The URI we should post data to.

 *  const char *post_data      The POST data we should send.

 *  const char *content_type   The content type of the POST data. This

 *                             parameter can be NULL, in which case the

 *                             content type will be

 *                             "application/x-www-form-urlencoded".

 *  void **buffer              A pointer to where we should store a pointer

 *                             to the downloaded data. We will always add a

 *                             null-terminator to the data. This parameter

 *                             can't be NULL.

 *  apr_size_t *size           This is a pointer to where we will store the

 *                             length of the downloaded data, not including

 *                             the null-terminator we add. This parameter

 *                             can be NULL.

 *

 * Returns:

 *  OK on success. On failure we will write a log message describing the

 *  error, and return HTTP_INTERNAL_SERVER_ERROR.

 */

int am_httpclient_post_str(request_rec *r, const char *uri,

                           const char *post_data,

                           const char *content_type,

                           void **buffer, apr_size_t *size)

{

    return am_httpclient_post(r, uri, post_data, strlen(post_data),

                              content_type, buffer, size);

}