mh5misc.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 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 <string.h>
#include "mh5base.h"
#include "mh5profile.h"
#include "mh5misc.h"
#include "mh5debug.h"
#include "mh5parse.h"
#include "mh5stream.h"
#include "mh5memory.h"
#include "mg_video.h"
#include "dvb_video.h"
#include "glue_main.h"
#include "dvb_service.h"
#ifndef CI_PLUS_ONLY
 #include "glue_dsmcc.h"
#endif
#include "mh5control.h"

#ifdef INCLUDE_IC
#include "mh5queue.h"
#include "stb_net.h"
#ifdef INCLUDE_FREESAT
#include <openssl/sha.h>
#include <openssl/rsa.h>
#include <openssl/evp.h>
#include <openssl/x509.h>
#endif  /* INCLUDE_FREESAT */
#endif  /* INCLUDE_IC */
#ifdef INCLUDE_CI_PLUS
#include "mheg5_ci.h"
#include "dvb_ci.h"
#endif

/*---constant definitions for this file--------------------------------------*/
#define MAX_NDX_MAP              8
#define MAX_WAI_LEN              256

#define MAX_PROMPT               50

#define RSA_SALT_SIZE            16
#define RSA_SIGNATURE_SIZE       (1024 / 8)
#define MAX_VERSION_LEN          12
#define MAX_RSA_KEY_SIZE         1024


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

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

#ifdef INCLUDE_IC
static MHEG5Int currentICStatus = -1;
#ifdef INCLUDE_ICS
static U8BIT guidanceMessage[MAX_PROMPT * 4 + 1];
#endif
#endif


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

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

#ifdef INCLUDE_FREESAT
static U16BIT EncodeBase64(U8BIT *data, U16BIT len, U8BIT *result);
#endif

extern void MHEG5setInputEventRegister(MHEG5Int inputEventRegister);

MHEG5Bool MHEG5parseUrl(U8BIT *buffer, U32BIT length, S_DVB_LOCATOR *multiplexRef)
{
   MHEG5Bool rtn_val = MHEG5TRUE;

   assert( buffer != NULL && length != 0);

   /* URL is dvb://<original network id>.[<transport stream id>].<service id> */
   if (strncmp((char *)buffer, (char *)"dvb://", 6) == 0)
   {
      rtn_val = MHEG5parseDvbUrl( buffer + 6, length - 6, multiplexRef );
   }
   else if (strncmp((char *)buffer, (char *)"rec://svc/", 10) == 0)
   {
      buffer += 10;

      /* URL is rec://svc/def */
      if (strncmp((char *)buffer, (char *)"def", 3) == 0)
      {
         MHEG5GetDefaultService(multiplexRef);
      }
      /* URL is rec://svc/cur */
      else if (strncmp((char *)buffer, (char *)"cur", 3) == 0)
      {
         if (!MHEG5streamGetCurrentService(multiplexRef))
         {
            TRACE(TSTRM, ("svc/cur is default service %d", multiplexRef->service_id))
         }
      }
      /* URL is rec://svc/lcn/<LCN> */
      else if (strncmp((char *)buffer, (char *)"lcn/", 4) == 0 &&
               length > 14)
      {
         S_DvbLocator dvbLocator;
         int lcn;

         lcn = MHEG5parseLcn( buffer + 4, buffer + length - 10 );

         if ((lcn != -1) &&
             (DVB_MhegLcnToDvbLocator(lcn, &dvbLocator) == MHERR_OK))
         {
            /* URL was valid. Copy into the multiplex reference */
            multiplexRef->original_network_id = dvbLocator.original_network_id;
            multiplexRef->transport_stream_id = dvbLocator.transport_stream_id;
            multiplexRef->service_id = dvbLocator.service_id;
         }
         else
         {
            rtn_val = MHEG5FALSE;
         }
      }
#ifdef INCLUDE_FREESAT
      else if (strncmp((char *)buffer, (char *)"fsi/", 4) == 0 &&
               length > 14)
      {
         S_DvbLocator dvbLocator;
         int fsi;

         /*reusing the LCN parser for FSI (both just a decimal number)*/
         fsi = MHEG5parseLcn( buffer + 4, buffer + length - 10 );

         if ((fsi != -1) &&
             (DVB_MhegGetFSILocator(fsi, &dvbLocator) == MHERR_OK))
         {
            /* URL was valid. Copy into the multiplex reference */
            multiplexRef->original_network_id = dvbLocator.original_network_id;
            multiplexRef->transport_stream_id = dvbLocator.transport_stream_id;
            multiplexRef->service_id = dvbLocator.service_id;
         }
         else
         {
            rtn_val = MHEG5FALSE;
         }
      }
#endif
      else
      {
         rtn_val = MHEG5FALSE;
      }
   }
   else
   {
      rtn_val = MHEG5FALSE;
   }
   TRACE(TSTRM, ("name=%s -> srv_id=0x%x (%d)", buffer, multiplexRef->service_id, multiplexRef->service_id))

   return rtn_val;
}

MHEG5Int MHEG5GetServiceIndex(MHEG5String *serviceReference)
{
   S_DvbLocator dvbLocator;
   S_DVB_LOCATOR multiplexRef;
   S32BIT serviceIndex = -1;

   /* Convert from URL string to multiplex reference */
   if (serviceReference->data && serviceReference->len &&
       MHEG5parseUrl(serviceReference->data, serviceReference->len, &multiplexRef))
   {
      /* Copy multiplex reference to dvb locator */
      dvbLocator.original_network_id = multiplexRef.original_network_id;
      dvbLocator.transport_stream_id = multiplexRef.transport_stream_id;
      dvbLocator.service_id = multiplexRef.service_id;
      /* Get the service index from the controlling environment */
      TRACE(TTUNE, ("net_id=%d trns_id=%d serv_id=%d",
                     dvbLocator.original_network_id, dvbLocator.transport_stream_id, dvbLocator.service_id))
      if (DVB_MhegDvbLocatorToIndex(&dvbLocator, &serviceIndex) != MHERR_OK)
      {
         serviceIndex = -1;
      }
   }

   TRACE(TTUNE, (" %.*s --> index=%x", serviceReference->len, serviceReference->data, serviceIndex));

   return serviceIndex;
}

#ifndef CI_PLUS_ONLY

MHEG5String MHEG5GetBootInfo(MHEG5Bool *InfoResultVal)
{
   MHEG5String result;
   S_STRING nbInfo;

   if (!MH5GlueSiqNetBootInfo(&nbInfo))
   {
      /* Boot info was not found */
      *InfoResultVal = MHEG5FALSE;
      result.len = 0;
      result.data = NULL;
   }
   else
   {
      MHEG5String tmp;

      /* Boot info was found */
      *InfoResultVal = MHEG5TRUE;

      tmp.len = nbInfo.zlen;
      tmp.data = nbInfo.zptr;

      result = MHEG5stringCopy(tmp);
   }
   return result;
}

#endif


MHEG5Int MHEG5GetDisplayAspectRatio(void)
{
   if (DVB_MhegGetDisplayAspectRatio() == ASPECT_RATIO_4_3)
   {
      return 1;
   }
   else
   {
      return 2;
   }
}

MHEG5Bool MHEG5GetBasicSI(MHEG5Int serviceIndex, MHEG5Int *networkID,
   MHEG5Int *origNetworkID, MHEG5Int *transportStreamID,
   MHEG5Int *serviceID)
{
   S_DvbLocation location;
   MHEG5Bool rc = MHEG5FALSE;

   if (DVB_MhegIndexToDvbLocation((U32BIT) serviceIndex, &location) == MHERR_OK)
   {
      *networkID = location.network_id;
      *origNetworkID = location.original_network_id;
      *transportStreamID = location.transport_stream_id;
      *serviceID = location.service_id;
      rc = MHEG5TRUE;
   }
   else
   {
      *networkID = 0;
      *origNetworkID = 0;
      *transportStreamID = 0;
      *serviceID = 0;
   }

   return rc;
}

#ifdef INCLUDE_CI_PLUS

MHEG5Bool MHEG5RequestMPEGDecoder(MHEG5Bool request)
{
   BOOLEAN result;

   if (request)
   {
      DVB_MhegRequestMPEGDecoder(MHEG5_DECODER_REQUEST, &result);
   }
   else
   {
      DVB_MhegRequestMPEGDecoder(MHEG5_DECODER_RELEASE, &result);
   }

   if (result)
   {
      return MHEG5TRUE;
   }

   return MHEG5FALSE;
}

void MHEG5SuppressMHEGGraphics(MHEG5Bool request)
{
   /* Currently we just pass the request on to the external app
      We may want to be more clever in the future*/
   DVB_MhegSuppressMHEGGraphics(request);
}

#endif  /* INCLUDE_CI_PLUS */


void MHEG5restoreReceiverDefaults(void)
{
   DVB_MhegSetAspectRatio(ASPECT_UNDEFINED);

   /* Widescreen Alignment - default centre cutout (4:3) */
   DVB_MhegSetVideoAlignment(ASPECT_MODE_4_3);

   /* Subtitle Mode */
   MG_SetSubtitleMode(MHEG5TRUE);

#ifndef CI_PLUS_ONLY
   MHEG5TuneIndexInfo(FALSE);
#endif /* CI_PLUS_ONLY*/

   /* Reset the input event register to 0, indicating that MHEG-5 will
    * not process up, down, left, right, select and digits.
    */
   MHEG5setInputEventRegister(-1);
}

#ifdef INCLUDE_IC

void MHEG5getICStatus(MHEG5Int *icStatus)
{
   if (currentICStatus == -1)
   {
      switch (STB_NWGetLinkStatus())
      {
         case NW_LINK_ACTIVE:
            currentICStatus = 0;
            break;
         case NW_LINK_INACTIVE:
            currentICStatus = 1;
            break;
         case NW_LINK_DISABLED:
         default:
            currentICStatus = 2;
            break;
      }
   }

   *icStatus = currentICStatus;
}

void MHEG5clearICStatus(void)
{
   /* Set status to "unknown" */
   currentICStatus = -1;
}

void MHEG5changedICStatus(void)
{
   /* Set status to "unknown" */
   currentICStatus = -1;
   MHEG5sendAppEngineEvent( EE_IC_STATUS_CHANGED );
}

void MHEG5isConnectionEnabled(MHEG5Bool *enabled)
{
   BOOLEAN isAllowed;
#ifdef INCLUDE_FREESAT
   S32BIT service_index;
   service_index = MHEG5GetCurrentServiceIndex();
   DVB_MhegIsConnectionAllowed(service_index, &isAllowed);
#else
   isAllowed = TRUE;
#endif
   if (isAllowed && (STB_NWGetLinkStatus() == NW_LINK_ACTIVE))
   {
      *enabled = MHEG5TRUE;
   }
   else
   {
      *enabled = MHEG5FALSE;
   }
}

#ifdef INCLUDE_ICS

MHEG5Bool MHEG5IsPinRequired(void)
{
   MHEG5Bool required = MHEG5TRUE;
#ifdef INCLUDE_FREESAT
   E_ICSPinReq status;
   DVB_MhegGetPINRequirement(&status);
   if ( status == MHEG5_ICS_PIN_REQ_NEVER )
   {
      required = MHEG5FALSE;
   }
#else
   E_ICSPinSupport support;
   DVB_MhegGetPINSupport(&support);
   if (support != MHEG5_ICS_PIN_SUPPORT_ENABLED)
   {
      required = MHEG5FALSE;
   }
   TRACE(TICS,("PIN support %d %d",support,required))
#endif
   return required;
}


MHEG5Bool MHEG5promptForGuidance(MHEG5String *restriction, MHEG5Bool show)
{
   U8BIT *out;
   U8BIT byte;
   U32BIT len;
   U16BIT index, count;
   U32BIT ch = 0;
   enum
   {
      S_START,
      S_MARKUP,
      S_UTF_END,
      S_UTF_3,
      S_UTF_4,
      S_DROP,
      S_RESYNC
   } state;

   out = guidanceMessage;

   if (restriction != NULL)
   {
      index = 0;
      count = 0;
      state = S_START;
      len = restriction->len;

      /* Copy restriction to local buffer while removing unrecognised character
       * and markup sequences.
       */
      while (index < len)
      {
         byte = restriction->data[index];
         switch (state)
         {
            case S_START:
               if (byte == 0x1b)
               {
                  state = S_MARKUP;
               }
               else if (byte <= 0x7f)
               {
                  if (count < MAX_PROMPT)
                  {
                     *out++ = byte;
                     ++count;
                  }
               }
               else if ((byte & 0xe0) == 0xc0)
               {
                  /* 2-byte UTF-8 sequence */
                  ch = byte & 0x1f;
                  state = S_UTF_END;
               }
               else if ((byte & 0xf0) == 0xe0)
               {
                  /* 3-byte UTF-8 sequence */
                  ch = byte & 0x0f;
                  state = S_UTF_3;
               }
               else if ((byte & 0xf8) == 0xf0)
               {
                  /* 4-byte UTF-8 sequence */
                  ch = byte & 0x07;
                  state = S_UTF_4;
               }
               break;
            case S_MARKUP:
               if (byte >= 0x40 && byte <= 0x5e)
               {
                  /* Sequence 0x1b T N b1 b2 ... bN */
                  if (index + (U16BIT)2 < (U16BIT)len)
                  {
                     /* Skip sequence */
                     index += 2 + restriction->data[index + 2];
                     state = S_START;
                  }
                  else
                  {
                     state = S_DROP;
                  }
               }
               else if (byte >= 0x60 && byte <= 0x7e)
               {
                  /* Sequence 0x1b T - skip */
                  ++index;
                  state = S_START;
               }
               else
               {
                  /* Unknown escape sequence */
                  state = S_RESYNC;
               }
               break;
            case S_UTF_3:
               if ((byte & 0xc0) == 0x80)
               {
                  /* 2nd byte from the end */
                  ch <<= 6;
                  ch |= byte & 0x3f;
                  state = S_UTF_END;
               }
               else
               {
                  /* Invalid UTF-8 sequence */
                  state = S_RESYNC;
               }
               break;
            case S_UTF_4:
               if ((byte & 0xc0) == 0x80)
               {
                  /* 3rd byte from the end */
                  ch <<= 6;
                  ch |= byte & 0x3f;
                  state = S_UTF_3;
               }
               else
               {
                  /* Invalid UTF-8 sequence */
                  state = S_RESYNC;
               }
               break;
            case S_UTF_END:
               if ((byte & 0xc0) == 0x80)
               {
                  /* Last UTF-8 byte */
                  ch <<= 6;
                  ch |= byte & 0x3f;

                  if (count < MAX_PROMPT)
                  {
                     /* Re-encode character */
                     if (ch <= 0x7f)
                     {
                        *out++ = (U8BIT)ch;
                     }
                     else if (ch <= 0x7ff)
                     {
                        *out++ = 0xc0 | (U8BIT)(ch >> 6);
                        *out++ = 0x80 | (U8BIT)(ch & 0x3f);
                     }
                     else if (ch <= 0xffff)
                     {
                        *out++ = 0xe0 | (U8BIT)(ch >> 12);
                        *out++ = 0x80 | ((ch >> 6) & 0x3f);
                        *out++ = 0x80 | (ch & 0x3f);
                     }
                     else
                     {
                        *out++ = 0xe0 | (U8BIT)(ch >> 18);
                        *out++ = 0x80 | ((ch >> 12) & 0x3f);
                        *out++ = 0x80 | ((ch >> 6) & 0x3f);
                        *out++ = 0x80 | (ch & 0x3f);
                     }
                     ++count;
                  }
                  state = S_START;
               }
               else
               {
                  /* Invalid UTF-8 sequence */
                  state = S_RESYNC;
               }
               break;
            case S_DROP:
               /* Just drop everything */
               break;
            case S_RESYNC:
               if ((((byte & 0x80) == 0x00) && (byte != 0x00)) ||
                   ((byte & 0xe0) == 0xc0) ||
                   ((byte & 0xf0) == 0xe0) ||
                   ((byte & 0xf8) == 0xf0))
               {
                  /* Valid first UTF-8 byte: make sure the character is
                   * re-processed and start again.
                   */
                  --index;
                  state = S_START;
               }
               break;
         }
         ++index;
      }
   }
   *out = '\0';

   return (DVB_MhegPromptForGuidance(guidanceMessage, show ? TRUE : FALSE) == MHERR_OK)? MHEG5TRUE : MHEG5FALSE;
}

#ifndef INCLUDE_FREESAT

MHEG5Bool MHEG5GetPINSupport(MHEG5Int *support)
{
   E_ICSPinSupport pinSupport;
   MHEG5Bool success;
   E_MhegErr err;

   success = MHEG5FALSE;

   err = DVB_MhegGetPINSupport(&pinSupport);
   if (err == MHERR_OK)
   {
      switch (pinSupport)
      {
         case MHEG5_ICS_PIN_SUPPORT_NONE:
            *support = -1;
            success = MHEG5TRUE;
            break;
         case MHEG5_ICS_PIN_SUPPORT_DISABLED:
            *support = 0;
            success = MHEG5TRUE;
            break;
         case MHEG5_ICS_PIN_SUPPORT_ENABLED:
            *support = 1;
            success = MHEG5TRUE;
            break;
         default:
            ;
      }
   }

   return success;
}

#else  /* INCLUDE_FREESAT */

MHEG5Bool MHEG5GetPINRequirement(MHEG5Int *status)
{
   E_ICSPinReq pinStatus;
   MHEG5Bool success;

   success = MHEG5FALSE;

   DVB_MhegGetPINRequirement(&pinStatus);
   switch (pinStatus)
   {
      case MHEG5_ICS_PIN_REQ_NEVER:
         *status = 0;
         success = MHEG5TRUE;
         break;
      case MHEG5_ICS_PIN_REQ_GUIDANCE_ONLY:
         *status = 1;
         success = MHEG5TRUE;
         break;
      case MHEG5_ICS_PIN_REQ_ALWAYS:
         *status = 2;
         success = MHEG5TRUE;
         break;
      default:
         ;
   }

   return success;
}

MHEG5Bool MHEG5GetFSIServiceReference(MHEG5Int serviceIndex, MHEG5Int *fsi, MHEG5String *fsiString)
{
   MHEG5Byte fsiChars[5];
   U16BIT fsiBuffer;
   int i;

   if (DVB_MhegGetFSIServiceReference(serviceIndex, &fsiBuffer) == MHERR_OK)
   {
      /*one more check that the returned FSI is within the valid range*/
      if (fsiBuffer > 0x7ff || fsiBuffer < 1)
      {
         return MHEG5FALSE;
      }

      fsiString->len = 19;
      fsiChars[4] = '0' + fsiBuffer % 10;
      fsiChars[3] = '0' + fsiBuffer / 10;
      fsiChars[2] = '0' + fsiBuffer / 100;
      fsiChars[1] = '0' + fsiBuffer / 1000;
      fsiChars[0] = '0' + fsiBuffer / 10000;

      for (i = 0; i < 5; i++)
      {
         if (fsiChars[i] == '0')
         {
            fsiString->len--;
         }
         else
         {
            break;
         }
      }

      fsiString->data = STR_DataAlloc( fsiString->len );
      memcpy(fsiString->data, "rec://svc/fsi/", 14);
      memcpy(fsiString->data + 14, &fsiChars[i], fsiString->len - 14);
      *fsi = fsiBuffer;
   }
   else
   {
      return MHEG5FALSE;
   }

   return MHEG5TRUE;
}

MHEG5Bool MHEG5ValidatePIN(MHEG5String *pin, MHEG5Int *status)
{
   E_ICSPinStatus pinStatus;
   MHEG5Bool success;

   success = MHEG5FALSE;

   DVB_MhegValidatePIN(pin->data, &pinStatus);
   switch (pinStatus)
   {
      case MHEG5_ICS_PIN_STATUS_NOT_REQUIRED:
         *status = -1;
         success = MHEG5TRUE;
         break;
      case MHEG5_ICS_PIN_STATUS_OK:
         *status = 0;
         success = MHEG5TRUE;
         break;
      case MHEG5_ICS_PIN_STATUS_INVALID:
         *status = 1;
         success = MHEG5TRUE;
         break;
      default:
         ;
   }

   return success;
}

MHEG5Bool MHEG5ComputePrivateSignature(MHEG5String *data, MHEG5String *result)
{
   /* workspace */
   U8BIT *workspace;
   U8BIT *ws_salt;
   U8BIT *ws_data;
   U8BIT *ws_digest;
   U8BIT *ws_key;
   U8BIT *ws_signature;

   /* OpenSSL */
   EVP_MD_CTX ctx;
   BIO *bio;
   RSA *rsa;
   unsigned int siglen = RSA_SIGNATURE_SIZE;
   int rc;

   /* General */
   U32BIT version;
   char verstr[MAX_VERSION_LEN];
   U16BIT keylen;
   U32BIT reslen, offset;
   U16BIT i;
   BOOLEAN success;

   success = FALSE;
   result->data = NULL;
   result->len = 0;

   /* Workspace = salt + data + digest + key + signature */
   workspace = MHEG5getMem(RSA_SALT_SIZE + data->len + SHA_DIGEST_LENGTH + MAX_RSA_KEY_SIZE + RSA_SIGNATURE_SIZE);
   if (workspace != NULL)
   {
      ws_salt = workspace;
      ws_data = ws_salt + RSA_SALT_SIZE;
      ws_digest = ws_data + data->len;
      ws_key = ws_digest + SHA_DIGEST_LENGTH;
      ws_signature = ws_key + MAX_RSA_KEY_SIZE;

      /* Generate salt - "high quality" random not required */
      for (i = 0; i < 10; i++)
      {
         ws_salt[i] = (U8BIT)MHEG5random();
      }

      /* Append MAC address */
      DVB_MhegGetMACAddress(ws_salt + 10);

      /* Append data */
      memcpy(ws_data, data->data, data->len);

      /* Generate SHA-1 hash */
      EVP_DigestInit(&ctx, EVP_sha1());
      EVP_DigestUpdate(&ctx, workspace, RSA_SALT_SIZE + data->len);
      EVP_DigestFinal(&ctx, ws_digest, NULL);

      /* Sign hash (encrypt using private key) */
      DVB_MhegGetPrivateKey(ws_key, MAX_RSA_KEY_SIZE, &keylen, &version);
      if (keylen <= MAX_RSA_KEY_SIZE)
      {
         bio = BIO_new_mem_buf(ws_key, keylen);
         if (bio != NULL)
         {
            rsa = d2i_RSAPrivateKey_bio(bio, NULL);

            /* Make sure it's a 1024-bit key */
            if (rsa != NULL && RSA_size(rsa) == RSA_SIGNATURE_SIZE)
            {
               /* Calculate signature */
               rc = RSA_sign(NID_sha1, ws_digest, SHA_DIGEST_LENGTH,
                     ws_signature, &siglen, rsa);
               if (rc == 1)
               {
                  success = TRUE;
               }
               RSA_free(rsa);
            }
            BIO_free(bio);
         }
      }
   }

   if (success)
   {
      /* Create result string */
      sprintf(verstr, "%u", version);
      reslen = strlen(verstr) + 1 + 24 + 1 + 172;

      result->len = reslen;
      result->data = (U8BIT *)STR_DataAlloc(result->len + 1);
      if (result->data != NULL)
      {
         strcpy((char *)result->data, verstr);
         offset = strlen(verstr);
         result->data[offset] = ':';
         offset++;
         offset += EncodeBase64(ws_salt, RSA_SALT_SIZE,
               result->data + offset);
         result->data[offset] = ':';
         offset++;
         offset += EncodeBase64(ws_signature, siglen,
               result->data + offset);
         result->data[offset] = '\0';
      }
   }

   if (workspace != NULL)
   {
      MHEG5freeMem(workspace);
   }

   return MHEG5TRUE;
}

static U16BIT EncodeBase64(U8BIT *data, U16BIT len, U8BIT *result)
{
   static char *base64 =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
      "abcdefghijklmnopqrstuvwxyz"
      "0123456789+/=";
   U16BIT i;

   for (i = 0; i < len; i += 3)
   {
      result[i / 3 * 4  ] = base64[(data[i  ] >> 2) & 0x3f];
      result[i / 3 * 4 + 1] = base64[(data[i  ] << 4 | data[i + 1] >> 4) & 0x3f];
      result[i / 3 * 4 + 2] = base64[(data[i + 1] << 2 | data[i + 2] >> 6) & 0x3f];
      result[i / 3 * 4 + 3] = base64[(data[i + 2]) & 0x3f];
   }

   i -= 3;
   switch (len - i)
   {
      case 2:
         result[i / 3 * 4  ] = base64[(data[i  ] >> 2) & 0x3f];
         result[i / 3 * 4 + 1] = base64[(data[i  ] << 4 | data[i + 1] >> 4) & 0x3f];
         result[i / 3 * 4 + 2] = base64[(data[i + 1] << 2) & 0x3f];
         result[i / 3 * 4 + 3] = '=';
         break;
      case 1:
         result[i / 3 * 4  ] = base64[(data[i  ] >> 2) & 0x3f];
         result[i / 3 * 4 + 1] = base64[(data[i  ] << 4) & 0x3f];
         result[i / 3 * 4 + 2] = '=';
         result[i / 3 * 4 + 3] = '=';
         break;
      case 0:
         /* all done */
         break;
   }

   return (len + 2) / 3 * 4;
}

#endif /* INCLUDE_FREESAT */

#endif /* INCLUDE_ICS */

#endif /* INCLUDE_IC */


#ifdef INCLUDE_CONNECTED_TV
/*******************************************************************************
*@begin
* NAME: MHEG5ApplicationLaunch
*       Causes a new (non-MHEG-5) application to be started.
*
* Returns : Nothing
*
* Parameter     Flow    Description
* ------------------------------------------------------------------------------
* location      IN      Location of the application to run
* args          IN      Application arguments (encoded string)
*
* Externals             Flow    Usage
* ------------------------------------------------------------------------------
*
* Additional information:
*
*@end
*******************************************************************************/
void MHEG5ApplicationLaunch(MHEG5String *location, MHEG5String *args)
{
    DVB_MhegApplicationLaunch(location->data, args->data);
}
#endif  /* INCLUDE_CONNECTED_TV */