mh5filegroup.c

Go to the documentation of this file.

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

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

#include "stb_nvm.h"
#include "glue_debug.h"
#include "glue_memory.h"
#include "glue_timers.h"
#include "glue_queue.h"
#include "mh5json.h"
#include "mh5gate.h"
#include "dsm_control.h"
#include "glue_dsmcc.h"
#include "mh5support.h"
#include "mh5fileorm.h"
#include "mh5filegroup.h"

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

#define VERSION_TOKEN            "version"
#define SIZE_TOKEN               "size"
#define NODES_TOKEN              "nodes"
#define NODE_TOKEN               "node"
#define COUNT_TOKEN              "count"

#define MANIFEST_TIMEOUT         500 /* 500 msecs */
#define MANIFEST_TIME_STOP       600 /* (5 mins / 500 msecs) */
#define MAX_MAN_HDR_SIZE         224 /* this plus manifest file size must be less than MAX_MANIFEST_FILE_SIZE */
#define MAX_PATH_LEN             64
#define GROUP_DIR_LEN            8

#define MAX_SIZE_OF_CACHED_FILE  (32 * 1024)

#define USE_FROM_CAROUSEL        0x80
#define USE_VERSION_FLAG         0x40

#define FG_PROFILE_ALL           0x00
#define FG_PROFILE_HD_GRAPHICS   0x01
#define FG_PROFILE_HD_VIDEO      0x02
#define FG_PROFILE_IC            0x03
#define FG_PROFILE_ICS           0x04
#define FG_PROFILE_ICES          0x05
#define FG_PROFILE_LIFECYCLE     0x06
#define FG_PROFILE_NATIVE_APP    0x07
#define FG_PROFILE_DL_FONT       0x08
#define FG_PROFILE_SI            0x80
#define FG_PROFILE_PVR           0x81

#define INVALID_NODE_COUNTER     1000  /* any number greater than 999 */

#define MAX_SPECIAL_OWNER_ID     0x0003
#define MAX_SPECIAL_GROUP_ID     0x0009
#define NAME_CHAR_OFFSET         17

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


typedef struct s_node
{
   U16BIT count;
   U16BIT nflen;
   char *nfname;
   union
   {
      /* for single file (count==0), use 'content' for file data */
      S_CONTENT content;
      /* for multiple files (count!=0), use 'contents' which points to array of file data */
      S_CONTENT *contents;
   } u;
} S_NODE;

typedef enum
{
   FGS_PASSIVE,
   FGS_STALE,
   FGS_LOADING,
   FGS_PENDING,
   FGS_ACTIVE,
   FGS_ERROR
} E_FGS_STATUS;

/* structure to hold loaded groups of files - saved (or to be saved) in NVM */
typedef struct s_stored_group
{
   struct s_stored_group *next;
   S_CarouselInfoFileGroup crsl_usr_info;
   H_ObjCarousel hOC;
   S_STRING loc_str;
   U8BIT dir_name[GROUP_DIR_LEN];
   U32BIT group_size;
   U32BIT man_file_size;
   U32BIT last_accessed;
   E_FGS_STATUS status;
   E_FS_ORIGIN origin;
   MHEG5Int offset;
   U16BIT file_version;
   U16BIT total_nodes;
   S_NODE *nodes;
} S_STORED_GROUP;

/* structure to hold client file requests */
typedef struct s_fgc_request
{
   struct s_fgc_request *next;
   F_DSM_CBLOAD cb_func;
   S_STORED_GROUP *pSG;
   S_CONTENT *pClientContent;
   S_CONTENT *pFgCtnt;
} S_FGC_REQUEST;

/* structure to hold file requests to DSM-CC */
typedef struct s_dsm_file_rqst
{
   S_STORED_GROUP *sfg;
   S_CONTENT *pFgCtnt;
   char *fname;
} S_DSM_FILE_RQST;

/* structure to hold (global) manifest list (and state of manifest requests to DSM-CC */
/* structure to hold (global) manifest list (and state of manifest requests to DSM-CC */
typedef struct s_FGManifest
{
   void *ormRqst;
} S_FGManifest;

typedef struct s_manifest_rqst
{
   struct s_manifest_rqst *next;
   H_DsmControl dsmInst;
   H_ObjCarousel hOC;
   U16BIT total;
   U8BIT outstanding;
   U8BIT cachePriority;
   S_CarouselInfoFileGroup *pFG;
} S_ManRequest;

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

static S_STORED_GROUP* GetStoredGroup( U16BIT owner_id, U16BIT group_id );
static S_STORED_GROUP* FindValidGroup( E_FS_ORIGIN origin, const char **pname, S_CONTENT **ppCtnt );
static BOOLEAN HasMissingFileData( S_STORED_GROUP *pSGrp );
static void ManifestLoadGood( void *userData, S_CONTENT *pContent );
static void ManifestLoadFail( void *userData );
static void FileLoadedGood( void *userData, S_CONTENT *pContent );
static void FileLoadedFail( void *userData );
static void LoadAllFileData( S_STORED_GROUP *pSGrp, U8BIT cachePriority );
static void GetAllFileData( S_STORED_GROUP *pSGrp, U8BIT cachePriority );
static E_FsStatus ReadFileData( S_STORED_GROUP *pSGrp, const char *fname, S_CONTENT *pCtnt );
static BOOLEAN DeleteFileInNvm( S_STORED_GROUP *pSGrp, const char *fname );
static void DeleteAllFiles( S_STORED_GROUP *pSGrp );
static void FileGroupFree( S_STORED_GROUP *pSGrp );

/* JSON callbacks */
static void* NodesArray( unsigned int val, void *array, void *gptr );
static void* NodeFinish( unsigned int val, void *array, void *gptr );

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

static const char hex_digits_low[] = "0123456789abcdef";
static S_STRING tmp_node_filename = { 0, NULL };
static U32BIT tmp_node_count = 0;
static U32BIT tmp_group_version = 0;
static U32BIT tmp_group_size = 0;

static const S_JSON_MEMBERS group_node_members[] = {
   DECLARE_OBJECT((void *)NodeFinish ),
   DECLARE_MEMBER( NODE_TOKEN, JST_PTR_STRING, &tmp_node_filename, NULL ),
   DECLARE_MEMBER( COUNT_TOKEN, JST_PTR_INTEGER, &tmp_node_count, NULL ),
   DECLARE_OBJEND()
};

static const S_JSON_MEMBERS file_group_members[] = {
   DECLARE_MEMBER( VERSION_TOKEN, JST_PTR_INTEGER, &tmp_group_version, NULL ),
   DECLARE_MEMBER( SIZE_TOKEN, JST_PTR_INTEGER, &tmp_group_size, NULL ),
   DECLARE_MEMBER( NODES_TOKEN, JST_CBF_ARRAY_OBJ, (void *)NodesArray, group_node_members ),
   DECLARE_OBJEND()
};

static S_JSON_MEMBERS fg_cache_members[] = {
   DECLARE_MEMBER( "ids", JST_PTR_INTEGER, NULL, NULL ),
   DECLARE_MEMBER( "prop", JST_PTR_INTEGER, NULL, NULL ),
   DECLARE_MEMBER( "path", JST_PTR_ASTRING, NULL, NULL ),
   DECLARE_MEMBER( "group", JST_CBF_OBJECT, NULL, file_group_members ),
   DECLARE_OBJEND()
};

static S_STORED_GROUP *stored_group_list = NULL;
static S_FGC_REQUEST *fg_request_head = NULL;
static S_FGC_REQUEST *fg_request_tail = NULL;
static U32BIT fg_nvm_max_limit = 0;
static S_ManRequest *fg_manifest_rqst = NULL;
static H_Timer fgManifestTimer = NULL;
static H_ObjCarousel fgTimerOC = NULL;
static U32BIT fgRequestCount = 0;

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


static E_FS_ORIGIN GetOrigin( S_STRING loc, MHEG5Int *pOffset )
{
   E_FS_ORIGIN origin;
   MHEG5String ref;
   ref.len = loc.zlen;
   ref.data = loc.zptr;
   if ( !MHEG5ResolveOrigin(&ref, &origin, pOffset) || *pOffset <= 1 )
   {
      origin = ORIGIN_DSM;
   }
   return origin;
}

static BOOLEAN FileRead( const char *filename, U8BIT *data, U32BIT size )
{
   BOOLEAN rslt = FALSE;
   void *file;
   file = STB_NVMOpenFile((U8BIT*)filename, FILE_MODE_READ);
   if (file == NULL)
   {
      TRACE(TERROR, ("%s", filename))
   }
   else
   {
      if (STB_NVMReadFile(file, data, size) != size)
      {
         TRACE(TERROR, ("%s sz %d", filename, size))
      }
      else
      {
         rslt = TRUE;
      }
      STB_NVMCloseFile( file );
   }
   return rslt;
}

static S_STORED_GROUP* AddCachedManifestFile( char *filename )
{
   S_STORED_GROUP *pSGrp = NULL;
   U32BIT size, *pU32;
   U8BIT *data;

   if (!STB_NVMFileSize((U8BIT*) filename, &size))
   {
      TRACE(TERROR, ("%s", filename))
   }
   else
   {
      data = DSMAlloc( size );

      if (data == NULL)
      {
         TRACE(TERROR, ("sz %d", size))
      }
      else
      {
         if (!FileRead(filename, data, size))
         {
            TRACE(TERROR, ("%s", filename))
         }
         else
         {
            pSGrp = DSMAlloc( sizeof(S_STORED_GROUP));
            if (pSGrp == NULL)
            {
               TRACE(TERROR, ("malloc()"))
            }
            else
            {
               memset(pSGrp, 0, sizeof(S_STORED_GROUP));
               tmp_group_size = 0;
               pSGrp->man_file_size = size;
               pSGrp->last_accessed = STB_OSGetClockMilliseconds();
               pSGrp->total_nodes = 0;
               pSGrp->nodes = NULL;
               pU32 = (U32BIT *)&pSGrp->crsl_usr_info;
               fg_cache_members[0].u.p_uint = pU32;
               fg_cache_members[1].u.p_uint = pU32 + 1;
               fg_cache_members[2].u.p_str = &pSGrp->loc_str;
               if (JSON_Parse( data, size, fg_cache_members, pSGrp ) != JSON_OKAY)
               {
                  TRACE(TERROR, ("%s", filename))
                  FileGroupFree( pSGrp );
                  pSGrp = NULL;
               }
               else
               {
                  assert( tmp_group_size != 0 );
                  assert( pSGrp->total_nodes != 0 );
                  assert( pSGrp->nodes != NULL );
                  TRACE(TDSMFG, ("Success : owner 0x%x, group 0x%x, size %d",
                                 pSGrp->crsl_usr_info.owner_id, pSGrp->crsl_usr_info.group_id, tmp_group_size))
                  pSGrp->group_size = tmp_group_size;
                  pSGrp->file_version = (U16BIT)tmp_group_version;
                  memcpy( pSGrp->dir_name, filename, 4 );
                  memcpy( pSGrp->dir_name + 4, filename + 5, 4 );
                  pSGrp->origin = GetOrigin(pSGrp->loc_str,&(pSGrp->offset));
               #ifdef INCLUDE_SA_PROFILE
                  if ( MH5_SupportMhegProfile(CPROFILE_SA)
                    && pSGrp->crsl_usr_info.owner_id <= MAX_SPECIAL_OWNER_ID
                    && pSGrp->crsl_usr_info.group_id <= MAX_SPECIAL_GROUP_ID )
                  {
                     pSGrp->status = FGS_ACTIVE;
                  }
                  else
               #endif
               #ifdef INCLUDE_AU_PROFILE
                  if (!(pSGrp->crsl_usr_info.use_flags & USE_FROM_CAROUSEL))
                  {
                     pSGrp->status = FGS_PENDING;
                  }
                  else
               #endif
                  {
                     pSGrp->status = FGS_PASSIVE;
                  }
                  pSGrp->next = stored_group_list;
                  stored_group_list = pSGrp;
               }
            }
         }
         /* free manifest file data */
         DSMFree( data );
      }
   }
   return pSGrp;
}

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

void FG_Initialise( U32BIT nvmSize )
{
   int n;
   void *dir;
   E_STB_DIR_ENTRY_TYPE type;
   U16BIT owner, group;
   char filename[MAX_PATH_LEN];

   assert( stored_group_list == NULL );
   fg_nvm_max_limit = nvmSize;

   dir = STB_NVMOpenDirectory((U8BIT *) "" ); /* root dir should have manifest files */
   if (dir == NULL)
   {
      TRACE(TERROR, (""))
   }
   else
   {
      TRACE(TDSMFG, (" "))
      while (STB_NVMReadDirectory(dir, (U8BIT *) filename, MAX_PATH_LEN, &type))
      {
         if (type == DIR_ENTRY_FILE &&
             strlen(filename) == 13 &&
             memcmp(filename + 9, ".man", 4) == 0 &&
             filename[4] == '-')
         {
            TRACE(TDSMFG, ("found: %s", filename))
            owner = 0;
            for (n = 0; n != 4; n++)
            {
               owner <<= 4;
               if (filename[n] >= '0' && filename[n] <= '9')
               {
                  owner |= filename[n] - '0';
               }
               else if (filename[n] >= 'a' && filename[n] <= 'f')
               {
                  owner |= filename[n] + 10 - 'a';
               }
               else
               {
                  TRACE(TERROR, ("invalid char 0x%x", filename[n]))
                  break;
               }
            }
            if (n != 4)
            {
               TRACE(TERROR, (" n %d", n))
            }
            else
            {
               group = 0;
               for (n = 5; n != 9; n++)
               {
                  group <<= 4;
                  if (filename[n] >= '0' && filename[n] <= '9')
                  {
                     group |= filename[n] - '0';
                  }
                  else if (filename[n] >= 'a' && filename[n] <= 'f')
                  {
                     group |= filename[n] + 10 - 'a';
                  }
                  else
                  {
                     TRACE(TERROR, ("invalid char 0x%x", filename[n]))
                     break;
                  }
               }
               if (n != 9)
               {
                  TRACE(TERROR, ("n %d", n))
               }
               else
               {
                  /* Succesfully obtain group with sensible ID's in filename */
                  assert( GetStoredGroup( owner, group ) == NULL );
                  (void)AddCachedManifestFile( filename );
               }
            }
         }
      }

      STB_NVMCloseDirectory( dir );
   }
}

void FG_Terminate( void )
{
   S_STORED_GROUP *pSGrp;

   TRACE(TDSMFG, (" "))
   /* Clear entire cache */
   while (stored_group_list != NULL)
   {
      pSGrp = stored_group_list;
      stored_group_list = stored_group_list->next;
      FileGroupFree( pSGrp );
   }
}

static void SetFilename( U16BIT owner_id, U16BIT group_id, char *fname )
{
   const char *digits = hex_digits_low;
   U16BIT tmp, n;
   /* fill in owner and group IDs into the file name */
   tmp = group_id;
   /* Initialise file name with extension '.man' -
    * assuming filename format is '0000-0000' i.e. length of 9 */
   strcpy(fname + 9, ".man");
   n = 8;
   do
   {
      fname[n] = digits[tmp & 0xf];
      tmp >>= 4;
      n--;
   }
   while (n != 4);
   fname[4] = '-';
   tmp = owner_id;
   n--;
   do
   {
      fname[n] = digits[tmp & 0xf];
      tmp >>= 4;
   }
   while (n--);
}

static MHEG5Bool FileGroupRequired( U8BIT receiver_profile )
{
   MHEG5Bool result = MHEG5TRUE;
   switch (receiver_profile)
   {
      case FG_PROFILE_HD_GRAPHICS:
         result = MH5_SupportHDGraphics();
         break;
      case FG_PROFILE_HD_VIDEO:
         result = MH5_SupportHDVideo();
         break;
      case FG_PROFILE_IC:
         result = MH5_SupportInteractionChannel();
         break;
      case FG_PROFILE_ICS:
         result = MH5_SupportICStreaming();
         break;
      case FG_PROFILE_ICES:
         /* ICEncyrptedStreamExtension is not supported? */
         result = MHEG5FALSE;
         break;
      case FG_PROFILE_NATIVE_APP:
         result = MH5_SupportNativeApplication();
         break;
      case FG_PROFILE_DL_FONT:
         result = MH5_SupportFontClass();
         break;
      case FG_PROFILE_SI:
         result = MH5_SupportServiceInfoExtension();
         break;
      case FG_PROFILE_PVR:
         result = MH5_SupportPVRExtension();
         break;
      default:
      case FG_PROFILE_LIFECYCLE:
      /* fallthrough - always support Lifecycle (NDT) */
      case FG_PROFILE_ALL:
         result = MHEG5TRUE;
         break;
   }
   return result;
}

static S_ManRequest *FindManRequest(H_ObjCarousel hOC)
{
   S_ManRequest *pManRqst = fg_manifest_rqst;
   while ((pManRqst != NULL) && (hOC != pManRqst->hOC))
   {
      pManRqst = pManRqst->next;
   }
   return pManRqst;
}

static void FreeManRequest(S_ManRequest *pManRqst)
{
   S_CONTENT *pContent;
   U16BIT total;
   if (pManRqst->outstanding)
   {
      /* cancel outstanding manifest file requests */
      pContent = (S_CONTENT *)(pManRqst + 1);
      for (total = pManRqst->total; total--; pContent++)
      {
         if (pContent->user_data != 0)
         {
            if (pContent->destroy)
            {
               TRACE(TDSMFG, ("destory fsh=%p",pContent->fs_handle ))
               pContent->destroy( pContent->fs_handle );
               pContent->destroy = NULL;
               pContent->fs_handle = NULL;
            }
            pManRqst->outstanding--;
            if (!pManRqst->outstanding)
               break;
         }
      }
      DSMCC_ClientUnloadFileGroups( pManRqst->dsmInst, pManRqst->hOC, pManRqst->pFG );
   }
   DSMFree( pManRqst );
}

static void DisableStoreGroupsFromCarousel( H_ObjCarousel hOC )
{
   S_STORED_GROUP *pStoreGrp = stored_group_list;
   while (pStoreGrp != NULL)
   {
      if (pStoreGrp->hOC == hOC)
      {
         if ( !MH5_SupportMhegProfile(CPROFILE_SA)
           || pStoreGrp->crsl_usr_info.owner_id > MAX_SPECIAL_OWNER_ID
           || pStoreGrp->crsl_usr_info.group_id > MAX_SPECIAL_GROUP_ID )
         {
            pStoreGrp->status = FGS_PASSIVE;
            pStoreGrp->hOC = NULL;
         }
      }
      pStoreGrp = pStoreGrp->next;
   }
}

static void ClearManRequest( H_ObjCarousel hOC )
{
   S_ManRequest *pManRqst, **ppManRqst;

   TRACE(TDSMFG, ("ObjCrsl=%p", hOC))
   pManRqst = fg_manifest_rqst;
   ppManRqst = &fg_manifest_rqst;
   while (pManRqst != NULL)
   {
      if (hOC == pManRqst->hOC)
      {
         *ppManRqst = pManRqst->next;
         DisableStoreGroupsFromCarousel(hOC);
         FreeManRequest( pManRqst );
         break;
      }
      ppManRqst = &(pManRqst->next);
      pManRqst = pManRqst->next;
   }
}

static void AddManRequest(H_ObjCarousel hOC)
{
   S_ManRequest *pManRqst;
   S_CarouselInfoFileGroup *pFG;
   H_DsmControl dsmInst;
   U16BIT total;

   dsmInst = MHEG5_DsmccInstance();
   if (!DSMCC_ClientLoadFileGroups(dsmInst, hOC, &total, &pFG))
   {
      TRACE(TERROR, ("DSMCC_ClientLoadFileGroups failure ObjCrsl=%p",hOC))
      pManRqst = NULL;
   }
   else
   {
      TRACE(TDSMFG, ("ObjCrsl=%p total=%d", hOC, total ))
      pManRqst = DSMAlloc( sizeof(S_ManRequest) + (total * sizeof(S_FGManifest)) );
      if (pManRqst == NULL)
      {
         TRACE(TERROR, ("Memory failure"))
         DSMCC_ClientUnloadFileGroups( dsmInst, hOC, pFG );
      }
      else
      {
         pManRqst->next = fg_manifest_rqst;
         fg_manifest_rqst = pManRqst;
         pManRqst->dsmInst = dsmInst;
         pManRqst->hOC = hOC;
         pManRqst->total = total;
         pManRqst->outstanding = 0;
         pManRqst->cachePriority = 0;
         pManRqst->pFG = pFG;
         memset(pManRqst+1, 0, total * sizeof(S_FGManifest));
      }
   }
}

static BOOLEAN LoadManifest( H_ObjCarousel hOC, S_CarouselInfoFileGroup *pFG, U8BIT cachePriority, S_FGManifest *pFgm )
{
   S_STORED_GROUP *pSGrp;
   char filename[16];
   S_STRING location, name;
   MHEG5Int os;
   BOOLEAN result = FALSE;

   location.zptr = pFG->location;
   location.zlen = strlen((char *) location.zptr);
   SetFilename( pFG->owner_id, pFG->group_id, filename );
   name.zlen = 13;
   name.zptr = (U8BIT*)filename;

   if ( MH5_SupportMhegProfile(CPROFILE_SA) )
   {
      /* For South Africa profile, USE_FROM_CAROUSEL bit must be set */
      pFG->use_flags |= USE_FROM_CAROUSEL;
   }
   pSGrp = GetStoredGroup( pFG->owner_id, pFG->group_id );
   if (pSGrp == NULL)
   {
      /* Any cached group, should have been obtained in FG_Initialise,
       * but does not do any harm to give it another try.
       * Some platforms do not succeed in obtaining files at that early stage. */
      pSGrp = AddCachedManifestFile( filename );
      TRACE(TDSMFG, ("%s, Group was not in memory %p", filename, pSGrp))
   }
   else
   {
      TRACE(TDSMFG, ("%s, pSGrp %p", filename, pSGrp))
      TRACE(TDSMFG, ("cgrp_ver=%d file_ver=%d flgs=%x",pFG->group_version,pSGrp->file_version,pFG->use_flags))
   }
   if (pSGrp == NULL ||
       ((pFG->use_flags & USE_VERSION_FLAG) && pFG->group_version != pSGrp->file_version))
   {
      if ( pSGrp != NULL )
      {
         pSGrp->hOC = hOC;
         if (!MH5_SupportMhegProfile(CPROFILE_SA) ||
             pSGrp->crsl_usr_info.owner_id > MAX_SPECIAL_OWNER_ID ||
             pSGrp->crsl_usr_info.group_id > MAX_SPECIAL_GROUP_ID)
         {
            TRACE(TDSMFG,("Stale group %x,%x",pSGrp->crsl_usr_info.owner_id,pSGrp->crsl_usr_info.group_id))
            pSGrp->status = FGS_STALE;

         }
         else
         {
            TRACE(TDSMFG,("Starting update of special group %x,%x",pSGrp->crsl_usr_info.owner_id,pSGrp->crsl_usr_info.group_id))
         }
      }
      /* Request file containing group manifest */
      pFgm->ormRqst = MHEG5FileOrmRetrieve( GetOrigin(location,&os), location, name, cachePriority,
                                            pFG, ManifestLoadGood, ManifestLoadFail );
      result = TRUE;
   }
#ifdef INCLUDE_AU_PROFILE
   else if (!(pSGrp->crsl_usr_info.use_flags & USE_FROM_CAROUSEL))
   {
      /* An "All or Nothing" group */
      pSGrp->hOC = hOC;
      // should be pSGrp->status == FGS_PENDING
      /* make requests for all files in the group */
      LoadAllFileData( pSGrp, cachePriority );
      if (pSGrp->status != FGS_ERROR &&
          HasMissingFileData( pSGrp ) == FALSE)
      {
         pSGrp->status = FGS_ACTIVE;
      }
   }
#endif //INCLUDE_AU_PROFILE
   else
   {
      /* ensure have got all files updated in NVM */
      pSGrp->status = FGS_ACTIVE;
      GetAllFileData( pSGrp, cachePriority );
      pSGrp->hOC = hOC;
   }
   return result;
}

static void FetchManifests( H_ObjCarousel hOC, U8BIT cachePriority )
{
   S_CarouselInfoFileGroup *pFG;
   S_FGManifest *pFgm;
   S_ManRequest *pManRqst;
   U16BIT total;

   if (fgTimerOC == hOC)
   {
      fgTimerOC = NULL;
   }
   pManRqst = FindManRequest(hOC);
   if (pManRqst != NULL)
   {
      pFG = pManRqst->pFG;
      if (!pManRqst->outstanding && pFG != NULL)
      {
         pManRqst->cachePriority = cachePriority;
         pFgm = (S_FGManifest *)(pManRqst + 1);
         for(total = pManRqst->total; total--; pFG++, pFgm++)
         {
            if (!FileGroupRequired( pFG->receiver_profile ))
            {
               TRACE(TDSMFG, ("Group not required (0x%x,0x%x)", pFG->owner_id, pFG->group_id))
            }
            else
            {
               pManRqst->outstanding++;
               if (!LoadManifest( hOC, pFG, cachePriority, pFgm ))
               {
                  pManRqst->outstanding--;
               }
            }
         }
      }
   }
}

void FG_NotifyCarouselUnLoaded( H_ObjCarousel hOC )
{
   S_ManRequest *pManRqst, **ppManRqst;

   TRACE(TDSMFG, ("ObjCrsl=%p", hOC))
   if (fgTimerOC == hOC)
   {
      fgTimerOC = NULL;
   }
   pManRqst = fg_manifest_rqst;
   ppManRqst = &fg_manifest_rqst;
   while (pManRqst != NULL)
   {
      if (hOC == pManRqst->hOC)
      {
         *ppManRqst = pManRqst->next;
         pManRqst->hOC = NULL;
         DisableStoreGroupsFromCarousel(hOC);
         FreeManRequest( pManRqst );
         break;
      }
      ppManRqst = &(pManRqst->next);
      pManRqst = pManRqst->next;
   }
   if (fgManifestTimer != NULL)
   {
      VT_TimerDestroy( fgManifestTimer );
      fgManifestTimer = NULL;
   }
}

void FG_NotifyListLoaded(S_DsmccEvent *param)
{
   H_ObjCarousel hOC = param->hCarousel;
   TRACE(TDSMFG, ("hOC=%p",hOC))
   AddManRequest(hOC);
   FetchManifests( hOC, FRP_CACHE_DEFAULT );
}

void FG_NotifyListChanged(S_DsmccEvent *param)
{
   H_ObjCarousel hOC = param->hCarousel;
   TRACE(TDSMFG, ("hOC=%p",hOC))
   ClearManRequest(hOC);
   AddManRequest(hOC);
   FetchManifests( hOC, 0 );
}

void FG_NotifyVersionChanged(S_DsmccEvent *param)
{
   H_ObjCarousel hOC = param->hCarousel;
   TRACE(TDSMFG, ("hOC=%p",hOC))
   ClearManRequest(hOC);
   AddManRequest(hOC);
   FetchManifests( hOC, 0 );
}

static void FreeContent( S_CONTENT *pFgCtnt )
{
   if (pFgCtnt->data != NULL)
   {
      assert( pFgCtnt->destroy != NULL );
      if (pFgCtnt->destroy != NULL)
      {
         pFgCtnt->destroy( pFgCtnt->fs_handle );
         pFgCtnt->destroy = NULL;
         pFgCtnt->fs_handle = NULL;
      }
      pFgCtnt->data = NULL;
   }
}

static void ReleaseContent( S_CONTENT *pFgCtnt )
{
   S_FGC_REQUEST *pRqst;
   /* check that there is no other outstanding client usage */
   pRqst = fg_request_head;
   while (pRqst != NULL)
   {
      if (pRqst->pFgCtnt == pFgCtnt)
      {
         break;
      }
      pRqst = pRqst->next;
   }
   if (pRqst == NULL &&
       pFgCtnt->size > MAX_SIZE_OF_CACHED_FILE)
   {
      FreeContent( pFgCtnt );
   }
}

static void RemoveClientRqst( void *dsmFileRef )
{
   S_FGC_REQUEST *p_rqst, *p_prv;
   if (dsmFileRef != NULL)
   {
      TRACE(TDSMFG, ("ref=%p", dsmFileRef))
      if (fg_request_head != NULL)
      {
         if (dsmFileRef == fg_request_head)
         {
            fg_request_head = fg_request_head->next;
            if (fg_request_head == NULL)
            {
               fg_request_tail = NULL;
            }
            ReleaseContent(((S_FGC_REQUEST *)dsmFileRef)->pFgCtnt );
            TRACE(TDSMFG, ("ref=%p", dsmFileRef))
            DSMFree( dsmFileRef );
         }
         else
         {
            p_prv = fg_request_head;
            p_rqst = fg_request_head->next;
            while (p_rqst != NULL)
            {
               if (p_rqst == dsmFileRef)
               {
                  p_prv->next = p_rqst->next;
                  if (p_rqst->next == NULL)
                  {
                     fg_request_tail = p_prv;
                  }
                  ReleaseContent( p_rqst->pFgCtnt );
                  TRACE(TDSMFG, ("ref=%p", dsmFileRef))
                  DSMFree( dsmFileRef );
                  break;
               }
               p_prv = p_rqst;
               p_rqst = p_rqst->next;
            }
         }
      }
   }
}

static E_FsStatus AquireFileData( S_STORED_GROUP *pSGrp, const char *fname,
   S_CONTENT *pCtnt, U8BIT cachePriority )
{
   E_FsStatus fstat;
   S_DSM_FILE_RQST *pDsmRqst;
   S_STRING name;
   assert( pCtnt->data == NULL );
   if (pCtnt->user_data != NULL)
   {
      TRACE(TDSMFG, ("another request for %s at %p", fname, pCtnt->user_data))
      fstat = FS_STATUS_PENDING;
   }
   else
   {
      name.zlen = strlen(fname);
      name.zptr = (U8BIT*)fname;
      pDsmRqst = DSMAlloc( sizeof(S_DSM_FILE_RQST) + name.zlen + 10 );
      if (pDsmRqst == NULL)
      {
         fstat = FS_STATUS_ERROR;
      }
      else
      {
         pDsmRqst->fname = (char *)(pDsmRqst + 1);
         memcpy( pDsmRqst->fname, pSGrp->dir_name, GROUP_DIR_LEN );
         pDsmRqst->fname[8] = '/';
         strcpy( pDsmRqst->fname + 9, fname );
         pDsmRqst->sfg = pSGrp;
         pDsmRqst->pFgCtnt = pCtnt;
         pCtnt->user_data = MHEG5FileOrmRetrieve(pSGrp->origin, pSGrp->loc_str, name, cachePriority,
                                                   pDsmRqst, FileLoadedGood, FileLoadedFail);
         if (pCtnt->user_data == NULL)
         {
            fstat = (pCtnt->data==NULL)? FS_STATUS_ERROR : FS_STATUS_OK;
         }
         else
         {
            fstat = FS_STATUS_PENDING;
         }
      }
   }
   return fstat;
}

E_FsStatus FG_LoadRequest( E_FS_ORIGIN origin, const char *fname,
   F_DSM_CBLOAD cb_func, S_CONTENT *pContent, U8BIT cachePriority )
{
   E_FsStatus fstat;
   S_CONTENT *pCtnt;
   S_STORED_GROUP *pSG;

   assert( cb_func != NULL );
   assert( pContent != NULL );
   assert( pContent->destroy == NULL );

   pSG = FindValidGroup( origin, &fname, &pCtnt );
   if (pCtnt == NULL)
   {
      /* file not in any valid file groups */
      fstat = FS_STATUS_INVALID;
      TRACE(TDSMFG, ("%s not in active file group", fname))
   }
   else
   {
      S_FGC_REQUEST *pRqst = DSMAlloc( sizeof(S_FGC_REQUEST));
      if (pRqst == NULL)
      {
         TRACE(TERROR, ("%s", fname))
         fstat = FS_STATUS_ERROR;
      }
      else
      {
         pRqst->next = NULL;
         pRqst->cb_func = cb_func;
         pRqst->pFgCtnt = pCtnt;
         pRqst->pClientContent = pContent;
         pRqst->pSG = pSG;
         if (fg_request_tail == NULL)
         {
            fg_request_head = pRqst;
         }
         else
         {
            fg_request_tail->next = pRqst;
         }
         fg_request_tail = pRqst;
         pSG->last_accessed = STB_OSGetClockMilliseconds();
         switch (pSG->status)
         {
            case FGS_PENDING:
               TRACE(TDSMFG, ("FGS_PENDING %s", fname))
               fstat = FS_STATUS_PENDING;
               break;

            case FGS_ERROR:
               TRACE(TERROR, ("FGS_ERROR %s", fname))
               fstat = FS_STATUS_ERROR;
               break;

            case FGS_ACTIVE:
               if (cachePriority == 0)
               {
                  FreeContent( pCtnt );
                  DeleteFileInNvm( pSG, fname );
                  fstat = FS_STATUS_PENDING;
               }
               else if (pCtnt->data != NULL)
               {
                  /* File in the Group Store */
                  TRACE(TDSMFG, ("FGS_ACTIVE getting %s from store", fname))
                  fstat = FS_STATUS_OK;
               }
               else
               {
                  fstat = ReadFileData( pSG, fname, pCtnt );
               }
               if (fstat == FS_STATUS_OK)
               {
                  pContent->size = pCtnt->size;
                  pContent->data = pCtnt->data;
               }
               else
               {
                  /* Request file */
                  TRACE(TDSMFG, ("FGS_ACTIVE request %s from carousel", fname))
                  fstat = AquireFileData( pSG, fname, pCtnt, cachePriority );
               }
               break;
            default:
               fstat = FS_STATUS_ERROR;
               TRACE(TERROR, ("state unknown %d (fname=%s)", pSG->status, fname))
               break;
         }
         if (fstat == FS_STATUS_ERROR)
         {
            RemoveClientRqst( pRqst );
         }
         else
         {
            pContent->fs_handle = pRqst;
            pContent->destroy = RemoveClientRqst;
         }
      }
   }
   TRACE(TDSMFG, ("fstat=%d", fstat))
   return fstat;
}

E_FsStatus FG_FileExists( E_FS_ORIGIN origin, const char *fname )
{
   E_FsStatus fstat;
   S_CONTENT *pCtnt;
   S_STORED_GROUP *pSG;

   pSG = FindValidGroup( origin, &fname, &pCtnt);
   if (pCtnt == NULL)
   {
      /* file not in any valid file groups */
      fstat = FS_STATUS_INVALID;
      TRACE(TDSMFG, ("%s not in active file group", fname))
   }
   else
   {
      TRACE(TDSMFG, (" %s", fname))
      switch (pSG->status)
      {
         case FGS_PENDING:
         case FGS_ACTIVE:
            /* File in the Group Store */
            fstat = FS_STATUS_OK;
            break;

         case FGS_ERROR:
            TRACE(TERROR, (" %s", fname))
            fstat = FS_STATUS_ERROR;
            break;

         default:
            fstat = FS_STATUS_INVALID;
      }
   }
   return fstat;
}

void FG_FactoryReset( void )
{
   S_STORED_GROUP *pSGrp;
   H_ObjCarousel hOC;

   /* Clear entire cache */
   while (stored_group_list != NULL)
   {
      pSGrp = stored_group_list;
      stored_group_list = stored_group_list->next;
      DeleteAllFiles( pSGrp );
      FileGroupFree( pSGrp );
   }

   hOC = DSMCC_CurrentCarousel(MHEG5_DsmccInstance());
   /* re-load file groups from current Object Carousel */
   if (hOC != NULL)
   {
      FetchManifests( hOC, FRP_CACHE_DEFAULT );
   }
}

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


static S_STORED_GROUP* GetStoredGroup( U16BIT owner_id, U16BIT group_id )
{
   S_STORED_GROUP *pStoreGrp = stored_group_list;
   while (pStoreGrp != NULL)
   {
      if (pStoreGrp->crsl_usr_info.owner_id == owner_id &&
          pStoreGrp->crsl_usr_info.group_id == group_id)
      {
         break;
      }
      pStoreGrp = pStoreGrp->next;
   }
   return pStoreGrp;
}

static U32BIT FileGroupTotalSize( void )
{
   S_STORED_GROUP *pStoreGrp = stored_group_list;
   U32BIT total = 0;
   while (pStoreGrp != NULL)
   {
      total += pStoreGrp->group_size + pStoreGrp->man_file_size;
      pStoreGrp = pStoreGrp->next;
   }
   return total;
}

static void FileGroupRemove( S_STORED_GROUP *pSGrp )
{
   assert( pSGrp != NULL );
   /* Remove group from the list - if it is in it */
   if (stored_group_list)
   {
      if (pSGrp == stored_group_list)
      {
         stored_group_list = pSGrp->next;
      }
      else
      {
         S_STORED_GROUP *pPrev = stored_group_list;
         while (pPrev->next != pSGrp && pPrev->next != NULL)
         {
            pPrev = pPrev->next;
         }
         if (pPrev->next == pSGrp)
         {
            pPrev->next = pSGrp->next;
         }
      }
   }
}

static void FileGroupFree( S_STORED_GROUP *pSGrp )
{
   assert( pSGrp != NULL );
   /* Free all data associated with this stored group */
   if (pSGrp->nodes != NULL)
   {
      U16BIT remaining_nodes = pSGrp->total_nodes;
      S_NODE *pNode = pSGrp->nodes + remaining_nodes;

      while (remaining_nodes > 0)
      {
         pNode--;
         remaining_nodes--;

         if (pNode->count != 0)
         {
            if (pNode->u.contents != NULL)
            {
               U16BIT c = pNode->count;
               S_CONTENT *pCtnt = pNode->u.contents;
               pCtnt += c;
               do
               {
                  pCtnt--;
                  c--;
                  FreeContent( pCtnt );
               }
               while (c != 0);
               /* free array of contents */
               DSMFree( pNode->u.contents );
            }
         }
         else
         {
            /* just file data (i.e one file) */
            FreeContent( &(pNode->u.content));
         }
         if (pNode->nfname != NULL)
         {
            STR_DataFree((U8BIT *)pNode->nfname, pNode->nflen ); /* Free filename string */
         }
      }
      DSMFree( pSGrp->nodes ); /* free nodes list */
      MH5GlueStringFree( &pSGrp->loc_str );
   }
   DSMFree( pSGrp ); /* free store group */
}

static void DeleteStoredGroup( U16BIT owner_id, U16BIT group_id )
{
   S_STORED_GROUP *pSGrp = GetStoredGroup( owner_id, group_id );
   if (pSGrp != NULL)
   {
      TRACE(TDSMFG, ("Delete OLD version 0x%x", pSGrp->file_version))
      /* remove old group from store - should already be marked as FGS_STALE */
      DeleteAllFiles( pSGrp );
      FileGroupRemove( pSGrp );
      FileGroupFree( pSGrp );
   }
}

static S_CONTENT* FindMatchingNode( S_NODE *pNode, U16BIT total, const char *fname )
{
   U16BIT filelen, baselen, fnumber;
   filelen = strlen(fname);
   fnumber = INVALID_NODE_COUNTER;
   baselen = filelen;
   if (baselen > 3)
   {
      baselen--;
      while (fname[baselen] >= '0' && fname[baselen] <= '9')
      {
         if (baselen == filelen - 3)
         {
            fnumber = ((fname[baselen] - '0') * 100) + ((fname[baselen + 1] - '0') * 10) + (fname[baselen + 2] - '0');
            if (fnumber == 0)
            {
               // spec says number must be "001 to count", so set to invalid value
               fnumber = INVALID_NODE_COUNTER;
            }
            else
            {
               fnumber--;
            }
            break;
         }
         baselen--;
      }
   }
   while (total--)
   {
      if (pNode->count == 0)
      {
         if (pNode->nflen == filelen &&
             !memcmp(pNode->nfname, fname, filelen))
         {
            /*fount it!*/
            return &(pNode->u.content);
         }
      }
      else if (fnumber < pNode->count && pNode->u.contents != NULL)
      {
         if (pNode->nflen == baselen &&
             !memcmp(pNode->nfname, fname, baselen))
         {
            /*fount it!*/
            return pNode->u.contents + fnumber;
         }
      }
      pNode++;
   }
   return NULL;
}

static const char* MatchingLocation( E_FS_ORIGIN origin, const char *pname, S_STRING location, MHEG5Int offset )
{
   if (origin == ORIGIN_DSM && location.zlen == 0)
   {
      /* default location */
      return pname;
   }
   if (location.zptr != NULL)
   {
      location.zptr += offset;
      location.zlen -= offset;
      if (MHEG5strncmp(pname, location.zptr, location.zlen) == 0)
      {
         return pname + location.zlen;
      }
   }
   return NULL;
}

static S_STORED_GROUP* FindValidGroup( E_FS_ORIGIN origin, const char** pname, S_CONTENT** ppCtnt )
{
   S_STORED_GROUP* pSGrp;
   S_CONTENT *pCtnt;
   const char *fname;

   *ppCtnt = NULL;
   pSGrp = stored_group_list;
   while ( pSGrp != NULL )
   {
      TRACE(TDSMFG,("ID (0x%x,0x%x) nodes=%d ver=%d origin=%d status=%d",
         pSGrp->crsl_usr_info.owner_id, pSGrp->crsl_usr_info.group_id,
         pSGrp->total_nodes, pSGrp->file_version, pSGrp->origin, pSGrp->status))
      if (pSGrp->status > FGS_LOADING &&
          pSGrp->nodes != NULL &&
          pSGrp->origin == origin)
      {
         fname = MatchingLocation( origin, *pname, pSGrp->loc_str, pSGrp->offset );
         if ( fname != NULL )
         {
            if (fname[0] == '/') fname++;
            TRACE(TDSMFG,("matching location: path=%s fname=%s",*pname,fname))
            pCtnt = FindMatchingNode( pSGrp->nodes, pSGrp->total_nodes, fname );
            if ( pCtnt != NULL )
            {
               TRACE(TDSMFG,("==== Found it path %s fname %s ====",*pname,fname))
               *ppCtnt = pCtnt;
               *pname = fname;
               break;
            }
         }
      }
      pSGrp = pSGrp->next;
   }
   return pSGrp;
}

static BOOLEAN HasMissingFileData( S_STORED_GROUP *pSGrp )
{
   S_NODE *pNode;
   S_CONTENT *pCtnt;
   U16BIT n, c, total;
   BOOLEAN result = FALSE;

   assert(pSGrp->nodes != NULL);

   pNode = pSGrp->nodes;
   for (n = 0; n != pSGrp->total_nodes; n++, pNode++)
   {
      if (pNode->count == 0)
      {
         if (pNode->u.content.data == NULL)
         {
            result = TRUE;
            break;
         }
      }
      else
      {
         pCtnt = pNode->u.contents;
         total = pNode->count + 1;
         for (c = 1; c != total; c++, pCtnt++)
         {
            if (pCtnt->data == NULL)
            {
               result = TRUE;
               break;
            }
         }
         if (result == TRUE)
         {
            break;
         }
      }
   }
   return result;
}

static BOOLEAN FulfilRequest( S_CONTENT *pCtnt, E_FsStatus fstat )
{
   S_FGC_REQUEST *p_rqst;
   BOOLEAN found = FALSE;
   TRACE(TDSMFG, ("pCtnt=%p fstat=%d", pCtnt, fstat));
   p_rqst = fg_request_head;
   while (p_rqst != NULL)
   {
      if (p_rqst->pFgCtnt == pCtnt)
      {
         /* do callback */
         if (p_rqst->cb_func != NULL)
         {
            p_rqst->pClientContent->size = pCtnt->size;
            p_rqst->pClientContent->data = pCtnt->data;
            p_rqst->cb_func( fstat, p_rqst->pClientContent );
            p_rqst->cb_func = NULL;
         }
         found = TRUE;
      }
      p_rqst = p_rqst->next;
   }
   return found;
}

static void FulfilOutstandingFileRequests( S_STORED_GROUP *pSGrp, E_FsStatus fstat )
{
   S_NODE *pNode;
   S_CONTENT *pCtnt;
   U16BIT n, c, total;

   assert(pSGrp->nodes != NULL);
   assert((pSGrp->crsl_usr_info.use_flags & USE_FROM_CAROUSEL) == 0);
   assert(fg_request_head != NULL);

   pNode = pSGrp->nodes;
   for (n = 0; n != pSGrp->total_nodes; n++, pNode++)
   {
      if (pNode->count == 0)
      {
         assert( pNode->u.content.data != NULL );
         (void)FulfilRequest( &(pNode->u.content), fstat );
      }
      else
      {
         pCtnt = pNode->u.contents;
         total = pNode->count + 1;
         for (c = 1; c != total; c++, pCtnt++)
         {
            assert( pCtnt->data != NULL );
            (void)FulfilRequest( pCtnt, fstat );
         }
      }
   }
}

static BOOLEAN FileExistsInNvm( S_STORED_GROUP *pSGrp, char *fname )
{
   U32BIT size;
   BOOLEAN exists;
   char fullname[MAX_PATH_LEN];
   memcpy( fullname, pSGrp->dir_name, GROUP_DIR_LEN );
   fullname[8] = '/';
   strcpy( fullname + 9, fname );
   if (STB_NVMFileSize( (U8BIT*) fullname, &size ))
   {
      exists = TRUE;
   }
   else
   {
      exists = FALSE;
   }
   return exists;
}

static BOOLEAN DeleteFileInNvm( S_STORED_GROUP *pSGrp, const char *fname )
{
   char fullname[MAX_PATH_LEN];
   memcpy( fullname, pSGrp->dir_name, GROUP_DIR_LEN );
   fullname[8] = '/';
   strcpy( fullname + 9, fname );
   return STB_NVMDeleteFile((U8BIT*)fullname);
}

static E_FsStatus ReadFileData( S_STORED_GROUP *pSGrp, const char *fname, S_CONTENT *pCtnt )
{
   U8BIT *data;
   U32BIT size;
   E_FsStatus fstat;
   char fullname[MAX_PATH_LEN];

   assert( pCtnt->data == NULL );

   memcpy( fullname, pSGrp->dir_name, GROUP_DIR_LEN );
   fullname[8] = '/';
   strcpy( fullname + 9, fname );

   if (STB_NVMFileSize( (U8BIT*) fullname, &size ))
   {
      data = DSMAlloc((size == 0) ? 1 : size );
      if (data == NULL)
      {
         TRACE(TERROR, ("%s", fullname))
         fstat = FS_STATUS_ERROR;
      }
      else if (size == 0)
      {
         TRACE(TDSMFG, ("%s in NVM is zero len", fname))
         pCtnt->size = 0;
         pCtnt->data = data;
         pCtnt->destroy = DSMFree;
         pCtnt->fs_handle = data;
         *data = 0;
         fstat = FS_STATUS_OK;
      }
      else if (FileRead( fullname, data, size ))
      {
         TRACE(TDSMFG, ("Read %s from NVM", fname))
         pCtnt->size = size;
         pCtnt->data = data;
         pCtnt->destroy = DSMFree;
         pCtnt->fs_handle = data;
         fstat = FS_STATUS_OK;
      }
      else
      {
         TRACE(TERROR, ("%s sz %d", fullname, size))
         fstat = FS_STATUS_ERROR;
         DSMFree( data );
      }
   }
   else
   {
      TRACE(TDSMFG, ("%s not in NVM", fname))
      fstat = FS_STATUS_NONE;
   }
   return fstat;
}

static void LoadAllFileData( S_STORED_GROUP *pSGrp, U8BIT cachePriority )
{
   S_NODE *pNode;
   S_CONTENT *pCtnt;
   char *pNumb;
   U16BIT n, c, total;

   assert(pSGrp->nodes != NULL);

   pNode = pSGrp->nodes;
   for (n = 0; n != pSGrp->total_nodes; n++, pNode++)
   {
      if (pNode->count == 0)
      {
         if (pNode->u.content.data == NULL &&
             ReadFileData( pSGrp, pNode->nfname, &(pNode->u.content)) != FS_STATUS_OK)
         {
            AquireFileData( pSGrp, pNode->nfname, &(pNode->u.content), cachePriority );
         }
      }
      else
      {
         pNumb = pNode->nfname + pNode->nflen;
         pCtnt = pNode->u.contents;
         total = pNode->count + 1;
         for (c = 1; c != total; c++, pCtnt++)
         {
            pNumb[0] = '0' + ((c / 100) % 10);
            pNumb[1] = '0' + ((c / 10) % 10);
            pNumb[2] = '0' + (c % 10);
            if (pCtnt->data == NULL &&
                ReadFileData( pSGrp, pNode->nfname, pCtnt ) != FS_STATUS_OK)
            {
               AquireFileData( pSGrp, pNode->nfname, pCtnt, cachePriority );
            }
         }
         *pNumb = 0; /*null end char again*/
      }
   }
}

static void GetAllFileData( S_STORED_GROUP *pSGrp, U8BIT cachePriority )
{
   S_NODE *pNode;
   S_CONTENT *pCtnt;
   char *pNumb;
   U16BIT n, c, total;

   assert(pSGrp->nodes != NULL);

   pNode = pSGrp->nodes;
   for (n = 0; n != pSGrp->total_nodes; n++, pNode++)
   {
      if (pNode->count == 0)
      {
         if (pNode->u.content.data == NULL &&
             !FileExistsInNvm( pSGrp, pNode->nfname ))
         {
            AquireFileData( pSGrp, pNode->nfname, &(pNode->u.content), cachePriority );
         }
      }
      else
      {
         pNumb = pNode->nfname + pNode->nflen;
         pCtnt = pNode->u.contents;
         total = pNode->count + 1;
         for (c = 1; c != total; c++, pCtnt++)
         {
            pNumb[0] = '0' + ((c / 100) % 10);
            pNumb[1] = '0' + ((c / 10) % 10);
            pNumb[2] = '0' + (c % 10);
            if (pCtnt->data == NULL &&
                !FileExistsInNvm( pSGrp, pNode->nfname ))
            {
               AquireFileData( pSGrp, pNode->nfname, pCtnt, cachePriority );
            }
         }
         *pNumb = 0; /*null end char again*/
      }
   }
}

static void DeleteAllFiles( S_STORED_GROUP *pSGrp )
{
   S_NODE *pNode;
   char *pNumb;
   U16BIT n, c, total;
   char fullname[MAX_PATH_LEN];

   memcpy( fullname, pSGrp->dir_name, GROUP_DIR_LEN );
   fullname[8] = '/';

   assert(pSGrp->nodes != NULL);

   pNode = pSGrp->nodes;
   for (n = 0; n != pSGrp->total_nodes; n++, pNode++)
   {
      if (pNode->count == 0)
      {
         strcpy( fullname + 9, pNode->nfname );
         STB_NVMDeleteFile( (U8BIT*) fullname );
      }
      else
      {
         pNumb = pNode->nfname + pNode->nflen;
         total = pNode->count + 1;
         for (c = 1; c != total; c++)
         {
            pNumb[0] = '0' + ((c / 100) % 10);
            pNumb[1] = '0' + ((c / 10) % 10);
            pNumb[2] = '0' + (c % 10);
            strcpy( fullname + 9, pNode->nfname );
            STB_NVMDeleteFile( (U8BIT*) fullname );
         }
         *pNumb = 0; /*null end char again*/
      }
   }
   fullname[8] = fullname[7];
   fullname[7] = fullname[6];
   fullname[6] = fullname[5];
   fullname[5] = fullname[4];
   fullname[4] = '-';
   fullname[9] = '.';
   fullname[10] = 'm';
   fullname[11] = 'a';
   fullname[12] = 'n';
   fullname[13] = 0;
   STB_NVMDeleteFile( (U8BIT*) fullname );
}

static BOOLEAN RemoveLeastDesiredGroup( void )
{
   S_STORED_GROUP *pSGrp;
   BOOLEAN found = FALSE;
   U32BIT last = STB_OSGetClockMilliseconds();

   assert( stored_group_list != NULL );

   pSGrp = stored_group_list;
   do
   {
   #ifdef INCLUDE_SA_PROFILE
      if ( !MH5_SupportMhegProfile(CPROFILE_SA)
        || pSGrp->crsl_usr_info.owner_id > MAX_SPECIAL_OWNER_ID
        || pSGrp->crsl_usr_info.group_id > MAX_SPECIAL_GROUP_ID )
   #endif
      {
         if ( last > pSGrp->last_accessed )
         {
            last = pSGrp->last_accessed;
         }
      }
      pSGrp = pSGrp->next;
   }
   while (pSGrp != NULL);

   pSGrp = stored_group_list;
   while (pSGrp != NULL)
   {
      if (last == pSGrp->last_accessed)
      {
         DeleteAllFiles( pSGrp );
         FileGroupRemove( pSGrp );
         FileGroupFree( pSGrp );
         found = TRUE;
         break;
      }
      pSGrp = pSGrp->next;
   }
   return found;
}

static void RequestManifest(S_DsmccEvent *params)
{
   H_ObjCarousel hOC = params->hCarousel;
   if (fgTimerOC == hOC)
   {
      if (hOC == DSMCC_CurrentCarousel(MHEG5_DsmccInstance()))
      {
         ClearManRequest(hOC);
         AddManRequest(hOC);
         FetchManifests( hOC, 0 );
      }
      /* else ignore - could be re-booting with new carousel */
   }
}

static void ManifestTimeoutFunc( BOOLEAN trig, void *ptr, H_Timer timer )
{
   H_ObjCarousel hOC = (H_ObjCarousel) ptr;
   S_MhegMessage event_msg;
   if (trig == TRUE)
   {
      TRACE(TERROR, ("fgRequestCount=%d", fgRequestCount))
      event_msg.proc_msg_func = (F_MSG_PROCESS)RequestManifest;
      event_msg.data_type = DT_NONE;
      event_msg.data.dsmEvent.hCarousel = hOC;
      VQ_PutMsg(&event_msg, PRTY_NORMAL);
   }
   if (timer == fgManifestTimer)
   {
      fgManifestTimer = NULL;
   }
}

static void SetManifestTimer(H_ObjCarousel hOC)
{
   if (fgRequestCount != MANIFEST_TIME_STOP)
   {
      fgRequestCount++;
      if (fgManifestTimer != NULL)
      {
         VT_TimerDestroy( fgManifestTimer );
         fgManifestTimer = NULL;
      }
      fgTimerOC = hOC;
      (void)VT_TimerCreate( MANIFEST_TIMEOUT, ManifestTimeoutFunc, (void *) hOC, &fgManifestTimer );
   }
}

static S_STORED_GROUP* ParseManifestFile( U8BIT *data, U32BIT size, void *gptr, H_ObjCarousel hOC )
{
   S_CarouselInfoFileGroup *pGrp = (S_CarouselInfoFileGroup *)gptr;
   S_STORED_GROUP *pSGrp;

   pSGrp = DSMAlloc( sizeof(S_STORED_GROUP));
   if (pSGrp == NULL)
   {
      TRACE(TERROR, ("malloc()"))
   }
   else
   {
      tmp_group_size = 0;
      tmp_group_version = pGrp->group_version;

      memset(pSGrp, 0, sizeof(S_STORED_GROUP));

      TRACE(TDSMFG, ("owner_id 0x%x, group_id 0x%x, use_flags 0x%x, ver 0x%x", pGrp->owner_id, pGrp->group_id, pGrp->use_flags, pGrp->group_version))
      if (JSON_Parse( data, size, file_group_members, pSGrp ) != JSON_OKAY)
      {
         FileGroupFree( pSGrp );
         pSGrp = NULL;
      }
      else if (tmp_group_version != pGrp->group_version)
      {
         TRACE(TERROR, ("Version mis-match file:0x%x srg:0x%x", tmp_group_version, pGrp->group_version))
         FileGroupFree( pSGrp );
         pSGrp = NULL;
         /* Set a timer to re-load the file groups - assuming there is a delay
          * between signalling of new version and transmission of its manifest file */
         SetManifestTimer(hOC);
      }
      else
      {
         /* reset global request counter, since we have received manifest file with correct version */
         fgRequestCount = 0;

         if (tmp_group_size == 0 || pSGrp->total_nodes == 0 || pSGrp->nodes == NULL ||
             tmp_group_size + size + MAX_MAN_HDR_SIZE > fg_nvm_max_limit)
         {
            if (tmp_group_size == 0 || pSGrp->total_nodes == 0 || pSGrp->nodes == NULL)
            {
               TRACE(TDSMFG,("Delete empty group (%x,%x)",pGrp->owner_id,pGrp->group_id))
            }
            else
            {
               TRACE(TERROR, ("FG Cache overflow; required:0x%x maximum:0x%x", (tmp_group_size+size+MAX_MAN_HDR_SIZE), fg_nvm_max_limit))
            }
            /* remove new group - do this way in case of any allocs during JSON parse */
            FileGroupFree( pSGrp );
            pSGrp = NULL;
            /* Group should no longer exist in the store either */
            DeleteStoredGroup( pGrp->owner_id, pGrp->group_id );
         }
         else
         {
            /* New file group */
            pSGrp->group_size = tmp_group_size;
            pSGrp->file_version = (U16BIT)tmp_group_version;
            pSGrp->crsl_usr_info = *pGrp;
            pSGrp->loc_str = MH5GlueStringCreate( strlen((char *) pGrp->location), pGrp->location );
            pSGrp->origin = GetOrigin(pSGrp->loc_str,&(pSGrp->offset));
         #ifdef INCLUDE_SA_PROFILE
            if ( MH5_SupportMhegProfile(CPROFILE_SA)
              && pGrp->owner_id <= MAX_SPECIAL_OWNER_ID
              && pGrp->group_id <= MAX_SPECIAL_GROUP_ID )
            {
               TRACE(TDSMFG,("Loading new group %x,%x ver %d",pGrp->owner_id,pGrp->group_id,tmp_group_version))
               pSGrp->status = FGS_LOADING;
            }
            else
         #endif
            {
               TRACE(TDSMFG,("Delete old stale group (%x,%x) new ver %d",pGrp->owner_id,pGrp->group_id,tmp_group_version))
               DeleteStoredGroup( pGrp->owner_id, pGrp->group_id );
            #ifdef INCLUDE_AU_PROFILE
               if ( !(pSGrp->crsl_usr_info.use_flags & USE_FROM_CAROUSEL) )
               {
                  pSGrp->status = FGS_PENDING;
               }
               else
            #endif
               {
                  pSGrp->status = FGS_ACTIVE;
               }
            }
            /* before add to the list, check the cache available size */
            tmp_group_size += size + MAX_MAN_HDR_SIZE; /* add max man file size */
            while (tmp_group_size + FileGroupTotalSize() > fg_nvm_max_limit)
            {
               if ( !RemoveLeastDesiredGroup() ) break;
            }
            /* add group to list */
            pSGrp->next = stored_group_list;
            stored_group_list = pSGrp;
         }
      }
   }
   return pSGrp;
}

static U32BIT SaveManifestFile( const char *fname, U8BIT *data, U32BIT size, S_CarouselInfoFileGroup *pFG )
{
   void *file;
   U32BIT hdr_size, val;
   S_JSON_MEMBERS *pJM;
   S_STRING location;
   char *pCh;
   char hdr_data[MAX_MAN_HDR_SIZE];

   TRACE(TDSMFG, ("  %s", fname))

   file = STB_NVMOpenFile( (U8BIT*)fname, FILE_MODE_OVERWRITE );
   if (file == NULL)
   {
      TRACE(TERROR, ("STB_NVMOpenFile failed for %s", fname))
      hdr_size = 0;
   }
   else
   {
      hdr_data[0] = '{';
      hdr_size = 1;
      /* there are three fields in header
       * 1. owner and group IDs
       * 2. the other four (one byte) properties
       * 3. group location (path)
       */
      pJM = fg_cache_members;
      pJM->u.p_uint = (U32BIT *)pFG;
      pJM[1].u.p_uint = pJM->u.p_uint + 1;
      pJM[2].u.p_str = &location;
      location.zptr = pFG->location;
      location.zlen = strlen((char *) location.zptr);
      while (pJM->tk_len != 0)
      {
         if (hdr_size != 1)
         {
            hdr_data[hdr_size++] = ',';
            hdr_data[hdr_size++] = '\n';
         }
         hdr_data[hdr_size++] = '\"';
         memcpy(hdr_data + hdr_size, pJM->tk_str, pJM->tk_len);
         hdr_size += pJM->tk_len;
         hdr_data[hdr_size++] = '\"';
         hdr_data[hdr_size++] = ':';
         switch (pJM->type)
         {
            case JST_PTR_INTEGER:
               memcpy(hdr_data + hdr_size, "          ", 10);
               hdr_size += 10;
               pCh = hdr_data + hdr_size - 1;
               *pCh = '0';
               val = *pJM->u.p_uint;
               while (val != 0)
               {
                  *pCh = '0' + (val % 10);
                  val /= 10;
                  pCh--;
               }
               break;
            case JST_PTR_ASTRING:
               hdr_data[hdr_size++] = '\"';
               val = pJM->u.p_str->zlen;
               if (val)
               {
                  memcpy(hdr_data + hdr_size, pJM->u.p_str->zptr, val);
                  hdr_size += val;
               }
               hdr_data[hdr_size++] = '\"';
               break;
            default:;
         }
         pJM++;
      }
      hdr_data[hdr_size++] = '\n';
      if (STB_NVMWriteFile( file, (U8BIT *)hdr_data, hdr_size) == hdr_size &&
          STB_NVMWriteFile( file, data, size ) == size &&
          STB_NVMWriteFile( file, (U8BIT *)"}\n", 2 ) == 2)
      {
         hdr_size += size + 2;
      }
      else
      {
         TRACE(TERROR, ("STB_NVMWriteFile failed for %s", fname))
         hdr_size = 0;
      }
      STB_NVMCloseFile( file );
   }
   return hdr_size;
}

void ManifestLoadGood( void *userData, S_CONTENT *pContent )
{
   S_CarouselInfoFileGroup *pFG;
   S_FGManifest *pFgm;
   S_STORED_GROUP *pSGrp;
   S_ManRequest *pManRqst;
   char filename[16];
   U32BIT size;
   TRACE(TDSMFG, ("##########################"));
   assert( fg_manifest_rqst != NULL );
   pFG = (S_CarouselInfoFileGroup *)userData;
   pManRqst = fg_manifest_rqst;
   while (pManRqst != NULL)
   {
      if (pFG >= pManRqst->pFG && pFG < (pManRqst->pFG + pManRqst->total))
      {
         break;
      }
      pManRqst = pManRqst->next;
   }
   if (pManRqst == NULL)
   {
      TRACE(TERROR,("Manifest request not found"))
   }
   else
   {
      assert( pManRqst->outstanding != 0 );
      pFgm = (S_FGManifest *)(pManRqst + 1);
      pFgm += pFG - pManRqst->pFG;
      pFgm->ormRqst = NULL;

      pSGrp = ParseManifestFile( pContent->data, pContent->size, pFG, pManRqst->hOC );
      if (pSGrp != NULL)
      {
         /* reconstruct filename from owner and group ids */
         SetFilename( pFG->owner_id, pFG->group_id, filename );
         if (pSGrp->status == FGS_LOADING)
         {
            /* Set first char of name to offset char -avoiding clash with original stored group name */
            filename[0] += NAME_CHAR_OFFSET;
         }
         size = SaveManifestFile( filename, pContent->data, pContent->size, pFG );
         if (size == 0)
         {
            FileGroupRemove( pSGrp );
            FileGroupFree( pSGrp );
         }
         else
         {
            pSGrp->hOC = pManRqst->hOC;
            pSGrp->man_file_size = size;
            pSGrp->last_accessed = STB_OSGetClockMilliseconds();
            /* next assumes GROUP_DIR_LEN is 8 */
            memcpy( pSGrp->dir_name, filename, 4 );
            memcpy( pSGrp->dir_name + 4, filename + 5, 4 );
            /* make requests for all files in the group */
            if (!(pSGrp->crsl_usr_info.use_flags & USE_FROM_CAROUSEL))
            {
               LoadAllFileData( pSGrp, pManRqst->cachePriority );
            }
            else
            {
               GetAllFileData( pSGrp, pManRqst->cachePriority );
            }
         }
      }
      if (pContent->destroy)
      {
         pContent->destroy( pContent->fs_handle );
         pContent->destroy = NULL;
         pContent->fs_handle = NULL;
      }

      /* clear content's user_data so that can later detect which is still outstanding */
      pManRqst->outstanding--;
      if (!pManRqst->outstanding)
      {
         DSMCC_ClientUnloadFileGroups( pManRqst->dsmInst, pManRqst->hOC, pManRqst->pFG );
      }
   }
}

void ManifestLoadFail( void *userData )
{
   S_CarouselInfoFileGroup *pFG;
   S_FGManifest *pFgm;
   S_ManRequest *pManRqst;
   TRACE(TDSMFG, ("##########################"));
   assert( fg_manifest_rqst != NULL );
   pFG = (S_CarouselInfoFileGroup *)userData;
   pManRqst = fg_manifest_rqst;
   while (pManRqst != NULL)
   {
      if (pFG >= pManRqst->pFG && pFG < (pManRqst->pFG + pManRqst->total))
      {
         break;
      }
      pManRqst = pManRqst->next;
   }
   if (pManRqst == NULL)
   {
      TRACE(TERROR,("Manifest request not found"))
   }
   else
   {
      assert( pManRqst->outstanding != 0 );
      pFgm = (S_FGManifest *)(pManRqst + 1);
      pFgm += pFG - pManRqst->pFG;
      pFgm->ormRqst = NULL;

      /* clear content's user_data so that can later detect which is still outstanding */
      pManRqst->outstanding--;
      if (!pManRqst->outstanding)
      {
         DSMCC_ClientUnloadFileGroups( pManRqst->dsmInst, pManRqst->hOC, pManRqst->pFG );
      }
   }
}

static void SwitchToNewStoredGroup(S_STORED_GROUP* pSGrp)
{
   S_STORED_GROUP* pOrigSG;
   U8BIT oldname[16];
   U8BIT newname[16];
   U8BIT olddir[10];
   U8BIT newdir[10];
   BOOLEAN error = FALSE;

   assert(pSGrp->crsl_usr_info.owner_id <= MAX_SPECIAL_OWNER_ID && pSGrp->crsl_usr_info.group_id <= MAX_SPECIAL_GROUP_ID);

   SetFilename( pSGrp->crsl_usr_info.owner_id, pSGrp->crsl_usr_info.group_id, oldname );
   strcpy(newname,oldname);
   memcpy( olddir, oldname, 4 );
   memcpy( olddir+4, oldname+5, 4 );
   olddir[8] = 0;
   strcpy(newdir,olddir);

   pOrigSG = stored_group_list;
   while ( pOrigSG != NULL )
   {
      if ( pOrigSG->crsl_usr_info.owner_id == pSGrp->crsl_usr_info.owner_id
        && pOrigSG->crsl_usr_info.group_id == pSGrp->crsl_usr_info.group_id )
      {
         assert( memcmp(olddir,pOrigSG->dir_name,8) == 0 );
         newname[1] += NAME_CHAR_OFFSET;
         newdir[1] += NAME_CHAR_OFFSET;
         if ( !STB_NVMMoveFile( oldname, newname ) )
         {
            error = TRUE;
         }
         else if ( !STB_NVMMoveFile( olddir, newdir ) )
         {
            error = TRUE;
            STB_NVMMoveFile( newname, oldname );
         }
         else
         {
            memcpy( pOrigSG->dir_name, newdir, 8 );
         }
         newname[1] -= NAME_CHAR_OFFSET;
         newdir[1] -= NAME_CHAR_OFFSET;
         break;
      }
      pOrigSG = pOrigSG->next;
   }
   if (!error)
   {
      oldname[0] += NAME_CHAR_OFFSET;
      olddir[0] += NAME_CHAR_OFFSET;
      assert( memcmp(olddir,pSGrp->dir_name,8) == 0 );
      if ( !STB_NVMMoveFile( oldname, newname ) )
      {
         error = TRUE;
      }
      else if ( !STB_NVMMoveFile( olddir, newdir ) )
      {
         error = TRUE;
         STB_NVMMoveFile( newname, oldname );
      }
      if ( error )
      {
         TRACE(TERROR,("failed to move to new Store group: %s",newdir))
         if (pOrigSG != NULL)
         {
            /* Restore old group */
            oldname[0] -= NAME_CHAR_OFFSET;
            olddir[0] -= NAME_CHAR_OFFSET;
            newname[1] += NAME_CHAR_OFFSET;
            newdir[1] += NAME_CHAR_OFFSET;
            STB_NVMMoveFile( newname, oldname );
            STB_NVMMoveFile( newdir, olddir );
            memcpy( pOrigSG->dir_name, olddir, 8 );
         }
         DeleteAllFiles( pSGrp );
         FileGroupRemove( pSGrp );
         FileGroupFree( pSGrp );
      }
      else
      {
         memcpy( pSGrp->dir_name, newname, 8 );
         pSGrp->status = FGS_ACTIVE;
         if (pOrigSG != NULL)
         {
            DeleteAllFiles( pOrigSG );
            FileGroupRemove( pOrigSG );
            FileGroupFree( pOrigSG );
         }
      }
   }
}

static void FileLoadedGood( void *userData, S_CONTENT *pContent )
{
   S_DSM_FILE_RQST *pDsmRqst = (S_DSM_FILE_RQST *)userData;
   S_STORED_GROUP *pSGrp = pDsmRqst->sfg;
   U32BIT size = pContent->size;
   U8BIT *data = NULL;
   void *file;

   TRACE(TDSMFG, ("########### GOOD ###############"));

   /* Update NVM copy of file data */
   file = STB_NVMOpenFile((U8BIT*) pDsmRqst->fname, FILE_MODE_OVERWRITE);
   if (file != NULL)
   {
      if (STB_NVMWriteFile(file, pContent->data, size) != size)
      {
         TRACE(TERROR, ("STB_NVMWriteFile failed for %s", pDsmRqst->fname))
      }
      STB_NVMCloseFile( file );
   }
   switch (pSGrp->status)
   {
      case FGS_ACTIVE:
      case FGS_LOADING:
         if (size > MAX_SIZE_OF_CACHED_FILE)
         {
            break;
         }
      /* else fall though */
      case FGS_PENDING:
         /* FG keeps a copy of file data memory */
         data = DSMAlloc((size == 0) ? 1 : size );
         if (data == NULL)
         {
            TRACE(TERROR, ("malloc(%d)", size))
         }
         break;
      default:;
   }
   if (data == NULL)
   {
      TRACE(TDSMFG, ("Using DSMCC content data"))
      *(pDsmRqst->pFgCtnt) = *pContent;
      memset(pContent,0,sizeof(S_CONTENT));
      pContent = pDsmRqst->pFgCtnt;
   }
   else
   {
      if (size == 0)
      {
         data[0] = 0;
      }
      else
      {
         memcpy(data, pContent->data, size);
      }
      /* free DSM memory resource */
      if (pContent->destroy)
      {
         pContent->destroy( pContent->fs_handle );
         memset(pContent,0,sizeof(S_CONTENT));
      }
      /* Save data in FG Content */
      pContent = pDsmRqst->pFgCtnt;
      pContent->size = size;
      pContent->data = data;
      pContent->destroy = DSMFree;
      pContent->fs_handle = data;
   }
   switch (pSGrp->status)
   {
      case FGS_ACTIVE:
         /* find and fulfil any Client request for this file */
         if (!FulfilRequest( pContent, FS_STATUS_OK ))
         {
            TRACE(TERROR,("Request not found for %s",pDsmRqst->fname))
            if (data == NULL && pContent->destroy != NULL)
            {
               pContent->destroy( pContent->fs_handle );
               pContent->destroy = NULL;
               pContent->fs_handle = NULL;
               pContent->data = NULL;
            }
         }
         break;
      case FGS_LOADING:
         if ( !HasMissingFileData(pSGrp) )
         {
            SwitchToNewStoredGroup(pSGrp);
         }
         break;
      case FGS_PENDING:
         if (!HasMissingFileData(pSGrp))
         {
            pSGrp->status = FGS_ACTIVE;
            if (fg_request_head != NULL)
            {
               FulfilOutstandingFileRequests( pSGrp, FS_STATUS_OK );
            }
         }
         break;
      default:;
   }
   pContent->user_data = NULL;
   DSMFree( pDsmRqst );
}

static void FileLoadedFail( void *userData )
{
   S_DSM_FILE_RQST *pDsmRqst = (S_DSM_FILE_RQST *)userData;
   S_STORED_GROUP *pSGrp = pDsmRqst->sfg;

   TRACE(TDSMFG, ("########### FAIL ###############"));
   switch (pSGrp->status)
   {
      case FGS_ACTIVE:
         FulfilRequest( pDsmRqst->pFgCtnt, FS_STATUS_ERROR );
         break;
      case FGS_LOADING:
         break;
      case FGS_PENDING:
         pSGrp->status = FGS_ERROR;
         if (fg_request_head != NULL)
         {
            TRACE(TERROR, (" status Error, use_flg 0x%x", pSGrp->crsl_usr_info.use_flags))
            FulfilOutstandingFileRequests( pSGrp, FS_STATUS_ERROR );
         }
         break;
      default:;
   }
   pDsmRqst->pFgCtnt->user_data = NULL;
   DSMFree( pDsmRqst );
}

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


static void* NodesArray( unsigned int val, void *array, void *gptr )
{
   S_STORED_GROUP *pSGrp;
   S_NODE *pNode = NULL;
   switch (val)
   {
      case JSON_VALUE_FINISH:
         TRACE(TDSMFG, ("Array FINISH"))
         break;

      case JSON_VALUE_ERROR:
         TRACE(TERROR, ("Array ERROR"))
         break;

      default:
         /* val is number of nodes */
         if (gptr != NULL)
         {
            pSGrp = (S_STORED_GROUP *)gptr;
            pSGrp->total_nodes = val;
            if (val == 0)
            {
               TRACE(TDSMFG,("Group has zero nodes - it will be deleted"))
            }
            else
            {
               pNode = DSMAlloc( val * sizeof(S_NODE));
               if (pNode != NULL)
               {
                  memset(pNode, 0, val * sizeof(S_NODE));
               }
            }
            pSGrp->nodes = pNode;
            tmp_node_filename.zlen = 0;
            tmp_node_filename.zptr = NULL;
            tmp_node_count = 0;
         }
   }
   return pNode;
}

static void* NodeFinish( unsigned int val, void *array, void *gptr )
{
   S_NODE *pNode;
   char *pName;
   if (val == JSON_VALUE_FINISH && gptr != NULL && tmp_node_filename.zptr != NULL)
   {
      pNode = (S_NODE *)gptr;

      TRACE(TDSMFG, ("File=%.*s", (int)tmp_node_filename.zlen, tmp_node_filename.zptr))

      /* Strip off leading slashes and backslashes */
      while (tmp_node_filename.zlen != 0 &&
             ((*tmp_node_filename.zptr == '/') || (*tmp_node_filename.zptr == '\\')))
      {
         tmp_node_filename.zptr++;
         tmp_node_filename.zlen--;
      }
      if (tmp_node_filename.zlen != 0)   /*should always be non-zero if it's a sensible file name*/
      {
         if (tmp_node_count == 0)
         {
            pName = (char *)STR_DataAlloc( tmp_node_filename.zlen );
         }
         else
         {
            /* reserve 3 extra bytes for '000' extension <- used by GetAllFileData() */
            pName = (char *)STR_DataAlloc( tmp_node_filename.zlen + 3 );
         }
         if (pName != NULL)
         {
            memcpy(pName, tmp_node_filename.zptr, tmp_node_filename.zlen);
            pName[tmp_node_filename.zlen] = 0;
            pNode->nfname = pName;
            pNode->nflen = (U16BIT)tmp_node_filename.zlen;
            if (tmp_node_count == 0)
            {
               memset( &(pNode->u.content), 0, sizeof(S_CONTENT));
               pNode->count = 0;
            }
            else
            {
               S_CONTENT *pCtnt;

               pName[tmp_node_filename.zlen + 3] = 0; /*null extra end char*/

               if (tmp_node_count > 999)
               {
                  tmp_node_count = 999;
               }
               pCtnt = (S_CONTENT *)DSMAlloc( tmp_node_count * sizeof(S_CONTENT));
               if (pCtnt != NULL)
               {
                  memset(pCtnt, 0, tmp_node_count * sizeof(S_CONTENT));
                  pNode->count = (U16BIT)tmp_node_count;
                  pNode->u.contents = pCtnt;
               }
               else
               {
                  TRACE(TERROR, ("malloc(%ld)", tmp_node_count * sizeof(S_CONTENT)))
               }
            }
         }
         pNode++; /* return pointer to next node */
      }
      tmp_node_count = 0;
      tmp_node_filename.zptr = NULL;
   }
   else
   {
      pNode = NULL;
   }
   return pNode;
}

#endif /*INCLUDE_DSM_FG*/