CMake/Utilities/cmxmlrpc/xmlrpc_curl_transport.c

/*=============================================================================
                           xmlrpc_curl_transport
===============================================================================
   Curl-based client transport for Xmlrpc-c

   By Bryan Henderson 04.12.10.

   Contributed to the public domain by its author.
=============================================================================*/

#include "xmlrpc_config.h"

#if defined(__BEOS__)
/* Some helpful system header has char==bool, then bool.h does int==bool. */
#define HAVE_BOOL 1
#endif

#include "bool.h"
#include "mallocvar.h"
#include "linklist.h"
#include "casprintf.h"
#include "xmlrpc.h"
#include "xmlrpc_int.h"
#include "xmlrpc_client.h"
#include "xmlrpc_client_int.h"

#include <string.h>
#include <stdlib.h>
#include <errno.h>

#if defined(HAVE_PTHREADS)
#  include "xmlrpc_pthreads.h"
#endif

#include <cmcurl/curl/curl.h>
#include <cmcurl/curl/types.h>
#include <cmcurl/curl/easy.h>

#ifndef WIN32
#  include <unistd.h>
#endif

#if defined (WIN32) && defined(_DEBUG)
#  include <crtdbg.h>
#  define new DEBUG_NEW
#  define malloc(size) _malloc_dbg( size, _NORMAL_BLOCK, __FILE__, __LINE__)
#  undef THIS_FILE
   static char THIS_FILE[] = __FILE__;
#endif /*WIN32 && _DEBUG*/

static void xmlrpc_abort(void)
{
  abort();
}

struct clientTransport {
#if defined (HAVE_PTHREADS)
    pthread_mutex_t listLock;
#endif
    struct list_head rpcList;
        /* List of all RPCs that exist for this transport.  An RPC exists
           from the time the user requests it until the time the user 
           acknowledges it is done.
        */
};

typedef struct {
    /* This is all stuff that really ought to be in the CURL object,
       but the Curl library is a little too simple for that.  So we
       build a layer on top of it, and call it a "transaction," as
       distinct from the Curl "session" represented by the CURL object.
    */
    CURL * curlSessionP;
        /* Handle for Curl library session object */
    char curlError[CURL_ERROR_SIZE];
        /* Error message from Curl */
    struct curl_slist * headerList;
        /* The HTTP headers for the transaction */
    const char * serverUrl;  /* malloc'ed - belongs to this object */
} curlTransaction;



typedef struct {
    struct list_head link;  /* link in transport's list of RPCs */
    curlTransaction * curlTransactionP;
        /* The object which does the HTTP transaction, with no knowledge
           of XML-RPC or Xmlrpc-c.
        */
    xmlrpc_mem_block * responseXmlP;
    xmlrpc_bool threadExists;
#if defined(HAVE_PTHREADS)
    pthread_t thread;
#endif
    transport_asynch_complete complete;
        /* Routine to call to complete the RPC after it is complete HTTP-wise.
           NULL if none.
        */
    struct call_info * callInfoP;
        /* User's identifier for this RPC */
} rpc;



static size_t 
collect(void *  const ptr, 
        size_t  const size, 
        size_t  const nmemb,  
        FILE  * const stream) {
/*----------------------------------------------------------------------------
   This is a Curl output function.  Curl calls this to deliver the
   HTTP response body.  Curl thinks it's writing to a POSIX stream.
-----------------------------------------------------------------------------*/
    xmlrpc_mem_block * const responseXmlP = (xmlrpc_mem_block *) stream;
    char * const buffer = ptr;
    size_t const length = nmemb * size;

    size_t retval;
    xmlrpc_env env;

    xmlrpc_env_init(&env);
    xmlrpc_mem_block_append(&env, responseXmlP, buffer, length);
    if (env.fault_occurred)
        retval = (size_t)-1;
    else
        /* Really?  Shouldn't it be like fread() and return 'nmemb'? */
        retval = length;
    
    return retval;
}



static void
initWindowsStuff(xmlrpc_env * const envP) {

#if defined (WIN32)
    /* This is CRITICAL so that cURL-Win32 works properly! */
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
    wVersionRequested = MAKEWORD(1, 1);
    
    err = WSAStartup(wVersionRequested, &wsaData);
    (void)err;
    if (LOBYTE(wsaData.wVersion) != 1 || 
        HIBYTE( wsaData.wVersion) != 1) {
        /* Tell the user that we couldn't find a useable */ 
        /* winsock.dll. */ 
        WSACleanup();
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, "Winsock reported that "
            "it does not implement the requested version 1.1.");
    }
#else
    if (0)
        envP->fault_occurred = TRUE;  /* Avoid unused parm warning */
#endif
}


static void 
create(xmlrpc_env *              const envP,
       int                       const flags ATTR_UNUSED,
       const char *              const appname ATTR_UNUSED,
       const char *              const appversion ATTR_UNUSED,
       struct clientTransport ** const handlePP) {
/*----------------------------------------------------------------------------
   This does the 'create' operation for a Curl client transport.
-----------------------------------------------------------------------------*/
    struct clientTransport * transportP;

    initWindowsStuff(envP);

    MALLOCVAR(transportP);
    if (transportP == NULL)
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "Unable to allocate transport descriptor.");
    else {
#ifdef HAVE_PTHREADS
        pthread_mutex_init(&transportP->listLock, NULL);
#endif
        
        list_make_empty(&transportP->rpcList);

        /*
         * This is the main global constructor for the app. Call this before
         * _any_ libcurl usage. If this fails, *NO* libcurl functions may be
         * used, or havoc may be the result.
         */
        curl_global_init(CURL_GLOBAL_ALL);

        /* The above makes it look like Curl is not re-entrant.  We should
           check into that.
        */

        *handlePP = transportP;
    }
}


static void
termWindowStuff(void) {

#if defined (WIN32)
    WSACleanup();
#endif
}



static void 
destroy(struct clientTransport * const clientTransportP) {
/*----------------------------------------------------------------------------
   This does the 'destroy' operation for a Libwww client transport.
-----------------------------------------------------------------------------*/
    XMLRPC_ASSERT(clientTransportP != NULL);

    XMLRPC_ASSERT(list_is_empty(&clientTransportP->rpcList));

#if defined(HAVE_PTHREADS)
    pthread_mutex_destroy(&clientTransportP->listLock);
#endif

    curl_global_cleanup();

    termWindowStuff();

    free(clientTransportP);
}



static void
createCurlHeaderList(xmlrpc_env *         const envP,
                     xmlrpc_server_info * const serverP,
                     struct curl_slist ** const headerListP) {

    struct curl_slist * headerList;

    headerList = NULL;  /* initial value */

    headerList = curl_slist_append(headerList, "Content-Type: text/xml");

    if (headerList == NULL)
        xmlrpc_env_set_fault_formatted(
                envP, XMLRPC_INTERNAL_ERROR, 
                "Could not add header.  curl_slist_append() failed.");
    else {
        /* Send an authorization header if we need one. */
        if (serverP->_http_basic_auth) {
            /* Make the authentication header "Authorization: " */
            /* we need 15 + length of _http_basic_auth + 1 for null */

            char * const authHeader = 
                malloc(strlen(serverP->_http_basic_auth) + 15 + 1);
            
            if (authHeader == NULL)
                xmlrpc_env_set_fault_formatted(
                    envP, XMLRPC_INTERNAL_ERROR,
                    "Couldn't allocate memory for authentication header");
            else {
                memcpy(authHeader,"Authorization: ", 15);
                memcpy(authHeader + 15, serverP->_http_basic_auth,
                       strlen(serverP->_http_basic_auth) + 1);

                headerList = curl_slist_append(headerList, authHeader);
                if (headerList == NULL)
                    xmlrpc_env_set_fault_formatted(
                        envP, XMLRPC_INTERNAL_ERROR,
                        "Could not add authentication header.  "
                        "curl_slist_append() failed.");
                free(authHeader);
            }
        }
        if (envP->fault_occurred)
            free(headerList);
    }
    *headerListP = headerList;
}



static void
setupCurlSession(xmlrpc_env *       const envP,
                 CURL *             const curlSessionP,
                 curlTransaction *  const curlTransactionP,
                 xmlrpc_mem_block * const callXmlP,
                 xmlrpc_mem_block * const responseXmlP) {

  static char proxy[1024];
  static char proxyUser[1024];
  int proxy_type = 0;

  if ( getenv("HTTP_PROXY") )
    {
    proxy_type = 1;
    if (getenv("HTTP_PROXY_PORT") )
      {
      sprintf(proxy, "%s:%s", getenv("HTTP_PROXY"), getenv("HTTP_PROXY_PORT"));
      }
    else
      {
      sprintf(proxy, "%s", getenv("HTTP_PROXY"));
      }
    if ( getenv("HTTP_PROXY_TYPE") )
      {
      /* HTTP/SOCKS4/SOCKS5 */
      if ( strcmp(getenv("HTTP_PROXY_TYPE"), "HTTP") == 0 )
        {
        proxy_type = 1;
        }
      else if ( strcmp(getenv("HTTP_PROXY_TYPE"), "SOCKS4") == 0 )
        {
        proxy_type = 2;
        }
      else if ( strcmp(getenv("HTTP_PROXY_TYPE"), "SOCKS5") == 0 )
        {
        proxy_type = 3;
        }
      }
    if ( getenv("HTTP_PROXY_USER") )
      {
      strcpy(proxyUser, getenv("HTTP_PROXY_USER"));
      }
    if ( getenv("HTTP_PROXY_PASSWD") )
      {
      strcat(proxyUser, ":");
      strcat(proxyUser, getenv("HTTP_PROXY_PASSWD"));
      }
    }
    /* Using proxy */
    if ( proxy_type > 0 )
      {
      curl_easy_setopt(curlSessionP, CURLOPT_PROXY, proxy); 
      switch (proxy_type)
        {
      case 2:
        curl_easy_setopt(curlSessionP, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
        break;
      case 3:
        curl_easy_setopt(curlSessionP, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
        break;
      default:
        curl_easy_setopt(curlSessionP, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);           
        if (*proxyUser)
          {
          curl_easy_setopt(curlSessionP, CURLOPT_PROXYUSERPWD, proxyUser);
          }
        }
      }

    curl_easy_setopt(curlSessionP, CURLOPT_POST, 1 );
    curl_easy_setopt(curlSessionP, CURLOPT_URL, curlTransactionP->serverUrl);
    XMLRPC_MEMBLOCK_APPEND(char, envP, callXmlP, "\0", 1);
    if (!envP->fault_occurred) {
        curl_easy_setopt(curlSessionP, CURLOPT_POSTFIELDS, 
                         XMLRPC_MEMBLOCK_CONTENTS(char, callXmlP));
        
        curl_easy_setopt(curlSessionP, CURLOPT_FILE, responseXmlP);
        curl_easy_setopt(curlSessionP, CURLOPT_HEADER, 0 );
        curl_easy_setopt(curlSessionP, CURLOPT_WRITEFUNCTION, collect);
        curl_easy_setopt(curlSessionP, CURLOPT_ERRORBUFFER, 
                         curlTransactionP->curlError);
        curl_easy_setopt(curlSessionP, CURLOPT_NOPROGRESS, 1);
        
        curl_easy_setopt(curlSessionP, CURLOPT_HTTPHEADER, 
                         curlTransactionP->headerList);
    }
}



static void
createCurlTransaction(xmlrpc_env *         const envP,
                      xmlrpc_server_info * const serverP,
                      xmlrpc_mem_block *   const callXmlP,
                      xmlrpc_mem_block *   const responseXmlP,
                      curlTransaction **   const curlTransactionPP) {

    curlTransaction * curlTransactionP;

    MALLOCVAR(curlTransactionP);
    if (curlTransactionP == NULL)
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR,
            "No memory to create Curl transaction.");
    else {
        CURL * const curlSessionP = curl_easy_init();
    
        if (curlSessionP == NULL)
            xmlrpc_env_set_fault_formatted(
                envP, XMLRPC_INTERNAL_ERROR,
                "Could not create Curl session.  curl_easy_init() failed.");
        else {
            curlTransactionP->curlSessionP = curlSessionP;

            curlTransactionP->serverUrl = strdup(serverP->_server_url);
            if (curlTransactionP->serverUrl == NULL)
                xmlrpc_env_set_fault_formatted(
                    envP, XMLRPC_INTERNAL_ERROR,
                    "Out of memory to store server URL.");
            else {
                createCurlHeaderList(envP, serverP, 
                                     &curlTransactionP->headerList);

                if (!envP->fault_occurred)
                    setupCurlSession(envP, curlSessionP, curlTransactionP,
                                     callXmlP, responseXmlP);

                if (envP->fault_occurred)
                    strfree(curlTransactionP->serverUrl);
            }
            if (envP->fault_occurred)
                curl_easy_cleanup(curlSessionP);
        }
        if (envP->fault_occurred)
            free(curlTransactionP);
    }
    *curlTransactionPP = curlTransactionP;
}



static void
destroyCurlTransaction(curlTransaction * const curlTransactionP) {

    curl_slist_free_all(curlTransactionP->headerList);
    strfree(curlTransactionP->serverUrl);
    curl_easy_cleanup(curlTransactionP->curlSessionP);
    free(curlTransactionP);
}


static void
performCurlTransaction(xmlrpc_env *      const envP,
                       curlTransaction * const curlTransactionP) {

    CURL * const curlSessionP = curlTransactionP->curlSessionP;

    CURLcode res;

    res = curl_easy_perform(curlSessionP);
    
    if (res != CURLE_OK)
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_NETWORK_ERROR, "Curl failed to perform "
            "HTTP POST request.  curl_easy_perform() says: %s (%d)", 
            curlTransactionP->curlError, res);
    else {
        CURLcode crRes;
        long http_result;
        crRes = curl_easy_getinfo(curlSessionP, CURLINFO_HTTP_CODE, 
                                &http_result);

        if (crRes != CURLE_OK)
            xmlrpc_env_set_fault_formatted(
                envP, XMLRPC_INTERNAL_ERROR, 
                "Curl performed the HTTP POST request, but was "
                "unable to say what the HTTP result code was.  "
                "curl_easy_getinfo(CURLINFO_HTTP_CODE) says: %s", 
                curlTransactionP->curlError);
        else {
            if (http_result != 200)
                xmlrpc_env_set_fault_formatted(
                    envP, XMLRPC_NETWORK_ERROR, "HTTP response: %ld",
                    http_result);
        }
    }
}


#if defined(HAVE_PTHREADS)

static void
doAsyncRpc2(void * const arg) {

    rpc * const rpcP = arg;

    xmlrpc_env env;

    xmlrpc_env_init(&env);

    performCurlTransaction(&env, rpcP->curlTransactionP);

    rpcP->complete(rpcP->callInfoP, rpcP->responseXmlP, env);

    xmlrpc_env_clean(&env);
}



#ifdef WIN32

static unsigned __stdcall 
doAsyncRpc(void * arg) {
    doAsyncRpc2(arg);
    return 0;
}

#else

static void *
doAsyncRpc(void * arg) {
    doAsyncRpc2(arg);
    return NULL;
}

#endif


static void
createRpcThread(xmlrpc_env *              const envP,
                rpc *                     const rpcP,
                pthread_t *               const threadP) {

    int rc;

    rc = pthread_create(threadP, NULL, doAsyncRpc, rpcP);
    switch (rc) {
    case 0: 
        break;
    case EAGAIN:
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "pthread_create() failed:  System Resources exceeded.");
        break;
    case EINVAL:
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "pthread_create() failed:  Param Error for attr.");
        break;
    case ENOMEM:
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "pthread_create() failed:  No memory for new thread.");
        break;
    default:
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR, 
            "pthread_create() failed: Unrecognized error code %d.", rc);
        break;
    }
}
#endif



static void
rpcCreate(xmlrpc_env *             const envP,
          struct clientTransport * const clientTransportP,
          xmlrpc_server_info *     const serverP,
          xmlrpc_mem_block *       const callXmlP,
          xmlrpc_mem_block *       const responseXmlP,
          transport_asynch_complete      complete, 
          struct call_info *       const callInfoP,
          rpc **                   const rpcPP) {

    rpc * rpcP;

    MALLOCVAR(rpcP);
    if (rpcP == NULL)
        xmlrpc_env_set_fault_formatted(
            envP, XMLRPC_INTERNAL_ERROR,
            "Couldn't allocate memory for rpc object");
    else {
        rpcP->callInfoP = callInfoP;
        rpcP->complete  = complete;
        rpcP->responseXmlP = responseXmlP;
        rpcP->threadExists = FALSE;

        createCurlTransaction(envP, serverP,
                              callXmlP, responseXmlP, 
                              &rpcP->curlTransactionP);
        if (!envP->fault_occurred) {
            if (complete) {
#if defined(HAVE_PTHREADS)
                createRpcThread(envP, rpcP, &rpcP->thread);
#else 
                xmlrpc_abort();
#endif
                if (!envP->fault_occurred)
                    rpcP->threadExists = TRUE;
            }
            if (!envP->fault_occurred) {
                list_init_header(&rpcP->link, rpcP);
#if defined(HAVE_PTHREADS)
                pthread_mutex_lock(&clientTransportP->listLock);
#endif
                list_add_head(&clientTransportP->rpcList, &rpcP->link);
#if defined(HAVE_PTHREADS)
                pthread_mutex_unlock(&clientTransportP->listLock);
#endif
            }
            if (envP->fault_occurred)
                    destroyCurlTransaction(rpcP->curlTransactionP);
        }
        if (envP->fault_occurred)
          {
          free(rpcP);
          rpcP = 0; /* set this to null as it is used later on */
          }
    }
    *rpcPP = rpcP;
}


static void 
rpcDestroy(rpc * const rpcP) {

    XMLRPC_ASSERT_PTR_OK(rpcP);
    XMLRPC_ASSERT(!rpcP->threadExists);

    destroyCurlTransaction(rpcP->curlTransactionP);

    list_remove(&rpcP->link);

    free(rpcP);
}


static void 
sendRequest(xmlrpc_env *             const envP, 
            struct clientTransport * const clientTransportP,
            xmlrpc_server_info *     const serverP,
            xmlrpc_mem_block *       const callXmlP,
            transport_asynch_complete      complete,
            struct call_info *       const callInfoP) {
/*----------------------------------------------------------------------------
   Initiate an XML-RPC rpc asynchronously.  Don't wait for it to go to
   the server.

   Unless we return failure, we arrange to have complete() called when
   the rpc completes.

   This does the 'send_request' operation for a Curl client transport.
-----------------------------------------------------------------------------*/
    rpc * rpcP;
    xmlrpc_mem_block * responseXmlP;

    responseXmlP = XMLRPC_MEMBLOCK_NEW(char, envP, 0);
    if (!envP->fault_occurred) {
        rpcCreate(envP, clientTransportP, serverP, callXmlP, responseXmlP,
                  complete, callInfoP,
                  &rpcP);

        if (envP->fault_occurred)
            XMLRPC_MEMBLOCK_FREE(char, responseXmlP);
    }
    /* The user's eventual finish_asynch call will destroy this RPC
       and response buffer
    */
}



static void * 
finishRpc(struct list_head * const headerP, 
          void *             const context ATTR_UNUSED) {
    
    rpc * const rpcP = headerP->itemP;

    if (rpcP->threadExists) {
#if defined(HAVE_PTHREADS)
        void *status;
        int result;

        result = pthread_join(rpcP->thread, &status);
        (void)result;
#else
        xmlrpc_abort();
#endif
        
        rpcP->threadExists = FALSE;
    }

    XMLRPC_MEMBLOCK_FREE(char, rpcP->responseXmlP);

    rpcDestroy(rpcP);

    return NULL;
}



static void 
finishAsynch(struct clientTransport * const clientTransportP ATTR_UNUSED,
             enum timeoutType         const timeoutType ATTR_UNUSED,
             timeout_t                const timeout ATTR_UNUSED) {
/*----------------------------------------------------------------------------
   Wait for the threads of all outstanding RPCs to exit and destroy those
   RPCs.

   This does the 'finish_asynch' operation for a Curl client transport.
-----------------------------------------------------------------------------*/
    /* We ignore any timeout request.  Some day, we should figure out how
       to set an alarm and interrupt running threads.
    */

#if defined(HAVE_PTHREADS)
    pthread_mutex_lock(&clientTransportP->listLock);
#else
    xmlrpc_abort();
#endif

    list_foreach(&clientTransportP->rpcList, finishRpc, NULL);

#if defined(HAVE_PTHREADS)
    pthread_mutex_unlock(&clientTransportP->listLock);
#else
    xmlrpc_abort();
#endif
}



static void
call(xmlrpc_env *             const envP,
     struct clientTransport * const clientTransportP,
     xmlrpc_server_info *     const serverP,
     xmlrpc_mem_block *       const callXmlP,
     struct call_info *       const callInfoP,
     xmlrpc_mem_block **      const responsePP) {

    xmlrpc_mem_block * responseXmlP;
    rpc * rpcP;

    XMLRPC_ASSERT_ENV_OK(envP);
    XMLRPC_ASSERT_PTR_OK(serverP);
    XMLRPC_ASSERT_PTR_OK(callXmlP);
    XMLRPC_ASSERT_PTR_OK(callInfoP);
    XMLRPC_ASSERT_PTR_OK(responsePP);

    responseXmlP = XMLRPC_MEMBLOCK_NEW(char, envP, 0);
    if (!envP->fault_occurred) {
        rpcCreate(envP, clientTransportP, serverP, callXmlP, responseXmlP,
                  NULL, NULL, &rpcP);
        if (!envP->fault_occurred) {
            performCurlTransaction(envP, rpcP->curlTransactionP);
            
            *responsePP = responseXmlP;
            
            rpcDestroy(rpcP);
        }
        if (envP->fault_occurred)
            XMLRPC_MEMBLOCK_FREE(char, responseXmlP);
    }
}



struct clientTransportOps xmlrpc_curl_transport_ops = {
    &create,
    &destroy,
    &sendRequest,
    &call,
    &finishAsynch,
};