hdrutil.c

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

		return TRUE;
	}
	return FALSE;
}

/* Compact-value | Text-value */
BOOL isWapTypedValue(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

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

/* Integer-value | Text-value */
BOOL isWapUnTypedValue(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

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

/* OCTET (1xxx xxxx) */
BOOL isWapShortInteger(BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;	

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

/* <ANY OCTET 0-30> 1*30 OCTET */
BOOL isWapLongInteger (BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;
	BYTE bLength=0;
	UINT32 iCount=0;
	
	if (pbTemp<pbEnd)
	{
		bLength=*pbTemp;
		
		if (isWapShortLength(&pbTemp,pbEnd))
		{
			for (iCount=0; iCount<bLength; iCount++)
			{
				if (!(pbTemp++<pbEnd))
				{
					/* Error - return FALSE */
					return FALSE;
				}
			}

			/* OK! */
			*ppbStart=pbTemp;
			return TRUE;
		}
	}
	return FALSE;
}

/* Short-integer | Long-integer */
BOOL isWapIntegerValue (BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;	

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

/* Short-length | (Length-quote Length) */
BOOL isWapValueLength (BYTE **ppbStart, BYTE *pbEnd)
{
	UINT32 iPos=0;
	UINT32 iResult=0;
	BYTE *pbTemp=*ppbStart;
	
	if (pbTemp<pbEnd)
	{
		if (isWapShortLengthCh(*pbTemp))
		{
			pbTemp++;
			*ppbStart=pbTemp;
			return TRUE;
		}
		else if (isWapLengthQuoteCh(*pbTemp))
		{
			pbTemp++;

			if (ReadMBUInt32(&iResult,pbTemp,(UINT32)(pbEnd-pbTemp),&iPos))
			{
				pbTemp+=iPos;

				*ppbStart=pbTemp;
				return TRUE;
			}
		}
	}
	return FALSE;
}

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

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

/* <Any OCTET 1-31> */
BOOL isWapShortCutShiftDel (BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

	if (pbTemp<pbEnd)
	{
		if ((*pbTemp>=1)&&(*pbTemp<=31))
		{
			pbTemp++;
			*ppbStart=pbTemp;
			return TRUE;	
		}
	}
	return FALSE;
}

/* ------------ AUTHORIZATION RULES ------------ */

/* Token-text */
BOOL isWapAuthenticationScheme (BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;	

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

/* <OCTET 128> */
BOOL isWapBasic (BYTE **ppbStart, BYTE *pbEnd)
{
	BYTE *pbTemp=*ppbStart;

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

/* --------------------------------------------- */

void WSP_EmptyHeaderList (pHEADERDEF pDef)
{
	pHEADERELEMENT pTemp;

	if (pDef!=NULL)
	{
		if (pDef->pHeadList!=NULL) 
		{
			/* First element */
			pTemp=pDef->pHeadList;

			while (pDef->pHeadList!=NULL)
			{
				pDef->pHeadList=pDef->pHeadList->pNext;

				/* Check if in original instream or if the 
				   header is added in the client, i.e., if
				   the pTemp->end < start or pTemp->Start 
				   >= end. */

				/* pTemp never NULL */
				if ((pTemp->pbFieldValStart>pDef->pbEnd) ||
					(pTemp->pbFieldValEnd<pDef->pbData))
				{
					/* This block is added in the client! - DEALLOC */
					DEALLOC(&pTemp->pbFieldValStart);
				}

				DEALLOC(&pTemp);
				pTemp=pDef->pHeadList;
			}
		}
	}
}


/*========================================================================
	WSP_DeleteParameters 
==========================================================================*/
void WSP_DeleteParameters (pWSPPARAMETERS* ppParameters)
{
	if ((ppParameters!=NULL)&&(*ppParameters!=NULL))
	{
		/* Delete struct */
		DEALLOC(ppParameters);
	}
}


pHEADERDEF WSP_PreParseHeaders (BYTE *pbInstream, INT32 iLength, BOOL *fError) 
{
	pHEADERDEF pDef;
	pHEADERELEMENT pHead;
	BYTE *pbToken;
	BYTE *pbInstreamCopy=NULL;

	BYTE *pbTemp=NULL;
	BYTE *pbEnd=NULL;
	BYTE bCurrentCodePage=0;
	
	/* ASSERT:	pbInstream!=NULL
	*/

	/* Copy byte data */
	pbInstreamCopy=B_CopyByteString(pbInstream, iLength);
		
	if (pbInstreamCopy!=NULL)
	{	
		/* Init variables */
		pDef=CreateHEADERDEF(pbInstreamCopy, iLength);
		pbTemp=pbInstreamCopy;
		pbEnd=pbInstreamCopy+iLength;
		bCurrentCodePage=1;

		if (pDef!=NULL)
		{
			if (pbTemp<pbEnd)
			{
				/* Content-Type always the first header */
				pHead=CreateHeaderElement (bCurrentCodePage, Field_Content_Type | 0x80, 
												NULL, pbTemp, pbEnd);
				if (pHead!=NULL)
				{
					AddHeaderElement(pDef,pHead);

					if (StepFieldLength(&pbTemp,pbEnd))
					{
						/* Set FieldValEnd in pHead */
						pHead->pbFieldValEnd=pbTemp;
					}
					else 
					{
						pHead->pbFieldValEnd=pbEnd;
						*fError=TRUE;
					}
				}
				else
				{
					/* Out of memory */
					*fError=TRUE;
				}	
			}

			/* Parse all header fields. */
			while ((pbTemp<pbEnd)&&!(*fError)) 
			{
				/* Pointer to current byte */
				pbToken=pbTemp;
	
				/* Check if Shift-delimeter */
				if (isWapShiftDel(&pbTemp, pbEnd)) 
				{
					if (pbTemp<pbEnd)
					{
						/* Set the new code page */
						bCurrentCodePage=*pbTemp;
					}
					else
					{
						*fError=TRUE;
					}
				}
					
				/* Check if Short-cut-shift-delimeter */
				else if (isWapShortCutShiftDel(&pbTemp, pbEnd))
				{
					/* Set the new code page */
					bCurrentCodePage=*pbToken;
				}
					
				/* Check if Well-known-field-name */
				else if (isWapShortInteger(&pbTemp, pbEnd))
				{
					pHead=CreateHeaderElement (bCurrentCodePage, *pbToken,
												NULL, pbTemp, pbEnd);
					if (pHead!=NULL)
					{
						AddHeaderElement(pDef,pHead);

						if (StepFieldLength(&pbTemp,pbEnd))
						{
							/* Set FieldValEnd in pHead */
							pHead->pbFieldValEnd=pbTemp;
						}
						else 
						{
							*fError=TRUE;
						}
					}
					else
					{
						/* Out of memory */
						*fError=TRUE;
					}
				}
					
				/* Check if Token-Text */
				else if (isWapTokenText(&pbTemp, pbEnd))
				{
					pHead=CreateHeaderElement (0, 0, pbToken, pbTemp, pbEnd);
					if (pHead!=NULL)
					{
						AddHeaderElement(pDef,pHead);
						if (StepFieldLength(&pbTemp,pbEnd))
						{
							/* Set FieldValEnd in pHead */
							pHead->pbFieldValEnd=pbTemp;
						}
						else 
						{
							*fError=TRUE;
						}
					}
				}
				else 
				{
					*fError=TRUE;
				}				
			}
			return pDef;
		}
	}

	/* Could not create HEADERDEF */
	*fError=TRUE;
	return NULL;
}


pHEADERELEMENT WSP_GetHeaderWK (BYTE bCodePage, BYTE bByte, 
							pHEADERELEMENT pFirstElm)
{
	while (pFirstElm!=NULL)
	{
		if ((bCodePage==pFirstElm->bCodePage)&&
				(bByte==((pFirstElm->bFieldName)&(127))))
		{
			return pFirstElm;
		}
		else
		{
			pFirstElm=pFirstElm->pNext;
		}
	}
	return NULL;
}

pHEADERELEMENT WSP_GetHeaderTT (BYTE *pbTokenText, pHEADERELEMENT pFirstElm)
{
	BYTE *pbTemp;
	BYTE *pbTestText;
	BOOL fTest=TRUE;

	while (pFirstElm!=NULL)
	{
		if (pFirstElm->pbFieldName!=NULL)
		{
			pbTemp=pFirstElm->pbFieldName;
			pbTestText=pbTokenText;

			/* Compare the strings. */
			while ((*pbTestText!='\x0')&&(fTest))
			{
				fTest=FALSE;
				if (*pbTemp!='\x0')
				{
					if (*pbTemp==*pbTestText)
					{
						fTest=TRUE;
				
						/* Increase pbTemp */
						if (pbTemp<pFirstElm->pbFieldValEnd)
						{
							pbTemp++;
						}
						else 
						{
							fTest=FALSE;
						}
					}
				}
				/* Increase pbTestText */
				pbTestText++;
			}
			if (fTest)
			{
				/* Check if both strings terminated */
				if ((*pbTestText==0)&&(*pbTemp==0))
				{
					return pFirstElm;
				}
			}
		}
		pFirstElm=pFirstElm->pNext;
	}
	return NULL;
}

BYTE WSP_GetShortInt (BYTE bShortInt)
{
	return (BYTE)((bShortInt)&('\x7F'));
}

UINT32 WSP_GetLongInteger (BYTE **ppbStart, BYTE *pbEnd, BOOL *pfError)
{
	UINT32 iResult=0;
	BYTE bLength=0;
	BYTE *pbValue=NULL;
	BYTE *pbTemp=NULL;
	INT8 i = 0;
	UINT32 t;

	if (*ppbStart<pbEnd)
	{
		pbValue=*ppbStart;
		pbTemp=*ppbStart;
		bLength=*pbValue;

		/* Check if Long-integer */
		if (isWapLongInteger(&pbTemp,pbEnd))
		{
			pbValue++;

			/* Get Long-integer length (maximum 4 bytes) Big-endian. */
			if (bLength>4)
			{
				bLength=4;
			}

			for (i = 0; i < bLength; i++)
			{
				t = pbValue[i];
				t = t << ((bLength -1 - i) * 8);
				iResult |= t;
			}

			/* Step past integer data */
			*ppbStart=pbTemp;
		}
	}
	else 
	{
		*pfError=TRUE;
	}
	return iResult;
}


UINT32 WSP_GetInteger (BYTE **ppbStart, BYTE *pbEnd, BOOL *pfError)
{
	BYTE *pbTemp=NULL;
	UINT32 iInteger=0;

	if (*ppbStart<pbEnd)
	{
		pbTemp=*ppbStart;

		/* Get typed value */
		if (isWapShortInteger(&pbTemp,pbEnd))
		{
			iInteger=WSP_GetShortInt(**ppbStart);
		}
		else if (isWapLongInteger(&pbTemp,pbEnd))
		{
			/* Long-integer-value */
			iInteger=WSP_GetLongInteger (ppbStart,pbEnd,pfError);
		}
		else
		{
			/* Error */
			*pfError=TRUE;
		}
	}
	else
	{
		/* Error */
		*pfError=TRUE;
	}

	return iInteger;
}


BYTE* WSP_GetTextString (BYTE **ppbStart, BYTE *pbEnd, BOOL *pfError)
{
	BYTE* pbValue=*ppbStart;
	
	/* Step past Quote if found. */
	isWapQuote(&pbValue,pbEnd);
	
	/* Check if valid Text-string */
	if (isWapTextString(ppbStart,pbEnd))
	{
		/* OK - Return text */
		*pfError=FALSE;
		return pbValue;
	}
	
	*pfError=TRUE;
	return NULL;
}


/* --------------------------------------------------------------------
	Descr : The function creates a WSPPARAMETERS struct and stores the 
			found parameters in the struct. Only Well-Known parameters
			are considered (table 38 is WSP)

			Supported parameters are:

			Level, Charset, Type (Multipart/Related), Start, Start-info,
			SEC and MAC
   -------------------------------------------------------------------- */
void WSP_GetParameters (BYTE *pbStart, BYTE *pbEnd, BOOL *fError, 
								   pWSPPARAMETERS* ppParameters)
{
	BYTE bParam=0;
	BYTE *pbValue=pbStart;
	BYTE *pbTemp=NULL;
	pWSPPARAMETERS pParams=NULL;

	/* Create new parameter struct */
	pParams=NEWSTRUCT(WSPPARAMETERS);
	
	if (pParams==NULL)
	{
		/* Error */
		*fError=TRUE;
		return;
	}
	pParams->iSEC = 255;
	pParams->pbMAC = NULL;

	/* Get all parameters (only if general form - fParameter TRUE)*/
	while ((pbValue<pbEnd)&&(!*fError))
	{		
		bParam=*pbValue;

		if (isWapShortInteger(&pbValue,pbEnd))
		{
			/* Well known parameter (Short-integer) */
			bParam=WSP_GetShortInt(bParam);
			
			/* If Well-known-charset */
			if (bParam==1)
			{
				/* Get charset value (Integer-value) */
				pParams->iCharset=(INT16)(WSP_GetInteger (&pbValue,pbEnd,fError));
			}

			/* Well-known-level*/
			else if (bParam==2)
			{
				pbTemp=pbValue;

				/* Get level value (only integer is used) */
				if (isWapIntegerValue(&pbTemp,pbEnd))
				{
					pParams->iLevel=(BYTE)(WSP_GetInteger (&pbValue,pbEnd,fError));
				}
				else if (isWapTextString(&pbValue,pbEnd))