* 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 <extendedconnpref.h> //For OCC

const TInt KMaxGBAUsageLength = 4;

const TInt KMaxVerLength = 4;

const TInt KMaxNewPasswordLength = 16;

const TInt KMaxPskKeyLength = 256;

const TInt KMaxRootKeyLength = 32;

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

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++]);

        }

    }

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

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), iPrompt(EFalse), iWlanOnly(EFalse)

void CSuplConnection::ConstructL(const TDesC &aHostAddress,

        const TUint aPort, const TInt aIAPId, MSuplPacketNotifier *aNotifier)

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

        }

    if (iPskTLSUsage)

        {

        // PSK TLS Start

#if WITH_GBA_OFFF

        iGbaClient = CGbaClientRequestHandler::NewL();

#endif /* WITH_GBA */

        // PSK TLS End

        }

void CSuplConnection::ConstructL(const TDesC &aHostAddress,

        const TUint aPort, const TInt aIAPId, TBool aTls, TBool aPskTls,

        MSuplPacketNotifier *aNotifier)

    if (iVariantEnabled)

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

                KTraceFileName, __LINE__);

        _LIT(KTLS1, "TLS1.0");

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

        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

            }

        iSocketReader = CSuplSocketReader::NewL(iTlsSocket, aNotifier,

                iVariantEnabled);

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

                KTraceFileName, __LINE__);

        iSocketReader = CSuplSocketReader::NewL(iSocket, aNotifier,

                iVariantEnabled);

    if (iPskTLSUsage)

        {

        // PSK TLS Start

#if WITH_GBA_OFFF

        iGbaClient = CGbaClientRequestHandler::NewL();

#endif /* WITH_GBA */

        // PSK TLS End

        }

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

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

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

    if (iTrace)

        {

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

                __LINE__);

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

                KTraceFileName, __LINE__);

        }

    iTrace->Trace(_L("CSuplConnection::Destructor...Deleting Socket Reader"),

            KTraceFileName, __LINE__);

    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__);

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

        {

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

                KTraceFileName, __LINE__);

        iSocket.Close();

        }

    if (iTrace)

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

                KTraceFileName, __LINE__);

    // PSK TLS Start

    // PSK TLS End

    // Delete Trace

    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());

                    }

                }

            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());

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

                        KTraceFileName, __LINE__);

                }

            break;

            // Secure Connection

        case ESecureHandShake:

            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());

            break;

            // DNS Lookup has completed

        case ELookingUp: