// Copyright (c) 2003-2010 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "CLWSPPduHandlerTraces.h"
#endif

#include "CLWSPPduHandler.h"
#include "wapmsgerr.h"

void CCLWSPPduHandler::UnpackWSPPduL(HBufC8* aWSPPdu, TWSPPduType& aType, HBufC8*& aWSPHeader, HBufC8*& aBody, TUint8& aId, TWSPStatus& aStatus)
/** 
Unpack the received WSP PDU from remote peer to several data structure expected by the client.
@internalComponent
@released 
@since v8.0 
@param aWSPPdu the received WSP PDU from the remote peer. 
@param aType the type of the received WSP PDU.
@param aWSPHeader the WSP header of the received WSP PDU.
@param aBody the data body of the received WSP PDU.
@param aId the transaction ID or Push ID of the received WSP PDU.
@param aStatus the WSP status of the received WSP PDU.
@returns TInt KErrNone on successful completion, or one of the system error codes on failure.
*/
	{
	TPtr8 des=aWSPPdu->Des();
	if(des.Length() < KPDUTransactionIDAndPDUTypeLength)
	{
        OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CCLWSPPDUHANDLER_UNPACKWSPPDUL_1, "CCLWSPPduHandler::UnpackWSPPduL() Corrupted InComing Wsp PDU");
        User::Leave(KErrCorrupt);
	}
	aId=des[KPDUHeaderTransactionIDOffSet];
	aType=TWSPPduType(des[KPDUHeaderWSPPDUTypeOffSet]);
	switch (aType)
		{
	case EReply:
		UnpackReplyPduL(aWSPPdu, aWSPHeader, aBody, aStatus);
		break;
	case EPush:
		UnpackPushPduL(aWSPPdu, aWSPHeader, aBody);
		break;
	default:
		OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CCLWSPPDUHANDLER_UNPACKWSPPDUL_2, "CCLWSPPduHandler::UnpackWSPPduL() Unknown InComing Wsp PDU Type");
		User::Leave(KErrCorrupt);
		}
	}

void CCLWSPPduHandler::PackWSPPduL(HBufC8*& aWSPPdu, TWSPPduType aType, const TDesC& aURI, const TDesC8& aWSPHeader, const TDesC8& aBody, const TUint8 aId)
/** 
Pack the information to be sent into WSP PDU.
@internalComponent
@released 
@since v8.0 
@param aWSPPdu the WSP PDU that is to sent 
@param aType the WSP PDU type(the method is to be invoked) 
@param aURI  the URI where the WSP PDU goes
@param aWSPHeader the WSP header
@param aBody the data body
@param aId the transaction ID
@returns TInt KErrNone on successful completion, or one of the system error codes on failure.
*/
	{
	switch (aType)
		{
	case EGet:
	case EGetOptions:
	case EGetHead:
	case EGetDelete:
	case EGetTrace:
		PackGetPduL(aWSPPdu, aType, aURI, aWSPHeader, aId);
		break;
	
	case EPost:
	case EPostPut:
		PackPostPduL(aWSPPdu, aType, aURI, aWSPHeader, aBody, aId);
		break;

	default:
	    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CCLWSPPDUHANDLER_PACKWSPPDUL_1, "CCLWSPPduHandler::PackWSPPduL() Unknown Method Invoke Wsp PDU Type");
	    User::Leave(Wap::EWspClParameterError);
		}
	}

void CCLWSPPduHandler::UnpackPushPduL(HBufC8* aWSPPdu, HBufC8*& aWSPHeader, HBufC8*& aBody)
/**
Unpack the WSP PUSH PDU.
@internalComponent
@released 
@since v8.0 
@param aWSPPdu the received WSP PDU from the remote peer. 
@param aWSPHeader the WSP header of the received WSP PDU.
@param aBody the data body of the received WSP PDU.
@returns TInt KErrNone on successful completion, or one of the system error codes on failure.
*/
	{
	TPtrC8 pduBuffer(*aWSPPdu);
	TUint32 pduLength=pduBuffer.Length();
	TUint32 headerLength(0);
	TInt uintvarLength(0);

	// if uintvarLength less than KErrNone, then it is a error code.
	if ((uintvarLength=UintVar(headerLength, pduBuffer, KPDUTransactionIDAndPDUTypeLength))<KErrNone)
		{
		User::Leave(uintvarLength);
		}
 	TInt32 bodyLength= pduLength-KPDUTransactionIDAndPDUTypeLength-uintvarLength-headerLength;
	if (bodyLength<0)
		{
		User::Leave(KErrCorrupt);
		}
	// Extract the WSP Header.
	aWSPHeader=HBufC8::NewL(headerLength);
	TPtr8 headerDes=aWSPHeader->Des();
	headerDes.Copy(pduBuffer.Mid(KPDUTransactionIDAndPDUTypeLength+uintvarLength, headerLength));
	// Extract the WSP data body.
	aBody=HBufC8::NewL(bodyLength);
	TPtr8 bodyDes=aBody->Des();
	bodyDes.Copy(pduBuffer.Mid(KPDUTransactionIDAndPDUTypeLength+uintvarLength+headerLength));
	}

void CCLWSPPduHandler::UnpackReplyPduL(HBufC8* aWSPPdu, HBufC8*& aWSPHeader, HBufC8*& aBody, TWSPStatus& aStatus)
/**
Unpack the WSP Reply PDU.
@internalComponent
@released 
@since v8.0 
@param aWSPPdu the received WSP PDU from the remote peer. 
@param aWSPHeader the WSP header of the received WSP PDU.
@param aBody the data body of the received WSP PDU.
@param aStatus the WSP status of the received WSP PDU.  
@returns TInt KErrNone on successful completion, or one of the system error codes on failure.
*/
	{
	TPtrC8 pduBuffer(*aWSPPdu);
	TUint32 pduLength=pduBuffer.Length();

	//Extract the WSP status
	aStatus=pduBuffer[KPDUTransactionIDAndPDUTypeLength];

	TUint32 headerLength(0);
	TInt uintvarLength(0);
	// if uintvarLength less than KErrNone, then it is a error code.
	if ((uintvarLength=UintVar(headerLength, pduBuffer, KPDUTransactionIDAndPDUTypeLength+KWSPStatusLength))<KErrNone)
		{
		User::Leave(uintvarLength);
		}
		
	TInt32 bodyLength= pduLength-KPDUTransactionIDAndPDUTypeLength-KWSPStatusLength-uintvarLength-headerLength;
	if (bodyLength<0)
		{
		User::Leave(KErrCorrupt);
		}
		
	// Extract the WSP Header.
	aWSPHeader=HBufC8::NewL(headerLength);
	TPtr8 headerDes=aWSPHeader->Des();
	headerDes.Copy(pduBuffer.Mid(KPDUTransactionIDAndPDUTypeLength+KWSPStatusLength+uintvarLength, headerLength));

	// Extract the WSP data body.
	aBody=HBufC8::NewL(bodyLength);
	TPtr8 bodyDes=aBody->Des();
	bodyDes.Copy(pduBuffer.Mid(KPDUTransactionIDAndPDUTypeLength+KWSPStatusLength+uintvarLength+headerLength));
	}

void CCLWSPPduHandler::PackPostPduL(HBufC8*& aWSPPdu, TWSPPduType aType, const TDesC& aURI, const TDesC8& aWSPHeader, const TDesC8& aBody, const TUint8 aId)
/** 
Pack the WSP Post PDU.
@internalComponent
@released 
@since v8.0 
@param aWSPPdu the WSP PDU that is to sent 
@param aType the WSP PDU type(the method is to be invoked) 
@param aURI the URI where the WSP PDU goes
@param aWSPHeader the WSP header
@param aBody the data body
@param aId the transaction ID
@returns TInt KErrNone on successful completion, or one of the system error codes on failure.
*/
	{
	//Convert the URI length to Varible length unsigned integer
	TUint32 uriLength=aURI.Length();
	HBufC8* uriLengthDes=UintVarL(uriLength);

	//Convert the URI length to Varible length unsigned integer
	TUint32 headerLength=aWSPHeader.Length();
	HBufC8* headerLengthDes=UintVarL(headerLength);

	// Calculate the pdu length
	TUint32 pduLength = KPDUTransactionIDAndPDUTypeLength+
						uriLengthDes->Length()+
						headerLengthDes->Length()+
						uriLength+
						headerLength+
						aBody.Length();

	//Build the PDU.
	aWSPPdu = HBufC8::NewL(pduLength);
	TPtr8 pduPtr(aWSPPdu->Des());
	pduPtr.Append(aId);
	pduPtr.Append(aType);
	pduPtr.Append(*uriLengthDes);
	pduPtr.Append(*headerLengthDes);
	pduPtr.Append(aURI);
	pduPtr.Append(aWSPHeader);
	pduPtr.Append(aBody);

	// delete the temporary buffers
	delete uriLengthDes;
	delete headerLengthDes;
	}
void CCLWSPPduHandler::PackGetPduL(HBufC8*& aWSPPdu, TWSPPduType aType, const TDesC& aURI, const TDesC8& aWSPHeader, const TUint8 aId)
/** 
Pack the WSP Get PDU.
@internalComponent
@released 
@since v8.0 
@param aWSPPdu the WSP PDU that is to sent 
@param aType the WSP PDU type(the method is to be invoked) 
@param aURI the URI where the WSP PDU goes
@param aWSPHeader the WSP header
@param aId the transaction ID
@returns KErrNone on successful completion, or one of the system error codes on failure.
*/
	{

	//Convert the URI length to Varible length unsigned integer
	TUint32 uriLength=aURI.Length();
	HBufC8* uriLengthDes=UintVarL(uriLength);

	// Calculate the pdu length
	TUint32 pduLength =	KPDUTransactionIDAndPDUTypeLength+
						uriLengthDes->Length()+
						uriLength+
						aWSPHeader.Length();

	// Build the PDU.
	aWSPPdu = HBufC8::NewL(pduLength);
	TPtr8 pduPtr(aWSPPdu->Des());
	pduPtr.Append(aId);
	pduPtr.Append(aType);
	pduPtr.Append(*uriLengthDes);
	pduPtr.Append(aURI);
	pduPtr.Append(aWSPHeader);
	
	//Delete the temporary buffer
	delete uriLengthDes;
	}
TInt CCLWSPPduHandler::UintVar(TUint32& aVal, TPtrC8& aBuffer, TUint aOffset)
/** 
Decode the variable length Unsigned integer to TUint32
@internalComponent
@released 
@since v8.0 
@param aVal the value of the variable length Unsigned integer
@param aBuffer the descriptor that contains the variable length Unsigned integer
@param aOffset the offset of the variable length Unsigned integer
@returns one of the system error codes on failure, or the size of variable length Unsigned integer.
*/
	{
	// have we run out of buffer?
	if (aOffset >= (TUint)aBuffer.Length())
		{
		return KErrCorrupt;
		}
		
	// maximum length for a uintvar is 5
	TInt lenLeft = Min(aBuffer.Mid(aOffset).Length(), KMaxUintVarLength);

	// get the first octet
	TUint8 byte = aBuffer[aOffset++];
	TInt numBytes = 1;
	--lenLeft;

	// Check if any of the top 3 bits, ignoring the very top 'continue' bit, are set.  
	// Later if we see that this is a 5 byte number - we'll know it is corrupt.  
	// Encoding uses 7 bits/number 7x5=35 and we only support a maxiumum number 
	// of 32 bits.
	TBool topThreeBitsSet = byte & KTop3BitSet; 

	// copy over data from the byte into our return value (the top bit is a carry bit)
	aVal = byte & KWapQuote;

	// while the 'continue' bit is set and we have more data
	while ((byte & KCarryBitMask) && (lenLeft > 0))
		{
		// shift our last value up
		aVal <<= KUIntVarOctetShift;
		// get the next byte
		byte = aBuffer[aOffset++];
		// copy it over to the lowest byte
		aVal |= byte & KWapQuote;
		--lenLeft;
		++numBytes;
		} 

	// last octet has continue bit set ... NOT allowed Or
	// this was encoded wrong - can't have a number bigger than 32 bits
	if ((byte & KCarryBitMask) || (numBytes == 5 && topThreeBitsSet))
		{
		return KErrCorrupt;
		}
	// number of bytes read
	return numBytes;

	}

HBufC8* CCLWSPPduHandler::UintVarL(const TUint32 aInt)
/** 
Encode the TUint32 to the variable length Unsigned integer
@internalComponent
@released 
@since v8.0 
@param aInt the length of the data
@returns the descriptor that contains the variable length Unsigned integer
*/
	{
	TUint8 size = 0; // maximum value is 5 with a 32bit integer
	TUint32 value=aInt;
	do {
		++size;
		value >>=KUIntVarOctetShift; ; // shift by 7 bits.
		} while (value>0);

	HBufC8* output = HBufC8::NewL(size);
	TPtr8 outPtr(output->Des());

	TInt ii = size; 
	while (--ii > 0)
		{
		outPtr.Append( (TUint8)(aInt>>(KUIntVarOctetShift*(ii))  & KWapQuote) | KCarryBitMask); 
		} 

	// Finally the first 7 bits, last octet, do not set first bit.
	outPtr.Append( (TUint8)(aInt & KWapQuote) ); // Add even if 0 value.

	return output;
	}