mh5access.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 <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "mh5profile.h"
#include "mh5gate.h"
#include "mh5memory.h"
#include "mh5base.h"
#include "mh5access.h"
#include "mh5fileorm.h"
#include "mh5misc.h"

#ifndef CI_PLUS_ONLY
#include "glue_dsmcc.h"
#endif
#include "stb_os.h"

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


#define SERVER_AUTH_FILE   "DSM://auth.servers"
#define ACCESS_FILE_TIMEOUT_MS (1000 * 60 * 60 * 4)
#define MAX_CALLBACKS 5

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

typedef enum
{
   ACCESS_FILE_NOTLOADED,
   ACCESS_FILE_LOADED,
   ACCESS_FILE_MISSING,
   ACCESS_FILE_LOADING_SYNC,
   ACCESS_FILE_LOADING_ASYNC
} AccessFileState_t;


/*---local (static) variable declarations for this file----------------------*/
static AccessFileState_t accessFileState = ACCESS_FILE_NOTLOADED;

static U32BIT lastAccessUpdate = 0;
static MHEG5String accessFile = {0, NULL};
static U16BIT callbackCount = 0;

static void(*fileLoadedCallback[MAX_CALLBACKS]) (void);

/*---local function prototypes for this file---------------------------------*/
static MHEG5ServerAccess_t CheckUrlPermitted(U8BIT *url);
static void AuthFileRetrieved( void *userData, S_CONTENT *content );
static void AuthFileRetrievalFailed( void *userData );
static int GetLineLength(U8BIT *string, U8BIT **remaining, int max);
static void NotifyServerAccessReady(void);

static void MHEG5UpdateServerAccess(void)
{
   MHEG5String authFilename;

   accessFileState = ACCESS_FILE_LOADING_SYNC;

   lastAccessUpdate = STB_OSGetClockMilliseconds();

   authFilename.data = (U8BIT *)SERVER_AUTH_FILE;
   authFilename.len = strlen(SERVER_AUTH_FILE);

   (void)MHEG5FileOrmGet( authFilename, FRP_CACHE_DEFAULT, NULL,
      AuthFileRetrieved, AuthFileRetrievalFailed );

   if (accessFileState == ACCESS_FILE_LOADING_SYNC)
   {
      accessFileState = ACCESS_FILE_LOADING_ASYNC;
   }
}

MHEG5ServerAccess_t MHEG5CheckServerPermitted(U8BIT *url)
{
   U32BIT currentTime;
   BOOLEAN timeToUpdate;
   MHEG5ServerAccess_t permission;

   currentTime = STB_OSGetClockMilliseconds();
   timeToUpdate = FALSE;

   permission = SERVER_ACCESS_PENDING;

   if (accessFileState == ACCESS_FILE_NOTLOADED)
   {
      timeToUpdate = TRUE;
   }
   else if ((currentTime > lastAccessUpdate) &&
            (currentTime - lastAccessUpdate) > ACCESS_FILE_TIMEOUT_MS)
   {
      timeToUpdate = TRUE;
   }
   else if (currentTime < lastAccessUpdate)
   {
      /* overflow */
      timeToUpdate = TRUE;
   }

   if (timeToUpdate)
   {
      MHEG5UpdateServerAccess();
   }

   switch (accessFileState)
   {
      case ACCESS_FILE_LOADED:
         permission = CheckUrlPermitted(url);
         break;
      case ACCESS_FILE_MISSING:
         permission = SERVER_ACCESS_BLOCKED;
         break;
      case ACCESS_FILE_LOADING_ASYNC:
         permission = SERVER_ACCESS_PENDING;
         break;
      default:
         assert(0);
   }

   return permission;
}

static MHEG5ServerAccess_t CheckUrlPermitted(U8BIT *url)
{
   U8BIT *fileBuffer;
   U8BIT *line;
   U8BIT *nextLine;
   int lineLength;
   int remainingChars;
   MHEG5ServerAccess_t permission;
   MHEG5ServerAccess_t entryAuthRequired;
   int differ;

   permission = SERVER_ACCESS_BLOCKED;
   if (accessFileState == ACCESS_FILE_LOADED)
   {
      fileBuffer = accessFile.data;

      /*get first line*/
      line = fileBuffer;
      remainingChars = accessFile.len;
      lineLength = GetLineLength(line, &nextLine, remainingChars);
      while (lineLength >= 0)
      {
         if (*line == '!')
         {
            /*remove the '!'*/
            line++;
            lineLength--;

            entryAuthRequired = SERVER_ACCESS_PERMITTED_NO_AUTH;
         }
         else
         {
            entryAuthRequired = SERVER_ACCESS_PERMITTED_AUTH;
         }

         if (lineLength == 0)
         {
            /*ignore blank lines*/
            ;
         }
         else if (*line == '#')
         {
            /*ignore lines beginning with #*/
            ;
         }
         else if (strlen((char *)url) <= (size_t)lineLength)
         {
            /*url must be longer than line*/
            ;
         }
         else
         {
            /*check the url against the access file entry*/
            differ = MHEG5strncmp( line, url, lineLength );

            if (!differ)
            {
               /*check that either the server-list line ends with '/'
                  or the next character in the url is one*/
               if (line[lineLength - 1] == '/' || url[lineLength] == '/')
               {
                  permission = entryAuthRequired;
                  break;
               }
            }
         }
         /*get next line*/
         line = nextLine;
         remainingChars -= (lineLength + 1);
         lineLength = GetLineLength(line, &nextLine, remainingChars);
      }
   }
   return permission;
}

static void AuthFileRetrieved(void *userData, S_CONTENT *content )
{
   BOOLEAN call;

   USE_UNWANTED_PARAM(userData);

   /*free any file already loaded*/
   if (accessFile.data)
   {
      MHEG5freeMem(accessFile.data);
   }

   accessFile.data = MHEG5getMem(content->size + 1);
   if (accessFile.data != NULL)
   {
      accessFile.len = content->size;

      memcpy(accessFile.data, content->data, content->size);
      accessFile.data[accessFile.len] = '\0';

      call = FALSE;
      if (accessFileState == ACCESS_FILE_LOADING_ASYNC)
      {
         call = TRUE;
      }

      accessFileState = ACCESS_FILE_LOADED;

      /*call the provided callback if one was provided*/
      if (call)
      {
         NotifyServerAccessReady();
      }
   }
}

static void AuthFileRetrievalFailed( void *userData )
{
   BOOLEAN call;

   USE_UNWANTED_PARAM(userData);

   call = FALSE;
   if (accessFileState == ACCESS_FILE_LOADING_ASYNC)
   {
      call = TRUE;
   }

   accessFileState = ACCESS_FILE_MISSING;

   /*free any loaded file*/
   accessFile.len = 0;
   if (accessFile.data)
   {
      MHEG5freeMem(accessFile.data);
      accessFile.data = NULL;
   }

   /*call the provided callback if one was provided*/
   if (call)
   {
      NotifyServerAccessReady();
   }
}

void MHEG5ResetServerAccess(void)
{
   if (accessFileState != ACCESS_FILE_LOADING_ASYNC)
   {
      accessFile.len = 0;
      if (accessFile.data)
      {
         MHEG5freeMem(accessFile.data);
         accessFile.data = NULL;
      }
   }

   accessFileState = ACCESS_FILE_NOTLOADED;
}

void MHEG5AddServerAccessCallback(void (*LoadNotifyCallback)(void))
{
   if (callbackCount < MAX_CALLBACKS)
   {
      fileLoadedCallback[callbackCount] = LoadNotifyCallback;
      callbackCount++;
   }
}

static int GetLineLength(U8BIT *string, U8BIT **remaining, int max)
{
   int i = -1;

   *remaining = NULL;

   if (string != NULL && max > 0)
   {
      /*check each character*/
      for (i = 0; i < max; i++)
      {
         /*stop on newline or end of text*/
         if (string[i] == '\n')
         {
            /*set remainder to start of next line*/
            *remaining = string + i + 1;
            break;
         }
         else if (string[i] == '\0')
         {
            /*no remaining text*/
            break;
         }
      }
   }
   /*return the number of characters*/
   return i;
}

static void NotifyServerAccessReady(void)
{
   U16BIT i;

   for (i = 0; i < callbackCount; i++)
   {
      if (fileLoadedCallback[i] != NULL)
      {
         fileLoadedCallback[i]();
      }
   }
}