--- /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 <connect/sbdefs.h>
+
+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;
+ }