hdrutil.c

是一个手机功能的模拟程序

/*
 * Copyright (C) Ericsson Mobile Communications AB, 2000.
 * Licensed to AU-System AB.
 * All rights reserved.
 *
 * This software is covered by the license agreement between
 * the end user and AU-System AB, and may be used and copied
 * only in accordance with the terms of the said agreement.
 *
 * Neither Ericsson Mobile Communications AB nor AU-System AB
 * assumes any responsibility or liability for any errors or inaccuracies in
 * this software, or any consequential, incidental or indirect damage arising
 * out of the use of the Generic WAP Client software.
 */
/* ==================================================================
	FILE: hdrutil.c
  
	Utilities for Header Encoding/Decoding for WAP.
	Source file.

	Rev history:
		980923	JPR		Created
		990406	JPR		Corrections
		990408	JPR		Function create header Accept-language added
		990409	JPR		URL-functions removed
		990412	JPR		Macros used for character classification
		990416	JPR		Authentication functions updated (TR 64)
		990510	JPR		WSP_GetContentTypeByte updated
		990526	JPR		Corrections
		990611	JPR		Removal of unreferenced variables
		990623	JPR		Correction of Authentication functions
		990826	JPR		Changes in CreateHeaderField
						WSP_GetContentTypeString added
		990908	JPR		Correction in WSP_CreateHeaderField
		990921	JPR		Correction in WSP_CreateHeaderField (Accept
						Language and Accept Charset with long integer)
		991006	JPR		Correction in StepFieldLength
		991108	JPR		Correction in WSP_GetProxyAuthenticateRealm 
						and isWapCRLF.
		991112	JPR		ADDRESS functions added
		991118	JPR		Corrections in ADDRESS functions
		000110	IPN		Authentication functions moved to authoriz.c
		000111	JPR		Multipart functions updated
		000114	JPR		WSP Parameter handling changed
		000121	JPR		WSP_GetEtag added, WSP_CreateHeaderField
						function updated
		000125	JPR		WAE_AddTextFormDataPart added, corrections in
						multipart handling, correction in function
						WSP_CreateHeaderField (Authorization)
		000126	JPR		Correction in function WSP_CreateHeaderField 
						(Authorization and encoding of long integer)
						and Field_Profile_Diff header added. Function
						WSP_GetProfileWarning added.
						WSP_DeleteMultipartListWithContent added.
		000211	JPR		WSP_CreateHeaderField updated to support 
						Accept Application and Bearer Indication
						Function WSP_GetEtagWCHAR removed.
		000301	JPR		Function WAE_AddGenericFormDataPart implemented
		001106	JPR		Function WSP_GetPushHeaderAppId implemented
		001114  HEAD    Function WSP_BuildMultipart has a new parameter
						iTotalSize that is used in Large Data Transfer.
		001206	KEOL	Changed the fault handling in WSP_GetPushHeaderAppId 
        010306  ASPN    Corection in WSP_GetContentTypeByte
		010319  RMZ     Added function WSP_GetSetCookie
		010320	IPN		WSP_CreateHeaderField updated to support 
						Cookie
		010403	IPN		Added function WSP_GetEncodingVersion.
						WSP_CreateHeaderField updated to support 
						AcceptCharset EncodingVersion 1.3
		010410	IPN		WSP_GetParameters supports now SEC and MAC
		010419	IPN		Correction in WSP_GetParameters
        010502  ASPN    WTA_WML constants added
				

   ================================================================== */

#include "hdrutil.h"
#include "headdef.h"
#include "confvars.h"
#include "cmmnrsrc.h"

pHEADERDEF CreateHEADERDEF (BYTE *pbInstream, UINT32 iLength)
{
	pHEADERDEF pDef;

	pDef=NEWSTRUCT(HEADERDEF);
	if (pDef!=NULL) 
	{
		pDef->pbData=pbInstream;
		pDef->pbEnd=pbInstream+iLength;
		pDef->pHeadList=NULL;
		return pDef;
	}
	return NULL;
}

void DeleteHEADERDEF (pHEADERDEF pDef)
{
	if (pDef!=NULL)
	{
		WSP_EmptyHeaderList(pDef);

		/* Remove copy of WSP header stream */
		DEALLOC(&pDef->pbData);

		DEALLOC(&pDef);
	}
}

/* Copies a byte stream with the specified length. 
   If the iLen is negative the stream is terminated with 
   0 and the length is determined in the function. */
BYTE *B_CopyByteString (BYTE *pbString, INT32 iLen)
{
	BYTE *pbTempString=NULL;

	if (iLen<0)
	{
		iLen=B_STRINGLENGTH(pbString)+1;
	}

	pbTempString=NEWARRAY(BYTE,iLen);
	if (pbTempString!=NULL) 
	{
		B_COPYSTRINGN(pbTempString,pbString,iLen);

		return pbTempString;
	}
	return NULL;
}

pHEADERELEMENT CreateHeaderElement (BYTE bCodePage, BYTE bFieldName, 
									BYTE *pbFieldName, BYTE *pbStart, BYTE *pbEnd)
{
	pHEADERELEMENT pTemp;

	pTemp=NEWSTRUCT(HEADERELEMENT);
	if (pTemp!=NULL)
	{
		pTemp->bCodePage=bCodePage;
		pTemp->bFieldName=bFieldName;
		pTemp->pbFieldName=pbFieldName;
		pTemp->pbFieldValStart=pbStart;
		pTemp->pbFieldValEnd=pbEnd;
		pTemp->pNext=NULL;
	}
	return pTemp;
}

void AddHeaderElement (pHEADERDEF pDef, pHEADERELEMENT pHeadElm)
{
	pHEADERELEMENT pTemp;

	if (pDef->pHeadList==NULL)
	{
		pDef->pHeadList=pHeadElm;
	}
	else 
	{
		pTemp=pDef->pHeadList;

		while (pTemp->pNext!=NULL)
		{
			pTemp=pTemp->pNext;
		}
		pTemp->pNext=pHeadElm;
	}
}

BOOL HdrNextByte (BYTE **ppbStart, BYTE *pbEnd) 
{
	BYTE *pbTemp=*ppbStart;

	pbTemp++;

	/* Check if within bounds */
	if (pbTemp<pbEnd) 
	{
		*ppbStart=pbTemp;
		return TRUE;
	}
	return FALSE;
}

BOOL StepFieldLength (BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;
	UINT32 iResult=0;
	UINT32 iPos=0;

	if (pbTemp<pbEnd)
	{
		/* Only this byte as data */
		if (*pbTemp>=128)
		{
			pbTemp++;
			*ppbStart=pbTemp;
			return TRUE;
		}

		/*	This byte is followed by the indicated 
			number of bytes (0-30) */
		else if (*pbTemp<=30)
		{		
			if ((*pbTemp)<(pbEnd-pbTemp))
			{
				pbTemp+=*pbTemp+1;
				*ppbStart=pbTemp;
				return TRUE;
			}
		} 

		/*	This byte is followed by an uintvar which
			indicates the number of following bytes. */
		else if (*pbTemp==31)
		{
			pbTemp++;

			if (ReadMBUInt32(&iResult,pbTemp,(UINT32)(pbEnd-pbTemp-1),&iPos))
			{
				/* Increase pTemp with the number of bytes indicated 
				   by iResult and the number of bytes for the MBUInt32. */
				pbTemp+=iPos+iResult;
				*ppbStart=pbTemp;
				return TRUE;
			}	
			return FALSE;
		} 

		/* Text string teminated with End-Of-Text */
		else if ((*pbTemp>=32)&&(*pbTemp<=127))
		{
			while (pbTemp<pbEnd) 
			/* Find NULL */
			{
				if (*pbTemp==0)
				{
					pbTemp++;
					*ppbStart=pbTemp;
					return TRUE;
				}
				pbTemp++;
			}
		} 

	}
	
	/* Error - return FALSE */
	return FALSE;
}

/* <any CHAR except CTLs or tspecials> */
BOOL isWapTokenCh(BYTE pbChar)
{
	return ( isWapCharCh(pbChar) && !isWapCtlCh(pbChar) && 
		!wae_istspecial(pbChar) );
}

/* CR LF */
BOOL isWapCRLF(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;
	
	/* Check CR */
	if (pbTemp<pbEnd)
	{
		if (isWapCRCh(*pbTemp))
		{
			if (HdrNextByte(&pbTemp,pbEnd))
			{
				/* Check LF */
				if (isWapLFCh(*pbTemp))
				{
					pbTemp++;
					*ppbStart=pbTemp;
					return TRUE;
				}
			}
		}
	}
	return FALSE;
}

/* [CRLF] 1*( SP | HT ) */
BOOL isWapLWS(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;	

	isWapCRLF(&pbTemp,pbEnd);

	if (pbTemp<pbEnd)
	{
		/* Check at least one SP or HT */
		if ((isWapSPCh(*pbTemp))||(isWapHTCh(*pbTemp)))
		{
			while (HdrNextByte(&pbTemp,pbEnd))
			{
				if (!((isWapSPCh(*pbTemp))||(isWapHTCh(*pbTemp))))
				{
					/* Finished - return TRUE */
					*ppbStart=pbTemp;
					return TRUE;
				}
			}
		}
	}
	return FALSE;
}

/* <any OCTET except CTLs but including LWS> */
BOOL isWapTEXT(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	/* At least one TEXT-byte must exist */
	if (pbTemp<pbEnd)
	{
		if (isWapLWS(&pbTemp,pbEnd))
		{
			/* OK - do nothing */
		}
		else
		{
			if (isWapCtlCh(*pbTemp))
			{
				return FALSE;
			}
		}

		while (pbTemp<pbEnd)
		{
			if (isWapLWS(&pbTemp,pbEnd))
			{
				/* OK - do nothing */
			}
			else
			{
				if (isWapCtlCh(*pbTemp))
				{
					*ppbStart=pbTemp;
					return TRUE;
				}
				pbTemp++;
			}
		}
	}
	return FALSE;		
}

/* 1*<any CHAR except CTLs or tspecials> */
BOOL isWapToken(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		/* at least one Token */
		if (isWapTokenCh(*pbTemp))  
		{
			pbTemp++;

			/* Step through token */
			while (pbTemp<pbEnd)
			{
				if (!(isWapTokenCh(*pbTemp)))
				{
					/* Token ended */
					*ppbStart=pbTemp;
					return TRUE;
				}
				pbTemp++; 
			}
		}
	}
	return FALSE;
}

/* <Octet 127> */
BOOL isWapQuote(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		if (*pbTemp==127)
		{
			pbTemp++;
			*ppbStart=pbTemp;
			return TRUE;
		}
	}
	return FALSE;
}

/* <Octet 0> */
BOOL isWapNoValue(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		if (*pbTemp==0)
		{
			pbTemp++;			
			*ppbStart=pbTemp;
			return TRUE;
		}
	}
	return FALSE;
}

/* <Any Octet 0-30> */
BOOL isWapShortLength(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		if (isWapShortLengthCh(*pbTemp))
		{
			pbTemp++;
			*ppbStart=pbTemp;
			return TRUE;
		}
	}
	return FALSE;
}

/* <Octet 31> */
BOOL isWapLengthQuote(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		if (isWapLengthQuoteCh(*pbTemp))
		{
			pbTemp++;
			*ppbStart=pbTemp;
			return TRUE;
		}
	}
	return FALSE;
}

/* *TEXT End-of-string */
BOOL isWapExtensionMedia(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	/* Check if TEXT */
	if (isWapTEXT(&pbTemp,pbEnd))
	{
		/* Check if End-of-text */
		if (pbTemp<pbEnd)
		{
			if (isWapEndOfStringCh(*pbTemp))
			{
				pbTemp++;
				*ppbStart=pbTemp;
				return TRUE;
			}
		}
	}
	return FALSE;
}

/* <Octet 34> *TEXT End-of-string */
BOOL isWapQuotedString(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		if (isWapQuoteCh(*pbTemp))
		{
			pbTemp++;

			/* Check if TEXT */
			if (isWapExtensionMedia(&pbTemp,pbEnd))
			{
				*ppbStart=pbTemp;
				return TRUE;
			}
		}
	}
	return FALSE;
}

/* [quote] *TEXT End-of-string */
BOOL isWapTextString(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		/* Step past quote. */
		isWapQuote(&pbTemp,pbEnd);

		/* Check if Extension-media */
		if (isWapExtensionMedia(&pbTemp,pbEnd))
		{
			*ppbStart=pbTemp;
			return TRUE;
		}
	}
	return FALSE;
}

/* Token End-of-string */
BOOL isWapTokenText(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (isWapToken(&pbTemp,pbEnd))
	{
		/* Step past End-of-string */
		if (pbTemp<pbEnd)
		{
			if (isWapEndOfStringCh(*pbTemp))
			{
				pbTemp++;
				*ppbStart=pbTemp;
				return TRUE;
			}
		}
	}
	return FALSE;
}

/* No-Value | Token-text | Quoted-string */
BOOL isWapTextValue(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (isWapTokenText(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;
		return TRUE;
	}
	else if (isWapQuotedString(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;
		return TRUE;
	}
	else if (isWapNoValue(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;
		return TRUE;
	}
	return FALSE;
}

/* 1*2 OCTETS */
BOOL isWapQValue(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		if (*pbTemp>='\x80')
		{
			/* Two bytes */
			if (HdrNextByte(&pbTemp,pbEnd))
			{
				pbTemp++;
				*ppbStart=pbTemp;
				return TRUE;
			}
		}
		else
		{
			/* One byte */
			pbTemp++;
			*ppbStart=pbTemp;
			return TRUE;
		}
	}
	return FALSE;
}

/* Short-integer | Text-string */
BOOL isWapVersionValue(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (isWapShortInteger(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;
		return TRUE;
	}
	else if (isWapTextString(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;
		return TRUE;
	}
	return FALSE;
}

/* Integer-value | Date-value | Q-value | Version-value | Uri-value */
BOOL isWapCompactValue(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (isWapIntegerValue(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;
		return TRUE;
	}

	/* Date-value = Long-integer */
	
	else if (isWapQValue(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;
		return TRUE;
	}
	else if (isWapVersionValue(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;
		return TRUE;
	}
	/* Uri-value = Text-string */
	else if (isWapTextString(&pbTemp,pbEnd))
	{
		*ppbStart=pbTemp;