mh5tps.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2012 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 "stdio.h"
#include <assert.h>
#include <string.h>

#include "mh5base.h"
#include "mh5tps.h"
#include "mh5misc.h"

#include "mherrors.h"
#include "techtype.h"
#ifndef INCLUDE_TPS
#include "mheg5_nvm.h"
#else
#include "mh5memory.h"
#include "mh5date.h"
#include "dvb_service.h"
#include "stb_nvm.h"
#include "glue_queue.h"
#endif
/*---constant definitions for this file--------------------------------------*/

#define FILESIZE_MAX 100
#define MAX_PATH_LEN 64

#ifdef INCLUDE_TPS
#define MAX_FILES 800
#define TPS_DIRECTORY "tps/"
#define MAX_WRITES_IN_PERIOD 64
#define WRITE_PERIOD_DAYS 28
#define HEADER_SIZE 9

//#define DEBUG_TPS
#ifdef DEBUG_TPS
#define DBG_PRINT(x) DBG_PRINTF x
#define DBG_TPS(x) do { DBG_PRINTF("%s: ", __func__); DBG_PRINTF x; } while (0)
#else
#define DBG_TPS(x)
#define DBG_PRINT(x)
#endif

#endif

/*---local typedef structs for this file-------------------------------------*/
typedef S_DvbLocator *pS_DvbLocator;

#ifdef INCLUDE_TPS
typedef struct s_TruePersistentFile
{
   U32BIT filename_len;
   U8BIT *filename;
   char *file_path;

   S_DvbLocator service_info;
   U8BIT num_writes;
   U32BIT write_date;
   void *file_data;
   MHEG5Int file_len;
   struct s_TruePersistentFile *next;
   struct s_TruePersistentFile *previous;
} t_TruePersistentFile;
#endif

/*---local (static) variable declarations for this file----------------------*/
#ifdef INCLUDE_TPS
static t_TruePersistentFile *file_list_head = NULL;
static t_TruePersistentFile *file_list_tail = NULL;
static U16BIT file_count = 0;
static BOOLEAN init = FALSE;
static pS_DvbLocator current_file_list = NULL;
static MHEG5Bool TPS_enabled = MHEG5TRUE;
static S_DvbLocator current_service;
#endif

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

#ifdef INCLUDE_TPS

static BOOLEAN TPS_StorageRead(S_STRING filename, void **data, U32BIT *data_len);
static BOOLEAN TPS_StorageWrite(S_STRING filename, void *data, U32BIT data_len);
static E_MhegErr TPS_StorageOpen();
static void TPS_StorageClose(void);
static BOOLEAN TPS_StorageGetEnabled();

static void FreeFile(t_TruePersistentFile *file);
static void DeleteFile(t_TruePersistentFile *file);
static void ClearCache();
static BOOLEAN AddFileToList(t_TruePersistentFile *file);
static BOOLEAN LoadFile(char *filename);
static t_TruePersistentFile* FindFileByName(S_STRING filename);
static BOOLEAN DeleteFileByService(pS_DvbLocator service_info);
static BOOLEAN DeleteOldFile();
static BOOLEAN ServicesEqual(pS_DvbLocator service_a,
   pS_DvbLocator service_b);
static MHEG5Bool WriteFileToStore( t_TruePersistentFile *out_file);
static t_TruePersistentFile* NewFile(S_STRING filename, void *data, MHEG5Int len,
   pS_DvbLocator service, U32BIT today);

static t_TruePersistentFile* OverwriteFileEntry(void *data, MHEG5Int len,
   pS_DvbLocator service, U32BIT today,
   t_TruePersistentFile *replaced_file);

static t_TruePersistentFile* UpdateFileEntry(t_TruePersistentFile *file, void *data, MHEG5Int len,
   pS_DvbLocator service);

static U32BIT Read32Bits(U8BIT *bytes);
static void Store32Bits(U8BIT *bytes, U32BIT value);
static U16BIT Read16Bits(U8BIT *bytes);
static void Store16Bits(U8BIT *bytes, U16BIT value);

#endif

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

void MHEG5TpsSetCurrentService(S_DvbLocator *pDvbLoc)
{
   current_service = *pDvbLoc;
}

MHEG5Bool MHEG5TpsRead(MHEG5String fn, void **data, MHEG5Int *len)
{
   S_STRING filename;
   BOOLEAN rc = FALSE;
   filename.zptr = fn.data;
   filename.zlen = fn.len;

   DBG_TPS(("reading:%.*s\n", (int)fn.len, fn.data));
   if (filename.zlen && filename.zlen < 9)
   {
      rc = TPS_StorageRead(filename, data, (U32BIT *)len);
   }
   if (rc == TRUE)
   {
#ifdef DEBUG_TPS
      int i;
      DBG_TPS(("read:\n"));
      for (i = 0; i < *len; i++)
      {
         DBG_PRINT(("0x%x ", ((U8BIT *)*data)[i]));
      }
      DBG_PRINT(("\n"));
#endif
      return MHEG5TRUE;
   }
   else
   {
      return MHEG5FALSE;
   }
}

MHEG5Bool MHEG5TpsWrite(MHEG5String fn, void *data, MHEG5Int len)
{
   MHEG5Bool success = MHEG5FALSE;
   BOOLEAN rc = FALSE;

   if (len <= FILESIZE_MAX)
   {
      S_STRING filename;
#ifdef DEBUG_TPS
      int i;
      DBG_TPS(("writing:%.*s\n", (int)fn.len, fn.data));
      DBG_TPS(("writing:\n"));
      for (i = 0; i < len; i++)
      {
         DBG_PRINT(("0x%x ", ((U8BIT *)data)[i]));
      }
      DBG_PRINT(("\n"));
#endif
      filename.zptr = fn.data;
      filename.zlen = fn.len;
      if (filename.zlen && filename.zlen < 9)
      {
         rc = TPS_StorageWrite(filename, data, len);
      }
      if (rc)
      {
         success = MHEG5TRUE;
      }
   }

   return success;
}

MHEG5Bool MHEG5GetTpsStatus(void)
{
   if (TPS_StorageGetEnabled())
   {
      return MHEG5TRUE;
   }
   else
   {
      return MHEG5FALSE;
   }
}

void MHEG5TpsClose(void)
{
   TPS_StorageClose();
}

#ifdef INCLUDE_TPS

static void MHEG5NotifyTpsFilesChanged(void *dummy)
{
   USE_UNWANTED_PARAM(dummy);
   TPS_StorageClose();
}

E_MhegErr MHEG5_NotifyNvmFilesChanged(void)
{
   MHEG5eventMessage_t event_msg;
   event_msg.proc_msg_func = MHEG5NotifyTpsFilesChanged;
   event_msg.data_type = DT_VALUE;
   return VQ_PutMsg(&event_msg, PRTY_NORMAL);
}

static BOOLEAN TPS_StorageRead(S_STRING filename, void **data, U32BIT *data_len)
{
   t_TruePersistentFile *file_entry;
   if (!TPS_enabled)
   {
      return FALSE;
   }
   /*open the store and read files into cache*/
   TPS_StorageOpen();

   file_entry = FindFileByName(filename);
   if (file_entry)
   {
      *data = file_entry->file_data;
      *data_len = file_entry->file_len;
      return TRUE;
   }
   else
   {
      return FALSE;
   }
}

static BOOLEAN TPS_StorageWrite(S_STRING filename, void *data, U32BIT data_len)
{
   t_TruePersistentFile *replaced_file;
   t_TruePersistentFile *updated_file;
   BOOLEAN write = TRUE;
   BOOLEAN check_service = TRUE;
   BOOLEAN success = FALSE;
   U32BIT day, sec;

   if (!TPS_enabled)
   {
      return FALSE;
   }

   TPS_StorageOpen();
   MHEG5getDate((S32BIT *)&day, (S32BIT *)&sec );

   DBG_TPS(("current service_id 0x%x\n", current_service.service_id));

   replaced_file = FindFileByName(filename);
   /*if the file exists check if we can write to it*/
   if (replaced_file)
   {
      DBG_TPS(("File exists\n"));
      if (replaced_file->write_date >= day - WRITE_PERIOD_DAYS)
      {
         replaced_file->num_writes = 0;
      }

      if (replaced_file->num_writes >= MAX_WRITES_IN_PERIOD)
      {
         write = FALSE;
         DBG_TPS(("Warning: File has been written too many times\n"));
      }
      /*if the file being overwritten is assigned to a different service
         then there may be files assigned to the current service that will
         need to be deleted*/
      else if (ServicesEqual(&current_service, &replaced_file->service_info))
      {
         check_service = FALSE;
      }
   }

   if (write && check_service)
   {
      /*delete any file already on the current service*/
      DeleteFileByService(&current_service);
   }
   /*if the store is full, delete an old file*/
   if (write && file_count == MAX_FILES)
   {
      DBG_TPS(("Store full, deleting old files\n"));
      DeleteOldFile();
      if (file_count == MAX_FILES)
      {
         write = FALSE;
      }
   }

   if (write)
   {
      if (replaced_file)
      {
         updated_file = OverwriteFileEntry(data, data_len, &current_service, day, replaced_file);
      }
      else
      {
         updated_file = NewFile(filename, data, data_len, &current_service, day);
      }
      if (WriteFileToStore( updated_file ))
      {
         file_count++;
         success = TRUE;
      }
   }

   return success;
}

static void FreeFile(t_TruePersistentFile *file)
{
   assert(file);

   if (file->file_path)
   {
      MHEG5freeMem(file->file_path);
   }
   if (file->file_data)
   {
      MHEG5freeMem(file->file_data);
   }
   MHEG5freeMem(file);
   file_count--;
}

static void DeleteFile(t_TruePersistentFile *file)
{
   assert(file);

   if (file->next)
   {
      file->next->previous = file->previous;
   }
   else
   {
      file_list_tail = file->previous;
   }


   if (file->previous)
   {
      file->previous->next = file->next;
   }
   else
   {
      file_list_head = file->next;
   }

   STB_NVMDeleteFile( (U8BIT *) file->file_path );
   FreeFile(file);
}

static void ClearCache(void)
{
   t_TruePersistentFile *current;
   t_TruePersistentFile *next;

   current = file_list_head;

   while (current)
   {
      next = current->next;
      FreeFile(current);
      current = next;
   }
   file_list_head = NULL;
   file_list_tail = NULL;
}

/*******************************************************************************
 *@begin
 * NAME: AddFileToList
 *       Adds a file read from NVM to the file list
 *
 * Returns :
 *
 * Parameter     Flow    Description
 * ------------------------------------------------------------------------------
 *
 *
 * Externals     Flow    Usage
 * ------------------------------------------------------------------------------
 *
 * Additional information:
 *
 *@end
 *******************************************************************************/
static BOOLEAN AddFileToList(t_TruePersistentFile *file)
{
   t_TruePersistentFile *current;
   assert(file);
   if (file_list_tail == NULL)
   {
      file_list_tail = file;
      file_list_head = file;
   }
   else
   {
      current = file_list_tail;
      while (current)
      {
         if (file->write_date >= current->write_date)
         {
            file->previous = current;
            file->next = current->next;
            if (current->next)
            {
               current->next->previous = file;
               current->next = file;
            }
            else
            {
               file_list_tail = file;
               current->next = file;
            }
            return TRUE;
         }
         else
         {
            current = current->previous;
         }
      }
      if (current == NULL)
      {
         file_list_head->previous = file;
         file->next = file_list_head;
         file_list_head = file;
      }
   }
   return TRUE;
}

static BOOLEAN LoadFile(char *filename)
{
   char *full_path;
   t_TruePersistentFile *new_file;
   void *filep = NULL;
   U8BIT *data;
   U32BIT file_size;
   U32BIT offset = 0;
   pS_DvbLocator service_info;
   BOOLEAN success = FALSE;

   /*refomat the filename*/
   full_path = MHEG5getMem(strlen(TPS_DIRECTORY) + strlen(filename) + 1);

   memcpy(full_path, (char *)TPS_DIRECTORY, strlen(TPS_DIRECTORY) + 1);
   strncat(full_path, filename, strlen(filename) + 1);

   DBG_TPS(("Loading File %s\n", filename));

   new_file = MHEG5getMem(sizeof(t_TruePersistentFile));

   new_file->previous = NULL;
   new_file->next = NULL;
   new_file->num_writes = 0;
   new_file->write_date = 0;
   new_file->file_path = full_path;
   new_file->filename = (U8BIT *)full_path + strlen(TPS_DIRECTORY);
   new_file->filename_len = strlen(filename);

   STB_NVMFileSize((U8BIT *) full_path, &file_size);

   /*if the file is less than the header size, don't bother loading it*/
   if (file_size >= HEADER_SIZE)
   {
      filep = STB_NVMOpenFile((U8BIT *) full_path, FILE_MODE_READ);
   }

   if (filep)
   {
      data = MHEG5getMem(file_size);
      if (data)
      {
         if (STB_NVMReadFile(filep, data, file_size) == file_size)
         {
            service_info = &new_file->service_info;

            service_info->original_network_id = Read16Bits(data + offset);
            offset += 2;
            service_info->service_id = Read16Bits(data + offset);
            offset += 2;

            service_info->transport_stream_id = 0;

            new_file->num_writes = *(data + offset);
            offset += 1;
            new_file->write_date = Read32Bits(data + offset);
            offset += 4;

            new_file->file_len = file_size - offset;
            new_file->file_data = MHEG5getMem(new_file->file_len);
            if (new_file->file_data)
            {
               memcpy(new_file->file_data, data + offset, new_file->file_len);
               success = AddFileToList(new_file);
            }
         }
         MHEG5freeMem(data);
      }
      STB_NVMCloseFile(filep);
   }
   else
   {
      MHEG5freeMem(new_file);
      MHEG5freeMem(full_path);
   }

   return success;
}

static U32BIT Read32Bits(U8BIT *bytes)
{
   U32BIT buffer;

   buffer = bytes[3];
   buffer <<= 8;
   buffer |= bytes[2];
   buffer <<= 8;
   buffer |= bytes[1];
   buffer <<= 8;
   buffer |= bytes[0];

   return buffer;
}

static void Store32Bits(U8BIT *bytes, U32BIT value)
{
   bytes[0] = value & 0xFF;
   bytes[1] = (value >> 8) & 0xFF;
   bytes[2] = (value >> 16) & 0xFF;
   bytes[3] = (value >> 24) & 0xFF;
}

static U16BIT Read16Bits(U8BIT *bytes)
{
   U16BIT buffer;

   buffer = bytes[1];
   buffer <<= 8;
   buffer |= bytes[0];

   return buffer;
}

static void Store16Bits(U8BIT *bytes, U16BIT value)
{
   bytes[0] = value & 0xFF;
   bytes[1] = (value >> 8) & 0xFF;
}

static E_MhegErr TPS_StorageOpen(void)
{
   void *directory;
   char filename_buffer[MAX_PATH_LEN];
   E_MhegErr retval = MHERR_OK;
   E_STB_DIR_ENTRY_TYPE entry_type;

   if (!init && TPS_enabled)
   {
      init = TRUE;
      directory = STB_NVMOpenDirectory((U8BIT *) TPS_DIRECTORY);
      if (!directory)
      {
         return FALSE;
      }
      while (STB_NVMReadDirectory(directory, (U8BIT *) filename_buffer, MAX_PATH_LEN, &entry_type))
      {
         if (entry_type == DIR_ENTRY_FILE)
         {
            if (!LoadFile(filename_buffer))
            {
               retval = MHERR_OTHER;
               break;
            }
            file_count++;
         }
      }
      STB_NVMCloseDirectory(directory);
   }
   return retval;
}

static void TPS_StorageClose(void)
{
   if (init)
   {
      ClearCache();
      file_count = 0;
   }
   init = FALSE;
}

static t_TruePersistentFile* FindFileByName(S_STRING filename)
{
   t_TruePersistentFile *file_entry;
   file_entry = file_list_tail;

   while (file_entry)
   {
      if (filename.zlen == file_entry->filename_len)
      {
         if (!memcmp(filename.zptr, file_entry->filename, filename.zlen))
         {
            break;
         }
      }
      file_entry = file_entry->previous;
   }
   return file_entry;
}

static BOOLEAN DeleteOldFile(void)
{
   t_TruePersistentFile *current;
   S32BIT index;

   current = file_list_head;

   while (current)
   {
      DVB_MhegDvbLocatorToIndex(&current->service_info, &index);
      if (index == -1)
      {
         DeleteFile(current);
         return TRUE;
      }
      current = current->next;
   }
   return FALSE;
}

static BOOLEAN ServicesEqual(pS_DvbLocator service_a, pS_DvbLocator service_b)
{
   BOOLEAN same = TRUE;

   if (service_a->service_id != service_b->service_id)
   {
      same = FALSE;
   }
   else if (service_a->original_network_id != service_b->original_network_id)
   {
      same = FALSE;
   }

   return same;
}

static BOOLEAN DeleteFileByService(pS_DvbLocator service_info)
{
   t_TruePersistentFile *file_entry;

   file_entry = file_list_head;
   DBG_TPS(("deleting files on service 0x%x\n", service_info->service_id));
   while (file_entry)
   {
      if (ServicesEqual(service_info, &file_entry->service_info))
      {
         DeleteFile(file_entry);
         return TRUE;
      }

      file_entry = file_entry->next;
   }
   return FALSE;
}

static MHEG5Bool WriteFileToStore( t_TruePersistentFile *out_file)
{
   void *filep = NULL;
   U8BIT *file_data;
   U32BIT len;
   int offset = 0;

   len = HEADER_SIZE;

   len += out_file->file_len;

   file_data = MHEG5getMem(len);
   if (file_data)
   {
      Store16Bits(file_data + offset, out_file->service_info.original_network_id);
      offset += 2;
      Store16Bits(file_data + offset, out_file->service_info.service_id);
      offset += 2;
      memcpy(file_data + offset, &out_file->num_writes, 1);
      offset++;
      Store32Bits(file_data + offset, out_file->write_date);
      offset += 4;

      memcpy(file_data + offset, out_file->file_data, out_file->file_len);

      filep = STB_NVMOpenFile((U8BIT *) out_file->file_path, FILE_MODE_OVERWRITE);
   }
   if (filep)
   {
      STB_NVMWriteFile(filep, file_data, len);
      STB_NVMCloseFile(filep);
      return MHEG5TRUE;
   }
   else
   {
      return MHEG5FALSE;
   }
}

static t_TruePersistentFile* NewFile(S_STRING filename, void *data, MHEG5Int len,
   pS_DvbLocator service, U32BIT today)

{
   t_TruePersistentFile *new_file;
   MHEG5Bool success = MHEG5FALSE;
   char *full_path;

   new_file = MHEG5getMem(sizeof(t_TruePersistentFile));
   if (new_file)
   {
      full_path = MHEG5getMem(strlen(TPS_DIRECTORY) + filename.zlen + 1);
      if (full_path)
      {
         success = MHEG5TRUE;
      }
   }

   if (success)
   {
      *full_path = 0;
      strncat(full_path, TPS_DIRECTORY, strlen(TPS_DIRECTORY));
      strncat(full_path, (char *)filename.zptr, filename.zlen);

      new_file->file_path = full_path;
      new_file->filename = (U8BIT *)full_path + strlen(TPS_DIRECTORY);
      new_file->filename_len = filename.zlen;
      new_file->num_writes = 1;
      new_file->write_date = today;

      UpdateFileEntry(new_file, data, len, service);
   }
   return new_file;
}

static t_TruePersistentFile* OverwriteFileEntry(void *data, MHEG5Int len,
   pS_DvbLocator service, U32BIT today,
   t_TruePersistentFile *replaced_file)
{
   MHEG5Bool success = MHEG5TRUE;

   assert(replaced_file);


   if (today <= replaced_file->write_date + WRITE_PERIOD_DAYS)
   {
      if (replaced_file->num_writes == MAX_WRITES_IN_PERIOD)
      {
         success = MHEG5FALSE;
      }
      else
      {
         replaced_file->num_writes++;
      }
   }
   else
   {
      replaced_file->write_date = today;
      replaced_file->num_writes = 1;
   }

   if (success)
   {
      /*if it is in the middle of the list*/
      if (replaced_file->previous && replaced_file->next)
      {
         /*join the previous and next items together*/
         replaced_file->previous->next = replaced_file->next;
         replaced_file->next->previous = replaced_file->previous;
      }
      else if (replaced_file->next) /*if it is the first item*/
      {
         /*push the next item to the head*/
         replaced_file->next->previous = NULL;
      }
      else if (replaced_file->previous)  /*it is at the end*/
      {
         replaced_file->previous->next = NULL;
      }

      if (file_list_head == replaced_file)
      {
         file_list_head = replaced_file->next;
      }
      if (file_list_tail == replaced_file)
      {
         file_list_tail = replaced_file->previous;
      }

      /*free the old file data*/
      MHEG5freeMem(replaced_file->file_data);
      replaced_file->file_data = NULL;
      replaced_file->file_len = 0;
      replaced_file->next = NULL;
      replaced_file->previous = NULL;
      return UpdateFileEntry(replaced_file, data, len, service);
   }
   else
   {
      return NULL;
   }
}

static t_TruePersistentFile* UpdateFileEntry(t_TruePersistentFile *file, void *data, MHEG5Int len,
   pS_DvbLocator service)
{
   if (file_list_tail)
   {
      file_list_tail->next = file;
   }
   else
   {
      file_list_head = file;
   }


   file->previous = file_list_tail;
   file->next = NULL;
   file_list_tail = file;

   file->service_info.original_network_id = service->original_network_id;
   file->service_info.transport_stream_id = service->transport_stream_id;
   file->service_info.service_id = service->service_id;
   file->file_data = MHEG5getMem( len );
   if (file->file_data)
   {
      memcpy(file->file_data, data, len);
      file->file_len = len;

      return file;
   }
   else
   {
      return NULL;
   }
}

E_MhegErr MHEG5_GetTPSStatus(BOOLEAN *enabled)
{
   *enabled = (TPS_enabled) ? TRUE : FALSE;
   return MHERR_OK;
}

E_MhegErr MHEG5_EnableTPS(BOOLEAN enabled)
{
   if (TPS_enabled && !enabled)
   {
      TPS_StorageClose();
   }

   TPS_enabled = enabled;
   return MHERR_OK;
}

E_MhegErr MHEG5_GetTPSServices(U16BIT *pfile_count, pS_DvbLocator *first_file)
{
   t_TruePersistentFile *cursor;

   if (current_file_list)
   {
      return MHERR_COMP_ALREADY_OPEN;
   }
   TPS_StorageOpen();
   if (file_count)
   {
      current_file_list = MHEG5getMem(sizeof(S_DvbLocator) * file_count);
      if (current_file_list)
      {
         for (cursor = file_list_head, file_count = 0; cursor; file_count++, cursor = cursor->next)
         {
            current_file_list[file_count].original_network_id = cursor->service_info.original_network_id;
            current_file_list[file_count].transport_stream_id = cursor->service_info.transport_stream_id;
            current_file_list[file_count].service_id = cursor->service_info.service_id;
         }
         *pfile_count = file_count;
         *first_file = current_file_list;
      }
      else
      {
         *pfile_count = 0;
         *first_file = NULL;
         return MHERR_OTHER;
      }
   }
   else
   {
      *pfile_count = 0;
      *first_file = NULL;
   }
   return MHERR_OK;
}

E_MhegErr MHEG5_AckTPSServiceList(void)
{
   if (current_file_list)
   {
      MHEG5freeMem(current_file_list);
      current_file_list = NULL;
   }
   return MHERR_OK;
}

E_MhegErr MHEG5_RemoveTPSFile(pS_DvbLocator service)
{
   if (DeleteFileByService(service))
   {
      return MHERR_OK;
   }
   else
   {
      return MHERR_OBJECT_NOT_FOUND;
   }
}

BOOLEAN TPS_StorageGetEnabled(void)
{
   return TPS_enabled ? TRUE : FALSE;
}

#endif