mh5fileorm.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * 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 "mh5fileorm.h"
#include "mh5stream.h"
#include "mh5memory.h"
#include "mh5debug.h"
#include "mh5profile.h"
#include "mh5object.h"
#include "mh5queue.h"
#include "mh5gate.h"
#include "mh5misc.h"
#include "mh5control.h"
#include <string.h>

#ifdef COMMON_INTERFACE
#include "ci_appmmi.h"
#endif
#include "glue_queue.h"
#include "glue_main.h"
#include "glue_timers.h"

#ifndef CI_PLUS_ONLY
 #include "glue_dsmcc.h"
 #ifdef INCLUDE_DSM_FG
  #include "mh5filegroup.h"
 #endif
#endif

#ifdef INCLUDE_IC
#include "http_interface.h"
#include "mh5hfs.h"
#include "mh5tls.h"
#include "mh5access.h"
#include "mh5hash.h"
#include "mh5sig.h"
#endif


#ifdef PRINT_DSM_FILES
#include "glue_memory.h"
#include "dvb_service.h"
#include "dsm_control.h"
void DBG_FilePrintf(const char *format, ...);
#endif
#ifdef SAVING_DSM_FILES
#include "glue_memory.h"
#include "dvb_service.h"
#include "dsm_control.h"
void DBG_SaveFile(unsigned int srv_ndx, unsigned int srv_id, unsigned int crsl_id,
   char *name, unsigned char *data, unsigned int len);
#endif

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

#define MAX_PATHNAME_LENGTH     (1024)

#ifndef MAX_CI_REQUESTS
#define MAX_CI_REQUESTS         (1)
#endif
#define CI_ACK_TIMEOUT           9999  /*  about 10 secs */

#define MIN_HTTP_REPLY_BLOCK    (128)
#define MAX_REDIRECTS           (5)

#ifndef CI_PLUS_ONLY
#define DsmAlloc AllocRequest
#else
#define DsmAlloc AllocNothing
#endif

#ifdef COMMON_INTERFACE
#define CiAlloc AllocRequest
#else
#define CiAlloc AllocNothing
#endif

#ifdef INCLUDE_IC
#define HttpAlloc AllocRequest
#define HybrAlloc AllocRequest
#else
#define HttpAlloc AllocNothing
#define HybrAlloc AllocNothing
#endif

#ifdef INCLUDE_IC
#define DEFAULT_ORIGIN ORIGIN_HYBRID
#else
#ifndef CI_PLUS_ONLY
#define DEFAULT_ORIGIN ORIGIN_DSM
#else
#define DEFAULT_ORIGIN ORIGIN_CI
#endif
#endif

#define IS_HTTP_REQUEST(r)   ((r)->origin == ORIGIN_HTTP || (r)->origin == ORIGIN_HTTPS)
#define IS_HTTPS_REQUEST(r)  ((r)->origin == ORIGIN_HTTPS)
#define IS_HYBRID_REQUSET(r) ((r)->origin == ORIGIN_HYBRID)

#ifndef NDEBUG
#define CHECK_ORM_MAGIC
#endif
#ifdef CHECK_ORM_MAGIC
 #define ORM_REQUEST_MAGIC 0xdeadbeef
 #define ORM_REQUEST_BAD_MAGIC 0xfeedface
 #define SET_ORM_MAGIC(r) (r)->magic = ORM_REQUEST_MAGIC
 #define CLEAR_ORM_MAGIC(r) (r)->magic = ORM_REQUEST_BAD_MAGIC
 #define VERIFY_ORM_MAGIC(r) assert((r)->magic == ORM_REQUEST_MAGIC)
#else
 #define SET_ORM_MAGIC(r)
 #define CLEAR_ORM_MAGIC(r)
 #define VERIFY_ORM_MAGIC(r)
#endif

#ifdef TRACING

#define PRINT_ERROR(x) TPRINT(TERROR, x)

#else

#define PRINT_ERROR(x)

#endif /*TRACING*/

#define ORM_STATE_STRING(r)                                             \
   ((r)->state == ORM_STATE_START ? "ORM_STATE_START" :                 \
    (r)->state == ORM_STATE_QUEUED ? "ORM_STATE_QUEUED" :               \
    (r)->state == ORM_STATE_WAIT_ACCESS ? "ORM_STATE_WAIT_ACCESS" :     \
    (r)->state == ORM_STATE_CHECK_ACCESS ? "ORM_STATE_WAIT_ACCESS" :    \
    (r)->state == ORM_STATE_HAS_ACCESS ? "ORM_STATE_HAS_ACCESS" :       \
    (r)->state == ORM_STATE_WAIT_CERT ? "ORM_STATE_WAIT_CERT" :         \
    (r)->state == ORM_STATE_HAS_CERT ? "ORM_STATE_HAS_CERT" :           \
    (r)->state == ORM_STATE_REQUESTED ? "ORM_STATE_REQUESTED" :         \
    (r)->state == ORM_STATE_WAIT_VERIFY ? "ORM_STATE_WAIT_VERIFY" :     \
    (r)->state == ORM_STATE_CHECK_VERIFY ? "ORM_STATE_CHECK_VERIFY" :   \
    (r)->state == ORM_STATE_SUCCEEDED ? "ORM_STATE_SUCCEEDED" :         \
    (r)->state == ORM_STATE_FAILED ? "ORM_STATE_FAILED" :               \
    (r)->state == ORM_STATE_ABORTED ? "ORM_STATE_ABORTED" :             \
    "UNKNOWN")

#ifdef MHEG5LOG
   #undef TRACING
   #define TRACING 511
#endif


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

/* Enumerated type to tell where the origin of a file is (i.e. the part before
 * "://")
 */

/* Enumerated type to tell the state of a request */
typedef enum
{
   ORM_STATE_START,
   ORM_STATE_QUEUED,
   ORM_STATE_WAIT_ACCESS,
   ORM_STATE_CHECK_ACCESS,
   ORM_STATE_HAS_ACCESS,
   ORM_STATE_WAIT_CERT,
   ORM_STATE_HAS_CERT,
   ORM_STATE_REQUESTED,
   ORM_STATE_WAIT_VERIFY,
   ORM_STATE_CHECK_VERIFY,
   ORM_STATE_SUCCEEDED,
   ORM_STATE_FAILED,
   ORM_STATE_ABORTED
} E_OrmState;

/* Enumerated type to tell the type of a request */
typedef enum
{
   ORM_TYPE_GET,
   ORM_TYPE_FGR,
   ORM_TYPE_POST
} E_OrmType;

/* Asynchronous CI message record structure. */

typedef struct CiMessageContext_struct
{
   void *userData;
   E_FsStatus successFlag;
   F_CB_CiMsg callback;
   MHEG5String input;
   MHEG5String output;
   struct CiMessageContext_struct *next;
} CiMessageContext;

#ifdef INCLUDE_IC
/* HTTP/S reply */
typedef struct HttpReplyBuffer_struct
{
   U32BIT allocated;
   U32BIT used;
   U8BIT *data;
   BOOLEAN valid;
} HttpReplyBuffer;
#endif /*INCLUDE_IC*/

/* Request structures */

typedef struct sOrmRequest *P_OrmRequest;

typedef struct sOrmFuncs
{
   P_OrmRequest (*Alloc)(void);
   void (*Action)(P_OrmRequest request);
   void (*Clear)(P_OrmRequest request);
} S_OrmFuncs;

/* GET request */
typedef struct sOrmGetRequest
{
   F_CB_Good cbGood;
   F_CB_Fail cbFail;
   S_CONTENT ocontent;
   P_OrmRequest child;
   U16BIT priority;
} S_OrmGetRequest;

/* HTTP POST request */
typedef struct sOrmPostRequest
{
   F_CB_Post callback;
   MHEG5String postData;
   MHEG5Int responseCode;
   MHEG5String responseData;
} S_OrmPostRequest;

typedef struct sOrmRequest
{
   P_OrmRequest next;
#ifdef CHECK_ORM_MAGIC
   U32BIT magic;
#endif
   E_FS_ORIGIN origin;
   E_OrmType type;
   E_OrmState state;
   void *requestRef;
   void *userData;
   MHEG5String url;
   U32BIT requestId;
#ifdef INCLUDE_IC
   /* HTTP/S */
   U16BIT redirectCount;
   U32BIT certCount;
   /* Hybrid */
   void *hybrid_mapping;
   MHEG5MappingIter_t hybrid_iter;
#endif
   union
   {
      S_OrmGetRequest  get;
      S_OrmPostRequest post;
   } r;
} S_OrmRequest;

/*---local (static) variable declarations for this file----------------------*/
static S_OrmRequest *requestListHead = 0;

/* dvb:// or rec:// resolution request */
static S_DVB_LOCATOR dvbMultiplexReference = {0, 0, 0};

#ifdef COMMON_INTERFACE
/* CI:// requests */
static CiMessageContext *ciMessageListHead = 0;
static BOOLEAN ciMessageSent = FALSE;
static U16BIT ciRequestCount = 0;
static H_Timer ciAckTimerHandle = NULL;
#endif /*COMMON_INTERFACE*/

static U32BIT globalRequestId = 0;

/* Request list re-processing information */
static BOOLEAN inprocess = FALSE;
static BOOLEAN reprocess = FALSE;

/* Reset information */
static BOOLEAN inreset = FALSE;
static MHEG5FileOrmResetMode currentResetMode = MHEG5_FILE_ORM_RESET_ALL;

/*---local function prototypes for this file---------------------------------*/

#ifdef INCLUDE_IC
static void HybridGetCallback( void *userData, S_CONTENT *ocontent );
static void HybridGetFailCallback( void *userData );
static BOOLEAN HttpGetCallback( void *userdata, U32BIT requestId,
   HttpResponse_t *response);
static BOOLEAN HttpPostCallback(void *userdata, U32BIT requestId,
   HttpResponse_t *response);
#endif /* INCLUDE_IC */

#ifndef CI_PLUS_ONLY
/* DSM-CC Get request */
static void DsmAction(S_OrmRequest *ormRequest);
static void DsmClear(S_OrmRequest *ormRequest);
#else
#define DsmAction DummyFunc
#define DsmClear  DummyFunc
#endif  /* !CI_PLUS_ONLY */

/* CI Get request */
#ifdef COMMON_INTERFACE
static BOOLEAN CiSetFileContent(U8BIT *data, U32BIT size, S_CONTENT *pContent);
static void CiAction(S_OrmRequest *ormRequest);
static void CiClear(S_OrmRequest *ormRequest);
#else
#define CiAction DummyFunc
#define CiClear  DummyFunc
#endif /*COMMON_INTERFACE*/

/* DVB or REC Get request */
static void DvbAction(S_OrmRequest *ormRequest);
static void DvbClear(S_OrmRequest *ormRequest);
static P_OrmRequest DvbAlloc(void);

#if defined(CI_PLUS_ONLY) || !defined(COMMON_INTERFACE) || !defined(INCLUDE_IC)
static P_OrmRequest AllocNothing(void);
#endif
static P_OrmRequest AllocRequest(void);

#if !defined(CI_PLUS_ONLY) || defined(INCLUDE_IC)
static S_OrmRequest* FindRequest(U32BIT requestId);
#endif

#ifdef INCLUDE_IC

static void HybrAction(S_OrmRequest *ormRequest);
static void HybrClear(S_OrmRequest *ormRequest);
static void HttpAction(S_OrmRequest *ormRequest);
static void HttpClear(S_OrmRequest *ormRequest);

/* HTTP POST request */
static MHEG5Bool PostProcess(S_OrmRequest *ormRequest);

static void CheckServerAccess(S_OrmRequest *ormRequest);
static void CheckTlsCertificates(S_OrmRequest *ormRequest);
static void PerformHttpRequest(S_OrmRequest *ormRequest);
static void VerifyRequestContent(S_OrmRequest *ormRequest);

static void HttpRedirect(S_OrmRequest *ormRequest);

/* Callbacks for sub-systems */
static void TlsCertCallback(void);
static void ServerAccessCallback(void);
static void VerificationCallback(void);

static void AppendData(HttpReplyBuffer *hcontent, U8BIT *data, U32BIT dataLen);

#else /* !INCLUDE_IC */

#define HybrAction DummyFunc
#define HybrClear  DummyFunc
#define HttpAction DummyFunc
#define HttpClear  DummyFunc

#endif /* INCLUDE_IC */

static MHEG5Bool DefaultGetProcess(S_OrmRequest *ormRequest);

static void ReprocessRequestList(void);
static void ProcessRequestList(void);

#if defined(CI_PLUS_ONLY) || !defined(COMMON_INTERFACE) || !defined(INCLUDE_IC)
static void DummyFunc(S_OrmRequest *ormRequest) {}
#endif

/*---local (static) variable declarations for this file----------------------*/

static S_OrmFuncs ormFunctions[ORIGIN_MAX] = {
   /*DSM    */  { DsmAlloc,    DsmAction,  DsmClear },
   /*CI     */  { CiAlloc,     CiAction,   CiClear },
   /*HYBRID */  { HybrAlloc,   HybrAction, HybrClear },
   /*HTTP   */  { HttpAlloc,   HttpAction, HttpClear },
   /*HTTPS  */  { HttpAlloc,   HttpAction, HttpClear },
   /*DVB    */  { DvbAlloc,    DvbAction,  DvbClear },
   /*REC    */  { DvbAlloc,    DvbAction,  DvbClear },
};

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

#if defined(CI_PLUS_ONLY) || !defined(COMMON_INTERFACE) || !defined(INCLUDE_IC)
static P_OrmRequest AllocNothing(void)
{
   return NULL;
}
#endif

static P_OrmRequest AllocRequest(void)
{
   P_OrmRequest request;
   request = MHEG5getMem(sizeof(S_OrmRequest));
   if (request != NULL)
   {
      memset(request, 0, sizeof(S_OrmRequest));
      SET_ORM_MAGIC(request);
   }
   return request;
}

static P_OrmRequest DvbAlloc(void)
{
   static S_OrmRequest dvbRequest;
   S_OrmRequest *request = &dvbRequest;
   memset(request, 0, sizeof(S_OrmRequest));
   SET_ORM_MAGIC(request);
   return request;
}

#ifdef INCLUDE_IC

static void DefaultDataClear( void *data )
{
   MHEG5freeMem(data);
}

#endif  /* INCLUDE_IC */


#ifdef COMMON_INTERFACE

static void AddToCiMessageContextList(CiMessageContext *contextToAdd)
{
   /* Add context to the head of the list */
   contextToAdd->next = ciMessageListHead;
   ciMessageListHead = contextToAdd;

   DEBUG_PRINT(("Added message context to head of ciMessageListHead list\n"));
}

static void RemoveFromCiMessageContextList(CiMessageContext *contextToRemove)
{
   if (contextToRemove == ciMessageListHead)
   {
      /* Context to remove is at the head of the list - remove it by changing
       * the list head pointer
       */
      ciMessageListHead = ciMessageListHead->next;

      INFO_PRINT(("Removed message context from head of ciMessageListHead list\n"));
   }
   else
   {
      CiMessageContext *context;

      /* Search the context list, looking for a pointer to this context */
      context = ciMessageListHead;

      while (context->next)
      {
         if (context->next == contextToRemove)
         {
            /* Found the context to remove in the list - route list pointers
             * round it.
             */
            context->next = contextToRemove->next;
            INFO_PRINT(("Removed message context from middle or end of ciMessageListHead list\n"));
            return;                             /*** RETURN ***/
         }
         context = context->next;
      }

      /* We did not find the specified context - print an error message */
      ERROR_PRINT(("INTERNAL ERROR: RemoveFromCiMessageContextList - context not found\n"));
      assert(0);
   }
}
#endif /*COMMON_INTERFACE*/

static void AddToRequestList(S_OrmRequest *request)
{
   S_OrmRequest **pRequest;

   pRequest = &requestListHead;
   while (*pRequest != NULL)
   {
      pRequest = &(*pRequest)->next;
   }
   *pRequest = request;
}

static void RemoveFromRequestList(S_OrmRequest *request)
{
   S_OrmRequest **pRequest;

   assert(request != NULL);

   pRequest = &requestListHead;
   while (*pRequest != NULL && *pRequest != request)
   {
      pRequest = &(*pRequest)->next;
   }

   if (*pRequest == request)
   {
      *pRequest = request->next;
   }
   else
   {
      /* We did not find the specified request - print an error message */
      ERROR_PRINT(("INTERNAL ERROR: RemoveFromRequestList - request not found\n"));
      assert(0);
   }
}

#ifdef COMMON_INTERFACE
static void ciAckTimeoutFunc( BOOLEAN trig, void *cRef, H_Timer timer )
{
   if (trig == TRUE)
   {
      TRACE(TERROR, ("CAM never returned an ACK! ciRequestCount=%d", ciRequestCount))
      if (ciRequestCount != 0)
      {
         ciRequestCount = 0;
         ciMessageSent = FALSE;
      }
   }
}
#endif /*COMMON_INTERFACE*/

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

void MHEG5FileOrmInit(void)
{
#ifdef INCLUDE_IC
   MHEG5AddTlsCertificateCallback(TlsCertCallback);
   MHEG5AddServerAccessCallback(ServerAccessCallback);
   MHEG5SetVerificationCallback(VerificationCallback);
#endif
}

void MHEG5FileOrmReset(MHEG5FileOrmResetMode resetMode)
{
   S_OrmRequest *ormRequest;
   MHEG5Bool requestDone;
   BOOLEAN remove;

   inreset = TRUE;
   currentResetMode = resetMode;

   ormRequest = requestListHead;
   while (ormRequest)
   {
      if (resetMode == MHEG5_FILE_ORM_RESET_ALL)
      {
         remove = TRUE;
      }
      else if (ormRequest->type == ORM_TYPE_GET)
      {
         if (ormRequest->r.get.priority & FRP_SERVER)
         {
            /* don't clear 'external' requests such as TLS or server access */
            remove = FALSE;
         }
         else if ((resetMode == MHEG5_FILE_ORM_RESET_SCENE_OBJECTS) &&
                  (ormRequest->r.get.priority & FRP_IN_APP))
         {
            /* don't clear requests for application ingredients */
            remove = FALSE;
         }
         else
         {
            /* all group and ingredients can be removed */
            remove = TRUE;
         }
      }
      else
      {
         /*
          * remove is unitialised here so set to FALSE?
          * otherwise the subsequent check on remove will have unexpected results.
          */
         remove = FALSE;
      }

      if (remove)
      {
         /* Notify load failure */
         ormRequest->state = ORM_STATE_FAILED;
         requestDone =
            #ifdef INCLUDE_IC
               (ormRequest->type == ORM_TYPE_POST)? PostProcess(ormRequest) :
            #endif
               DefaultGetProcess(ormRequest);

         assert(requestDone);
         if (requestDone)
         {
            /* Free off memory for the item we just removed */
            ormFunctions[ormRequest->origin].Clear(ormRequest);
         }

         /* Start from beginning of list, in case callback changed anything */
         ormRequest = requestListHead;
      }
      else
      {
         ormRequest = ormRequest->next;
      }
   }

#ifdef COMMON_INTERFACE
   /* Free off all entries in the message list */
   while (ciMessageListHead)
   {
      CiMessageContext *ciItem;

      /* Remember the current list head */
      ciItem = ciMessageListHead;

      /* Remove the current list head from the list */
      RemoveFromCiMessageContextList(ciItem);

      /* Free off memory for the item we just removed */
      MHEG5stringDestruct(&ciItem->input);
      if (ciItem->output.data != NULL)
      {
         MHEG5CiAckData(ciItem->output.data);
      }
      MHEG5freeMem(ciItem);
   }

   if (ciRequestCount != 0)
   {
      if (ciAckTimerHandle != NULL)
      {
         VT_TimerDestroy( ciAckTimerHandle );
         ciAckTimerHandle = NULL;
      }
      (void)VT_TimerCreate( CI_ACK_TIMEOUT, (F_TimerCallback)ciAckTimeoutFunc, 0, &ciAckTimerHandle );
   }
#endif /*COMMON_INTERFACE*/

   inreset = FALSE;
}

BOOLEAN MHEG5FileOrmIsReset(MHEG5FileOrmResetMode *resetMode)
{
   if (inreset)
   {
      if (resetMode != NULL)
      {
         *resetMode = currentResetMode;
      }
      return TRUE;
   }
   return FALSE;
}

#if defined(PRINT_DSM_FILES) || defined(SAVING_DSM_FILES)

#define PRNT_FL_MAX 37
typedef struct sFileNames
{
   struct sFileNames *next;
   int nmlen;
   U8BIT name[4];
} FileNames_t;

typedef struct sPrintFiles
{
   struct sPrintFiles *next;
   MHEG5Int srv_ndx;
   FileNames_t *file_head;
} PrintFiles_t;

PrintFiles_t print_files_hash[PRNT_FL_MAX];
int print_files = 0;
int file_printing = 1;

void dumpDsmFile( U8BIT *fname, U8BIT *data, U32BIT size )
{
   const char digits[16] = "0123456789ABCDEF";
   S_DVB_LOCATOR multiplexRef;
   S_DVB_LOCATOR dvbLocator;
   S32BIT service_ndx;
   PrintFiles_t *p_pf;
   FileNames_t *p_fn;
   int nlen;

   if (!file_printing)
      return;

   MHEG5streamGetCurrentService(&multiplexRef);

   dvbLocator.original_network_id = multiplexRef.original_network_id;
   dvbLocator.transport_stream_id = multiplexRef.transport_stream_id;
   dvbLocator.service_id = (U16BIT)multiplexRef.service_id;
   /* Get the service index from the controlling environment */
   if (DVB_MhegDvbLocatorToIndex(&dvbLocator, &service_ndx) != MHERR_OK || service_ndx == -1)
      return;
   nlen = strlen(fname);
   if (print_files == 0)
   {
      /* initialise */
      memset( print_files_hash, 0, 37 * sizeof(PrintFiles_t));
   }
   p_pf = &print_files_hash[service_ndx % PRNT_FL_MAX];

   while ((p_pf->next) && (p_pf->srv_ndx != service_ndx))
      p_pf = p_pf->next;

   if (p_pf->srv_ndx != service_ndx)
   {
      p_pf->srv_ndx = service_ndx;
   }
   p_fn = p_pf->file_head;
   while (p_fn)
   {
      if ((nlen == p_fn->nmlen) &&
          (memcmp( p_fn->name, fname, nlen ) == 0))
      {
         break;
      }
      p_fn = p_fn->next;
   }
   if (p_fn == 0)
   {
      /* not a duplicate - now save details of this file */
      p_fn = p_pf->file_head;
      p_pf->file_head = (FileNames_t *)STB_MemAlloc(sizeof(FileNames_t) + nlen - 2);
      p_pf->file_head->next = p_fn;
      p_pf->file_head->nmlen = nlen;
      memcpy( p_pf->file_head->name, fname, nlen );

      #ifdef SAVING_DSM_FILES
      DBG_SaveFile(service_ndx, dvbLocator.service_id, DSMCC_CurrentCarouselId(MHEG5_DsmccInstance()), (char *)fname, data, size);
      #endif
      #ifdef PRINT_DSM_FILES
      DBG_FilePrintf( "%ld_%d/%s", (long int)service_ndx, dvbLocator.service_id, (char *)fname );
      for (nlen = 0; nlen != size; nlen++)
      {
         if ((nlen & 0x1f) == 0x00)
            DBG_FilePrintf("\n");
         DBG_FilePrintf("%c%c", digits[data[nlen] >> 4], digits[data[nlen] & 0xf]);
      }
      DBG_FilePrintf("\n*\n");
      #endif
      print_files++;
   }
}

#define PRINTFILE(t, n, d, s) /*if (t == ORM_TYPE_GET)*/ dumpDsmFile(n, d, s)
#else
#define PRINTFILE(t, n, d, s)
#endif

BOOLEAN MHEG5FileOrmProcess(void)
{
#ifdef COMMON_INTERFACE
   CiMessageContext *ciItem;
   MHEG5String output;
#endif

   reprocess = FALSE;
   inprocess = TRUE;

   ProcessRequestList();

#ifdef COMMON_INTERFACE
   ciItem = ciMessageListHead;
   while (ciItem != NULL)
   {
      switch (ciItem->successFlag)
      {
         default:
            /* Remove the item from the list */
            RemoveFromCiMessageContextList(ciItem);

            /* Send the reply to the callback */
            output.data = &ciItem->output.data[1];
            output.len = ciItem->output.len - 1;
            (ciItem->callback)(ciItem->userData, output, MHEG5TRUE);

            if (ciItem->output.data != NULL)
            {
               MHEG5CiAckData(ciItem->output.data);
            }
            MHEG5freeMem(ciItem);

            /* The callback may have removed or added entries into the context
             * list, therefore we cannot rely on any previously held information
             * about the next entry in the list. We must start again from the
             * list head.
             */
            ciItem = ciMessageListHead;
            break;

         case FS_STATUS_INVALID:
            /* File hasn't been requested yet */
            if (ciRequestCount < MAX_CI_REQUESTS && !ciMessageSent)
            {
               /* Request the file from the CI module */
               if (ciItem->input.data != NULL &&
                   STB_CIFileRequest(MHEG5GetCiModuleId(), ciItem->input.data, ciItem->input.len) == TRUE)
               {
                  /* File has been requested */
                  ciItem->successFlag = FS_STATUS_PENDING;
                  ciRequestCount++;
                  ciMessageSent = TRUE;

                  /* We can finally get rid of the message */
                  MHEG5stringDestruct(&ciItem->input);

                  /* Move on to next item */
                  ciItem = ciItem->next;
               }
               else
               {
                  ERROR_PRINT(("MHEG5FileOrmProcess : error from ciFileRequest\n"));

                  /* Pass error back via callback */
                  (ciItem->callback)(ciItem->userData, ciItem->output, MHEG5FALSE);

                  /* Remove the item from the list */
                  RemoveFromCiMessageContextList(ciItem);
                  MHEG5stringDestruct(&ciItem->input);
                  MHEG5freeMem(ciItem);

                  /* Start from the beginning */
                  ciItem = ciMessageListHead;
               }
               break;
            } /* else Can't do much about this one, so fall through to 'pending' case */
         case FS_STATUS_PENDING:
            ciItem = ciItem->next;
            break;
      }
   }
#endif /*COMMON_INTERFACE*/

   inprocess = FALSE;
   return reprocess;
}

static U8BIT* buildName(MHEG5String name, MHEG5String *url, E_FS_ORIGIN *origin)
{
   U8BIT *data;
   int len;

   assert(origin);

   /* Set default to an empty string */
   *origin = ORIGIN_ERROR;

   /* Check for special service names */
   if ((name.len > 6) && (MHEG5strncmp(name.data, "dvb://", 6) == 0))
   {
      *origin = ORIGIN_DVB;
   }
   else if ((name.len > 6) && (MHEG5strncmp(name.data, "rec://", 6) == 0))
   {
      *origin = ORIGIN_REC;
   }

   if ((*origin == ORIGIN_DVB) || (*origin == ORIGIN_REC))
   {
      /* Make a copy of the input name into the output buffer */
      *url = MHEG5stringCopy( name );
      data = url->data;
   }
   else
   {
      /* Convert using name mapping rules */
      *url = MHEG5convertGIDGetOrigin(&name,origin);
      len = url->len;
      data = url->data;
      if (len == 0)
      {
         WARNING_PRINT(("buildName illegal name \"%s\"\n", name.data));
         *origin = ORIGIN_ERROR;
      }
      else
      {
         DEBUG_PRINT(("buildName [%.*s] %s, %d\n", name.len, name.data, data, *origin));
         data += MHEG5FullOriginLength(*origin);
      }
   }
   return data;
}

void MHEG5FileOrmClear( void *orm_ref )
{
   S_OrmRequest *ormRequest, *next;

   /* Start at the list head */
   ormRequest = requestListHead;

   while (ormRequest != NULL)
   {
      /* Keep a pointer to the next item in the list */
      next = ormRequest->next;

      /* Check for matching object reference */
      if (ormRequest == orm_ref && ormRequest->type == ORM_TYPE_GET)
      {
         /* Remove this entry from the request list */
         RemoveFromRequestList(ormRequest);

         /* Destroy the entry */
         ormRequest->state = ORM_STATE_ABORTED;
         ormFunctions[ormRequest->origin].Clear(ormRequest);

         next = requestListHead;
      }
      ormRequest = next;
   }
}

static MHEG5Bool MHEG5FileOrmIsWaiting(void *usr, MHEG5String url)
{
   S_OrmRequest *ormRequest, *next;
   BOOLEAN check;

   /* Start at the list head */
   ormRequest = requestListHead;

   while (ormRequest)
   {
      /* Keep a pointer to the next item in the list */
      next = ormRequest->next;

      /* Check for matching object reference */
      check = ormRequest->type == ORM_TYPE_GET && ormRequest->userData == usr;
      #ifdef INCLUDE_IC
      if (check)
      {
         /* For IC we also need to check "special" requests such as hash
          * and signature files.
          */
         check = check && !(ormRequest->r.get.priority & FRP_HASH);
      }
      #endif
      if (check)
      {
         if (ormRequest->url.len == url.len &&
             strcmp((char *)ormRequest->url.data, (char *)url.data) == 0)
         {
            return MHEG5TRUE;
         }
         else
         {
            /* matching object but requesting new name */

            /* Remove this entry from the file orm context list */
            RemoveFromRequestList(ormRequest);

            /* Destroy the entry */
            ormFunctions[ormRequest->origin].Clear(ormRequest);
            return MHEG5FALSE;
         }
      }
      ormRequest = next;
   }
   return MHEG5FALSE;
}

#ifdef INCLUDE_DSM_FG
static void FileGroupComplete( E_FsStatus status, S_CONTENT *content )
{
   S_OrmRequest *ormRequest;
   U32BIT requestId;
   requestId = (U32BIT)content->user_data;
   ormRequest = requestListHead;
   while (ormRequest != NULL)
   {
      if (ormRequest->requestId == requestId)
      {
         switch (status)
         {
            case FS_STATUS_OK:
               TRACE(TFILE, (" Got size=%d, for:%s", content->size, ormRequest->url.data));
               ormRequest->state = ORM_STATE_SUCCEEDED;
               //ormRequest->r.get.ocontent = *content;
               break;

            case FS_STATUS_INVALID:
               ormRequest->state = ORM_STATE_QUEUED;
               break;

            case FS_STATUS_ERROR:
               TRACE(TFILE, (" Failed to get %s", ormRequest->url.data));
               ormRequest->state = ORM_STATE_FAILED;
               break;

            case FS_STATUS_ABORT:
               TRACE(TFILE, (" ABORTED %s", ormRequest->url.data));
               if (ormRequest->state == ORM_STATE_REQUESTED)
               {
                  ormRequest->state = ORM_STATE_FAILED;
               }
               /* else it should already be aborted state */
               break;

            case FS_STATUS_PENDING:
               TRACE(TERROR, (" STILL PENDING! %s", ormRequest->url.data))
               ormRequest->state = ORM_STATE_REQUESTED;
               break;

            default:
               /* An error ocurred */
               TRACE(TERROR, ("UNKNOWN return %d for %s", status, ormRequest->url.data))
               ormRequest->state = ORM_STATE_FAILED;
         }
         MH5GlueAddPostProcessFunc( MHEG5FileOrmProcess );
         break;
      }
      ormRequest = ormRequest->next;
   }
}

static MHEG5Bool FileGroupAction( E_FS_ORIGIN origin, U8BIT *path, P_OrmRequest ormRequest, U16BIT priority )
{
   E_FsStatus status;
   MHEG5Bool done;
   /* not zero cache priority */
   if (priority & FRP_EXISTS)
   {
      status = FG_FileExists( origin, (char *)path );
   }
   else
   {
      status = FG_LoadRequest( origin, (char *)path, FileGroupComplete,
                  &ormRequest->r.get.ocontent, (U8BIT)(priority & FRP_CACHE_MASK) );
   }
   switch (status)
   {
      case FS_STATUS_OK:
      {
         ormRequest->state = ORM_STATE_SUCCEEDED;
         ReprocessRequestList();
         done = MHEG5TRUE;
         break;
      }
      case FS_STATUS_PENDING:
      {
         TRACE(TFILE, (" loading %s", ormRequest->url.data));
         ormRequest->state = ORM_STATE_REQUESTED;
         ReprocessRequestList();
         done = MHEG5TRUE;
         break;
      }
      case FS_STATUS_INVALID:
      {
         done = MHEG5FALSE;
         break;
      }
      default:
      case FS_STATUS_ERROR:
      {
         TRACE(TFILE, ("(%s) stat %d", ormRequest->url.data, status));
         ormRequest->state = ORM_STATE_FAILED;
         ReprocessRequestList();
         done = MHEG5TRUE;
      }
   }
   return done;
}
#endif /*INCLUDE_DSM_FG*/

void* MHEG5FileOrmGet( MHEG5String name, U16BIT priority, void *userData,
   F_CB_Good cbGood, F_CB_Fail cbFail)
{
   MHEG5String url;
#if defined(INCLUDE_DSM_FG) || defined(TRACING)
   U8BIT *path;
#endif
   E_FS_ORIGIN  origin = DEFAULT_ORIGIN;
   P_OrmRequest ormRequest;
   MHEG5Bool requestDone;

   assert( cbGood != NULL );
   assert( cbFail != NULL );

   /* Check that name is valid */
   if (!name.len)
   {
      /* Specified file name is empty - indicate that it does not exist */
      cbFail( userData );
      ormRequest = NULL;
   }
   else
   {
      /* Build absolute file name */
      #if defined(INCLUDE_DSM_FG) || defined(TRACING)
      path =
      #endif
         buildName(name, &url, &origin);
      if (origin == ORIGIN_ERROR)
      {
         /* Specified file name is invalid - indicate that it does not exist */
         cbFail( userData );
         MHEG5stringDestruct( &url );
         ormRequest = NULL;
      }
      /* Check any outstanding requests for this object */
      else if ((userData != NULL) && (MHEG5FileOrmIsWaiting(userData, url)))
      {
         TRACE(TFILE, ("repeated request (%p) for file %s", userData, url.data));
         MHEG5stringDestruct( &url );
         ormRequest = NULL;
      }
      else
      {

         ormRequest = ormFunctions[origin].Alloc();
         if (ormRequest == NULL)
         {
            TRACE(TERROR, ("memory failure, or origin not supported; url=%s", path))
            cbFail( userData );
            MHEG5stringDestruct( &url );
            ormRequest = NULL;
         }
         else
         {
            U_PARAM ud;
            ormRequest->url = url;
            ormRequest->origin = origin;
            ormRequest->userData = userData;
            ormRequest->r.get.cbGood = cbGood;
            ormRequest->r.get.cbFail = cbFail;
            ormRequest->requestId = ++globalRequestId;
            ud.u32 = globalRequestId;
            ormRequest->r.get.ocontent.user_data = ud.ptr;
            if (origin == ORIGIN_HTTP || origin == ORIGIN_HTTPS)
            {
               priority |= FRP_VERIFY;
            }
            ormRequest->r.get.priority = priority;
            TRACE(TFILE, ("Ptr=%p url=%s priority=0x%x", ormRequest, path, priority))

            /* Add request to list */
            AddToRequestList(ormRequest);
         #ifdef INCLUDE_DSM_FG
            if (!FileGroupAction(origin,path,ormRequest,priority))
         #endif
            {
               ormFunctions[origin].Action(ormRequest);
            }
            VERIFY_ORM_MAGIC(ormRequest);
            if (ormRequest->state == ORM_STATE_SUCCEEDED ||
                ormRequest->state == ORM_STATE_FAILED)
            {
               requestDone = DefaultGetProcess(ormRequest);
               if (requestDone)
               {
                  ormFunctions[origin].Clear(ormRequest);
                  ormRequest = NULL;
               }
            }
         }
      }
   }
   return ormRequest;
}

void* MHEG5FileOrmRetrieve( E_FS_ORIGIN origin, S_STRING location, S_STRING name,
   U16BIT priority, void *userData, F_CB_Good cbGood, F_CB_Fail cbFail)
{
   MHEG5String url;
   P_OrmRequest ormRequest;
   MHEG5Bool requestDone;

   assert( cbGood != NULL );
   assert( cbFail != NULL );
   assert( name.zlen );

   if (origin == ORIGIN_ERROR)
   {
      /* Specified file name is invalid - indicate that it does not exist */
      cbFail( userData );
      ormRequest = NULL;
   }
   else
   {
      url = MHEG5CreateUrl(origin,location,name);
      if (url.data == NULL)
      {
         cbFail( userData );
         ormRequest = NULL;
      }
      else
      {
         ormRequest = ormFunctions[origin].Alloc();
         if (ormRequest == NULL)
         {
            TRACE(TERROR, ("memory failure, or origin not supported; url=%s", url.data))
            cbFail( userData );
            MHEG5stringDestruct( &url );
            ormRequest = NULL;
         }
         else
         {
            U_PARAM ud;
            ormRequest->url = url;
            ormRequest->origin = origin;
            ormRequest->type = ORM_TYPE_FGR;
            ormRequest->userData = userData;
            ormRequest->r.get.cbGood = cbGood;
            ormRequest->r.get.cbFail = cbFail;
            ormRequest->requestId = ++globalRequestId;
            ud.u32 = globalRequestId;
            ormRequest->r.get.ocontent.user_data = ud.ptr;
            if (origin == ORIGIN_HTTP || origin == ORIGIN_HTTPS)
            {
               priority |= FRP_VERIFY;
            }
            ormRequest->r.get.priority = priority;
            TRACE(TFILE, ("Ptr=%p url=%s", ormRequest, url.data))

            /* Add request to list */
            AddToRequestList(ormRequest);
            ormFunctions[origin].Action(ormRequest);
            VERIFY_ORM_MAGIC(ormRequest);
            if (ormRequest->state == ORM_STATE_SUCCEEDED ||
                ormRequest->state == ORM_STATE_FAILED)
            {
               requestDone = DefaultGetProcess(ormRequest);
               if (requestDone)
               {
                  ormFunctions[origin].Clear(ormRequest);
                  ormRequest = NULL;
               }
            }
         }
      }
   }
   return ormRequest;
}

#ifdef COMMON_INTERFACE

MHEG5Bool MHEG5FileOrmSendCiMessage(MHEG5String input, F_CB_CiMsg callback, void *userData)
{
   U8BIT *data;
   CiMessageContext *w;
   S32BIT retval;
   MHEG5Bool err = MHEG5TRUE;

   DEBUG_PRINT(("INFO: MHEG5FileOrmSendCiMessage ( %.*s, 0x%x )\n", input.len, input.data));

   /* Create CI message context */
   w = (CiMessageContext *) MHEG5getMem( sizeof(CiMessageContext));
   if (!w)
   {
      ERROR_PRINT(("ERROR: MHEG5FileOrmSendCiMessage unable to allocate memory\n"));
      return MHEG5FALSE;
   }

   /* Clear newly allocated data to zero */
   memset(w, 0, sizeof(CiMessageContext));

   w->userData = userData;
   w->successFlag = FS_STATUS_INVALID;
   w->callback = callback;
   w->output.data = NULL;
   w->output.len = 0;

   /* Create CI file request for message */
   data = (U8BIT *) STR_DataAlloc( input.len + 1 );
   if (data)
   {
      /* Create CI file request for message */
      data[0] = 0x01;  /* 'data' */
      memcpy(&data[1], input.data, input.len);

      /* Add message to list of CI messages */
      AddToCiMessageContextList(w);

      if (ciRequestCount < MAX_CI_REQUESTS && !ciMessageSent)
      {
         /* Send the file request to CI module */
         retval = STB_CIFileRequest(MHEG5GetCiModuleId(), data, input.len + 1);
         if (retval == TRUE)
         {
            /* File has been requested */
            w->successFlag = FS_STATUS_PENDING;
            ciRequestCount++;
            ciMessageSent = TRUE;

            /* Can get rid of the data, it's been sent to the CI module */
            STR_DataFree(data, input.len + 1);
         }
         else
         {
            /* An error ocurred */
            ERROR_PRINT(("ERROR: MHEG5FileOrmSendCiMessage ciFileRequest retval is %d\n", retval));

            /* Remove entry from list of requested objects */
            RemoveFromCiMessageContextList(w);
            STR_DataFree(data, input.len + 1);
            MHEG5freeMem(w);
            err = MHEG5FALSE;
         }
      }
      else
      {
         /* Need to store the message until we're ready for file request */
         w->input.data = data;
         w->input.len = input.len + 1;
      }
   }
   else
   {
      /* Cannot create message, destroy context */
      ERROR_PRINT(("ERROR: MHEG5FileOrmSendCiMessage unable to allocate memory\n"));
      MHEG5freeMem(w);
      err = MHEG5FALSE;
   }

   return err;
}

#endif /*COMMON_INTERFACE*/


#ifdef INCLUDE_IC

MHEG5Bool MHEG5FileOrmReturnData(MHEG5String name, MHEG5String postData,
   F_CB_Post callback, void *userData)
{
   MHEG5String invalid = {0, 0};
   MHEG5String url;
   E_FS_ORIGIN  origin = ORIGIN_HYBRID;
   S_OrmRequest *ormRequest;
   MHEG5Bool success = MHEG5FALSE;
   MHEG5Bool requestDone;

   /* Check that URL is valid */
   if (!name.len)
   {
      /* Specified file name is empty */
      callback(userData, invalid, 0);
   }
   else
   {
      /* Build absolute file name */
      buildName(name, &url, &origin);
      if (origin == ORIGIN_ERROR)
      {
         /* Specified file name is invalid */
         callback(userData, invalid, 0);
         MHEG5stringDestruct( &url );
      }
      else
      {
         ormRequest = ormFunctions[origin].Alloc();
         if (ormRequest == NULL)
         {
         TRACE(TERROR, ("memory failure, or origin not supported; url=%s", url.data))
            callback(userData, invalid, 0);
            MHEG5stringDestruct( &url );
         }
         else
         {
            ormRequest->url = url;
            ormRequest->origin = origin;
            ormRequest->userData = userData;
            ormRequest->type = ORM_TYPE_POST;
            ormRequest->requestId = ++globalRequestId;
            ormRequest->r.post.postData = MHEG5stringCopy(postData);
            ormRequest->r.post.callback = callback;

            AddToRequestList(ormRequest);
            ormFunctions[origin].Action(ormRequest);
            if (ormRequest->state == ORM_STATE_FAILED)
            {
               TRACE(TFILE, ("Ptr=%p url=%s", ormRequest, url.data))

               requestDone = PostProcess(ormRequest);
               if (requestDone)
               {
                  ormFunctions[origin].Clear(ormRequest);
               }
            }
            else if (ormRequest->state == ORM_STATE_REQUESTED)
            {
               TRACE(TFILE,("url = \"%s\"", (char *)url.data));
               success = MHEG5TRUE;
            }
            else
            {
               MHEG5stringDestruct( &url );
               ERROR_PRINT(("MHEG5FileOrmReturnData : Unexpected result\n"));
            }
         }
      }
   }
   return success;
}

#endif /* INCLUDE_IC */

void MHEG5FileOrmPreloadHint(MHEG5String name)
{
   MHEG5String url;
   E_FS_ORIGIN origin = DEFAULT_ORIGIN;
#ifndef CI_PLUS_ONLY
   U8BIT *buffer;
#endif

   /* Check that name is valid */
   if (!name.len)
   {
      /* Specified file name is empty */
      return;
   }

   /* Build absolute file name */
#ifndef CI_PLUS_ONLY
   buffer = buildName(name, &url, &origin);
   if (origin == ORIGIN_DSM)
   {
      /* Pass the preload hint on to DSM-CC */
      DSMCC_ClientPreloadHint(MHEG5_DsmccInstance(), buffer);
   }
#else
   buildName(name, &url, &origin);
#endif

   MHEG5stringDestruct( &url );
}

#ifndef CI_PLUS_ONLY

static void FileOrmDsmGetComplete( S_FileSystemAck *param )
{
   S_OrmRequest *ormRequest;
   U_PARAM ud;
   ud.ptr = param->content.user_data;
   ormRequest = FindRequest(ud.u32);
   if (ormRequest != NULL)
   {
      assert(ormRequest->origin == ORIGIN_DSM);
      switch (param->status)
      {
         case FS_STATUS_OK:
            TRACE(TFILE, (" Got size=%d, for:%s", param->content.size, ormRequest->url.data));
            ormRequest->state = ORM_STATE_SUCCEEDED;
            ormRequest->r.get.ocontent = param->content;
            break;

         case FS_STATUS_INVALID:
            ormRequest->state = ORM_STATE_QUEUED;
            break;

         case FS_STATUS_ERROR:
            TRACE(TFILE, (" Failed to get %s", ormRequest->url.data));
            ormRequest->state = ORM_STATE_FAILED;
            break;

         case FS_STATUS_ABORT:
            TRACE(TFILE, (" ABORTED %s", ormRequest->url.data));
            if (ormRequest->state == ORM_STATE_REQUESTED)
            {
               ormRequest->state = ORM_STATE_FAILED;
            }
            /* else it should already be aborted state */
            break;

         case FS_STATUS_PENDING:
            TRACE(TERROR, (" STILL PENDING! %s", ormRequest->url.data))
            ormRequest->state = ORM_STATE_REQUESTED;
            break;

         default:
            /* An error ocurred */
            TRACE(TERROR, ("UNKNOWN return %d for %s", param->status, ormRequest->url.data))
            ormRequest->state = ORM_STATE_FAILED;
      }
      MH5GlueAddPostProcessFunc( MHEG5FileOrmProcess );
   }
}

static void FileOrmDsmccComplete( E_FsStatus status, S_CONTENT *content )
{
   S_MhegMessage msg;
#ifdef TRACING
   S_OrmRequest *ormRequest;
   ormRequest = FindRequest((U32BIT)content->user_data);
   if (ormRequest != NULL)
   {
      TRACE(TFILE, ("ptr=%p url:%s size=%u", ormRequest, ormRequest->url.data, content->size ));
   }
   else
   {
      TRACE(TFILE, ("rid=%u size=%u",(U32BIT)content->user_data, content->size));
   }
#endif
   msg.data.fsAck.content = *content;
   msg.data.fsAck.status = status;
   msg.proc_msg_func = (F_MSG_PROCESS)FileOrmDsmGetComplete;
   msg.data_type = DT_CONTENT;
   VQ_PutMsg(&msg, PRTY_NORMAL);
}
#endif /*CI_PLUS_ONLY*/

#ifdef COMMON_INTERFACE

void MHEG5ciFileAcknowledge(BOOLEAN fileOK, U8BIT *pFileData, U32BIT length)
{
#ifdef COMMON_INTERFACE
   S_OrmRequest *ormRequest;
   CiMessageContext *ciItem;
   U8BIT fileNameLength;
   char *url;
   BOOLEAN ack;

   DEBUG_PRINT(("MHEG5ciFileAcknowledge(%s, [%x %x], %d)  ciRequestCount=%d\n",
                fileOK ? "TRUE" : "FALSE", pFileData[0], pFileData[1], length, ciRequestCount));

   /* Find context */
   ack = TRUE;
   if (pFileData != NULL && length > 0 && ciRequestCount > 0)
   {
      ciRequestCount--;
      if (ciAckTimerHandle != NULL)
      {
         VT_TimerDestroy( ciAckTimerHandle );
         ciAckTimerHandle = NULL;
      }
      if (pFileData[0] == 0x00 && length > 1)   /* 'file' */
      {
         fileNameLength = pFileData[1];

         DEBUG_PRINT(("MHEG5ciFileAcknowledge: URL=%s\n", pFileData + 2));

         /* Could be either existence query or file request */
         ormRequest = requestListHead;
         while (ormRequest != NULL)
         {
            if (ormRequest->origin == ORIGIN_CI)
            {
               url = (char *)ormRequest->url.data;
               if ((ormRequest->url.len == fileNameLength) &&
                   (strncmp(url, (char *)pFileData + 2, fileNameLength) == 0))
               {
                  /* Found the file request */
                  if (fileOK && CiSetFileContent(pFileData,length,&ormRequest->r.get.ocontent))
                  {
                     ormRequest->state = ORM_STATE_SUCCEEDED;
                     /* We store the data, so do not acknowledge yet */
                     ack = FALSE;
                  }
                  else
                  {
                     ormRequest->state = ORM_STATE_FAILED;
                     if (ormRequest->type == ORM_TYPE_GET)
                     {
                        ormRequest->r.get.ocontent.size = 0;
                        ormRequest->r.get.ocontent.data = NULL;
                     }
                  }
                  break;
               }
            }
            ormRequest = ormRequest->next;
         }
      }
      else if (pFileData[0] == 0x01)   /* 'data' */
      {
         /* We can now allow more messages to be sent */
         ciMessageSent = FALSE;

         /* CI data message */
         ciItem = ciMessageListHead;
         while (ciItem != NULL)
         {
            if (ciItem->successFlag == FS_STATUS_PENDING)
            {
               /* Mark message as received */
               ciItem->successFlag = FS_STATUS_OK;
               ciItem->output.len = length;
               ciItem->output.data = pFileData;

               /* We store the data, so do not acknowledge yet */
               ack = FALSE;
               break;
            }
            ciItem = ciItem->next;
         }
      }
   }

   if (ack && pFileData != NULL)
   {
      /* Release the data, it's not needed */
      MHEG5CiAckData(pFileData);
   }
   MH5GlueAddPostProcessFunc( MHEG5FileOrmProcess );
#endif /*COMMON_INTERFACE*/
}
#endif /*COMMON_INTERFACE*/

#ifdef INCLUDE_IC

static void HybridGetCallback( void *userData, S_CONTENT *ocontent )
{
   S_OrmRequest *ormRequest;

   assert( userData );
   ormRequest = (S_OrmRequest *)userData;
   VERIFY_ORM_MAGIC(ormRequest);
   assert(ormRequest->type == ORM_TYPE_GET);
   ormRequest->r.get.ocontent = *ocontent;

   ocontent->destroy = NULL; /* don't let child request clear the data */
   ormRequest->r.get.child = NULL; /* after callback this pointer is no longer valid */

   ormRequest->state = ORM_STATE_SUCCEEDED;
   ReprocessRequestList();
}

static void HybridGetFailCallback( void *userData )
{
   S_OrmRequest *ormRequest;

   assert( userData );
   ormRequest = (S_OrmRequest *)userData;
   VERIFY_ORM_MAGIC(ormRequest);

   assert(ormRequest->origin == ORIGIN_HYBRID);
   ormRequest->state = ORM_STATE_QUEUED;
   if (ormRequest->type != ORM_TYPE_POST)
   {
      ormRequest->r.get.child = NULL;
   }

   ReprocessRequestList();
   MH5GlueAddPostProcessFunc( MHEG5FileOrmProcess );
}

static void httpRequestAck(U32BIT requestId, U32BIT status, S32BIT code,
   U8BIT *data, U32BIT len)
{
   S_OrmRequest *ormRequest;
   void *fileRef;
   BOOLEAN releaseData;

   /* Release data unless we are storing it somewhere */
   releaseData = TRUE;

   ormRequest = FindRequest(requestId);
   if (ormRequest != NULL && (IS_HTTP_REQUEST(ormRequest)))
   {
      if (status == HTTP_STATUS_OK)
      {
         TRACE(TFILE, ("code=%d", code))
         if (((code >= 301) && (code <= 305)) || (code == 307))
         {
            if (ormRequest->type != ORM_TYPE_POST)
            {
               /* Redirect -- only GET or HEAD */
               HttpRedirect(ormRequest);
            }
            else
            {
               /* POST + redirection = failure */
               ormRequest->state = ORM_STATE_FAILED;
               TRACE(TFILE, ("POST redirect Ptr=%p FAIL url=%s", ormRequest, ormRequest->url.data))
            }
         }
         else if (code != 200)
         {
            if (code >= 400 && code < 500)
            {
               if (ormRequest->type == ORM_TYPE_POST ||
                   !(ormRequest->r.get.priority & (FRP_HASH | FRP_CERT)))
               {   /* Engine events should not be generated by "external" requests */
                  MHEG5sendAppEngineEvent( EE_IC_REMOTE_ERROR );
               }
            }
            ormRequest->state = ORM_STATE_FAILED;
            TRACE(TFILE, ("Ptr=%p FAIL url=%s", ormRequest, ormRequest->url.data))
         }
         else
         {
            /* Update request data */
            if (ormRequest->type != ORM_TYPE_POST)
            {
               if (ormRequest->r.get.ocontent.data != NULL)
               {
                  MHEG5freeMem(ormRequest->r.get.ocontent.data);
               }

               ormRequest->r.get.ocontent.data = data;
               ormRequest->r.get.ocontent.size = len;
               ormRequest->r.get.ocontent.destroy = DefaultDataClear;
               ormRequest->r.get.ocontent.fs_handle = data;
               releaseData = FALSE;
            }

            /* Check the content against the hash file */
            VerifyRequestContent(ormRequest);
         }
      }
      else if (status == HTTP_STATUS_SSL_ERROR)
      {
         /* Try again, maybe there are more certificates */
         ormRequest->state = ORM_STATE_QUEUED;
         ReprocessRequestList();
      }
      else if (status == HTTP_STATUS_NETWORK_ERROR)
      {
         if (ormRequest->type == ORM_TYPE_POST ||
             !(ormRequest->r.get.priority & FRP_HASH))
         {   /* Engine events should not be generated by "external" requests */
            MHEG5sendAppEngineEvent( EE_IC_NETWORK_ERROR );
         }
         TRACE(TFILE, ("Network error Ptr=%p FAIL url=%s", ormRequest, ormRequest->url.data))
         ormRequest->state = ORM_STATE_FAILED;
      }
      else if (status == HTTP_STATUS_TIMEOUT)
      {
         /* Response code is modified for HTTP POST */
         TRACE(TFILE, ("response mod Ptr=%p FAIL url=%s", ormRequest, ormRequest->url.data))
         code = 0;
         ormRequest->state = ORM_STATE_FAILED;
      }
      else
      {
         TRACE(TFILE, ("status=%d Ptr=%p FAIL url=%s", status, ormRequest, ormRequest->url.data))
         ormRequest->state = ORM_STATE_FAILED;
      }

      if (ormRequest->type == ORM_TYPE_POST)
      {
         /* Update request */
         ormRequest->r.post.responseData.data = data;
         ormRequest->r.post.responseData.len = len;
         ormRequest->r.post.responseCode = code;
         releaseData = FALSE;
      }

      /* Destroy HTTP request */
      fileRef = ormRequest->requestRef;
      ormRequest->requestRef = NULL;
      httpStopRequest(fileRef);
      httpDestroyRequest(fileRef);
   }
   else
   {
      TRACE(TERROR, ("Cannot find request (requestId = %d)\n", requestId));
   }

   if (releaseData && data != NULL)
   {
      MHEG5freeMem(data);
   }
}

static void httpResponse(MHEG5HttpResponseEventParams_t *params)
{
   httpRequestAck(params->requestId, params->status, params->code,
      params->data, params->len);
   MH5GlueAddPostProcessFunc( MHEG5FileOrmProcess );
}

static BOOLEAN HttpGetCallback(void *userdata, U32BIT requestId,
   HttpResponse_t *response)
{
   HttpReplyBuffer *hcontent = userdata;
   MHEG5eventMessage_t event;
   E_MhegErr cqu_err;

   if (response->data_len > 0)
   {
      AppendData(hcontent, response->data, response->data_len);
   }

   if (response->status != HTTP_STATUS_WAIT)
   {
      event.proc_msg_func = (F_MSG_PROCESS)httpResponse;
      event.data_type = DT_ALLOC;
      event.data.httpResponse.requestId = requestId;
      event.data.httpResponse.status = response->status;
      event.data.httpResponse.code = response->code;
      event.data.httpResponse.data = hcontent->data;
      event.data.httpResponse.len = hcontent->used;

      cqu_err = VQ_PutMsg(&event, PRTY_NORMAL);
      if (cqu_err != MHERR_OK)
      {
         TRACE(TERROR, ("VQ_PutMsg failed", cqu_err));
         MHEG5freeMem(hcontent->data);
      }

      MHEG5freeMem(hcontent);
   }

   return TRUE;
}

static BOOLEAN HttpPostCallback(void *userdata, U32BIT requestId,
   HttpResponse_t *response)
{
   HttpReplyBuffer *hcontent = userdata;
   MHEG5eventMessage_t event;
   E_MhegErr cqu_err;

   if (response->data_len > 0)
   {
      AppendData(hcontent, response->data, response->data_len);
   }

   if (response->status != HTTP_STATUS_WAIT)
   {
      event.proc_msg_func = (F_MSG_PROCESS)httpResponse;
      event.data_type = DT_ALLOC;
      event.data.httpResponse.requestId = requestId;
      event.data.httpResponse.status = response->status;
      event.data.httpResponse.code = response->code;
      event.data.httpResponse.data = hcontent->data;
      event.data.httpResponse.len = hcontent->used;

      cqu_err = VQ_PutMsg(&event, PRTY_NORMAL);
      if (cqu_err != MHERR_OK)
      {
         TRACE(TERROR, ("VQ_PutMsg failed", cqu_err));
         MHEG5freeMem(hcontent->data);
      }

      MHEG5freeMem(hcontent);
   }

   return TRUE;
}

#endif /*INCLUDE_IC*/


#ifndef CI_PLUS_ONLY

static void DsmAction(S_OrmRequest *ormRequest)
{
   E_FsStatus retval;
   U32BIT flags;
   U8BIT *path;

   assert(ormRequest->origin == ORIGIN_DSM);

   path = ormRequest->url.data + MHEG5FullOriginLength(ORIGIN_DSM);

   TRACE(TFILE,("Fetching url: %s", (char *)ormRequest->url.data));

   flags = ormRequest->r.get.priority & FRP_CACHE_MASK;
   if (ormRequest->r.get.priority & FRP_EXISTS)
   {
      flags |= LOAD_FLAGS_REQUEST_EXISTANCE_BIT;
   }
   if (ormRequest->r.get.priority & FRP_DEFER_SERV)
   {
      flags |= LOAD_FLAGS_REQUEST_DEFERRED_SERVICE_BIT;
   }
   if (ormRequest->r.get.priority & FRP_GROUP)
   {
      flags |= LOAD_FLAGS_REQUEST_FILE_ONLY_BIT;
   }
   retval = DSMCC_ClientLoadObject( MHEG5_DsmccInstance(), path, flags,
         FileOrmDsmccComplete, &ormRequest->r.get.ocontent );
   TRACE(TFILE, ("ref=%p Ptr=%p", ormRequest->requestRef, ormRequest))
   TRACE(TFILE, ("url=%s, rtn=%d", ormRequest->url.data, retval))
   switch (retval)
   {
      case FS_STATUS_OK:
         assert(ormRequest->requestRef == NULL);
         ormRequest->state = ORM_STATE_SUCCEEDED;
         ReprocessRequestList();
         break;

      case FS_STATUS_PENDING:
         TRACE(TFILE, (" loading %s", ormRequest->url.data));
         ormRequest->state = ORM_STATE_REQUESTED;
         ReprocessRequestList();
         break;

      case FS_STATUS_INVALID:
         /* File cannot be requested yet, as there is no carousel (and we're doing NDT) */
         ormRequest->state = ORM_STATE_QUEUED;
         break;

      default:
         /* An error ocurred */
         TRACE(TFILE, ("dsmFLoad(%s) retval is %d\n", ormRequest->url.data, retval));
         ormRequest->state = ORM_STATE_FAILED;
         ReprocessRequestList();
   }
}

#endif  /* !CI_PLUS_ONLY */

#ifndef CI_PLUS_ONLY

static void DsmClear(S_OrmRequest *ormRequest)
{
   VERIFY_ORM_MAGIC(ormRequest);
   assert(ormRequest->origin == ORIGIN_DSM);

   TRACE(TFILE, ("Ptr=%p url(%d)=%s", ormRequest,ormRequest->url.len,ormRequest->url.data))

   if (ormRequest->r.get.ocontent.destroy != NULL)
   {
      /* call the clear function for the content owner */
      ormRequest->r.get.ocontent.destroy( ormRequest->r.get.ocontent.fs_handle );
   }
   MHEG5stringDestruct( &ormRequest->url );

   CLEAR_ORM_MAGIC(ormRequest);
   MHEG5freeMem(ormRequest);
}

#endif  /* !CI_PLUS_ONLY */

static void DvbAction(S_OrmRequest *ormRequest)
{
   MHEG5Bool success;

   assert(ormRequest->origin == ORIGIN_DVB || ormRequest->origin == ORIGIN_REC);

   /* Resolve the URL */
   success = MHEG5parseUrl(ormRequest->url.data, ormRequest->url.len,
         &dvbMultiplexReference );
   if (success)
   {
      ormRequest->r.get.ocontent.data = (U8BIT *)&dvbMultiplexReference;
      ormRequest->r.get.ocontent.size = sizeof(S_DVB_LOCATOR);

      /* there is no need to do any clear on data */
      assert( ormRequest->r.get.ocontent.destroy == NULL );
      assert( ormRequest->r.get.ocontent.fs_handle == NULL );

      ormRequest->state = ORM_STATE_SUCCEEDED;
   }
   else
   {
      ormRequest->state = ORM_STATE_FAILED;
   }
   ReprocessRequestList();
}

static void DvbClear(S_OrmRequest *ormRequest)
{
   VERIFY_ORM_MAGIC(ormRequest);
   MHEG5stringDestruct( &ormRequest->url );
   assert(ormRequest->type == ORM_TYPE_GET);
}

#ifdef INCLUDE_IC

static void HybrAction(S_OrmRequest *ormRequest)
{
   MHEG5String reference;
   MHEG5String mapped;
   E_FS_ORIGIN origin;
   MHEG5Int offset;

   assert(ormRequest->origin == ORIGIN_HYBRID);
   assert(ormRequest->state == ORM_STATE_START);

   TRACE(TFILE,("Fetching url: %s", (char *)ormRequest->url.data));

   reference.len = ormRequest->url.len - 7;
   reference.data = ormRequest->url.data + 7;

   if (ormRequest->hybrid_mapping == NULL)
   {
      ormRequest->hybrid_mapping = MHEG5GetHybridFileSystemMapping(&reference);
      MHEG5InitMappingIter(&ormRequest->hybrid_iter, ormRequest->hybrid_mapping);
   }

   do {
      mapped = MHEG5GetNextReference(&reference, &ormRequest->hybrid_iter);
      if (mapped.len != 0)
      {
         ormRequest->state = ORM_STATE_REQUESTED;
         if (ormRequest->type == ORM_TYPE_FGR)
         {
            if (MHEG5ResolveOrigin(&mapped,&origin,&offset))
            {
               S_STRING path,name;
               path.zlen = mapped.len - offset;
               path.zptr = mapped.data + offset;
               name.zlen = 0;
               name.zptr = NULL;
               ormRequest->r.get.child = MHEG5FileOrmRetrieve( origin, path, name, ormRequest->r.get.priority,
                     ormRequest, HybridGetCallback, HybridGetFailCallback );
            }
         }
         else
         {
            ormRequest->r.get.child = MHEG5FileOrmGet( mapped, ormRequest->r.get.priority, ormRequest,
                  HybridGetCallback, HybridGetFailCallback );
         }
         MHEG5stringDestruct(&mapped);
      }
      else
      {
         MHEG5ReleaseHybridFileSystemMapping(ormRequest->hybrid_mapping);
         ormRequest->hybrid_mapping = NULL;
         ormRequest->state = ORM_STATE_FAILED;
         ReprocessRequestList();
         break;
      }
      /* ORM_STATE_QUEUED means HybridGetFailCallback was called synchronously,
       * so can loop here to move to next reference */
   } while (ormRequest->state == ORM_STATE_QUEUED);
}

static void HybrClear(S_OrmRequest *ormRequest)
{
   VERIFY_ORM_MAGIC(ormRequest);
   assert(ormRequest->origin == ORIGIN_HYBRID);

   if (ormRequest->r.get.ocontent.destroy != NULL)
   {
      /* call the clear function for the content owner */
      ormRequest->r.get.ocontent.destroy( ormRequest->r.get.ocontent.fs_handle );
   }
   TRACE(TFILE,("ptr=%p url=\"%s\"",ormRequest,(char *)ormRequest->url.data));
   if (ormRequest->r.get.child != NULL)
   {
      S_OrmRequest *childRequest = (S_OrmRequest *)ormRequest->r.get.child;

      VERIFY_ORM_MAGIC(childRequest);
      assert(childRequest->userData == ormRequest);

      /* Remove and clear and child request */
      RemoveFromRequestList(childRequest);
      childRequest->state = ORM_STATE_ABORTED;
      ormFunctions[childRequest->origin].Clear(childRequest);
   }
   /* Release hybrid mapping */
   if (ormRequest->hybrid_mapping != NULL)
   {
      MHEG5ReleaseHybridFileSystemMapping(ormRequest->hybrid_mapping);
      ormRequest->hybrid_mapping = NULL;
   }
   MHEG5stringDestruct( &ormRequest->url );

   CLEAR_ORM_MAGIC(ormRequest);
   MHEG5freeMem(ormRequest);
}

#endif /* INCLUDE_IC */

static MHEG5Bool DefaultGetProcess(S_OrmRequest *ormRequest)
{
   MHEG5Bool requestDone;

   requestDone = MHEG5FALSE;

   if (ormRequest->state == ORM_STATE_SUCCEEDED)
   {
      /* Do not process groups when the engine is not active */
      if (MH5GlueActiveState() || !(ormRequest->r.get.priority & FRP_GROUP))
      {
         /* Remove the request from the list */
         RemoveFromRequestList(ormRequest);

         TRACE(TFILE, ("Ptr=%p GOT IT url=%s", ormRequest, ormRequest->url.data))

         /* Dump out all retrieved files in hex - useful for capturing ASN1 files
          * over serial port or on Windows application */
         PRINTFILE( ormRequest->type, ormRequest->url.data, ormRequest->r.get.ocontent.data, ormRequest->r.get.ocontent.size );

         /* Return file contents */
         ormRequest->r.get.cbGood( ormRequest->userData, &ormRequest->r.get.ocontent );

         requestDone = MHEG5TRUE;
      }
      else
      {
         TRACE(TFILE, ("Delay process of file, url=%s", ormRequest, ormRequest->url.data))
      }
   }
   else if (ormRequest->state == ORM_STATE_FAILED)
   {
      /* Remove the request from the list */
      RemoveFromRequestList(ormRequest);

      TRACE(TFILE, ("Ptr=%p FAIL url=%s", ormRequest, ormRequest->url.data))

      /* Notify that the load operation failed */
      if (ormRequest->r.get.cbFail != NULL)
      {
         ormRequest->r.get.cbFail( ormRequest->userData );
      }
      requestDone = MHEG5TRUE;
   }
   else if (ormRequest->state == ORM_STATE_ABORTED)
   {
      /* Remove the request from the list */
      RemoveFromRequestList(ormRequest);

      TRACE(TFILE, ("Ptr=%p ABORT url=%s", ormRequest, ormRequest->url.data))

      /* No notifications */
      requestDone = MHEG5TRUE;
   }
   else if (ormRequest->state == ORM_STATE_QUEUED ||
            ormRequest->state == ORM_STATE_HAS_ACCESS)
   {
      TRACE(TFILE, ("Ptr=%p QUEUE url=%s", ormRequest, ormRequest->url.data))

      /* Try again */
      ormRequest->state = ORM_STATE_START;
      ormFunctions[ormRequest->origin].Action(ormRequest);
   }
   else if (ormRequest->state == ORM_STATE_CHECK_VERIFY ||
            ormRequest->state == ORM_STATE_CHECK_ACCESS)
   {
      TRACE(TFILE, ("Ptr=%p OK url=%s", ormRequest, ormRequest->url.data))

      /* Must not restart request, as it already has content */
      ormFunctions[ormRequest->origin].Action(ormRequest);
   }

   return requestDone;
}

/*****************************************************************************/



#ifdef INCLUDE_IC

static void HttpRedirect(S_OrmRequest *ormRequest)
{
   MHEG5String url;
   U8BIT *redirectUrl;
   E_FS_ORIGIN origin;
   MHEG5String name;

   assert(ormRequest->type != ORM_TYPE_POST && IS_HTTP_REQUEST(ormRequest));

   ormRequest->state = ORM_STATE_FAILED;

   if (ormRequest->redirectCount < MAX_REDIRECTS)
   {
      redirectUrl = httpGetRequestRedirect(ormRequest->requestRef);
      if (redirectUrl != NULL)
      {
         /* Build absolute file name */
         name.data = redirectUrl;
         name.len = strlen((char *)redirectUrl);
         buildName(name, &url, &origin);
         if ((origin == ORIGIN_HTTP) || (origin == ORIGIN_HTTPS))
         {
            MHEG5stringDestruct( &ormRequest->url );
            ormRequest->url = url;
            ormRequest->origin = origin;

            ++ormRequest->redirectCount;
            ormRequest->certCount = 0;
            ormRequest->state = ORM_STATE_QUEUED;
            ReprocessRequestList();
         }
         else
         {
            MHEG5stringDestruct( &url );
         }
      }
   }
}

static MHEG5Bool PostProcess(S_OrmRequest *ormRequest)
{
   MHEG5Bool requestDone;

   assert(ormRequest->type == ORM_TYPE_POST);

   requestDone = MHEG5FALSE;
   if (ormRequest->state == ORM_STATE_SUCCEEDED ||
       ormRequest->state == ORM_STATE_FAILED)
   {
      /* Remove the request from the list */
      RemoveFromRequestList(ormRequest);

      ormRequest->r.post.callback(ormRequest->userData, ormRequest->r.post.responseData,
         ormRequest->r.post.responseCode);

      requestDone = MHEG5TRUE;
   }
   else if (ormRequest->state == ORM_STATE_CHECK_VERIFY ||
            ormRequest->state == ORM_STATE_CHECK_ACCESS)
   {
      /* Must not restart request, as it already has content */
      ormFunctions[ormRequest->origin].Action(ormRequest);
   }

   return requestDone;
}

#endif /* INCLUDE_IC */

#ifdef COMMON_INTERFACE

static BOOLEAN CiSetFileContent(U8BIT *data, U32BIT size, S_CONTENT *pContent)
{
   U8BIT *fileData;
   U32BIT fileSize;
   U8BIT fileNameLength;

   /* File data must be processed */
   fileData = NULL;
   fileSize = 0;
   if (size > 1)
   {
      fileNameLength = data[1];
      if (size >= fileNameLength + 6U)
      {
         fileData = data + fileNameLength + 2;
         fileSize = (fileData[0] << 24 |
                     fileData[1] << 16 |
                     fileData[2] << 8 | fileData[3]);
         fileData += 4;
         if (size < fileSize + fileNameLength + 6)
         {
            fileData = NULL;
            fileSize = 0;
         }
      }
   }
   if (fileData == NULL)
   {
      return FALSE;
   }
   /* Return file contents */
   pContent->data = fileData;
   pContent->size = fileSize;
   pContent->destroy = (F_DESTROY)MHEG5CiAckData;
   pContent->fs_handle = (FS_HANDLE)fileData;
   return TRUE;
}

static void CiAction(S_OrmRequest *ormRequest)
{
   U8BIT ciRequest[MHEG5_ABSOLUTE_PATH_LENGTH + 1];
   size_t length;
   S32BIT retval;

   assert(ormRequest->origin == ORIGIN_CI);

   ormRequest->state = ORM_STATE_FAILED;
   if (ciRequestCount < MAX_CI_REQUESTS)
   {
      /* Create CI file request */
      length = ormRequest->url.len;
      if (length <= MHEG5_ABSOLUTE_PATH_LENGTH)
      {
         ciRequest[0] = 0x00;  /* 'file' */
         memcpy(&ciRequest[1], ormRequest->url.data, length);

         TRACE(TFILE, ("Ptr=%p len=%d url=%s", length,ormRequest->url.data))

         /* Request the file from the CAM */
         retval = STB_CIFileRequest(MHEG5GetCiModuleId(), ciRequest, length + 1);
         if (retval == TRUE)
         {
            /* File has been requested */
            ormRequest->state = ORM_STATE_REQUESTED;
            ciRequestCount++;
         }
      }
   }
   else
   {
      /* Cannot request at the moment */
      ormRequest->state = ORM_STATE_QUEUED;
   }
}

static void CiClear(S_OrmRequest *ormRequest)
{
   VERIFY_ORM_MAGIC(ormRequest);
   assert( ormRequest->origin == ORIGIN_CI );

   TRACE(TFILE, ("Ptr=%p url(%d)=%s", ormRequest,ormRequest->url.len,ormRequest->url.data))

   if (ormRequest->r.get.ocontent.destroy != NULL)
   {
      /* call the clear function for the content owner */
      assert( ormRequest->r.get.ocontent.destroy == (F_DESTROY)MHEG5CiAckData );
      ormRequest->r.get.ocontent.destroy( ormRequest->r.get.ocontent.fs_handle );
   }
   MHEG5stringDestruct( &ormRequest->url );

   CLEAR_ORM_MAGIC(ormRequest);
   MHEG5freeMem(ormRequest);
}

#endif /*COMMON_INTERFACE*/

#ifdef INCLUDE_IC

static BOOLEAN HttpExistsCallback(void *userdata, U32BIT requestId,
   HttpResponse_t *response)
{
   MHEG5eventMessage_t event;
   E_MhegErr cqu_err;

   if (response->status != HTTP_STATUS_WAIT)
   {
      event.proc_msg_func = (F_MSG_PROCESS)httpResponse;
      event.data_type = DT_VALUE;
      event.data.httpResponse.requestId = requestId;
      event.data.httpResponse.status = response->status;
      event.data.httpResponse.code = response->code;
      event.data.httpResponse.data = NULL;
      event.data.httpResponse.len = 0;

      cqu_err = VQ_PutMsg(&event, PRTY_NORMAL);
      if (cqu_err != MHERR_OK)
      {
         TRACE(TERROR, ("VQ_PutMsg failed", cqu_err));
      }
   }
   return TRUE;
}

static void HttpAction(S_OrmRequest *ormRequest)
{
   MHEG5Bool connectionEnabled;

   assert(IS_HTTP_REQUEST(ormRequest));

   TRACE(TFILE,("Fetching / checking url \"%s\"", (char *)ormRequest->url.data));

   /* Check whether connection is allowed */
   MHEG5isConnectionEnabled(&connectionEnabled);
   if (connectionEnabled)
   {
      /* IC is Active */
      TRACE(TFILE,("[1] state = %s\n", ORM_STATE_STRING(ormRequest)));
      if (ormRequest->state == ORM_STATE_START ||
          ormRequest->state == ORM_STATE_CHECK_ACCESS)
      {
         CheckServerAccess(ormRequest);
      }
      TRACE(TFILE,("[2] state = %s\n", ORM_STATE_STRING(ormRequest)));
      if (ormRequest->state == ORM_STATE_HAS_ACCESS)
      {
         CheckTlsCertificates(ormRequest);
      }
      TRACE(TFILE,("[3] state = %s\n", ORM_STATE_STRING(ormRequest)));
      if (ormRequest->state == ORM_STATE_HAS_CERT)
      {
         PerformHttpRequest(ormRequest);
      }
      TRACE(TFILE,("[4] state = %s\n", ORM_STATE_STRING(ormRequest)));
      if (ormRequest->state == ORM_STATE_CHECK_VERIFY)
      {
         VerifyRequestContent(ormRequest);
      }
      TRACE(TFILE,("[5] state = %s\n", ORM_STATE_STRING(ormRequest)));
      if (ormRequest->state == ORM_STATE_FAILED)
      {
         ReprocessRequestList();
      }
   }
   else
   {
      /* IC is not active */
      if (ormRequest->type == ORM_TYPE_POST ||
          !(ormRequest->r.get.priority & FRP_HASH))
      {   /* Engine events should not be generated by "external" requests */
         MHEG5sendAppEngineEvent( EE_IC_LOCAL_ERROR );
      }
      ormRequest->state = ORM_STATE_FAILED;
      ReprocessRequestList();
   }
}

static void HttpClear(S_OrmRequest *ormRequest)
{
   VERIFY_ORM_MAGIC(ormRequest);
   assert(IS_HTTP_REQUEST(ormRequest));

   TRACE(TFILE, ("Ptr=%p url(%d)=%s", ormRequest,ormRequest->url.len,ormRequest->url.data))

   if (ormRequest->state == ORM_STATE_REQUESTED)
   {
      httpStopRequest(ormRequest->requestRef);
      httpDestroyRequest(ormRequest->requestRef);
      ormRequest->requestRef = NULL;
   }

   if (ormRequest->type == ORM_TYPE_GET || ormRequest->type == ORM_TYPE_FGR)
   {
      if (ormRequest->r.get.ocontent.destroy != NULL)
      {
         /* call the clear function for the content owner */
         ormRequest->r.get.ocontent.destroy(ormRequest->r.get.ocontent.fs_handle );
      }
   }
   else if (ormRequest->type == ORM_TYPE_POST)
   {
      if (ormRequest->r.post.responseData.data != NULL)
      {
         MHEG5freeMem(ormRequest->r.post.responseData.data);
      }
      MHEG5stringDestruct(&ormRequest->r.post.postData);
   }

   MHEG5stringDestruct( &ormRequest->url );

   CLEAR_ORM_MAGIC(ormRequest);
   MHEG5freeMem(ormRequest);
}

static void CheckServerAccess(S_OrmRequest *ormRequest)
{
   MHEG5ServerAccess_t permission;
   BOOLEAN check;

   check = TRUE;

   if (ormRequest->redirectCount > 0)
   {
      /* Redirections are not checked */
      check = FALSE;
   }
   else if (ormRequest->type != ORM_TYPE_POST)
   {
      if (ormRequest->r.get.priority & (FRP_HASH | FRP_CERT))
      {
         /* Special files are not checked */
         check = FALSE;
      }
   }

   if (check)
   {
      /* Check server access */
      ormRequest->state = ORM_STATE_WAIT_ACCESS;
      permission = MHEG5CheckServerPermitted(ormRequest->url.data);
      switch (permission)
      {
         case SERVER_ACCESS_PERMITTED_AUTH:
            ormRequest->state = ORM_STATE_HAS_ACCESS;
            break;
         case SERVER_ACCESS_PERMITTED_NO_AUTH:
            ormRequest->state = ORM_STATE_HAS_ACCESS;
            if (ormRequest->type != ORM_TYPE_POST)
            {
               ormRequest->r.get.priority &= ~FRP_VERIFY;
            }
            break;
         case SERVER_ACCESS_BLOCKED:
            ormRequest->state = ORM_STATE_FAILED;
            break;
         case SERVER_ACCESS_PENDING:
            break;
         default:
            PRINT_ERROR(("Invalid server access permission\n"));
            assert(0);
      }
   }
   else
   {
      ormRequest->state = ORM_STATE_HAS_ACCESS;
   }
}

static void CheckTlsCertificates(S_OrmRequest *ormRequest)
{
   U32BIT certCount;
   MHEG5TlsCertRequestStatus status;

   if (IS_HTTPS_REQUEST(ormRequest))
   {
      /* Check TLS certificates */
      ormRequest->state = ORM_STATE_WAIT_CERT;

      certCount = MHEG5GetTlsCertStoreCount();
      if (certCount == 0 || ormRequest->certCount == certCount)
      {
         /* Either no certificates, or no new certificates - request
          * next certificate
          */
         status = MHEG5GetNextTlsCertificate();
         if (status == MHEG5_TLS_CERT_REQUEST_SUCCESS)
         {
            /* New certificates obtained (synchronously) */
            ormRequest->certCount = MHEG5GetTlsCertStoreCount();
            ormRequest->state = ORM_STATE_HAS_CERT;
         }
         else if (status == MHEG5_TLS_CERT_REQUEST_FAILURE)
         {
            ormRequest->state = ORM_STATE_FAILED;
         }
      }
      else if (ormRequest->certCount < certCount)
      {
         /* No need to request new certificates */
         ormRequest->certCount = certCount;
         ormRequest->state = ORM_STATE_HAS_CERT;
      }
   }
   else
   {
      /* HTTP requests don't need to check certificates */
      ormRequest->state = ORM_STATE_HAS_CERT;
   }
}

static void PerformHttpRequest(S_OrmRequest *ormRequest)
{
   HttpRequest_t httpRequest;
   U8BIT *postData;
   HttpReplyBuffer *hcontent;
   U16BIT priority;
   U8BIT cachePriority;

   hcontent = NULL;
   if (ormRequest->type != ORM_TYPE_POST)
   {
      priority = ormRequest->r.get.priority;
   }
   else
   {
      priority = 0;
   }
   if (!(priority & FRP_EXISTS))
   {
      /* Requests with hcontent need a placeholder for the content */
      hcontent = MHEG5getMem(sizeof *hcontent);
      if (hcontent != NULL)
      {
         hcontent->allocated = 0;
         hcontent->used = 0;
         hcontent->data = NULL;
         hcontent->valid = TRUE;
      }
      else
      {
         ormRequest->state = ORM_STATE_FAILED;
      }
   }
   if (ormRequest->state != ORM_STATE_FAILED)
   {
      /* Perform the actual request */
      httpRequest = NULL;
      if (priority & FRP_EXISTS)
      {
         httpRequest = httpCreateHeadRequest(ormRequest->url.data,
               HttpExistsCallback,
               ormRequest->requestId, NULL);
      }
      else if (ormRequest->type != ORM_TYPE_POST)
      {
         if ((ormRequest->r.get.priority & (FRP_GROUP | FRP_CACHE_MASK))
             == FRP_GROUP)
         {
            /* For groups, cache priority 0 is transparent caching */
            cachePriority = 1;
         }
         else
         {
            cachePriority = ormRequest->r.get.priority & FRP_CACHE_MASK;
         }
         httpRequest = httpCreateGetRequest(ormRequest->url.data,
               cachePriority,
               HttpGetCallback,
               ormRequest->requestId, hcontent);
         TRACE(TFILE,("httpRequest =%p", httpRequest));
      }
      else // if (ormRequest->type == ORM_TYPE_POST)
      {
         postData = ormRequest->r.post.postData.data;
         httpRequest = httpCreatePostRequest(ormRequest->url.data,
               postData,
               HttpPostCallback,
               ormRequest->requestId, hcontent);
      }

      if (httpRequest != NULL)
      {
         ormRequest->requestRef = httpRequest;
         ormRequest->state = ORM_STATE_REQUESTED;
         httpStartRequest(httpRequest);
      }
      else
      {
         MHEG5freeMem(hcontent);
         ormRequest->state = ORM_STATE_FAILED;
      }
   }
}

static void VerifyRequestContent(S_OrmRequest *ormRequest)
{
   MHEG5ContentVerification_t status;
   TRACE(TFILE, (""))
   if ((ormRequest->type == ORM_TYPE_GET || ormRequest->type == ORM_TYPE_FGR) &&
       !(ormRequest->r.get.priority & FRP_EXISTS))
   {
      if (ormRequest->r.get.priority & FRP_HASH)
      {
         /* Hash requests are always ok, otherwise we have an infinite loop */
         ormRequest->state = ORM_STATE_SUCCEEDED;
      }
      else if (ormRequest->r.get.priority & (FRP_VERIFY | FRP_GROUP))
      {
         TRACE(TFILE,("Checking %s\n", ormRequest->url.data));
         status = MHEG5IsContentVerified( ormRequest->url.data, ormRequest->r.get.ocontent.data,
               ormRequest->r.get.ocontent.size );
         switch (status)
         {
            case CONTENT_NOT_VERIFIED_SAME:
               TRACE(TFILE,("CONTENT_NOT_VERIFIED_SAME\n"));
               ormRequest->state = ORM_STATE_FAILED;
               MHEG5ResetHashFile(ormRequest->url.data);
               ReprocessRequestList();
               break;
            case CONTENT_NOT_VERIFIED_NEW:
               TRACE(TFILE,("CONTENT_NOT_VERIFIED_NEW\n"));
               /* Failed verification, try again (from the start) */
               ormRequest->state = ORM_STATE_QUEUED;
               ormRequest->certCount = 0;
               MHEG5ResetHashFile(ormRequest->url.data);
               ReprocessRequestList();
               break;
            case CONTENT_VERIFIED_SIGNED:
               TRACE(TFILE,("CONTENT_VERIFIED_SIGNED\n"));
               ormRequest->state = ORM_STATE_SUCCEEDED;
               MHEG5ResetHashFile(ormRequest->url.data);
               ReprocessRequestList();
               break;
            case CONTENT_VERIFIED_UNSIGNED:
               TRACE(TFILE,("CONTENT_VERIFIED_UNSIGNED\n"));
               if (ormRequest->r.get.priority & FRP_GROUP)
               {
                  /* Groups must be signed */
                  ormRequest->state = ORM_STATE_FAILED;
               }
               else
               {
                  /* Content can be unsigned */
                  ormRequest->state = ORM_STATE_SUCCEEDED;
               }
               MHEG5ResetHashFile(ormRequest->url.data);
               ReprocessRequestList();
               break;
            case CONTENT_VERIFICATION_PENDING:
               TRACE(TFILE,("CONTENT_VERIFICATION_PENDING\n"));
               ormRequest->state = ORM_STATE_WAIT_VERIFY;
               break;
         }
      }
      else
      {
         TRACE(TFILE, (""))
         /* Server access file indicated that content verification is
          * not required, and the request is for content (not group).
          */
         ormRequest->state = ORM_STATE_SUCCEEDED;
      }
   }
   else
   {
      TRACE(TFILE, (""))
      /* Content is only verified for 'Get' requests */
      ormRequest->state = ORM_STATE_SUCCEEDED;
   }
}

static void TlsCertCallback(void)
{
   S_OrmRequest *ormRequest;

   ormRequest = requestListHead;
   while (ormRequest != NULL)
   {
      if (ormRequest->state == ORM_STATE_WAIT_CERT)
      {
         assert(IS_HTTPS_REQUEST(ormRequest));
         ormRequest->state = ORM_STATE_QUEUED;
         ReprocessRequestList();
      }
      ormRequest = ormRequest->next;
   }
}

static void ServerAccessCallback(void)
{
   S_OrmRequest *ormRequest;

   ormRequest = requestListHead;
   while (ormRequest != NULL)
   {
      if ((IS_HTTP_REQUEST(ormRequest)) &&
          (ormRequest->state == ORM_STATE_WAIT_ACCESS))
      {
         ormRequest->state = ORM_STATE_CHECK_ACCESS;
      }
      ormRequest = ormRequest->next;
   }
   ReprocessRequestList();
}

static void VerificationCallback(void)
{
   S_OrmRequest *ormRequest;

   ormRequest = requestListHead;
   while (ormRequest != NULL)
   {
      if ((IS_HTTP_REQUEST(ormRequest)) &&
          (ormRequest->state == ORM_STATE_WAIT_VERIFY))
      {
         ormRequest->state = ORM_STATE_CHECK_VERIFY;
      }
      ormRequest = ormRequest->next;
   }
   ReprocessRequestList();
}

static void AppendData(HttpReplyBuffer *hcontent, U8BIT *data, U32BIT dataLen)
{
   U32BIT size;
   U8BIT *new_data;

   if (hcontent->valid)
   {
      if (hcontent->allocated == 0)
      {
         size = dataLen;

         /* This finds the next power of two */
         --size;
         size |= size >> 16;
         size |= size >> 8;
         size |= size >> 4;
         size |= size >> 2;
         size |= size >> 1;
         ++size;

         if (size < MIN_HTTP_REPLY_BLOCK)
         {
            size = MIN_HTTP_REPLY_BLOCK;
         }
         hcontent->data = MHEG5getMem(size + 1);
         if (hcontent->data != NULL)
         {
            hcontent->allocated = size;
            hcontent->used = dataLen;
            memcpy(hcontent->data, data, dataLen);
            hcontent->data[hcontent->used] = '\0';
         }
      }
      else if (hcontent->allocated >= hcontent->used + dataLen)
      {
         memcpy(hcontent->data + hcontent->used, data, dataLen);
         hcontent->used += dataLen;
      }
      else
      {
         size = hcontent->allocated;
         do
         {
            size *= 2;
         }
         while (size < hcontent->used + dataLen);
         new_data = MHEG5getMem(size + 1);
         if (new_data != NULL)
         {
            memcpy(new_data, hcontent->data, hcontent->used);
            memcpy(new_data + hcontent->used, data, dataLen);
            MHEG5freeMem(hcontent->data);
            hcontent->allocated = size;
            hcontent->used += dataLen;
            hcontent->data = new_data;
            hcontent->data[hcontent->used] = '\0';
         }
         else
         {
            MHEG5freeMem(hcontent->data);
            hcontent->used = 0;
            hcontent->allocated = 0;
            hcontent->valid = FALSE;
         }
      }
   }
}

#endif /* INCLUDE_IC */

static void ReprocessRequestList(void)
{
   if (inprocess)
   {
      reprocess = TRUE;
   }
   else
   {
      MH5GlueAddPostProcessFunc( MHEG5FileOrmProcess );
   }
}

static void ProcessRequestList(void)
{
   S_OrmRequest *ormRequest;
   MHEG5Bool requestDone;

   ormRequest = requestListHead;
   while (ormRequest != NULL)
   {
      requestDone =
      #ifdef INCLUDE_IC
         (ormRequest->type == ORM_TYPE_POST)? PostProcess(ormRequest) :
      #endif
         DefaultGetProcess(ormRequest);
      if (requestDone)
      {
         /* Clear request */
         ormFunctions[ormRequest->origin].Clear(ormRequest);

         /* Start from the beginning */
         ormRequest = requestListHead;
      }
      else
      {
         ormRequest = ormRequest->next;
      }
   }
}

#if !defined(CI_PLUS_ONLY) || defined(INCLUDE_IC)

static S_OrmRequest* FindRequest(U32BIT requestId)
{
   S_OrmRequest *ormRequest;

   ormRequest = requestListHead;
   while (ormRequest != NULL)
   {
      if (ormRequest->requestId == requestId)
      {
         break;
      }
      ormRequest = ormRequest->next;
   }

   return ormRequest;
}
#endif