http_interface.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2009 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
 *******************************************************************************/
#if defined(INCLUDE_IC)

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

#include "mh5support.h"
#include "http_platform.h"
#include "http_interface.h"
#include "glue_memory.h"
#include "glue_debug.h"

#include "dvb_misc.h"
#include "stb_os.h"

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

#ifndef HTTP_STACK_SIZE
#define HTTP_STACK_SIZE 4096
#endif

#ifndef HTTP_TIMEOUT
#define HTTP_TIMEOUT 45
#endif

#define HTTP_QUEUE_SIZE 512
#define HTTP_FAILURE_TIMEOUT   500   /* ms */
#define REQUEST_START_TIMEOUT  500   /* ms */
#define HTTP_IDLE_TIMEOUT      200   /* ms */
#define MAX_RANGE_LEN          255

//#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

#define MAX_USER_AGENT         256


/*---local typedef structs for this file-------------------------------------*/

typedef enum HttpRequestCmd_tag
{
   HTTP_REQUEST_ADD,
   HTTP_REQUEST_RESUME,
   HTTP_REQUEST_REMOVE,
   HTTP_REQUEST_NONE
} HttpRequestCmd_t;

struct HttpRequest_tag
{
   struct HttpRequest_tag *next;
   HttpCallback_t header_cb;
   HttpCallback_t callback;
   U32BIT request_id;
   S32BIT response_code;
   U8BIT *url;
   void *userdata;
   U8BIT *postdata;
   U32BIT postdata_len;
   U8BIT range[MAX_RANGE_LEN];
   BOOLEAN processing;
   void *handle;
};

typedef struct HttpTaskCmd_tag
{
   HttpRequest_t request;
   HttpRequestCmd_t kind;
} HttpTaskCmd;

enum HttpTaskStatus_t
{
   HTTP_TASK_STOPPED,
   HTTP_TASK_RUNNING,
   HTTP_TASK_STOP_REQUEST
};


/*---local (static) variable declarations for this file----------------------*/
/* HTTP task related */
static void *http_task_handle = NULL;
static enum HttpTaskStatus_t http_task_status = HTTP_TASK_STOPPED;
static void *http_task_semaphore = NULL;
static void *http_task_mutex = NULL;
static void *http_task_queue = NULL;

static HttpRequest_t http_request_list = NULL;
static U32BIT http_cert_count = 0;
static U8BIT http_user_agent[MAX_USER_AGENT + 1] = { 0 };

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

/*---global function definitions---------------------------------------------*/
static void httpSetRequestUrl(U8BIT *requrl, U8BIT *url);
static void httpSetupCache(HttpRequest_t request, U8BIT cachePriority);
static BOOLEAN httpStartTask(U32BIT taskPriority);
static void httpStopTask(void);
static void httpTaskMain(void *task_arg);
static void httpAddRequest(HttpRequest_t request);
static void httpContinueRequest(HttpRequest_t request);
static void httpRemoveRequest(HttpRequest_t request);
static U16BIT httpProcessRequests(void);
static BOOLEAN httpIsValidRequest(HttpRequest_t request);

#ifdef DEBUG_LIST
static void httpPrintRequestList(void);
#endif

static void httpCookieParse(void *data, U32BIT data_len, char *url);
static U8BIT* httpCookieGenerateHeader(U8BIT *url);
static void httpCookieAckHeader(U8BIT *header);

static HttpCookieManager_t cookie_manager = {
   httpCookieParse,
   httpCookieGenerateHeader,
   httpCookieAckHeader
};


E_HttpErr httpOpen(U32BIT task_priority)
{
   E_HttpErr err;
   BOOLEAN success;

   DBG_ENTRY(httpOpen);

   if (http_task_semaphore != NULL)
   {
      err = HTTP_OK;
   }
   else
   {
      http_task_semaphore = STB_OSCreateSemaphore();
      if (http_task_semaphore == NULL)
      {
         err = HTTP_ERR_INTERNAL;
      }
      else
      {
         /* Initial value for semaphore is 1, so do wait to decrement value to 0 */
         STB_OSSemaphoreWait(http_task_semaphore);
         http_task_mutex = STB_OSCreateMutex();
         if (http_task_mutex == NULL)
         {
            err = HTTP_ERR_INTERNAL;
            STB_OSDeleteSemaphore(http_task_semaphore);
            http_task_semaphore = NULL;
         }
         else
         {
            http_task_queue = STB_OSCreateQueue(sizeof(HttpTaskCmd), HTTP_QUEUE_SIZE);
            if (http_task_queue == NULL)
            {
               err = HTTP_ERR_INTERNAL;
               STB_OSDeleteMutex(http_task_mutex);
               http_task_mutex = NULL;
               STB_OSDeleteSemaphore(http_task_semaphore);
               http_task_semaphore = NULL;
            }
            else
            {
               err = HP_Initialise();
               if (err == HTTP_OK)
               {
                  TRACE(TFILE,("Set timeout"));
                  HP_SetTimeout(HTTP_TIMEOUT);
                  success = httpStartTask(task_priority);
                  if (!success)
                  {
                     TRACE(TERROR,("Start task failed"));
                     HP_Terminate();
                     STB_OSDestroyQueue(http_task_queue);
                     http_task_queue = NULL;
                     STB_OSDeleteMutex(http_task_mutex);
                     http_task_mutex = NULL;
                     STB_OSDeleteSemaphore(http_task_semaphore);
                     http_task_semaphore = NULL;
                     err = HTTP_ERR_INTERNAL;
                  }
               }
               else
               {
                  TRACE(TERROR,("Init failed err=%d",err));
               }
            }
         }
      }
   }

   DBG_EXIT(httpOpen);

   return err;
}

void httpSetCookieManager(HttpCookieManager_t *manager)
{
   if (manager != NULL)
   {
      cookie_manager = *manager;
   }
   else
   {
      /* Reset to defaults */
      cookie_manager.parse = httpCookieParse;
      cookie_manager.generate_header = httpCookieGenerateHeader;
      cookie_manager.ack_header = httpCookieAckHeader;
   }
}

void httpSetUserAgent(U8BIT *user_agent)
{
   size_t len;

   len = strlen((char *)user_agent);
   if (len > MAX_USER_AGENT)
   {
      len = MAX_USER_AGENT;
   }
   memcpy(http_user_agent, user_agent, len);
   http_user_agent[len] = '\0';
   HP_SetUserAgent(http_user_agent);
}

void httpClearTlsCertStore(void)
{
   DBG_ENTRY(httpClearTlsCertStore);

   HP_ClearTlsCertificates();
   http_cert_count = 0;

   DBG_EXIT(httpClearTlsCertStore);
}

void httpAddTlsCertToStore(U8BIT *certData, U32BIT certLen)
{
   E_HttpErr err;

   DBG_ENTRY(httpAddTlsCertToStore);

   err = HP_AddTlsCertificate(certData, certLen);
   if (err == HTTP_OK)
   {
      http_cert_count++;
   }

   DBG_EXIT(httpAddTlsCertToStore);
}

U32BIT httpGetTlsCertStoreCount(void)
{
   DBG_ENTRY(httpGetTlsCertStoreCount);

   DBG_EXIT(httpGetTlsCertStoreCount);

   return http_cert_count;
}

HttpRequest_t httpCreateGetRequest(U8BIT *url, U8BIT cachePriority,
   HttpCallback_t callback,
   U32BIT request_id, void *userdata)
{
   HttpRequest_t request;
   U8BIT *header;

   DBG_ENTRY(httpCreateGetRequest);

   request = STB_MemAlloc(sizeof *request);
   if (request == NULL)
   {
      TRACE(TERROR, ("Malloc failed"));
   }
   else
   {
      request->url = STB_MemAlloc(strlen((char *)url) + 1);
      if (request->url != NULL)
      {
         httpSetRequestUrl(request->url, url);

         request->next = NULL;
         request->header_cb = NULL;
         request->callback = callback;
         request->request_id = request_id;
         request->response_code = 0;
         request->userdata = userdata;
         request->postdata = NULL;
         request->postdata_len = 0;
         request->processing = FALSE;

         HP_CreateRequest(request->url, HTTP_REQUEST_GET, &request->handle);
         if (request->handle != NULL)
         {
            TRACE(TFILE, ("HP_CreateRequest %p returned=%p URL=%s", request, request->handle, request->url));
            HP_SetUserData(request->handle, request);

            header = cookie_manager.generate_header((U8BIT *)request->url);
            if (header != NULL)
            {
               HP_AddHeader(request->handle, header);
               cookie_manager.ack_header(header);
            }

            httpSetupCache(request, cachePriority);
         }
         else
         {
            TRACE(TERROR, ("HP_CreateRequest failed"));
            STB_MemFree(request);
            request = NULL;
         }
      }
      else
      {
         STB_MemFree(request);
         request = NULL;
      }
   }

   DBG_EXIT(httpCreateGetRequest);

   return request;
}

HttpRequest_t httpCreateHeadRequest(U8BIT *url, HttpCallback_t callback,
   U32BIT request_id, void *userdata)
{
   HttpRequest_t request;
   U8BIT *header;

   DBG_ENTRY(httpCreateHeadRequest);

   request = STB_MemAlloc(sizeof *request);
   if (request != NULL)
   {
      request->url = STB_MemAlloc(strlen((char *)url) + 1);
      if (request->url != NULL)
      {
         httpSetRequestUrl(request->url, url);

         request->next = NULL;
         request->header_cb = callback;
         request->callback = callback;
         request->request_id = request_id;
         request->response_code = 0;
         request->userdata = userdata;
         request->postdata = NULL;
         request->postdata_len = 0;
         request->processing = FALSE;

         HP_CreateRequest(request->url, HTTP_REQUEST_HEAD, &request->handle);
         if (request->handle != NULL)
         {
            TRACE(TFILE, ("HP_CreateRequest %p returned=%p URL=%s", request, request->handle,request->url));
            HP_SetUserData(request->handle, request);

            header = cookie_manager.generate_header((U8BIT *)request->url);
            if (header != NULL)
            {
               HP_AddHeader(request->handle, header);
               cookie_manager.ack_header(header);
            }
         }
         else
         {
            TRACE(TERROR, ("HP_CreateRequest failed"));
            STB_MemFree(request);
            request = NULL;
         }
      }
      else
      {
         TRACE(TERROR, ("memory fail"));
         STB_MemFree(request);
         request = NULL;
      }
   }

   DBG_EXIT(httpCreateHeadRequest);

   return request;
}

extern HttpRequest_t httpCreatePostRequest(U8BIT *url, U8BIT *data,
   HttpCallback_t callback,
   U32BIT request_id, void *userdata)
{
   HttpRequest_t request;
   U8BIT *header;
   BOOLEAN success;
   E_HttpErr err;

   DBG_ENTRY(httpCreateHeadRequest);

   request = STB_MemAlloc(sizeof *request);
   if (request != NULL)
   {
      request->url = STB_MemAlloc(strlen((char *)url) + 1);
      if (request->url != NULL)
      {
         httpSetRequestUrl(request->url, url);

         request->next = NULL;
         request->header_cb = NULL;
         request->callback = callback;
         request->request_id = request_id;
         request->response_code = 0;
         request->userdata = userdata;
         request->processing = FALSE;

         if (data != NULL)
         {
            request->postdata_len = strlen((char *)data);
            request->postdata = STR_DataAlloc(request->postdata_len);
            if (request->postdata != NULL)
            {
               memcpy(request->postdata, data, request->postdata_len);
            }
            else
            {
               request->postdata_len = 0;
            }
         }
         else
         {
            request->postdata = NULL;
            request->postdata_len = 0;
         }

         HP_CreateRequest(request->url, HTTP_REQUEST_POST, &request->handle);
         if (request->handle != NULL)
         {
            TRACE(TFILE, ("HP_CreateRequest %p returned=%p", request, request->handle));

            success = TRUE;
            HP_SetUserData(request->handle, request);

            header = cookie_manager.generate_header((U8BIT *)request->url);
            if (header != NULL)
            {
               HP_AddHeader(request->handle, header);
               cookie_manager.ack_header(header);
            }

            if (request->postdata != NULL)
            {
               err = HP_SetPostData(request->handle, request->postdata);
               if (err != HTTP_OK)
               {
                  TRACE(TERROR, ("HP_SetPostData failed %p",err));
                  success = FALSE;
               }
            }

            if (!success)
            {
               TRACE(TFILE, ("Destroying Request hdl=%p", request->handle));
               HP_DestroyRequest(request->handle);
               if (request->postdata != NULL)
               {
                  STR_DataFree(request->postdata, request->postdata_len);
               }
               STB_MemFree(request);
               request = NULL;
            }
         }
         else
         {
            TRACE(TERROR, ("HP_CreateRequest failed"));
            STB_MemFree(request);
            request = NULL;
         }
      }
      else
      {
         STB_MemFree(request);
         request = NULL;
      }
   }

   DBG_EXIT(httpCreateHeadRequest);

   return request;
}

HttpRequest_t httpCreateStreamRequest(U8BIT *url, U8BIT *range,
   HttpCallback_t header_callback,
   HttpCallback_t callback,
   U32BIT request_id, void *userdata)
{
   HttpRequest_t request;
   U8BIT *header;

   DBG_ENTRY(httpCreateStreamRequest);

   request = STB_MemAlloc(sizeof *request);
   if (request != NULL)
   {
      request->url = STB_MemAlloc(strlen((char *)url) + 1);
      if (request->url != NULL)
      {
         httpSetRequestUrl(request->url, url);

         request->next = NULL;
         request->header_cb = header_callback;
         request->callback = callback;
         request->request_id = request_id;
         request->response_code = 0;
         request->userdata = userdata;
         request->postdata = NULL;
         request->postdata_len = 0;
         request->processing = FALSE;

         HP_CreateRequest(request->url, HTTP_REQUEST_STREAM, &request->handle);
         if (request->handle != NULL)
         {
            TRACE(TICS, ("HP_CreateRequest %p returned=%p URL=%s", request, request->handle, request->url));
            HP_SetUserData(request->handle, request);

            header = cookie_manager.generate_header((U8BIT *)request->url);
            if (header != NULL)
            {
               HP_AddHeader(request->handle, header);
               cookie_manager.ack_header(header);
            }

            request->range[0] = '\0';
            if (range != NULL)
            {
               strcpy((char *)request->range, (char *)range);
               HP_SetRange(request->handle, request->range);
            }
         }
         else
         {
            TRACE(TERROR, ("HP_CreateRequest failed"));
            STB_MemFree(request);
            request = NULL;
         }
      }
      else
      {
         STB_MemFree(request);
         request = NULL;
      }
   }

   DBG_EXIT(httpCreateStreamRequest);

   return request;
}

void httpStartRequest(HttpRequest_t request)
{
   BOOLEAN success;
   HttpTaskCmd cmd;

   DBG_ENTRY(httpStartRequest);

   /* Add request to requests pool */
   cmd.request = request;
   cmd.kind = HTTP_REQUEST_ADD;

   TRACE(TICS, ("%p hdl=%p", request, request->handle));
   /* Send request to HTTP task */
   do
   {
      success = STB_OSWriteQueue(http_task_queue, &cmd, sizeof cmd,
            REQUEST_START_TIMEOUT);
      if (!success)
      {
         TRACE(TERROR,("Cannot add to queue, retrying"));
      }
   }
   while (!success);

   DBG_EXIT(httpStartRequest);
}

void httpResumeRequest(HttpRequest_t request)
{
   BOOLEAN success;
   HttpTaskCmd cmd;

   DBG_ENTRY(httpResumeRequest);

   /* Add request to requests pool */
   cmd.request = request;
   cmd.kind = HTTP_REQUEST_RESUME;

   TRACE(TFILE, ("%p hdl=%p", request, request->handle));
   /* Send request to HTTP task */
   do
   {
      success = STB_OSWriteQueue(http_task_queue, &cmd, sizeof cmd,
            REQUEST_START_TIMEOUT);
      if (!success)
      {
         TRACE(TERROR,("Cannot resume to queue, retrying"));
      }
   }
   while (!success);

   DBG_EXIT(httpResumeRequest);
}

U8BIT* httpGetRequestRedirect(HttpRequest_t request)
{
   U8BIT *url;

   DBG_ENTRY(httpGetRequestRedirect);

   HP_GetRedirectUrl(request->handle, &url);

   DBG_EXIT(httpGetRequestRedirect);

   return url;
}

void httpStopRequest(HttpRequest_t request)
{
   BOOLEAN success;
   HttpTaskCmd cmd;

   DBG_ENTRY(httpStopRequest);

   /* Remove request from requests pool */
   cmd.request = request;
   cmd.kind = HTTP_REQUEST_REMOVE;

   TRACE(TICS, ("%p hdl=%p", request, request->handle));
   /* Send request to HTTP task */
   do
   {
      success = STB_OSWriteQueue(http_task_queue, &cmd, sizeof cmd,
            REQUEST_START_TIMEOUT);
   }
   while (!success);

   /* Wait for request to be stopped */
   STB_OSSemaphoreWait(http_task_semaphore);

   TRACE(TICS, ("Stopped Request %p", request));

   DBG_EXIT(httpStopRequest);
}

void httpDestroyRequest(HttpRequest_t request)
{
   DBG_ENTRY(httpDestroyRequest);

   assert(request != NULL);
   assert(request->handle != NULL);

   TRACE(TICS, ("Destroying Request hdl=%p", request->handle));
   HP_DestroyRequest(request->handle);
   if (request->postdata != NULL)
   {
      STR_DataFree(request->postdata, request->postdata_len);
   }
   STB_MemFree(request->url);
   STB_MemFree(request);

   DBG_EXIT(httpDestroyRequest);
}

void httpClose(void)
{
   DBG_ENTRY(httpClose);

   httpStopTask();

   /* curl does not work too well with 'cleanup'/'init' cycle
    * So - it can be disabled here
    */
#ifndef DISABLE_HTTP_CLOSEDOWN

   STB_OSDestroyQueue(http_task_queue);
   STB_OSDeleteMutex(http_task_mutex);
   STB_OSDeleteSemaphore(http_task_semaphore);
   http_task_semaphore = NULL;

   HP_Terminate();

#endif

   DBG_EXIT(httpClose);
}

static void httpSetRequestUrl(U8BIT *requrl, U8BIT *url)
{
   static char lowercase[] = "abcdefghijklmnopqrstuvwxyz";
   static char uppercase[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   char *p, *sp;
   int c, idx;

   DBG_ENTRY(httpSetRequestUrl);

   strcpy((char *)requrl, (char *)url);

   /* The URL should already have the correct format, so we can assume
    * http(s)://<hostname>/<rest>
    */
   p = strstr((char *)requrl, "://");
   if (p != NULL)
   {
      for (p += 3; *p != '/' && *p != '\0'; p++)
      {
         c = *p;
         /* NOTE: slower but more portable than "(c >= 'A' && c <= 'Z')" */
         sp = strchr(uppercase, c);
         if (sp != NULL)
         {
            idx = sp - uppercase;
            *p = lowercase[idx];
         }
      }
   }

   DBG_EXIT(httpSetRequestUrl);
}

static void httpSetupCache(HttpRequest_t request, U8BIT cachePriority)
{
   if (cachePriority == 0)
   {
      /* No caching */
      HP_AddHeader(request->handle, (U8BIT *)"Cache-Control: no-cache, no-transform");
      HP_AddHeader(request->handle, (U8BIT *)"Pragma: no-cache");
   }
   else if (cachePriority % 2 == 0)
   {
      /* From cache (as much as possible) */
      HP_AddHeader(request->handle, (U8BIT *)"Cache-Control: max-stale, no-transform");
   }
   else
   {
      /* Transparent caching */
      HP_AddHeader(request->handle, (U8BIT *)"Cache-Control: no-transform");
   }
}

static BOOLEAN httpStartTask(U32BIT taskPriority)
{
   BOOLEAN success;

   DBG_ENTRY(httpStartTask);

   http_task_handle = STB_OSCreateTask(httpTaskMain, NULL, HTTP_STACK_SIZE,
         (U8BIT)taskPriority, (U8BIT *)"HTTP");
   if (http_task_handle != NULL)
   {
      STB_OSSemaphoreWait(http_task_semaphore);
      success = TRUE;
   }

   DBG_EXIT(httpStartTask);

   return success;
}

static void httpStopTask(void)
{
   DBG_ENTRY(httpStopTask);

   if (http_task_status == HTTP_TASK_RUNNING)
   {
      http_task_status = HTTP_TASK_STOP_REQUEST;
      STB_OSSemaphoreWait(http_task_semaphore);

      assert(http_task_status == HTTP_TASK_STOPPED);
   }

   DBG_EXIT(httpStopTask);
}

static void httpTaskMain(void *task_arg)
{
   U16BIT count;
   BOOLEAN success;
   HttpTaskCmd cmd;

   DBG_ENTRY(httpTaskMain);

   http_task_status = HTTP_TASK_RUNNING;
   STB_OSSemaphoreSignal(http_task_semaphore);

   while (http_task_status == HTTP_TASK_RUNNING)
   {
      count = httpProcessRequests();
      if (count == 0)
      {
         success = STB_OSReadQueue(http_task_queue, &cmd, sizeof cmd,
               HTTP_IDLE_TIMEOUT);
         STB_OSTaskDelay(1);
      }
      else
      {
         success = FALSE;
      }

      while (success || count > 0)
      {
         if (success)
         {
            /* New HTTP request */
            switch (cmd.kind)
            {
               case HTTP_REQUEST_ADD:
                  httpAddRequest(cmd.request);
                  break;
               case HTTP_REQUEST_RESUME:
                  httpContinueRequest(cmd.request);
                  break;
               case HTTP_REQUEST_REMOVE:
                  httpRemoveRequest(cmd.request);
                  /* Stay in idle mode */
                  break;
               case HTTP_REQUEST_NONE:
                  /* Requests in the queue should not have NONE command */
                  assert(0);
                  break;
            }
         }

         count = httpProcessRequests();
         success = STB_OSReadQueue(http_task_queue, &cmd, sizeof cmd, 0);
         STB_OSTaskDelay(1);
      }
   }

   if (http_task_status == HTTP_TASK_STOP_REQUEST)
   {
      http_task_status = HTTP_TASK_STOPPED;
      STB_OSSemaphoreSignal(http_task_semaphore);
   }

   STB_OSDestroyTask(http_task_handle);
   DBG_EXIT(httpTaskMain);
}

static void httpAddRequest(HttpRequest_t request)
{
   U16BIT dummy;
   HttpRequest_t *p_request;
   E_HttpErr err;

   DBG_ENTRY(httpAddRequest);

#ifdef DEBUG_LIST
   httpPrintRequestList();
#endif
   if (request == NULL)
   {
      TRACE(TERROR, ("request is NULL!"));
   }
   else
   {
      TRACE(TICS, ("Start request hdl=%p", request->handle));
      err = HP_StartRequest(request->handle);
      if (err == HTTP_OK)
      {
         /* Append request to request list */
         p_request = &http_request_list;
         while (*p_request != NULL)
         {
            p_request = &(*p_request)->next;
         }
         *p_request = request;

         /* Start the transfer */
         HP_Process(&dummy);
      }
      else
      {
         TRACE(TERROR, ("HP_StartRequest failed %d",err));
      }
   #ifdef DEBUG_LIST
      httpPrintRequestList();
   #endif
   }
   DBG_EXIT(httpAddRequest);
}

static void httpContinueRequest(HttpRequest_t request)
{
   DBG_ENTRY(httpContinueRequest);

   if (httpIsValidRequest(request))
   {
      if (!request->processing)
      {
         TRACE(TICS, ("Resuming request hdl=%p", request->handle));
         HP_ResumeRequest(request->handle);
      }
      else
      {
         TRACE(TICS, ("Resume not needed hdl=%p", request->handle));
      }
   }

   DBG_EXIT(httpContinueRequest);
}

static void httpRemoveRequest(HttpRequest_t request)
{
   HttpRequest_t *p_request;
   E_HttpErr err;

   DBG_ENTRY(httpRemoveRequest);

#ifdef DEBUG_LIST
   httpPrintRequestList();
#endif

   if (!httpIsValidRequest(request))
   {
      TRACE(TERROR,("request %p was not found", request))
   }
   else
   {
      TRACE(TICS, ("Stop request %p hdl=%p", request, request->handle));
      err = HP_StopRequest(request->handle);
      if (err != HTTP_OK)
      {
         TRACE(TERROR,("HP_StopRequest for request %p failed err=%d - removing anyway", request, err))
         /* TODO: can't remove request? */
      }

      /* Remove request from request list */
      p_request = &http_request_list;
      while (*p_request != NULL)
      {
         if (*p_request == request)
         {
            *p_request = request->next;
            request->next = NULL;
            break;
         }
         p_request = &(*p_request)->next;
      }
   }
#ifdef DEBUG_LIST
   httpPrintRequestList();
#endif

   /* Signal semaphore even if couldn't remove the request, otherwise
    * the caller will wait forever.
    */
   STB_OSSemaphoreSignal(http_task_semaphore);

   DBG_EXIT(httpRemoveRequest);
}

static U16BIT httpProcessRequests(void)
{
   U16BIT running_handles;

   DBG_ENTRY(httpProcessRequests);

   HP_WaitForAction();
   HP_Process(&running_handles);

   DBG_EXIT(httpProcessRequests);

   return running_handles;
}

void HP_HeaderCallback(void *userdata, S32BIT code, U8BIT *data, U32BIT len)
{
   HttpRequest_t request;
   HttpResponse_t response;

   DBG_ENTRY(HP_HeaderCallback);

   request = userdata;

   request->response_code = code;
   cookie_manager.parse(data, len, (char *)request->url);

   if (request->header_cb != NULL && data != NULL && len > 0)
   {
      response.status = HTTP_STATUS_WAIT;
      response.code = code;
      response.data = data;
      response.data_len = len;
      request->header_cb(request->userdata, request->request_id, &response);
   }

   DBG_EXIT(HP_HeaderCallback);
}

BOOLEAN HP_ContentCallback(void *userdata, U8BIT *data, U32BIT len)
{
   HttpRequest_t request;
   HttpResponse_t response;
   BOOLEAN processed = TRUE;

   DBG_ENTRY(HP_ContentCallback);

   request = userdata;
   if (request->callback != NULL)
   {
      response.status = HTTP_STATUS_WAIT;
      response.code = 0;
      response.data = data;
      response.data_len = len;
      processed = request->callback(request->userdata, request->request_id,
            &response);
      request->processing = processed;
   }

   DBG_EXIT(HP_ContentCallback);

   return processed;
}

void HP_EndCallback(void *userdata, E_HttpStatus status)
{
   HttpRequest_t request;
   HttpResponse_t response;

   DBG_ENTRY(HP_EndCallback);

   request = userdata;
   if (request->callback != NULL)
   {
      response.status = status;
      response.code = request->response_code;
      response.data = NULL;
      response.data_len = 0;
      request->callback(request->userdata, request->request_id, &response);
   }

   DBG_EXIT(HP_EndCallback);
}

static BOOLEAN httpIsValidRequest(HttpRequest_t request)
{
   HttpRequest_t current;
   BOOLEAN valid;

   valid = FALSE;

   current = http_request_list;
   while (current != NULL)
   {
      if (current == request)
      {
         valid = TRUE;
         break;
      }
      current = current->next;
   }

   return valid;
}

#ifdef DEBUG_LIST

static void httpPrintRequestList(void)
{
   HttpRequest_t request;

   request = http_request_list;
   while (request != NULL)
   {
      DBG_PRINTF("%p -> ", request); fflush(stdout);
      request = request->next;
   }
   DBG_PRINTF("||\n"); fflush(stdout);
}

#endif  /* DEBUG_LIST */

static void httpCookieParse(void *data, U32BIT data_len, char *url)
{
   /* do nothing */
}

static U8BIT* httpCookieGenerateHeader(U8BIT *url)
{
   return NULL;
}

static void httpCookieAckHeader(U8BIT *header)
{
   /* do nothing */
}

#endif /*INCLUDE_IC*/