/*

* Copyright (c) 2002-2005 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:   Class for handling SUPL_END message.

*

*/

#include <hash.h>

#include "epos_comasuplend.h"

#include "lbs/epos_comasuplposition.h"

#include "lbs/epos_eomasuplposerrors.h"

#include "lbs/epos_comasuplvelocity.h"

#include "epos_comasupltrace.h"

#include "epos_comasuplendstate.h"

#include "epos_omasuplconstants.h"

#include "epos_comasuplasnbase.h"

_LIT(KTraceFileName,"SUPL_OMA_SESSION::EPos_COMASuplEndState.cpp");

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// COMASuplEndState::COMASuplEndState

// C++ constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

COMASuplEndState::COMASuplEndState(COMASuplEnd::TOMASuplStatusCode aStatusCode,COMASuplAsnHandlerBase* aOMASuplAsnHandlerBase):

																	 iOMASuplAsnHandlerBase(aOMASuplAsnHandlerBase)

    {

			iMessageTimeOut = 0; 

			iCurrentState = ESUPL_END;   

			iStatusCode = aStatusCode;

			iSetStatusCode = ETrue;

    }

// -----------------------------------------------------------------------------

// COMASuplEndState::COMASuplEndState

// C++ constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

COMASuplEndState::COMASuplEndState(COMASuplAsnHandlerBase* aOMASuplAsnHandlerBase):iOMASuplAsnHandlerBase(aOMASuplAsnHandlerBase)

    {

			iMessageTimeOut = 0; 

			iCurrentState = ESUPL_END; 

			iSetStatusCode = EFalse;  

    } 

// -----------------------------------------------------------------------------

// COMASuplEndState::~COMASuplEndState

// -----------------------------------------------------------------------------

//

COMASuplEndState::~COMASuplEndState()

    {

    	delete iHSLPAddress;

    	delete iEncodedSuplInit;

    }

// -----------------------------------------------------------------------------

// COMASuplEndState::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void COMASuplEndState::ConstructL(HBufC8* aEncodedSuplInit, HBufC8* aHSLPAddress)

    {

    	COMASuplState::BaseConstructL();

    	iTrace->Trace(_L("COMASuplEndState::ConstructL..."), KTraceFileName, __LINE__); 							

		if(aEncodedSuplInit)    	

		{

	    	TInt len = aEncodedSuplInit->Length();

	    	if(len > 0)

	    	{

	    		iEncodedSuplInit = HBufC8::NewL(len);

	    		*iEncodedSuplInit = *aEncodedSuplInit;

	       	}

		}

    	if(aHSLPAddress)	

    	{

	    	TInt len = aHSLPAddress->Length();

	    	if(len > 0)

	    	{

			   	iHSLPAddress = HBufC8::NewL(len);

			  	*iHSLPAddress = *aHSLPAddress;

	    	}

    	}

    }

// -----------------------------------------------------------------------------

// COMASuplEndState::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

COMASuplEndState* COMASuplEndState::NewL(COMASuplEnd::TOMASuplStatusCode aStatusCode,COMASuplAsnHandlerBase* aOMASuplAsnHandlerBase,

										 HBufC8* aEncodedSuplInit,

										 HBufC8* aHSLPAddress)

    {

	    COMASuplEndState* self =  new ( ELeave ) COMASuplEndState(aStatusCode,aOMASuplAsnHandlerBase);

	    CleanupStack::PushL( self );

	    self->ConstructL(aEncodedSuplInit, aHSLPAddress);

	    CleanupStack::Pop(self);

	    return self;

    }

// -----------------------------------------------------------------------------

// COMASuplEndState::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

COMASuplEndState* COMASuplEndState::NewL(COMASuplAsnHandlerBase* aOMASuplAsnHandlerBase,HBufC8* aEncodedSuplInit, HBufC8* aHSLPAddress)

    {

	    COMASuplEndState* self =  new ( ELeave ) COMASuplEndState(aOMASuplAsnHandlerBase);

	    CleanupStack::PushL( self );

	    self->ConstructL(aEncodedSuplInit, aHSLPAddress);

	    CleanupStack::Pop(self);

	    return self;

    }

// -----------------------------------------------------------------------------

// COMASuplEndState::GenerateMessage

// Generates SUPL_END message

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt COMASuplEndState::GenerateMessageL() 

	{

		iTrace->Trace(_L("Start of COMASuplEndState::GenerateMessage"), KTraceFileName, __LINE__); 

		if(iEncodedSuplInit)

		{

			iVerPresent = ComputeSuplEndVerL();

			if(iVerPresent)

			{

				if(iMsgStateObserver)

				{

					iMsgStateObserver->OperationCompleteL(KErrNone);

					return KErrNone;

				}

			}

			else

			{

				iMsgStateObserver->OperationCompleteL(KErrGeneral);

				return KErrGeneral;

			}

		}

		else

		{

			if(iMsgStateObserver)

			{

				iMsgStateObserver->OperationCompleteL(KErrNone);

				return KErrNone;

			}

		}

		return KErrNone;		

	}

// -----------------------------------------------------------------------------

// COMASuplEndState::EncodeMessageL

// Encodes message ...returns encoded data

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

HBufC8* COMASuplEndState::EncodeMessageL(TOMASuplVersion &aSuplVersion,COMASuplSessionID* aSessionId,

										 TInt &aError)

	{

		iTrace->Trace(_L("Start of COMASuplEndState::Encode_SUPL_END"), KTraceFileName, __LINE__); 					

		COMASuplState::EncodeMessageL(aSuplVersion,aSessionId,aError);

		COMASuplAsnMessageBase* OMASuplMessageBase = iOMASuplAsnHandlerBase->CreateOMASuplMessageL(COMASuplAsnMessageBase::ESUPL_END);

		CleanupStack::PushL(OMASuplMessageBase);

		COMASuplEnd* OMASuplEnd  =  static_cast<COMASuplEnd*>(OMASuplMessageBase);

		iTrace->Trace(_L("**************** SUPL END **********************"), KTraceFileName, __LINE__);

		iTrace->Trace(_L("Created COMASuplEnd"), KTraceFileName, __LINE__); 							

		OMASuplEnd->SetMessageBase(aSuplVersion,aSessionId); 

		if(iSetStatusCode)

			{

	 			OMASuplEnd->SetStatusCode(iStatusCode);		

	 			iTrace->Trace(_L("Status Code in SUPL_END :"), KTraceFileName, __LINE__); 											

				TBuf<64> Res;			

				Res.AppendNum(iStatusCode);

				iTrace->Trace(Res, KTraceFileName, __LINE__); 

			}		

		if(iEncodedSuplInit)

			{

				OMASuplEnd->SetVer(iRes);

	 		}

		iTrace->Trace(_L("Starting Encoding...SUPL_END"), KTraceFileName, __LINE__); 							

		TInt error = KErrNone;

		HBufC8 *encodedBuffer = NULL;		

		TRAPD(err,encodedBuffer = iOMASuplAsnHandlerBase->EncodeL(OMASuplEnd,error));

		CleanupStack::PopAndDestroy(OMASuplEnd);

		iTrace->Trace(_L("Encoding Done..."), KTraceFileName, __LINE__); 

		 if ( error == KErrNone && err == KErrNone )

		 	{

		 			aError = KErrNone;

					return encodedBuffer;

		 	}

		 else

		 	{

		 		iTrace->Trace(_L("Encoding Failed."), KTraceFileName, __LINE__); 

				aError = error;	

		 		delete encodedBuffer;

		 		encodedBuffer = NULL;

		 	}

 	return NULL;

}

// -----------------------------------------------------------------------------

// COMASuplEndState::StartTimer

// StartTimer...starts the timer ... depending on type of message

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void COMASuplEndState::StartTimer()

	{

		iTrace->Trace(_L("COMASuplEndState::StartTimer...No Use."), KTraceFileName, __LINE__); 							

	}

// -----------------------------------------------------------------------------

// COMASuplEndState::ComputeSuplEndVerL

// Generates SUPL_POS_INIT message

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool COMASuplEndState::ComputeSuplEndVerL()

{

	if(!iEncodedSuplInit) //Terminal initiated case

	{

		return ETrue;

	}

	if(iEncodedSuplInit && (iEncodedSuplInit->Length()) > 0 &&

	iHSLPAddress && iHSLPAddress->Length() > 0)

	{

		TInt blockSize = 64;

	    TChar ipad = 0x36;

	    TChar opad = 0x5c;

	    TBuf8<64> key0;

	    TInt i;

	    CMessageDigest* sha1 = CMessageDigestFactory::NewDigestLC(

	                                CMessageDigest::ESHA1 );

	    // Step 1: Append 0x00 to the key to create a string of size = blocksize

	    key0.SetLength( blockSize );

	    key0.FillZ();

	    if ( iHSLPAddress->Length() != blockSize )

	        {

	        // If key greater than the block size of digest which is 64

	        // then hash the key to get a 20 byte code

	        if ( iHSLPAddress->Length() > blockSize )

	            {

	            TPtrC8 hashedKey = sha1->Hash(*iHSLPAddress );

	            for ( i = 0; i < hashedKey.Length(); i++ )

	                {

	                key0[i] = hashedKey[i];

	                }

	            sha1->Reset();

	            }

	        else if ( iHSLPAddress->Length() < blockSize )

	            {

	            for ( i = 0; i < iHSLPAddress->Length(); i++ )

	                {

	                key0[i] = (*iHSLPAddress)[i];

	                }

	            }

	        }

	    else

	        {

	        for ( i = 0; i < iHSLPAddress->Length(); i++ )

	            {

	            key0[i] = (*iHSLPAddress)[i];

	            }

	        } 

	     // Step 2: XOR the string obtained in Step 1 with ipad

	    for ( TInt i = 0; i < blockSize; i++ )

	        {

	        iRes.Append( key0[i] ^ ipad );

	        }

#ifdef PRINT_MESSAGE

   	    iTrace->Trace(_L("ipad of server address  "), KTraceFileName, __LINE__); 					

	    PrintHex(iRes,__LINE__); 

#endif

	    // Step 3: Append the message to the string resulting from Step 2

	    HBufC8* messageKeyString = 

	            HBufC8::NewLC( iEncodedSuplInit->Size() + iRes.Size() );

	    messageKeyString->Des().Append( iRes );

	    messageKeyString->Des().Append( *iEncodedSuplInit );

	    // Step 4: Generate hash code of the string resulting in Step 3

	    iRes.FillZ();

	    iRes.Zero();

	    TPtrC8 innerHashedMessage = sha1->Hash( messageKeyString->Des() );

	    HBufC8* step4Msg = HBufC8::NewLC(innerHashedMessage.Size());

	    step4Msg->Des().Append(innerHashedMessage);

	    sha1->Reset();

	    // Truncate the hash output to 64 bits

	    // Step 5: XOR the string obtained in Step 1 with opad

        HBufC8* hmacString = HBufC8::NewLC( step4Msg->Size() + blockSize );

	    for ( TInt i = 0; i < blockSize; i++ )

	        {

	        hmacString->Des().Append( key0[i] ^ opad );

	        }

#ifdef PRINT_MESSAGE

   	    iTrace->Trace(_L("xor ofserver address with opad"), KTraceFileName, __LINE__); 					

	    PrintHex(hmacString->Des(),__LINE__); 

#endif

	    // Step 6: Append the string obtained in step 4 to the string 

	    // obtained in Step 5

        hmacString->Des().Append( step4Msg->Des() );

	    // Step 7: Generate hash code of the string resulting from Step 6

	    iRes.FillZ();

	    iRes.Zero();

	    TPtrC8 hmacSha1Code = sha1->Hash( hmacString->Des() );

	    // Truncate hash output to 64 bits

	    iRes.Copy( hmacSha1Code.Ptr(), 8 );

	    CleanupStack::PopAndDestroy( hmacString );

        CleanupStack::PopAndDestroy( step4Msg );

	    CleanupStack::PopAndDestroy( messageKeyString );

	    CleanupStack::PopAndDestroy( sha1 );

#ifdef PRINT_MESSAGE

   		iTrace->Trace(_L("Final ver..."), KTraceFileName, __LINE__); 							

		PrintHex(iRes,__LINE__);

#endif

	    return ETrue;

	}

	return EFalse;

}

// -----------------------------------------------------------------------------

// COMASuplEndState::ProcessMessage

// process message...

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt COMASuplEndState::ProcessMessageL(COMASuplAsnMessageBase* aDecodedMessage)

{

			COMASuplEnd* OMASuplEnd = static_cast <COMASuplEnd *>(aDecodedMessage);

			COMASuplEnd::TOMASuplStatusCode statusCode;

			TInt error = OMASuplEnd->StatusCode(statusCode);

            iStatusCode = statusCode;

			OMASuplEnd->Position(iOMASuplPosition);	

			LogReceivedPosition();

			if(error == KErrOMASuplParamNotSet )

			    {

			    //OMASuplEnd->Position(iOMASuplPosition); // Changed by Manish					

			    return KErrNone;

			    }			

			else

			    {

			    return KErrCompletion;  //Error in status code

			    }	

}

// -----------------------------------------------------------------------------

// COMASuplEndState::CancelOperation

// Cancels Operation...Cancels operation

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void COMASuplEndState::CancelOperation() 

	{ 

		 COMASuplState::CancelOperation();	

		 iTrace->Trace(_L("COMASuplEndState::CancelOperation..."), KTraceFileName, __LINE__); 							

	}	

// -----------------------------------------------------------------------------

// COMASuplEndState::GetPosition

// Retrive Position

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

COMASuplPosition* COMASuplEndState::GetPosition() const

{

		return iOMASuplPosition;

}

void COMASuplEndState::LogReceivedPosition() const 

	{

#ifdef PRINT_MESSAGE

            if (iOMASuplPosition)            

                {            

  	            TBuf <300> positionLog;

	            positionLog.Copy(_L("-------Position Log in SUPL END------------"));

                TOMASuplUtcTime utcTime;

                TOMASuplPositionEstimate posEstimate;

	            TDateTime lDateTime;

	            TInt  	  zoneCode;

	            TInt      zone;

	            iTrace->Trace(positionLog, KTraceFileName, __LINE__); 

                iOMASuplPosition->GetPosition(utcTime,posEstimate );

                utcTime.GetUtcTime(lDateTime,zoneCode,zone);		

	            positionLog.Copy(_L("UTC Time Log : "));

	            positionLog.Append(_L("Year : "));

	            positionLog.AppendNum(lDateTime.Year());

	            positionLog.Append(_L("Month : "));

	            positionLog.AppendNum(lDateTime.Month());

	            positionLog.Append(_L("Day : "));

	            positionLog.AppendNum(lDateTime.Day());	

	            positionLog.Append(_L("Hour : "));

	            positionLog.AppendNum(lDateTime.Hour());	

	            positionLog.Append(_L("Minute : "));

	            positionLog.AppendNum(lDateTime.Minute());	

	            positionLog.Append(_L("Second : "));

	            positionLog.AppendNum(lDateTime.Second());	

	            iTrace->Trace(positionLog, KTraceFileName, __LINE__); 

	            positionLog.Copy(_L("MicroSecond : "));

	            positionLog.AppendNum(lDateTime.MicroSecond());	

	            positionLog.Append(_L("Zone Code : "));

	            positionLog.AppendNum(zoneCode);	

	            positionLog.Append(_L("Zone : "));

	            positionLog.AppendNum(zone);

	            iTrace->Trace(positionLog, KTraceFileName, __LINE__); 

	            TOMASuplPositionEstimate::TOMASuplLatitudeSign  latSign;

                TInt               latitude;

                TInt               longitude;

                posEstimate.GetPositionEstimate(latSign,latitude,longitude);

                positionLog.Copy(_L("Position Estimate : "));

	            positionLog.Append(_L("latitude Sign : "));

	            positionLog.AppendNum(latSign);

	            positionLog.Append(_L(" Latitude : "));

	            positionLog.AppendNum(latitude);

	            positionLog.Append(_L(" Longitude : "));

	            positionLog.AppendNum(longitude);	

	            iTrace->Trace(positionLog, KTraceFileName, __LINE__); 

	            TOMASuplUncertainty uncertainty;

	            TInt logError = posEstimate.GetUncertainty(uncertainty);

	            if(!logError)

		            {

		            TInt uncertSemiMajor;

       	            TInt uncertSemiMinor;

       	            TInt orientMajorAxis;

       	            uncertainty.GetUncertainty(uncertSemiMajor,uncertSemiMinor,orientMajorAxis);

       	            positionLog.Copy(_L("Uncertainity Semi Major : "));

		            positionLog.AppendNum(uncertSemiMajor);

		            positionLog.Append(_L(" Uncertainity Semi Minor : "));

		            positionLog.AppendNum(uncertSemiMinor);

		            positionLog.Append(_L(" Orientation Major Axis : "));

		            positionLog.AppendNum(orientMajorAxis);	

		            }

	            iTrace->Trace(positionLog, KTraceFileName, __LINE__);

	            // Retrieve Confidence

	            TInt confidence;

	            logError = posEstimate.GetConfidence(confidence);

	            if(!logError)

		            {

		            positionLog.Copy(_L("Confidence in Position : "));	

		            positionLog.AppendNum(confidence);	

	                iTrace->Trace(positionLog, KTraceFileName, __LINE__);

		            }

	            TOMASuplAltitudeInfo altitudeInfo;

	            logError = posEstimate.GetAltitudeInfo(altitudeInfo);

	            if(!logError)

		            {

		            TOMASuplAltitudeInfo::TOMASuplAltitudeDirection altDirection;

    	            TInt altitude;

       	            TInt altUncert;

       	            altitudeInfo.GetAltitudeInfo(altDirection,altitude,altUncert);

       	            positionLog.Copy(_L("Altitude Information "));

	                iTrace->Trace(positionLog, KTraceFileName, __LINE__);