/*

* 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_POS_INIT message...

*

*/

#include <etelmm.h> 

#include <hash.h>

#include <f32file.h>

#include <flogger.h>

#include <lbs/epos_comasuplpossessionbase.h>

#include "utf.h"

#include "epos_comasupllocationid.h"

#include "epos_comasupllocationidver2.h"

#include "lbs/epos_comasuplreqasstdata.h"

#include "lbs/epos_comasuplinforequestlist.h"

#include "lbs/epos_comasuplsetcapabilities.h"

#include "lbs/epos_comasuplpospayload.h"

#include "lbs/epos_comasuplposition.h"

#include "lbs/epos_comasuplvelocity.h"

#include "epos_comasuplsession2.h"

#include "epos_comasuplposinitver2.h"

#include "epos_comasuplposinitstate.h"

#include "epos_comasuplposrequestor.h"

#include "epos_omasuplconstants.h"

#include "epos_comasupltrace.h"

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

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

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

// COMASuplPosInitState::COMASuplPosInitState

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

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

//

COMASuplPosInitState::COMASuplPosInitState(COMASuplSETCapabilities* aOldCapabilities,

										   RMobilePhone& aMobilePhone,TInt aMsgTimeout,

										   COMASuplPOSRequestor* aPosRequestor,

										   COMASuplSession::TOMASuplReqType aRequestType,

										   COMASuplAsnHandlerBase* aOMASuplAsnHandlerBase):

										   COMASuplStartState(aMobilePhone,

										   aMsgTimeout,aPosRequestor,aOMASuplAsnHandlerBase),

										   iRequestType(aRequestType),

                       iPosPayloadPresent(EFalse),iIgnorePosData(EFalse),iRepeatedPosDataFetch(EFalse)

    {

		iCurrentState =  ESUPL_POS_INIT;

		iOldCapabilities = aOldCapabilities;   // Caps recevied during SUPL_START from POS

		iRes.FillZ();

		iGenerationStatus = EFalse;

    }

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

// COMASuplPosInitState::~COMASuplPosInitState

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

//

COMASuplPosInitState::~COMASuplPosInitState()

    {

	if(iHSLPAddress)

		{

		delete iHSLPAddress;

		}

	if(iEncodedSuplInit)

		{

		delete iEncodedSuplInit;

		}

	if(iLocationId)

		{

		delete iLocationId;	

		iLocationId=NULL;

		}    	

	if(iTrace)

		{

		iTrace->Trace(_L("COMASuplPosInitState::~COMASuplPosInitState..."), KTraceFileName, __LINE__); 							

		}

    }

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

// COMASuplPosInitState::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void COMASuplPosInitState::ConstructL(TInt aAllowedCapabilities, TOMASuplPosMethod aPosMethod, HBufC8* aEncodedSuplInit, HBufC8* aHSLPAddress)

    {

    	COMASuplStartState::ConstructL(aAllowedCapabilities);

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

		switch(aPosMethod)

			{

			case EOMAAgpsSETAssisted:

				{

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

				iPosMethod = COMASuplPosSessionBase::EGpsSETAssisted;

				}

				break;

			case EOMAAgpsSETAssistedPref:

				{

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

				iPosMethod = COMASuplPosSessionBase::EGpsSETAssistedPreferred;

				}

				break;

			case EOMAAgpsSETBased:

				{

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

				iPosMethod = COMASuplPosSessionBase::EGpsSETBased;

				}

				break;

			case EOMAAgpsSETBasedPref:

				{

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

				iPosMethod = COMASuplPosSessionBase::EGpsSETBasedPreferred;

				}

				break;

			case EOMAAutonomousGps:

				{

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

				iPosMethod = COMASuplPosSessionBase::EAutonomousGps;

				}

				break;

			case EOMAFLT:

				{

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

				iPosMethod = COMASuplPosSessionBase::EAFLT;

				}

				break;

			case EOMAeOTD:

				{

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

				iPosMethod = COMASuplPosSessionBase::EeOTD;

				}

				break;

			case EOMAoTDOA:

				{

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

				iPosMethod = COMASuplPosSessionBase::EoTDOA;

				}

				break;

			case EOMANoPosition:

				{

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

				iPosMethod = COMASuplPosSessionBase::ENoPosition;

				}

				break;

			default:

				{

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

				iPosMethod = COMASuplPosSessionBase::EPositionUndefined;			

				}

				break;

			}

		TBuf<128> msg(_L("COMASuplPosInitState::ConstructL... iPosMethod: "));

		msg.AppendNum(iPosMethod);

		iTrace->Trace(msg, 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;

		    	}

    		}

    }

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

// COMASuplPosInitState::NewL

// Two-phased constructor.

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

//

COMASuplPosInitState* COMASuplPosInitState::NewL(COMASuplSETCapabilities* aOldCapabilities,

											RMobilePhone& aMobilePhone,TInt aMsgTimeout,

											COMASuplPOSRequestor* aPosRequestor,TInt aAllowedCapabilities,

											COMASuplSession::TOMASuplReqType aRequestType, TOMASuplPosMethod aPosMethod,

											COMASuplAsnHandlerBase* aOMASuplAsnHandlerBase,

											HBufC8* aEncodedSuplInit,

											HBufC8* aHSLPAddress

											)

    {

	    COMASuplPosInitState* self =  new ( ELeave ) COMASuplPosInitState(aOldCapabilities,

	    											  aMobilePhone,aMsgTimeout,aPosRequestor,aRequestType,aOMASuplAsnHandlerBase);

	    CleanupStack::PushL( self );

	    self->ConstructL(aAllowedCapabilities, aPosMethod, aEncodedSuplInit, aHSLPAddress);

	    CleanupStack::Pop(self);

	    return self;

    }

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

// COMASuplPosInitState::GenerateMessage

// Generates SUPL_POS_INIT message

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

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

//

TInt COMASuplPosInitState::GenerateMessageL() 

	{

		iGenerationStatus = ETrue;

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

		iVerPresent = ComputeSuplInitVerL();

		if(iVerPresent)

			{

				iLocationIDRequestor->GetLocationID();		

			}

		else

			{

				iMsgStateObserver->OperationCompleteL(KErrGeneral);

			}

		return KErrNone;				

	}

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

// COMASuplPosInitState::ComputeSuplInitVer

// Generates SUPL_POS_INIT message

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

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

//

TBool COMASuplPosInitState::ComputeSuplInitVerL() 

	{

	if(iRequestType == COMASuplSession::ESUPL_TERMINAL) 

		{

			return ETrue;

		}

    if (iRequestType == COMASuplSession::ESUPL_NETWORK && GetTriggerSessionFlag())

		{

			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

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

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

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

	    sha1->Reset();

	    // 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;

	}	

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

// COMASuplPosInitState::GetPosParamsL

// Collects the optional parameters for SUPL_POS_INIT 

// message from POS Message plugin

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

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

//

void COMASuplPosInitState::GetPosParamsL() 

	{

	iGenerationStatus = ETrue;

	// Re-initialize the POS Requestor

	if(iPosRequestor)

		iPosRequestor->DestroyList();

	iPosRequestor->CreateListL();

	// Create SET capabilities object

	iCurSetCapabilities = COMASuplSETCapabilities::NewL();

	// Create the Request Assistance data object

	iReqAsstData = COMASuplReqAsstData::NewL();

	// Create Position

	iPosition = COMASuplPosition::NewL();

	// Create POS Payload

	iPosPayload = COMASuplPosPayload::NewL();

	// Create Velocity

	iVelocity = COMASuplVelocity::NewL();

	// Append the SUPL POS INIT optional parameters to the list

	// in POS Requestor

	iPosRequestor->AppendInfoRequest(iCurSetCapabilities);

	iPosRequestor->AppendInfoRequest(iReqAsstData);

	iPosRequestor->AppendInfoRequest(iPosition);

	iPosRequestor->AppendInfoRequest(iPosPayload);

	iPosRequestor->AppendInfoRequest(iVelocity);

	// Set self as Observer to POS Requestor

	iPosRequestor->SetObserver(this);

	TBuf<128> msg(_L("Filling iPosMethod in iPosRequestor: "));

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

	if(iPosRequestor)

		{

		iAllowedCapabilitiesforPOS.SetAllowedCapabilities(EFalse, EFalse, EFalse, EFalse, EFalse, EFalse, EFalse, EFalse);

		iPosRequestor->SetPosMethodAndAllowedCapabilities (iAllowedCapabilitiesforPOS,iPosMethod ); 

        if(iHSLPAddress)

            {

            HBufC* slpAddress = CnvUtfConverter::ConvertToUnicodeFromUtf8L(*iHSLPAddress);

            msg.Copy(_L("Filling iHSLPAddress in iPosRequestor: "));

            msg.Append(*slpAddress);

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

            iPosRequestor->SetSLPAddressUsed(*slpAddress);

            }

		}

	// Get the information from POS

	if(iPosRequestor)

	User::LeaveIfError(iPosRequestor->GetSuplInfoL());

	}

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

// COMASuplPosInitState::OperationCompleteL

// An observer method that indicates the completion of

// data retrieval from POS Message plugin

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

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

//

void COMASuplPosInitState::OperationCompleteL(TInt  aError ) 

	{

		if(iMsgStateObserver)

		{

			iGenerationStatus = EFalse;

			if(aError == KErrNone)

			    {

			    iLocationIDRequestor->GetComparisionLocationID();

			    }

			else

			    iMsgStateObserver->OperationCompleteL(aError);

		}

	}

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

// COMASuplPosInitState::ValidateSetCapabilities

// Collects the optional parameters for SUPL_POS_INIT 

// message from POS Message plugin

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

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

//

TInt COMASuplPosInitState::ValidateSetCapabilities() 

	{

		if(!iPosRequestor || iRequestType == COMASuplSession::ESUPL_NETWORK )  //No need to check status if POS is not there

			{

				return KErrNone;  

			}

		TInt status = iCurSetCapabilities->Status();  // Caps from POS

		if(status == KErrNone)

		{

			TOMASuplPosTechnology oldPosTech, curPosTech;

			COMASuplSETCapabilities::TOMASuplPrefMethod oldPrefMethod, curPrefMethod;

			TOMASuplPosProtocol oldPosProtocol, curPosProtocol;

			iOldCapabilities->GetSETCapabilities(oldPosTech, oldPrefMethod, oldPosProtocol);

			iCurSetCapabilities->GetSETCapabilities(curPosTech, curPrefMethod, curPosProtocol);

			TBool oldGpsSETAssisted, curGpsSETAssisted, oldGpsSETBased, curGpsSETBased;

			TBool oldAutonomousGps, curAutonomousGps, oldaFLT, curaFLT, oldAeOTD, curAeOTD;

			TBool oldOTDOA, curoTDOA;

			oldPosTech.GetPosTechnology(oldGpsSETAssisted, oldGpsSETBased, oldAutonomousGps, oldaFLT,

										oldAeOTD, oldOTDOA);

			curPosTech.GetPosTechnology(curGpsSETAssisted, curGpsSETBased, curAutonomousGps, curaFLT,

										curAeOTD, curoTDOA);

			if((oldGpsSETAssisted == curGpsSETAssisted) && (oldGpsSETBased == curGpsSETBased) &&

			  (oldAutonomousGps == curAutonomousGps) && (oldaFLT == curaFLT) && (oldAeOTD == curAeOTD)

			  && (oldOTDOA == curoTDOA))

			{

				TBool oldTIA801, curTIA801, oldRRLP, curRRLP, oldRRC, curRRC;

				oldPosProtocol.GetPosProtocol(oldTIA801, oldRRLP, oldRRC);

				curPosProtocol.GetPosProtocol(curTIA801, curRRLP, curRRC);

				if((oldTIA801 == curTIA801) && (oldRRLP == curRRLP) && (oldRRC == curRRC))

				{

					if(oldPrefMethod == curPrefMethod)

					{

						return KErrNone;

					}

				}

			}

			return KErrOMASETCapMisMatch;

		}