--- 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 <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