/*

* Copyright (c) 2010 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:  VPN Agile provision Web Service Client

*

*/

#include <SenXmlServiceDescription.h>

#include <SenServiceConnection.h>

#include <SenServiceManager.h>

#include <SenIdentityProvider.h>

#include "agileprovisionws.h"

#include "agileprovisiondefs.h"

#include "policyinstaller_constants.h"

#include "base64.h" 

EXPORT_C CAgileProvisionWs* CAgileProvisionWs::NewL()

    {

	CAgileProvisionWs* self = NewLC();

	CleanupStack::Pop(); // self

	return self;

    }

EXPORT_C CAgileProvisionWs* CAgileProvisionWs::NewLC() 	

    {

	CAgileProvisionWs* self = new (ELeave) CAgileProvisionWs();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

    }

CAgileProvisionWs::CAgileProvisionWs()

    {

    }

void CAgileProvisionWs::ConstructL()

    {

    }

CAgileProvisionWs::~CAgileProvisionWs()

    {

    delete iPService;

    delete iServiceAddr;

    }

EXPORT_C void CAgileProvisionWs::GetPolicy(const TDesC8& aEndPointUri, const TUint aIapId,

                                           TRequestStatus& aStatus)

    {

    __ASSERT_DEBUG( iClientStatus == NULL,

                    User::Invariant() );

    // Store client's request status.

    iClientStatus = &aStatus;

    *iClientStatus = KRequestPending;

    TRAPD( err, DoGetPolicyL( aEndPointUri, aIapId) );

    if ( err != KErrNone )

        {

        DoComplete( err );

        }

    }

EXPORT_C void CAgileProvisionWs::CancelGetPolicy()

    {

    if ( iPService != NULL )

        {

        iPService->CancelTransaction();

        delete iPService;

        iPService = NULL;

        }

    DoComplete( KErrCancel );

    }

EXPORT_C void CAgileProvisionWs::SetServiceAddr(const HBufC8* aServiceAddr)

    {

    iServiceAddr=aServiceAddr;

    }

void CAgileProvisionWs::DoGetPolicyL(const TDesC8& aEndPointUri, const TUint aIapId)

    {

    CSenXmlServiceDescription* pServiceDesc = CSenXmlServiceDescription::NewLC( aEndPointUri,

                                                                                    KNullDesC8() );

    iEndPointUri=&aEndPointUri;

    pServiceDesc->SetFrameworkIdL( KDefaultBasicWebServicesFrameworkID );            

    delete iPService;

    iPService = NULL;

    iPService  = CAgileProvisionServiceService::NewL( *this, *pServiceDesc );

    CleanupStack::PopAndDestroy( pServiceDesc );

    iPService->iIapId= aIapId;   

    iState = KStateGettingConf;

    }

void CAgileProvisionWs::HandleMessageL(const TDesC8& aMessage)

{

    iPService->ResetTransactionId();

    if ( iState == KStateGettingConf )

        {

        HandleGetConfSoapInL( aMessage );

        GenerateCertReqL();

        iPService->GetCertificateAsyncL(iPService->iCertreq);

        iState = KStateGettingCertificate;

        }

    else if ( iState == KStateGettingCertificate )

        {

        HandleGetCertificateSoapInL( aMessage );        

        DoComplete( KErrNone );

        iState = KStateInitial;

        }

    else

        {

        User::Leave( KErrArgument );

        }

}

void CAgileProvisionWs::HandleErrorL(const TInt aErrorCode, const TDesC8&  /*aError*/)

    {

    DoComplete( aErrorCode );

    }

void CAgileProvisionWs::SetStatus(const TInt aStatus)

    {

    TInt err = KErrNone;

    if ( aStatus == KSenConnectionStatusReady )

        {

        TRAP( err, iPService->GetConfAsyncL() );

        }

    else if ( aStatus == KSenConnectionStatusCreateFailed )

        {

        err = aStatus;

        }

    else

        {

        // Do nothing.

        }

    if ( err != KErrNone )

        {

        DoComplete( err );

        }

    }

EXPORT_C void CAgileProvisionWs::HandleGetConfSoapInL(const TDesC8& aMessage)

    {

    CSenXmlReader *pXmlReader = CSenXmlReader::NewL();

    CleanupStack::PushL(pXmlReader);

    //CSenDomFragment

    CSenDomFragment* pBase = CSenDomFragment::NewL();

    CleanupStack::PushL(pBase);

    //must set the content handler

    pXmlReader->SetContentHandler(*pBase);

   // and the reader

    pBase->SetReader(*pXmlReader);

    pXmlReader->ParseL(aMessage);

    RPointerArray<CSenElement>& array = pBase->AsElement().ElementsL();

	//start the listing of the elements, first level is 1

    TInt contentType(1);

	TInt vpnFilePathLth = KAgileProvisionPolicyFileName().Length() + KTempDirectory().Length();

	HBufC* vpnFilePathBuf = HBufC::NewLC(vpnFilePathLth);

	TPtr vpnFilePath(vpnFilePathBuf->Des());

	vpnFilePath.Copy(KTempDirectory);

	vpnFilePath.Append(KAgileProvisionPolicyFileName);

	ParseFileFromSoapEnvelopeL(array, contentType, 1, vpnFilePath);

    CleanupStack::PopAndDestroy(vpnFilePathBuf); // file

    CleanupStack::PopAndDestroy(pBase); // delete pXmlReader, procMsg, responseStr

    CleanupStack::PopAndDestroy(pXmlReader); // delete pXmlReader, procMsg, responseStr

    }

EXPORT_C void CAgileProvisionWs::HandleGetCertificateSoapInL(const TDesC8& aMessage)

    {

    CSenXmlReader *pXmlReader = CSenXmlReader::NewL();

    CleanupStack::PushL(pXmlReader);

    //CSenDomFragment

    CSenDomFragment* pBase = CSenDomFragment::NewL();

    CleanupStack::PushL(pBase);

    //must set the content handler

    pXmlReader->SetContentHandler(*pBase);

   // and the reader

    pBase->SetReader(*pXmlReader);

    pXmlReader->ParseL(aMessage);

    RPointerArray<CSenElement>& array = pBase->AsElement().ElementsL();

    //start the listing of the elements, first level is 1

    TInt vpnFilePathLth = KAgileProvisionCertificateFileName().Length() + KTempDirectory().Length();

    HBufC* vpnFilePathBuf = HBufC::NewLC(vpnFilePathLth);

    TPtr vpnFilePath(vpnFilePathBuf->Des());

    vpnFilePath.Copy(KTempDirectory);

    vpnFilePath.Append(KAgileProvisionCertificateFileName);

    TInt contentType(2);

    ParseFileFromSoapEnvelopeL(array, contentType, 1, vpnFilePath);

    CleanupStack::PopAndDestroy(vpnFilePathBuf); // file

    CleanupStack::PopAndDestroy(pBase); // delete pXmlReader, procMsg, responseStr

    CleanupStack::PopAndDestroy(pXmlReader); // delete pXmlReader, procMsg, responseStr

    }

// The listing of the elements is done in ListNodesL function:

void CAgileProvisionWs::ParseFileFromSoapEnvelopeL(RPointerArray<CSenElement>& aArray, 

                                                       TInt aContentType,TInt aLevel, TDesC& aFileName )

    {

    TInt size = aArray.Count();

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

        {

        //get an element

        CSenElement* pElement = aArray[i];

        if ( pElement->HasContent() )

            {

            //get the content of the element

            TPtrC8 content =  pElement->Content();

            TBase64Codec* base64Inst = new (ELeave) TBase64Codec();

            CleanupStack::PushL(base64Inst);

            HBufC8* dataBuf = base64Inst->Base64DecodeLC(content);

            HBufC8* fileBuf = base64Inst->Base64DecodeLC(*dataBuf);

            //CA from getConf envelope

            if ( aContentType == 1 && i==1 )

                {

                CAgileCryptoCert* agileClientCert = CAgileCryptoCert::NewL(fileBuf->Des(), EFalse);

                CleanupStack::PushL(agileClientCert);

                agileClientCert->SaveCACertL();

                CleanupStack::PopAndDestroy(agileClientCert);

                }

            else if ( aContentType == 2)

                {

                CAgileCryptoCert* agileClientCert = CAgileCryptoCert::NewL(fileBuf->Des(), ETrue);

                CleanupStack::PushL(agileClientCert);

                agileClientCert->SaveClientCertL(iKeyRef,KPublicKeyLen);

                CleanupStack::PopAndDestroy(agileClientCert);

                }

            else           

                {

                RFile file;

                RFs iFs;

                TInt err= iFs.Connect();

                CleanupClosePushL(file);

                User::LeaveIfError(file.Replace(iFs, aFileName, EFileWrite));

                User::LeaveIfError(file.Write(*fileBuf));

                //write pin file

                TInt vpnPinFilePathLth = KAgileProvisionPinFileName().Length() + KTempDirectory().Length();

                HBufC* vpnPinFilePathBuf = HBufC::NewLC(vpnPinFilePathLth);

                TPtr vpnPinFilePath(vpnPinFilePathBuf->Des());

                vpnPinFilePath.Copy(KTempDirectory);

                vpnPinFilePath.Append(KAgileProvisionPinFileName);

                User::LeaveIfError(file.Replace(iFs, vpnPinFilePath, EFileWrite));

                CleanupStack::PopAndDestroy(vpnPinFilePathBuf); // file                

                file.Flush();

                file.Close();

                CleanupStack::PopAndDestroy(&file);

                iFs.Close();

                }

			CleanupStack::PopAndDestroy(fileBuf);

            CleanupStack::PopAndDestroy(dataBuf);

            CleanupStack::PopAndDestroy(base64Inst);

            }

        //get the first child

        CSenElement* child = pElement->Child(0);

        //check if element has childs

        if( child )

            {

            //get the child elements

            RPointerArray<CSenElement>& tree = pElement->ElementsL();

            //list child elements by a recursive call

            ParseFileFromSoapEnvelopeL(tree, aContentType, ++aLevel, aFileName);

            }

        aLevel--;

        } //for loop ends

  }

EXPORT_C void CAgileProvisionWs::GenerateCertReqL()

    {

    TRequestStatus status;

    CAgileCryptoPrivKey* agileCryptoPrivKey = CAgileCryptoPrivKey::NewL();

    CleanupStack::PushL(agileCryptoPrivKey);

    CAgileCryptoGenerateKeypair* agileCryptoGenerateKeypair = CAgileCryptoGenerateKeypair::NewL(agileCryptoPrivKey);

    CleanupStack::PushL(agileCryptoGenerateKeypair);

    // generate key

    agileCryptoGenerateKeypair->GenerateKeypairL(KPublicKeyLen, iKeyRef, status);

    User::WaitForRequest(status);

    // generate subjectname

    _LIT8(KCnHeader, "CN=");

    _LIT8(KCnUsername, "vpnuser");

    TInt distinguishedNameLth = KCnHeader().Length() + KCnUsername().Length();

    HBufC8* distinguishedNameHBuf = HBufC8::NewLC(distinguishedNameLth);

    TPtr8 distinguishedName(distinguishedNameHBuf->Des());

    distinguishedName.Copy(KCnHeader);

    distinguishedName.Append(KCnUsername);

    // generate certreq

    const TInt KDmAdMaxCertReqRefLth = KMaxFileName;

    HBufC* certReqRef = HBufC::NewLC(KDmAdMaxCertReqRefLth);

    TPtr certReqRefPtr(certReqRef->Des());

    TInt certReqSize;

    agileCryptoPrivKey->GenerateCertReqL(*distinguishedNameHBuf, //subjectname

                                                           KNullDesC8, // subjectaltname

                                                           KNullDesC8, //aChallengePassword,

                                                           KNullDesC8, //DnsName,

                                                           iKeyRef,

                                                           certReqRefPtr,

                                                           certReqSize);

    // read certreq

    TRetBufCertReq certReq;

    certReq = agileCryptoPrivKey->ReadCertReqL(certReqRefPtr, certReqSize);

    if ( iPService )

        {

        iPService->iCertreq = certReq;

        }

    else

        {

        delete certReq;

        certReq=NULL;

        }

    CleanupStack::PopAndDestroy(certReqRef);

    CleanupStack::PopAndDestroy(distinguishedNameHBuf);

    CleanupStack::PopAndDestroy(agileCryptoGenerateKeypair);

    CleanupStack::PopAndDestroy(agileCryptoPrivKey);            

    }

void CAgileProvisionWs::DoComplete( const TInt aStatus )

    {

    if ( iClientStatus != NULL )

        {

        User::RequestComplete( iClientStatus,

                               aStatus );

        }

    }