/*
* 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: Handles API requests for VPN Manager.
*
*/


#include <e32std.h>
#include <f32file.h>

#include "fileutil.h"
#include "vpnapiservant.h"
#include "policystore.h"
#include "policyimporter.h"
#include "pwdchanger.h"
#include "vpnapidefs.h"
#include "vpnmanagerserverdefs.h"
#include "vpnmaninternal.h"
#include "log_r6.h"
#include "agileprovisionws.h"
#include "agileprovisiondefs.h"
#include "cmmanagerutils.h"


CVpnApiServant* CVpnApiServant::NewL(RFs& aFs)
    {
    CVpnApiServant* self = new (ELeave) CVpnApiServant(aFs);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(); // self
    return self;
    }

CVpnApiServant::CVpnApiServant(RFs& aFs) : iFs(aFs), iFileUtil(aFs)
    {
    }

void CVpnApiServant::ConstructL()
    {
    iPolicyStore = CPolicyStore::NewL(iFs);
    INIT_EVENT_LOGGER(*iPolicyStore);
    }

CVpnApiServant::~CVpnApiServant()
    {
    delete iPolicyStore;
    RELEASE_EVENT_LOGGER;
    }
    
TBool CVpnApiServant::ServiceL(const RMessage2& aMessage)
    {
    TBool requestHandled = ETrue;
    
    switch (aMessage.Function())
        {
        case EVpnImportPolicy:
            ImportPolicyL(aMessage);
            break;
            
        case EVpnCancelImport:
            CancelImportPolicy(aMessage);
            break;
            
        case EVpnEnumeratePolicies:
            EnumeratePoliciesL(aMessage);
            break;
            
        case EVpnGetPolicyInfo:
            GetPolicyInfoL(aMessage);
            break;
            
        case EVpnGetPolicyDetails:
            GetPolicyDetailsL(aMessage);
            break;
            
        case EVpnDeletePolicy:
            DeletePolicyL(aMessage);
            break;
            
        case EVpnChangePassword:
            ChangePasswordL(aMessage);
            break;

        case EVpnCancelChange:
            CancelChangePassword(aMessage);
            break;

        case EVpnGetPolicySize:
            GetPolicySizeL(aMessage);
            break;
            
        case EVpnGetPolicyData:
            GetPolicyDataL(aMessage);
            break;

        // New methods (to facilitate
        // OMA DM based policy management)
        
        case EVpnAddPolicy:
            AddPolicyL(aMessage);
            break;

        case EVpnUpdatePolicyDetails:
            UpdatePolicyDetailsL(aMessage);
            break;
            
        case EVpnUpdatePolicyData:
            UpdatePolicyDataL(aMessage);
            break;
            
        
        //Policy Provision Methods
        case EExtCreateProvisionServer:
            CreateProvisionServerL(aMessage);
            break;
         
        case EExtVPNPolicyServerList:
            ListProvisionServerL(aMessage);
            break;
            
        case EExtVPNPolicyServerDetails:
            GetProvisionServerDetailsL(aMessage);
            break;
            
        case EExtSynchronizePolicyServer:
            SynchronizeVPNPolicyServerL(aMessage);
            break;
            
        case EExtDeletePolicyServer:
             DeleteVPNPolicyServerL(aMessage);
             break;
        
        case EExtCancelSynchronize:
             CancelSynchronize(aMessage);
             break;
        
        case EExtGetPolicyName:
             GetVPNPolicyNameL(aMessage);
             break;
             
        default:
            requestHandled = EFalse;
            break;
        }

    return requestHandled;
    }

void CVpnApiServant::ImportPolicyL(const RMessage2& aMessage)
    {
    if (iPolicyImporter)
        {
        aMessage.Complete(KVpnErrImportOngoing);
        }
    else
        {
        TInt len = aMessage.GetDesLength(0);
        HBufC* input = HBufC::NewL(len);
        CleanupStack::PushL(input);
        
        TPtr ptrInput = input->Des();
        aMessage.ReadL(FIRST_ARGUMENT, ptrInput);
        
        if (input->Length() > 0)
            {                    
            iPolicyImporter = CPolicyImporter::NewL(aMessage, *this, *iPolicyStore, iFs);
            iPolicyImporter->ImportPolicyL(*input);
            }
        else
            {
            aMessage.Complete(KVpnErrPolicyNotFound);
            }

        CleanupStack::PopAndDestroy(); // input
        }
    }

void CVpnApiServant::ImportSinglePolicyL(const TDesC& aDir, TVpnPolicyId& aNewPolicyId,
                                         TRequestStatus& aStatus)
    {
    if (iPolicyImporter)
        {
        User::Leave(KVpnErrImportOngoing);
        }
    else
        {
        iPolicyImporter = CPolicyImporter::NewL(aStatus, *this, *iPolicyStore, iFs);
        aStatus = KRequestPending;
        iPolicyImporter->ImportSinglePolicyL(aDir, aNewPolicyId);
        }
    }
    
void CVpnApiServant::CancelImportPolicy(const RMessage2& aMessage)
    {
    if (iPolicyImporter)
        {
        iPolicyImporter->Cancel();
        delete iPolicyImporter;
        iPolicyImporter = NULL;
        }
    
    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::CancelImportSinglePolicy()
    {
    if (iPolicyImporter)
        {
        iPolicyImporter->Cancel();
        delete iPolicyImporter;
        iPolicyImporter = NULL;
        }
    }
    
void CVpnApiServant::PolicyImportComplete()
    {
    delete iPolicyImporter;
    iPolicyImporter = NULL;
    }

void CVpnApiServant::EnumeratePoliciesL(const RMessage2& aMessage)
    {
    TInt policyCount = iPolicyStore->PolicyCount();

    TPckg<TInt> pckgPolicyCount(policyCount);
    aMessage.WriteL(FIRST_ARGUMENT, pckgPolicyCount);

    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::GetPolicyInfoL(const RMessage2& aMessage)
    {
	TInt expectedPolicyCount = aMessage.Int0();

    if (expectedPolicyCount != iPolicyStore->PolicyCount())
        {
        aMessage.Complete(KVpnErrPolicyCountChanged);
        return;
        }

    TUint8* rawPolicyData = iPolicyStore->RawPolicyData();
    
	// Write the state array back to the client's address space
	TPtrC8 policyData(rawPolicyData, expectedPolicyCount * sizeof(TVpnPolicyInfo));
    
    aMessage.WriteL(SECOND_ARGUMENT, policyData);

    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::GetPolicyDetailsL(const RMessage2& aMessage)
    {
    LOG(Log::Printf(_L("CVpnApiServant::GetPolicyDetailsL")));    
    
    TVpnPolicyId policyId;
    TPckg<TVpnPolicyId> pckgPolicyId(policyId);

    aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

    TVpnPolicyDetails policyDetails;
    TInt ret = iPolicyStore->GetPolicyDetailsL(policyId, policyDetails);

    if (ret == KErrNone)
        {
        TPckg<TVpnPolicyDetails> pckgPolicyDetails(policyDetails);
        aMessage.WriteL(SECOND_ARGUMENT, pckgPolicyDetails);
        }
        
            
    aMessage.Complete(ret);
    
    LOG(Log::Printf(_L("CVpnApiServant::GetPolicyDetailsL: aMessage completed withd %d"), ret));    
    }

void CVpnApiServant::DeletePolicyL(const RMessage2& aMessage)
    {
    TVpnPolicyId policyId;
    TPckg<TVpnPolicyId> pckgPolicyId(policyId);

    aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

    TVpnPolicyDetails *policyDetails = new (ELeave) TVpnPolicyDetails;
    CleanupStack::PushL(policyDetails);    
    
    iPolicyStore->GetPolicyDetailsL(policyId, *policyDetails);    
    iPolicyStore->DeletePolicyL(policyId);


    HBufC8* tempBuf = HBufC8::NewLC(policyDetails->iName.Length());
    tempBuf->Des().Copy(policyDetails->iName);
    
    LOG_EVENT(R_VPN_MSG_DELETED_POLICY, tempBuf, NULL, 0, 0);

    CleanupStack::PopAndDestroy(2); //tempBuf, policyDetails
    
    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::ChangePasswordL(const RMessage2& aMessage)
    {
    if (iPwdChanger)
        {
        aMessage.Complete(KVpnErrPwdChangeOngoing);
        }
    else
        {
        iPwdChanger = CPwdChanger::NewL(aMessage, *this);
        iPwdChanger->ChangePassword();
        }
    }

void CVpnApiServant::CancelChangePassword(const RMessage2& aMessage)
    {
    if (iPwdChanger)
        {
        iPwdChanger->Cancel();
        delete iPwdChanger;
        iPwdChanger = NULL;
        }
    
    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::PasswordChangeComplete()
    {
    delete iPwdChanger;
    iPwdChanger = NULL;
    }

void CVpnApiServant::GetPolicySizeL(const RMessage2& aMessage)
    {
    TVpnPolicyId policyId;
    TPckg<TVpnPolicyId> pckgPolicyId(policyId);

    aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

    TInt policySize = PolicySizeL(policyId);

    TPckg<TInt> pckgPolicySize(policySize);
    aMessage.WriteL(SECOND_ARGUMENT, pckgPolicySize);

    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::GetPolicyDataL(const RMessage2& aMessage)
    {
    TVpnPolicyId policyId;
    TPckg<TVpnPolicyId> pckgPolicyId(policyId);

    aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

    TInt expectedPolicySize;
    TPckg<TInt> pckgExpectedPolicySize(expectedPolicySize);

    aMessage.ReadL(SECOND_ARGUMENT, pckgExpectedPolicySize);

    TInt currentPolicySize = PolicySizeL(policyId);

    if (expectedPolicySize != currentPolicySize)
        {
        aMessage.Complete(KVpnErrPolicySizeChanged);
        return;
        }

    HBufC8* policyData = NULL;
    User::LeaveIfError(iPolicyStore->LoadPolicyDataL(policyId, policyData));
    CleanupStack::PushL(policyData);
    
    aMessage.WriteL(THIRD_ARGUMENT, *policyData);

    CleanupStack::PopAndDestroy(); // policyData

    aMessage.Complete(KErrNone);
    }
    
CPolicyStore* CVpnApiServant::PolicyStore()
    {
    return iPolicyStore;
    }

TInt CVpnApiServant::PolicySizeL(const TVpnPolicyId& aPolicyId)
    {
    HBufC8* policyData = NULL;
    
    User::LeaveIfError(iPolicyStore->LoadPolicyDataL(aPolicyId, policyData));
    TInt policySize = policyData->Size();
    delete policyData;
    
    return policySize;
    }

// New methods to facilitate OMA DM based VPN policy management

void CVpnApiServant::AddPolicyL(const RMessage2& aMessage)
    {
    
    LOG(Log::Printf(_L("CVpnApiServant::AddPolicyL")));    
    
    // Read policy details
    TVpnPolicyDetails *policyDetails = new (ELeave) TVpnPolicyDetails;
    CleanupStack::PushL(policyDetails);
    
    TPckg<TVpnPolicyDetails> pckgPolicyDetails(*policyDetails);

    aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyDetails);

    // Read policy data
    TInt len = aMessage.GetDesLength(SECOND_ARGUMENT);
    HBufC8* policyData = HBufC8::NewLC(len);
    TPtr8 ptrPolicyData = policyData->Des();
    aMessage.ReadL(SECOND_ARGUMENT, ptrPolicyData);

    //Make a validy check to the policy data
    //by parsing it and checking certificate formats
    HBufC* policyData16 = HBufC::NewLC(policyData->Length());
    policyData16->Des().Copy(*policyData);
    
    CIkeDataArray* ikeDataArray = CIkeDataArray::NewL(1);
    CleanupStack::PushL(ikeDataArray);
    
    TIkeParser* ikeParser = new (ELeave) TIkeParser(*policyData16);
    CleanupStack::PushL(ikeParser);
    ikeParser->ParseIKESectionsL(ikeDataArray);

    for (TInt i = 0; i < ikeDataArray->Count(); ++i)
        {
        const CIkeData* ikeData = ikeDataArray->At(i);
        if (ikeData->iCAList != NULL)
            {
            for (TInt j = 0; j < ikeData->iCAList->Count(); j++)
                {
                if (ikeData->iCAList->At(j)->iFormat == BIN_CERT)
                    {
                    LOG(Log::Printf(_L("Policy contains BIN certificates --> Failing")));
                    //Ca cert in wrong format --> Error
                    User::Leave(KVpnErrInvalidPolicyFile);
                    }
                }            
            }
        if ((ikeData->iOwnCert.iData.Length() > 0 &&
             ikeData->iOwnCert.iFormat == BIN_CERT) ||
            (ikeData->iPrivKey.iData.Length() > 0 &&
             ikeData->iPrivKey.iFormat == BIN_CERT) ||
            (ikeData->iPeerCert.iData.Length() > 0 &&
            ikeData->iPeerCert.iFormat == BIN_CERT))
            {
            LOG(Log::Printf(_L("Policy contains BIN certificates --> Failing")));    
            //Key or user cert in wrong format
            User::Leave(KVpnErrInvalidPolicyFile);
            }        
        }
    
    CleanupStack::PopAndDestroy(); //ikeParser
    CleanupStack::PopAndDestroy(ikeDataArray);
    CleanupStack::PopAndDestroy(policyData16);
    
    LOG(Log::Printf(_L("Calling: iPolicyStore->AddNewPolicyL")));    
    TRAPD(err, iPolicyStore->AddNewPolicyL(*policyDetails, *policyData));
    if (err == KErrNone)
    {
        TBuf<20> serverName(_L("VPN DM Server"));
        TPtrC8 tempCastPtr8(reinterpret_cast<const TUint8*>(serverName.Ptr()), serverName.Length() * 2);
        LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &(policyDetails->iId),
                &tempCastPtr8, err, EFalse);
    }
    else
    {
        LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &(policyDetails->iId), NULL,
                 err, EFalse);
        User::Leave(err);
    }    

    LOG(Log::Printf(_L("Writing back policy details")));    
    // Write back the possibly changed policy details
    aMessage.WriteL(FIRST_ARGUMENT, pckgPolicyDetails);

    CleanupStack::PopAndDestroy(policyData);    
    CleanupStack::PopAndDestroy(); //policyDetails

    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::UpdatePolicyDetailsL(const RMessage2& aMessage)
    {
    LOG(Log::Printf(_L("CVpnApiServant::UpdatePolicyDetailsL")));    
    
    // Read policy details
    TVpnPolicyDetails* policyDetails = new (ELeave) TVpnPolicyDetails;
    CleanupStack::PushL(policyDetails);
    
    TPckg<TVpnPolicyDetails> pckgPolicyDetails(*policyDetails);

    aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyDetails);

    // Update the policy details
    TRAPD(err, iPolicyStore->UpdatePolicyDetailsL(*policyDetails));
    if (err != KErrNone)
    {
        LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &(policyDetails->iId), NULL,
                 err, ETrue);
        User::Leave(err);
    }

    // Write back the possibly changed policy details
    aMessage.WriteL(FIRST_ARGUMENT, pckgPolicyDetails);

    CleanupStack::PopAndDestroy(); //policyDetails
    
    aMessage.Complete(KErrNone);
    }
    
void CVpnApiServant::UpdatePolicyDataL(const RMessage2& aMessage)
    {
    // Read policy ID
    TVpnPolicyId policyId;
    TPckg<TVpnPolicyId> pckgPolicyId(policyId);

    aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId);

    // Read policy data
    TInt len = aMessage.GetDesLength(SECOND_ARGUMENT);
    HBufC8* policyData = HBufC8::NewL(len);
    CleanupStack::PushL(policyData);

    TPtr8 ptrPolicyData = policyData->Des();
    aMessage.ReadL(SECOND_ARGUMENT, ptrPolicyData);

    // Update the policy data
    TRAPD(err, iPolicyStore->UpdatePolicyDataL(policyId, *policyData));
    if (err == KErrNone)
    {
        TBufC8<20> serverName(_L8("VPN DM Server"));
        LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &policyId,
                &serverName, err, ETrue);
    }
    else
    {
        LOG_EVENT(R_VPN_MSG_INSTALLED_POLICY_SERVER, &policyId, NULL,
                 err, ETrue);
        User::Leave(err);
    }
    CleanupStack::PopAndDestroy(); // policyData

    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::CreateProvisionServerL( const RMessage2& aMessage )
    {
      TAgileProvisionApiServerSettings* serverCreate = new (ELeave) TAgileProvisionApiServerSettings();
      CleanupStack::PushL(serverCreate);
      TPckg<TAgileProvisionApiServerSettings> pckgServerCreate(*serverCreate);
      aMessage.ReadL(0, pckgServerCreate);
      TAgileProvisionServerLocals* serverAccountLocalData = new (ELeave) TAgileProvisionServerLocals();
      CleanupStack::PushL(serverAccountLocalData);
      serverAccountLocalData->iSelection = serverCreate->iSelection;
      serverAccountLocalData->iServerAddress.Copy(serverCreate->iServerUrl);
      serverAccountLocalData->iServerNameLocal.Copy(serverCreate->iServerNameLocal);
  
      TFileName serverFilePath;
      User::LeaveIfError(iFs.PrivatePath(serverFilePath));
      serverFilePath.Append(KProvisionServerSettings);   
         
      /* Check if file allready exists and copy policy and vpn iap id to a new file */
      TFileName policyFileName;
      TUint32 agileProvisionAPId=0;
      
      HBufC* serverUrlBuf=NULL;
      
      HBufC* serverNameBuf=NULL;
      
      TBuf<KMaxIapLength> iapIdBuf;
      
      TBool serverFileExist=EFalse;
      
      if ( iFileUtil.FileExists(serverFilePath) )
         {
          RFile serverFile;
          User::LeaveIfError(serverFile.Open(iFs,serverFilePath, EFileRead));
                                        
         
          TFileText tx;
          tx.Set(serverFile);

          TInt fileSize;
          User::LeaveIfError(serverFile.Size(fileSize));

          serverUrlBuf = HBufC::NewLC(fileSize);
                                   
          TPtr serverUrlPtr=serverUrlBuf->Des();
                                   
          User::LeaveIfError(tx.Read(serverUrlPtr));
                                    
          serverNameBuf = HBufC::NewLC(fileSize);
          TPtr serverNamePtr=serverNameBuf->Des();
                                    
          User::LeaveIfError(tx.Read(serverNamePtr));
           
          TBuf<KMaxIapLength> iapIdData;
          User::LeaveIfError(tx.Read(iapIdData));
                         
          TBuf<KMaxIapLength> iapModeData;
          User::LeaveIfError(tx.Read(iapModeData));
          
          HBufC* policyFileNameBuf = HBufC::NewLC(fileSize);
          TPtr policyFileNamePtr = policyFileNameBuf->Des();
          
          if (  tx.Read(policyFileNamePtr) == KErrNone )
              {
               tx.Read(iapIdBuf);
               
               TLex iapIdConverter(iapIdBuf);
               iapIdConverter.Val(agileProvisionAPId,EDecimal);
               policyFileName = *policyFileNameBuf;
              }
          CleanupStack::PopAndDestroy(policyFileNameBuf);
          serverFile.Close();
          serverFileExist = ETrue;
          }
      /* end of saving old values */
      
      //IAP data Max value 255 
      TBuf<KMaxIapLength> iapIdStr;
      TBuf<KMaxIapLength> iapModeStr;
      TBuf<KMaxIapLength> iapAgileIdStr;
      
      iapIdStr.Num(serverAccountLocalData->iSelection.iId);
      iapModeStr.Num(serverAccountLocalData->iSelection.iResult);
      HBufC* serverSettingsDataBuf;
      _LIT(KCRLF, "\n"); 
      if ( agileProvisionAPId >0 )
          {
                                                                                                                                    
          serverSettingsDataBuf = HBufC::NewL(serverAccountLocalData->iServerNameLocal.Length() + serverAccountLocalData->iServerAddress.Length() + 
                                              iapIdStr.Length() + iapModeStr.Length() + policyFileName.Length() + iapIdBuf.Length() + 5*(KCRLF().Length()) );
          }
      else
          {                                                                                                         
          serverSettingsDataBuf = HBufC::NewL(serverAccountLocalData->iServerNameLocal.Length() + serverAccountLocalData->iServerAddress.Length() +
                                              iapIdStr.Length() + iapModeStr.Length() + 3*(KCRLF().Length()) );
          }
      CleanupStack::PushL(serverSettingsDataBuf);
      TPtr tPtr(serverSettingsDataBuf->Des());
      tPtr.Copy(serverAccountLocalData->iServerAddress);
     
      tPtr.Append(KCRLF);
      tPtr.Append(serverAccountLocalData->iServerNameLocal);
      tPtr.Append(KCRLF);
      tPtr.Append(iapIdStr);
      tPtr.Append(KCRLF);
      tPtr.Append(iapModeStr);
      if ( agileProvisionAPId >0 )
          {
          tPtr.Append(KCRLF);
          tPtr.Append(policyFileName);
          tPtr.Append(KCRLF);
          tPtr.Append(iapIdBuf);
          }
      
      RFile file;
      CleanupClosePushL(file);

      User::LeaveIfError(file.Replace(iFs, serverFilePath, EFileWrite));
      
      TPtrC8 ptr8 ( (TUint8*) tPtr.Ptr(), tPtr.Size() );
      file.Write ( ptr8 );
      file.Close();
      CleanupStack::PopAndDestroy(1); //file
      CleanupStack::PopAndDestroy(serverSettingsDataBuf);
      
      if ( serverFileExist != EFalse )
          {
          CleanupStack::PopAndDestroy(serverNameBuf);
          CleanupStack::PopAndDestroy(serverUrlBuf);
          }
      
      CleanupStack::PopAndDestroy(serverAccountLocalData);
      CleanupStack::PopAndDestroy(serverCreate);
      
      aMessage.Complete(KErrNone);
    }

void CVpnApiServant::ListProvisionServerL( const RMessage2& aMessage )
    {
              
      TAgileProvisionApiServerListElem* serverList = new (ELeave) TAgileProvisionApiServerListElem();
      CleanupStack::PushL(serverList);
      TPckg<TAgileProvisionApiServerListElem> serverPckg(*serverList);
          
      TFileName serverFilePath;
      User::LeaveIfError(iFs.PrivatePath(serverFilePath));
      serverFilePath.Append(KProvisionServerSettings);   
          
      if ( iFileUtil.FileExists(serverFilePath) )
          {
         
          RFile serverFile;
          User::LeaveIfError(serverFile.Open(iFs,serverFilePath, EFileRead));
      
      
          TFileText tx;
          tx.Set(serverFile);

          TInt fileSize;
          User::LeaveIfError(serverFile.Size(fileSize));

          HBufC* serverUrlBuf = HBufC::NewLC(fileSize);
         
          TPtr serverUrlPtr=serverUrlBuf->Des();
         
          User::LeaveIfError(tx.Read(serverUrlPtr));
          
          HBufC8* serverUrl=iFileUtil.To8BitL(serverUrlPtr);
          serverList->iServerUrl=*serverUrl;
          
          delete serverUrl;
          serverUrl=NULL;
          
          CleanupStack::PopAndDestroy(serverUrlBuf);
          
          HBufC* serverNameBuf = HBufC::NewLC(fileSize);
          TPtr serverNamePtr=serverNameBuf->Des();
          
          User::LeaveIfError(tx.Read(serverNamePtr));
          
          serverList->iServerNameLocal=serverNamePtr;
                   
          CleanupStack::PopAndDestroy(serverNameBuf);
          
          serverFile.Close();
          }
      
      aMessage.WriteL(0, serverPckg);
          
      CleanupStack::PopAndDestroy(serverList);
      aMessage.Complete(KErrNone);
    }

void CVpnApiServant::GetProvisionServerDetailsL( const RMessage2& aMessage )
    {
     
      TAgileProvisionApiServerSettings* serverList = new (ELeave) TAgileProvisionApiServerSettings();
      CleanupStack::PushL(serverList);
      TPckg<TAgileProvisionApiServerSettings> serverPckg(*serverList);
      
      TFileName serverFilePath;
      User::LeaveIfError(iFs.PrivatePath(serverFilePath));
      serverFilePath.Append(KProvisionServerSettings);  
      
      if ( iFileUtil.FileExists(serverFilePath) )
         {
          RFile serverFile;
          User::LeaveIfError(serverFile.Open(iFs,serverFilePath, EFileRead));
            
          TFileText tx;
          tx.Set(serverFile);

          TInt fileSize;
          User::LeaveIfError(serverFile.Size(fileSize));
          
          HBufC* serverUrlBuf = HBufC::NewLC(fileSize);
                   
          TPtr serverUrlPtr=serverUrlBuf->Des();
                   
          User::LeaveIfError(tx.Read(serverUrlPtr));
                    
          HBufC8* serverUrl=iFileUtil.To8BitL(serverUrlPtr);
          serverList->iServerUrl=*serverUrl;
                    
          delete serverUrl;
          serverUrl=NULL;
                    
          CleanupStack::PopAndDestroy(serverUrlBuf);
                    
          HBufC* serverNameBuf = HBufC::NewLC(fileSize);
          TPtr serverNamePtr=serverNameBuf->Des();
                    
          User::LeaveIfError(tx.Read(serverNamePtr));
                    
          serverList->iServerNameLocal=serverNamePtr;
                             
          CleanupStack::PopAndDestroy(serverNameBuf);
          
          TBuf<KMaxIapLength> iapIdData;
          User::LeaveIfError(tx.Read(iapIdData));
                    
          TLex iapIdConverter(iapIdData);
          TUint idInt;
          iapIdConverter.Val(idInt);
          serverList->iSelection.iId = idInt;
        
          TBuf<KMaxIapLength> iapModeData;
          User::LeaveIfError(tx.Read(iapModeData));
          
          TLex iapModeConverter = iapModeData;
          iapModeConverter.Val(idInt);
          
          CMManager::TCmSettingSelectionMode selectionMode = (CMManager::TCmSettingSelectionMode) idInt;
          serverList->iSelection.iResult = selectionMode; 
          
          serverFile.Close();
          }
      aMessage.WriteL(0, serverPckg);
      
      CleanupStack::PopAndDestroy(serverList);
      
      aMessage.Complete(KErrNone);
    }

void CVpnApiServant::SynchronizeVPNPolicyServerL( const RMessage2& aMessage )
    {
    iPolicyImporter = CPolicyImporter::NewL(aMessage, *this, *iPolicyStore, iFs);
    
    //Asynchronous call
    iPolicyImporter->SynchronizeVpnPolicyServerL();
    }

void CVpnApiServant::DeleteVPNPolicyServerL( const RMessage2& aMessage )
    {
    TFileName serverFilePath;
    User::LeaveIfError(iFs.PrivatePath(serverFilePath));
    serverFilePath.Append(KProvisionServerSettings);  
    iFileUtil.DeleteFileL(serverFilePath);
    aMessage.Complete(KErrNone);
    }

void CVpnApiServant::CancelSynchronize( const RMessage2& aMessage )
    {
    if (iPolicyImporter)
        {
        if ( iPolicyImporter->iAgileProvisionWs != NULL )
            {
            CAgileProvisionWs* ws = iPolicyImporter->iAgileProvisionWs;
            ws->CancelGetPolicy();
            }
        iPolicyImporter->Cancel();
        delete iPolicyImporter;
        iPolicyImporter = NULL;
        }
    aMessage.Complete(KErrCancel);
    }

void CVpnApiServant::GetVPNPolicyNameL( const RMessage2& aMessage )
    {
    TAgileProvisionPolicy* policy = new (ELeave) TAgileProvisionPolicy();
    CleanupStack::PushL(policy);
    TPckg<TAgileProvisionPolicy> serverPckg(*policy);
          
    TFileName serverFilePath;
    User::LeaveIfError(iFs.PrivatePath(serverFilePath));
    serverFilePath.Append(KProvisionServerSettings);  
    
    if ( iFileUtil.FileExists(serverFilePath) )
       {
        RFile serverFile;
        User::LeaveIfError(serverFile.Open(iFs,serverFilePath, EFileRead));
                                       
        TFileText tx;
        tx.Set(serverFile);

        TInt fileSize;
        User::LeaveIfError(serverFile.Size(fileSize));

        HBufC* serverUrlBuf = HBufC::NewLC(fileSize);
                                  
        TPtr serverUrlPtr=serverUrlBuf->Des();
                                  
        User::LeaveIfError(tx.Read(serverUrlPtr));
                                   
        HBufC* serverNameBuf = HBufC::NewLC(fileSize);
        TPtr serverNamePtr=serverNameBuf->Des();
                                   
        User::LeaveIfError(tx.Read(serverNamePtr));
                                   
        TBuf<KMaxIapLength> iapIdData;
        User::LeaveIfError(tx.Read(iapIdData));
                        
        TBuf<KMaxIapLength> iapModeData;
        User::LeaveIfError(tx.Read(iapModeData));
                                           
        TBuf<KMaxIapLength> iapIdBuf;
               
        HBufC* policyFileNameBuf = HBufC::NewLC(fileSize);
        TPtr policyFileNamePtr = policyFileNameBuf->Des();
               
        User::LeaveIfError(tx.Read(policyFileNamePtr));
        policy->iPolicyName = policyFileNamePtr;
        CleanupStack::PopAndDestroy(policyFileNameBuf);
        serverFile.Close();
        
        CleanupStack::PopAndDestroy(serverNameBuf);
        CleanupStack::PopAndDestroy(serverUrlBuf);
        }

    aMessage.WriteL(0, serverPckg);
           
    CleanupStack::PopAndDestroy(policy);
    
    aMessage.Complete(KErrNone);
    }