/*

* 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 fallback in case of multiple SLP

*

*/

#include "epos_csuplsettingsinternal.h"

#include "epos_comasuplfallbackhandler.h"

#include "epos_omasuplconstants.h"

#include "epos_momasuplconnobserver.h"

#include "epos_comasupltrace.h"

#include "epos_csuplsettingparams.h"

#include "epos_csuplsettingextensionparams.h"

#include "epos_csuplsettingsinternalconstants.h"

#include <networking/dnd_err.h>   //Error codes

#include <etelpckt.h> //Error codes

#include <exterror.h>

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

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

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

// COMASuplFallBackHandler::COMASuplFallBackHandler

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

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

//

COMASuplFallBackHandler::COMASuplFallBackHandler(CSuplSettingsInternal& aSettings):

												iSuplSettings(aSettings),

												iAttemptedBackupServer(EFalse)

    {

    }

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

// COMASuplFallBackHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void COMASuplFallBackHandler::ConstructL()

    {

    	iCurrentServerCounter = 0;

    	iTLSAuthenticationFailed = EFalse;

    	iErrorCode = KErrNone;

    	iSLPList = new (ELeave) CArrayFixFlat<TSLPDetails>(16);

    	iTrace = COMASuplTrace::NewL();

		 TInt err = iSuplSettings.GetFallBackTimerValue(iAllowedFallBackTimerValue);

		 if(err != KErrNone)

		 	{

		 		iAllowedFallBackTimerValue = 200000000;

		 	}

		TBuf<64> buffer(_L("Fallback Timer Value in Seconds : "));

		buffer.AppendNum(iAllowedFallBackTimerValue);

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

    }

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

// COMASuplFallBackHandler::NewL

// Two-phased constructor.

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

//

COMASuplFallBackHandler* COMASuplFallBackHandler::NewL( CSuplSettingsInternal& aSettings)

    {

	    COMASuplFallBackHandler* self =  new ( ELeave ) COMASuplFallBackHandler(aSettings);

	    CleanupStack::PushL( self );

	    self->ConstructL();

	    CleanupStack::Pop(self);

	    return self;

    }

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

// COMASuplFallBackHandler::COMASuplFallBackHandler

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

//

COMASuplFallBackHandler::~COMASuplFallBackHandler()

    {

    	delete iTrace;

    	if(iSLPList)

    	    {

    	    iSLPList->Reset();

    	    }

    	delete iSLPList;

    	iSLPList=NULL;

    	iGenratedHslpAddress.Close();

    	iDefaultIAPName.Close();

    }

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

// COMASuplFallBackHandler::GetNextSLPAddressL

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

//    TODO: Merge if conditions...

TInt COMASuplFallBackHandler::GetNextSLPAddressL(TInt64& aSLPId, TDes& aHslpToBeUsedAddress,TDes& aIAPName,TBool& aTls,

                                                 TBool& aPskTls,TInt aLastErrorCode,TBool& aIsIapDialogShown)

    {

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

        _LIT(KFormatTxt,"%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%:3%+B"); 

        TBuf<256> LogBuffer;

       if( aLastErrorCode != KErrNone)// If its KErrNone then its means server name is asked first time and no need for Tls failure check

    	{

    	if( CheckErrorCodeL(aLastErrorCode) )

        	{

        	if( iTLSAuthenticationFailed )

        		{

        		if(iErrorCode == KErrNone)

            		{	

            		aHslpToBeUsedAddress.Copy(iGenratedHslpAddress);

            		aIAPName.Zero();   

            		aIAPName.Copy(iDefaultIAPName);

            		aTls = ETrue;

            		aPskTls = EFalse;

            		aIsIapDialogShown = ETrue;

            		iTrace->Trace(_L("Fallback allowed & TLSAuth failed"),KTraceFileName, __LINE__);

            		iTrace->Trace(_L("Server being used:"),KTraceFileName, __LINE__);

            		LogBuffer.Copy(aHslpToBeUsedAddress);

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

            		iTrace->Trace(_L("iap being used:"),KTraceFileName, __LINE__);

            		LogBuffer.Copy(aIAPName);

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

            		iTrace->Trace(_L("iap dlg configuration:"),KTraceFileName, __LINE__);

            		LogBuffer.Delete(0,256);

            		LogBuffer.AppendNum(aIsIapDialogShown);

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

            		return KErrNone;

            		}

        		else

            		{

            		return KErrArgument;        

            		}

            	}

       	 	}

     	else

	     	{

	     	return KErrNotFound;

	     	}  

	 	}

		//Check to see if the server list is empty.  If it is create the HSLP Address from the IMSI and use that

		// as the server address.  This does not add the server to the list and this functionality should only

		// be tried once

		if(iSLPList->Count() <= 0 && (!iAttemptedBackupServer))

			{

			iTrace->Trace(_L("Going to create and use alternative HSLP Address from IMSI"),KTraceFileName, __LINE__);

			iAttemptedBackupServer = ETrue;

			//Generate the HSLP Address

			GenerateHslpAddressFromIMSIL();

			//Copy the generated address into the supplied function arguments

			aHslpToBeUsedAddress.Copy(iGenratedHslpAddress);

			aIAPName.Zero();   

			aIAPName.Copy(iDefaultIAPName);

			aTls = ETrue;

			aPskTls = EFalse;

			aIsIapDialogShown = ETrue;

			iTrace->Trace(_L("Server being used:"),KTraceFileName, __LINE__);

			LogBuffer.Copy(aHslpToBeUsedAddress);

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

			iTrace->Trace(_L("iap being used:"),KTraceFileName, __LINE__);

			LogBuffer.Copy(aIAPName);

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

			return KErrNone;

			}

        if( iSLPList->Count() <= 0 || iCurrentServerCounter >= iSLPList->Count() ) 

            {

            LogBuffer.Copy(_L("No more servers available..."));

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

            return KErrNotFound;

            }

        iTrace->Trace(_L("Trying next server..."),KTraceFileName, __LINE__);                

        //Fallback Timer...

        if(aLastErrorCode == KErrNone) //This means, server name is asked for first time only...

            {

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

            iFallBackStartTime.HomeTime();

            LogBuffer.Zero();

            iFallBackStartTime.FormatL(LogBuffer,KFormatTxt); 

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

            }

        else

            {

            TTime currentTime;

            currentTime.HomeTime();

            TTimeIntervalMicroSeconds diff = currentTime.MicroSecondsFrom(iFallBackStartTime); 

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

            LogBuffer.Zero();

            currentTime.FormatL(LogBuffer,KFormatTxt); 

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

            LogBuffer.Copy(_L("Difference between time: "));

            LogBuffer.AppendNum(diff.Int64());

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

            if( diff.Int64() > iAllowedFallBackTimerValue)  

                {

                LogBuffer.Copy(_L("Timeout happened..."));

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

                return KErrTimedOut;

                }

            }   

        if(aLastErrorCode == KErrNone)  //This will be called only once...for first time only

            {

            aSLPId = (*iSLPList)[0].iSLPId;

            aHslpToBeUsedAddress.Copy((*iSLPList)[0].iHSLPAddress);

            aIAPName.Copy((*iSLPList)[0].iIapName);

            aTls = (*iSLPList)[0].iTls;

            aPskTls = (*iSLPList)[0].iPskTls;

            aIsIapDialogShown = (*iSLPList)[0].iIsIAPDialgShown;

            iCurrentServerCounter++;                

            iTrace->Trace(_L("Server being used:"),KTraceFileName, __LINE__);

            LogBuffer.Copy(aHslpToBeUsedAddress);

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

            iTrace->Trace(_L("iap being used:"),KTraceFileName, __LINE__);

            LogBuffer.Copy(aIAPName);

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

            iTrace->Trace(_L("iap dlg configuration:"),KTraceFileName, __LINE__);

            LogBuffer.Delete(0,256);

            LogBuffer.AppendNum(aIsIapDialogShown);

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

            return KErrNone;

            }

        else

            {

            if(iIsFallBackAllowed && CheckErrorCodeL(aLastErrorCode))// Do not fallback in case if IMSI generated address failed for previous try.

                {

                aSLPId = (*iSLPList)[iCurrentServerCounter].iSLPId; 

                aHslpToBeUsedAddress.Copy((*iSLPList)[iCurrentServerCounter].iHSLPAddress);

                aIAPName.Copy((*iSLPList)[iCurrentServerCounter].iIapName);             

                aTls = (*iSLPList)[iCurrentServerCounter].iTls;

                aPskTls = (*iSLPList)[iCurrentServerCounter].iPskTls;

                aIsIapDialogShown = (*iSLPList)[iCurrentServerCounter].iIsIAPDialgShown;

                iCurrentServerCounter++;

                iTrace->Trace(_L("Fallback allowed & TLSAuth passed"),KTraceFileName, __LINE__);

                iTrace->Trace(_L("Server being used:"),KTraceFileName, __LINE__);

                LogBuffer.Copy(aHslpToBeUsedAddress);

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

                iTrace->Trace(_L("iap being used:"),KTraceFileName, __LINE__);

                LogBuffer.Copy(aIAPName);

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

                iTrace->Trace(_L("iap dlg configuration:"),KTraceFileName, __LINE__);

                LogBuffer.Delete(0,256);

                LogBuffer.AppendNum(aIsIapDialogShown);

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

                return KErrNone;

                }

            else

                {

                return KErrNotFound;

                }

            }

    }

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

// COMASuplFallBackHandler::CheckErrorCodeL

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

//    

TBool COMASuplFallBackHandler::CheckErrorCodeL(TInt aLastErrorCode)

{

		if(iTLSAuthenticationFailed)

		{

			iTrace->Trace(_L("IMSI Generated SLP also failed after TLS faliure for previous SLP..."), KTraceFileName, __LINE__); 				

			return EFalse;		

		}

		if ( (aLastErrorCode >= KErrSSLAlertNoRenegotiation ) && (aLastErrorCode <= KErrSSLAlertCloseNotify)  && !iTLSAuthenticationFailed )

		{

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

			iTLSAuthenticationFailed = ETrue;	

			GenerateHslpAddressFromIMSIL();

			return ETrue;

		}

		if ( (aLastErrorCode >= KErrDndServerUnusable ) && (aLastErrorCode <= KErrDndNameNotFound) )

		{

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

			return ETrue;		

		}

		if ( (aLastErrorCode >= KErrUrgentData  ) && (aLastErrorCode <= KErrNetUnreach ) )

		{

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

			return ETrue;		

		}

		if  (aLastErrorCode == KErrCouldNotConnect  )

		{

			iTrace->Trace(_L("Could not connect to Server..."), KTraceFileName, __LINE__); 				

			return ETrue;		

		}

		if  (aLastErrorCode == KErrSuplTimeout  )

		{

			iTrace->Trace(_L("Timeout for DNS/TLS operation..."), KTraceFileName, __LINE__); 				

			return ETrue;		

		}

		if( aLastErrorCode == KErrGsmMMServiceOptionNotSubscribed )

		{

		   iTrace->Trace(_L("GSM MM Service Option Not Subscribed ..."), KTraceFileName, __LINE__);                 

		   return ETrue;  

	    }

		if ( (aLastErrorCode >= KErrGprsFeatureNotSupported ) && (aLastErrorCode <= KErrGsmRRUnspecifedAbnormalRelease) )

		{

			iTrace->Trace(_L("GPRS Service is not allowed/rejected/not supported..."), KTraceFileName, __LINE__); 				

			return EFalse;		

		}

	return EFalse;

}

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

// COMASuplFallBackHandler::ReadSLPListL

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

//    

void COMASuplFallBackHandler::ReadSLPListL(const TDesC& aClientProvidedHSLPAddress)

{

	  	RPointerArray<CServerParams> SLPList;

		TBool isSLPEntryExist = EFalse;

    	TBool serverEnabled,simChangeRemove,usageInHomeNw,editable;

		TInt err = iSuplSettings.GetAllSlp(SLPList);

		TInt cnt = SLPList.Count();

		TSLPDetails	 SlpEntry;

		TSLPDetails  FirstSlpEntry;

		HBufC* dmConfigurableIapFirstEntry =  HBufC::NewL(KMaxIapNameLength);

		TPtr dmConfigIap(NULL,KMaxIapNameLength);

		dmConfigIap.Set(dmConfigurableIapFirstEntry->Des());

		HBufC* hslpAddress =  HBufC::NewL(KHSLPAddressLength);       

		HBufC* iapName =  HBufC::NewL(KMaxIapNameLength);   

		HBufC* dmConfigurableIapName =  HBufC::NewL(KMaxIapNameLength); 

		HBufC* serverid =  HBufC::NewL(KMaxServerIdLen); 

		HBufC* iap2 =  HBufC::NewL(KMaxIapNameLength); 

		HBufC* serveradd =  HBufC::NewL(KMaxServerAddLen); 

		HBufC* serveraddtype =  HBufC::NewL(KMaxServerAddTypeLen); 

		iSLPList->Reset(); // Reset the list

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

		{

				TInt64 SLPId;	

			   	CServerParams* params = SLPList[i];

			   	params->Get(SLPId,hslpAddress->Des(),iapName->Des(),serverEnabled,simChangeRemove,usageInHomeNw,editable);

			   	CServerExtensionParams* extnparams = CServerExtensionParams::NewL();

			   	TInt err = iSuplSettings.GetServerExtensionParams(SLPId,extnparams); // Ignore error

			   	extnparams->Get(serverid->Des(),dmConfigurableIapName->Des(),iap2->Des(),serveradd->Des(),serveraddtype->Des() );

		   	    delete extnparams; 

			   	SlpEntry.iHSLPAddress.LowerCase();

			   	TBuf<KHSLPAddressLength> clientHSLP;

			   	clientHSLP.Copy(aClientProvidedHSLPAddress);

			   	clientHSLP.LowerCase();

			   	SlpEntry.iSLPId = SLPId;

			   	SlpEntry.iHSLPAddress.Copy(hslpAddress->Des());

			   	SlpEntry.iIapName.Copy(iapName->Des());

			   	SlpEntry.iIapName.LowerCase();

			   	SlpEntry.iHomeNetworkUsage = usageInHomeNw;

			   	iSuplSettings.GetTlsFlag(SLPId,SlpEntry.iTls);

			   	iSuplSettings.GetPskTlsFlag(SLPId,SlpEntry.iPskTls);

			   	SlpEntry.iHSLPAddress.LowerCase();

			   	SlpEntry.iIsIAPDialgShown=ETrue;//To identify its a entry with primary iap

		   	if(!isSLPEntryExist && (SlpEntry.iHSLPAddress.Compare(clientHSLP) == KErrNone) )// Client provided SLP will be on top of list.

		   	{

		   		if(serverEnabled)   // Following is to handle specical case where client specified SLP is disabled and fallback not allowed...

				{

				 FirstSlpEntry = SlpEntry;

				 // Store the 2ndary iap if exists

				if( dmConfigurableIapName->Length() > 0 )

				    {

				    dmConfigIap=dmConfigurableIapName->Des();

				    }

				else

				    {

				    dmConfigIap.Zero();

				    }

				isSLPEntryExist = ETrue;

				} 		

        		  else

				  {

						if(iIsFallBackAllowed)

						{

							continue;

						}

			   		  	else

			   		  	{

			   		  			isSLPEntryExist = EFalse;

			   		  			iSLPList->Reset();

			   		  			break;

			   		  	}

                  } 	

		   	}

		   	else

		   	{

		   		if(serverEnabled)

		   		{

				iSLPList->AppendL(SlpEntry);

				if( dmConfigurableIapName->Length() > 0 )

                    {

                    // Replace default iap field with 2ndary iap field

                    SlpEntry.iIapName.Copy(dmConfigurableIapName->Des());

                    SlpEntry.iIapName.LowerCase();

                    // Set IapDialog flag to false for entry with secondary iap

                    SlpEntry.iIsIAPDialgShown=EFalse;

                    // Append this entry to the list

                    iSLPList->AppendL(SlpEntry);

                    }

				}	

			}

		}