curlInterface.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2010 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "http_platform.h"

#include <assert.h>
#include <string.h>

#include <curl/curl.h>

#include <openssl/ssl.h>

#include "dvb_misc.h"
#include "stb_memory.h"
#include "stb_os.h"
#include "glue_debug.h"

/*---constant definitions for this file--------------------------------------*/

#define HTTP_IDLE_TIMEOUT      200   /* ms */
#define MAX_USER_AGENT         256

#define CHK_EASY(call)                          \
   {                                            \
      CURLcode code;                            \
      code = (call);                            \
      if (code != CURLE_OK)                     \
      {                                         \
         TRACE(TERROR, ("FAIL %s",#call))         \
         return FALSE;                          \
      }                                         \
   }

//#define HTTP_DEBUG
#ifdef HTTP_DEBUG
#define DBG_ENTRY(x) DBG_PRINTF(" >> %s\n", #x);
#define DBG_EXIT(x) DBG_PRINTF(" << %s\n", #x);
#else
#define DBG_ENTRY(x)
#define DBG_EXIT(x)
#endif


/*---local typedef structs for this file-------------------------------------*/
typedef struct
{
   size_t size;
   void *ptr;
} AllocInfo_t;

typedef struct HttpClientInfo_tag
{
   void *userdata;
   struct curl_slist *headers;
} *HttpClientInfo_t;

typedef struct HttpCertList_tag
{
   struct HttpCertList_tag *next;
   X509 *x509;
} *HttpCertList_t;


/*---local (static) variable declarations for this file----------------------*/
static CURLM *multi_handle = NULL;
static HttpCertList_t http_cert_list = NULL;
static void *ssl_mutex;

static char http_user_agent[MAX_USER_AGENT] = "";
static U16BIT http_timeout = 30;
static char curl_error_buffer[CURL_ERROR_SIZE];

/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/

static size_t httpWriteCallback(void *ptr, size_t size,
   size_t nmemb, void *handle);
static size_t httpHeaderCallback(void *ptr, size_t size,
   size_t nmemb, void *handle);
static void* httpParseCertificate(U8BIT *buffer, U16BIT length);
static CURLcode httpSslCtxFunction(CURL *curl, void *sslctx, void *parm);

E_HttpErr HP_Initialise(void)
{
   E_HttpErr err;

   DBG_ENTRY(HP_Initialise);

   ssl_mutex = STB_OSCreateMutex();

   multi_handle = curl_multi_init();
   if (multi_handle != NULL)
   {
      err = HTTP_OK;
   }
   else
   {
      err = HTTP_ERR_INTERNAL;
   }

   DBG_EXIT(HP_Initialise);

   return err;
}

E_HttpErr HP_SetUserAgent(U8BIT *user_agent)
{
   DBG_ENTRY(HP_SetUserAgent);

   strcpy(http_user_agent, (char *)user_agent);

   DBG_EXIT(HP_SetUserAgent);

   return HTTP_OK;
}

E_HttpErr HP_SetTimeout(U16BIT timeout)
{
   DBG_ENTRY(HP_SetTimeout);

   http_timeout = timeout;

   DBG_EXIT(HP_SetTimeout);

   return HTTP_OK;
}

E_HttpErr HP_CreateRequest(U8BIT *url, E_HttpRequestType type,
   void **handle)
{
   HttpClientInfo_t client_info;
   E_HttpErr err;

   DBG_ENTRY(HP_CreateRequest);

   if (handle != NULL)
   {
      *handle = curl_easy_init();
      if (*handle != NULL)
      {
         client_info = STB_MemAlloc(sizeof *client_info);
         if (client_info != NULL)
         {
            client_info->userdata = NULL;
            client_info->headers = NULL;

            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_URL, (U8BIT *)url));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_PRIVATE, client_info));

            if (http_user_agent[0] != '\0')
            {
               CHK_EASY(curl_easy_setopt(*handle, CURLOPT_USERAGENT,
                     http_user_agent));
            }

            curl_error_buffer[0] = 0;
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_ERRORBUFFER,
                  curl_error_buffer));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_WRITEFUNCTION,
                  httpWriteCallback));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_WRITEDATA, *handle));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_HEADERFUNCTION,
                  httpHeaderCallback));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_WRITEHEADER, *handle));

            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_HEADER, 0));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_NOPROGRESS, 1));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_HTTP_VERSION,
                  CURL_HTTP_VERSION_1_1));

            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_SSL_CTX_FUNCTION,
                  httpSslCtxFunction));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_SSL_CIPHER_LIST,
                  "aRSA:MD5:SHA:eNULL"));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_CAINFO, NULL));

            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_CONNECTTIMEOUT,
                  http_timeout));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_LOW_SPEED_LIMIT, 32));
            CHK_EASY(curl_easy_setopt(*handle, CURLOPT_LOW_SPEED_TIME,
                  http_timeout));

            switch (type)
            {
               case HTTP_REQUEST_GET:
                  CHK_EASY(curl_easy_setopt(*handle, CURLOPT_HTTPGET, 1));
                  break;
               case HTTP_REQUEST_HEAD:
                  CHK_EASY(curl_easy_setopt(*handle, CURLOPT_NOBODY, 1));
                  break;
               case HTTP_REQUEST_POST:
                  CHK_EASY(curl_easy_setopt(*handle, CURLOPT_POST, 1));
                  CHK_EASY(curl_easy_setopt(*handle, CURLOPT_POSTFIELDS, ""));
                  CHK_EASY(curl_easy_setopt(*handle, CURLOPT_POSTFIELDSIZE, 0));
                  break;
               case HTTP_REQUEST_STREAM:
                  CHK_EASY(curl_easy_setopt(*handle, CURLOPT_HTTPGET, 1));
                  break;
            }
         }
         else
         {
            curl_easy_cleanup(*handle);
            *handle = NULL;
         }
      }
      err = HTTP_OK;
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_CreateRequest);

   return err;
}

E_HttpErr HP_StartRequest(void *handle)
{
   void *private;
   HttpClientInfo_t client_info;
   CURLcode code;
   CURLMcode multi_code;
   E_HttpErr err;

   DBG_ENTRY(HP_StartRequest);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL)
   {
      code = CURLE_OK;

      /* Commit HTTP headers */
      curl_easy_getinfo(handle, CURLINFO_PRIVATE, &private);
      client_info = private;
      if (client_info->headers != NULL)
      {
         code = curl_easy_setopt(handle, CURLOPT_HTTPHEADER,
               client_info->headers);
      }

      if (code == CURLE_OK)
      {
         /* Add handle to multi handle */
         multi_code = curl_multi_add_handle(multi_handle, handle);
         if (multi_code == CURLM_OK)
         {
            err = HTTP_OK;
         }
         else
         {
            TRACE(TERROR,("curl_multi_add_handle %d",multi_code))
         }
      }
      else
      {
         TRACE(TERROR,("curl_easy_setopt d",code))
      }
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_StartRequest);

   return err;
}

E_HttpErr HP_ResumeRequest(void *handle)
{
   CURLcode code;
   U16BIT dummy;
   E_HttpErr err;

   DBG_ENTRY(HP_ResumeRequest);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL)
   {
      code = curl_easy_pause(handle, CURLPAUSE_CONT);
      if (code == CURLE_OK)
      {
         /* Continue the transfer */
         HP_Process(&dummy);
         err = HTTP_OK;
      }
      else
      {
         TRACE(TERROR,("CURL error %d",code))
      }
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_ResumeRequest);

   return err;
}

E_HttpErr HP_StopRequest(void *handle)
{
   CURLMcode multi_code;
   E_HttpErr err;

   DBG_ENTRY(HP_StopRequest);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL)
   {
      multi_code = curl_multi_remove_handle(multi_handle, handle);
      if (multi_code == CURLM_OK)
      {
         err = HTTP_OK;
      }
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_StopRequest);

   return err;
}

E_HttpErr HP_DestroyRequest(void *handle)
{
   void *private;
   HttpClientInfo_t client_info;
   E_HttpErr err;

   DBG_ENTRY(HP_DestroyRequest);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL)
   {
      /* Clear client information */
      curl_easy_getinfo(handle, CURLINFO_PRIVATE, &private);
      client_info = private;
      if (client_info->headers != NULL)
      {
         curl_easy_setopt(handle, CURLOPT_HTTPHEADER, NULL);
         curl_slist_free_all(client_info->headers);
         client_info->headers = NULL;
      }
      STB_MemFree(client_info);

      /* Clean curl handle */
      curl_easy_cleanup(handle);
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_DestroyRequest);

   return err;
}

E_HttpErr HP_SetUserData(void *handle, void *userdata)
{
   void *private;
   HttpClientInfo_t client_info;
   E_HttpErr err;

   DBG_ENTRY(HP_SetUserData);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL)
   {
      curl_easy_getinfo(handle, CURLINFO_PRIVATE, &private);
      client_info = private;
      client_info->userdata = userdata;
      err = HTTP_OK;
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_SetUserData);

   return err;
}

E_HttpErr HP_AddHeader(void *handle, U8BIT *header)
{
   void *private;
   HttpClientInfo_t client_info;
   E_HttpErr err;

   DBG_ENTRY(HP_AddHeader);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL && header != NULL)
   {
      curl_easy_getinfo(handle, CURLINFO_PRIVATE, &private);
      client_info = private;
      client_info->headers = curl_slist_append(client_info->headers,
            (char *)header);
      err = HTTP_OK;
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_AddHeader);

   return err;
}

E_HttpErr HP_SetPostData(void *handle, U8BIT *postdata)
{
   CURLcode code;
   E_HttpErr err;

   DBG_ENTRY(HP_SetPostData);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL && postdata != NULL)
   {
      code = curl_easy_setopt(handle, CURLOPT_POSTFIELDS, postdata);
      if (code == CURLE_OK)
      {
         code = curl_easy_setopt(handle, CURLOPT_POSTFIELDSIZE, -1);
         if (code == CURLE_OK)
         {
            err = HTTP_OK;
         }
      }
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_SetPostData);

   return err;
}

E_HttpErr HP_SetRange(void *handle, U8BIT *range)
{
   E_HttpErr err;

   DBG_ENTRY(HP_SetRange);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL && range != NULL)
   {
      CHK_EASY(curl_easy_setopt(handle, CURLOPT_RANGE, range));
      err = HTTP_OK;
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_SetRange);

   return err;
}

E_HttpErr HP_GetRedirectUrl(void *handle, U8BIT **url)
{
   CURLcode code;
   char *redir_url;
   E_HttpErr err;

   DBG_ENTRY(HP_GetRedirectUrl);

   err = HTTP_ERR_INTERNAL;

   if (handle != NULL && url != NULL)
   {
      code = curl_easy_getinfo(handle, CURLINFO_REDIRECT_URL, &redir_url);
      if (code == CURLE_OK)
      {
         *url = (U8BIT *)redir_url;
         err = HTTP_OK;
      }
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_GetRedirectUrl);

   return err;
}

E_HttpErr HP_AddTlsCertificate(U8BIT *cert, U32BIT len)
{
   HttpCertList_t *pcert, curr;
   E_HttpErr err;

   DBG_ENTRY(HP_AddTlsCertificate);

   err = HTTP_ERR_INTERNAL;

   if (cert != NULL && len > 0)
   {
      STB_OSMutexLock(ssl_mutex);
      pcert = &http_cert_list;
      while (*pcert != NULL)
      {
         pcert = &(*pcert)->next;
      }

      curr = STB_MemAlloc(sizeof *curr);
      if (curr != NULL)
      {
         curr->next = NULL;
         curr->x509 = httpParseCertificate(cert, len);
         if (curr->x509 != NULL)
         {
            /* Append certificate */
            *pcert = curr;
            err = HTTP_OK;
         }
         else
         {
            /* Cannot parse / create certificate */
            STB_MemFree(curr);
         }
      }
      STB_OSMutexUnlock(ssl_mutex);
   }
   else
   {
      err = HTTP_ERR_BAD_PARAMETER;
   }

   DBG_EXIT(HP_AddTlsCertificate);

   return err;
}

E_HttpErr HP_ClearTlsCertificates(void)
{
   HttpCertList_t *pcert, curr;

   DBG_ENTRY(HP_ClearTlsCertificates);

   STB_OSMutexLock(ssl_mutex);
   pcert = &http_cert_list;
   while (*pcert != NULL)
   {
      curr = *pcert;
      *pcert = (*pcert)->next;
      X509_free(curr->x509);
      STB_MemFree(curr);
   }
   STB_OSMutexUnlock(ssl_mutex);

   DBG_EXIT(HP_ClearTlsCertificates);

   return HTTP_OK;
}

E_HttpErr HP_WaitForAction(void)
{
   CURLMcode multi_code;
   fd_set readfds;
   fd_set writefds;
   fd_set exceptfds;
   int max_fd;
   struct timeval timeout;
   E_HttpErr err;

   DBG_ENTRY(HP_WaitForAction);

   err = HTTP_ERR_INTERNAL;

   /* Wait for activity on one or more sockets */
   FD_ZERO(&readfds);
   FD_ZERO(&writefds);
   FD_ZERO(&exceptfds);

   multi_code = curl_multi_fdset(multi_handle, &readfds, &writefds,
         &exceptfds, &max_fd);
   if (multi_code == CURLM_OK)
   {
      if (max_fd >= 0)
      {
         timeout.tv_sec = 0;
         timeout.tv_usec = HTTP_IDLE_TIMEOUT * 1000;
         select(max_fd + 1, &readfds, &writefds, &exceptfds, &timeout);
      }
      err = HTTP_OK;
   }

   DBG_EXIT(HP_WaitForAction);

   return err;
}

E_HttpErr HP_Process(U16BIT *active_count)
{
   int running_handles;
   CURLMcode multi_code;
   CURLMsg *multi_msg;
   int msgs_in_queue;
   void *private;
   HttpClientInfo_t client_info;
   E_HttpStatus status;
   E_HttpErr err;

   DBG_ENTRY(HP_Process);

   err = HTTP_ERR_INTERNAL;

   do
   {
      multi_code = curl_multi_perform(multi_handle, &running_handles);
      STB_OSTaskDelay(1);
   }
   while (multi_code == CURLM_CALL_MULTI_PERFORM);

   if (multi_code == CURLM_OK)
   {
      do
      {
         multi_msg = curl_multi_info_read(multi_handle, &msgs_in_queue);
         if (multi_msg != NULL)
         {
            if (multi_msg->msg == CURLMSG_DONE)
            {
               curl_easy_getinfo(multi_msg->easy_handle,
                  CURLINFO_PRIVATE, &private);
               client_info = private;
               switch (multi_msg->data.result)
               {
                  case CURLE_OK:
                     status = HTTP_STATUS_OK;
                     break;
                  case CURLE_PARTIAL_FILE:
                     status = HTTP_STATUS_PARTIAL;
                     break;
                  case CURLE_SSL_CACERT:
                     status = HTTP_STATUS_SSL_ERROR;
                     break;
                  case CURLE_COULDNT_RESOLVE_PROXY:
                  case CURLE_COULDNT_RESOLVE_HOST:
                  case CURLE_COULDNT_CONNECT:
                     status = HTTP_STATUS_NETWORK_ERROR;
                     break;
                  case CURLE_OPERATION_TIMEDOUT:
                     status = HTTP_STATUS_TIMEOUT;
                     break;
                  default:
                     status = HTTP_STATUS_OTHER_ERROR;
                     TRACE(TERROR,("error buffer=%s",curl_error_buffer));
               }
               TRACE(TICS, ("ud=%p status=%u rslt=%u", client_info->userdata, status, multi_msg->data.result));
               HP_EndCallback(client_info->userdata, status);
            }
            else
            {
               TRACE(TERROR,("multi_msg->msg = %d\n", multi_msg->msg));
            }
         }
      }
      while (multi_msg != NULL);

      err = HTTP_OK;
   }
   else
   {
      TRACE(TERROR,("curl error %s", curl_multi_strerror(multi_code)));
   }

   *active_count = running_handles;

   DBG_EXIT(HP_Process);

   return err;
}

E_HttpErr HP_Terminate(void)
{
   DBG_ENTRY(HP_Terminate);

   if (multi_handle != NULL)
   {
      curl_multi_cleanup(multi_handle);
      multi_handle = NULL;
   }

   curl_global_cleanup();

   STB_OSDeleteMutex(ssl_mutex);

   DBG_EXIT(HP_Terminate);

   return HTTP_OK;
}

static size_t httpHeaderCallback(void *ptr, size_t size,
   size_t nmemb, void *handle)
{
   long response_code;
   void *private;
   HttpClientInfo_t client_info;

   DBG_ENTRY(httpHeaderCallback);

   curl_easy_getinfo(handle, CURLINFO_PRIVATE, &private);
   curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &response_code);

   client_info = private;
   TRACE(TICS, ("itm size=%u num=%u ptr=%p", size, nmemb, ptr));
   HP_HeaderCallback(client_info->userdata, response_code,
      ptr, size * nmemb);

   DBG_EXIT(httpHeaderCallback);

   return size * nmemb;
}

static size_t httpWriteCallback(void *ptr, size_t size,
   size_t nmemb, void *handle)
{
   size_t retval;
   BOOLEAN processed;
   void *private;
   HttpClientInfo_t client_info;

   DBG_ENTRY(httpWriteCallback);

   retval = size * nmemb;

   curl_easy_getinfo(handle, CURLINFO_PRIVATE, &private);
   client_info = private;
   TRACE(TICS, ("itm size=%u num=%u ptr=%p", size, nmemb, ptr));
   processed = HP_ContentCallback(client_info->userdata, ptr, size * nmemb);
   if (!processed)
   {
      /* Pause the connection */
      retval = CURL_WRITEFUNC_PAUSE;
   }

   DBG_EXIT(httpWriteCallback);

   return retval;
}

static void* httpParseCertificate(U8BIT *buffer, U16BIT length)
{
   BIO *bio;
   X509 *x509;
   void *cert;

   DBG_ENTRY(httpParseCertificate);

   cert = NULL;

   bio = BIO_new_mem_buf(buffer, length);
   if (bio != NULL)
   {
      x509 = d2i_X509_bio(bio, NULL);
      if (x509 != NULL)
      {
         cert = x509;
      }
      BIO_free(bio);
   }

   DBG_EXIT(httpParseCertificate);

   return cert;
}

static CURLcode httpSslCtxFunction(CURL *curl, void *sslctx, void *parm)
{
   SSL_CTX *ssl_ctx = sslctx;
   X509_STORE *x509_store;
   HttpCertList_t curr;
   X509_VERIFY_PARAM *param;
   S_DateTime date_time;
   struct tm tmstruct;
   time_t current_time;
   CURLcode rc;

   DBG_ENTRY(sslCtxFunction);

   rc = CURLE_OK;
   x509_store = SSL_CTX_get_cert_store(ssl_ctx);
   if (x509_store != NULL)
   {
      /* Setup certificate store */
      STB_OSMutexLock(ssl_mutex);

      curr = http_cert_list;
      while (curr != NULL)
      {
         if (X509_STORE_add_cert(x509_store, curr->x509) == 0)
         {
            TRACE(TERROR,("failed to ADD cert"));
            rc = CURLE_SSL_CERTPROBLEM;
            break;
         }
         curr = curr->next;
      }

      if (rc == CURLE_OK)
      {
         /* Set date for certificate varification */
         param = X509_VERIFY_PARAM_new();
         if (param != NULL)
         {
            DVB_MhegGetLocalTime(&date_time);
            tmstruct.tm_sec = date_time.second;
            tmstruct.tm_min = date_time.minute;
            tmstruct.tm_hour = date_time.hour;
            tmstruct.tm_mday = date_time.day;
            tmstruct.tm_mon = date_time.month - 1;
            tmstruct.tm_year = date_time.year - 1900;
            tmstruct.tm_isdst = 0;
            current_time = mktime(&tmstruct);
            X509_VERIFY_PARAM_set_time(param, current_time);
            X509_STORE_set1_param(x509_store, param);
            X509_VERIFY_PARAM_free(param);
         }
      }

      STB_OSMutexUnlock(ssl_mutex);
   }
   else
   {
      TRACE(TERROR,("failed to GET cert"));
      rc = CURLE_SSL_CERTPROBLEM;
   }
   TRACE(TICS, ("rc=%d", rc));
   DBG_EXIT(sslCtxFunction);

   return rc;
}