mh5hfs.c

Go to the documentation of this file.

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

#include "mh5profile.h"
#include "mh5hfs.h"
#include "mh5gate.h"
#include "mh5memory.h"
#include "techtype.h"
#include "glue_debug.h"

/*---constant definitions for this file--------------------------------------*/
/*#define HFS_DEBUG_TABLE*/
/*#define HFS_DEBUG_PRINT*/

#ifdef HFS_DEBUG_PRINT
#define PRINT(x) TRACE(TFILE,x)
#else
#define PRINT(x)
#endif

/* TODO: This needs to be tied in with maximum number of applications */
#define MAX_HFS_TABLES 6


/*---local typedef structs for this file-------------------------------------*/
typedef struct HfsMapping
{
   struct HfsMapping *next;
   MHEG5String pathName;
   MHEG5String mappingList;
   MHEG5Int refCount;
} HfsMapping;

typedef struct HfsTable
{
   HfsMapping *anchor;
} HfsTable;

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

static HfsTable hfsTables[MAX_HFS_TABLES];
static HfsTable *hfsTable = &hfsTables[0];
static HfsMapping defaultMapping = {
   NULL,
   { 2, (MHEG5Byte *)"//" },
   { 6, (MHEG5Byte *)"DSM://" },
   0
};

/*---local function prototypes for this file---------------------------------*/
static void ClearMappingTable(void);
static void PushMappingTable(void);
static void PopMappingTable(void);
static void ReleaseMapping(HfsMapping *mapping);
static HfsMapping** FindMapping(MHEG5String *pathName);
static void RemoveMapping(HfsMapping **pMapping);
static void ReplaceMapping(HfsMapping **pMapping, HfsMapping *mapping);
static HfsMapping* CreateMapping(MHEG5String *pathName,
   MHEG5String *mappingList);
static void InsertMapping(HfsMapping *newMapping);
static MHEG5Bool IsStringEqual(MHEG5String *string, MHEG5String *otherString);
static MHEG5Bool IsStringAfter(MHEG5String *string, MHEG5String *otherString);
static MHEG5Bool IsDefaultMapping(HfsMapping *mapping);
static MHEG5Bool IsValidReference(MHEG5String *reference);
static MHEG5Bool IsValidInput(MHEG5String *pathName, MHEG5String *mappingList);

#ifdef HFS_DEBUG_TABLE
static void PrintMappingTable(void);
#endif  /* HFS_DEBUG_TABLE */

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

void MHEG5InitialiseHybridFileSystem(void)
{
   ClearMappingTable();
}

void MHEG5ClearHybridFileSystem(void)
{
   ClearMappingTable();
   while (hfsTable != hfsTables)
   {
      PopMappingTable();
      ClearMappingTable();
   }
}

void MHEG5PushHybridFileSystem(void)
{
   PushMappingTable();
}

void MHEG5PopHybridFileSystem(void)
{
   PopMappingTable();
}

void MHEG5SetHybridFileSystem(MHEG5String *pathName, MHEG5String *mappingList)
{
   HfsMapping *newMapping;
   HfsMapping **pMapping;

   TRACE(TFILE,("(\"%.*s\",\"%.*s\")",
          (int)pathName->len, (char *)pathName->data,
          (int)mappingList->len, (char *)mappingList->data));

   if (pathName->len > 0)
   {
      pMapping = FindMapping(pathName);
      if (pMapping != NULL)
      {
         if (mappingList->len == 0)
         {
            RemoveMapping(pMapping);
         }
         else
         {
            newMapping = CreateMapping(pathName, mappingList);
            if (newMapping != NULL)
            {
               ReplaceMapping(pMapping, newMapping);
            }
         }
      }
      else
      {
         if (mappingList->len != 0)
         {
            newMapping = CreateMapping(pathName, mappingList);
            if (newMapping != NULL)
            {
               InsertMapping(newMapping);
            }
         }
      }
   }
   else
   {
      /* When pathName is empty, all mappings are removed and the
       * default mapping is restored
       */
      MHEG5InitialiseHybridFileSystem();
   }

#ifdef HFS_DEBUG_TABLE
   DBGTRACE(TFILE,"");
   PrintMappingTable();
#endif
}

void* MHEG5GetHybridFileSystemMapping(MHEG5String *reference)
{
   HfsMapping *mapping;
   HfsMapping *currentMapping;
   MHEG5String pathName;
   MHEG5Int longest;

   longest = 0;
   mapping = NULL;
   if (IsValidReference(reference))
   {
      currentMapping = hfsTable->anchor;
      while (currentMapping != NULL)
      {
         pathName = currentMapping->pathName;
         if (longest < pathName.len)
         {
            if (pathName.data[pathName.len - 1] == '/')
            {
               /* Directory, must be a proper prefix */
               if (pathName.len < reference->len &&
                   memcmp(pathName.data, reference->data, pathName.len) == 0)
               {
                  longest = pathName.len;
                  mapping = currentMapping;
               }
            }
            else
            {
               /* File, must be a complete match */
               if (pathName.len == reference->len &&
                   memcmp(pathName.data, reference->data, pathName.len) == 0)
               {
                  longest = pathName.len;
                  mapping = currentMapping;
               }
            }
         }
         currentMapping = currentMapping->next;
      }
      if (mapping != NULL)
      {
         TRACE(TFILE,("path=%.*s mapping=%.*s",
            (int)mapping->pathName.len, mapping->pathName.data,
            (int)mapping->mappingList.len, mapping->mappingList.data));
         mapping->refCount++;
      }
   }

   return mapping;
}

void MHEG5ReleaseHybridFileSystemMapping(void *handle)
{
   assert(handle != NULL);

   ReleaseMapping(handle);
}

void MHEG5InitMappingIter(MHEG5MappingIter_t *iter, void *mapping)
{
   assert(iter != NULL);
   assert(mapping != NULL);

   iter->mapping = mapping;
   iter->currentPos = 0;
   TRACE(TFILE,(""));
}

MHEG5String MHEG5GetNextReference(MHEG5String *ref,
   MHEG5MappingIter_t *iter)
{
   MHEG5String reference;
   HfsMapping *mapping;
   MHEG5Byte *data;
   MHEG5Int len, limit;

   assert(iter != NULL);

   mapping = iter->mapping;
   if (iter->currentPos == mapping->mappingList.len)
   {
      /* End of iteration */
      reference.len = 0;
      reference.data = NULL;
      TRACE(TFILE,("END"));
   }
   else
   {
      /* Find next space or end-of-list */
      data = mapping->mappingList.data + iter->currentPos;
      limit = mapping->mappingList.len - iter->currentPos;
      len = 0;
      while (len < limit && data[len] != ' ')
      {
         len++;
      }

      if (data[len - 1] == '/')
      {
         reference.len = 0;
         reference.data = STR_DataAlloc(len + ref->len -
               mapping->pathName.len);
         if (reference.data != NULL)
         {
            memcpy(reference.data, data, len);
            reference.len += len;
            memcpy(reference.data + reference.len,
               ref->data + mapping->pathName.len,
               ref->len - mapping->pathName.len);
            reference.len += ref->len - mapping->pathName.len;
            reference.data[reference.len] = '\0';
         }
      }
      else
      {
         reference.len = 0;
         reference.data = STR_DataAlloc(len);
         if (reference.data != NULL)
         {
            memcpy(reference.data, data, len);
            reference.data[len] = '\0';
            reference.len = len;
         }
      }

      iter->currentPos += len;
      if (iter->currentPos < mapping->mappingList.len)
      {
         /* Skip space */
         iter->currentPos++;
      }
      TRACE(TFILE,("reference=%.*s",(int)reference.len, reference.data));
   }
   return reference;
}

MHEG5String MHEG5GetFirstDsmReference(MHEG5String *reference)
{
   MHEG5String path;
   MHEG5String output, input;
   void *mapping;
   E_FS_ORIGIN origin;
   MHEG5MappingIter_t iter;

   output.len = 0;
   output.data = NULL;

   /* Convenience function - uses other API functions */
   path = MHEG5convertGIDGetOrigin(reference,&origin);
   if (origin == ORIGIN_HYBRID)
   {
      input.data = (U8BIT *)path.data + 7;  /* skip "hybrid:" */
      input.len = path.len - 7;
      mapping = MHEG5GetHybridFileSystemMapping(&input);
      MHEG5InitMappingIter(&iter, mapping);
      output = MHEG5GetNextReference(&input, &iter);
      while (output.len != 0)
      {
         if (output.len >= 6 && memcmp(output.data, "DSM://", 6) == 0)
         {
            break;
         }
         MHEG5stringDestruct(&output);
         output = MHEG5GetNextReference(&input, &iter);
      }
      MHEG5ReleaseHybridFileSystemMapping(mapping);
   }
   else if (origin == ORIGIN_DSM)
   {
       /* starts with "DSM://" */
      output = MHEG5stringCopy(*reference);
   }
   MHEG5stringDestruct(&path);

   return output;
}

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


static void ClearMappingTable(void)
{
   HfsMapping *mapping;

   /* Release all mappings */
   mapping = hfsTable->anchor;
   while (mapping != NULL)
   {
      hfsTable->anchor = mapping->next;
      ReleaseMapping(mapping);
      mapping = hfsTable->anchor;
   }

   /* Create default mapping */
   hfsTable->anchor = &defaultMapping;

#ifdef HFS_DEBUG_TABLE
   DBGTRACE(TFILE,"");
   PrintMappingTable();
#endif
}

static void PushMappingTable(void)
{
   HfsTable *newTable = hfsTable + 1;
   HfsMapping *curr, **new;

   assert(newTable - hfsTables < MAX_HFS_TABLES);
   assert(newTable->anchor == NULL ||
      newTable->anchor == &defaultMapping);

   /* Copy mapping, resetting reference counts */
   curr = hfsTable->anchor;
   new = &newTable->anchor;
   while (curr != NULL)
   {
      (*new) = MHEG5getMem(sizeof **new);
      if (*new != NULL)
      {
         (*new)->pathName = MHEG5stringCopy(curr->pathName);
         (*new)->mappingList = MHEG5stringCopy(curr->mappingList);
         (*new)->refCount = 1;

         new = &(*new)->next;
      }
      curr = curr->next;
   }
   *new = NULL;

   ++hfsTable;

#ifdef HFS_DEBUG_TABLE
   DBGTRACE(TFILE,"");
   PrintMappingTable();
#endif
}

static void PopMappingTable(void)
{
   assert(hfsTable - hfsTables > 0);

   ClearMappingTable();
   --hfsTable;

#ifdef HFS_DEBUG_TABLE
   DBGTRACE(TFILE,"");
   PrintMappingTable();
#endif
}

static void ReleaseMapping(HfsMapping *mapping)
{
   if (mapping != &defaultMapping)
   {
      mapping->refCount--;
      assert(mapping->refCount >= 0);

      if (mapping->refCount == 0)
      {
         MHEG5stringDestruct(&mapping->pathName);
         MHEG5stringDestruct(&mapping->mappingList);
         MHEG5freeMem(mapping);
      }
   }
}

static HfsMapping** FindMapping(MHEG5String *pathName)
{
   HfsMapping *mapping;
   HfsMapping **pMapping;
   MHEG5Bool match;

   pMapping = &hfsTable->anchor;
   mapping = *pMapping;
   match = MHEG5FALSE;
   while (mapping != NULL && !match)
   {
      match = IsStringEqual(pathName, &mapping->pathName);
      if (!match)
      {
         pMapping = &mapping->next;
         mapping = *pMapping;
      }
   }

   if (!match)
   {
      pMapping = NULL;
   }

   return pMapping;
}

static void RemoveMapping(HfsMapping **pMapping)
{
   HfsMapping *oldMapping;
   HfsMapping *nextMapping;

   oldMapping = *pMapping;
   if (!IsDefaultMapping(oldMapping))
   {
      nextMapping = oldMapping->next;

      /* Detach old mapping */
      *pMapping = nextMapping;

      /* Release old mapping */
      ReleaseMapping(oldMapping);
   }
}

static void ReplaceMapping(HfsMapping **pMapping, HfsMapping *mapping)
{
   HfsMapping *oldMapping;
   HfsMapping *nextMapping;

   oldMapping = (*pMapping);
   nextMapping = oldMapping->next;

   /* Detach old mapping */
   oldMapping->next = NULL;

   /* Replace mapping */
   mapping->next = nextMapping;
   *pMapping = mapping;

   /* Release old mapping */
   ReleaseMapping(oldMapping);
}

static HfsMapping* CreateMapping(MHEG5String *pathName,
   MHEG5String *mappingList)
{
   HfsMapping *mapping;

   mapping = NULL;
   if (IsValidInput(pathName, mappingList))
   {
      mapping = MHEG5getMem(sizeof *mapping);
      if (mapping != NULL)
      {
         mapping->pathName = MHEG5stringCopy(*pathName);
         mapping->mappingList = MHEG5stringCopy(*mappingList);
         if ((mapping->pathName.len == pathName->len) &&
             (mapping->mappingList.len == mappingList->len))
         {
            mapping->next = NULL;
            mapping->refCount = 1;
         }
         else
         {
            MHEG5stringDestruct(&mapping->pathName);
            MHEG5stringDestruct(&mapping->mappingList);
            MHEG5freeMem(mapping);
            mapping = NULL;
         }
      }
   }

   return mapping;
}

static void InsertMapping(HfsMapping *newMapping)
{
   HfsMapping *mapping;
   HfsMapping **pMapping;

   newMapping->next = NULL;

   pMapping = &hfsTable->anchor;
   while (*pMapping != NULL)
   {
      mapping = *pMapping;
      if (IsStringAfter(&newMapping->pathName, &mapping->pathName))
      {
         newMapping->next = mapping;
         break;
      }
      else
      {
         pMapping = &(*pMapping)->next;
      }
   }
   *pMapping = newMapping;
}

static MHEG5Bool IsStringEqual(MHEG5String *string, MHEG5String *otherString)
{
   MHEG5Bool equal;

   equal = MHEG5FALSE;
   if (string->len == otherString->len)
   {
      if (string->len == 0 ||
          (string->len > 0 &&
           memcmp(string->data, otherString->data, string->len) == 0))
      {
         equal = MHEG5TRUE;
      }
   }

   return equal;
}

static MHEG5Bool IsStringAfter(MHEG5String *string, MHEG5String *otherString)
{
   MHEG5Bool after;
   MHEG5Int toCompare;
   int comp;

   after = MHEG5FALSE;
   toCompare = string->len;
   if (toCompare > otherString->len)
   {
      toCompare = otherString->len;
   }

   comp = memcmp(string->data, otherString->data, toCompare);
   if (comp > 0 || (comp == 0 && string->len > otherString->len))
   {
      after = MHEG5TRUE;
   }

   return after;
}

static MHEG5Bool IsDefaultMapping(HfsMapping *mapping)
{
   MHEG5Bool result;

   result = MHEG5FALSE;
   if (mapping->pathName.len == 2 &&
       mapping->pathName.data[0] == '/' &&
       mapping->pathName.data[1] == '/')
   {
      result = MHEG5TRUE;
   }

   return result;
}

static MHEG5Bool IsValidReference(MHEG5String *reference)
{
   MHEG5Bool valid;

   valid = MHEG5FALSE;
   if ((reference->len > 2) &&
       (reference->data[0] == '/') && (reference->data[1] == '/'))
   {
      valid = MHEG5TRUE;
   }

   return valid;
}

static MHEG5Bool IsValidInput(MHEG5String *pathName, MHEG5String *mappingList)
{
   MHEG5Int start;
   MHEG5Int offset;
   MHEG5Int length;
   MHEG5String check;
   MHEG5Bool valid;
   MHEG5Bool isFile;
   MHEG5String path;
   E_FS_ORIGIN origin;

   valid = MHEG5TRUE;

   /* Check path name */
   path = MHEG5convertGIDGetOrigin(pathName,&origin);
   if (path.len > 0)
   {
      if (path.data[path.len - 1] != '/')
      {
         isFile = MHEG5TRUE;
      }
      else
      {
         isFile = MHEG5FALSE;
      }
   }
   else
   {
      valid = MHEG5FALSE;
   }

   /* Check mapping list */
   start = 0;
   offset = 0;
   while (valid && offset < mappingList->len)
   {
      while (offset < mappingList->len && mappingList->data[offset] != ' ')
      {
         ++offset;
      }

      length = offset - start;
      PRINT(("Checking \"%.*s\"\n", (int)length, mappingList->data + start));

      check.data = mappingList->data + start;
      check.len = length;
      MHEG5stringDestruct(&path);
      path = MHEG5convertGIDGetOrigin(&check,&origin);
      if (path.len == 0 || origin == ORIGIN_HYBRID)
      {
         valid = MHEG5FALSE;
      }
      else if (path.data[path.len - 1] == '/' && isFile)
      {
         valid = MHEG5FALSE;
      }
      else if (path.data[path.len - 1] != '/' && !isFile)
      {
         valid = MHEG5FALSE;
      }

      ++offset;
      start = offset;
   }
   MHEG5stringDestruct(&path);

   return valid;
}

#ifdef HFS_DEBUG_TABLE

static void PrintMappingTable(void)
{
   HfsMapping *mapping;

   mapping = hfsTable->anchor;
   while (mapping != NULL)
   {
      TPRINT(TFILE,("pathName = \"%.*s\"\n", (int)mapping->pathName.len,
             (char *)mapping->pathName.data));
      TPRINT(TFILE,("mappingList = \"%.*s\"\n", (int)mapping->mappingList.len,
             (char *)mapping->mappingList.data));
      mapping = mapping->next;
   }
}

#endif  /* HFS_DEBUG_TABLE */