diff -r 000000000000 -r d0791faffa3f backupandrestore/backuptest/ABTester/src/abdataowner.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/backupandrestore/backuptest/ABTester/src/abdataowner.cpp Tue Feb 02 01:11:40 2010 +0200 @@ -0,0 +1,443 @@ +// Copyright (c) 2005-2009 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: +// + +/** +@file + +CABDataOwnerCallbackImplementation implementation +*/ + +#include "abdataowner.h" +#include "abtesterlog.h" +#include + +namespace conn + { + const TInt KSourceSize = 8000; + + CABDataOwnerCallbackImplementation* CABDataOwnerCallbackImplementation::NewL(TSecureId aID) + { + CABDataOwnerCallbackImplementation* self = new (ELeave) CABDataOwnerCallbackImplementation(aID); + //CleanupStack::PushL(self); + //self->ConstructL(); + //CleanupStack::Pop(self); + return self; + } + + + + CABDataOwnerCallbackImplementation::CABDataOwnerCallbackImplementation(TSecureId aID) : iABClient(NULL), iVersion(1,0,0), iProxy(EFalse), iSourceSize(KSourceSize), iID(aID) + { + } + + void CABDataOwnerCallbackImplementation::SetABClient(CActiveBackupClient* aABClient) + { + iABClient = aABClient; + } + + CABDataOwnerCallbackImplementation::~CABDataOwnerCallbackImplementation() + { + delete iABClient; + delete iSnapshot; + delete iData; + } + + // from MActiveBackupDataClient - callbacks + void CABDataOwnerCallbackImplementation::AllSnapshotsSuppliedL() + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::AllSnapshotsSuppliedL()", iID.iId); + } + + void CABDataOwnerCallbackImplementation::ReceiveSnapshotDataL(TDriveNumber aDrive, TDesC8& aBuffer, TBool /*aLastSection*/) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::ReceiveSnapshotDataL()", iID.iId); + // Create or append a buffer containing the snapshot + if (!iSnapshot) + { + iSnapshot = CABData::NewL(aDrive); + } + + iSnapshot->AddDataL(aBuffer); + } + + TUint CABDataOwnerCallbackImplementation::GetExpectedDataSize(TDriveNumber /*aDrive*/) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::GetExpectedDataSize()", iID.iId); + + return iSourceSize; + } + + void CABDataOwnerCallbackImplementation::GetSnapshotDataL(TDriveNumber /*aDrive*/, TPtr8& aBuffer, TBool& aFinished) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::GetSnapshotDataL()", iID.iId); + aBuffer.Append(KABTestSnapshot()); + + aFinished = ETrue; + } + + void CABDataOwnerCallbackImplementation::InitialiseGetBackupDataL(TDriveNumber /*aDrive*/) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::InitialiseGetBackupData()", iID.iId); + iOffset = 0; + + if (!iSnapshot) + { + iFillChar = 66; + } + else + { + iFillChar = 73; + } + } + + void CABDataOwnerCallbackImplementation::GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinished) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::GetBackupDataSectionL()", iID.iId); + + FillBuffer(aBuffer, aFinished); + } + + void CABDataOwnerCallbackImplementation::InitialiseRestoreBaseDataL(TDriveNumber aDrive) + { + __LOG("CABDataOwnerCallbackImplementation::InitialiseRestoreBaseDataL()"); +// WaitForMillisecondsL(KABInitTime); + + iData = CABData::NewL(aDrive); + } + + void CABDataOwnerCallbackImplementation::RestoreBaseDataSectionL(TDesC8& aBuffer, TBool aFinished) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::RestoreBaseDataSectionL()", iID.iId); + + // append a buffer containing the base data + iData->AddDataL(aBuffer); + + if (aFinished) + { + ValidateRestoredData(); + + delete iData; + iData = NULL; + } + } + + void CABDataOwnerCallbackImplementation::InitialiseRestoreIncrementDataL(TDriveNumber aDrive) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::InitialiseRestoreIncrementDataL()", iID.iId); + if (!iSnapshot) + { + User::Leave(KErrCorrupt); + } + + if (!iData) + { + iData = CABData::NewL(aDrive); + } + } + + void CABDataOwnerCallbackImplementation::RestoreIncrementDataSectionL(TDesC8& aBuffer, TBool aFinished) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::RestoreIncrementDataSectionL()", iID.iId); + + iData->AddDataL(aBuffer); + + if (aFinished) + { + ValidateRestoredData(); + + delete iData; + iData = NULL; + } + } + + void CABDataOwnerCallbackImplementation::RestoreComplete(TDriveNumber /*aDrive*/) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::RestoreComplete()", iID.iId); + } + + void CABDataOwnerCallbackImplementation::TerminateMultiStageOperation() + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::TerminateMultiStageOperation()", iID.iId); + // We also don't do anything here until we start testing multipart? + } + + TUint CABDataOwnerCallbackImplementation::GetDataChecksum(TDriveNumber /*aDrive*/) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::GetDataChecksum()", iID.iId); + return 0; + } + + void CABDataOwnerCallbackImplementation::WaitForMillisecondsL(TInt aMilliseconds) + { + RTimer timer; + TRequestStatus status; + + User::LeaveIfError(timer.CreateLocal()); + + timer.After(status, aMilliseconds); + User::WaitForRequest(status); + } + + TBool CABDataOwnerCallbackImplementation::ValidateRestoredData() + { + TBool result = ETrue; + + __LOG3("[0x%08x]: Received data : %d %c's", iID.iId, (*iData)().Size(), (*iData)()[0]); + + return result; + } + + TBool CABDataOwnerCallbackImplementation::ValidateRestoredSnapshot() + { + TBool result = ETrue; + + if ((*iSnapshot)() != KABTestSnapshot()) + { + __LOG1("[0x%08x]: Snapshot was NOT received correctly", iID.iId); + result = EFalse; + } + else + { + __LOG1("[0x%08x]: Snapshot was received correctly", iID.iId); + } + + return result; + } + + void CABDataOwnerCallbackImplementation::InitialiseGetProxyBackupDataL(TSecureId aSID, TDriveNumber /*aDrive*/) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::InitialiseGetProxyBackupDataL()", iID.iId); + __LOG2("[0x%08x]: Proxy data about to be requested for SID 0x%08x", iID.iId, aSID.iId); + iProxy = ETrue; + iOffset = 0; + + iFillChar = 80; // 'P' + } + + void CABDataOwnerCallbackImplementation::InitialiseRestoreProxyBaseDataL(TSecureId aSID, TDriveNumber aDrive) + { + __LOG1("[0x%08x]: CABDataOwnerCallbackImplementation::InitialiseRestoreProxyBaseDataL()", iID.iId); + __LOG2("[0x%08x]: Proxy data about to be restored for SID 0x%08x", iID.iId, aSID.iId); + iProxy = ETrue; + iData = CABData::NewL(aDrive); + } + + void CABDataOwnerCallbackImplementation::FillBuffer(TDes8& aDes, TBool& aFinished) + { + TInt bytesToAdd; + TChar fillChar(iFillChar); + + if ((iOffset + aDes.MaxSize()) < iSourceSize) + { + aFinished = EFalse; + bytesToAdd = aDes.MaxSize(); + } + else + { + aFinished = ETrue; + bytesToAdd = iSourceSize - iOffset; + } + + aDes.Fill(fillChar, bytesToAdd); + + iOffset += bytesToAdd; + } + + + + + + + CABDataOwner* CABDataOwner::NewL() + { + CABDataOwner* self = new (ELeave) CABDataOwner; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + void CABDataOwner::StartL() + { + CActiveScheduler::Add(this); + Subscribe(); + CActiveScheduler::Start(); + } + + void CABDataOwner::RunL() + { + if (iStatus == KErrNone) + { + __LOG1("[0x%08x]: ABTester RunL", iID.iId); + Subscribe(); + CheckStatusL(); + } + else + { + __LOG2("[0x%08x]: RunL leaves with code %d", iID.iId, iStatus.Int()); + User::Leave(iStatus.Int()); + } + } + + void CABDataOwner::Subscribe() + { + __LOG1("[0x%08x]: Subscibe", iID.iId); + iProperty.Subscribe(iStatus); // Wait until SBE tells us that we're in normal mode again + SetActive(); + } + + TInt CABDataOwner::RunError(TInt aError) + { + __LOG2("ABDataOwner [0x%08x] Panic'd with error code %d", iID.iId, aError); + + Subscribe(); + + return KErrNone; + } + + void CABDataOwner::CheckStatusL() + { + TInt backupInfo =0; + iProperty.Get(backupInfo); + __LOG1("[0x%08x]: CABDataOwner::CheckStatus", iID.iId); + if ((backupInfo & KBURPartTypeMask) == EBURNormal || (backupInfo & KBURPartTypeMask) == EBURUnset) + { + delete iABClient; + iABClient = NULL; + __LOG2("[0x%08x]: Backup Mode Normal or Unset, deleting client", iID.iId, backupInfo); + } + else + { + if (iABClient == NULL) + { + iABClient = CActiveBackupClient::NewL(iCallback); + iCallback->SetABClient(iABClient); + // do nothing + __LOG1("[0x%08x]: In Backup/Restore: ConfirmReadyForBUR", iID.iId); + } + + TDriveList driveList; + TBURPartType partType; + TBackupIncType incType; + TInt err; + TRAP(err, iABClient->BURModeInfoL(driveList, partType, incType)); + if (err != KErrNone) + { + __LOG2("[0x%08x]: BURModeInfoL error %d", iID.iId, err); + } + + TBool amIaffected = ETrue; + + if (partType == EBURRestorePartial || partType == EBURBackupPartial) + { + TRAP(err, amIaffected = iABClient->DoesPartialBURAffectMeL()); + if (err == KErrNone) + { + if (amIaffected) + { + __LOG1("[0x%08x]: RunL: Partial Affects me!", iID.iId); + } + else + { + __LOG1("[0x%08x]: RunL: Partial Does NOT Affect me!", iID.iId); + } + } + else + { + __LOG2("[0x%08x]: Error calling DoesPartialBURAffectMeL()", iID.iId, err); + + User::After(5000000); + TRAP(err, amIaffected = iABClient->DoesPartialBURAffectMeL()); + __LOG2("[0x%08x]: Called DoesPartialBURAffectMeL() again after 5sec: ", iID.iId, err); + } + } + + if (amIaffected) + { + // Confirm that this data owner is ready for backup/restore operations + iABClient->ConfirmReadyForBURL(KErrNone); + } + } + } + + void CABDataOwner::DoCancel() + { + } + + CABDataOwner::~CABDataOwner() + { + if (IsActive()) + { + Cancel(); + } + delete iCallback; + delete iABClient; + } + + void CABDataOwner::ConstructL() + { + RProcess process; + iID = process.SecureId(); + process.Close(); + iABClient = NULL; + + iCallback = CABDataOwnerCallbackImplementation::NewL(iID); + + iProperty.Attach(TUid::Uid(KUidSystemCategoryValue), KUidBackupRestoreKey); + TInt backupInfo = 0; + iProperty.Get(backupInfo); + if ((backupInfo & KBURPartTypeMask) != EBURNormal || (backupInfo & KBURPartTypeMask) != EBURUnset) + { + iABClient = CActiveBackupClient::NewL(iCallback); + iCallback->SetABClient(iABClient); + + // Confirm that this data owner is ready for backup/restore operations + iABClient->ConfirmReadyForBURL(KErrNone); + // do nothing + __LOG1("[0x%08x]: In Backup/Restore: ConfirmReadyForBUR", iID.iId); + } + __LOG1("[0x%08x]: ABTester ConstructL", iID.iId); + } + } + +void RunActiveBackupClientL() + { + CActiveScheduler* pScheduler = new (ELeave) CActiveScheduler(); + CleanupStack::PushL(pScheduler); + CActiveScheduler::Install(pScheduler); + conn::CABDataOwner* pDO = conn::CABDataOwner::NewL(); + CleanupStack::PushL(pDO); + + pDO->StartL(); + + CleanupStack::PopAndDestroy(pDO); + CleanupStack::PopAndDestroy(pScheduler); + } + +TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup* pCleanup = CTrapCleanup::New(); + TInt nRet = KErrNone; + + if(pCleanup != NULL) + { + TRAP(nRet, RunActiveBackupClientL()); + delete pCleanup; + } + + __UHEAP_MARKEND; + return nRet; + }