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

#include <glue_memory.h>

#include "http_header.h"

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

#define MAX_FIELD_NAME         (32)
#define MAX_CONTENT_LENGTH     (24)

#define DBG(x)


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

typedef enum
{
   TOKEN_NUMBER = '0',
   TOKEN_BYTES = 'b',
   TOKEN_SPACE = ' ',
   TOKEN_HYPHEN = '-',
   TOKEN_SLASH = '/',
   TOKEN_ASTERISK = '*'
} TokenType;

typedef struct sToken
{
   TokenType type;
   U8BIT *data;
   U16BIT len;
} Token;

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

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

static BOOLEAN GetNextToken(U8BIT **data, Token *token);


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


U8BIT* httpHdrParseFieldName(U8BIT *data, U32BIT len, E_HTTP_FIELD *field)
{
   U8BIT name[MAX_FIELD_NAME];
   U16BIT nameLen;
   char *sep = "()<>@,;:\\\"/[]?={} \t";

   *field = HTTP_FIELD_UNKNOWN;
   nameLen = 0;
   while ((*data > 32) && (*data < 127) && (strchr(sep, *data) == NULL) &&
          (nameLen < MAX_FIELD_NAME))
   {
      if (*data >= 'A' && *data <= 'Z')
      {
         /* Convert to lower-case as we go */
         name[nameLen] = *data - 'A' + 'a';
      }
      else
      {
         name[nameLen] = *data;
      }
      ++nameLen;
      ++data;
   }

   if (nameLen <= MAX_FIELD_NAME && *data == ':')
   {
      /* Content-Length */
      if (nameLen == 14 && memcmp(name, "content-length", 14) == 0)
      {
         *field = HTTP_FIELD_CONTENT_LENGTH;
      }
      else if (nameLen == 13 && memcmp(name, "content-range", 13) == 0)
      {
         *field = HTTP_FIELD_CONTENT_RANGE;
      }
      else if (nameLen == 12 && memcmp(name, "content-type", 12) == 0)
      {
         *field = HTTP_FIELD_CONTENT_TYPE;
      }
      else if (nameLen == 6 && memcmp(name, "x-keys", 6) == 0)
      {
         *field = HTTP_FIELD_X_KEYS;
      }
      else if (nameLen == 13 && memcmp(name, "x-keylocation", 13) == 0)
      {
         *field = HTTP_FIELD_X_KEY_LOCATION;
      }
      else if (nameLen == 16 && memcmp(name, "x-bytespersecond", 16) == 0)
      {
         *field = HTTP_FIELD_X_BYTES_PER_SECOND;
      }
      ++data;
      /* Skip LWS (linear white spaces) */
      while (*data == '\r' || *data == '\n' || *data == ' ' || *data == '\t')
      {
         ++data;
      }
      /* data should now point at data for the field */
   }

   return data;
}

U64BIT httpHdrParseContentLength(U8BIT *data, U32BIT len)
{
   U64BIT contentLength;
   char buffer[MAX_CONTENT_LENGTH];
   Token token;
   BOOLEAN success;

   ULL_SetInvalid(contentLength);

   /* The field is 1*DIGIT (one or more digits) */
   success = GetNextToken(&data, &token);
   if (success)
   {
      if ((token.type == TOKEN_NUMBER) &&
          (token.len < MAX_CONTENT_LENGTH))
      {
         memcpy(buffer, token.data, token.len);
         buffer[token.len] = '\0';
         contentLength = ULONG_Atoi(buffer);
      }
   }
   return contentLength;
}

U64BIT httpHdrParseContentRange(U8BIT *data, U32BIT len)
{
   U64BIT contentLength;
   char buffer[MAX_CONTENT_LENGTH];
   Token token;
   BOOLEAN success;

   /* The field is 1*DIGIT "-" 1*DIGIT "/" (1*DIGIT | "*"), but
    * we're only interested in the last field.
    */
   success = GetNextToken(&data, &token);
   if (success && token.type == TOKEN_BYTES)
   {
      success = GetNextToken(&data, &token);
   }
   if (success && token.type == TOKEN_SPACE)
   {
      success = GetNextToken(&data, &token);
   }
   if (success && token.type == TOKEN_NUMBER)
   {
      success = GetNextToken(&data, &token);
   }
   if (success && token.type == TOKEN_HYPHEN)
   {
      success = GetNextToken(&data, &token);
   }
   if (success && token.type == TOKEN_NUMBER)
   {
      success = GetNextToken(&data, &token);
   }
   if (success && token.type == TOKEN_SLASH)
   {
      success = GetNextToken(&data, &token);
   }
   /* if (token.type == TOKEN_ASTERISK)
      {
          // Unknown length, nothing to do
      }
    */
   if (success &&
       (token.type == TOKEN_NUMBER) &&
       (token.len < MAX_CONTENT_LENGTH))
   {
      memcpy(buffer, token.data, token.len);
      buffer[token.len] = '\0';
      contentLength = ULONG_Atoi(buffer);
   }
   else
   {
      ULL_SetInvalid(contentLength);
   }
   return contentLength;
}

/*******************
 * LOCAL FUNCTION   *
 ********************/

static BOOLEAN GetNextToken(U8BIT **data, Token *token)
{
   BOOLEAN success;
   U8BIT *p = *data;

   token->data = p;
   switch (*p)
   {
      case '0': case '1': case '2': case '3': case '4':
      case '5': case '6': case '7': case '8': case '9':
         token->type = TOKEN_NUMBER;
         do
         {
            ++p;
         }
         while (*p >= '0' && *p <= '9');
         token->len = p - *data;
         success = TRUE;
         break;
      case 'b':
         do
         {
            ++p;
         }
         while (*p >= 'a' && *p <= 'z');
         if (p - *data == 5 && memcmp(*data, "bytes", 5) == 0)
         {
            token->type = TOKEN_BYTES;
            token->len = 5;
            success = TRUE;
         }
         else
         {
            success = FALSE;
         }
         break;
      case ' ':
         token->type = TOKEN_SPACE;
         token->len = 1;
         success = TRUE;
         break;
      case '-':
         token->type = TOKEN_HYPHEN;
         token->len = 1;
         success = TRUE;
         break;
      case '/':
         token->type = TOKEN_SLASH;
         token->len = 1;
         success = TRUE;
         break;
      case '*':
         token->type = TOKEN_ASTERISK;
         token->len = 1;
         success = TRUE;
         break;
      default:
         success = FALSE;
         break;
   }

   if (success)
   {
      *data += token->len;
   }

   return success;
}