diff -r 352850cbed81 -r 9f4e37332ce5 vpnengine/agileprovisionws/src/agileprovisionws.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/agileprovisionws/src/agileprovisionws.cpp	Thu Aug 19 10:54:34 2010 +0300
@@ -0,0 +1,378 @@
+/*
+* 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 );
+        }
+    }