/*

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

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

    {

    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;