stmr_header.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 <string.h>
#include <stdio.h>
#include <sys/types.h>

#include <glue_memory.h>
#include "mh5parse.h"

#include "stmr_header.h"
#include "stmr_common.h"

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

#define DBG(x)


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

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

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

static BOOLEAN DecodeKey(U8BIT **data, U8BIT *key, U16BIT len)
{
   static char *base64 =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
      "abcdefghijklmnopqrstuvwxyz"
      "0123456789+/=";
   char *p = (char *)(*data);
   int symbols, bytes, i, j;
   int b0, b1, b2, b3;
   BOOLEAN success;

   success = FALSE;

   symbols = strspn(p, base64);
   if (symbols > 0 && symbols % 4 == 0)
   {
      bytes = symbols * 3 / 4;
      if (p[symbols - 1] == '=')
      {
         --bytes;
      }
      if (p[symbols - 2] == '=')
      {
         --bytes;
      }
      if (bytes == len)
      {
         for (i = 0, j = 0; i < symbols; i += 4)
         {
            b0 = strchr(base64, *p++) - base64;
            b1 = strchr(base64, *p++) - base64;
            b2 = strchr(base64, *p++) - base64;
            b3 = strchr(base64, *p++) - base64;

            key[j++] = b0 << 2 | b1 >> 4;
            if (b2 < 64)
            {
               key[j++] = b1 << 4 | b2 >> 2;
               if (b3 < 64)
               {
                  key[j++] = b2 << 6 | b3;
               }
            }
         }

         *data += symbols;
         success = TRUE;
      }
   }

   return success;
}

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

void MHEG5parseStreamKeys(U8BIT *data, U16BIT len, S_ICSKeys *keys)
{
   S_ICSPidInfo *pid_info;
   U16BIT colons;
   U16BIT num_pids, i;
   U8BIT *p;
   BOOLEAN success;

   /*
    * Input format:
    *
    * KeyFile ::= KeyString
    * KeyHeader ::= ~X-Keys:~ <space> KeyString
    * KeyString ::= PIDString [ ~:~ KeyString]
    * PIDString ::= PID ~:~ IV ~:~ OddKey ~:~ EvenKey
    * PID ::= <integer encoded as decimal ascii value>
    * IV ::= <128bit binary value encoded as Base64>
    * OddKey ::= <128bit binary value encoded as Base64>
    * EvenKey ::= <128bit binary value encoded as Base64>
    */

   /* Count number of colons to determine maximum number of key sets */
   colons = 0;
   p = (U8BIT *)strchr((char *)data, ':');
   while (p != NULL)
   {
      ++colons;
      p = (U8BIT *)strchr((char *)p + 1, ':');
   }

   if (colons % 4 == 3)
   {
      num_pids = (colons + 1) / 4;
      keys->num_pids = 0;
      keys->pid_info = MHEG5getMem(num_pids * sizeof *keys->pid_info);
      if (keys->pid_info != NULL)
      {
         /* Try to parse as many sets as possible */
         for (i = 0; i < num_pids; ++i)
         {
            pid_info = &keys->pid_info[i];

            /* Parse PID */
            pid_info->PID = 0;
            p = (U8BIT *)strchr((char *)data, ':');
            assert(p != NULL);
            while (*data >= '0' && *data <= '9')
            {
               pid_info->PID *= 10;
               pid_info->PID += *data - '0';
               ++data;
            }

            if (data != p)
            {
               /* Colon was expected */
               break;
            }
            ++data;

            /* Parse IV */
            success = DecodeKey(&data, pid_info->iv, 16);
            if (!success || *data != ':')
            {
               break;
            }
            ++data;

            /* Parse odd key */
            success = DecodeKey(&data, pid_info->odd_key, 16);
            if (!success || *data != ':')
            {
               break;
            }
            ++data;

            /* Parse even key */
            success = DecodeKey(&data, pid_info->even_key, 16);
            if (!success)
            {
               break;
            }

            if (*data == ':')
            {
               /* Skip colon for next set */
               ++data;
            }

            ++keys->num_pids;
         }

         success = TRUE;

         /* If nothing was parsed, clear key information */
         if (keys->num_pids == 0)
         {
            MHEG5freeMem(keys->pid_info);
            keys->pid_info = NULL;
            success = FALSE;
         }
      }
   }
   else
   {
      keys->num_pids = 0;
      keys->pid_info = NULL;
   }
}

void MHEG5ParseXKeys(U8BIT *data, U32BIT len, S_ICSKeys *keys)
{
   MHEG5parseStreamKeys(data, strlen((char *)data), keys);
}

void MHEG5ParseXKeyLocation(U8BIT *data, U32BIT len, MHEG5String *keyLocation)
{
   static const char *lws = "\r\n \t";

   /* Find end of string */
   keyLocation->len = strcspn((char *)data, lws);

   /* Copy URL */
   keyLocation->data = STR_DataAlloc((keyLocation->len + 1));
   if (keyLocation->data != NULL)
   {
      memcpy(keyLocation->data, data, keyLocation->len);
      keyLocation->data[keyLocation->len] = '\0';
   }
   else
   {
      keyLocation->len = 0;
   }
}

void MHEG5ParseXBytesPerSecond(U8BIT *data, U32BIT len, U32BIT *bytesPerSecond,
   BOOLEAN *knownBitrate)
{
   *bytesPerSecond = 0;
   *knownBitrate = FALSE;

   if (*data >= '1' && *data <= '9')
   {
      *bytesPerSecond = *data - '0';
      ++data;
   }
   while (*data >= '0' && *data <= '9')
   {
      *bytesPerSecond *= 10;
      *bytesPerSecond += *data - '0';
      ++data;
   }

   if (*data == '\r' || *data == '\n')
   {
      *knownBitrate = TRUE;
   }
}