hdrutil.c

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

					{
						iPos=0;
	
						/* Get data length */
						if (ReadMBUInt32(&iLen,pbInstream,(UINT32)(pbEnd-pbInstream-1),&iPos))
						{
							pbInstream+=iPos;

							/* Store Data len */
							pMultiTemp->iBodyLen=iLen;

							/* Store pointer to header */
							pMultiTemp->pbHdrStart=pbInstream;
							pbInstream+=pMultiTemp->iHdrLen;

							/* Store pointer to data */
							pMultiTemp->pbBodyStart=pbInstream;
							pbInstream+=iLen;

							/* Check boundaries */
							if (!( ((pMultiTemp->pbHdrStart+pMultiTemp->iHdrLen-1) < pMultiTemp->pbBodyStart) &&
								 ((pMultiTemp->pbBodyStart+pMultiTemp->iBodyLen-1) < pbEnd ) ))
							{
								fError=TRUE;
							}
						}
						else 
						{
							fError=TRUE;
						}
					}
					else 
					{
						fError=TRUE;
					}
		
					if (!fError)
					{
						/* Add the multipart element to list */
						if (pMultiList==NULL)
						{
							pMultiList=pMultiTemp;
							pMultiLast=pMultiList;
						}
						else 
						{
							/* Last in the list */
							pMultiLast->pNext=pMultiTemp;
							pMultiLast=pMultiTemp;
						}
					}
					else 
					{
						DEALLOC (&pMultiTemp);	

						/* Empty list and return NULL */
						while (pMultiList!=NULL)
						{
							pMultiTemp=pMultiList;
							pMultiList=pMultiList->pNext;
							DEALLOC (&pMultiTemp);	
						}
						return NULL;
					}
				}
				else 
				{
					fError=TRUE;
				}

				iCount++;
			}
		}
	}
	return pMultiList;
}



/*========================================================================
	WSP_DeleteMultipartList
==========================================================================*/
void WSP_DeleteMultipartList (pMULTIPARTSTR* ppList)
{
	pMULTIPARTSTR pTemp=NULL;

	if (ppList!=NULL)
	{
		while (*ppList!=NULL)
		{
			pTemp=*ppList;
			*ppList=(*ppList)->pNext;
			DEALLOC(&pTemp);			
		}
	}
}


/*========================================================================
	WSP_DeleteMultipartListWithContent
==========================================================================*/
void WSP_DeleteMultipartListWithContent (pMULTIPARTSTR* ppList)
{
	pMULTIPARTSTR pTemp=NULL;

	if (ppList!=NULL)
	{
		while (*ppList!=NULL)
		{
			pTemp=*ppList;
			*ppList=(*ppList)->pNext;

			/* Delete memory */
			DEALLOC(&pTemp->pbHdrStart);
			DEALLOC(&pTemp->pbBodyStart);
			DEALLOC(&pTemp);			
		}
	}
}


/*========================================================================
	WSP_MultipartAddPart
==========================================================================*/
void WSP_MultipartAddPart (pMULTIPARTSTR* ppList, BYTE** ppbHeader, 
						   BYTE** ppbData, UINT32 iHeaderLen, UINT32 iDataLen)
{
	pMULTIPARTSTR pNew=NEWSTRUCT(MULTIPARTSTR);
	pMULTIPARTSTR pTemp;

	/* ASSERT: ppList!=NULL
			   ppbHeader!=NULL
			   ppbData!=NULL
	*/

	if (pNew!=NULL)
	{
		/* Store values in multipart struct */
		pNew->pbHdrStart=*ppbHeader;
		pNew->iHdrLen=iHeaderLen;
		pNew->pbBodyStart=*ppbData;
		pNew->iBodyLen=iDataLen;
		pNew->pNext=NULL;
		
		/* Store struct last in list */
		pTemp=*ppList;

		if (pTemp==NULL)
		{
			/* First element in list */
			*ppList=pNew;
		}
		else
		{
			/* Find last element */
			while (pTemp->pNext!=NULL)
			{
				pTemp=pTemp->pNext;
			}

			pTemp->pNext=pNew;
		}

		/* Set inparameters to point to NULL */
		*ppbHeader=NULL;
		*ppbData=NULL;
	}
}


/*========================================================================
	WSP_BuildMultipart
==========================================================================*/
BOOL WSP_BuildMultipart (pMULTIPARTSTR* ppList, BYTE** ppbContentData,
						 UINT32* piDataLen, UINT32 iTotalSize)
{
	/* Check inparameters */
	if ((ppList!=NULL)&&(ppbContentData!=NULL)&&(piDataLen!=NULL))
	{
		pMULTIPARTSTR pTemp=*ppList;
		UINT32 iSize=0;
		UINT32 iNbrOfParts=0;
		BYTE* pbTemp;

		/* Calculate size for multipart content */
		while (pTemp!=NULL)
		{
			iNbrOfParts++;

			/* Add space for lengths */
			iSize += UintvarLen(pTemp->iHdrLen);
			if (iTotalSize>(pTemp->iBodyLen))
				iSize += UintvarLen(iTotalSize);
			else
				iSize += UintvarLen(pTemp->iBodyLen);

			/* Add size of part */
			iSize += pTemp->iHdrLen;
			iSize += pTemp->iBodyLen;			

			/* Next part */
			pTemp=pTemp->pNext;	
		}

		/* Add space for number of entries (uintvar) */
		iSize+=UintvarLen (iNbrOfParts);

		if (iSize>0)
		{
			/* Allocate memory */
			*ppbContentData=NEWARRAY(BYTE,iSize);
			pbTemp=*ppbContentData;

			if (*ppbContentData==NULL)
			{
				/* Could not allocate memory */
				return FALSE;
			}

			/* Store size */
			*piDataLen=iSize;

			/* Store number of entries in multipart data */
			pbTemp+=IntToUintvar (iNbrOfParts, pbTemp);

			pTemp=*ppList;

			/* Store the parts */
			while (pTemp!=NULL)
			{
				/* Store header size */
				pbTemp+=IntToUintvar (pTemp->iHdrLen, pbTemp);

				/* Store data size */
				if (iTotalSize>(pTemp->iBodyLen))
					pbTemp+=IntToUintvar (iTotalSize, pbTemp);
				else
					pbTemp+=IntToUintvar (pTemp->iBodyLen, pbTemp);

				/* Copy header data */
				B_COPYSTRINGN (pbTemp,pTemp->pbHdrStart,pTemp->iHdrLen);
				pbTemp+=pTemp->iHdrLen;

				/* Copy body data */
				B_COPYSTRINGN (pbTemp,pTemp->pbBodyStart,pTemp->iBodyLen);
				pbTemp+=pTemp->iBodyLen;

				/* Get next part */
				pTemp=pTemp->pNext;
			}

			/* OK */
			return TRUE;
		}
	}

	return FALSE;
}




BYTE *WSP_CreateStructure (BYTE bField, UINT32 iLength, BYTE **ppbTemp)
{
	BYTE *pbHeaderString=NULL;

	pbHeaderString=NEWARRAY(BYTE,iLength);

	if (pbHeaderString!=NULL)
	{
		*ppbTemp=pbHeaderString;

		/* Add Field Name */
		*(*ppbTemp)++=(BYTE)(bField|128);

	}		
	
	return pbHeaderString;
}

void WSP_EndCreateHeader (pHEADBUILDSTR *ppList, pHEADBUILDSTR pHead, UINT32 iLength)
{
	pHead->iLength=iLength;
	pHead->pNext=NULL;

	/* Addto the end of the list */
	if (*ppList!=NULL)
	{
		(*ppList)->pNext=pHead;
	}

	/* Update ppList */
	*ppList=pHead;
}


/*	
	THE pbContentType PARAMETER IS USED IF IT IS NOT NULL. OTHERWISE
	THE bContentType PARAMETER IS USED. IF THE fUseParams is TRUE, 
	A PARAMETER IS ADDED (only charset is used at the moment).

	Content-type-value = Constrained-media | Content-general-form

	Content-general-form = Value-length Media-type
	Media-type = (Well-known-media | Extension-media) *(Parameter)

	Well-known-media = Integer-value
	Extension-media = *TEXT End-of-string

    Charset parameter = 0x01 (Well-known-charset)
	Well-known-charset = Integer-value
*/
pHEADBUILDSTR WSP_CreateContentTypeHeader (BYTE* pbContentType, BYTE bContentType, 
										   WSPPARAMETERS sParams, BOOL fUseParams )
{
	pHEADBUILDSTR pHead=NEWSTRUCT(HEADBUILDSTR);
	BYTE* pbHeader=NULL;
	BYTE* pbTemp=NULL;
	UINT16 iLength=0;
	UINT16 iStringLength=0;
	UINT8 iCharEncLen=0;
	INT16 iCharset=sParams.iCharset;
	BYTE tempArray[2];

	if (pHead!=NULL)
	{
		if (fUseParams)
		{
			/* Calculate length of CharEnc parameter */
			if ( iCharset >= 128 )
			{
				/* If the byte is greater or equal to x80 - encode as long 
				   integer. Add space for Short-length */
				iCharEncLen=1;

				/* Calculate number of bytes in Multi-octet-integer, one or two. */
				if( iCharset < 256 )
				{
					tempArray[0] = (BYTE) (iCharset & 0xff);
					iCharEncLen++;
				}
				else
				{
					tempArray[0] = (BYTE) ((iCharset >> 8) & 0xff);
					tempArray[1] = (BYTE) (iCharset & 0xff);
					iCharEncLen+=2;
				}
			}
			else if (iCharset > -1 )
			{
				/* One byte */
				iCharEncLen=1;
			}
			else
			{
				/* One byte */
				iCharEncLen=1;

				/* Set charset to US-ASCII */
				iCharset=IANA_CHARSET_USASCII;
			}

			/* Add space for Value-length, parameter Charset,
			   and charset integer */
			iLength+=(2+iCharEncLen);
		}

		/* Add length for content-type-value (byte or string) */
		if (pbContentType!=NULL)
		{
			/* Add room for string */
			iStringLength=B_STRINGLENGTH (pbContentType);

			iLength+=iStringLength+1;
		}
		else
		{
			iLength++;
		}

		/* Create new array */
		pbHeader=NEWARRAY(BYTE,iLength);
		pbTemp=pbHeader;

		if (pbHeader==NULL)
		{
			/* Error */
			return NULL;
		}

		if (fUseParams)
		{
			/* Add Value-length */
			*pbTemp++=(BYTE)(iLength-1);
		}

		/* Add Content-type */
		if (pbContentType!=NULL)
		{
			/* Copy string */
			B_COPYSTRING (pbTemp,pbContentType);
			pbTemp+=iStringLength+1;
		}
		else
		{
			*pbTemp++=((BYTE)( bContentType | 0x80 ));
		}

		if (fUseParams)
		{
			/* Add parameter Charset */
			*pbTemp++=(0x81);

			/* Add parameter value */
			if (iCharEncLen==1)
			{
				/* Short-integer */
				*pbTemp++=(BYTE)( ((BYTE)(iCharset)) | 0x80 );
			}
			else
			{
				/* Long-integer, add Short-length */
				*pbTemp++=(BYTE)(iCharEncLen-1);

				/* Add integer */
				B_COPYSTRINGN (pbTemp,tempArray,iCharEncLen-1);
			}
		}

		/* Store data in struct */
		pHead->pbHeader=pbHeader;
		pHead->iLength=iLength;
		pHead->pNext=NULL;
	}

	return pHead;
}


/* Create WSP header Content-Disposition : form-data; Name = pbNameData 
							OR
					 Content-Disposition : attachment [; Filename = pbNameData]

   Content-disposition-value = Value-length Disposition *(Parameter)
   Disposition = Form-data | Attachment

   Form-data  = <octet 128>
   Attachment = <octet 129>

   Name parameter		= 0x05 (Text-string)
   FileName parameter	= 0x06 (Text-string)

   e.g., AE 07 80 85 'N' 'A' 'M' 'E' 00
*/
pHEADBUILDSTR WSP_CreateContentDispositionHeader 
					(BYTE* pbNameData, BYTE bDisposition, BYTE bParameter)
{
	pHEADBUILDSTR pHead=NEWSTRUCT(HEADBUILDSTR);
	BYTE* pbHeader=NULL;
	BYTE* pbTemp=NULL;
	UINT32 iLength=0;
	UINT32 iDataLength=0;
	UINT32 iNameLength=0;
	UINT8 iUintVarLen=0;

	if (pHead!=NULL)
	{
		if (pbNameData!=NULL)
		{
			/* Calculate name data length including termination char */
			iNameLength=B_STRINGLENGTH(pbNameData)+1;

			iDataLength=iNameLength;

			/* Check if quote needed */
			if (pbNameData[0]>127)
			{
				iDataLength++;
			}

			/* Add space for Disposition and parameter */
			iDataLength+=2;

			/* Calculate total length (include Content-disposition) */
			iLength=iDataLength+1;

			if (iDataLength > 30)
			{
				/* Get length of uintvar. */
				iUintVarLen = (UINT8) UintvarLen (iDataLength);

				/* Add length for bytes and Value-length (octet 31) */
				iLength += (iUintVarLen+1);
			}
			else
			{
				/* Add length for Value-length */
				iLength++;
			}
		}
		else
		{
			/* No parameter */
			iLength=2;
		}

		/* Create new array */	/*Should use Field_Content_Disposition_1_4 during some circumstances. */
		pbHeader=WSP_CreateStructure(Field_Content_Disposition,iLength,&pbTemp);

		if (pbHeader==NULL)
		{
			/* Error */
			return NULL;
		}

		/* If iLength == 2  --> No parameter */
		if (iLength != 2) 
		{
			/* Check if DATA length > 30 */
			if (iDataLength > 30)
			{
				/* Add Length-quote */
				*pbTemp++=31;

				/* Convert to uintvar. */
				(void) IntToUintvar (iDataLength, pbTemp);

				pbTemp+=iUintVarLen;
			}
			else
			{
				*pbTemp++=(BYTE)(iDataLength);
			}
		}

		/* Store Disposition */
		*pbTemp++=bDisposition;

		/* Store parameter (if any) */
		if ((pbNameData!=NULL)&&(iLength!=2))
		{
			*pbTemp++ = (BYTE)( bParameter | 0x80 );

			/* Copy data */
			B_COPYSTRINGN(pbTemp,pbNameData,iNameLength);
		}

		/* Store data in struct */
		pHead->pbHeader=pbHeader;
		pHead->iLength=iLength;
		pHead->pNext=NULL;
	}

	return pHead;
}


/*========================================================================
	WAE_AddTextFormDataPart
==========================================================================*/
/*  Modified by GBU,000510, use type
void WAE_AddTextFormDataPart (void** ppMultiPartList, BYTE* pbNameData,  
							  BYTE** ppbValueData, UINT32 iValueLen, INT16 iCharEnc)
*/
void WAE_AddTextFormDataPart (pMULTIPARTSTR* ppMultiPartList, BYTE* pbNameData,  
                              BYTE** ppbValueData, UINT32 iValueLen, INT16 iCharEnc)
{
	/* ASSERT: ppMultipartList!=NULL
			   ppbNameData!=NULL
			   ppbValueData!=NULL
	*/

	pHEADBUILDSTR pList=NULL;
	WSPPARAMETERS sParams;	
	BYTE* pbHeader=NULL;
	UINT32 iHeaderLen=0;

	/* Create parameter struct for WSP Content-type header */
	sParams.iCharset=iCharEnc;
	sParams.iLevel=0;
	sParams.bMPRType=0;
	sParams.pbMPRStart=NULL;
	sParams.pbMPRStartInfo=NULL;

	/* Content-type : text/plain with charset as indicated by the parameter 
	  (iCharEnc). "Charset is required when the content contains 
	  characters not in the US-ASCII characer set" (WML 9.5.1) */

	/* Create WSP header Content-type : text/plain; charset = iCharEnc */
	pList=WSP_CreateContentTypeHeader (NULL,0x03,sParams,TRUE);

	if (pList!=NULL)
	{
		/* Create WSP header Content-Disposition : form-data; name = pbNameData */
		pList->pNext=WSP_CreateContentDispositionHeader (pbNameData,128,5);

		/* Build header */
		pbHeader=WSP_BuildHeader(pList,&iHeaderLen);

		/* Add multipart record */
/*  Modified by GBU.000510, removed cast
		WSP_MultipartAddPart ((pMULTIPARTSTR*)ppMultiPartList,&pbHeader,
							   ppbValueData,iHeaderLen,iValueLen);
*/
        WSP_MultipartAddPart (ppMultiPartList,&pbHeader,
                              ppbValueData,iHeaderLen,iValueLen);

	}

	/* Deallocate ppbValueData (if not already done) */
	DEALLOC (ppbValueData);
}


/*  Modified by GBU,000510, use type
void WAE_AddGenericFormDataPart (void** ppMultiPartHandle, BYTE** ppbData, UINT16 iDataLen, 
								 BYTE* pbContentType, BYTE* pbContentDispositionFileName)
*/
void WAE_AddGenericFormDataPart (pMULTIPARTSTR* ppMultiPartHandle, BYTE** ppbData, UINT16 iDataLen,
                                 BYTE* pbContentType, BYTE* pbContentDispositionFileName)
{
	/* ASSERT: ppMultipartHandle!=NULL
	*/

	pHEADBUILDSTR pList=NULL;