mh5gate.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 orig 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 <string.h>

#include "mh5base.h"
#include "mh5memory.h"
#include "mh5application.h"
#include "mh5debug.h"
#include "mh5profile.h"
#include "mh5gate.h"
#ifdef INCLUDE_IC
#include "mh5control.h"
#include "mh5support.h"
#endif

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


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


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

static struct
{
   const char *data;
   int len;
} source_names[ORIGIN_MAX] = {
   { "DSM:/", 5 },
   { "CI:/", 4 },
   { "hybrid:/", 8 },
   { "http:/", 6 },
   { "https:/", 7 },
   { "dvb:/", 5 },
   { "rec:/", 5 }
};

/* Path from // to the active application - see UK1.05 section 8.3.3.3 */
static MHEG5String activeAppPath = { 0, NULL };

/* Origin of the current orig - See UK1.05 section 6.2.4 */
#ifdef INCLUDE_IC
static E_FS_ORIGIN currentSource = ORIGIN_HYBRID;
#else
static E_FS_ORIGIN currentSource = ORIGIN_DSM;
#endif

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

static void ResolveParentDir(MHEG5String *ref, MHEG5Int *parents)
{
   MHEG5Int i, j, k;
   enum
   {
      ST_START, ST_SEP, ST_FIRST_DOT, ST_SECOND_DOT
   } state;

   *parents = 0;
   state = ST_SEP;
   j = 0;
   for (i = 0, j = 0; i != ref->len; ++i, ++j)
   {
      ref->data[j] = ref->data[i];
      switch (state)
      {
         case ST_START:
            if (ref->data[i] == '/')
            {
               /* / */
               state = ST_SEP;
            }
            break;

         case ST_SEP:
            if (ref->data[i] == '.')
            {
               /* /. */
               state = ST_FIRST_DOT;
            }
            else
            {
               /* /x */
               state = ST_START;
            }
            break;

         case ST_FIRST_DOT:
            if (ref->data[i] == '.')
            {
               /* /.. */
               state = ST_SECOND_DOT;
            }
            else
            {
               /* /.x or /./ - no resolution */
               state = ST_START;
            }
            break;

         case ST_SECOND_DOT:
            if (ref->data[i] == '/')
            {
               /* /../ - find previous separator */
               for (k = j - 4; k >= 0; --k)
               {
                  if (ref->data[k] == '/')
                  {
                     break;
                  }
               }
               if (k >= 0)
               {
                  if (memcmp(&ref->data[k], "/../", 4) == 0)
                  {
                     /* Previous path is also .. - no resolution */
                     ++(*parents);
                  }
                  else
                  {
                     /* /../ cancels the previous path */
                     j = k;
                  }
               }
               else
               {
                  /* No previous path */
                  ++(*parents);
               }
               state = ST_SEP;
            }
            else
            {
               /* /..x */
               state = ST_START;
            }
      }
   }
   ref->len = j;
   ref->len -= 3 * *parents;
   memmove(ref->data, ref->data + 3 * *parents, ref->len);
}

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

MHEG5Int MHEG5FullOriginLength(E_FS_ORIGIN origin)
{
   if (origin < ORIGIN_MAX)
   {
      return source_names[origin].len + 1;
   }
   return 0;
}

MHEG5Bool MHEG5ResolveOrigin(MHEG5String *ref, E_FS_ORIGIN *orig, MHEG5Int *offset)
{
   E_FS_ORIGIN i;
   MHEG5Bool success;

   *offset = 0;
   success = MHEG5FALSE;

   if (ref->len > 0)
   {
      if (ref->data[0] == '~')
      {
         /* Default orig */
      #ifdef INCLUDE_IC
         if (MH5_SupportInteractionChannel())
         {
            *orig = ORIGIN_HYBRID;
         }
         else
      #endif
         {
            *orig = ORIGIN_DSM;
         }
         if (ref->len > 1 && ref->data[1] == '/')
         {
            *offset = 2;   /* Skip the "~/" */
            success = MHEG5TRUE;
         }
      }
      else if (ref->data[0] == '/')
      {
         /* Empty orig. Use current orig */
         *orig = currentSource;
         *offset = 1;   /* Skip the "/" */
         success = MHEG5TRUE;
      }
      else
      {
         for (i = 0; i != ORIGIN_MAX; ++i)
         {
            if ((ref->len >= source_names[i].len) &&
                (MHEG5strncmp(ref->data, source_names[i].data, source_names[i].len)) == 0)
            {
               *orig = i;
               *offset = source_names[i].len;
               success = MHEG5TRUE;
               break;
            }
         }
      }
   }
   return success;
}

MHEG5String MHEG5convertGID( MHEG5String *inRef )
{
   E_FS_ORIGIN origin;
   return MHEG5convertGIDGetOrigin( inRef, &origin );
}

MHEG5String MHEG5convertGIDGetOrigin( MHEG5String *inRef, E_FS_ORIGIN *pOrigin )
{
   MHEG5Bool success;
   MHEG5String copy;
   MHEG5String path;
   MHEG5String out;
   E_FS_ORIGIN orig;
   MHEG5Int offset;
   MHEG5Int parents;
   MHEG5Bool root;
   MHEG5Int app_dir_len;
   MHEG5Int in_len;

   out.len = 0;
   out.data = NULL;

   in_len = inRef->len;

   /* Find origin */
   success = MHEG5ResolveOrigin(inRef, pOrigin, &offset);
   orig = *pOrigin;
   if (success)
   {
      /* Check whether the path starts from the root */
      if (inRef->data[offset] == '/')
      {
         root = MHEG5TRUE;
         offset++;
      }
      else
      {
         root = MHEG5FALSE;

         /* HTTP and HTTPS must be at root level. http:/xyz is not acceptable
          * although DSM:/xyz or hybrid:/xyz are (18.3.2.3). Note that
          * '/scene.mheg' is acceptable when the current orig is HTTP or HTTPS.
          */
         if ((offset >= 6) && (orig == ORIGIN_HTTP || orig == ORIGIN_HTTPS))
         {
            success = MHEG5FALSE;
         }
      }
   }
   if (success)
   {
      if (orig == ORIGIN_CI)
      {
         /* Remove trailing null-terminators */
         while (in_len > 0 && inRef->data[in_len - 1] == '\0')
         {
            in_len--;
         }
      }
      path.data = inRef->data + offset;
      path.len = in_len - offset;
      copy = MHEG5stringCopy(path);
      if (copy.len > 0)
      {
         ResolveParentDir(&copy, &parents);
         if (!root)
         {
            /* Not root - need to "append" to current working directory
             * after resolving parent directory. For example, "appending"
             * "../../x to DSM://a/b/c/d results in DSM://a/b/x.
             */
            app_dir_len = activeAppPath.len;
            while (parents > 0)
            {
               while (app_dir_len > 0 &&
                      activeAppPath.data[app_dir_len - 1] != '/')
               {
                  --app_dir_len;
               }
               if (app_dir_len > 0)
               {
                  --app_dir_len;
               }
               --parents;
               if (app_dir_len == 0 && parents > 0)
               {
                  break;
               }
            }
            if (parents == 0)
            {
               /* Root without parents */
               out.len = source_names[orig].len + 1 + copy.len;
               if (app_dir_len > 0)
               {
                  out.len += app_dir_len + 1;
               }
               out.data = STR_DataAlloc( out.len );
               if (out.data != NULL)
               {
                  memcpy( out.data, source_names[orig].data, source_names[orig].len );
                  offset = source_names[orig].len;
                  out.data[offset++] = '/';
                  if (app_dir_len > 0)
                  {
                     /* Current working directory is valid, we have:
                      * "<orig>://" + "cur/work/dir" + "/path"
                      */
                     memcpy( out.data + offset, activeAppPath.data, app_dir_len );
                     offset += app_dir_len;
                     out.data[offset++] = '/';
                  }
                  /* else The substring from the current working directory
                   * is empty. This means that we have:
                   * "<orig>://" + "" + "/path", so one separator is redundant
                   */
                  memcpy( out.data + offset, copy.data, copy.len );
               }
            }
         }
         else if (parents == 0)
         {
            /* Root path, no parents */
            out.len = source_names[orig].len + 1 + copy.len;
            out.data = STR_DataAlloc( out.len );
            if (out.data != NULL)
            {
               memcpy( out.data, source_names[orig].data, source_names[orig].len );
               offset = source_names[orig].len;
               out.data[offset++] = '/';
               memcpy( out.data + offset, copy.data, copy.len );
            }
         }
         else
         {
            /* invalid: root with parents (e.g. DSM://../x/y) */
         }

         /* restore original length of string, so that STR_DataFree will find the original allocation */
         copy.len = path.len;
      }
      else if (copy.len == 0 && root)
      {
         /* Root dir */
         out.len = source_names[orig].len + 1;
         out.data = STR_DataAlloc( out.len );
         if (out.data != NULL)
         {
            memcpy( out.data, source_names[orig].data, source_names[orig].len );
            offset = source_names[orig].len;
            out.data[offset++] = '/';
         }
      }
      /* Note: even zero length string gets an allocation */
      MHEG5stringDestruct(&copy);
   }

   return out;
}

MHEG5String MHEG5CreateUrl( E_FS_ORIGIN origin, S_STRING path, S_STRING name )
{
   MHEG5String out;
   MHEG5Int offset;
   out.len = source_names[origin].len;
   if (path.zptr != NULL)
   {
      if (path.zptr[0] != '/')
      {
         out.len++;
      }
      if (path.zptr[path.zlen-1] == '/')
      {
         out.len--;
      }
      out.len += path.zlen;
   }
   if (name.zptr != NULL)
   {
      if (name.zptr[0] != '/')
      {
         out.len++;
      }
      out.len += name.zlen;
   }
   out.data = STR_DataAlloc( out.len );
   if (out.data == NULL)
   {
      TRACE(TERROR,("mem fail"))
      out.len = 0;
   }
   else
   {
      memcpy( out.data, source_names[origin].data, source_names[origin].len );
      offset = source_names[origin].len;
      if (path.zptr != NULL)
      {
         if (path.zptr[0] != '/')
         {
            out.data[offset++] = '/';
         }
         if (path.zptr[path.zlen-1] == '/')
         {
            path.zlen--;
         }
         memcpy( out.data + offset, path.zptr, path.zlen );
         offset += path.zlen;
      }
      if (name.zptr != NULL)
      {
         if (name.zptr[0] != '/')
         {
            out.data[offset++] = '/';
         }
         memcpy( out.data + offset, name.zptr, name.zlen );
         offset += name.zlen;
      }
      assert(out.len == offset);
   }
   return out;
}

MHEG5Bool MHEG5sameGroup(MH5GroupPtr gptr, MH5GroupRef gref)
{
   MHEG5String path;
   MHEG5Bool rc = MHEG5FALSE;

   assert( gref.len );
   path = MHEG5convertGID((MHEG5String *)&gref);
   if (path.len == gptr->groupName.len)
   {
      if (memcmp(path.data, gptr->groupName.data, gptr->groupName.len) == 0)
         rc = MHEG5TRUE;
   }
   MHEG5stringDestruct(&path);
   return rc;
}

MHEG5Bool MHEG5sameGroups(MH5GroupRef gref1, MH5GroupRef gref2)
{
   MHEG5String path1;
   MHEG5String path2;
   MHEG5Bool rc = MHEG5FALSE;

   assert( gref1.ptr.group != gref2.ptr.group );
   if (gref1.len == 0)
   {
      if (gref2.len == 0)
      {
         rc = MHEG5TRUE;
      }
      else
      {
         rc = MHEG5sameGroup( gref1.ptr.group, gref2 );
      }
   }
   else if (gref2.len == 0)
   {
      if (gref1.len == 0)
      {
         rc = MHEG5TRUE;
      }
      else
      {
         rc = MHEG5sameGroup( gref2.ptr.group, gref1 );
      }
   }
   else
   {
      path1 = MHEG5convertGID((MHEG5String *)&gref1);
      path2 = MHEG5convertGID((MHEG5String *)&gref2);
      if ((path1.len == path2.len) &&
          (memcmp(path1.data, path2.data, path1.len) == 0)
          )
         rc = MHEG5TRUE;
      MHEG5stringDestruct(&path1);
      MHEG5stringDestruct(&path2);
   }
   return rc;
}

void MHEG5setWorkingDir(MHEG5String app_dir)
{
   E_FS_ORIGIN i;
   int firstByte;
   int lastByte;

   /* free any old path */
   if (activeAppPath.data != NULL)
   {
      STR_DataFree( activeAppPath.data, activeAppPath.len );
      activeAppPath.len = 0;
      activeAppPath.data = NULL;
   }

   if (app_dir.len < 2)
   {
      ERROR_PRINT(("ERROR: MHEG5setWorkingDir - app_dir too short\n"));
   }
   else
   {
      for (i = 0; i != ORIGIN_MAX; ++i)
      {
         if ((app_dir.len >= source_names[i].len) &&
             (MHEG5strncmp(app_dir.data, source_names[i].data, source_names[i].len)) == 0)
         {
            currentSource = i;
            break;
         }
      }
      if ( i == ORIGIN_MAX )
      {
         ERROR_PRINT(("ERROR: MHEG5setWorkingDir - unrecognised app_dir\n"));
      #ifdef INCLUDE_IC
         if (MH5_SupportInteractionChannel())
         {
            currentSource = ORIGIN_HYBRID;
         }
         else
      #endif
         {
            currentSource = ORIGIN_DSM;
         }
      }

      /* Find the first character after the first ocurrence of "//" */
      firstByte = 2;
      while (firstByte < app_dir.len)
      {
         if ((app_dir.data[firstByte - 2] == '/') &&
             (app_dir.data[firstByte - 1] == '/'))
         {
            break;
         }
         firstByte++;
      }

      /* Strip off the file name leaving only the directory path - This is done by
       * finding the last slash character
       */
      lastByte = app_dir.len - 2;
      while ((lastByte > 0) && (app_dir.data[lastByte + 1] != '/'))
      {
         lastByte--;
      }

      if (lastByte >= firstByte) /* is something to copy */
      {
         /* Calculate the number of bytes to copy */
         activeAppPath.len = lastByte - firstByte + 1;
         activeAppPath.data = STR_DataAlloc( activeAppPath.len );
         if (activeAppPath.data == NULL)
         {
            activeAppPath.len = 0;
         }
         else
         {
            /* Copy the active application directory path */
            memcpy( activeAppPath.data, app_dir.data + firstByte, activeAppPath.len );
         }
      }
   }
}