mh5cookies.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 <stdio.h>
#include <string.h>
#include <ctype.h>

#include "mh5cookies.h"
#include "mh5memory.h"
#include "mh5base.h"
#include "mh5date.h"

#include "techtype.h"

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

#define MAX_COOKIES 32
#define MAX_STORE_SIZE 8192
#define MINUTE 60
#define HOUR 1200
#define SECONDS_IN_DAY (24 * HOUR)


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

typedef struct cookiestore_s
{
   MHEG5String identity;
   MHEG5String name;
   MHEG5String value;
   MHEG5String path;
   MHEG5String domain;
   MHEG5Int version;
   MHEG5Int expire_date;
   MHEG5Int expire_time;
   MHEG5Bool secure;

   struct cookiestore_s *next;
   struct cookiestore_s *previous;
} cookiestore_t;

/*---local (static) variable declarations for this file----------------------*/
static cookiestore_t *cookiejar = NULL;
static cookiestore_t *oldest_cookie = NULL;

static U32BIT cookie_count = 0;
static U32BIT cookiejar_size = 0;

/*---local function prototypes for this file---------------------------------*/
static void DeleteCookie(cookiestore_t *cookie);

static U32BIT SkipWhitespace(void *data, U32BIT offset, U32BIT data_len);

static MHEG5Bool ParseIdentity(cookiestore_t *cookie);

static void PushCookie(cookiestore_t *new_cookie);

static MHEG5Int FindChrInStr(MHEG5String source, MHEG5Int offset, char *search);

static MHEG5Bool StrCmpChr(MHEG5String cmp_str, char *cmp_chrs);

static U8BIT* AddHeader(U8BIT *header, cookiestore_t *cookie);

static MHEG5Int ParseDate(MHEG5String date_string, MHEG5Int *date, MHEG5Int *time);

static void SetMaxAge(MHEG5String duration_string, MHEG5Int *date, MHEG5Int *time);

static MHEG5Bool GetDomainFromUrl(char *full_url, MHEG5String *domain_string);
static MHEG5Bool CookieEqual(MHEG5String *stored, MHEG5String *requested);

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

void MHEG5CookieParse(void *data, U32BIT data_len, char *url)
{
   MHEG5String data_handle;
   cookiestore_t *new_cookie;
   MHEG5String name;
   MHEG5String value;
   U32BIT offset = 0;
   MHEG5Int pos;
   MHEG5Bool quoted;

   assert(data);

   data_handle.data = data;
   data_handle.len = data_len;

   if (data_len > 11 && memcmp(data_handle.data, "Set-Cookie:", 11) == 0)
   {
      offset = strlen("Set-Cookie:");
      new_cookie = MHEG5getMem(sizeof(cookiestore_t));
      if (new_cookie)
      {
         new_cookie->secure = MHEG5FALSE;
         new_cookie->expire_date = 0;
         new_cookie->expire_time = 0;
         new_cookie->domain.data = NULL;
         new_cookie->domain.len = 0;
         new_cookie->name.len = 0;
         new_cookie->name.data = NULL;
         new_cookie->path.len = 0;
         new_cookie->path.data = NULL;
      }
      while (new_cookie && offset < data_len)
      {
         quoted = MHEG5FALSE;
         /*skip to the beginning of the name field*/
         offset = SkipWhitespace(data, offset, data_len);
         /*find the end of the name, by searching for the '='*/
         pos = FindChrInStr(data_handle, offset, "=");
         if (pos > 0)
         {
            name.len = pos - offset;
            name.data = (MHEG5Byte *)data + offset;
            /*set the position to after the '='*/
            offset = pos + 1;
            if (data_handle.data[offset] == '\"')
            {
               offset++;
               quoted = MHEG5TRUE;
            }

            pos = FindChrInStr(data_handle, offset, ";");
            if (pos == -1)
            {
               pos = FindChrInStr(data_handle, offset, "\r\n");
            }
            if (quoted)
            {
               pos--;
            }

            value.data = (MHEG5Byte *)data + offset;
            if (pos > 0)
            {
               value.len = pos - offset;
               if (quoted)
               {
                  /*reset the position*/
                  pos++;
               }
               offset = pos + 1;
            }
            else
            {
               value.len = data_handle.len - offset;
               offset = data_handle.len;
            }


            if (StrCmpChr(name, "path") == MHEG5TRUE || StrCmpChr(name, "Path") == MHEG5TRUE)
            {
               new_cookie->path = MHEG5stringCopy(value);
            }
            else if (StrCmpChr(name, "domain") == MHEG5TRUE)
            {
               new_cookie->domain = MHEG5stringCopy(value);
            }
            else if (StrCmpChr(name, "expires") == MHEG5TRUE)
            {
               ParseDate(value, &new_cookie->expire_date, &new_cookie->expire_time);
            }
            else if (StrCmpChr(name, "max-age") == MHEG5TRUE)
            {
               SetMaxAge(value, &new_cookie->expire_date, &new_cookie->expire_time);
            }
            else if (StrCmpChr(name, "Version") == MHEG5TRUE)
            {
               new_cookie->version = MHEG5strToInt(value);
            }
            else
            {
               new_cookie->value = MHEG5stringCopy(value);
               new_cookie->name = MHEG5stringCopy(name);
            }
         }
      }
      if (new_cookie)
      {
         if (new_cookie->domain.len == 0)
         {
            GetDomainFromUrl(url, &new_cookie->domain);
         }
         new_cookie->identity.len = new_cookie->name.len + new_cookie->domain.len +
                                    new_cookie->path.len + 1;
         new_cookie->identity.data = STR_DataAlloc(new_cookie->identity.len);
         if (new_cookie->identity.data)
         {
            offset = 0;
            memcpy(new_cookie->identity.data + offset, new_cookie->name.data, new_cookie->name.len);
            offset += new_cookie->name.len;

            *(new_cookie->identity.data + offset) = ',';
            offset++;

            memcpy(new_cookie->identity.data + offset, new_cookie->domain.data, new_cookie->domain.len);
            offset += new_cookie->domain.len;
            memcpy(new_cookie->identity.data + offset, new_cookie->path.data, new_cookie->path.len);
            PushCookie(new_cookie);
         }
      }
   }
}

U8BIT* MHEG5CookieGenerateHeader(U8BIT *url)
{
   U8BIT *cookie_header = NULL;
   int offset;
   MHEG5Bool secure;
   cookiestore_t *cursor;
   cookiestore_t *next;
   MHEG5String location;
   S32BIT current_time, current_date;

   if (!cookiejar)
   {
      /*no cookies*/
      return NULL;
   }

   MHEG5getDate(&current_date, &current_time);
   if (!memcmp(url, "http://", 7))
   {
      offset = 7;
      secure = MHEG5FALSE;
   }
   else if (!memcmp(url, "https://", 8))
   {
      offset = 8;
      secure = MHEG5TRUE;
   }
   else
   {
      /*The URL seems to be broke,
         but we'll let somebody else deal with it*/
      return NULL;
   }

   location.len = strlen((char *)url) - offset;
   location.data = url + offset;

   cursor = cookiejar;

   while (cursor)
   {
      next = cursor->next;
      if (cursor->expire_date == 0 ||
          cursor->expire_date > current_date ||
          (cursor->expire_date == current_date && cursor->expire_time > current_time))
      {
         if ((cursor->secure == MHEG5FALSE || secure == MHEG5TRUE) &&
             !memcmp(location.data, cursor->domain.data, cursor->domain.len))
         {
            offset = cursor->domain.len;
            if (!memcmp(location.data + offset, cursor->path.data, cursor->path.len))
            {
               cookie_header = AddHeader(cookie_header, cursor);
            }
         }
      }
      /* else
         {
         DeleteCookie(cursor);
         }*/

      cursor = next;
   }

   return cookie_header;
}

MHEG5Bool MHEG5CookieAdd(MHEG5cookie_t *cookie)
{
   cookiestore_t *new_cookie;
   MHEG5Bool success = MHEG5FALSE;

   if (cookie->value.len > MAX_STORE_SIZE)
   {
      return MHEG5FALSE;
   }
   new_cookie = MHEG5getMem(sizeof(cookiestore_t));
   if (new_cookie)
   {
      new_cookie->identity = MHEG5stringCopy(cookie->identity);
      success = ParseIdentity(new_cookie);
      if (success == MHEG5TRUE)
      {
         new_cookie->value = MHEG5stringCopy(cookie->value);

         new_cookie->secure = cookie->secure;
         new_cookie->expire_date = cookie->expires;
         new_cookie->expire_time = 0;
         PushCookie(new_cookie);
      }
      else
      {
         MHEG5freeMem(new_cookie);
      }
   }
   return success;
}

void MHEG5CookieAckHeader(U8BIT *header)
{
   assert(header);
   MHEG5freeMem(header);
}

MHEG5Bool MHEG5CookieRetrieve(MHEG5cookie_t *cookie)
{
   cookiestore_t *cursor;
   cookiestore_t *next;
   S32BIT current_time, current_date;

   MHEG5getDate(&current_date, &current_time);
   cursor = cookiejar;
   while (cursor)
   {
      next = cursor->next;
      /*if(cursor->expire_date == 0 ||
         cursor->expire_date > current_date ||
         (cursor->expire_date == current_date && cursor->expire_time > current_time))   */
      {
         if (CookieEqual(&cursor->identity, &cookie->identity) == MHEG5TRUE)
         {
            cookie->expires = cursor->expire_date;
            cookie->secure = cursor->secure;
            cookie->value = MHEG5stringCopy(cursor->value);
            return MHEG5TRUE;
         }
      }
      /* else
         {
         DeleteCookie(cursor);
         }*/
      cursor = next;
   }

   return MHEG5FALSE;
}

void MHEG5CookieClearStore(void)
{
   while (cookiejar)
   {
      DeleteCookie(cookiejar);
   }
}

static U32BIT SkipWhitespace(void *data, U32BIT offset, U32BIT data_len)
{
   U8BIT *handle = data;

   while (offset < data_len)
   {
      if (handle[offset] != ' ' && handle[offset] != '\t' && handle[offset] != '\r' && handle[offset] != '\n')
      {
         return offset;
      }
      offset++;
   }
   return offset;
}

static void DeleteCookie(cookiestore_t *cookie)
{
   assert(cookie);

   if (cookie->name.data != cookie->identity.data)
   {
      if (cookie->name.len)
         MHEG5stringDestruct(&cookie->name);
      if (cookie->path.len)
         MHEG5stringDestruct(&cookie->path);
      if (cookie->domain.len)
         MHEG5stringDestruct(&cookie->domain);
   }

   if (cookie->value.len)
   {
      cookiejar_size -= cookie->value.len;
      MHEG5stringDestruct(&cookie->value);
   }
   if (cookie->identity.len)
   {
      MHEG5stringDestruct(&cookie->identity);
   }
   if (cookie->previous)
   {
      cookie->previous->next = cookie->next;
   }
   else
   {
      assert(cookie == cookiejar);
      cookiejar = cookie->next;
   }

   if (cookie->next)
   {
      cookie->next->previous = cookie->previous;
   }

   if (cookie == oldest_cookie)
   {
      oldest_cookie = cookie->previous;
   }

   MHEG5freeMem(cookie);
   cookie_count--;
}

static MHEG5Bool ParseIdentity(cookiestore_t *cookie)
{
   MHEG5Bool success = MHEG5FALSE;
   MHEG5Int domain_pos, path_pos;
   int offset;

   domain_pos = FindChrInStr(cookie->identity, 0, ",");
   if (domain_pos != -1)
   {
      path_pos = FindChrInStr(cookie->identity, domain_pos, "/");
      if (path_pos != -1)
      {
         cookie->name.len = domain_pos;
         cookie->name.data = cookie->identity.data;

         cookie->domain.len = path_pos - domain_pos - 1;
         offset = domain_pos + 1;
         cookie->domain.data = cookie->identity.data + offset;

         cookie->path.len = cookie->identity.len - path_pos;
         offset = path_pos;
         cookie->path.data = cookie->identity.data + offset;

         success = MHEG5TRUE;
      }
   }

   return success;
}

static void PushCookie(cookiestore_t *new_cookie)
{
   if (cookiejar == NULL)
   {
      cookiejar = new_cookie;
      new_cookie->previous = NULL;
      new_cookie->next = NULL;
      oldest_cookie = new_cookie;
   }
   else
   {
      cookiejar->previous = new_cookie;
      new_cookie->next = cookiejar;
      new_cookie->previous = NULL;
      cookiejar = new_cookie;
   }


   cookie_count++;
   cookiejar_size += new_cookie->value.len;

   if (cookie_count > MAX_COOKIES)
   {
      DeleteCookie(oldest_cookie);
   }

   while (cookiejar_size > MAX_STORE_SIZE)
   {
      DeleteCookie(oldest_cookie);
   }
}

static MHEG5Int FindChrInStr(MHEG5String source, MHEG5Int offset, char *search)
{
   int len;
   register int rc = -1, i, j = 0;

   if (offset >= 0 && offset < source.len && search && source.data)
   {
      len = strlen(search);
      for (i = offset; i != source.len; i++)
      {
         if ((source.data[i] | 0x20) == (search[j] | 0x20))
         {
            if (j == 0)
               rc = i;
            j++;
            if (j == len)
            {
               return rc;
            }
         }
         else
         {
            j = 0;
         }
      }
   }
   return -1;
}

static MHEG5Bool StrCmpChr(MHEG5String cmp_str, char *cmp_chrs)
{
   if (cmp_str.len != strlen(cmp_chrs))
   {
      return MHEG5FALSE;
   }

   if (!memcmp(cmp_chrs, cmp_str.data, cmp_str.len))
   {
      return MHEG5TRUE;
   }
   else
   {
      return MHEG5FALSE;
   }
}

static U8BIT* AddHeader(U8BIT *header, cookiestore_t *cookie)
{
   U8BIT *header_string;
   int offset, len;

   if (!header)
   {
      header = MHEG5getMem(23);

      memcpy(header, "Cookie: $Version=\"0\"; \0", 23);
   }

   len = strlen((char *)header);
   len += cookie->name.len;
   len += cookie->value.len;
   len += cookie->path.len;
   len += 12;
   header_string = MHEG5getMem(len);

   memcpy(header_string, header, strlen((char *)header));
   offset = strlen((char *)header);

   MHEG5freeMem(header);

   memcpy(header_string + offset, cookie->name.data, cookie->name.len);
   offset += cookie->name.len;

   memcpy(header_string + offset, "=", 1);
   offset += 1;

   memcpy(header_string + offset, cookie->value.data, cookie->value.len);
   offset += cookie->value.len;

   memcpy(header_string + offset, "; $Path=", 8);
   offset += 8;

   memcpy(header_string + offset, cookie->path.data, cookie->path.len);
   offset += cookie->path.len;

   memcpy(header_string + offset, "; \0", 3);


   return header_string;
}

static S32BIT ParseMonthString(U8BIT *input_string)
{
   S32BIT month_index = 0;
   switch (input_string[0])
   {
      case 'J':
         if (!memcmp(input_string, "Jan", 3))
         {
            month_index = 1;
         }
         if (!month_index && !memcmp(input_string, "Jun", 3))
         {
            month_index = 6;
         }
         if (!month_index && !memcmp(input_string, "Jul", 3))
         {
            month_index = 7;
         }
         break;
      case 'F':
         if (!memcmp(input_string, "Feb", 3))
         {
            month_index = 2;
         }
         break;
      case 'M':
         if (!memcmp(input_string, "Mar", 3))
         {
            month_index = 3;
         }
         if (!month_index && !memcmp(input_string, "May", 3))
         {
            month_index = 5;
         }
         break;
      case 'A':
         if (!memcmp(input_string, "Apr", 3))
         {
            month_index = 4;
         }
         if (!month_index && !memcmp(input_string, "Aug", 3))
         {
            month_index = 8;
         }
         break;
      case 'S':
         if (!memcmp(input_string, "Sep", 3))
         {
            month_index = 9;
         }
         break;
      case 'O':
         if (!memcmp(input_string, "Oct", 3))
         {
            month_index = 10;
         }
         break;
      case 'N':
         if (!memcmp(input_string, "Nov", 3))
         {
            month_index = 11;
         }
         break;
      case 'D':
         if (!memcmp(input_string, "Dec", 3))
         {
            month_index = 12;
         }
         break;
   }

   return month_index;
}

static S32BIT ParseTimeString(U8BIT *input_string)
{
   S32BIT time;
   time = (input_string[0] - '0') * HOUR * 10;
   time += (input_string[1] - '0') * HOUR;
   time += (input_string[3] - '0') * MINUTE * 10;
   time += (input_string[4] - '0') * MINUTE;
   time += (input_string[6] - '0') * 10;
   time += (input_string[7] - '0');
   return time;
}

static MHEG5Int ParseDate(MHEG5String date_string, MHEG5Int *date, MHEG5Int *time)
{
   S32BIT day = 0;
   S32BIT month;
   S32BIT year = 0;
   if (date_string.len == 29)
   {
      day = (date_string.data[5] - '0') * 10;
      day += date_string.data[6] - '0';
      month = ParseMonthString(date_string.data + 8);
      year = (date_string.data[12] - '0') * 1000;
      year += (date_string.data[13] - '0') * 100;
      year += (date_string.data[14] - '0') * 10;
      year += date_string.data[15] - '0';
      *date = JulianDate(day, month, year);
      *time = ParseTimeString(date_string.data + 17);
   }

   return 0;
}

static void SetMaxAge(MHEG5String duration_string, MHEG5Int *date, MHEG5Int *time)
{
   MHEG5Int max_age;
   S32BIT current_date, current_time;


   max_age = MHEG5strToInt(duration_string);
   MHEG5getDate(&current_date, &current_time);

   *date = current_date + (max_age / SECONDS_IN_DAY);
   *time = current_time + (max_age % SECONDS_IN_DAY);
}

static MHEG5Bool GetDomainFromUrl(char *full_url, MHEG5String *domain_string)
{
   U32BIT full_len;
   U32BIT offset, end;
   full_len = strlen(full_url);

   if (full_len > 7 && full_url[7] != '/')
   {
      offset = 7;
   }
   else if (full_len > 8 && full_url[8] != '/')
   {
      offset = 8;
   }
   else
   {
      return MHEG5FALSE;
   }
   for (end = offset; end != full_len; end++)
   {
      if (full_url[end] == '/')
      {
         break;
      }
   }
   if (end == full_len)
   {
      return MHEG5FALSE;
   }
   end -= offset;
   domain_string->data = STR_DataAlloc(end);
   if (domain_string->data == NULL)
   {
      return MHEG5FALSE;
   }
   domain_string->len = end;
   memcpy(domain_string->data,(U8BIT *)full_url + offset,end);
   return MHEG5TRUE;
}

static MHEG5Bool CookieEqual(MHEG5String *stored, MHEG5String *requested)
{
   enum { NAME, DOMAIN, PATH } state = NAME;
   MHEG5Int i, len;
   MHEG5Bool equal;

   equal = MHEG5FALSE;
   if (stored->len == requested->len)
   {
      equal = MHEG5TRUE;
      len = stored->len;
      for (i = 0; equal && i < len; i++)
      {
         if ((state == DOMAIN) && (stored->data[i] == '/'))
         {
            state = PATH;
         }

         if (state == DOMAIN)
         {
            /* case-insensitive comparison */
            if (toupper(stored->data[i]) != toupper(requested->data[i]))
            {
               equal = MHEG5FALSE;
            }
         }
         else
         {
            if (stored->data[i] != requested->data[i])
            {
               equal = MHEG5FALSE;
            }
         }

         if ((state == NAME) && (stored->data[i] == ','))
         {
            state = DOMAIN;
         }
      }
   }

   return equal;
}