--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivitymodules/SeCon/services/pcd/src/sconsbeclient.cpp Wed Sep 01 12:20:56 2010 +0100
@@ -0,0 +1,1668 @@
+/*
+* Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: CSConSBEClient implementation
+*
+*/
+
+
+// INCLUDE FILES
+
+#include <pathinfo.h>
+#include <mmf/common/mmfcontrollerpluginresolver.h>
+
+#include "sconsbeclient.h"
+#include "debug.h"
+
+const TInt KDataBufExpandSize( 1024 );
+const TInt KMaxObjectSize( 1048576 - 1024 ); // Max chunk size is 1MB, but give some space for ConML wbxml
+_LIT( KSConNoDrive, "\x0" );
+_LIT( KSConDriveExists, "\x1" );
+// ============================= MEMBER FUNCTIONS ==============================
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::NewL( cosnt TInt aMaxObjectSize )
+// Two-phase constructor
+// -----------------------------------------------------------------------------
+//
+CSConSBEClient* CSConSBEClient::NewL( const TInt aMaxObjectSize, RFs& aFs )
+ {
+ TRACE_FUNC;
+ CSConSBEClient* self = new (ELeave) CSConSBEClient( aMaxObjectSize, aFs );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::CSConSBEClient( const TInt aMaxObjectSize )
+// Constructor
+// -----------------------------------------------------------------------------
+//
+CSConSBEClient::CSConSBEClient( const TInt /*aMaxObjectSize*/, RFs& aFs ) :
+ CActive( EPriorityStandard ), iBURModeNormal( ETrue ), iFs( aFs )
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::~CSConSBEClient()
+// Initializes member data
+// -----------------------------------------------------------------------------
+//
+CSConSBEClient::~CSConSBEClient()
+ {
+ TRACE_FUNC_ENTRY;
+ TInt err( KErrNone );
+
+ if( !iBURModeNormal && iSBEClient )
+ {
+ TDriveList driveList;
+
+ for( TInt i = 0; i<KMaxDrives; i++ )
+ {
+ if( i == EDriveC || i == EDriveE )
+ {
+ driveList.Append( KSConDriveExists );
+ }
+ else
+ {
+ driveList.Append( KSConNoDrive );
+ }
+ }
+
+ TRAP( err, iSBEClient->SetBURModeL( driveList, EBURNormal, ENoBackup ) );
+ }
+
+ if( iSBEClient )
+ {
+ delete iSBEClient;
+ iSBEClient = NULL;
+ }
+
+ delete iDataBuffer;
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::SetBURMode( TRequestStatus& aStatus, CSConTask*& aTask )
+// Set backup/restore mode
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::SetBURMode( TRequestStatus& aStatus, CSConTask*& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ iCallerStatus = &aStatus;
+ *iCallerStatus = KRequestPending;
+
+ iCurrentTask = aTask;
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ListPublicFiles( TRequestStatus& aStatus,
+// CSConTask*& aTask )
+// Lists public files from data owners
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::ListPublicFiles( TRequestStatus& aStatus,
+ CSConTask*& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ iCallerStatus = &aStatus;
+ *iCallerStatus = KRequestPending;
+
+ iCurrentTask = aTask;
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ListDataOwners( TRequestStatus& aStatus, CSConTask*& aTask )
+// Lists participant data owners
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::ListDataOwners( TRequestStatus& aStatus, CSConTask*& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ iCallerStatus = &aStatus;
+ *iCallerStatus = KRequestPending;
+
+ iCurrentTask = aTask;
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::GetDataSize( TRequestStatus& aStatus, CSConTask*& aTask )
+// Lists data sizes from data owners
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::GetDataSize( TRequestStatus& aStatus, CSConTask*& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ iCallerStatus = &aStatus;
+ *iCallerStatus = KRequestPending;
+
+ iCurrentTask = aTask;
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::RequestData( TRequestStatus& aStatus, CSConTask*& aTask )
+// Request a data from a data owner
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::RequestData( TRequestStatus& aStatus, CSConTask*& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ iCallerStatus = &aStatus;
+ *iCallerStatus = KRequestPending;
+
+ iCurrentTask = aTask;
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::GetDataOwnerStatus( TRequestStatus& aStatus,
+// CSConTask*& aTask )
+// Lists the status of data owners
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::GetDataOwnerStatus( TRequestStatus& aStatus,
+ CSConTask*& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ iCallerStatus = &aStatus;
+ *iCallerStatus = KRequestPending;
+
+ iCurrentTask = aTask;
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::SupplyData( TRequestStatus& aStatus, CSConTask*& aTask )
+// Supplies a data to a data owner
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::SupplyData( TRequestStatus& aStatus, CSConTask*& aTask )
+ {
+ TRACE_FUNC_ENTRY;
+ iCallerStatus = &aStatus;
+ *iCallerStatus = KRequestPending;
+
+ iCurrentTask = aTask;
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::DoCancel()
+// Implementation of CActive::DoCancel()
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::DoCancel()
+ {
+ TRACE_FUNC;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::RunL()
+// Implementation of CActive::RunL()
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::RunL()
+ {
+ TRACE_FUNC_ENTRY;
+ TInt err( KErrNone );
+ TInt ret( KErrNone );
+
+ //Initialize a connection to the backup server
+ if( !iSBEClient )
+ {
+ iSBEClient = CSBEClient::NewL();
+ }
+
+ switch( iCurrentTask->GetServiceId() )
+ {
+ case ESetBURMode :
+ LOGGER_WRITE( "CSConSBEClient::RunL() : ESetBURMode" );
+ TRAP( err, ProcessSetBURModeL() );
+ LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessSetBURModeL() : returned %d", err );
+ break;
+ case EListPublicFiles :
+ LOGGER_WRITE( "CSConSBEClient::RunL() : EListPublicFiles" );
+ TRAP( err, ProcessListPublicFilesL() );
+ LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListPublicFilesL() : returned %d", err );
+ break;
+ case EListDataOwners :
+ LOGGER_WRITE( "CSConSBEClient::RunL() : EListDataOwners" );
+ TRAP( err, ProcessListDataOwnersL() );
+ LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListDataOwnersL() : returned %d", err );
+ break;
+ case EGetDataSize :
+ LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataSize" );
+ TRAP( err, ProcessGetDataSizeL() );
+ LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataSizeL() : returned %d", err );
+ break;
+ case ERequestData :
+ LOGGER_WRITE( "CSConSBEClient::RunL() : ERequestData" );
+ TRAP( err, ret = ProcessRequestDataL() );
+ LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessRequestDataL() : returned %d", err );
+ break;
+ case EGetDataOwnerStatus :
+ LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataOwnerStatus" );
+ TRAP( err, ProcessGetDataOwnerStatusL() );
+ LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataOwnerStatusL() : returned %d", err );
+ break;
+ case ESupplyData :
+ LOGGER_WRITE( "CSConSBEClient::RunL() : ESupplyData" );
+ TRAP( err, ret = ProcessSupplyDataL() );
+ LOGGER_WRITE_1( "CSConSBEClient::RunL() : SupplyDataL() : returned %d", err );
+ break;
+ default :
+ err = KErrNotSupported;
+ LOGGER_WRITE( "CSConSBEClient::RunL() : ERROR! Unknown!" );
+ break;
+ }
+
+ if ( err )
+ {
+ HandleSBEErrorL( err );
+ }
+ else
+ {
+ err = ret;
+ }
+ User::RequestComplete( iCallerStatus, err );
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ProcessSetBURModeL()
+// Executes SetBURMode task
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::ProcessSetBURModeL()
+ {
+ TRACE_FUNC_ENTRY;
+
+ iAllSnapshotsSuppliedCalled = EFalse;
+ iLastChunk = EFalse;
+
+ TDriveList driveList = iCurrentTask->iBURModeParams->iDriveList;
+
+ TBURPartType partialType = EBURUnset;
+ iRestoreMode = EFalse;
+
+ switch( iCurrentTask->iBURModeParams->iPartialType )
+ {
+ case ESConBurNormal :
+ partialType = EBURNormal;
+ break;
+ case ESConBurBackupFull :
+ partialType = EBURBackupFull;
+ break;
+ case ESConBurBackupPartial :
+ partialType = EBURBackupPartial;
+ break;
+ case ESConBurRestoreFull :
+ partialType = EBURRestoreFull;
+ iRestoreMode = ETrue;
+ break;
+ case ESConBurRestorePartial :
+ partialType = EBURRestorePartial;
+ iRestoreMode = ETrue;
+ break;
+ default :
+ partialType = EBURUnset;
+ break;
+ }
+
+ if ( partialType == EBURBackupFull || partialType == ESConBurBackupPartial )
+ {
+ // initialize buffer
+ if ( !iDataBuffer )
+ iDataBuffer = CBufFlat::NewL( KDataBufExpandSize );
+ else
+ iDataBuffer->Reset();
+ iDataBufferSize=0;
+ }
+ else
+ {
+ delete iDataBuffer;
+ iDataBuffer = 0;
+ }
+
+ TBackupIncType incType = ENoBackup;
+
+ switch( iCurrentTask->iBURModeParams->iIncType )
+ {
+ case ESConNoBackup :
+ incType = ENoBackup;
+ break;
+ case ESConBackupBase :
+ incType = EBackupBase;
+ break;
+ case ESConBackupIncrement :
+ incType = EBackupIncrement;
+ break;
+ default :
+ incType = ENoBackup;
+ break;
+ }
+
+ iSBEClient->SetBURModeL( driveList, partialType, incType );
+
+ if( partialType != EBURNormal )
+ {
+ iBURModeNormal = EFalse;
+ }
+ else
+ {
+ iBURModeNormal = ETrue;
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ProcessListPublicFilesL()
+// Executes ListPublicFiles task
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::ProcessListPublicFilesL()
+ {
+ TRACE_FUNC_ENTRY;
+ //Get the secure id
+ TSecureId sid = iCurrentTask->iPubFilesParams->iDataOwners[0]->iUid;
+ TSecureId packageSid;
+ LOGGER_WRITE_1("DO: 0x%08x", sid.iId);
+ TPtrC packageName(KNullDesC);
+ const TUint KSConUidLength = 8; // 8 digits (hex)
+ const TUint KSConUidPrefixLength = 3; // prefix is '#0x'
+
+ TInt packageNameLength = iCurrentTask->iPubFilesParams->iDataOwners[0]->iPackageName.Length();
+
+ if ( packageNameLength > KSConUidLength )
+ {
+ // remove uid from package name
+ packageName.Set(
+ iCurrentTask->iPubFilesParams->iDataOwners[0]->
+ iPackageName.Left( packageNameLength - (KSConUidLength + KSConUidPrefixLength) ) );
+ LOGGER_WRITE_1("PackageName: %S", &packageName );
+
+ TPtrC sidPtr( iCurrentTask->iPubFilesParams->iDataOwners[0]->
+ iPackageName.Right( KSConUidLength ) );
+ TLex lex(sidPtr);
+ TInt err = lex.Val( packageSid.iId, EHex );
+ if ( err )
+ {
+ LOGGER_WRITE_1("lex.Val error: %d", err);
+ packageName.Set( KNullDesC );
+ packageSid.iId = 0;
+ }
+ LOGGER_WRITE_1("packageSid: 0x%08x", packageSid.iId );
+ }
+
+ //Get the drive list
+ TDriveList driveList =
+ iCurrentTask->iPubFilesParams->iDataOwners[0]->iDriveList;
+
+ RFileArray files;
+ CleanupClosePushL( files );
+ //Go through all the drives in the list
+ for( TInt i = 0; i < KMaxDrives; i++ )
+ {
+ if( driveList[i] )
+ {
+ //Get files from the drive
+ TDriveNumber driveNumber = GetDriveNumber( i );
+ LOGGER_WRITE_1("driveNumber: %d", driveNumber);
+
+ LOGGER_WRITE("List public files using CSBSecureId");
+ CSBSecureId* secureId = CSBSecureId::NewL( sid );
+ CleanupStack::PushL( secureId );
+
+ TRAPD( err, iSBEClient->PublicFileListL( driveNumber, *secureId, files ) );
+
+ if( err != KErrNone && err != KErrNotFound )
+ {
+ LOGGER_WRITE_1("iSBEClient->PublicFileListL leaved: %d", err);
+ User::LeaveIfError( err );
+ }
+
+ CleanupStack::PopAndDestroy( secureId );
+ LOGGER_WRITE_1("public files: %d", files.Count());
+ AppendFilesToFilelistL( files, iCurrentTask->iPubFilesParams->iFiles) ;
+
+ if ( packageName.Length() > 0 )
+ {
+ LOGGER_WRITE("Append files registered to packages. Using CSBPackageId");
+
+ CSBPackageId* packageId = CSBPackageId::NewL(
+ iCurrentTask->iPubFilesParams->iDataOwners[0]->iUid,
+ packageSid,
+ packageName );
+ CleanupStack::PushL( packageId );
+
+ TRAPD( err, iSBEClient->PublicFileListL( driveNumber, *packageId, files ) );
+ if( err != KErrNone && err != KErrNotFound )
+ {
+ LOGGER_WRITE_1("iSBEClient->PublicFileListL leaved: %d", err);
+ User::LeaveIfError( err );
+ }
+ CleanupStack::PopAndDestroy( packageId );
+
+ LOGGER_WRITE_1("public files: %d", files.Count());
+ AppendFilesToFilelistL( files, iCurrentTask->iPubFilesParams->iFiles) ;
+ }
+
+ files.Reset();
+ }
+ }
+ CleanupStack::PopAndDestroy( &files );
+ TRACE_FUNC_EXIT;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ProcessListDataOwnersL()
+// Executes ListDataOwners task
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::ProcessListDataOwnersL()
+ {
+ TRACE_FUNC_ENTRY;
+ TBool includeToList( ETrue );
+ RPointerArray<CDataOwnerInfo> dataOwners;
+ RArray<TUid> packageArray;
+ CleanupResetAndDestroyPushL( dataOwners );
+ CleanupClosePushL( packageArray );
+
+ iSBEClient->ListOfDataOwnersL( dataOwners );
+ LOGGER_WRITE_1( "dataOwners count: %d", dataOwners.Count() );
+
+
+ for( TInt i = 0; i < dataOwners.Count(); i++ )
+ {
+ LOGGER_WRITE_2("handling do: %d, count: %d", i, dataOwners.Count());
+ CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();
+ CleanupStack::PushL( dataOwner );
+ // default values
+ TSecureId sid( 0 );
+ includeToList = ETrue;
+
+ TCommonBURSettings commonOptions = dataOwners[i]->CommonSettings();
+ TPassiveBURSettings passiveOptions = dataOwners[i]->PassiveSettings();
+ TActiveBURSettings activeOptions = dataOwners[i]->ActiveSettings();
+
+ //active, passive or hybrid? (common)
+ if( commonOptions & EActiveBUR && commonOptions & EPassiveBUR )
+ {
+ dataOwner->iType = EHybridDataOwner;
+ }
+ else if( commonOptions & EActiveBUR )
+ {
+ dataOwner->iType = EActiveDataOwner;
+ }
+ else if( commonOptions & EPassiveBUR )
+ {
+ dataOwner->iType = EPassiveDataOwner;
+ }
+
+ //requires reboot? (common)
+ if( commonOptions & ERequiresReboot )
+ {
+ dataOwner->iReqReboot = ETrue;
+ }
+ else
+ {
+ dataOwner->iReqReboot = EFalse;
+ }
+
+ //has system files? (common)
+ if( commonOptions & EHasSystemFiles )
+ {
+ dataOwner->iHasFiles = ESystemFiles;
+ }
+
+ //supports selective? (common)
+ if( commonOptions & ESupportsSelective )
+ {
+ dataOwner->iSupportsSel = ETrue;
+ }
+ else
+ {
+ dataOwner->iSupportsSel = EFalse;
+ }
+
+ //has public files? (passive)
+ if( passiveOptions & EHasPublicFiles )
+ {
+ if( dataOwner->iHasFiles == ESystemFiles )
+ {
+ dataOwner->iHasFiles = EPublicSystemFiles;
+ }
+ else
+ {
+ dataOwner->iHasFiles = EPublicFiles;
+ }
+ }
+
+ //supports incremental? (active and passive)
+ if( activeOptions & EActiveSupportsInc ||
+ passiveOptions & EPassiveSupportsInc )
+ {
+ dataOwner->iSupportsInc = ETrue;
+ }
+ else
+ {
+ dataOwner->iSupportsInc = EFalse;
+ }
+
+ //delay to prepare data? (active)
+ if( activeOptions & EDelayToPrepareData )
+ {
+ dataOwner->iDelayToPrep = ETrue;
+ }
+ else
+ {
+ dataOwner->iDelayToPrep = EFalse;
+ }
+
+ //fill drivelist
+ dataOwner->iDriveList = dataOwners[i]->DriveList();
+ //filter the drive list
+ FilterDriveList( dataOwner->iDriveList );
+
+ CSBGenericDataType* genericData = &( dataOwners[i]->Identifier() );
+ TSBDerivedType derived = genericData->DerivedTypeL();
+
+ if( derived == ESIDDerivedType )
+ {
+ //Uif of the data owner
+ CSBSecureId* secureId = CSBSecureId::NewL( genericData );
+ CleanupStack::PushL( secureId );
+ sid = secureId->SecureIdL();
+
+ dataOwner->iUid.iUid = (TInt32)sid.iId;
+ LOGGER_WRITE_1("ESIDDerivedType, sid: 0x%08x", dataOwner->iUid.iUid );
+
+ CleanupStack::PopAndDestroy( secureId );
+ }
+ else if( derived == EPackageDerivedType )
+ {
+ //Package name and uid of the data owner
+ CSBPackageId* packageId = CSBPackageId::NewL( genericData );
+ CleanupStack::PushL( packageId );
+
+ dataOwner->iPackageName = packageId->PackageNameL();
+ dataOwner->iUid.iUid = packageId->PackageIdL().iUid;
+ LOGGER_WRITE_1("EPackageDerivedType, uid: 0x%08x", dataOwner->iUid.iUid );
+ sid = packageId->SecureIdL();
+ LOGGER_WRITE_1("sid: 0x%08x", sid.iId );
+
+ // owerload the package name, also add sid information.
+ _LIT(KSidFormat, "#0x%08x");
+ const TInt KSidFormatLength = 11;
+ TBuf<KSidFormatLength> sidFormat;
+ sidFormat.Format( KSidFormat, sid.iId );
+ if ( dataOwner->iPackageName.Length() + sidFormat.Length()
+ <= dataOwner->iPackageName.MaxLength() )
+ {
+ dataOwner->iPackageName.Append( sidFormat );
+ }
+ else
+ {
+ LOGGER_WRITE("WARNING: Package name too long, sid not included.");
+ }
+
+ LOGGER_WRITE_1("Package name: %S", &dataOwner->iPackageName );
+ if( sid )
+ {
+ //Find if the package is already included to dataowner list
+ if( packageArray.Find( packageId->PackageIdL(),
+ CSConSBEClient::Match ) != KErrNotFound )
+ {
+ LOGGER_WRITE("dataowner was already included to list");
+ //Don't include dataowner to list again
+ includeToList = EFalse;
+ }
+ else
+ {
+ //Store package's id for filtering
+ LOGGER_WRITE_1( "Storing package id for filtering, uid: 0x%08x", dataOwner->iUid.iUid );
+ packageArray.Append( dataOwner->iUid );
+ }
+ }
+
+ CleanupStack::PopAndDestroy( packageId );
+ }
+ else if( derived == EJavaDerivedType )
+ {
+ //Hash
+ CSBJavaId* javaId = CSBJavaId::NewL( genericData );
+ CleanupStack::PushL( javaId );
+
+ //Initialize with hash data length and copy hash
+ dataOwner->iJavaHash = HBufC::NewL( javaId->SuiteHashL().Length() );
+ dataOwner->iJavaHash->Des().Copy( javaId->SuiteHashL() );
+
+ //For ConML: set as passive package
+ dataOwner->iType = EPassiveDataOwner;
+ dataOwner->iPackageName.Copy( javaId->SuiteNameL() );
+
+#ifdef _DEBUG
+ LOGGER_WRITE("EJavaDerivedType" );
+ LOGGER_WRITE_1("Package name: %S", &dataOwner->iPackageName );
+ TPtrC hash( dataOwner->iJavaHash->Des() );
+ LOGGER_WRITE_1("JavaHash: %S", &hash );
+#endif
+
+ CleanupStack::PopAndDestroy( javaId );
+ }
+ else
+ {
+ LOGGER_WRITE("Unknown type, ignored from list" );
+ //Unknown type => ignore from list
+ includeToList = EFalse;
+ }
+
+ if( includeToList )
+ {
+ LOGGER_WRITE_1( "Appending to list, uid: 0x%08x", dataOwner->iUid.iUid );
+ iCurrentTask->iListDataOwnersParams->iDataOwners.AppendL( dataOwner );
+ CleanupStack::Pop( dataOwner );
+ }
+
+ if( sid )
+ {
+ LOGGER_WRITE_1( "Appending package sid to list, sid: 0x%08x", sid.iId );
+ CSConDataOwner* packageDataOwner = dataOwner->CopyL();
+ CleanupStack::PushL( packageDataOwner );
+ //Clear package name
+ packageDataOwner->iPackageName = KNullDesC();
+ //Add sid
+ packageDataOwner->iUid.iUid = sid.iId;
+ iCurrentTask->iListDataOwnersParams->iDataOwners.AppendL( packageDataOwner );
+ CleanupStack::Pop( packageDataOwner );
+ }
+
+ if( !includeToList )
+ {
+ //Not included to list => delete memory allocation
+ CleanupStack::PopAndDestroy( dataOwner );
+ }
+ }
+
+ packageArray.Reset();
+ CleanupStack::PopAndDestroy( &packageArray );
+ CleanupStack::PopAndDestroy( &dataOwners );
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ProcessGetDataSizeL()
+// Executes GetDataSize task
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::ProcessGetDataSizeL()
+ {
+ TRACE_FUNC_ENTRY;
+
+ if ( !iAllSnapshotsSuppliedCalled )
+ {
+ TInt err(KErrNone);
+ // we have to call AllSnapshotsSupplied() to inform active
+ // data owners to start prepare their base data.
+ TRAP( err, iSBEClient->AllSnapshotsSuppliedL() );
+ LOGGER_WRITE_1( "AllSnapshotsSuppliedL() leaved: %d", err );
+ iAllSnapshotsSuppliedCalled = ETrue;
+ }
+
+
+ TBool packageData( EFalse );
+
+ //Calculate data size for every data owner received from the task
+ for( TInt i = 0; i < iCurrentTask->iGetDataSizeParams->iDataOwners.Count();
+ i++ )
+ {
+ packageData = EFalse;
+ CSConDataOwner* dataOwner =
+ iCurrentTask->iGetDataSizeParams->iDataOwners[i];
+
+ TTransferDataType tdt( ERegistrationData );
+ TPackageDataType pdt( ESystemData );
+
+ LOGGER_WRITE_2( "ProcessGetDataSizeL DO %d of %d", i, iCurrentTask->iGetDataSizeParams->iDataOwners.Count() );
+ LOGGER_WRITE_1( "ProcessGetDataSizeL SID 0x%08x", dataOwner->iUid );
+ switch( dataOwner->iTransDataType )
+ {
+ case ESConRegistrationData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : ERegistrationData" );
+ tdt = ERegistrationData;
+ break;
+ case ESConPassiveSnapshotData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EPassiveSnapshotData" );
+ tdt = EPassiveSnapshotData;
+ break;
+ case ESConPassiveBaseData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EPassiveBaseData" );
+ tdt = EPassiveBaseData;
+ break;
+ case ESConPassiveIncrementalData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EPassiveIncrementalData" );
+ tdt = EPassiveIncrementalData;
+ break;
+ case ESConActiveSnapshotData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EActiveSnapshotData" );
+ tdt = EActiveSnapshotData;
+ break;
+ case ESConActiveBaseData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EActiveBaseData" );
+ tdt = EActiveBaseData;
+ break;
+ case ESConActiveIncrementalData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EActiveIncrementalData" );
+ tdt = EActiveIncrementalData;
+ break;
+ case ESConSystemData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : ESystemData" );
+ pdt = ESystemData;
+ packageData = ETrue;
+ break;
+ case ESConSystemSnapshotData :
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : ESystemSnapshotData" );
+ pdt = ESystemSnapshotData;
+ packageData = ETrue;
+ break;
+ default :
+ break;
+ }
+
+ if( packageData && !dataOwner->iJavaHash )
+ {
+ dataOwner->iSize = PackageDataSizeL( dataOwner->iUid, dataOwner->iDriveList, pdt );
+ }
+ else if( !dataOwner->iJavaHash )
+ {
+ dataOwner->iSize = SidDataSizeL( dataOwner->iUid, dataOwner->iDriveList, tdt );
+ }
+ else
+ {
+ dataOwner->iSize = JavaDataSizeL( dataOwner->iJavaHash->Des(),
+ dataOwner->iDriveList );
+ }
+ }
+
+ TRACE_FUNC_EXIT;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ProcessRequestDataL()
+// Executes RequestData task
+// -----------------------------------------------------------------------------
+//
+TInt CSConSBEClient::ProcessRequestDataL()
+ {
+ TRACE_FUNC_ENTRY;
+ TInt ret( KErrNone );
+
+ TBool packageData = EFalse;
+ TTransferDataType transferDataType( ERegistrationData );
+ TPackageDataType packageDataType( ESystemSnapshotData );
+ LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() iTransDataType: %d",
+ (TInt)iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType);
+
+ switch( iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType )
+ {
+ case ESConRegistrationData :
+ transferDataType = ERegistrationData;
+ break;
+ case ESConPassiveSnapshotData :
+ transferDataType = EPassiveSnapshotData;
+ break;
+ case ESConPassiveBaseData :
+ transferDataType = EPassiveBaseData;
+ break;
+ case ESConPassiveIncrementalData :
+ transferDataType = EPassiveIncrementalData;
+ break;
+ case ESConActiveSnapshotData :
+ transferDataType = EActiveSnapshotData;
+ break;
+ case ESConActiveBaseData :
+ transferDataType = EActiveBaseData;
+ break;
+ case ESConActiveIncrementalData :
+ transferDataType = EActiveIncrementalData;
+ break;
+ case ESConSystemData :
+ packageDataType = ESystemData;
+ packageData = ETrue;
+ break;
+ case ESConSystemSnapshotData:
+ packageDataType = ESystemSnapshotData;
+ packageData = ETrue;
+ break;
+ default :
+ break;
+ }
+
+
+ //Get the drive number
+ TDriveNumber driveNumber = EDriveC;
+ TDriveList driveList = iCurrentTask->iRequestDataParams->
+ iDataOwner->iDriveList;
+
+ for( TInt i = 0; i < KMaxDrives; i++ )
+ {
+ if( driveList[i] )
+ {
+ driveNumber = GetDriveNumber( i );
+ break;
+ }
+ }
+
+ //Get UID, SID or Java hash
+ TUid uid;
+ TSecureId sid;
+
+ uid.iUid = 0;
+ sid.iId = 0;
+
+ if( packageData && !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
+ {
+ uid = iCurrentTask->iRequestDataParams->iDataOwner->iUid;
+ LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() uid: 0x%08x", uid.iUid);
+ }
+ else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
+ {
+ sid = iCurrentTask->iRequestDataParams->iDataOwner->iUid;
+ LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() sid: 0x%08x", sid.iId);
+ }
+
+
+ LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \
+ Begin - Package data: %d", packageData );
+
+ LOGGER_WRITE_1("iLastChunk: %d", (TInt) iLastChunk );
+ LOGGER_WRITE_1("iDataBufferSize: %d", iDataBufferSize );
+
+ // if was't last chunk and there are free space left on our packet
+ if( !iLastChunk && iDataBufferSize < KMaxObjectSize )
+ {
+ //No data left, request more from the server
+ if( packageData && !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
+ {
+ CSBPackageTransferType* ptt = CSBPackageTransferType::NewL(
+ uid, driveNumber, packageDataType );
+ CleanupStack::PushL( ptt );
+
+ RequestDataL( *ptt );
+
+ CleanupStack::PopAndDestroy( ptt );
+ }
+ else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )
+ {
+ CSBSIDTransferType* stt = CSBSIDTransferType::NewL(
+ sid, driveNumber, transferDataType );
+ CleanupStack::PushL( stt );
+
+ RequestDataL( *stt );
+
+ CleanupStack::PopAndDestroy( stt );
+ }
+ else
+ {
+ TPtr javaHashPtr = iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash->Des();
+ CSBJavaTransferType* jtt( NULL );
+ //When ESystemData is requested, request EJavaMIDlet
+ if( packageDataType == ESystemData )
+ {
+ jtt = CSBJavaTransferType::NewL( javaHashPtr, driveNumber, EJavaMIDlet );
+ }
+ //When EPassiveBaseData is requested, request EJavaMIDletData
+ else if( transferDataType == EPassiveBaseData )
+ {
+ jtt = CSBJavaTransferType::NewL( javaHashPtr, driveNumber, EJavaMIDletData );
+ }
+
+ if( packageDataType == ESystemData || transferDataType == EPassiveBaseData )
+ {
+ CleanupStack::PushL( jtt );
+
+ RequestDataL( *jtt );
+
+ CleanupStack::PopAndDestroy( jtt );
+ }
+ else
+ {
+ //No data
+ iDataBuffer->Reset();
+ iDataBufferSize = 0;
+ iLastChunk = ETrue;
+ }
+ }
+ }
+
+ LOGGER_WRITE_1("readed iLastChunk: %d", (TInt) iLastChunk );
+ LOGGER_WRITE_1("readed iDataBufferSize: %d", iDataBufferSize );
+
+
+
+ if( iCurrentTask->iRequestDataParams->iBackupData )
+ {
+ delete iCurrentTask->iRequestDataParams->iBackupData;
+ iCurrentTask->iRequestDataParams->iBackupData = NULL;
+ }
+
+ TInt dataToRead = KMaxObjectSize;
+ if ( dataToRead > iDataBufferSize )
+ dataToRead = iDataBufferSize;
+
+ //Initialize the task data buffer
+ iCurrentTask->iRequestDataParams->iBackupData = HBufC8::NewL( dataToRead );
+ //Get descriptor task's buffer
+ TPtr8 backupDataPtr = iCurrentTask->iRequestDataParams->iBackupData->Des();
+
+
+ iDataBuffer->Read(0, backupDataPtr, dataToRead );
+ iDataBuffer->Delete(0, dataToRead);
+ iDataBufferSize -= dataToRead;
+
+ if ( !iLastChunk || iDataBufferSize>0 )
+ {
+ LOGGER_WRITE( "CSConSBEClient::ProcessRequestDataL() : There are more data available" );
+ iCurrentTask->iRequestDataParams->iMoreData = ETrue;
+ //Another task is needed to transfer the data to the client
+ ret = KErrCompletion;
+ }
+ else
+ {
+ LOGGER_WRITE( "CSConSBEClient::ProcessRequestDataL() : All data readed" );
+ iDataBuffer->Reset();
+ iDataBufferSize = 0;
+ // task will be completed, initialize iLastChunk value for next operation
+ iLastChunk = EFalse;
+ }
+
+
+ LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : returned %d", ret );
+ return ret;
+ }
+
+void CSConSBEClient::RequestDataL( CSBGenericTransferType& aGenericTransferType )
+ {
+ TRACE_FUNC_ENTRY;
+ if ( !iDataBuffer )
+ User::Leave( KErrArgument );
+
+ do
+ {
+ LOGGER_WRITE( "iSBEClient->RequestDataL() : start" );
+ TRequestStatus status;
+ iSBEClient->RequestDataL( aGenericTransferType, status );
+ User::WaitForRequest( status );
+ LOGGER_WRITE_1( "iSBEClient->RequestDataL() : status.Int() %d", status.Int() );
+ User::LeaveIfError( status.Int() );
+
+ //Get the data and store the handle
+ CSBGenericTransferType* gtt = NULL;
+ const TPtrC8& dataPtr = iSBEClient->TransferDataInfoL( gtt, iLastChunk );
+ LOGGER_WRITE_1("data size: %d", dataPtr.Length());
+ delete gtt;
+ iDataBuffer->ExpandL( iDataBufferSize, dataPtr.Length() );
+ iDataBuffer->Write(iDataBufferSize, dataPtr);
+ iDataBufferSize += dataPtr.Length();
+ LOGGER_WRITE_1("total buffer size: %d", iDataBufferSize);
+ }
+ // Continue if there are more data, and our packet is not full
+ while ( !iLastChunk && iDataBufferSize < KMaxObjectSize );
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ProcessGetDataOwnerStatusL()
+// Executes GetDataOwnerStatus task
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::ProcessGetDataOwnerStatusL()
+ {
+ TRACE_FUNC_ENTRY;
+
+ //If restore-mode, call AllSystemFilesRestored()
+ if( iRestoreMode )
+ {
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataOwnerStatusL() : iSBEClient->AllSystemFilesRestored() start" );
+ iSBEClient->AllSystemFilesRestored();
+ LOGGER_WRITE( "CSConSBEClient::ProcessGetDataOwnerStatusL() : iSBEClient->AllSystemFilesRestored() end" );
+ }
+
+ RSIDStatusArray sidStatus;
+ CleanupClosePushL(sidStatus);
+
+ for( TInt i = 0; i < iCurrentTask->iGetDataOwnerParams->iDataOwners.Count();
+ i++ )
+ {
+ CSConDataOwner* dataOwner =
+ iCurrentTask->iGetDataOwnerParams->iDataOwners[i];
+ TSecureId sid( dataOwner->iUid );
+ TDataOwnerStatus dataOwnerStatus = EUnset;
+ TInt dataOwnerError = 0;
+
+ TDataOwnerAndStatus dataOwnerAndStatus( sid, dataOwnerStatus,
+ dataOwnerError );
+
+ sidStatus.Append( dataOwnerAndStatus );
+ }
+
+ iSBEClient->SIDStatusL( sidStatus );
+
+ for( TInt j = 0; j < sidStatus.Count(); j++ )
+ {
+ switch( sidStatus[j].iStatus )
+ {
+ case EUnset :
+ iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->
+ iDataOwnStatus = ESConUnset;
+ break;
+ case EDataOwnerNotFound :
+ iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->
+ iDataOwnStatus = ESConNotFound;
+ break;
+ case EDataOwnerReady :
+ iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->
+ iDataOwnStatus = ESConReady;
+ break;
+ case EDataOwnerNotReady :
+ iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->
+ iDataOwnStatus = ESConNotReady;
+ break;
+ case EDataOwnerFailed :
+ iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->
+ iDataOwnStatus = ESConFailed;
+ break;
+ case EDataOwnerNotConnected :
+ iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->
+ iDataOwnStatus = ESConNotConnected;
+ break;
+ case EDataOwnerReadyNoImpl :
+ iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->
+ iDataOwnStatus = ESConNotImplemented;
+ break;
+ default :
+ break;
+ }
+ }
+ sidStatus.Reset();
+ CleanupStack::PopAndDestroy( &sidStatus );
+
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::ProcessSupplyDataL()
+// Executes SupplyData task
+// -----------------------------------------------------------------------------
+//
+TInt CSConSBEClient::ProcessSupplyDataL()
+ {
+ TRACE_FUNC_ENTRY;
+ TBool packageData = EFalse;
+ TBool lastChunk = ETrue;
+ TTransferDataType transferDataType( ERegistrationData );
+ TPackageDataType packageDataType( ESystemSnapshotData );
+ LOGGER_WRITE_1("CSConSBEClient::ProcessSupplyDataL() iTransDataType: %d",
+ (TInt)iCurrentTask->iSupplyDataParams->iDataOwner->iTransDataType);
+ switch( iCurrentTask->iSupplyDataParams->iDataOwner->iTransDataType )
+ {
+ case ESConRegistrationData :
+ transferDataType = ERegistrationData;
+ break;
+ case ESConPassiveSnapshotData :
+ transferDataType = EPassiveSnapshotData;
+ break;
+ case ESConPassiveBaseData :
+ transferDataType = EPassiveBaseData;
+ break;
+ case ESConPassiveIncrementalData :
+ transferDataType = EPassiveIncrementalData;
+ break;
+ case ESConActiveSnapshotData :
+ transferDataType = EActiveSnapshotData;
+ break;
+ case ESConActiveBaseData :
+ transferDataType = EActiveBaseData;
+ break;
+ case ESConActiveIncrementalData :
+ transferDataType = EActiveIncrementalData;
+ break;
+ case ESConSystemData :
+ packageDataType = ESystemData;
+ packageData = ETrue;
+ break;
+ case ESConSystemSnapshotData:
+ packageDataType = ESystemSnapshotData;
+ packageData = ETrue;
+ break;
+ default :
+ break;
+ }
+
+ //Get the drive number
+ TDriveNumber driveNumber = EDriveC;
+ TDriveList driveList = iCurrentTask->iSupplyDataParams->iDataOwner->
+ iDriveList;
+
+ for( TInt i = 0; i < KMaxDrives; i++ )
+ {
+ if( driveList[i] )
+ {
+ driveNumber = GetDriveNumber( i );
+ break;
+ }
+ }
+
+ //Get UID or SID
+ TUid uid;
+ TSecureId sid;
+
+ uid.iUid = 0;
+ sid.iId = 0;
+
+ if( packageData && !iCurrentTask->iSupplyDataParams->iDataOwner->iJavaHash )
+ {
+ uid = iCurrentTask->iSupplyDataParams->iDataOwner->iUid;
+ LOGGER_WRITE_1( "CSConSBEClient::ProcessSupplyDataL() uid: 0x%08x", uid.iUid );
+ }
+ else if( !iCurrentTask->iSupplyDataParams->iDataOwner->iJavaHash )
+ {
+ sid = iCurrentTask->iSupplyDataParams->iDataOwner->iUid;
+ LOGGER_WRITE_1( "CSConSBEClient::ProcessSupplyDataL() sid: 0x%08x", sid.iId );
+ }
+
+
+ if( packageData && !iCurrentTask->iSupplyDataParams->iDataOwner->iJavaHash )
+ {
+ CSBPackageTransferType* ptt = CSBPackageTransferType::NewL( uid, driveNumber,
+ packageDataType );
+ CleanupStack::PushL( ptt );
+
+ //Write restore data to chunk
+ LOGGER_WRITE( "iSBEClient->TransferDataAddressL().Copy() : start" );
+ LOGGER_WRITE_1( "CSConSBEClient::ProcessSupplyDataL() :\
+ Received data length: %d", iCurrentTask->iSupplyDataParams->iRestoreData->Length() );
+ iSBEClient->TransferDataAddressL().Copy( iCurrentTask->
+ iSupplyDataParams->iRestoreData->Des() );
+ LOGGER_WRITE( "iSBEClient->TransferDataAddressL().Copy()" );
+
+ delete iCurrentTask->iSupplyDataParams->iRestoreData;
+ iCurrentTask->iSupplyDataParams->iRestoreData = NULL;
+
+ //Supply data
+ lastChunk = !( iCurrentTask->iSupplyDataParams->iMoreData );
+ LOGGER_WRITE( "iSBEClient->SupplyDataL( ptt, lastChunk ) : start" );
+ TRequestStatus status;
+ iSBEClient->SupplyDataL( *ptt, lastChunk, status );
+ User::WaitForRequest( status );
+ LOGGER_WRITE( "iSBEClient->SupplyDataL( ptt, lastChunk ) : stop" );
+
+ User::LeaveIfError( status.Int() );
+
+ CleanupStack::PopAndDestroy( ptt );
+ }
+ else if( !iCurrentTask->iSupplyDataParams->iDataOwner->iJavaHash )
+ {
+ CSBSIDTransferType* stt = CSBSIDTransferType::NewL( sid, driveNumber, transferDataType );
+ CleanupStack::PushL( stt );
+
+ //Write restore data to chunk
+ LOGGER_WRITE( "iSBEClient->TransferDataAddressL().Copy() : start" );
+ LOGGER_WRITE_1( "CSConSBEClient::ProcessSupplyDataL() : Received data length: %d",
+ iCurrentTask->iSupplyDataParams->iRestoreData->Length() );
+ iSBEClient->TransferDataAddressL().Copy( iCurrentTask->
+ iSupplyDataParams->iRestoreData->Des() );
+ LOGGER_WRITE( "iSBEClient->TransferDataAddressL().Copy()" );
+
+ delete iCurrentTask->iSupplyDataParams->iRestoreData;
+ iCurrentTask->iSupplyDataParams->iRestoreData = NULL;
+
+ //Supply data
+ lastChunk = !( iCurrentTask->iSupplyDataParams->iMoreData );
+ LOGGER_WRITE( "iSBEClient->SupplyDataL( stt, lastChunk ) : start" );
+ TRequestStatus status;
+ iSBEClient->SupplyDataL( *stt, lastChunk, status );
+ User::WaitForRequest( status );
+ LOGGER_WRITE( "iSBEClient->SupplyDataL( stt, lastChunk ) : stop" );
+
+ User::LeaveIfError( status.Int() );
+
+ CleanupStack::PopAndDestroy( stt );
+ }
+ else
+ {
+ TPtr javaHashPtr = iCurrentTask->iSupplyDataParams->iDataOwner->iJavaHash->Des();
+ CSBJavaTransferType* jtt( NULL );
+ if( packageDataType == ESystemData )
+ {
+ LOGGER_WRITE( "iSBEClient->SupplyDataL java ESystemData" );
+ jtt = CSBJavaTransferType::NewL( javaHashPtr, driveNumber, EJavaMIDlet );
+ }
+ else if( transferDataType == EPassiveBaseData )
+ {
+ LOGGER_WRITE( "iSBEClient->SupplyDataL java EPassiveBaseData" );
+ jtt = CSBJavaTransferType::NewL( javaHashPtr, driveNumber, EJavaMIDletData );
+ }
+
+ if( packageDataType == ESystemData || transferDataType == EPassiveBaseData )
+ {
+ CleanupStack::PushL( jtt );
+ //Write restore data to chunk
+ LOGGER_WRITE( "iSBEClient->TransferDataAddressL().Copy() : start" );
+ LOGGER_WRITE_1( "CSConSBEClient::ProcessSupplyDataL() : Received data length: %d",
+ iCurrentTask->iSupplyDataParams->iRestoreData->Length() );
+ iSBEClient->TransferDataAddressL().Copy( iCurrentTask->
+ iSupplyDataParams->iRestoreData->Des() );
+ LOGGER_WRITE( "iSBEClient->TransferDataAddressL().Copy()" );
+
+ delete iCurrentTask->iSupplyDataParams->iRestoreData;
+ iCurrentTask->iSupplyDataParams->iRestoreData = NULL;
+
+ //Supply data
+ lastChunk = !( iCurrentTask->iSupplyDataParams->iMoreData );
+ LOGGER_WRITE( "iSBEClient->SupplyDataL( jtt, lastChunk ) : start" );
+ TRequestStatus status;
+ iSBEClient->SupplyDataL( *jtt, lastChunk, status );
+ User::WaitForRequest( status );
+ LOGGER_WRITE( "iSBEClient->SupplyDataL( jtt, lastChunk ) : stop" );
+
+ User::LeaveIfError( status.Int() );
+
+ CleanupStack::PopAndDestroy( jtt );
+ }
+ }
+
+ TInt ret( KErrNone );
+
+ if( !lastChunk )
+ {
+ ret = KErrCompletion;
+ }
+
+ LOGGER_WRITE_1( "CSConSBEClient::ProcessSupplyDataL() : returned %d", ret );
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::GetDriveNumber( const TInt& aDrive ) const
+// Maps TInt drive number to TDriveNumber
+// -----------------------------------------------------------------------------
+//
+TDriveNumber CSConSBEClient::GetDriveNumber( const TInt& aDrive ) const
+ {
+ TDriveNumber driveNumber;
+ switch( aDrive )
+ {
+ case 0 :
+ driveNumber = EDriveA;
+ break;
+ case 1 :
+ driveNumber = EDriveB;
+ break;
+ case 2 :
+ driveNumber = EDriveC;
+ break;
+ case 3 :
+ driveNumber = EDriveD;
+ break;
+ case 4 :
+ driveNumber = EDriveE;
+ break;
+ case 5 :
+ driveNumber = EDriveF;
+ break;
+ case 6 :
+ driveNumber = EDriveG;
+ break;
+ case 7 :
+ driveNumber = EDriveH;
+ break;
+ case 8 :
+ driveNumber = EDriveI;
+ break;
+ case 9 :
+ driveNumber = EDriveJ;
+ break;
+ case 10 :
+ driveNumber = EDriveK;
+ break;
+ case 11 :
+ driveNumber = EDriveL;
+ break;
+ case 12 :
+ driveNumber = EDriveM;
+ break;
+ case 13 :
+ driveNumber = EDriveN;
+ break;
+ case 14 :
+ driveNumber = EDriveO;
+ break;
+ case 15 :
+ driveNumber = EDriveP;
+ break;
+ case 16 :
+ driveNumber = EDriveQ;
+ break;
+ case 17 :
+ driveNumber = EDriveR;
+ break;
+ case 18 :
+ driveNumber = EDriveS;
+ break;
+ case 19 :
+ driveNumber = EDriveT;
+ break;
+ case 20 :
+ driveNumber = EDriveU;
+ break;
+ case 21 :
+ driveNumber = EDriveV;
+ break;
+ case 22 :
+ driveNumber = EDriveW;
+ break;
+ case 23 :
+ driveNumber = EDriveX;
+ break;
+ case 24 :
+ driveNumber = EDriveY;
+ break;
+ case 25 :
+ driveNumber = EDriveZ;
+ break;
+ default :
+ driveNumber = EDriveC;
+ break;
+ }
+
+ return driveNumber;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::FilterDriveList( TDriveList& aDriveList ) const
+// Filters the drive list
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::FilterDriveList( TDriveList& aDriveList ) const
+ {
+ TDriveInfo info;
+
+ for ( TInt i = 0; i < aDriveList.Length(); i++ )
+ {
+ if ( aDriveList[i] )
+ {
+ iFs.Drive( info, i );
+#ifdef __WINS__
+ if ( i == EDriveD )
+ {
+ LOGGER_WRITE( "EDriveD skipped on WINS build" );
+ aDriveList[i] = '\x0';
+ }
+#else
+ if ( info.iType == EMediaRam )
+ {
+ aDriveList[i] = '\x0';
+ }
+#endif
+ }
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::Match( const CSConTask& aFirst, const CSConTask& aSecond )
+// Matches the uids
+// -----------------------------------------------------------------------------
+//
+TInt CSConSBEClient::Match( const TUid& aFirst, const TUid& aSecond )
+ {
+ if( aFirst == aSecond )
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::HandleSBEErrorL( TInt& aErr )
+// Handle error received from Secure Backup Engine
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::HandleSBEErrorL( TInt& aErr )
+ {
+ TRACE_FUNC_ENTRY;
+ LOGGER_WRITE_1( " aErr: %d", aErr );
+ if( aErr == KErrServerTerminated )
+ {
+ LOGGER_WRITE( "Re-connecting to SBE..." );
+ //Session has been terminated, recreate it..
+ delete iSBEClient;
+ iSBEClient = NULL;
+ iSBEClient = CSBEClient::NewL();
+ }
+ else if ( aErr ) // error
+ {
+ if ( iDataBuffer )
+ {
+ iDataBuffer->Reset();
+ iDataBufferSize = 0;
+ }
+ iLastChunk = EFalse;
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::AppendFilesToFilelistL()
+// Appends files from RFileArray to RPointerArray<CSConFile>
+// -----------------------------------------------------------------------------
+//
+void CSConSBEClient::AppendFilesToFilelistL( const RFileArray& aFiles, RPointerArray<CSConFile>& aSconFiles )
+ {
+ TRACE_FUNC_ENTRY;
+ _LIT( KSConXmlDate, "%F%Y%M%DT%H%T%SZ" );
+ for( TInt j = 0; j < aFiles.Count(); j++ )
+ {
+ CSConFile* fileInfo = new (ELeave) CSConFile();
+ CleanupStack::PushL( fileInfo );
+ fileInfo->iPath = aFiles[j].iName;
+ LOGGER_WRITE_1("file: %S", &fileInfo->iPath );
+
+ fileInfo->iSize = aFiles[j].iSize;
+
+ switch( aFiles[j].iAtt )
+ {
+ case KEntryAttNormal :
+ fileInfo->iUserPerm = EPermNormal;
+ break;
+ case KEntryAttReadOnly :
+ fileInfo->iUserPerm = EPermReadOnly;
+ break;
+ default :
+ fileInfo->iUserPerm = EPermNormal;
+ break;
+ }
+
+ TTime time( aFiles[j].iModified );
+ HBufC* timeBuf = HBufC::NewLC( KMaxTimeFormatSpec );
+ TPtr timePtr = timeBuf->Des();
+ time.FormatL( timePtr, KSConXmlDate );
+
+ fileInfo->iModified.Copy( timePtr );
+
+ CleanupStack::PopAndDestroy( timeBuf );
+
+ aSconFiles.Append( fileInfo );
+ CleanupStack::Pop( fileInfo );
+ }
+ TRACE_FUNC_EXIT;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::PackageDataSizeL()
+// Gets Package dataowner size
+// -----------------------------------------------------------------------------
+//
+TUint CSConSBEClient::PackageDataSizeL( TUid aPackageId, const TDriveList& aDriveList,
+ TPackageDataType aPackageDataType ) const
+ {
+ TUint dataSize(0);
+ //Ask data size from every drive
+ for( TInt j = 0; j < KMaxDrives; j++ )
+ {
+ if( aDriveList[j] )
+ {
+ CSBPackageTransferType* ptt( NULL );
+ TDriveNumber driveNumber = GetDriveNumber( j );
+ LOGGER_WRITE_1( "Drive %d", driveNumber );
+ ptt = CSBPackageTransferType::NewL( aPackageId, driveNumber, aPackageDataType );
+ CleanupStack::PushL( ptt );
+ //Get the size and store it to a variable
+ TRAPD( err, dataSize += iSBEClient->ExpectedDataSizeL( *ptt ) );
+ CleanupStack::PopAndDestroy( ptt );
+ LOGGER_WRITE_1( "ExpectedDataSizeL returned for package %d", err );
+ if( err != KErrNone && err != KErrNotFound )
+ {
+ LOGGER_WRITE_1( "ExpectedDataSizeL LEAVE %d", err );
+ User::Leave( err );
+ }
+ }
+ }
+ return dataSize;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::SidDataSizeL()
+// Gets Sid (SecureId) dataowner size
+// -----------------------------------------------------------------------------
+//
+TUint CSConSBEClient::SidDataSizeL( TUid aSid, const TDriveList& aDriveList,
+ TTransferDataType aTransferDataType ) const
+ {
+ TUint dataSize(0);
+ //Ask data size from every drive
+ for( TInt j = 0; j < KMaxDrives; j++ )
+ {
+ if( aDriveList[j] )
+ {
+ CSBSIDTransferType* stt( NULL );
+ TDriveNumber driveNumber = GetDriveNumber( j );
+ LOGGER_WRITE_1( "Drive %d", driveNumber );
+ stt = CSBSIDTransferType::NewL( aSid, driveNumber, aTransferDataType );
+ CleanupStack::PushL( stt );
+ //Get the size and store it to a variable
+ TRAPD( err, dataSize += iSBEClient->ExpectedDataSizeL( *stt ) );
+ CleanupStack::PopAndDestroy( stt );
+ LOGGER_WRITE_1( "ExpectedDataSizeL returned for DO %d", err );
+ if( err != KErrNone && err != KErrNotFound )
+ {
+ LOGGER_WRITE_1( "ExpectedDataSizeL LEAVE %d", err );
+ User::Leave( err );
+ }
+ }
+ }
+ return dataSize;
+ }
+
+// -----------------------------------------------------------------------------
+// CSConSBEClient::JavaDataSizeL()
+// Gets Java dataowner size
+// -----------------------------------------------------------------------------
+//
+TUint CSConSBEClient::JavaDataSizeL( const TDesC& aJavaHash, const TDriveList& aDriveList ) const
+ {
+ TUint dataSize(0);
+ //Ask data size from every drive
+ for( TInt j = 0; j < KMaxDrives; j++ )
+ {
+ if( aDriveList[j] )
+ {
+ CSBJavaTransferType* jtt( NULL );
+
+ TDriveNumber driveNumber = GetDriveNumber( j );
+ LOGGER_WRITE_1( "Drive %d", driveNumber );
+ jtt = CSBJavaTransferType::NewL( aJavaHash,
+ driveNumber,
+ EJavaMIDlet );
+ CleanupStack::PushL( jtt );
+ //Get the size and store it to a variable
+ TRAPD( err, dataSize += iSBEClient->ExpectedDataSizeL( *jtt ) );
+ CleanupStack::PopAndDestroy( jtt );
+ LOGGER_WRITE_1( "ExpectedDataSizeL returned for Java(EJavaMIDlet) DO %d", err );
+ if( err != KErrNone && err != KErrNotFound )
+ {
+ LOGGER_WRITE_1( "ExpectedDataSizeL LEAVE %d", err );
+ User::Leave( err );
+ }
+
+ jtt = NULL;
+ jtt = CSBJavaTransferType::NewL( aJavaHash,
+ driveNumber,
+ EJavaMIDletData );
+ CleanupStack::PushL( jtt );
+ //Get the size and store it to a variable
+ TRAP( err, dataSize += iSBEClient->ExpectedDataSizeL( *jtt ) );
+ CleanupStack::PopAndDestroy( jtt );
+ LOGGER_WRITE_1( "ExpectedDataSizeL returned for Java(EJavaMIDletData) DO %d", err );
+ if( err != KErrNone && err != KErrNotFound )
+ {
+ LOGGER_WRITE_1( "ExpectedDataSizeL LEAVE %d", err );
+ User::Leave( err );
+ }
+ }
+ }
+
+ return dataSize;
+ }
+// End of file