/*

* 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:   SUPL Connection provides the Connection End point

* 				 for SUPL Session to send/receive packets from the

*				 network

*

*/

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ssl_internal.h>

#endif

#include <commdbconnpref.h>

#include <centralrepository.h>

#include "epos_csuplserverprivatecrkeys.h"

#include "epos_csuplconnection.h"

#include "epos_csuplsocketreader.h"   

#include "epos_csuplsockettimer.h"

#include "epos_csuplconntrace.h"

#include "epos_csuplpacketinfo.h"

#include "epos_psktlsusageprivatecrkeys.h"

#include "epos_suplpskloger.h"

const TInt KMaxGBAUsageLength =  4;

const TInt KMaxVerLength =  4;

//const TInt KMaxNewPasswordLength =  8;

const TInt KMaxNewPasswordLength =  16;

const TInt KMaxPskKeyLength =  256;

const TInt KMaxRootKeyLength =  32;

const TInt KMaxRootKeyXORLength = 16;

																				//const TInt KMaxRootKeyLength =  16;

const TInt KMaxPassKeyLength =  8;

																				//const TInt KMaxPassKeyLength =  8;

const TInt KMaxSaltLength =  128;

																				//const TInt KMaxSaltLength =  64;

const TInt KMaxPskIdentityHintLength = KMaxGBAUsageLength + KMaxVerLength + KMaxPassKeyLength ;

// Constant definition

_LIT8(KWGBA,"WGBA");

_LIT(KTraceFileName,"SUPL_PH_API::epos_csuplconnection.cpp");

_LIT8(KSaltValue,"0x19,0x31,0x45,0x69,0x69,0x45,0x31,0x19");

void DoSelfXOR(TDes8& aDestination,const TDesC8& aSource)

	{

		aDestination.Zero();

		TInt half = aSource.Length() / 2;

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

			{

				aDestination.Append(aSource[i] ^ aSource[half + i]); 

			}

	}

void DoXOR(TDes8& aDestination,const TDesC8& aSource1,const TDesC8& aSource2)

	{

		aDestination.Zero();

		TInt srcLen1 = aSource1.Length();

		TInt srcLen2 = aSource2.Length();

		TInt j = 0;

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

			{

				if(j >= srcLen2 )

					{

						j = 0;		

					}

				aDestination.Append(aSource1[i] ^ aSource2[j++]);

			}

	}

//0x18,0x32,0x34,0x55,0x55,0x34,0x32,0x18	

void FormSaltKey(TDes8& aDestination,const TDesC8& aSource)	

	{

		TBuf8<2> seachText(_L8("0x"));

		aDestination.Zero();

		TBuf8<KMaxSaltLength> tempSaltBuffer(aSource);

		TUint32  hexNumber;

		TBuf<2> decNumber;

		TInt offSet = tempSaltBuffer.Find(seachText);

		while(offSet != KErrNotFound)

			{

				offSet+=2;

				decNumber.Copy(tempSaltBuffer.Mid(offSet,2));				

				tempSaltBuffer.Copy(tempSaltBuffer.Mid(offSet+2));				

				TLex lex(decNumber);

				lex.Val(hexNumber,EHex); 				

				aDestination.Append(hexNumber);

				offSet = tempSaltBuffer.Find(seachText);

			}

	}

//void get_key(unsigned char key[],unsigned int keylength);

void derive_key(const unsigned char pwd[],  /* the PASSWORD     */

               unsigned int pwd_len,        /* and its length   */

               const unsigned char salt[],  /* the SALT and its */

               unsigned int salt_len,       /* length           */

               unsigned int iter,   /* the number of iterations */

               unsigned char key[], /* space for the output key */

               unsigned int key_len);/* and its required length  */

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

CSuplConnection::CSuplConnection(RSocketServ &aSocketServ):

	CActive(EPriorityStandard), 

	iSocketServ(aSocketServ), 

	iRefCount(0), 

	iState(ENotConnected),

	iPacket(0,0),

	iVariantEnabled(ETrue),

	iPskTLSUsage(EFalse),

	iStartedListen(EFalse),

    iConnectStarted(EFalse),

    iSendInProgress(EFalse),

    iFirstPkt(EFalse),

    iListenCount(0)

    {

    iHostAddress.Zero();

    CActiveScheduler::Add(this);

    }

void CSuplConnection::ConstructL(const TDesC &aHostAddress, const TUint aPort,

								 const TInt aIAPId,

								 MSuplPacketNotifier *aNotifier)

    {

    iTrace = CSuplConnTrace::NewL();

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

    SetVariation();

    iHostAddress.Append(aHostAddress);

    iPort = aPort;

    iIAPId = aIAPId;

    // Create the Secure Socket

	if(iVariantEnabled)

		{

		iTrace->Trace(_L("Using CSuplConnection::Secure Construction"), KTraceFileName, __LINE__);

	    _LIT(KTLS1,"TLS1.0");

		iTlsSocket = CSecureSocket::NewL( iSocket, KTLS1 );

		TBuf8<KMaxHostAddressLen> dNSName;

		dNSName.Copy(aHostAddress);

		iTlsSocket->SetOpt(KSoSSLDomainName,KSolInetSSL,dNSName);

		if(iPskTLSUsage)

			{

			iTrace->Trace(_L("Considering PSK Ciphersuites for Usage..."), KTraceFileName, __LINE__);

			// PSK TLS Start

			        TPckgBuf<MSoPskKeyHandler *> pskConfigPkg;

			        pskConfigPkg() = this;

			        User::LeaveIfError(iTlsSocket->SetOpt(KSoPskConfig, KSolInetSSL, pskConfigPkg));

			// PSK TLS End

			}

		iTlsSocket->SetDialogMode(EDialogModeUnattended);

		iSocketReader = CSuplSocketReader::NewL(iTlsSocket, aNotifier, iVariantEnabled);

		}

	else

		{

		iTrace->Trace(_L("Using CSuplConnection::NonSecure Construction"), KTraceFileName, __LINE__);

		iSocketReader = CSuplSocketReader::NewL(iSocket, aNotifier, iVariantEnabled);

		}

    iTimer = CSuplSocketTimer::NewL(this);

		if(iPskTLSUsage)

			{

				// PSK TLS Start

				#if WITH_GBA_OFFF

				    iGbaClient = CGbaClientRequestHandler::NewL();

				#endif /* WITH_GBA */

				// PSK TLS End

			}

    iConnArray.Reset();

    iPktArray.Reset();

    }

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

// CSuplConnection::ConstructL

// 

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

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

//

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

void CSuplConnection::ConstructL(const TDesC &aHostAddress, const TUint aPort,

                                 const TInt aIAPId,

                                 TBool aTls, TBool aPskTls,

                                 MSuplPacketNotifier *aNotifier)

    {

    iTrace = CSuplConnTrace::NewL();

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

    //SetVariation(); 

    iVariantEnabled = aTls;

    iPskTLSUsage = aPskTls;

    iHostAddress.Append(aHostAddress);

    iPort = aPort;

    iIAPId = aIAPId;

    // Create the Secure Socket

    if(iVariantEnabled)

        {

        iTrace->Trace(_L("Using CSuplConnection::Secure Construction"), KTraceFileName, __LINE__);

        _LIT(KTLS1,"TLS1.0");

        iTlsSocket = CSecureSocket::NewL( iSocket, KTLS1 );

        TBuf8<KMaxHostAddressLen> dNSName;

        dNSName.Copy(aHostAddress);

        iTlsSocket->SetOpt(KSoSSLDomainName,KSolInetSSL,dNSName);

       if(iPskTLSUsage)

					{

					iTrace->Trace(_L("Considering PSK Ciphersuites for Usage..."), KTraceFileName, __LINE__);

					// PSK TLS Start

					        TPckgBuf<MSoPskKeyHandler *> pskConfigPkg;

					        pskConfigPkg() = this;

					        User::LeaveIfError(iTlsSocket->SetOpt(KSoPskConfig, KSolInetSSL, pskConfigPkg));

					// PSK TLS End

					}

        iTlsSocket->SetDialogMode(EDialogModeUnattended);

        iSocketReader = CSuplSocketReader::NewL(iTlsSocket, aNotifier, iVariantEnabled);

        }

    else

        {

        iTrace->Trace(_L("Using CSuplConnection::NonSecure Construction"), KTraceFileName, __LINE__);

        iSocketReader = CSuplSocketReader::NewL(iSocket, aNotifier, iVariantEnabled);

        }

    iTimer = CSuplSocketTimer::NewL(this);

    	if(iPskTLSUsage)

			{

				// PSK TLS Start

				#if WITH_GBA_OFFF

				    iGbaClient = CGbaClientRequestHandler::NewL();

				#endif /* WITH_GBA */

				// PSK TLS End

			}

    iConnArray.Reset();

    iPktArray.Reset();

    }

CSuplConnection* CSuplConnection::NewL(RSocketServ &aSocketServ, const TDesC &aHostAddress, 

                                       const TUint aPort,const TInt aIAPId,

                                       MSuplPacketNotifier *aNotifier)

    {

    CSuplConnection* self = new( ELeave ) CSuplConnection(aSocketServ);

    CleanupStack::PushL( self );

    self->ConstructL(aHostAddress, aPort,aIAPId, aNotifier);

    CleanupStack::Pop();

    return self;

    }

 // --------------------------------------------ADDED NEWL TAKING TLS ALSO-------------------------------------

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

// CSuplConnection::NewL

// 

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

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

//

CSuplConnection* CSuplConnection::NewL(RSocketServ &aSocketServ, const TDesC &aHostAddress, 

                                       const TUint aPort,const TInt aIAPId,

                                       TBool aTls, TBool aPskTls,

                                       MSuplPacketNotifier *aNotifier)

    {

    CSuplConnection* self = new( ELeave ) CSuplConnection(aSocketServ);

    CleanupStack::PushL( self );

    self->ConstructL(aHostAddress, aPort,aIAPId, aTls, aPskTls, aNotifier);

    CleanupStack::Pop();

    return self;

    }

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

CSuplConnection::~CSuplConnection()

    {

    // Log

    if(iTrace)

    {

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

    iTrace->Trace(_L("CSuplConnection::Destructor...Cancelling "), KTraceFileName, __LINE__);

    }

    // Cancel Any outstanding request

    Cancel();

    //Delete the Socket Reader

    delete iSocketReader;

    // Close the resolver if required

    if(iState == ELookingUp)

    {

    	if(iTrace)

    	iTrace->Trace(_L("CSuplConnection::Destructor...Closing Resolver"), KTraceFileName, __LINE__);

    	iResolver.Close();

    }

    if(iTrace)

    iTrace->Trace(_L("CSuplConnection::Destructor...Deleting Secure Socket"), KTraceFileName, __LINE__);

    // Delete the TLS Socket

    delete iTlsSocket;

    // Close the Socket if required

    if(iState == EConnected || iState == EConnecting)

    {

    	iTrace->Trace(_L("CSuplConnection::Destructor...Closing Socket"), KTraceFileName, __LINE__);

    	iSocket.Close();

    }

#ifndef __WINS__

    // Close the RConnection

    if(iTrace)

    iTrace->Trace(_L("CSuplConnection::Destructor...Closing RConnection"), KTraceFileName, __LINE__);

    iConnection.Close();

#endif

	 if(iTrace)

	iTrace->Trace(_L("CSuplConnection::Destructor...Deleting Timer"), KTraceFileName, __LINE__);

    // Delete timer

    delete iTimer;

// PSK TLS Start

#if WITH_GBA_OFFF

    delete iGbaClient;

#endif /* WITH_GBA */

// PSK TLS End

    iConnArray.Close();

   // Delete Trace

    delete iTrace;

    iPktArray.Close();

    }

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

// CSuplConnection::RunL

// This is the method to handle request completion for

// asynchronous requests made by CSuplConnection

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

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

//

void CSuplConnection::RunL()

    {

    // Log

    TBuf<64> msg(_L("CSuplConnection::RunL: State is "));

    msg.AppendNum(iState);

    msg.Append(_L("  iStatus is "));

    msg.AppendNum(iStatus.Int());

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

    switch(iState)

    	{

    	case ERetriveIAP:

			{

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

			if(iStatus.Int() == KErrNone)

				{

					ConnectIAP();

				}

			else

				{

					iTrace->Trace(_L("Error in Retriving IAP Id... "), KTraceFileName, __LINE__);

					iConnection.Close();

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

					//User::RequestComplete(iReqStatus, iStatus.Int());

                    CompleteConnectRequests(iStatus.Int());

				}	

			break;		

			}

    	// Socket Connect has completed

    	case EConnecting:

    		iTimer->Cancel(); // Valid SUPL server, Cancel timer started for this purpose

    		if(iStatus == KErrNone)

    		{

				if(iVariantEnabled)

					{

		    		iTrace->Trace(_L("CSuplConnection::RunL Making Secure Connection"), KTraceFileName, __LINE__);

		    		iState = EMakingSecureConn;

		    		MakeSecureConnection();

					}

				else

					{

		   			// Log

	    			iTrace->Trace(_L("CSuplConnection::RunL Non Secure Socket Connection Established"), KTraceFileName, __LINE__);

	    			// Change State

	    			iState = EConnected;

		       		//User::RequestComplete(iReqStatus, iStatus.Int());

                    CompleteConnectRequests(iStatus.Int());

					}

       		}

    		else	

    		{

    			// Log

    			iTrace->Trace(_L("CSuplConnection::RunL Socket Connection Failed"), KTraceFileName, __LINE__);

    			iState = EFailure;

    			iSocket.Close();

				#ifndef __WINS__  // Bug Fix for close connection

					// Close the RConnection

					iConnection.Close();

				#endif

    			//User::RequestComplete(iReqStatus, iStatus.Int());

                CompleteConnectRequests(iStatus.Int());

    			iTrace->Trace(_L("CSuplConnection::SocketConn Failed Exit"), KTraceFileName, __LINE__);

       		}

    		break;

    	// Secure Connection

    	case ESecureHandShake:

            // Stop timer

            iTimer->Cancel();

    		if(iStatus != KErrNone)

    		{

    			// Log

    			iTrace->Trace(_L("CSuplConnection::RunL Secure Connection Failed"), KTraceFileName, __LINE__);

    			// Connection was not successful

    			iState = EFailure;

    			iSocket.Close();

				#ifndef __WINS__  // Bug Fix for close connection

					// Close the RConnection

					iConnection.Close();

				#endif

    		}

    		else

    		{

    			// Log

    			iTrace->Trace(_L("CSuplConnection::RunL Secure Connection Established"), KTraceFileName, __LINE__);

    			// Change State

    			iState = EConnected;

       		}

    		//User::RequestComplete(iReqStatus, iStatus.Int());

            CompleteConnectRequests(iStatus.Int());

    		break;

    	// DNS Lookup has completed

    	case ELookingUp:

    	{

    		// Log

    		iTrace->Trace(_L("CSuplConnection::RunL DNS Lookup Complete"), KTraceFileName, __LINE__);

            iTimer->Cancel();

    		// Close the Resolver

    		iResolver.Close();

    		if(iStatus != KErrNone)

    		{

    			// Log

    			iTrace->Trace(_L("CSuplConnection::RunL DNS Lookup Failed"), KTraceFileName, __LINE__);

    			iState = EFailure;

    			iSocket.Close();

				#ifndef __WINS__  // Bug Fix for close connection

					// Close the RConnection

					iConnection.Close();

				#endif

    			//User::RequestComplete(iReqStatus, iStatus.Int());

                CompleteConnectRequests(iStatus.Int());

    			break;

    		}

    		// Log

    		iTrace->Trace(_L("CSuplConnection::RunL DNS Lookup Successful"), KTraceFileName, __LINE__);

    		// Retrieve Address

    		TInt addrFamily = iNameEntry().iAddr.Family();

    		if(addrFamily == KAfInet)

    		{

    			//IPv4 Address

    			iAddress.SetAddress(TInetAddr::Cast(iNameEntry().iAddr).Address());

    		}

    		if(addrFamily == KAfInet6)

    		{

    			//IPv6 Address

    			iAddress.SetAddress(TInetAddr::Cast(iNameEntry().iAddr).Ip6Address());

    		}

    		// Set Port

    		iAddress.SetPort(Port());

    		// Connect to Remote Host

    		Connect();