diff -r 453dfc402455 -r 0aa8cc770c8a connectivitymodules/SeCon/services/pcd/src/sconsbeclient.cpp --- a/connectivitymodules/SeCon/services/pcd/src/sconsbeclient.cpp Thu Aug 19 10:44:03 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1668 +0,0 @@ -/* -* 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 -#include - -#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; iSetBURModeL( 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 dataOwners; - RArray 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 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 -// ----------------------------------------------------------------------------- -// -void CSConSBEClient::AppendFilesToFilelistL( const RFileArray& aFiles, RPointerArray& 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