diff -r 000000000000 -r 33413c0669b9 vpnengine/vpnmanager/src/vpnapiservant.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vpnengine/vpnmanager/src/vpnapiservant.cpp Thu Dec 17 09:14:51 2009 +0200 @@ -0,0 +1,480 @@ +/* +* Copyright (c) 2003 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 "vpnapiservant.h" +#include "policystore.h" +#include "policyimporter.h" +#include "pwdchanger.h" +#include "vpnapidefs.h" +#include "vpnmanagerserverdefs.h" +#include "vpnmaninternal.h" +#include "log_r6.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) + { + } + +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; + + 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 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 pckgPolicyId(policyId); + + aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId); + + TVpnPolicyDetails policyDetails; + TInt ret = iPolicyStore->GetPolicyDetailsL(policyId, policyDetails); + + if (ret == KErrNone) + { + TPckg pckgPolicyDetails(policyDetails); + aMessage.WriteL(SECOND_ARGUMENT, pckgPolicyDetails); + } + + + aMessage.Complete(ret); + + LOG(Log::Printf(_L("CVpnApiServant::GetPolicyDetailsL: aMesage completed withd %d"), ret)); + } + +void CVpnApiServant::DeletePolicyL(const RMessage2& aMessage) + { + TVpnPolicyId policyId; + TPckg 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 pckgPolicyId(policyId); + + aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId); + + TInt policySize = PolicySizeL(policyId); + + TPckg pckgPolicySize(policySize); + aMessage.WriteL(SECOND_ARGUMENT, pckgPolicySize); + + aMessage.Complete(KErrNone); + } + +void CVpnApiServant::GetPolicyDataL(const RMessage2& aMessage) + { + TVpnPolicyId policyId; + TPckg pckgPolicyId(policyId); + + aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyId); + + TInt expectedPolicySize; + TPckg 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 pckgPolicyDetails(*policyDetails); + + aMessage.ReadL(FIRST_ARGUMENT, pckgPolicyDetails); + + // 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); + + + LOG(Log::Printf(_L("Calling: iPolicyStore->AddNewPolicyL"))); + // Add the policy to the policy store + TRAPD(err, iPolicyStore->AddNewPolicyL(*policyDetails, *policyData)); + if (err == KErrNone) + { + TBuf<20> serverName(_L("VPN DM Server")); + TPtrC8 tempCastPtr8(reinterpret_cast(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 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 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); + }