// Copyright (c) 2004-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:
// Implementation of CDataOwner
//
//
/**
@file
*/
#include <d32dbms.h>
#include "sbedataowner.h"
#include "abserver.h"
#include "sbtypes.h"
#include "sblog.h"
#include "sbeparserdefs.h"
#include <connect/panic.h>
namespace conn
{
_LIT(KDrive, "?:");
_LIT(KDriveAndSlash, "?:\\");
_LIT(KPrivateMatch, "?:\\private\\*");
_LIT(KPrivateSidMatch, "?:\\private\\");
_LIT(KSys, "?:\\sys\\*");
_LIT(KSystem, "?:\\system\\*");
_LIT(KResource, "?:\\resource\\*");
_LIT(KOther, "*\\..\\*");
_LIT(KPad, "00000000"); // Used for padding if required
_LIT(KQuestionMark, "?");
_LIT8(KVersion, "1.0");
_LIT( KExclamationAsDrive, "!"); // Used to generic drives for public data as in .SIS file package
_LIT( KPrivateNoBackup, "?:\\private\\????????\\NoBackup\\*"); // Used to exclude the file if it is in "NoBackup" folder.
void CleanupRPointerArray(TAny* aPtr)
{
RPointerArray<CBase>* array = static_cast<RPointerArray<CBase>*>(aPtr);
array->ResetAndDestroy();
delete array;
}
// CSelection //
/**
Symbian 2nd phase construction creates a Selection
@param aType - Selection Type
@param aSelection - Selection Nmae
@return CSelection a pointer to a new object
*/
CSelection* CSelection::NewLC(TSelectionType aType, const TDesC& aSelection)
{
CSelection* self = new (ELeave) CSelection(aType);
CleanupStack::PushL(self);
self->ConstructL(aSelection);
return self;
}
/**
Standard C++ destructor
*/
CSelection::~CSelection()
{
delete iSelection;
}
/**
Standard C++ constructor
*/
CSelection::CSelection(TSelectionType aType) : iType(aType)
{
}
/**
Symbian 2nd phase constructor
*/
void CSelection::ConstructL(const TDesC& aSelection)
{
iSelection = aSelection.AllocL();
}
/**
Selection Type
@return TSelectionType Type
*/
TSelectionType CSelection::SelectionType() const
{
return iType;
}
/**
Selection Name
@return const TDesC& Name
*/
const TDesC& CSelection::SelectionName() const
{
return *iSelection;
}
// CSelection End //
CDataOwner* CDataOwner::NewL(TSecureId aSID, CDataOwnerManager* apDataOwnerManager)
/** Symbian OS static constructor
@param aSID secure id of data owner
@param apDataOwnerManager data owner manager to access resources
@return a CDataOwner object
*/
{
CDataOwner* self = CDataOwner::NewLC(aSID, apDataOwnerManager);
CleanupStack::Pop(self);
return self;
}
CDataOwner* CDataOwner::NewLC(TSecureId aSID, CDataOwnerManager* apDataOwnerManager)
/** Symbian OS static constructor
@param aSID secure id of data owner
@param apDataOwnerManager data owner manager to access resources
@return a CDataOwner object
*/
{
CDataOwner* self = new(ELeave) CDataOwner(aSID, apDataOwnerManager);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
CDataOwner::CDataOwner(TSecureId aSID, CDataOwnerManager* apDataOwnerManager) :
iStatus(EUnset), iFilesParsed(EFalse), iPrimaryFile(EFalse), /*iBackupAsPartial(EFalse), */
iSecureId(aSID),
iBufferFileWriter(NULL), iBufferFileReader(NULL), iBufferSnapshotWriter(NULL),
iTempSnapshotHolder(NULL), ipDataOwnerManager(apDataOwnerManager)
/** Standard C++ constructor
@param aSID secure id of data owner
@param apDataOwnerManager data owner manager to access resources
*/
{
}
void CDataOwner::ConstructL()
/** Symbian 2nd stage constructor */
{
iRegistrationFiles = new (ELeave) CDesCArrayFlat(KDesCArrayGranularity);
iPrivatePath = HBufC::NewL(0);
iProxyInformationArray.Reset();
iPublicDirStack.Reset();
iPublicDirNameStack.Reset();
iPublicExcludes.Reset();
}
CDataOwner::~CDataOwner()
/** Standard C++ destructor
*/
{
// Close the RArrays
iProxyInformationArray.Close();
iStateByDrive.Close();
iProxyStateByDrive.Close();
iDBMSSelections.Close();
iPublicSelections.ResetAndDestroy();
iPassiveSelections.ResetAndDestroy();
iSnapshots.ResetAndDestroy();
for (TInt x = iPublicDirStack.Count(); x > 0; --x)
{
iPublicDirStack[x-1].Close();
delete iPublicDirNameStack[x-1];
}
iPublicDirStack.Close();
iPublicDirNameStack.Close();
iPublicExcludes.Close();
delete iPrivatePath;
delete iBufferFileWriter;
delete iBufferFileReader;
delete iBufferSnapshotWriter;
delete iBufferSnapshotReader;
delete iTempSnapshotHolder;
delete iRegistrationFiles;
}
void CDataOwner::AddRegistrationFilesL(const TDesC& aFileName)
/** Adds a registration file
Adds a registration file to the list of registration files for this data owner
@param aFileName the filename of the
*/
{
iRegistrationFiles->AppendL(aFileName);
}
void CDataOwner::StartProcessIfNecessaryL()
/**
Start the active process
*/
{
// Do we need to check that the process is started?
if (iActiveInformation.iSupported && iActiveInformation.iActiveDataOwner)
{
// Get the list of currently running processes
TBool processFound = EFalse;
TFullName processName;
TFindProcess findProcess;
while (!processFound && (findProcess.Next(processName) == KErrNone))
{
RProcess process;
CleanupClosePushL(process);
if (process.Open(processName) == KErrNone) // Should we leave on any errors?
{
if (process.SecureId() == iSecureId)
{
// Process already exists - see if it's previuosly connected and has a current session
__LOG1("Process %S already exists - not starting", &processName);
TRAPD(err, iStatus = ipDataOwnerManager->ABServer().SessionReadyStateL(iSecureId));
if (err == KErrNone)
{
__LOG2("Existing session for process %S has status %d", &processName, iStatus);
} // if
else
{
__LOG1("Existing process %S hasn't yet connected to a session", &processName);
iStatus = EDataOwnerNotConnected;//ReadyState only check session state when this status not equal to 'EDataOwnerReadyNoImpl' and 'EDataOwnerReady'
} // else
processFound = ETrue;
} // if
} // if
CleanupStack::PopAndDestroy(&process);
} // while
// If the process is not started then we need to start it
if (!processFound)
{
// Create the process
TUidType uidType(KNullUid, KNullUid, iSecureId);
RProcess process;
CleanupClosePushL(process);
TInt createErr = process.Create(iActiveInformation.iProcessName, KNullDesC, uidType);
if (createErr != KErrNone)
{
__LOG2("Process %S failed to start(%d)", &iActiveInformation.iProcessName, createErr);
iStatus = EDataOwnerFailed;
} // if
else
{
__LOG1("Process %S started.", &iActiveInformation.iProcessName);
process.Resume();
} // else
CleanupStack::PopAndDestroy(&process);
} // if
} // if
}
void CDataOwner::ParseFilesL()
/** Parse the registration files
@leave KErrGeneral data owner has no primary registration file
*/
{
if (!iFilesParsed)
{
TUint count = iRegistrationFiles->Count();
TBool foundPrimaryFile = EFalse;
while(count--)
{
const TDesC& fileName = (*iRegistrationFiles)[count];
// Determine if this is the primary file
iPrimaryFile = (fileName.FindF(KPrimaryBackupRegistrationFile) != KErrNotFound);
if (iPrimaryFile)
{
foundPrimaryFile = ETrue;
}
// Parse file
__LOG2("CDataOwner::ParseFilesL() - [0x%08x] - parsing reg file: %S...", iSecureId.iId, &fileName);
TRAPD(err, ParseFileL(fileName));
if (err == KErrNone)
{
__LOG1("CDataOwner::ParseFilesL() - [0x%08x] - ...file parsed okay", iSecureId.iId);
}
else
{
__LOG2("CDataOwner::ParseFilesL() - [0x%08x] - ...*** PARSING FAILED *** - error: %d", iSecureId.iId, err);
User::Leave(err);
}
// Add the registration file to the exclude list
CSelection* selection = CSelection::NewLC(EExclude, fileName);
iPassiveSelections.AppendL(selection);
CleanupStack::Pop(selection);
}
// Check that a primary file was found, as there must be one
if (!foundPrimaryFile)
{
User::Leave(KErrGeneral);
} // if
iFilesParsed = ETrue;
} // if
if (!iActiveInformation.iSupported && (iPassiveInformation.iSupported || iSystemInformation.iSupported))
{
iStatus = EDataOwnerReady;
}
}
void CDataOwner::GetExpectedDataSizeL(TTransferDataType aTransferType,
TDriveNumber aDriveNumber, TUint& aSize)
/** Gets the expected data size of the backkup.
@param aTransferType the type of the transfer
@param aDriveNumber the drive to check for files
@param aSize on return the total size in bytes of the backup
@leave KErrNotReady the snapshot has not been set
*/
{
aSize = 0;
switch (aTransferType)
{
case EPassiveSnapshotData:
{
__LOG1("CDataOwner::GetExpectedDataSizeL() - START - EPassiveSnapshotData - aDriveNumber: %c", aDriveNumber + 'A');
CDesCArray* files = new(ELeave) CDesC16ArrayFlat(KDesCArrayGranularity);
CleanupStack::PushL(files);
BuildFileListL(iPassiveSelections, aDriveNumber, aTransferType, EFalse, NULL, NULL, files);
// DBMS file?
AddDBMSFilesL(aDriveNumber, files, NULL);
TUint count = files->Count();
aSize = count * sizeof(TSnapshot);
__LOG2("CDataOwner::GetExpectedDataSizeL() - passive snapshot count: %d, expected size: %d", count, aSize);
CleanupStack::PopAndDestroy(files);
break;
}
case EPassiveBaseData:
case EPassiveIncrementalData:
{
__LOG1("CDataOwner::GetExpectedDataSizeL() - START - EPassiveBaseData/EPassiveIncrementalData - aDriveNumber: %c", aDriveNumber + 'A');
RFileArray files;
CleanupClosePushL(files);
// Find all the files
if (aTransferType == EPassiveBaseData)
{
__LOG("CDataOwner::GetExpectedDataSizeL() - EPassiveBaseData");
BuildFileListL(iPassiveSelections, aDriveNumber, aTransferType, EFalse, NULL, &files, NULL);
// Do we need to add the DBMS file?
AddDBMSFilesL(aDriveNumber, NULL, &files);
} // if
else
{
__LOG("CDataOwner::GetExpectedDataSizeL() - EPassiveIncrementalData");
// Do we have a snapshot?
const TUint count = iSnapshots.Count();
RSnapshots* pSnapshot = NULL;
for (TInt x = 0; !pSnapshot && (x < count); x++)
{
if (iSnapshots[x]->iDriveNumber == aDriveNumber)
{
pSnapshot = &(iSnapshots[x]->iSnapshots);
} // if
} // for x
BuildFileListL(iPassiveSelections, aDriveNumber, aTransferType, EFalse, pSnapshot, &files, NULL);
// Do we need to add the DBMS file?
AddDBMSFilesL(aDriveNumber, NULL, &files);
} // else
// Calculate the expected data size
const TUint count = files.Count();
__LOG1("CDataOwner::GetExpectedDataSizeL() - passive file count: %d", count);
aSize = (count * sizeof(TFileFixedHeader));
for (TInt x = 0; x < count; x++)
{
const TEntry& fileEntry = files[x];
const TInt fileSize = fileEntry.iSize;
__LOG2("CDataOwner::GetExpectedDataSizeL() - passive file: %S, size: %d", &fileEntry.iName, fileSize);
aSize += fileEntry.iName.Length();
aSize += fileSize;
}
CleanupStack::PopAndDestroy(&files);
break;
}
case EActiveBaseData:
case EActiveIncrementalData:
{
__LOG1("CDataOwner::GetExpectedDataSizeL() - START - EActiveBaseData/EActiveIncrementalData - aDriveNumber: %c", aDriveNumber + 'A');
// Only request expected data size if it's for this data owner, not the proxies
if (iActiveInformation.iSupported && iActiveInformation.iActiveDataOwner && (iActiveInformation.iActiveType != EProxyImpOnly))
{
ipDataOwnerManager->ABServer().GetExpectedDataSizeL(iSecureId, aDriveNumber, aSize);
}
else
{
aSize = 0;
__LOG1("CDataOwner::GetExpectedDataSizeL() - ACTIVE BASE - DO 0x%08x is PROXY, so setting size to 0!", iSecureId.iId);
}
} break;
case EActiveSnapshotData:
{
__LOG1("CDataOwner::GetExpectedDataSizeL() - START - EActiveSnapshotData - aDriveNumber: %c", aDriveNumber + 'A');
aSize = 0; // ABClient M class doesn't provide retrieval of snapshot data size
} break;
default:
__LOG1("CDataOwner::GetExpectedDataSizeL() - START - ERROR - UNSUPPORTED TYPE! => KErrNotSupported - aDriveNumber: %c", aDriveNumber + 'A');
User::Leave(KErrNotSupported);
} // switch
__LOG2("CDataOwner::GetExpectedDataSizeL() - END - size is: %d, data owner 0x%08x", aSize, iSecureId.iId);
}
void CDataOwner::GetPublicFileListL(TDriveNumber aDriveNumber, RFileArray& aFiles)
/** Gets the public file list
Gets the public file list for the given drive
@param aDriveNumber the drive to retrieve the public files for
@param aFiles on return a list of public files
*/
{
BuildFileListL(iPublicSelections, aDriveNumber, EPassiveBaseData, ETrue, NULL, &aFiles, NULL);
}
void CDataOwner::GetRawPublicFileListL(TDriveNumber aDriveNumber,
RRestoreFileFilterArray& aRestoreFileFilter)
/** Gets the raw public file list
@param aDriveNumber the drive to return the list for
@param aRestoreFileFilter on return the file filter
*/
{
// Convert drive number to letter
TChar drive;
User::LeaveIfError(ipDataOwnerManager->GetRFs().DriveToChar(aDriveNumber, drive));
const TUint count = iPublicSelections.Count();
for (TInt x = 0; x < count; x++)
{
TBool include = (iPublicSelections[x]->SelectionType() == EInclude);
TFileName filename;
const TDesC& selectionName = iPublicSelections[x]->SelectionName();
// Name
TBool add = false;
if ((selectionName.Length() > 1) && (selectionName[1] == KColon()[0]))
{
// It has a drive specified
TInt drive;
ipDataOwnerManager->GetRFs().CharToDrive(selectionName[0], drive);
if (static_cast<TDriveNumber>(drive) == aDriveNumber)
{
add = true;
filename.Append(selectionName);
} // if
} // if
else if (selectionName[0] == KBackSlash()[0])
{
add = true;
filename.Append(drive);
filename.Append(KColon);
filename.Append(selectionName);
} // if
else
{
filename.Append(drive);
filename.Append(KColon);
filename.Append(KBackSlash);
filename.Append(selectionName);
} // else
if (add)
{
aRestoreFileFilter.AppendL(TRestoreFileFilter(include, filename));
} // if
} // for x
}
void CDataOwner::ProcessSupplyDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType,
TDesC8& aBuffer, TBool aLastSection)
/** Supply data to the data owner
@param aDriveNumber the drive requesting data for
@param aTransferType the type of transfer
@param aBuffer the buffer containing the data
@param aLastSection have we received all our information
@leave KErrNotReady In the process of another call
@leave KErrNotSupported Unsupported transfer type
@leave KErrCorrupt If commands have been issued that violate the allowed sequence
*/
{
TBURPartType burType = ipDataOwnerManager->BURType();
__LOG2("CDataOwner::ProcessSupplyDataL() - START - drive: %c, aTransferType: %d", aDriveNumber + 'A', aTransferType);
switch (aTransferType)
{
case EPassiveSnapshotData:
{
__LOG1("CDataOwner::ProcessSupplyDataL() - Supplying passive snapshot data to data owner with SID 0x%08x", iSecureId.iId);
// Check that no passive data has been received for a data owner that doesn't support it
if (!iPassiveInformation.iSupported)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Passive restore has been requested but isn't supported");
User::Leave(KErrCorrupt);
}
// Check that no snapshot is supplied after backup data has been requested during a backup
if (((burType == EBURBackupFull) || (burType == EBURBackupPartial)) &&
(StateByDriveL(aDriveNumber).iPassiveBaseDataRequested ||
StateByDriveL(aDriveNumber).iPassiveIncDataRequested))
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Snapshot has been supplied after data has been requested");
User::Leave(KErrCorrupt);
}
// Check that no snapshot is supplied for a data owner expecting base backup
if (iPassiveInformation.iBaseBackupOnly)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Snapshot data has been supplied for a base data owner");
User::Leave(KErrCorrupt);
}
// Check that no snapshot data is provided after backup data has been supplied during a restore
if (((burType == EBURRestorePartial) || (burType == EBURRestoreFull))
&& (StateByDriveL(aDriveNumber).iPassiveBaseDataReceived ||
StateByDriveL(aDriveNumber).iPassiveIncDataReceived))
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Snapshot has been supplied after restore data has been supplied");
User::Leave(KErrCorrupt);
}
SupplyPassiveSnapshotDataL(aDriveNumber, aBuffer, aLastSection);
if (aLastSection)
{
StateByDriveL(aDriveNumber).iPassiveSnapshotReceived = ETrue;
}
break;
}
case EPassiveBaseData:
case EPassiveIncrementalData:
{
if (aTransferType == EPassiveBaseData)
{
__LOG1("CDataOwner::ProcessSupplyDataL() - Supplying passive base data to data owner with SID 0x%08x", iSecureId.iId);
}
else if (aTransferType == EPassiveIncrementalData)
{
__LOG1("CDataOwner::ProcessSupplyDataL() - Supplying passive inc data to data owner with SID 0x%08x", iSecureId.iId);
}
// Check that no passive data has been received for a data owner that doesn't support it
if (!iPassiveInformation.iSupported)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Passive restore data has been supplied but isn't supported");
User::Leave(KErrCorrupt);
}
// Check that no incremental data has been received for a SID that doesn't support it
if (iPassiveInformation.iBaseBackupOnly && (aTransferType == EPassiveIncrementalData))
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Incremental restore data has been received for a base only data owner");
User::Leave(KErrCorrupt);
}
// Passive Base data should only have been provided once for a SID
if ((aTransferType == EPassiveBaseData) && StateByDriveL(aDriveNumber).iPassiveBaseDataReceived)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Data is being restored more than once to a DO");
User::Leave(KErrCorrupt);
}
// A snapshot should already have been supplied if we're incremental
if (!StateByDriveL(aDriveNumber).iPassiveSnapshotReceived && (aTransferType == EPassiveIncrementalData))
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Snapshot has not yet been supplied and should have whether we're base or inc");
User::Leave(KErrCorrupt);
}
// If incremental data is being supplied, then base data must already have been supplied
if ((aTransferType == EPassiveIncrementalData) && !StateByDriveL(aDriveNumber).iPassiveBaseDataReceived)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Incremental data supplied before base data");
User::Leave(KErrCorrupt);
}
SupplyPassiveBaseDataL(aDriveNumber, aBuffer, aLastSection);
if ((aTransferType == EPassiveBaseData) && aLastSection)
{
StateByDriveL(aDriveNumber).iPassiveBaseDataReceived = ETrue;
}
if ((aTransferType == EPassiveIncrementalData) && aLastSection)
{
StateByDriveL(aDriveNumber).iPassiveIncDataReceived = ETrue;
}
break;
}
case EActiveSnapshotData:
{
__LOG1("CDataOwner::ProcessSupplyDataL() - Supplying active snapshot data to data owner with SID 0x%08x", iSecureId.iId);
// Check that no active data has been received for a data owner that doesn't support it
if (!iActiveInformation.iSupported)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Active snapshot data has been supplied for a DO that doesn't support it");
User::Leave(KErrCorrupt);
}
// Check that no active data has been received for a data owner that doesn't support it
if (!iActiveInformation.iSupportsIncremental)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Active snapshot data has been supplied for a base only Data Owner");
User::Leave(KErrCorrupt);
}
// Check that no snapshot is supplied after backup data has been requested during a backup
if (((burType == EBURBackupFull) || (burType == EBURBackupPartial)) && StateByDriveL(aDriveNumber).iActiveBaseDataRequested)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Active snapshot has been supplied after backup data has been requested");
User::Leave(KErrCorrupt);
}
// Check that no snapshot data is provided after backup data has been supplied during a restore
if (((burType == EBURRestorePartial) || (burType == EBURRestoreFull)) && StateByDriveL(aDriveNumber).iActiveBaseDataReceived)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Active snapshot data has been supplied after restore data");
User::Leave(KErrCorrupt);
}
ipDataOwnerManager->ABServer().SupplyDataL(iSecureId, aDriveNumber, aTransferType,
aBuffer, aLastSection);
if (aLastSection)
{
StateByDriveL(aDriveNumber).iActiveSnapshotReceived = ETrue;
}
} break;
case EActiveBaseData:
case EActiveIncrementalData:
{
if (aTransferType == EActiveBaseData)
{
__LOG1("CDataOwner::ProcessSupplyDataL() - Supplying active base data to data owner with SID 0x%08x", iSecureId.iId);
}
else if (aTransferType == EActiveIncrementalData)
{
__LOG1("CDataOwner::ProcessSupplyDataL() - Supplying active incremental data to data owner with SID 0x%08x", iSecureId.iId);
}
const TUint supportedProxyCount = iProxyInformationArray.Count();
TInt offset = 0;
// Only unpack from the first supply message
if (StateByDriveL(aDriveNumber).iFirstActiveTransaction)
{
iCurrentProxy = 0;
TInt proxyCountCheck = 0;
UnpackTypeAdvance(proxyCountCheck, aBuffer, offset);
StateByDriveL(aDriveNumber).iFirstActiveTransaction = EFalse;
__LOG1("CDataOwner::ProcessSupplyDataL() - Proxy Info : Unpacked TotalProxyCount = %d", proxyCountCheck);
// If the backup stream specifies a different number of proxy's to the registration file,
// then we're looking at different reg file versions. This isn't supported as far as proxy's
// are concerned
if (supportedProxyCount != proxyCountCheck)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Number of proxies supported (reg file) differs from backed up data");
User::Leave(KErrCorrupt);
}
// Check that no active data has been requested for a data owner that doesn't support it
if ((!iActiveInformation.iSupported) && (supportedProxyCount == 0))
{
// No proxies or active data
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Active data has been received but this DO doesn't support Active/Proxies");
User::Leave(KErrCorrupt);
}
// Reset proxy state information for this drive
for (TInt numProxy=0; numProxy < supportedProxyCount; numProxy++)
{
ProxyStateByDriveL(aDriveNumber,numProxy) = TProxyStateByDrive(aDriveNumber,numProxy);
}
for (TInt numProxies=0;numProxies<iProxyInformationArray.Count();numProxies++)
{
iProxyInformationArray[numProxies].iDataRequested = 0;
iProxyInformationArray[numProxies].iDataSupplied = 0;
iProxyInformationArray[numProxies].iOpInProgress = ETrue;
}
}
__LOG1("CDataOwner::ProcessSupplyDataL() - Supplying active base data of size = %D", aBuffer.Length());
// Restore the proxy data first
TBool currentBufferConsumed = EFalse;
while ( (iCurrentProxy < supportedProxyCount) && (!currentBufferConsumed))
{
__LOG2("CDataOwner::ProcessSupplyDataL() - Proxy Info : Unpacking proxy info %d of %d", iCurrentProxy + 1, supportedProxyCount);
// Unpack the proxy's finished flag, len and sid if we are handling the proxy for the first time
if ( iProxyInformationArray[iCurrentProxy].iDataSupplied == 0)
{
UnpackTypeAdvance(iProxyInformationArray[iCurrentProxy].iOpInProgress, aBuffer, offset);
__LOG1("CDataOwner::ProcessSupplyDataL() - Proxy Info : FinishedFlag = %d", iProxyInformationArray[iCurrentProxy].iOpInProgress);
UnpackTypeAdvance(iProxyInformationArray[iCurrentProxy].iDataRequested, aBuffer, offset);
__LOG1("CDataOwner::ProcessSupplyDataL() - Proxy Info : ProxyDataStreamLength = %d", iProxyInformationArray[iCurrentProxy].iDataRequested);
TSecureId proxySecureId;
UnpackTypeAdvance(proxySecureId, aBuffer, offset);
if ( iProxyInformationArray[iCurrentProxy].iSecureId.iId != proxySecureId.iId )
{
User::Leave(KErrCorrupt);
}
__LOG1("CDataOwner::ProcessSupplyDataL() - Proxy Info : ProxySID = 0x%08x", proxySecureId.iId);
}
// Is no more data coming , either from the buffer manager or from the server
TBool proxyFinished = iProxyInformationArray[iCurrentProxy].iOpInProgress && aLastSection;
TInt dataLengthRemaining = iProxyInformationArray[iCurrentProxy].iDataRequested - iProxyInformationArray[iCurrentProxy].iDataSupplied;
TInt currentBufferLen = 0;
// The data remaining for this proxy is more than data in this buffer
if (dataLengthRemaining >= aBuffer.Length()-offset )
{
// more data was expected but both server and data mgr have finished, then leave
if (proxyFinished && dataLengthRemaining > aBuffer.Length()-offset)
{
User::Leave(KErrCorrupt);
}
// use the buffer upto the end
currentBufferLen = aBuffer.Length() - offset;
currentBufferConsumed = ETrue;
}
else
{
// use the buffer upto the remaining length of this proxy
currentBufferLen = dataLengthRemaining;
}
// Create a pointer to the data of this proxy
TPtrC8 buffer(aBuffer.Mid(offset, currentBufferLen));
iProxyInformationArray[iCurrentProxy].iDataSupplied += currentBufferLen;
__LOG1("CDataOwner::ProcessSupplyDataL() - iProxyConsumedLength = %D",iProxyInformationArray[iCurrentProxy].iDataSupplied);
offset += currentBufferLen;
TBool proxyLastSection = EFalse;
// If the data to send is the last section, set proxyLastSection with true.
if ((iProxyInformationArray[iCurrentProxy].iOpInProgress == (TInt)ETrue) && (iProxyInformationArray[iCurrentProxy].iDataSupplied == iProxyInformationArray[iCurrentProxy].iDataRequested))
{
__LOG("CDataOwner::ProcessSupplyDataL() - Last Section to Proxy");
proxyLastSection = ETrue;
}
else
{
proxyLastSection = proxyFinished;
}
// Call the proxy and give it the restore data.
ipDataOwnerManager->ABServer().SupplyDataL(
iProxyInformationArray[iCurrentProxy].iSecureId,
aDriveNumber,
aTransferType,
buffer,
proxyLastSection,
ProxyStateByDriveL(aDriveNumber,iCurrentProxy).iOpInProgress,
iSecureId);
// If the proxy still has data to send, record the fact to that the
// data server or datamanager can supply again.
if (!proxyFinished)
{
__LOG("CDataOwner::ProcessSupplyDataL() - Proxy Info : Multipart send not complete, expecting more proxy data");
ProxyStateByDriveL(aDriveNumber,iCurrentProxy).iOpInProgress = ETrue;
}
else
{
__LOG("CDataOwner::ProcessSupplyDataL() - Proxy Info : Send complete");
ProxyStateByDriveL(aDriveNumber,iCurrentProxy).iOpInProgress = EFalse;
ProxyStateByDriveL(aDriveNumber,iCurrentProxy).iDataSupplied = ETrue;
}
__LOG2("CDataOwner::ProcessSupplyDataL() - Check proxyConsumedLength = %D & proxyTotalDataLength = %D",iProxyInformationArray[iCurrentProxy].iDataSupplied,iProxyInformationArray[iCurrentProxy].iDataRequested);
if (iProxyInformationArray[iCurrentProxy].iDataSupplied == iProxyInformationArray[iCurrentProxy].iDataRequested)
{
__LOG("CDataOwner::ProcessSupplyDataL() - Resetting internal variables");
// when whole packet from server is read.
iProxyInformationArray[iCurrentProxy].iDataSupplied = 0;
iProxyInformationArray[iCurrentProxy].iDataRequested = 0;
}
// Check
if ( (iProxyInformationArray[iCurrentProxy].iOpInProgress == (TInt)ETrue) && (iProxyInformationArray[iCurrentProxy].iDataSupplied == iProxyInformationArray[iCurrentProxy].iDataRequested) )
{
__LOG("CDataOwner::ProcessSupplyDataL() - Proxy Finished");
iCurrentProxy++;
}
} // while more proxies.
// Active data can be sent under 2 circumstances, data for a proxy and data for an actual active client
if (iActiveInformation.iSupported && iActiveInformation.iActiveDataOwner && (offset < aBuffer.Size()))
{
__LOG("CDataOwner::ProcessSupplyDataL() - State iActiveInformation.iSupported");
// Active Base data should only have been provided once for a SID
if ((aTransferType == EActiveBaseData) && StateByDriveL(aDriveNumber).iActiveBaseDataReceived)
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - Active restore data has been provided more than once for this DO");
User::Leave(KErrCorrupt);
}
TPtrC8 buffer(aBuffer.Mid(offset));
ipDataOwnerManager->ABServer().SupplyDataL(
iSecureId,
aDriveNumber,
aTransferType,
buffer,
aLastSection,
StateByDriveL(aDriveNumber).iOpInProgress);
if (!aLastSection)
{
StateByDriveL(aDriveNumber).iOpInProgress = ETrue;
}
else
{
StateByDriveL(aDriveNumber).iOpInProgress = EFalse;
StateByDriveL(aDriveNumber).iFirstActiveTransaction = ETrue;
if (aTransferType == EActiveBaseData)
{
StateByDriveL(aDriveNumber).iActiveBaseDataReceived = ETrue;
}
if (aTransferType == EActiveIncrementalData)
{
StateByDriveL(aDriveNumber).iActiveIncDataReceived = ETrue;
}
}
}
} break;
default:
{
__LOG("CDataOwner::ProcessSupplyDataL() - State Error - An unsupported transfer type has been supplied");
User::Leave(KErrNotSupported);
}
} // switch
}
void CDataOwner::SupplyDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType,
TDesC8& aBuffer, TBool aLastSection)
/** Supply data to the data owner
@param aDriveNumber the drive requesting data for
@param aTransferType the type of transfer
@param aBuffer the buffer containing the data
@param aLastSection have we received all our information
@leave KErrNotReady In the process of another call
@leave KErrNotSupported Unsupported transfer type
@leave KErrCorrupt If commands have been issued that violate the allowed sequence
*/
{
__LOG5("CDataOwner::SupplyDataL() - START - SID: 0x%08x, aDrive: %c, aTransferType: %d, aLastSection: %d, iState: %d", iSecureId.iId, aDriveNumber + 'A', aTransferType, aLastSection, iState.iState);
// Check our state
if (!((iState.iState == ENone) ||
((iState.iState == ESupply) && (iState.iDriveNumber == aDriveNumber) &&
(iState.iTransferType == aTransferType))))
{
User::Leave(KErrNotReady);
}
// Set the state?
if (iState.iState == ENone)
{
iState.iState = ESupply;
iState.iDriveNumber = aDriveNumber;
iState.iTransferType = aTransferType;
} // if
// What are we doing then?
// We must trap any errors and rethrow them so we can reset our state
TInt err = KErrNone;
// Do we need to perform a cleanup before restore?
if ((aTransferType == EPassiveBaseData) ||
(aTransferType == EPassiveIncrementalData) ||
(aTransferType == EActiveBaseData) ||
(aTransferType == EActiveIncrementalData))
{
TRAP(err, CleanupBeforeRestoreL(aDriveNumber));
}
if (err != KErrNone)
{
__LOG2("CDataOwner::SupplyDataL() - Data owner 0x%08x, drive %d could not cleanup before restore", iSecureId.iId, aDriveNumber);
}
TRAP(err, ProcessSupplyDataL(aDriveNumber, aTransferType, aBuffer, aLastSection));
// Was there an error?
if (err != KErrNone)
{
iState.iState = ENone;
delete iBufferFileReader;
iBufferFileReader = NULL;
delete iBufferSnapshotReader;
iBufferSnapshotReader = NULL;
User::Leave(err);
} // if
if (aLastSection) // If last section reset state
{
iState.iState = ENone;
} // if
__LOG("CDataOwner::SupplyDataL() - END");
} // SupplyDataL
void CDataOwner::ProcessRequestDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType,
TPtr8& aBuffer, TBool& aLastSection)
/**
So that the TRAPD isn't massive, this switch statement has been moved to this function
*/
{
__LOG4("CDataOwner::ProcessRequestDataL() - START - aDrive: %c, aTransferType: %d, aBuffer.Ptr(): 0x%08x, aBuffer.Length(): %d", aDriveNumber + 'A', aTransferType, aBuffer.Ptr(), aBuffer.Length());
//__LOGDATA("CDataOwner::ProcessRequestDataL() - %S", aBuffer.Ptr(), aBuffer.Length() );
//
switch (aTransferType)
{
case EPassiveSnapshotData:
{
__LOG1("CDataOwner::ProcessRequestDataL() - Requesting passive snapshot data from data owner with SID 0x%08x", iSecureId.iId);
// Check that no passive data has been requested for a data owner that doesn't support it
if (!iPassiveInformation.iSupported)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Passive snapshot data has been requested for a non-passive data owner");
User::Leave(KErrCorrupt);
}
// Check that snapshot data is only requested once
if (StateByDriveL(aDriveNumber).iPassiveSnapshotRequested)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Passive snapshot data has been requested more than once");
User::Leave(KErrCorrupt);
}
RequestPassiveSnapshotDataL(aDriveNumber, aBuffer, aLastSection);
if (aLastSection)
{
StateByDriveL(aDriveNumber).iPassiveSnapshotRequested = ETrue;
}
break;
}
case EPassiveBaseData:
case EPassiveIncrementalData:
{
if (aTransferType == EPassiveBaseData)
{
__LOG1("CDataOwner::ProcessRequestDataL() - Requesting passive base data from data owner with SID 0x%08x", iSecureId.iId);
}
else if (aTransferType == EPassiveIncrementalData)
{
__LOG1("CDataOwner::ProcessRequestDataL() - Requesting passive inc data from data owner with SID 0x%08x", iSecureId.iId);
}
// Check that no passive data has been requested for a data owner that doesn't support it
if (!iPassiveInformation.iSupported)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Passive backup data has been requested for a non-passive data owner");
User::Leave(KErrCorrupt);
}
// Check that if this is an incremental backup, complete snapshot data has been received
if ((aTransferType == EPassiveIncrementalData) && !StateByDriveL(aDriveNumber).iPassiveSnapshotReceived)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Incremental data has been requested without a snapshot being supplied");
User::Leave(KErrCorrupt);
}
// Check that Passive data has only been requested once for a Data Owner
if (((aTransferType == EPassiveBaseData) && StateByDriveL(aDriveNumber).iPassiveBaseDataRequested) ||
((aTransferType == EPassiveIncrementalData) && StateByDriveL(aDriveNumber).iPassiveIncDataRequested))
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Passive data has been requested more than once for this data owner");
User::Leave(KErrCorrupt);
}
// Check that for base backup, no snapshot data has been supplied
if ((aTransferType == EPassiveBaseData) && StateByDriveL(aDriveNumber).iPassiveSnapshotReceived)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Snapshot data has been received for a base only data owner");
User::Leave(KErrCorrupt);
}
// Check that only Base OR Incremental data is requested - not both
if (((aTransferType == EPassiveBaseData) && StateByDriveL(aDriveNumber).iPassiveIncDataRequested) ||
((aTransferType == EPassiveIncrementalData) && StateByDriveL(aDriveNumber).iPassiveBaseDataRequested))
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Base and Incremental data have been requested in the same session");
User::Leave(KErrCorrupt);
}
RequestPassiveDataL(aTransferType, aDriveNumber, aBuffer, aLastSection);
if ((aTransferType == EPassiveBaseData) && aLastSection)
{
StateByDriveL(aDriveNumber).iPassiveBaseDataRequested = ETrue;
}
if ((aTransferType == EPassiveIncrementalData) && aLastSection)
{
StateByDriveL(aDriveNumber).iPassiveIncDataRequested = ETrue;
}
break;
}
case EActiveSnapshotData:
{
__LOG1("CDataOwner::ProcessRequestDataL() - Requesting active snapshot data from data owner with SID 0x%08x", iSecureId.iId);
// Check that active data hasn't been requested for a data owner that doesn't support it
if (!iActiveInformation.iSupported)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Active snapshot data has been requested from a non-active data owner");
User::Leave(KErrCorrupt);
}
// Check that no active snapshot data has been requested for a base only active data owner
if (!iActiveInformation.iSupportsIncremental)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Active snapshot data has been requested from a base only data owner");
User::Leave(KErrCorrupt);
}
// Check that the Active client has prepared it's data and is ready
if (iStatus != EDataOwnerReady)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Active Snapshot data has been requested from a data owner that isn't ready");
User::Leave(KErrNotReady);
}
// Check that snapshot data is only requested once
if (StateByDriveL(aDriveNumber).iActiveSnapshotRequested)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Active Snapshot data has been requested more than once");
User::Leave(KErrCorrupt);
}
// Request the snapshot data from the abclient
ipDataOwnerManager->ABServer().RequestDataL(iSecureId, aDriveNumber, aTransferType,
aBuffer, aLastSection);
if (aLastSection)
{
StateByDriveL(aDriveNumber).iActiveSnapshotRequested = ETrue;
}
} break;
case EActiveBaseData:
case EActiveIncrementalData:
{
if (aTransferType == EActiveBaseData)
{
__LOG1("CDataOwner::ProcessRequestDataL() - Requesting active base data from data owner with SID 0x%08x", iSecureId.iId);
}
else if (aTransferType == EActiveIncrementalData)
{
__LOG1("CDataOwner::ProcessRequestDataL() - Requesting active inc data from data owner with SID 0x%08x", iSecureId.iId);
}
TInt supportedProxyCount = iProxyInformationArray.Count();
TInt offset = 0;
// Prepend the number of proxies into the data stream
if (StateByDriveL(aDriveNumber).iFirstActiveTransaction)
{
// Check that no active data has been requested for a data owner that doesn't support it
if ((!iActiveInformation.iSupported) && (supportedProxyCount == 0))
{
// No proxies or active data
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Active data has been requested from a non-active/no proxy data owner");
User::Leave(KErrCorrupt);
}
StateByDriveL(aDriveNumber).iFirstActiveTransaction = EFalse;
PackTypeAdvance(supportedProxyCount, aBuffer, offset);
__LOG1("CDataOwner::ProcessRequestDataL() - Proxy Info : Packing TotalProxyCount = %d", supportedProxyCount);
aBuffer.SetLength(offset);
//__LOGDATA( "CDataOwner::ProcessRequestDataL() - after adding proxy info - %S", aBuffer.Ptr(), aBuffer.Length() );
// Reset proxy state information for this drive
for (TInt numProxy=0; numProxy < supportedProxyCount; numProxy++)
{
ProxyStateByDriveL(aDriveNumber,numProxy) = TProxyStateByDrive(aDriveNumber,numProxy);
}
}
// Proxy data is always at the beginning of the data block
for (TInt index = 0; index < supportedProxyCount; index++)
{
__LOG2("CDataOwner::ProcessRequestDataL() - Proxy Info : Packing proxy info %d of %d", index + 1, supportedProxyCount);
// Request data from each of the data owners that haven't yet been added
// If the buffer's overflowed, then let the PC request again
if (!ProxyStateByDriveL(aDriveNumber,index).iDataRequested && aLastSection)
{
if (static_cast<TUint>(aBuffer.MaxSize() - aBuffer.Size()) > (sizeof(TBool) + sizeof(TInt32) + sizeof(TSecureId)))
{
// Pack protocol into active stream [Proxy data length][Proxy SID][Proxy Data]
// Set the descriptor to be maximum length and use the offset to determine where we're up to
aBuffer.SetMax();
// buffer for proxy data finished flag
TPtr8 finishedBuf(aBuffer.MidTPtr(offset, sizeof(TBool)));
offset += sizeof(TBool);
// buffer for length
TPtr8 lengthBuf(aBuffer.MidTPtr(offset, sizeof(TInt32)));
offset += sizeof(TInt32);
// buffer for the sid
TPtr8 sidBuf(aBuffer.MidTPtr(offset, sizeof(TSecureId)));
offset += sizeof(TSecureId);
// Create a buffer for the data
TPtr8 buffer(aBuffer.MidTPtr(offset));
// Call the proxy
ipDataOwnerManager->ABServer().RequestDataL(
iProxyInformationArray[index].iSecureId,
aDriveNumber,
aTransferType,
buffer,
aLastSection,
ProxyStateByDriveL(aDriveNumber,index).iOpInProgress,
iSecureId);
TInt size = buffer.Size();
// Write the proxy protocol block to the active backup data stream
PackType(aLastSection, finishedBuf, 0);
__LOG1("CDataOwner::ProcessRequestDataL() - Proxy Info : FinishedFlag = %d", aLastSection);
PackType(size, lengthBuf, 0);
__LOG1("CDataOwner::ProcessRequestDataL() - Proxy Info : ProxyStreamSize= %d", size);
PackType(iProxyInformationArray[index].iSecureId, sidBuf, 0);
__LOG1("CDataOwner::ProcessRequestDataL() - Proxy Info : ProxySID = 0x%08x", iProxyInformationArray[index].iSecureId.iId);
// Update the offset and main buffer size
offset += size;
aBuffer.SetLength(offset);
// If the proxy still has data to send, record the fact to that the PC can request again
if (!aLastSection)
{
ProxyStateByDriveL(aDriveNumber,index).iOpInProgress = ETrue;
}
else
{
ProxyStateByDriveL(aDriveNumber,index).iOpInProgress = EFalse;
ProxyStateByDriveL(aDriveNumber,index).iDataRequested = ETrue;
}
}
else
{
// If there's not enough room for the protocol info, then set the last section flag
aLastSection = EFalse;
}
}
}
if (iActiveInformation.iSupported && iActiveInformation.iActiveDataOwner && (aBuffer.Size() < aBuffer.MaxLength()))
{
// Check that if this is a base backup, no snapshot has been provided
if ((aTransferType == EActiveBaseData) && StateByDriveL(aDriveNumber).iActiveSnapshotReceived)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - A snapshot has been provided before a request for base data");
User::Leave(KErrCorrupt);
}
// Check that if this is an incremental backup that at least one complete snapshot has been sent
if ((aTransferType == EActiveIncrementalData) && !StateByDriveL(aDriveNumber).iActiveSnapshotReceived)
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - No snapshot has been supplied, yet incremental data has been requested");
User::Leave(KErrCorrupt);
}
// Check that only one (possibly multi-part) request of actual data is made to an active backup client
if (((aTransferType == EActiveBaseData) && StateByDriveL(aDriveNumber).iActiveBaseDataRequested) ||
((aTransferType == EActiveIncrementalData) && StateByDriveL(aDriveNumber).iActiveIncDataRequested))
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Active data has been requested more than once (not counting multi-part)");
User::Leave(KErrCorrupt);
}
// Check that only Base OR Incremental data is requested - not both
if (((aTransferType == EActiveBaseData) && StateByDriveL(aDriveNumber).iActiveIncDataRequested) ||
((aTransferType == EActiveIncrementalData) && StateByDriveL(aDriveNumber).iActiveBaseDataRequested))
{
__LOG("CDataOwner::ProcessRequestDataL() - State Error - Only active base or incremental data can be requested in the same session");
User::Leave(KErrCorrupt);
}
// Create a buffer pointer allowing the client to fill the remainder of the buffer
TInt currentBufferLength = aBuffer.Size();
aBuffer.SetMax();
TPtr8 buffer(aBuffer.MidTPtr(currentBufferLength));
// Request data from the abclient
ipDataOwnerManager->ABServer().RequestDataL(
iSecureId,
aDriveNumber,
aTransferType,
buffer,
aLastSection,
StateByDriveL(aDriveNumber).iOpInProgress);
aBuffer.SetLength(currentBufferLength + buffer.Size());
// If the active data owner still has data to send, record the fact to that the PC can request again
if (!aLastSection)
{
StateByDriveL(aDriveNumber).iOpInProgress = ETrue;
}
else
{
StateByDriveL(aDriveNumber).iOpInProgress = EFalse;
StateByDriveL(aDriveNumber).iFirstActiveTransaction = ETrue;
if (aTransferType == EActiveBaseData)
{
StateByDriveL(aDriveNumber).iActiveBaseDataRequested = ETrue;
}
if (aTransferType == EActiveIncrementalData)
{
StateByDriveL(aDriveNumber).iActiveIncDataRequested = ETrue;
}
}
} // Active data owner
} break;
default:
{
User::Leave(KErrNotSupported);
}
} // switch
__LOG2("CDataOwner::ProcessRequestDataL() - NEAR END - aBuffer.Ptr(): 0x%08x, aBuffer.Length(): %d", aBuffer.Ptr(), aBuffer.Length());
//__LOGDATA( "CDataOwner::ProcessRequestDataL() - %S", aBuffer.Ptr(), aBuffer.Length() );
__LOG("CDataOwner::ProcessRequestDataL() - END");
}
void CDataOwner::RequestDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType,
TPtr8& aBuffer, TBool& aLastSection)
{
aLastSection = ETrue; // Set the last section to be true by default
// Check our state
if (!((iState.iState == ENone) ||
((iState.iState == ERequest) && (iState.iDriveNumber == aDriveNumber) &&
(iState.iTransferType == aTransferType))))
{
User::Leave(KErrNotReady);
}
// Set the state?
if (iState.iState == ENone)
{
iState.iState = ERequest;
iState.iDriveNumber = aDriveNumber;
iState.iTransferType = aTransferType;
}
// What are we doing then?
// We must trap any errors and rethrow them so we can reset our state
TRAPD(err, ProcessRequestDataL(aDriveNumber, aTransferType, aBuffer, aLastSection));
if (err != KErrNone)
{
__LOG4("CDataOwner::RequestDataL() - drive: %c:, aTransferType: %d, secureId: 0x%08x - ERROR: %d", 'a' + aDriveNumber, aTransferType, iSecureId.iId, err);
iState.iState = ENone;
delete iBufferFileWriter;
iBufferFileWriter = NULL;
delete iBufferSnapshotWriter;
iBufferSnapshotWriter = NULL;
User::Leave(err);
} // if
if (aLastSection) // If last section reset state
{
iState.iState = ENone;
} // if
} // RequestDataL
void CDataOwner::RestoreCompleteL()
/** Indicate to the active client that the restore operation has been completed
*/
{
// Find all of the drives that this data owner could have stored data on
TDriveList driveList;
GetDriveListL(driveList);
for (TInt driveCountIndex = 0; driveCountIndex < KMaxDrives; driveCountIndex++)
{
if (driveList[driveCountIndex])
{
// If the particular drive is supported, then indicate that the restore is complete
ipDataOwnerManager->ABServer().RestoreCompleteL(iSecureId, static_cast<TDriveNumber>(driveCountIndex));
}
}
}
TSecureId CDataOwner::SecureId() const
/** Get the secure id of the data owner
@return the secure id of the data owner
*/
{
return iSecureId;
}
TDataOwnerStatus CDataOwner::ReadyState()
/** Gets the ready state of the data owner
@return The ready state
*/
{
TDataOwnerStatus status = EDataOwnerReady;
TInt proxyIndex = 0;
const TUint proxyCount = iProxyInformationArray.Count();
CDataOwner* pProxyDataOwner = NULL; // TRAPD forces us to use a pointer instead of ref
while ((proxyIndex < proxyCount) && (status == EDataOwnerReady || status == EDataOwnerReadyNoImpl))
{
// For each proxy required, query for ready state
TRAPD(err, pProxyDataOwner = &(ipDataOwnerManager->DataOwnerL(
iProxyInformationArray[proxyIndex].iSecureId)));
// If the proxy data owner doesn't exist - then error
if (err == KErrNotFound)
{
status = EDataOwnerNotFound;
}
else
{
if (pProxyDataOwner->ActiveInformation().iActiveType != EActiveOnly)
{
// Get the status from each of the supported proxies
status = pProxyDataOwner->ReadyState();
proxyIndex++;
}
else
{
status = EDataOwnerFailed;
break;
}
}
}
// If this data owner has only proxy data to backup, then echo the state of the proxies
if ((proxyCount > 0) && !iActiveInformation.iActiveDataOwner) // is passive
{
if (status == EDataOwnerReadyNoImpl) // proxy (eg.cent rep) is ready
{
iStatus = EDataOwnerReady;
}
else
{
iStatus = status;
}
}
if ((iActiveInformation.iActiveDataOwner) && (iStatus != EDataOwnerReady) && (iStatus != EDataOwnerReadyNoImpl))
{
TRAPD(err, iStatus = ipDataOwnerManager->ABServer().SessionReadyStateL(iSecureId));
if (err != KErrNone)
{
iStatus = EDataOwnerNotConnected;
}
}
// If all of the proxies are ok, then set the status to be that of this data owner
if (status == EDataOwnerReady || status == EDataOwnerReadyNoImpl)
{
status = iStatus;
}
__LOG2("CDataOwner::ReadyState() - Ready status for data owner 0x%08x is %d", iSecureId.iId, static_cast<TInt>(status));
return status;
}
void CDataOwner::SetReadyState(TDataOwnerStatus aDataOwnerStatus)
/**
Set upon a ConfirmReadyForBUR IPC call from an active backup client
*/
{
__LOG2("CDataOwner::SetReadyState() - Setting ready state of data owner 0x%08x to %d", iSecureId.iId, static_cast<TInt>(aDataOwnerStatus));
iStatus = aDataOwnerStatus;
if (aDataOwnerStatus == EDataOwnerReady && iActiveInformation.iActiveType == EProxyImpOnly)
{
iStatus = EDataOwnerReadyNoImpl;
}
}
TCommonBURSettings CDataOwner::CommonSettingsL()
/** Get the common settings of the data owner
@pre CDataOwner::ParseFilesL() must have been called
@return the common settings of the data owner
@leave KErrNotReady if CDataOwner::ParseFilesL() not called
*/
{
__LOG2("CDataOwner::CommonSettingsL() - START - sid: 0x%08x, iFilesParsed: %d", iSecureId.iId, iFilesParsed);
if (!iFilesParsed)
{
User::Leave(KErrNotReady);
}
__LOG2("CDataOwner::CommonSettingsL() - Active Supported: %d, proxyCount: %d", iActiveInformation.iSupported, iProxyInformationArray.Count());
TCommonBURSettings settings = ENoOptions;
if (iActiveInformation.iSupported || iProxyInformationArray.Count())
{
settings |= EActiveBUR;
} // if
__LOG1("CDataOwner::CommonSettingsL() - Passive Supported: %d", iPassiveInformation.iSupported);
if (iPassiveInformation.iSupported)
{
settings |= EPassiveBUR;
}
__LOG1("CDataOwner::CommonSettingsL() - System Supported: %d", iSystemInformation.iSupported);
if (iSystemInformation.iSupported)
{
settings |= EHasSystemFiles;
}
__LOG2("CDataOwner::CommonSettingsL() - SelActive: %d, SelPassive: %d", iActiveInformation.iSupportsSelective, iPassiveInformation.iSupportsSelective);
if (iActiveInformation.iSupportsSelective && iPassiveInformation.iSupportsSelective)
{
settings |= ESupportsSelective;
}
__LOG1("CDataOwner::CommonSettingsL() - Reboot required: %d", iRestoreInformation.iRequiresReboot);
if (iRestoreInformation.iRequiresReboot)
{
settings |= ERequiresReboot;
}
__LOG("CDataOwner::CommonSettingsL() - END");
return settings;
}
TPassiveBURSettings CDataOwner::PassiveSettingsL()
/** Get the passive settings of the data owner
@pre CDataOwner::ParseFilesL() must have been called
@return the passive settings of the data owner
@leave KErrNotReady if CDataOwner::ParseFilesL() not called
*/
{
if (!iFilesParsed)
{
User::Leave(KErrNotReady);
}
TPassiveBURSettings settings = ENoPassiveOptions;
if (iPassiveInformation.iSupported)
{
if (iPassiveInformation.iDeleteBeforeRestore)
{
settings |= EDeleteBeforeRestore;
} // if
if (!iPassiveInformation.iBaseBackupOnly)
{
settings |= EPassiveSupportsInc;
} // if
} // if
if (iPublicInformation.iSupported)
{
settings |= EHasPublicFiles;
} // if
return settings;
}
TActiveBURSettings CDataOwner::ActiveSettingsL()
/** Get the active settings of the data owner
@pre CDataOwner::ParseFilesL() must have been called
@return the active settings of the data owner
@leave KErrNotReady if CDataOwner::ParseFilesL() not called
*/
{
if (!iFilesParsed)
{
User::Leave(KErrNotReady);
}
TActiveBURSettings settings = ENoActiveOptions;
if (iActiveInformation.iSupported)
{
if (iActiveInformation.iRequiresDelayToPrepareData)
{
settings |= EDelayToPrepareData;
} // if
if (iActiveInformation.iSupportsIncremental)
{
settings |= EActiveSupportsInc;
} // if
} // if
return settings;
}
/**
Get ActiveInformation of the data owner
@return TActiveInformation active information
*/
TActiveInformation CDataOwner::ActiveInformation()
{
return iActiveInformation;
}
void CDataOwner::GetDriveListL(TDriveList& aDriveList)
/** Get the drive list for the data owner
@pre CDataOwner::ParseFilesL() must have been called
@return the active settings of the data owner
@leave KErrNotReady if CDataOwner::ParseFilesL() not called
*/
{
__LOG2("CDataOwner::GetDriveListL() - SID: 0x%08x, iFilesParsed: %d", iSecureId.iId, iFilesParsed);
if (!iFilesParsed)
{
User::Leave(KErrNotReady);
}
// Get the list of available drives, dont return drives that dont exist.
TDriveList existingDrives;
const TInt error = ipDataOwnerManager->GetRFs().DriveList(existingDrives);
if ( error != KErrNone )
{
__LOG1("CDataOwner::GetDriveListL() - couldnt get drive list: %d", error);
}
User::LeaveIfError(error);
// We now no longer return the Z drive, it has been decided that the Z drive will always be the
// ROM. Backing up and restoring the ROM drive should not be possible, as what is the point
TDriveList notToBackup = ipDataOwnerManager->Config().ExcludeDriveList();
for (TInt i = 0; i < KMaxDrives; i++)
{
if (notToBackup[i]) // if this drive is set
{
// don't include this drive
existingDrives[i] = EFalse;
}
}
// If we do active backup or dbms backup then we
// have to say all drives
if ((iActiveInformation.iSupported) || (iDBMSSelections.Count()))
{
__LOG("CDataOwner::GetDriveListL() - active DO, so using all existing drives");
aDriveList = existingDrives;
} // if
else
{
// See where we have files?
TBool allDrives = EFalse;
// Reset drives passed in
aDriveList.SetLength(KMaxDrives);
aDriveList.FillZ();
// Loop through passive files
TInt count = iPassiveSelections.Count();
__LOG1("CDataOwner::GetDriveListL() - checking %d passive file entries...", count);
for (TInt x = 0; !allDrives && x < count; x++)
{
const TDesC& selection = iPassiveSelections[x]->SelectionName();
if (iPassiveSelections[x]->SelectionType() != EExclude)
{
TInt drive = GetDrive(selection);
if (drive == -1)
{
__LOG3("CDataOwner::GetDriveListL() - passive[%2d/%2d] => all drives (no specific drive letter) - fullName: %S", x+1, count, &selection);
allDrives = ETrue;
}
else if (existingDrives[drive] != 0)
{
__LOG4("CDataOwner::GetDriveListL() - passive[%2d/%2d] => drive: %c, fullName: %S", x+1, count, drive + 'A', &selection);
aDriveList[drive] = ETrue;
}
}
} // for
__LOG(" ");
// Loop through public files
count = iPublicSelections.Count();
__LOG1("CDataOwner::GetDriveListL() - checking %d public file entries...", count);
for (TInt x = 0; !allDrives && (x < count); x++)
{
const TDesC& selection = iPublicSelections[x]->SelectionName();
if (iPublicSelections[x]->SelectionType() != EExclude)
{
TInt drive = GetDrive(selection);
if (drive == -1)
{
__LOG3("CDataOwner::GetDriveListL() - public[%2d/%2d] => all drives (no specific drive letter) - fullName: %S", x+1, count, &selection);
allDrives = ETrue;
}
else if (existingDrives[drive] != 0)
{
__LOG4("CDataOwner::GetDriveListL() - public[%2d/%2d] => drive: %c, fullName: %S", x+1, count, drive + 'A', &selection);
aDriveList[drive] = ETrue;
}
}
} // for
if (allDrives)
{
__LOG("CDataOwner::GetDriveListL() - using all drives!");
aDriveList = existingDrives;
} // if
} // else
#ifdef SBE_LOGGING_ENABLED
TBuf<256> drivePrint;
//
for(TInt i=0; i<KMaxDrives; i++)
{
if (aDriveList[i] != 0)
{
const TDriveUnit driveUnit(i);
const TDriveName name(driveUnit.Name());
drivePrint.Append(name);
if (i < KMaxDrives - 1)
{
drivePrint.Append(_L(", "));
}
}
}
__LOG2("CDataOwner::GetDriveListL() - END - SID: 0x%08x, supports drives: %S", iSecureId.iId, &drivePrint);
#endif
}
void CDataOwner::SetBackedUpAsPartial(TBool aPartial)
/**
Inform's the data owner that upon a partial backup, this DO is to be backed up
*/
{
iBackupAsPartial = aPartial;
}
TBool CDataOwner::PartialAffectsMe() const
/**
Accessor to discover whether or not the sbe client has specified this Data Owner to be backed
up as part of a partial backup
@return ETrue if this data owner has been requested to backup as partial
*/
{
return iBackupAsPartial;
}
void CDataOwner::ParseFileL(const TDesC& aFileName)
/** Parse a given registration file
@param aFileName the registration file to parse
*/
{
__LOG2("CDataOwner::ParseFileL() - START - aFileName: %S, iPrimaryFile: %d", &aFileName, iPrimaryFile);
PrivatePathL(aFileName);
// Parse the file
ipDataOwnerManager->ParserProxy().ParseL(aFileName, *this);
}
void CDataOwner::PrivatePathL(const TDesC& aFileName)
/** Get the private path
@param aPath The path to extract the drive from
*/
{
delete iPrivatePath;
TParsePtrC parse(aFileName);
iPrivatePath = parse.Path().AllocL();
}
TInt CDataOwner::GetDrive(const TDesC& aPath) const
/** Gets the drive relating to a path.
@param aPath The path to extract the drive from
@return A TDriveNumber or -1 if a drive is not specified
*/
{
TInt ret = KErrNotFound;
if (aPath.Length() > 0)
{
if (ipDataOwnerManager->GetRFs().CharToDrive(static_cast<TChar>(aPath[0]).GetLowerCase(), ret) != KErrNone)
{
ret = KErrNotFound;
} // if
}
return ret;
}
void CDataOwner::BuildFileListL(const RSelections& aFileSelection,
const TDriveNumber aDriveNumber,
const TTransferDataType aTransferType,
const TBool aIsPublic,
RSnapshots* apSnapshots,
RFileArray* apFileEntries,
CDesCArray* apFileNames)
/** Builds a file list.
Builds a file list for a given selection.
@param aFileSelection the selection
@param aDriveNumber The drive that the file resides on
@param aTransferType The type of the transfer
@param aIsPublic Are we building a public file list
@param apSnapshots A snapshot to compare files against
@param apFileEntries Array of file info's to populate
@param apFileNames Array of file names to populate
*/
{
TInt count = aFileSelection.Count();
__LOG4("CDataOwner::BuildFileListL() - START - aDriveNumber: %c, count: %d, aIsPublic: %d, aTransferType: %d", aDriveNumber + 'A', count, aIsPublic, aTransferType);
// Split selections into include and exclude
RArray<TPtrC> include;
CleanupClosePushL(include);
RArray<TPtrC> exclude;
CleanupClosePushL(exclude);
// sort the snapshost to speed up IsNewerL()
if (apSnapshots)
{
apSnapshots->Sort(CSnapshot::Compare);
}
__LOG("CDataOwner::BuildFileListL() - file selection listing...:");
for (TInt x = 0; x < count; x++)
{
const TDesC& selectionName = aFileSelection[x]->SelectionName();
__LOG3("CDataOwner::BuildFileListL() - selection[%03d]: %S, type: %d", x, &selectionName, aFileSelection[x]->SelectionType());
if (aFileSelection[x]->SelectionType() == EInclude)
{
include.AppendL(selectionName);
} // if
else
{
exclude.AppendL(selectionName);
} // else
} // for x
// Loop through all includes
count = include.Count();
__LOG("CDataOwner::BuildFileListL() - include listing...:");
TFileName* fileName = new(ELeave) TFileName();
CleanupStack::PushL(fileName);
for (TInt x = 0; x < count; x++)
{
fileName->Zero();
TChar drive;
User::LeaveIfError(ipDataOwnerManager->GetRFs().DriveToChar(aDriveNumber, drive));
const TDesC& includeEntry( include[x] );
__LOG2("CDataOwner::BuildFileListL() - entry[%03d] is: %S", x, &includeEntry);
// See if the drive is specified
if (includeEntry[0] == KBackSlash()[0])
{
// Add the drive
fileName->Append(drive);
fileName->Append(KColon);
fileName->Append(includeEntry);
}
else if (static_cast<TChar>(includeEntry[0]).GetLowerCase() == drive.GetLowerCase())
{
fileName->Copy(includeEntry);
} // else
__LOG2("CDataOwner::BuildFileListL() - entry[%03d] filename is therefore: %S", x, fileName);
if (fileName->Length() > 0)
{
// Check to see if fileName is just a drive(we cant get an entry)
TBool isDrive = EFalse;
if ((fileName->MatchF(KDrive) != KErrNotFound) ||
(fileName->MatchF(KDriveAndSlash) != KErrNotFound))
{
isDrive = ETrue;
__LOG("CDataOwner::BuildFileListL() - filename is a drive");
} // if
TEntry entry;
TBool isEntry = EFalse;
if (!isDrive)
{
TInt err = ipDataOwnerManager->GetRFs().Entry(*fileName, entry);
__LOG1("CDataOwner::BuildFileListL() - get entry error: %d", err);
entry.iName = *fileName;
switch (err)
{
case KErrNone:
isEntry = ETrue;
break;
case KErrNotFound:
case KErrPathNotFound:
case KErrBadName:
break;
default:
User::Leave(err);
} // switch
} // if
if (isDrive || (isEntry && entry.IsDir()))
{
__LOG("CDataOwner::BuildFileListL() - parsing directory...");
ParseDirL(*fileName, exclude, aTransferType, aIsPublic, apSnapshots, apFileEntries, apFileNames);
#ifdef SBE_LOGGING_ENABLED
if (apFileNames)
{
const TInt fNameCount = apFileNames->Count();
for(TInt k=0; k<fNameCount; k++)
{
const TDesC& fileName = (*apFileNames)[k];
__LOG2("CDataOwner::BuildFileListL() - directory entry[%03d] %S", k, &fileName);
}
}
__LOG("CDataOwner::BuildFileListL() - end of parsing directory");
#endif
} // if
else
{
if (isEntry)
{
const TBool isExcluded = IsExcluded(aIsPublic, *fileName, exclude);
if (!isExcluded)
{
TInt err = KErrNone;
TBool newer = EFalse;
if (apSnapshots && (aTransferType == EPassiveIncrementalData))
{
TRAP(err, IsNewerL(*fileName, entry, apSnapshots, newer));
} // if
if (!apSnapshots ||
(aTransferType == EPassiveBaseData) ||
newer ||
(err != KErrNone))
{
__LOG1("CDataOwner::BuildFileListL() - adding fully verified file: %S", fileName);
if (apFileEntries)
{
// Add to list of files
apFileEntries->AppendL(entry);
} // if
if (apFileNames)
{
apFileNames->AppendL(*fileName);
} // else
} // if
} // if
else
{
__LOG("CDataOwner::BuildFileListL() - file is excluded!");
}
} // if
} // else
} // if
} // for x
CleanupStack::PopAndDestroy(fileName);
CleanupStack::PopAndDestroy(&exclude);
CleanupStack::PopAndDestroy(&include);
__LOG("CDataOwner::BuildFileListL() - END");
}
void CDataOwner::ParseDirL(const TDesC& aDirName,
const RArray<TPtrC>& aExclude,
const TTransferDataType aTransferType,
const TBool aIsPublic,
RSnapshots* apSnapshots,
RFileArray* apFileEntries,
CDesCArray* apFileNames)
/** Parses a directory for files.
Parses the given directory for files. The function is called recursivily if a directory is found.
@param aDirName the directory to search
@param aExclude a list of directories or files to exclude
@param apFileEntries Array of file entries to populate
@param apFileNames Array of filenames to populate
*/
{
CDir* pFiles = NULL;
// This function requires a / on the end otherwise it does not work!
TFileName* path = new(ELeave) TFileName(aDirName);
CleanupStack::PushL(path);
if ((*path)[path->Length() - 1] != KBackSlash()[0])
{
path->Append(KBackSlash);
}
TInt err = ipDataOwnerManager->GetRFs().GetDir(*path, KEntryAttMatchMask, ESortNone, pFiles);
if ((err != KErrNone) && (err != KErrNotFound)) // Do we need to leave?
{
User::Leave(err);
} // if
CleanupStack::PushL(pFiles);
// sort the snapshost to speed up IsNewerL()
if (apSnapshots)
{
apSnapshots->Sort(CSnapshot::Compare);
}
TUint count = pFiles->Count();
if (count==0)
{
// empty directory
TEntry entry;
TInt err = ipDataOwnerManager->GetRFs().Entry(*path, entry);
entry.iName = *path;
if (entry.IsDir() && (!IsExcluded(aIsPublic, entry.iName, aExclude)))
{
// append empty directory entry to the list
entry.iSize = 0;
if (apFileEntries)
{
apFileEntries->AppendL(entry);
}
if (apFileNames)
{
apFileNames->AppendL(entry.iName);
}
}
}
TFileName* fileName = new(ELeave) TFileName();
CleanupStack::PushL(fileName);
while(count--)
{
TEntry entry((*pFiles)[count]);
fileName->Zero();
// Build full path
fileName->Append(*path);
fileName->Append(entry.iName);
entry.iName = *fileName;
if (!IsExcluded(aIsPublic, entry.iName, aExclude))
{
if (entry.IsDir())
{
ParseDirL(entry.iName, aExclude, aTransferType, aIsPublic, apSnapshots, apFileEntries, apFileNames);
} // if
else
{
TInt err = KErrNone;
TBool newer = EFalse;
if (apSnapshots && (aTransferType == EPassiveIncrementalData))
{
TRAP(err, IsNewerL(entry.iName, entry, apSnapshots, newer));
} // if
if (!apSnapshots ||
(aTransferType == EPassiveBaseData) ||
newer ||
(err != KErrNone))
{
if (apFileEntries)
{
// Add to list of files
apFileEntries->AppendL(entry);
} // if
if (apFileNames)
{
apFileNames->AppendL(entry.iName);
} // else
} // if
} // else
} // if
} // while
// Cleanup
CleanupStack::PopAndDestroy(fileName);
CleanupStack::PopAndDestroy(pFiles);
CleanupStack::PopAndDestroy(path);
}
void CDataOwner::GetNextPublicFileL(TBool aReset, TDriveNumber aDriveNumber, TEntry& aEntry)
/** Gets the next public file associated with the data owner
@param aReset set true to start reading from the beginning of the list
@param aDriveNumber the drive to retrieve the public files for
@param aEntry on return the next entry in the list, an empty entry indicates the end of the list has been reached
*/
{
TInt stackCount;
TFileName fileName;
TBool endOfList = EFalse;
TBool gotEntry = EFalse;
TChar drive;
User::LeaveIfError(ipDataOwnerManager->GetRFs().DriveToChar(aDriveNumber, drive));
if (aReset)
{
// Reset and start at the beginning
iPublicFileIndex = -1;
// Go through and close all RDirs, then reset the array.
for (stackCount = iPublicDirStack.Count(); stackCount > 0; --stackCount)
{
iPublicDirStack[stackCount-1].Close();
delete iPublicDirNameStack[stackCount-1];
}
iPublicDirStack.Reset();
iPublicDirNameStack.Reset();
// Build the list of excludes
iPublicExcludes.Reset();
TInt selectionCount = iPublicSelections.Count();
for (TInt x = 0; x < selectionCount; ++x)
{
const TDesC& selectionName = iPublicSelections[x]->SelectionName();
__LOG3("CDataOwner::GetNextPublicFileL() - selection[%03d]: %S, type: %d", x, &selectionName, iPublicSelections[x]->SelectionType());
if (iPublicSelections[x]->SelectionType() == EExclude)
{
iPublicExcludes.AppendL(selectionName);
} // else
} // for x
} // if (aReset)
while (!endOfList && !gotEntry)
{
stackCount = iPublicDirStack.Count();
if (stackCount == 0)
{
// Directory stack is empty, proceed to the next included file entry
do { ++iPublicFileIndex; }
while (iPublicFileIndex < iPublicSelections.Count() &&
iPublicSelections[iPublicFileIndex]->SelectionType() != EInclude);
if (iPublicFileIndex < iPublicSelections.Count())
{
const TDesC& selectionName = iPublicSelections[iPublicFileIndex]->SelectionName();
if (selectionName[0] == KBackSlash()[0])
{
// Add the drive
fileName.Zero();
fileName.Append(drive);
fileName.Append(KColon);
fileName.Append(selectionName);
}
else
{
// Handle the Exclamation (!) in Public data paths, if any.
// Exclamation mark in place of drive letter means that the path is to be checked in all available drives.
// And any dataowner can keep their public files in any drive and it can be mentioned in backup_registration file as below.
// <public_backup>
// <include_directory name="!:\mydatabases\" />
// </public_backup>
if ( selectionName[0] == KExclamationAsDrive()[0])
{
// Map public data path using current drive being backed up.
fileName.Zero();
fileName.Append(drive);
fileName.Append( selectionName.Mid(1) );
}
else
if (static_cast<TChar>(selectionName[0]).GetUpperCase() == drive.GetUpperCase())
{
fileName.Copy(selectionName);
} // else
} // else
__LOG1("CDataOwner::GetNextPublicFileL() - next include entry filename is therefore: %S", &fileName);
if (fileName.Length() > 0)
{
// Check to see if fileName is just a drive(we cant get an entry)
TBool isDrive = EFalse;
if ((fileName.MatchF(KDrive) != KErrNotFound) ||
(fileName.MatchF(KDriveAndSlash) != KErrNotFound))
{
isDrive = ETrue;
__LOG("CDataOwner::GetNextPublicFileL() - filename is a drive");
} // if
TBool isEntry = EFalse;
if (!isDrive)
{
TInt err = ipDataOwnerManager->GetRFs().Entry(fileName, aEntry);
__LOG1("CDataOwner::GetNextPublicFileL() - get entry error: %d", err);
aEntry.iName = fileName;
switch (err)
{
case KErrNone:
isEntry = ETrue;
break;
case KErrNotFound:
case KErrPathNotFound:
case KErrBadName:
break;
default:
User::Leave(err);
} // switch
// Must have a trailing backslash on a directory
if (aEntry.IsDir() && (fileName[fileName.Length() - 1] != '\\'))
{
fileName.Append(KBackSlash);
}
} // if
if (isDrive || (isEntry && aEntry.IsDir()))
{
__LOG("CDataOwner::GetNextPublicFileL() - parsing directory...");
RDir dir;
dir.Open(ipDataOwnerManager->GetRFs(), fileName, KEntryAttMaskSupported);
iPublicDirStack.AppendL(dir);
iPublicDirNameStack.AppendL(fileName.AllocL());
++stackCount;
} // if
else if (isEntry)
{
if (!IsExcluded(ETrue, fileName, iPublicExcludes))
{
gotEntry = ETrue;
}
else
{
__LOG("CDataOwner::BuildFileListL() - file is excluded!");
}
} // if
} // else if
}
else
{
endOfList = ETrue;
}
} // if (stackCount == 0)
if (stackCount > 0)
{
// There is a directory on the stack, so iterate through it
RDir& dir = iPublicDirStack[stackCount-1];
TInt err = dir.Read(aEntry);
if (err == KErrNone)
{
// Succesfully read the next directory entry
// Build full file path
fileName.Zero();
// loop through dir stack adding entries seperated by '\'.
for (TInt x = 0; x < iPublicDirStack.Count(); ++x)
{
fileName.Append(*iPublicDirNameStack[x]);
// Add a backslash if there's not already one
if (fileName[fileName.Length()-1] != KBackSlash()[0])
{
fileName.Append(KBackSlash);
}
}
// Append the currently entry name to complete the path
fileName.Append(aEntry.iName);
if (aEntry.IsDir())
{
// Must have a trailing backslash on directory paths
fileName.Append(KBackSlash);
// Open the directory and push it onto the dir stack
RDir dir;
User::LeaveIfError(dir.Open(ipDataOwnerManager->GetRFs(), fileName, KEntryAttMaskSupported));
iPublicDirStack.AppendL(dir);
iPublicDirNameStack.AppendL(aEntry.iName.AllocL());
++stackCount;
}
else
{
// Update entry with full path ready to return
aEntry.iName = fileName;
gotEntry = ETrue;
}
// if (entry.IsDir())
}
else if (err == KErrEof)
{
// Finished reading this directory, close it and pop it from the directory stack
stackCount--;
iPublicDirStack[stackCount].Close();
iPublicDirStack.Remove(stackCount);
delete iPublicDirNameStack[stackCount];
iPublicDirNameStack.Remove(stackCount);
}
else
{
User::Leave(err);
}
} // if (stackCount > 0)
}
if (endOfList)
{
// If the end of the list has been reached, make sure that an empty TEntry is returned
aEntry = TEntry();
}
}
TBool CDataOwner::IsExcluded(const TBool aIsPublic, const TDesC& aFileName, const RArray<TPtrC>& aExclude)
/** Checks to see if a given file is excluded
Checks to see if the given file is not in a private directory or in the exclude list.
@param aFileName file to check
@param aExclude list of excluded files
@return ETrue if excluded otherwise EFalse
*/
{
TBool ret = EFalse;
// Check it is not in sys, resource, system or backwards path
ret = (!((aFileName.MatchF(KSystem) == KErrNotFound) &&
(aFileName.MatchF(KResource) == KErrNotFound) &&
(aFileName.MatchF(KSys) == KErrNotFound) &&
(aFileName.MatchF(KOther) == KErrNotFound)
)
);
// If this is public backup remove the private directory
if (!ret && aIsPublic)
{
ret = (!(aFileName.MatchF(KPrivateMatch) == KErrNotFound));
}
/**
* Check whether file is in the "NoBackup" folder or not, if yes exclude it from the backup
* @note: All files which are kept in "NoBackup" folder under the private directory will be
* excluded from the backup by default.
*/
if (!ret)
{
ret = (!(aFileName.MatchF(KPrivateNoBackup) == KErrNotFound));
}
// See if the file is in a private directory the data owner can access
if (!ret && (aFileName.MatchF(KPrivateMatch) != KErrNotFound))
{
// The path includes a private directory, make sure it is the data owners
// private directory.
const TInt KSecureIdLength(8); // This is currently the length of a secure id
TBuf<KSecureIdLength> sid;
sid.Num(iSecureId, EHex);
TFileName match(KPrivateSidMatch());
match.Append(KPad().Ptr(), KPad().Length() - sid.Length());
match.Append(sid);
match.Append(KStar);
ret = (aFileName.MatchF(match) == KErrNotFound);
} // if
if (!ret)
{
// Is the file in the exclude list?
const TInt count = aExclude.Count();
for (TInt x = 0; !ret && x < count; x++)
{
__LOG1("file name: %S",&aFileName);
if (aExclude[x][0] == KBackSlash()[0])
{
// Compare with out drive
TFileName compare = KQuestionMark();
compare.Append(KColon);
compare.Append(aExclude[x]);
ret = (!(aFileName.MatchF(compare) == KErrNotFound));
} // if
else
{
// Normal compare
ret = (aFileName.CompareF(aExclude[x]) == 0);
} // else
} // for x
} // if
__LOG2("CDataOwner::IsExcluded() - END - returns excluded: %d for file: %S", ret, &aFileName);
return ret;
}
void CDataOwner::SupplyPassiveSnapshotDataL(TDriveNumber aDriveNumber, TDesC8& aBuffer, TBool aLastSection)
/** Handles the supply of passive snapshot data
@param aBuffer The buffer containing the snapshot data.
@param aLastSection Is this the last section?
*/
{
__LOG2("CDataOwner::SupplyPassiveSnapshotDataL() - START - aDriveNumber: %c, aLastSection: %d", aDriveNumber + 'A', aLastSection);
TInt err = KErrNone;
if (iBufferSnapshotReader == NULL)
{
__LOG("CDataOwner::SupplyPassiveSnapshotDataL() - making temporary snapshot holder..");
iTempSnapshotHolder = CSnapshotHolder::NewL();
iTempSnapshotHolder->iDriveNumber = aDriveNumber;
iBufferSnapshotReader = CBufferSnapshotReader::NewL(iTempSnapshotHolder->iSnapshots);
__LOG("CDataOwner::SupplyPassiveSnapshotDataL() - trying to unpack snapshots from buffer...");
TRAP(err, iBufferSnapshotReader->StartL(aBuffer, aLastSection));
__LOG1("CDataOwner::SupplyPassiveSnapshotDataL() - unpack result was: %d", err);
} // if
else
{
__LOG("CDataOwner::SupplyPassiveSnapshotDataL() - continuing unpack operation...");
TRAP(err, iBufferSnapshotReader->ContinueL(aBuffer, aLastSection));
__LOG1("CDataOwner::SupplyPassiveSnapshotDataL() - continued unpack operation result was: %d", err);
}
if ((err != KErrNone) || aLastSection)
{
delete iBufferSnapshotReader;
iBufferSnapshotReader = NULL;
if (err == KErrNone)
{
__LOG("CDataOwner::SupplyPassiveSnapshotDataL() - Snapshots identified ok!");
iSnapshots.AppendL(iTempSnapshotHolder);
iTempSnapshotHolder = NULL;
} // if
else
{
__LOG1("CDataOwner::SupplyPassiveSnapshotDataL() - END - leaving with error: %d", err);
User::Leave(err);
} // else
} // if
__LOG("CDataOwner::SupplyPassiveSnapshotDataL() - END");
}
void CDataOwner::SupplyPassiveBaseDataL(const TDriveNumber aDriveNumber, TDesC8& aBuffer, TBool aLastSection)
/** Handles the supply of passive base data
*/
{
__LOG3("CDataOwner::SupplyPassiveBaseDataL() - START - drive: %c, aLastSection: %d, iBufferFileReader: 0x%08x", aDriveNumber + 'A', aLastSection, iBufferFileReader);
TInt err = KErrNone;
if (iBufferFileReader == NULL)
{
iBufferFileReader = CBufferFileReader::NewL(ipDataOwnerManager->GetRFs(), FindSnapshot(aDriveNumber), this);
TRAP(err, iBufferFileReader->StartL(aBuffer, aLastSection));
} // if
else
{
TRAP(err, iBufferFileReader->ContinueL(aBuffer, aLastSection));
} // else
if ((err != KErrNone) || aLastSection)
{
if ( err != KErrNone )
{
__LOG1("CDataOwner::SupplyPassiveBaseDataL() - ERROR - error: %d", err);
}
delete iBufferFileReader;
iBufferFileReader = NULL;
User::LeaveIfError(err);
} // if
__LOG("CDataOwner::SupplyPassiveBaseDataL() - END");
}
void CDataOwner::RequestPassiveSnapshotDataL(TDriveNumber aDriveNumber, TPtr8& aBuffer,
TBool& aLastSection)
/** Handles the request for passive snapshot data
@param aDriveNumber The drive snapshot data is required.
@param aBuffer The buffer to write the data too.
@param aLastSection On return set to true if finished.
*/
{
__LOG3("CDataOwner::RequestPassiveSnapshotDataL() - START - aDriveNumber: %c, owner: 0x%08x, bufferLen: %d", aDriveNumber + 'A', iSecureId.iId, aBuffer.Length() );
if (iBufferSnapshotWriter == NULL)
{
RFileArray fileinfos;
CleanupClosePushL(fileinfos);
CDesCArray* filenames = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity);
CleanupStack::PushL(filenames);
BuildFileListL(iPassiveSelections, aDriveNumber, EPassiveBaseData, EFalse, NULL, &fileinfos, filenames);
// Add the DBMS file
AddDBMSFilesL(aDriveNumber, filenames, &fileinfos);
const TInt count = fileinfos.Count();
if (count > 0)
{
__LOG1("CDataOwner::SupplyPassiveBaseDataL() - got %d entries...", count);
// Create a tempory snapshot holder
RSnapshots* tempSnapshots = new(ELeave) RSnapshots();
TCleanupItem cleanup(CleanupRPointerArray, tempSnapshots);
CleanupStack::PushL(cleanup);
for (TInt x = 0; x < count; x++)
{
const TDesC& fileName = (*filenames)[x];
CSnapshot* snapshot = CSnapshot::NewLC(fileinfos[x].iModified.Int64(), fileName);
__LOG3("CDataOwner::RequestPassiveSnapshotDataL() - snapshot[%2d/%2d] = %S", x+1, count, &fileName);
tempSnapshots->AppendL(snapshot);
CleanupStack::Pop(snapshot);
} // for x
// Create a buffer writer
iBufferSnapshotWriter = CBufferSnapshotWriter::NewL(tempSnapshots);
CleanupStack::Pop(tempSnapshots);
__LOG("CDataOwner::RequestPassiveSnapshotDataL() - writing snapshots to buffer...");
iBufferSnapshotWriter->StartL(aBuffer, aLastSection);
if (aLastSection)
{
delete iBufferSnapshotWriter;
iBufferSnapshotWriter = NULL;
} // if
} // if
else
{
aLastSection = ETrue;
} // else
CleanupStack::PopAndDestroy(filenames);
CleanupStack::PopAndDestroy(&fileinfos);
} // if
else
{
iBufferSnapshotWriter->ContinueL(aBuffer, aLastSection);
if (aLastSection)
{
delete iBufferSnapshotWriter;
iBufferSnapshotWriter = NULL;
} // if
} // else
__LOG2("CDataOwner::RequestPassiveSnapshotDataL() - END - aLastSection: %d, bufferLen: %d", aLastSection, aBuffer.Length());
} // RequestPassiveSnapShotDataL
void CDataOwner::RequestPassiveDataL(TTransferDataType aTransferType,
TDriveNumber aDriveNumber, TPtr8& aBuffer,
TBool& aLastSection)
/** Handles the request for passive base data
@param aDriveNumber The drive that files must be on.
@param aBuffer The buffer to write the data to.
@param aLastSection On return set to true if finished.
*/
{
__LOG4("CDataOwner::RequestPassiveDataL() - START - aDrive: %c, aTransferType: %d, iSecureId: 0x%08x, iBufferFileWriter: 0x%08x", aDriveNumber + 'A', aTransferType, iSecureId.iId, iBufferFileWriter);
// Build the list of files
if (iBufferFileWriter == NULL)
{
CDesCArray* filenames = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity);
CleanupStack::PushL(filenames);
if (aTransferType == EPassiveBaseData)
{
__LOG("CDataOwner::RequestPassiveDataL() - EPassiveBaseData...");
BuildFileListL(iPassiveSelections, aDriveNumber, aTransferType, EFalse, NULL, NULL, filenames);
// Add the DBMS file
AddDBMSFilesL(aDriveNumber, filenames, NULL);
} // if
else
{
// Do we have a snapshot?
const TInt count = iSnapshots.Count();
RSnapshots* pSnapshot = NULL;
for (TInt x = 0; !pSnapshot && (x < count); x++)
{
if (iSnapshots[x]->iDriveNumber == aDriveNumber)
{
pSnapshot = &(iSnapshots[x]->iSnapshots);
} // if
} // for x
BuildFileListL(iPassiveSelections, aDriveNumber, aTransferType, EFalse, pSnapshot, NULL, filenames);
// Do we need to add the DBMS file?
AddDBMSFilesL(aDriveNumber, filenames, NULL);
} // else
__LOG1("CDataOwner::RequestPassiveDataL() - Got %d files...", filenames->Count());
if (filenames->Count() > 0)
{
// Create a file writer
iBufferFileWriter = CBufferFileWriter::NewL(ipDataOwnerManager->GetRFs(), filenames);
CleanupStack::Pop(filenames);
iBufferFileWriter->StartL(aBuffer, aLastSection);
if (aLastSection)
{
delete iBufferFileWriter;
iBufferFileWriter = NULL;
}
} // if
else
{
CleanupStack::PopAndDestroy(filenames);
aLastSection = ETrue;
} // else
} // if
else
{
iBufferFileWriter->ContinueL(aBuffer, aLastSection);
if (aLastSection)
{
delete iBufferFileWriter;
iBufferFileWriter = NULL;
} // if
} // else
__LOG("CDataOwner::RequestPassiveDataL() - END");
}
void CDataOwner::IsNewerL(const TDesC& aFileName, const TEntry& aFile, const RSnapshots* aSnapshots, TBool& aNewer)
/** Check to see if a file is newer.
Checks to see if aFile is newer than the one contained in aFiles.
@param aFile the file to check.
@param aFiles the array of files to check agaisnt
@param aNewer on return ETrue if aFile is newer, EFalse otherwise.
@leave KErrNotFound if aFile does not exist in aFiles.
*/
{
CSnapshot* snapshot = CSnapshot::NewLC(TTime().Int64(), aFileName);
TInt res = aSnapshots->Find(snapshot, CSnapshot::Match);
CleanupStack::PopAndDestroy(snapshot);
User::LeaveIfError(res);
if (aFile.iModified.Int64() > (*aSnapshots)[res]->Modified())
{
aNewer = ETrue;
}
else
{
aNewer = EFalse;
}
}
RSnapshots* CDataOwner::FindSnapshot(TDriveNumber aDriveNumber)
/** Searches the snapshots find a snapshot
@param aDriveNumber find snapshot for drive aDriveNumber
@return The snapshot or NULL
*/
{
const TInt count = iSnapshots.Count();
__LOG3("CDataOwner::FindSnapshot() - START - aDriveNumber: %c, count: %d, iSecureId: 0x%08x", aDriveNumber + 'A', count, iSecureId.iId);
RSnapshots* pRet = NULL;
for (TInt x = 0; !pRet && (x < count); x++)
{
CSnapshotHolder* snapshotHolder = iSnapshots[x];
#ifdef SBE_LOGGING_ENABLED
const TInt entryCount = snapshotHolder->iSnapshots.Count();
__LOG4("CDataOwner::FindSnapshot() - snapshot[%02d] - drive: %c, entry Count: %d, addr: 0x%08x", x, snapshotHolder->iDriveNumber + 'A', entryCount, &snapshotHolder->iSnapshots);
for(TInt i=0; i<entryCount; i++)
{
const TDesC& snapshot = snapshotHolder->iSnapshots[i]->FileName();
__LOG2("CDataOwner::FindSnapshot() - file[%04d]: %S", i+1, &snapshot);
}
#endif
if (snapshotHolder->iDriveNumber == aDriveNumber)
{
pRet = &(snapshotHolder->iSnapshots);
} // if
} // for x
__LOG1("CDataOwner::FindSnapshot() - END - ret: 0x%08x", pRet);
return pRet;
}
/**
Returns a reference to a state by drive object. Object is located using aDrive as a key
@param aDrive Index identifying the TDataOwnerStateByDrive
*/
TDataOwnerStateByDrive& CDataOwner::StateByDriveL(TDriveNumber& aDrive)
{
TBool found = EFalse;
const TInt count = iStateByDrive.Count();
TInt index = 0;
// Loop around until we find
while ((index < count) && !found)
{
if (iStateByDrive[index].iDrive == aDrive)
{
found = ETrue;
}
else
{
++index;
}
}
// We must have found, otherwise error
if (!found)
{
User::Leave(KErrNotFound);
}
return iStateByDrive[index];
}
/**
Returns a reference to a proxy state by drive object. Object is located using aDrive and aProxy as keys
@param aDrive Index identifying the TProxyStateByDrive
@param aProxy Index identifying the proxy
*/
TProxyStateByDrive& CDataOwner::ProxyStateByDriveL(TDriveNumber& aDrive, TInt aProxy)
{
TBool found = EFalse;
const TInt count = iProxyStateByDrive.Count();
TInt index = 0;
// Loop around until we find
while ((index < count) && !found)
{
if (iProxyStateByDrive[index].iDrive == aDrive &&
iProxyStateByDrive[index].iProxy == aProxy)
{
found = ETrue;
}
else
{
++index;
}
}
// Add a new entry if not found
if (!found)
{
iProxyStateByDrive.Append(TProxyStateByDrive(aDrive,aProxy));
index = count;
}
return iProxyStateByDrive[index];
}
/**
Called to re-create the state-by-drive array
*/
void CDataOwner::BuildDriveStateArrayL()
{
TDriveList driveList;
driveList.SetMax();
TRAPD(err, GetDriveListL(driveList));
__LOG2("CDataOwner::BuildDriveStateArrayL() - START - SID: 0x%08x, error: %d", iSecureId.iId, err);
if (err == KErrNone)
{
for (TInt index = 0; index < KMaxDrives; index++)
{
if (driveList[index])
{
// Add a new state object to the array of states
iStateByDrive.AppendL(TDataOwnerStateByDrive(static_cast<TDriveNumber>(index)));
}
}
}
else
{
__LOG1("CDataOwner::BuildDriveStateArrayL() - Warning! error ocurred whilst getting the drivelist from data owner %08x", iSecureId.iId);
}
}
/**
Adds the list of DBMS files to a filename list
*/
void CDataOwner::AddDBMSFilesL(TDriveNumber aDriveNumber, CDesCArray* apFileNames, RFileArray* apEntries)
{
const TInt count = iDBMSSelections.Count();
__LOG3("CDataOwner::AddDBMSFilesL() - START - aDriveNumber: %c, owner: 0x%08x, count: %d", aDriveNumber + 'A', iSecureId.iId, count);
if (count > 0)
{
// Get DB connection
RDbs dbs;
User::LeaveIfError(dbs.Connect());
CleanupClosePushL(dbs);
for (TInt x = 0; x < count; x++)
{
// Get list of filenames
TInt err = KErrNone;
CDbStrings* pFilenames = NULL;
TRAP(err, pFilenames = dbs.BackupPathsL(iSecureId, iDBMSSelections[x]));
if (err == KErrNone)
{
CleanupStack::PushL(pFilenames);
__LOG1("CDataOwner::AddDBMSFilesL() - getting backup paths for owner returned error: %d", err);
const TInt count = pFilenames->Count();
for (TInt x = 0; x < count; x++)
{
const TDesC& pFileName = (*pFilenames)[x];
__LOG3("CDataOwner::AddDBMSFilesL() - file[%3d/%3d] = %S", x + 1, count, &pFileName);
TInt drive = -1;
TInt driveerr = RFs::CharToDrive( pFileName[0], drive);
if ((driveerr == KErrNone) && (drive == aDriveNumber))
{
if (apFileNames)
{
__LOG1("CDataOwner::AddDBMSFilesL() - adding validated filename: %S", &pFileName);
apFileNames->AppendL( pFileName );
}
if (apEntries)
{
TEntry entry;
TInt entryError = ipDataOwnerManager->GetRFs().Entry( pFileName, entry);
__LOG2("CDataOwner::AddDBMSFilesL() - drive entry result for file \'%S\' is: %d", &pFileName, entryError);
if (entryError == KErrNone)
{
__LOG1("CDataOwner::AddDBMSFilesL() - adding validated entry: %S", &pFileName);
apEntries->AppendL(entry);
} // if
else if (entryError != KErrNotFound)
{
__LOG2("CDataOwner::AddDBMSFilesL() - Could not get entry for 0x%08x, error: %d", iSecureId.iId, entryError);
} // else if
} // if
} // if
else
{
__LOG("CDataOwner::AddDBMSFilesL() - File is not applicable for this drive => file ignored");
}
} // for x
// Cleanup
CleanupStack::PopAndDestroy(pFilenames);
}
else
{
__LOG2("CDataOwner::AddDBMSFilesL() - RDbs error %d SID: 0x%08x", err, iSecureId.iId);
} // else
} // for x
// Cleanup
CleanupStack::PopAndDestroy(&dbs);
} // if
__LOG2("CDataOwner::AddDBMSFilesL() - END - aDriveNumber: %c, owner: 0x%08x", aDriveNumber + 'A', iSecureId.iId);
} // AddDBMSFiles
/** Disables system data
*/
void CDataOwner::DisableSystemData()
{
iSystemInformation.iSupported = EFalse;
} // Disable system data
TInt CDataOwner::AddProxyToList(TProxyInformation aProxy)
/** Adds proxy to list making sure there are no duplicates
@param TProxyInformation Proxy to add
@return error if Append failes
*/
{
TInt count = iProxyInformationArray.Count();
TBool found = EFalse;
while (count && !found)
{
--count;
if (iProxyInformationArray[count].iSecureId == aProxy.iSecureId)
{
found = ETrue;
}
}
TInt err = KErrNone;
if (!found)
{
err = iProxyInformationArray.Append(aProxy);
__LOG2("Data owner(0x%08x): Adding Proxy(0x%08x) to the list", iSecureId.iId,aProxy.iSecureId.iId);
}
return err;
}
void CDataOwner::CleanupBeforeRestoreL(TDriveNumber& aDriveNumber)
/** Performs a cleanup before restore if required
@param aDriveNumber drive to clear
*/
{
const TBool passiveDeleteBeforeRestore = iPassiveInformation.iDeleteBeforeRestore;
const TBool driveAlreadyCleaned = StateByDriveL(aDriveNumber).iDeleteBeforeRestorePerformed;
__LOG4("CDataOwner::CleanupBeforeRestoreL() - START - aDriveNumber: %c, owner: 0x%08x, passiveDeleteBeforeRestore: %d, driveAlreadyCleaned: %d", aDriveNumber + 'A', iSecureId.iId, passiveDeleteBeforeRestore, driveAlreadyCleaned);
if ( passiveDeleteBeforeRestore && !driveAlreadyCleaned )
{
RSelections* selections = new(ELeave) RSelections();
TCleanupItem cleanup(CleanupRPointerArray, selections);
CleanupStack::PushL(cleanup);
// The path to search for files to delete
CSelection* selection = NULL;
const TDesC& privatePath = *iPrivatePath;
if (privatePath[0] == KBackSlash()[0])
{
selection = CSelection::NewLC(EInclude, privatePath);
} // if
else
{
selection = CSelection::NewLC(EInclude, privatePath.Right(privatePath.Length() - 2));
} // else
selections->AppendL(selection);
CleanupStack::Pop(selection);
// Find the files to delete
CDesCArray* toDelete = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity);
CleanupStack::PushL(toDelete);
BuildFileListL(*selections, aDriveNumber, EPassiveBaseData, EFalse, NULL, NULL, toDelete);
// Loop through the files to delete, deleting them
const TInt count = toDelete->Count();
for (TInt x = 0; x < count; x++)
{
const TDesC& fileName = (*toDelete)[x];
__LOG3("CDataOwner::CleanupBeforeRestoreL() - checking file[%2d/%2d] for match = %S", x + 1, count, &fileName);
// Check it is not a backup registration file
if ( fileName.MatchF(KBackupRegistrationFile) == KErrNotFound )
{
TInt deleteError=0;
if((fileName[(fileName.Length())-1])== KBackSlash()[0])
{
deleteError = ipDataOwnerManager->GetRFs().RmDir( fileName );
}
else
{
deleteError = ipDataOwnerManager->GetRFs().Delete( fileName );
}
__LOG2("CDataOwner::CleanupBeforeRestoreL() - trying to deleting file %S (error was: %d)", &fileName, deleteError);
User::LeaveIfError(deleteError);
} // if
} // for
// Mark as done
StateByDriveL(aDriveNumber).iDeleteBeforeRestorePerformed = ETrue;
// Cleanup
CleanupStack::PopAndDestroy(toDelete);
CleanupStack::PopAndDestroy(selections);
} // if
__LOG2("CDataOwner::CleanupBeforeRestoreL() - END - aDriveNumber: %c, owner: 0x%08x", aDriveNumber + 'A', iSecureId.iId);
}
/**
Check if the file is in the include list
@param TDesC& aFileName file name to check
@return TBool ETrue if file is in the include list
*/
TBool CDataOwner::ValidFileL(const TDesC& aFileName)
{
__LOG2("CDataOwner::ValidFileL() - START - owner: 0x%08x, aFileName: %S", iSecureId.iId, &aFileName);
TInt include = EFalse;
const TInt count = iPassiveSelections.Count();
for (TInt i =0; i < count; i++)
{
const TDesC& selectionName = iPassiveSelections[i]->SelectionName();
TInt match = aFileName.FindF(selectionName);
__LOG5("CDataOwner::ValidFileL() - match result against file[%3d/%3d], selectionType: %d, matchResult: %d, name: %S", i+1, count, iPassiveSelections[i]->SelectionType(), match, &selectionName);
if (match >= 0)
{
if (iPassiveSelections[i]->SelectionType() == EInclude)
{
__LOG("CDataOwner::ValidFileL() - file included");
include = ETrue;
}
else
{
__LOG("CDataOwner::ValidFileL() - file excluded");
include = EFalse;
break;
} // else if
} //if
} // for
const TInt dbmsSelectionCount = iDBMSSelections.Count();
if (dbmsSelectionCount && !include)
{
__LOG1("CDataOwner::ValidFileL() - checking against %d DBMS files...", dbmsSelectionCount);
for (TInt j = 0; j < dbmsSelectionCount; j++)
{
const TDesC& pDbmsFileName = iDBMSSelections[j].Name();
const TInt matchResult = aFileName.FindF( pDbmsFileName );
__LOG4("CDataOwner::ValidFileL() - checking against DBMS file[%2d/%2d] with result: %d (%S)...", j+1, dbmsSelectionCount, matchResult, &pDbmsFileName);
if ( matchResult )
{
__LOG("CDataOwner::ValidFileL() - DBMS file included");
include = ETrue;
break;
} // if
}//for
} // if
__LOG1("CDataOwner::ValidFileL() - END - valid file result is: %d", include);
return include;
}
//
// MContentHandler Implementaion //
//
void CDataOwner::OnStartDocumentL(const RDocumentParameters& /*aDocParam*/, TInt aErrorCode)
/** MContentHandler::OnStartDocumentL()
*/
{
if (aErrorCode != KErrNone)
{
__LOG1("CDataOwner::OnStartDocumentL() - error = %d", aErrorCode);
User::Leave(aErrorCode);
}
}
void CDataOwner::OnEndDocumentL(TInt aErrorCode)
/** MContentHandler::OnEndDocumentL()
*/
{
if (aErrorCode != KErrNone)
{
// just to satifsy UREL compiler
(void) aErrorCode;
__LOG1("CDataOwner::OnEndDocumentL() - error = %d", aErrorCode);
}
}
void CDataOwner::OnStartElementL(const RTagInfo& aElement,
const RAttributeArray& aAttributes,
TInt aErrorCode)
/** MContentHandler::OnStartElementL()
@leave KErrUnknown an unknown element
*/
{
if (aErrorCode != KErrNone)
{
__LOG1("CDataOwner::OnStartElementL() - error = %d", aErrorCode);
User::LeaveIfError(aErrorCode);
}
TBool unknownElement = EFalse;
const TDesC8& localName = aElement.LocalName().DesC();
if (localName == KIncludeFile)
{
HandlePathL(EInclude, aAttributes, EFalse);
}
else if (!localName.CompareF(KIncludeDirectory))
{
HandlePathL(EInclude, aAttributes, ETrue);
}
else if (!localName.CompareF(KExclude))
{
HandlePathL(EExclude, aAttributes, EFalse);
}
else if (!localName.CompareF(KBackupRegistration))
{
HandleBackupRegistrationL(aAttributes);
}
else if (!localName.CompareF(KDBMSBackup))
{
User::LeaveIfError(HandleDBMSBackupL(aAttributes));
}
else if (!localName.CompareF(KSystemBackup))
{
User::LeaveIfError(HandleSystemBackup(aAttributes));
}
else if (!localName.CompareF(KProxyDataManager))
{
User::LeaveIfError(HandleProxyDataManager(aAttributes));
}
else if (!localName.CompareF(KCenrepBackup))
{
User::LeaveIfError(HandleCenrepBackup(aAttributes));
}
else if (!localName.CompareF(KPublicBackup))
{
iCurrentElement = EPublic;
User::LeaveIfError(HandlePublicBackup(aAttributes));
}
else if (!localName.CompareF(KPassiveBackup))
{
iCurrentElement = EPassive;
// Only allow passive to be switched on in primary files
if (iPrimaryFile)
{
User::LeaveIfError(HandlePassiveBackup(aAttributes));
}
}
else if (iPrimaryFile)
{
// These remaining elements are only allowed in primary files
if (!localName.CompareF(KActiveBackup))
{
User::LeaveIfError(HandleActiveBackupL(aAttributes));
}
else if (!localName.CompareF(KRestore))
{
User::LeaveIfError(HandleRestore(aAttributes));
}
else
{
unknownElement = ETrue;
}
} // if primary file true
else
{
unknownElement = ETrue;
}
if (unknownElement)
{
__LOG1("CDataOwner::OnStartElementL() - Unknown element while parsing 0x%08x", iSecureId.iId);
}
}
void CDataOwner::OnEndElementL(const RTagInfo& aElement, TInt aErrorCode)
/** MContentHandler::OnEndElementL()
*/
{
if (aErrorCode != KErrNone)
{
__LOG1("CDataOwner::OnEndElementL() - error = %d", aErrorCode);
User::Leave(aErrorCode);
}
const TDesC8& localName = aElement.LocalName().DesC();
if (!localName.CompareF(KPassiveBackup))
{
iCurrentElement = ENoElement;
} // if
else if (localName == KPublicBackup)
{
iCurrentElement = ENoElement;
} // else if
}
void CDataOwner::OnContentL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)
/** MContentHandler::OnContentL()
*/
{
// Not handled
}
void CDataOwner::OnStartPrefixMappingL(const RString& /*aPrefix*/,
const RString& /*aUri*/, TInt /*aErrorCode*/)
/** MContentHandler::OnStartPrefixMappingL()
*/
{
// Not handled
}
void CDataOwner::OnEndPrefixMappingL(const RString& /*aPrefix*/, TInt /*aErrorCode*/)
/** MContentHandler::OnEndPrefixMappingL()
*/
{
// Not handled
}
void CDataOwner::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)
/** MContentHandler::OnIgnorableWhiteSpaceL()
*/
{
// Not handled
}
void CDataOwner::OnSkippedEntityL(const RString& /*aName*/, TInt /*aErrorCode*/)
/** MContentHandler::OnSkippedEntityL()
*/
{
// Not handled
}
void CDataOwner::OnProcessingInstructionL(const TDesC8& /*aTarget*/,
const TDesC8& /*aData*/,
TInt /*aErrorCode*/)
/** MContentHandler::OnProcessingInstructionL()
*/
{
// Not handled
}
void CDataOwner::OnError(TInt aErrorCode)
/** MContentHandler::OnError()
@leave aErrorCode
*/
{
(void)aErrorCode;
__LOG1("CDataOwner::OnError() - error = %d", aErrorCode);
}
TAny* CDataOwner::GetExtendedInterface(const TInt32 /*aUid*/)
/** MContentHandler::OnEndPrefixMappingL()
*/
{
return NULL;
}
void CDataOwner::HandleBackupRegistrationL(const RAttributeArray& aAttributes)
/** Handles the "backup_registration" element
@param aAttributes the attributes for the element
@return KErrNone no errors
@return KErrUnknown unknown version
*/
{
if (aAttributes.Count() == 1)
{
// Check the version is correct.
if (aAttributes[0].Value().DesC() != KVersion()) // Only version we know about
{
__LOG1("CDataOwner::HandleBackupRegistrationL() - Unknown version at SID(0x%08x)", iSecureId.iId);
User::Leave(KErrNotSupported);
} // else
} // if
}
TInt CDataOwner::HandlePassiveBackup(const RAttributeArray& aAttributes)
/** Handles the "passive_backup" element
@param aAttributes the attributes for the element
@return KErrNone
*/
{
iPassiveInformation.iSupported = ETrue;
// Loop through reading out attribute values
const TInt count = aAttributes.Count();
for (TInt x = 0; x < count; x++)
{
const TDesC8& localName = aAttributes[x].Attribute().LocalName().DesC();
if ( localName.CompareF(KSupportsSelective) == 0 )
{
const TBool supportsSelective = ( aAttributes[x].Value().DesC().CompareF(KYes) == 0 );
iPassiveInformation.iSupportsSelective = supportsSelective;
__LOG2("CDataOwner::HandlePassiveBackup(0x%08x) - iPassiveInformation.iSupportsSelective: %d", iSecureId.iId, supportsSelective);
} // if
else if ( localName.CompareF(KDeleteBeforeRestore) == 0 )
{
// AW This logic looks somewhat strange.
if (!aAttributes[x].Value().DesC().CompareF(KYes))
{
__LOG1("CDataOwner::HandlePassiveBackup(0x%08x) - iPassiveInformation.iDeleteBeforeRestore: ETrue", iSecureId.iId);
iPassiveInformation.iDeleteBeforeRestore |= ETrue;
} // if
else
{
__LOG1("CDataOwner::HandlePassiveBackup(0x%08x) - iPassiveInformation.iDeleteBeforeRestore: EFalse", iSecureId.iId);
iPassiveInformation.iDeleteBeforeRestore |= EFalse;
} // else
} // else if
else if ( localName.CompareF(KBaseBackupOnly) == 0 )
{
const TBool baseBackupOnly = ( aAttributes[x].Value().DesC().CompareF(KYes) == 0 );
iPassiveInformation.iBaseBackupOnly = baseBackupOnly;
__LOG2("CDataOwner::HandlePassiveBackup(0x%08x) - iPassiveInformation.iBaseBackupOnly: %d", iSecureId.iId, baseBackupOnly);
} // else if
else
{
__LOG1("CDataOwner::HandlePassiveBackup() - Unknown element while parsing 0x%08x", iSecureId.iId);
} // else
} // for x
return KErrNone;
}
TInt CDataOwner::HandlePublicBackup(const RAttributeArray& aAttributes)
/** Handles the "public_backup" element
@param aAttributes the attributes for the element
@return KErrNone
*/
{
iPublicInformation.iSupported = ETrue;
if (aAttributes.Count() > 0)
{
const TBool deleteBeforeRestore = ( aAttributes[0].Value().DesC().CompareF(KYes) == 0 );
iPublicInformation.iDeleteBeforeRestore = deleteBeforeRestore;
__LOG2("CDataOwner::HandlePublicBackup(0x%08x) - iPublicInformation.iDeleteBeforeRestore: %d", iSecureId.iId, deleteBeforeRestore);
} // if
return KErrNone;
}
TInt CDataOwner::HandleSystemBackup(const RAttributeArray& /*aAttributes*/)
/** Handles the "system_backup" element
@param aAttributes the attributes for the element
@return KErrNone
*/
{
iSystemInformation.iSupported = ETrue;
__LOG2("CDataOwner::HandleSystemBackup(0x%08x) - iSystemInformation.iSupported: %d", iSecureId.iId, iSystemInformation.iSupported);
return KErrNone;
}
TInt CDataOwner::HandleCenrepBackup(const RAttributeArray& /*aAttributes*/)
/** Handles the "cenrep_backup" element
@param aAttributes the attributes for the element
@return KErrNone
*/
{
TInt err = KErrNone;
TProxyInformation proxyInformation;
proxyInformation.iSecureId = ipDataOwnerManager->Config().CentRepId();
err = AddProxyToList(proxyInformation);
if (err == KErrNone)
{
if (iActiveInformation.iSupported == EFalse)
{
iActiveInformation.iSupported = ETrue;
iActiveInformation.iSupportsIncremental = EFalse;
iStatus = EDataOwnerNotConnected;
}
}
__LOG2("CDataOwner::HandleCenrepBackup(0x%08x) - proxy creation error: %d", iSecureId.iId, err);
return err;
}
TInt CDataOwner::HandleProxyDataManager(const RAttributeArray& aAttributes)
/** Handles the "proxy_data_manager" element
@param aAttributes the attributes for the element
@return KErrNone
*/
{
TInt err = KErrNone;
TProxyInformation proxyInformation;
const TDesC8& localName = aAttributes[0].Attribute().LocalName().DesC();
if (!localName.CompareF(KProxySID))
{
// The value returned from the XML element attribute parse
const TDesC8& hexString = aAttributes[0].Value().DesC();
TPtrC8 strippedSID;
// Test for lower case hex leader chars
TInt result = hexString.FindF(KHexLeader);
if (result != KErrNotFound)
{
if (hexString.Length() < (result + KHexLeader().Size()))
{
__LOG1("CDataOwner::HandleProxyDataManager() - The Hex number has incorrect number of digits", iSecureId.iId);
}
// Strip off the preceeding upper case hex leader characters
strippedSID.Set(hexString.Mid(result + KHexLeader().Size()));
}
else
{
// There were no leading characters in the data
strippedSID.Set(hexString);
}
TLex8 sIdLex(strippedSID);
err = sIdLex.Val(proxyInformation.iSecureId.iId, EHex);
if (err == KErrNone && proxyInformation.iSecureId.iId != iSecureId.iId)
{
err = AddProxyToList(proxyInformation);
if (err == KErrNone)
{
if (iActiveInformation.iSupported == EFalse)
{
iActiveInformation.iSupported = ETrue;
iActiveInformation.iSupportsIncremental = EFalse;
iStatus = EDataOwnerNotConnected;
}
}
__LOG3("CDataOwner::HandleProxyDataManager(0x%08x) - proxy creation error: %d for proxySid: 0x%08x", iSecureId.iId, err, proxyInformation.iSecureId.iId);
}
else
{
__LOG1("CDataOwner::HandleProxyDataManager() - Not a Hex Number specified in reg_file of 0x%08x)", iSecureId.iId);
err = KErrNone; // We shouldn't return an error unless Append has errored (OOM etc.)
}
} // else it's corrupt - don't error, just ignore this attribute
return err;
}
TInt CDataOwner::HandleDBMSBackupL(const RAttributeArray& aAttributes)
/** Handles the "dbms_backup" element
@param aAttributes the attributes for the element
@return KErrNone
*/
{
iPassiveInformation.iSupported = ETrue;
const TInt count = aAttributes.Count();
for (TInt x = 0; x < count; x++)
{
const TDesC8& localName = aAttributes[x].Attribute().LocalName().DesC();
if (localName.Length() > 0)
{
if (!localName.CompareF(KDatabase))
{
__LOG1("CDataOwner::HandleDBMSBackup(0x%08x) - Still using deprecated 'database' attribute", iSecureId.iId);
}
else if (!localName.CompareF(KPolicy))
{
TName policy;
if (KErrNone == ipDataOwnerManager->ParserProxy().ConvertToUnicodeL(policy, aAttributes[x].Value().DesC()))
{
TLex lex(policy);
TUint32 temp;
lex.Val(temp, EHex);
// Check we have not seen this Uid before
const TInt count = iDBMSSelections.Count();
TBool toAdd = ETrue;
for (TInt x = 0; toAdd && (x < count); x++)
{
if (iDBMSSelections[x].iUid == temp)
{
toAdd = EFalse;
} // if
} // for
// Add to list of Uid's
if (toAdd)
{
__LOG2("CDataOwner::HandleDBMSBackup(0x%08x) - adding database with policy uid: 0x%08x", iSecureId.iId, temp);
TUid tempUID;
tempUID.iUid = temp;
TRAP_IGNORE(iDBMSSelections.AppendL(tempUID));
} // if
} // if
else
{
__LOG1("CDataOwner::HandleDBMSBackup(0x%08x) - Error converting policy number", iSecureId.iId);
} // else
} // else if
} // if
else
{
__LOG1("CDataOwner::HandleDBMSBackup(0x%08x) - Incorrect use of attributes", iSecureId.iId);
}
} // for x
return KErrNone;
}
TInt CDataOwner::HandleActiveBackupL(const RAttributeArray& aAttributes)
/** Handles the "active_backup" element
@param aAttributes the attributes for the element
@return KErrNone
*/
{
iActiveInformation.iSupported = ETrue;
iActiveInformation.iActiveDataOwner = ETrue;
iStatus = EDataOwnerNotConnected;
const TInt count = aAttributes.Count();
for (TInt x = 0; (iActiveInformation.iSupported && (x < count)); x++)
{
const TDesC8& localName = aAttributes[x].Attribute().LocalName().DesC();
if (!localName.CompareF(KProcessName))
{
if (KErrNone != ipDataOwnerManager->ParserProxy().ConvertToUnicodeL(iActiveInformation.iProcessName, aAttributes[x].Value().DesC()))
{
iActiveInformation.iSupported = EFalse;
__LOG1("CDataOwner::HandleActiveBackup(0x%08x) - Error converting process name", iSecureId.iId);
}
}
else if (!localName.CompareF(KRequiresDelay))
{
const TBool required = ( aAttributes[x].Value().DesC().CompareF(KYes) == 0 );
iActiveInformation.iRequiresDelayToPrepareData = required;
__LOG2("CDataOwner::HandleActiveBackup(0x%08x) - iActiveInformation.iRequiresDelayToPrepareData: %d", iSecureId.iId, required);
} // else if
else if (!localName.CompareF(KSupportsSelective))
{
const TBool required = ( aAttributes[x].Value().DesC().CompareF(KYes) == 0 );
iActiveInformation.iSupportsSelective = required;
__LOG2("CDataOwner::HandleActiveBackup(0x%08x) - iActiveInformation.iSupportsSelective: %d", iSecureId.iId, required);
} // else if
else if (!localName.CompareF(KSupportsInc))
{
const TBool required = ( aAttributes[x].Value().DesC().CompareF(KYes) == 0 );
iActiveInformation.iSupportsIncremental = required;
__LOG2("CDataOwner::HandleActiveBackup(0x%08x) - iActiveInformation.iSupportsIncremental: %d", iSecureId.iId, required);
} // else if
else if (!localName.CompareF(KActiveType))
{
const TDesC8& value = aAttributes[x].Value().DesC();
if (!value.CompareF(KActiveOnly))
{
__LOG1("CDataOwner::HandleActiveBackup(0x%08x) - iActiveInformation.iActiveType: EActiveOnly", iSecureId.iId);
iActiveInformation.iActiveType = EActiveOnly;
}
else if (!value.CompareF(KActiveAndProxy))
{
__LOG1("CDataOwner::HandleActiveBackup(0x%08x) - iActiveInformation.iActiveType: EActiveAndProxyImpl", iSecureId.iId);
iActiveInformation.iActiveType = EActiveAndProxyImpl;
}
else if (!value.CompareF(KProxyOnly))
{
__LOG1("CDataOwner::HandleActiveBackup(0x%08x) - iActiveInformation.iActiveType: EProxyImpOnly", iSecureId.iId);
iActiveInformation.iActiveType = EProxyImpOnly;
}
}
} // for x
return KErrNone;
}
TInt CDataOwner::HandleRestore(const RAttributeArray& aAttributes)
/** Handles the "restore" element
@param aAttributes the attributes for the element
@return KErrNone
*/
{
iRestoreInformation.iSupported = ETrue;
if (aAttributes.Count() == 1)
{
if (!aAttributes[0].Attribute().LocalName().DesC().CompareF(KRequiresReboot))
{
const TBool required = ( aAttributes[0].Value().DesC().CompareF(KYes) == 0 );
iRestoreInformation.iRequiresReboot = required;
__LOG2("CDataOwner::HandleRestore(0x%08x) - iRestoreInformation.iRequiresReboot: %d", iSecureId.iId, required);
} // if
} // if
return KErrNone;
}
void CDataOwner::HandlePathL(const TSelectionType aType,
const RAttributeArray& aAttributes,
const TBool aDir)
/** Handles the "include_file", "include_directory" and "exclude" elements
@param aType The selection type
@param aAttributes The attributes for the element
@param aDir The element was found in an <include_dir/> element?
*/
{
// Check we dont have a NULL string
if (aAttributes[0].Value().DesC().Length() > 0)
{
TFileName filename;
if (KErrNone != ipDataOwnerManager->ParserProxy().ConvertToUnicodeL(filename, aAttributes[0].Value().DesC()))
{
__LOG1("CDataOwner::HandlePathL(0x%08x) - EPassive - Could not convert filename", iSecureId.iId);
return;
}
else
{
__LOG3("CDataOwner::HandlePathL(0x%08x) - path in the registration file is: %S [type: %d]", iSecureId.iId, &filename, aType);
}
// If it is a directory is do we add a trailing backslash,
if (aDir && (filename[filename.Length() - 1] != '\\'))
{
filename.Append(KBackSlash);
} // if
switch (iCurrentElement)
{
case EPassive:
{
TFileName selectionName;
// first check for absolute path
TInt offset = filename.FindC(*iPrivatePath);
if (offset == KErrNotFound)
{
//check for collon path
offset = filename.FindC(KColon);
if (offset != KErrNotFound)
{
// someone other absoulute path
__LOG2("CDataOwner::HandlePathL(0x%08x) - Path is not recognised by the data owner : %S", iSecureId.iId, &filename);
return;
}
else
{
selectionName = *iPrivatePath;
if (filename[0] == '\\')
{
// the filename begins with \, thefore we need to chop it off
selectionName.SetLength(selectionName.Length() - 1);
}
selectionName.Append(filename);
}
}
else
{
// get the path but not the drive (e.g c:)
selectionName.Copy(filename.Right(filename.Length() - offset) );
}
CSelection* selection = CSelection::NewLC(aType, selectionName);
iPassiveSelections.AppendL(selection);
CleanupStack::Pop(selection);
__LOG3("CDataOwner::HandlePathL(0x%08x) - Added selection: %S [type: %d]", iSecureId.iId, &selectionName, aType);
break;
}
case EPublic:
{
// check if path relative or absolute
if (filename.FindC(KColon) != KErrNotFound)
{
CSelection* selection = CSelection::NewLC(aType, filename);
iPublicSelections.AppendL(selection);
CleanupStack::Pop(selection);
__LOG3("CDataOwner::HandlePathL(0x%08x) - Added selection: %S [type: %d]", iSecureId.iId, &filename, aType);
}
else
{
__LOG3("CDataOwner::HandlePathL(0x%08x) - Not an Absolute Path: %S [type: %d]", iSecureId.iId, &filename, aType);
return;
}
break;
}
} // switch
} // if
else
{
__LOG1("CDataOwner::HandlePathL(0x%08x) - Path attribute error", iSecureId.iId);
} // else
}
CSnapshotHolder* CSnapshotHolder::NewL()
/** Symbain OS constructor
@return a CSnapshotHolder object
*/
{
CSnapshotHolder* self = NewLC();
CleanupStack::Pop(self);
return self;
}
CSnapshotHolder* CSnapshotHolder::NewLC()
/** Symbain OS constructor
@return a CSnapshotHolder object
*/
{
CSnapshotHolder* self = new(ELeave) CSnapshotHolder();
CleanupStack::PushL(self);
return self;
}
CSnapshotHolder::CSnapshotHolder()
/** Default C++ Constructor
*/
{
}
CSnapshotHolder::~CSnapshotHolder()
/** Default C++ Constructor
*/
{
iSnapshots.ResetAndDestroy();
}
} // namespace conn