1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  CSConSBEClient implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include <pathinfo.h>

    22 #include <mmf/common/mmfcontrollerpluginresolver.h>

    23 

    24 #include "sconsbeclient.h"

    25 #include "debug.h"

    26 

    27 

    28 _LIT( KSConNoDrive, "\x0" );

    29 _LIT( KSConDriveExists, "\x1" );

    30 // ============================= MEMBER FUNCTIONS ==============================

    31 

    32 // -----------------------------------------------------------------------------

    33 // CSConSBEClient::NewL( cosnt TInt aMaxObjectSize )

    34 // Two-phase constructor

    35 // -----------------------------------------------------------------------------

    36 //  

    37 CSConSBEClient* CSConSBEClient::NewL( const TInt aMaxObjectSize, RFs& aFs )

    38     {

    39     TRACE_FUNC;

    40     CSConSBEClient* self = new (ELeave) CSConSBEClient( aMaxObjectSize, aFs );

    41     return self;

    42     }

    43     

    44 // -----------------------------------------------------------------------------

    45 // CSConSBEClient::CSConSBEClient( const TInt aMaxObjectSize )

    46 // Constructor

    47 // -----------------------------------------------------------------------------

    48 //

    49 CSConSBEClient::CSConSBEClient( const TInt aMaxObjectSize, RFs& aFs ) : 

    50         CActive( EPriorityStandard ), iSBEClient(NULL), 

    51         iProcessComplete(EFalse), iProcessIndex( 0 ), iDataPos( 0 ),

    52         iDataLeft( EFalse ), iBURModeNormal( ETrue ),

    53         iRestoreMode( EFalse ), iFs( aFs )

    54     {

    55     iMaxObjectSize = aMaxObjectSize;

    56     }

    57 

    58 // -----------------------------------------------------------------------------

    59 // CSConSBEClient::~CSConSBEClient()

    60 // Initializes member data

    61 // -----------------------------------------------------------------------------

    62 //  

    63 CSConSBEClient::~CSConSBEClient()

    64     {

    65     TRACE_FUNC_ENTRY;

    66     TInt err( KErrNone );

    67     

    68     if( !iBURModeNormal && iSBEClient )

    69         {

    70         TDriveList driveList;

    71         

    72         for( TInt i = 0; i<KMaxDrives; i++ )

    73             {

    74             if( i == EDriveC || i == EDriveE )

    75                 {

    76                 driveList.Append( KSConDriveExists );

    77                 }

    78             else

    79                 {

    80                 driveList.Append( KSConNoDrive );

    81                 }

    82             }

    83         

    84         TRAP( err, iSBEClient->SetBURModeL( driveList, EBURNormal, ENoBackup ) );

    85         }

    86     

    87     if( iSBEClient )

    88         {

    89         delete iSBEClient;

    90         iSBEClient = NULL;

    91         }

    92     TRACE_FUNC_EXIT;

    93     }

    94 

    95 // -----------------------------------------------------------------------------

    96 // CSConSBEClient::SetBURMode( TRequestStatus& aStatus, CSConTask*& aTask )

    97 // Set backup/restore mode

    98 // -----------------------------------------------------------------------------

    99 //  

   100 void CSConSBEClient::SetBURMode( TRequestStatus& aStatus, CSConTask*& aTask )

   101     {

   102     TRACE_FUNC_ENTRY;

   103     iCallerStatus = &aStatus;

   104     *iCallerStatus = KRequestPending;

   105     

   106     iCurrentTask = aTask;

   107 

   108     TRequestStatus* status = &iStatus; 

   109     User::RequestComplete( status, KErrNone ); 

   110     SetActive();

   111     TRACE_FUNC_EXIT;

   112     }

   113 

   114 // -----------------------------------------------------------------------------

   115 // CSConSBEClient::ListPublicFiles( TRequestStatus& aStatus, 

   116 //                                  CSConTask*& aTask )

   117 // Lists public files from data owners

   118 // -----------------------------------------------------------------------------

   119 //  

   120 void CSConSBEClient::ListPublicFiles( TRequestStatus& aStatus, 

   121                                     CSConTask*& aTask )

   122     {

   123     TRACE_FUNC_ENTRY;

   124     iCallerStatus = &aStatus;

   125     *iCallerStatus = KRequestPending;

   126     

   127     iCurrentTask = aTask;

   128     

   129     TRequestStatus* status = &iStatus; 

   130     User::RequestComplete( status, KErrNone ); 

   131     SetActive();    

   132     TRACE_FUNC_EXIT;

   133     }

   134     

   135 // -----------------------------------------------------------------------------

   136 // CSConSBEClient::ListDataOwners( TRequestStatus& aStatus, CSConTask*& aTask )

   137 // Lists participant data owners

   138 // -----------------------------------------------------------------------------

   139 //  

   140 void CSConSBEClient::ListDataOwners( TRequestStatus& aStatus, CSConTask*& aTask )

   141     {

   142     TRACE_FUNC_ENTRY;

   143     iCallerStatus = &aStatus;

   144     *iCallerStatus = KRequestPending;

   145     

   146     iCurrentTask = aTask;

   147     

   148     TRequestStatus* status = &iStatus; 

   149     User::RequestComplete( status, KErrNone ); 

   150     SetActive();

   151     TRACE_FUNC_EXIT;

   152     }

   153     

   154 // -----------------------------------------------------------------------------

   155 // CSConSBEClient::GetDataSize( TRequestStatus& aStatus, CSConTask*& aTask )

   156 // Lists data sizes from data owners

   157 // -----------------------------------------------------------------------------

   158 //  

   159 void CSConSBEClient::GetDataSize( TRequestStatus& aStatus, CSConTask*& aTask )

   160     {

   161     TRACE_FUNC_ENTRY;

   162     iCallerStatus = &aStatus;

   163     *iCallerStatus = KRequestPending;

   164     

   165     iCurrentTask = aTask;

   166     

   167     TRequestStatus* status = &iStatus; 

   168     User::RequestComplete( status, KErrNone ); 

   169     SetActive();

   170     TRACE_FUNC_EXIT;

   171     }

   172 

   173 // -----------------------------------------------------------------------------

   174 // CSConSBEClient::RequestData( TRequestStatus& aStatus, CSConTask*& aTask )

   175 // Request a data from a data owner

   176 // -----------------------------------------------------------------------------

   177 //  

   178 void CSConSBEClient::RequestData( TRequestStatus& aStatus, CSConTask*& aTask )

   179     {

   180     TRACE_FUNC_ENTRY;

   181     iCallerStatus = &aStatus;

   182     *iCallerStatus = KRequestPending;

   183     

   184     iCurrentTask = aTask;

   185     

   186     TRequestStatus* status = &iStatus;

   187     User::RequestComplete( status, KErrNone );          

   188     SetActive();    

   189     TRACE_FUNC_EXIT;

   190     }

   191     

   192 // -----------------------------------------------------------------------------

   193 // CSConSBEClient::GetDataOwnerStatus( TRequestStatus& aStatus, 

   194 //                                      CSConTask*& aTask )

   195 // Lists the status of data owners

   196 // -----------------------------------------------------------------------------

   197 //  

   198 void CSConSBEClient::GetDataOwnerStatus( TRequestStatus& aStatus, 

   199                                         CSConTask*& aTask )

   200     {

   201     TRACE_FUNC_ENTRY;

   202     iCallerStatus = &aStatus;

   203     *iCallerStatus = KRequestPending;

   204     

   205     iCurrentTask = aTask;

   206     

   207     TRequestStatus* status = &iStatus; 

   208     User::RequestComplete( status, KErrNone ); 

   209     SetActive();

   210         

   211     TRACE_FUNC_EXIT;

   212     }

   213     

   214 // -----------------------------------------------------------------------------

   215 // CSConSBEClient::SupplyData( TRequestStatus& aStatus, CSConTask*& aTask )

   216 // Supplies a data to a data owner

   217 // -----------------------------------------------------------------------------

   218 //  

   219 void CSConSBEClient::SupplyData( TRequestStatus& aStatus, CSConTask*& aTask )

   220     {

   221     TRACE_FUNC_ENTRY;

   222     iCallerStatus = &aStatus;

   223     *iCallerStatus = KRequestPending;

   224     

   225     iCurrentTask = aTask;

   226     

   227     TRequestStatus* status = &iStatus; 

   228     User::RequestComplete( status, KErrNone ); 

   229     SetActive();    

   230     TRACE_FUNC_EXIT;

   231     }

   232     

   233 // -----------------------------------------------------------------------------

   234 // CSConSBEClient::DoCancel()

   235 // Implementation of CActive::DoCancel()

   236 // -----------------------------------------------------------------------------

   237 //          

   238 void CSConSBEClient::DoCancel()

   239     {

   240     TRACE_FUNC;

   241     }

   242 

   243 // -----------------------------------------------------------------------------

   244 // CSConSBEClient::RunL()

   245 // Implementation of CActive::RunL()

   246 // -----------------------------------------------------------------------------

   247 //              

   248 void CSConSBEClient::RunL()

   249     {

   250     TRACE_FUNC_ENTRY;

   251     TInt err( KErrNone );

   252     TInt ret( KErrNone );

   253     

   254     //Initialize a connection to the backup server

   255     if( !iSBEClient )

   256         {

   257         iSBEClient = CSBEClient::NewL();

   258         }   

   259     

   260     switch( iCurrentTask->GetServiceId() )

   261         {

   262         case ESetBURMode :

   263             LOGGER_WRITE( "CSConSBEClient::RunL() : ESetBURMode" );

   264             TRAP( err, ProcessSetBURModeL() );

   265             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessSetBURModeL() : returned %d", err );

   266             HandleSBEErrorL( err );

   267             User::RequestComplete( iCallerStatus, err );

   268             break;

   269         case EListPublicFiles :

   270             LOGGER_WRITE( "CSConSBEClient::RunL() : EListPublicFiles" );

   271             TRAP( err, ProcessListPublicFilesL() );

   272             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListPublicFilesL() : returned %d", err );

   273             HandleSBEErrorL( err );

   274             User::RequestComplete( iCallerStatus, err );

   275             break;

   276         case EListDataOwners :

   277             LOGGER_WRITE( "CSConSBEClient::RunL() : EListDataOwners" ); 

   278             TRAP( err, ProcessListDataOwnersL() );

   279             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListDataOwnersL() : returned %d", err );

   280             HandleSBEErrorL( err );

   281             User::RequestComplete( iCallerStatus, err );

   282             break;

   283         case EGetDataSize :

   284             LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataSize" );    

   285             TRAP( err, ProcessGetDataSizeL() );

   286             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataSizeL() : returned %d", err );

   287             HandleSBEErrorL( err );

   288             User::RequestComplete( iCallerStatus, err );

   289             break;

   290         case ERequestData :

   291             LOGGER_WRITE( "CSConSBEClient::RunL() : ERequestData" );

   292             TRAP( err, ret = ProcessRequestDataL() );

   293             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessRequestDataL() : returned %d", err );

   294             HandleSBEErrorL( err );

   295             

   296             if( err == KErrNone )

   297                 {

   298                 err = ret;

   299                 }

   300             

   301             User::RequestComplete( iCallerStatus, err );

   302             break;  

   303         case EGetDataOwnerStatus :

   304             LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataOwnerStatus" );

   305             TRAP( err, ProcessGetDataOwnerStatusL() );

   306             LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataOwnerStatusL() : returned %d", err );

   307             HandleSBEErrorL( err );

   308             User::RequestComplete( iCallerStatus, err );

   309             break;

   310         case ESupplyData :

   311             LOGGER_WRITE( "CSConSBEClient::RunL() : ESupplyData" ); 

   312             TRAP( err, ret = ProcessSupplyDataL() );

   313             LOGGER_WRITE_1( "CSConSBEClient::RunL() : SupplyDataL() : returned %d", err );

   314             HandleSBEErrorL( err );

   315             

   316             if( err == KErrNone )

   317                 {

   318                 err = ret;

   319                 }

   320             

   321             User::RequestComplete( iCallerStatus, err );

   322             break;

   323         default :

   324             LOGGER_WRITE( "CSConSBEClient::RunL() : ERROR! Unknown!" ); 

   325             break;

   326         }

   327             

   328     TRACE_FUNC_EXIT;

   329     }

   330     

   331 // -----------------------------------------------------------------------------

   332 // CSConSBEClient::ProcessSetBURModeL()

   333 // Executes SetBURMode task

   334 // -----------------------------------------------------------------------------

   335 //  

   336 void CSConSBEClient::ProcessSetBURModeL()

   337     {

   338     TRACE_FUNC_ENTRY;

   339     

   340     iAllSnapshotsSuppliedCalled = EFalse;

   341     

   342     TDriveList driveList = iCurrentTask->iBURModeParams->iDriveList;

   343     

   344     TBURPartType partialType = EBURUnset;

   345     iRestoreMode = EFalse;

   346     

   347     switch( iCurrentTask->iBURModeParams->iPartialType )

   348         {

   349         case ESConBurNormal :

   350             partialType = EBURNormal;

   351             break;

   352         case ESConBurBackupFull :

   353             partialType = EBURBackupFull;

   354             break;

   355         case ESConBurBackupPartial :

   356             partialType = EBURBackupPartial;

   357             break;

   358         case ESConBurRestoreFull :

   359             partialType = EBURRestoreFull;

   360             iRestoreMode = ETrue;

   361             break;

   362         case ESConBurRestorePartial :

   363             partialType = EBURRestorePartial;

   364             iRestoreMode = ETrue;

   365             break;

   366         default :

   367             partialType = EBURUnset;

   368             break;

   369         }

   370     

   371     TBackupIncType incType = ENoBackup;

   372     

   373     switch( iCurrentTask->iBURModeParams->iIncType )    

   374         {

   375         case ESConNoBackup :

   376             incType = ENoBackup;

   377             break;

   378         case ESConBackupBase :

   379             incType = EBackupBase;

   380             break;

   381         case ESConBackupIncrement :

   382             incType = EBackupIncrement;

   383             break;

   384         default :

   385             incType = ENoBackup;

   386             break;

   387         }

   388     

   389     iSBEClient->SetBURModeL( driveList, partialType, incType );

   390     

   391     if( partialType != EBURNormal )

   392         {

   393         iBURModeNormal = EFalse;

   394         }

   395     else

   396         {

   397         iBURModeNormal = ETrue;

   398         }

   399     TRACE_FUNC_EXIT;

   400     }

   401 

   402 // -----------------------------------------------------------------------------

   403 // CSConSBEClient::ProcessListPublicFilesL()

   404 // Executes ListPublicFiles task

   405 // -----------------------------------------------------------------------------

   406 //

   407 void CSConSBEClient::ProcessListPublicFilesL()

   408     {

   409     TRACE_FUNC_ENTRY;

   410     //Get the secure id

   411     TSecureId sid = iCurrentTask->iPubFilesParams->iDataOwners[0]->iUid;

   412     TSecureId packageSid;

   413     LOGGER_WRITE_1("DO: 0x%08x", sid.iId);

   414     TPtrC packageName(KNullDesC);

   415     const TUint KSConUidLength = 8; // 8 digits (hex)

   416     const TUint KSConUidPrefixLength = 3; // prefix is '#0x'

   417     

   418     TInt packageNameLength = iCurrentTask->iPubFilesParams->iDataOwners[0]->iPackageName.Length();

   419     

   420     if ( packageNameLength > KSConUidLength )

   421         {

   422         // remove uid from package name

   423         packageName.Set( 

   424                 iCurrentTask->iPubFilesParams->iDataOwners[0]->

   425                 iPackageName.Left( packageNameLength - (KSConUidLength + KSConUidPrefixLength) ) );

   426         LOGGER_WRITE_1("PackageName: %S", &packageName );

   427         

   428         TPtrC sidPtr( iCurrentTask->iPubFilesParams->iDataOwners[0]->

   429                 iPackageName.Right( KSConUidLength ) );

   430         TLex lex(sidPtr);

   431         TInt err = lex.Val( packageSid.iId, EHex );

   432         if ( err )

   433             {

   434             LOGGER_WRITE_1("lex.Val error: %d", err);

   435             packageName.Set( KNullDesC );

   436             packageSid.iId = 0;

   437             }

   438         LOGGER_WRITE_1("packageSid: 0x%08x", packageSid.iId );

   439         }

   440     

   441     //Get the drive list

   442     TDriveList driveList = 

   443     iCurrentTask->iPubFilesParams->iDataOwners[0]->iDriveList;

   444     

   445     RFileArray files;

   446     CleanupClosePushL( files );

   447     //Go through all the drives in the list

   448     for( TInt i = 0; i < KMaxDrives; i++ )

   449         {

   450         if( driveList[i] )

   451             {

   452             //Get files from the drive

   453             TDriveNumber driveNumber = GetDriveNumber( i );

   454             LOGGER_WRITE_1("driveNumber: %d", driveNumber);

   455             

   456             LOGGER_WRITE("List public files using CSBSecureId");

   457             CSBSecureId* secureId = CSBSecureId::NewL( sid );

   458             CleanupStack::PushL( secureId );

   459             

   460             TRAPD( err, iSBEClient->PublicFileListL( driveNumber, *secureId, files ) );

   461             

   462             if( err != KErrNone && err != KErrNotFound )

   463                 {

   464                 LOGGER_WRITE_1("iSBEClient->PublicFileListL leaved: %d", err);

   465                 User::LeaveIfError( err );

   466                 }

   467             

   468             CleanupStack::PopAndDestroy( secureId );

   469             LOGGER_WRITE_1("public files: %d", files.Count());

   470             AppendFilesToFilelistL( files, iCurrentTask->iPubFilesParams->iFiles) ;

   471             

   472             if ( packageName.Length() > 0 )

   473                 {

   474                 LOGGER_WRITE("Append files registered to packages. Using CSBPackageId");

   475                 

   476                 CSBPackageId* packageId = CSBPackageId::NewL(

   477                         iCurrentTask->iPubFilesParams->iDataOwners[0]->iUid,

   478                         packageSid,

   479                         packageName );

   480                 CleanupStack::PushL( packageId );

   481                 

   482                 TRAPD( err, iSBEClient->PublicFileListL( driveNumber, *packageId, files ) );

   483                 if( err != KErrNone && err != KErrNotFound )

   484                     {

   485                     LOGGER_WRITE_1("iSBEClient->PublicFileListL leaved: %d", err);

   486                     User::LeaveIfError( err );

   487                     }

   488                 CleanupStack::PopAndDestroy( packageId );

   489                 

   490                 LOGGER_WRITE_1("public files: %d", files.Count());

   491                 AppendFilesToFilelistL( files, iCurrentTask->iPubFilesParams->iFiles) ;

   492                 }

   493             

   494             files.Reset();

   495             }

   496         }

   497     CleanupStack::PopAndDestroy( &files );

   498     TRACE_FUNC_EXIT;

   499     }

   500 

   501     

   502 // -----------------------------------------------------------------------------

   503 // CSConSBEClient::ProcessListDataOwnersL()

   504 // Executes ListDataOwners task

   505 // -----------------------------------------------------------------------------

   506 //

   507 void CSConSBEClient::ProcessListDataOwnersL()

   508     {

   509     TRACE_FUNC_ENTRY;

   510     TBool includeToList( ETrue );

   511     RPointerArray<CDataOwnerInfo> dataOwners;

   512     RArray<TUid> packageArray;

   513     CleanupResetAndDestroyPushL( dataOwners );

   514     CleanupClosePushL( packageArray );

   515     

   516     iSBEClient->ListOfDataOwnersL( dataOwners );

   517     LOGGER_WRITE_1( "dataOwners count: %d", dataOwners.Count() );

   518     

   519     

   520     for( TInt i = 0; i < dataOwners.Count(); i++ )

   521         {

   522         LOGGER_WRITE_2("handling do: %d, count: %d", i, dataOwners.Count());

   523         CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();

   524         // default values

   525         TSecureId sid( 0 );

   526         includeToList = ETrue;

   527         

   528         TCommonBURSettings commonOptions = dataOwners[i]->CommonSettings();

   529         TPassiveBURSettings passiveOptions = dataOwners[i]->PassiveSettings();

   530         TActiveBURSettings activeOptions = dataOwners[i]->ActiveSettings();

   531         

   532         //active, passive or hybrid? (common)

   533         if( commonOptions & EActiveBUR && commonOptions & EPassiveBUR )

   534             {

   535             dataOwner->iType = EHybridDataOwner;

   536             }       

   537         else if( commonOptions & EActiveBUR )

   538             {

   539             dataOwner->iType = EActiveDataOwner;

   540             }

   541         else if( commonOptions & EPassiveBUR )

   542             {

   543             dataOwner->iType = EPassiveDataOwner;

   544             }

   545                 

   546         //requires reboot? (common)

   547         if( commonOptions & ERequiresReboot )

   548             {

   549             dataOwner->iReqReboot = ETrue;

   550             }

   551         else

   552             {

   553             dataOwner->iReqReboot = EFalse;

   554             }

   555             

   556         //has system files? (common)

   557         if( commonOptions & EHasSystemFiles )

   558             {

   559             dataOwner->iHasFiles = ESystemFiles;

   560             }

   561             

   562         //supports selective? (common)

   563         if( commonOptions & ESupportsSelective )

   564             {

   565             dataOwner->iSupportsSel = ETrue;

   566             }

   567         else

   568             {

   569             dataOwner->iSupportsSel = EFalse;

   570             }

   571             

   572         //has public files? (passive)

   573         if( passiveOptions & EHasPublicFiles )

   574             {

   575             if( dataOwner->iHasFiles == ESystemFiles )

   576                 {

   577                 dataOwner->iHasFiles = EPublicSystemFiles;

   578                 }

   579             else

   580                 {

   581                 dataOwner->iHasFiles = EPublicFiles;    

   582                 }

   583             }

   584             

   585         //supports incremental? (active and passive)

   586         if( activeOptions & EActiveSupportsInc || 

   587                 passiveOptions & EPassiveSupportsInc  )

   588             {

   589             dataOwner->iSupportsInc = ETrue;

   590             }

   591         else

   592             {

   593             dataOwner->iSupportsInc = EFalse;

   594             }

   595             

   596         //delay to prepare data? (active)

   597         if( activeOptions & EDelayToPrepareData )

   598             {

   599             dataOwner->iDelayToPrep = ETrue;

   600             }

   601         else

   602             {

   603             dataOwner->iDelayToPrep = EFalse;

   604             }

   605             

   606         //fill drivelist

   607         dataOwner->iDriveList = dataOwners[i]->DriveList();

   608         //filter the drive list

   609         FilterDriveList( dataOwner->iDriveList );

   610                         

   611         CSBGenericDataType* genericData = &( dataOwners[i]->Identifier() );

   612         TSBDerivedType derived = genericData->DerivedTypeL();

   613         

   614         if( derived == ESIDDerivedType )

   615             {

   616             //Uif of the data owner

   617             CSBSecureId* secureId = CSBSecureId::NewL( genericData );

   618             CleanupStack::PushL( secureId );

   619             sid = secureId->SecureIdL();

   620         

   621             dataOwner->iUid.iUid = (TInt32)sid.iId;

   622             LOGGER_WRITE_1("ESIDDerivedType, sid: 0x%08x", dataOwner->iUid.iUid );

   623         

   624             CleanupStack::PopAndDestroy( secureId );

   625             }

   626         else if( derived == EPackageDerivedType )

   627             {

   628             //Package name and uid of the data owner

   629             CSBPackageId* packageId = CSBPackageId::NewL( genericData );

   630             CleanupStack::PushL( packageId );

   631         

   632             dataOwner->iPackageName = packageId->PackageNameL();

   633             dataOwner->iUid.iUid = packageId->PackageIdL().iUid;

   634             LOGGER_WRITE_1("EPackageDerivedType, uid: 0x%08x", dataOwner->iUid.iUid );

   635             sid = packageId->SecureIdL();

   636             LOGGER_WRITE_1("sid: 0x%08x", sid.iId );

   637             

   638             // owerload the package name, also add sid information.

   639             _LIT(KSidFormat, "#0x%08x");

   640             const TInt KSidFormatLength = 11;

   641             TBuf<KSidFormatLength> sidFormat;

   642             sidFormat.Format( KSidFormat, sid.iId );

   643             if ( dataOwner->iPackageName.Length() + sidFormat.Length()

   644                 <= dataOwner->iPackageName.MaxLength() )

   645                 {

   646                 dataOwner->iPackageName.Append( sidFormat );

   647                 }

   648             else

   649                 {

   650                 LOGGER_WRITE("WARNING: Package name too long, sid not included.");

   651                 }

   652             

   653             LOGGER_WRITE_1("Package name: %S", &dataOwner->iPackageName );

   654             if( sid )

   655                 {

   656                 //Find if the package is already included to dataowner list

   657                 if( packageArray.Find( packageId->PackageIdL(), 

   658                                         CSConSBEClient::Match ) != KErrNotFound )

   659                     {

   660                     LOGGER_WRITE("dataowner was already included to list");

   661                     //Don't include dataowner to list again

   662                     includeToList = EFalse;

   663                     }

   664                 else

   665                     {

   666                     //Store package's id for filtering

   667                     LOGGER_WRITE_1( "Storing package id for filtering, uid: 0x%08x", dataOwner->iUid.iUid );

   668                     packageArray.Append( dataOwner->iUid ); 

   669                     }

   670                 }

   671             

   672             CleanupStack::PopAndDestroy( packageId );

   673             }

   674         else if( derived == EJavaDerivedType )

   675             {

   676             //Hash

   677             CSBJavaId* javaId = CSBJavaId::NewL( genericData );

   678             CleanupStack::PushL( javaId );

   679             

   680             //Initialize with hash data length and copy hash

   681             dataOwner->iJavaHash = HBufC::NewL( javaId->SuiteHashL().Length() );

   682             dataOwner->iJavaHash->Des().Copy( javaId->SuiteHashL() );

   683             

   684             //For ConML: set as passive package

   685             dataOwner->iType = EPassiveDataOwner;

   686             dataOwner->iPackageName.Copy( javaId->SuiteNameL() );

   687             

   688 #ifdef _DEBUG

   689             LOGGER_WRITE("EJavaDerivedType" );

   690             LOGGER_WRITE_1("Package name: %S", &dataOwner->iPackageName );

   691             TPtrC hash( dataOwner->iJavaHash->Des() );

   692             LOGGER_WRITE_1("JavaHash: %S", &hash );

   693 #endif

   694             

   695             CleanupStack::PopAndDestroy( javaId );

   696             }

   697         else

   698             {

   699             LOGGER_WRITE("Unknown type, ignored from list" );

   700             //Unknown type => ignore from list

   701             includeToList = EFalse;

   702             }

   703         

   704         if( includeToList ) 

   705             {

   706             LOGGER_WRITE_1( "Appending to list, uid: 0x%08x", dataOwner->iUid.iUid );

   707             iCurrentTask->iListDataOwnersParams->iDataOwners.Append( dataOwner );

   708             }

   709         

   710         if( sid )

   711             {

   712             LOGGER_WRITE_1( "Appending package sid to list, sid: 0x%08x", sid.iId );

   713             CSConDataOwner* packageDataOwner = dataOwner->CopyL();

   714             //Clear package name

   715             packageDataOwner->iPackageName = KNullDesC();

   716             //Add sid

   717             packageDataOwner->iUid.iUid = sid.iId;

   718             iCurrentTask->iListDataOwnersParams->iDataOwners.Append( packageDataOwner );

   719             }

   720         

   721         if( !includeToList )

   722             {

   723             //Not included to list => delete memory allocation

   724             delete dataOwner;

   725             }

   726         }

   727         

   728     packageArray.Reset();

   729     CleanupStack::PopAndDestroy( &packageArray );

   730     CleanupStack::PopAndDestroy( &dataOwners );

   731     TRACE_FUNC_EXIT;

   732     }

   733     

   734 // -----------------------------------------------------------------------------

   735 // CSConSBEClient::ProcessGetDataSizeL()

   736 // Executes GetDataSize task

   737 // -----------------------------------------------------------------------------

   738 //  

   739 void CSConSBEClient::ProcessGetDataSizeL()

   740     {

   741     TRACE_FUNC_ENTRY;

   742     

   743     if ( !iAllSnapshotsSuppliedCalled )

   744         {

   745         TInt err(KErrNone);

   746         // we have to call AllSnapshotsSupplied() to inform active

   747         // data owners to start prepare their base data.

   748         TRAP( err, iSBEClient->AllSnapshotsSuppliedL() );

   749         LOGGER_WRITE_1( "AllSnapshotsSuppliedL() leaved: %d", err );

   750         iAllSnapshotsSuppliedCalled = ETrue;

   751         }

   752     

   753     

   754     TBool packageData( EFalse );

   755     

   756     //Calculate data size for every data owner received from the task

   757     for( TInt i = 0; i < iCurrentTask->iGetDataSizeParams->iDataOwners.Count();

   758         i++ )

   759         {

   760         packageData = EFalse;

   761         CSConDataOwner* dataOwner = 

   762             iCurrentTask->iGetDataSizeParams->iDataOwners[i];

   763             

   764         TTransferDataType tdt( ERegistrationData );

   765         TPackageDataType pdt( ESystemData );

   766         

   767         LOGGER_WRITE_2( "ProcessGetDataSizeL DO %d of %d", i, iCurrentTask->iGetDataSizeParams->iDataOwners.Count() );

   768         LOGGER_WRITE_1( "ProcessGetDataSizeL SID 0x%08x", dataOwner->iUid );

   769         switch( dataOwner->iTransDataType )

   770             {

   771             case ESConRegistrationData :

   772                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : ERegistrationData" );

   773                 tdt = ERegistrationData;

   774                 break;

   775             case ESConPassiveSnapshotData :

   776                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EPassiveSnapshotData" );

   777                 tdt = EPassiveSnapshotData;

   778                 break;

   779             case ESConPassiveBaseData :

   780                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EPassiveBaseData" );

   781                 tdt = EPassiveBaseData;

   782                 break;

   783             case ESConPassiveIncrementalData :

   784                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EPassiveIncrementalData" );

   785                 tdt = EPassiveIncrementalData;

   786                 break;

   787             case ESConActiveSnapshotData :

   788                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EActiveSnapshotData" );

   789                 tdt = EActiveSnapshotData;

   790                 break;

   791             case ESConActiveBaseData :

   792                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EActiveBaseData" );

   793                 tdt = EActiveBaseData;

   794                 break;

   795             case ESConActiveIncrementalData :

   796                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : EActiveIncrementalData" );

   797                 tdt = EActiveIncrementalData;

   798                 break;

   799             case ESConSystemData :

   800                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : ESystemData" );

   801                 pdt = ESystemData;

   802                 packageData = ETrue;

   803                 break;

   804             case ESConSystemSnapshotData :

   805                 LOGGER_WRITE( "CSConSBEClient::ProcessGetDataSize() : ESystemSnapshotData" );

   806                 pdt = ESystemSnapshotData;

   807                 packageData = ETrue;

   808                 break;

   809             default :

   810                 break;

   811             }

   812         

   813         if( packageData && !dataOwner->iJavaHash )

   814             {

   815             dataOwner->iSize = PackageDataSizeL( dataOwner->iUid, dataOwner->iDriveList, pdt );

   816             }

   817         else if( !dataOwner->iJavaHash )

   818             {

   819             dataOwner->iSize = SidDataSizeL( dataOwner->iUid, dataOwner->iDriveList, tdt );

   820             }

   821         else

   822             {

   823             dataOwner->iSize = JavaDataSizeL( dataOwner->iJavaHash->Des(),

   824                     dataOwner->iDriveList );

   825             }

   826         }

   827     

   828     TRACE_FUNC_EXIT;

   829     }

   830 

   831 

   832 // -----------------------------------------------------------------------------

   833 // CSConSBEClient::ProcessRequestDataL()

   834 // Executes RequestData task

   835 // -----------------------------------------------------------------------------

   836 //      

   837 TInt CSConSBEClient::ProcessRequestDataL()

   838     {

   839     TRACE_FUNC_ENTRY;

   840     TInt ret( KErrNone );

   841     

   842     if( iMaxObjectSize <= 1 )

   843         {

   844         User::Leave( KErrGeneral );

   845         }

   846         

   847     TBool packageData = EFalse;

   848     TTransferDataType transferDataType( ERegistrationData );

   849     TPackageDataType packageDataType( ESystemSnapshotData );    

   850     LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() iTransDataType: %d",

   851         (TInt)iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType);

   852     

   853     switch( iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType )

   854         {

   855         case ESConRegistrationData :

   856             transferDataType = ERegistrationData;

   857             break;

   858         case ESConPassiveSnapshotData :

   859             transferDataType = EPassiveSnapshotData;

   860             break;

   861         case ESConPassiveBaseData :

   862             transferDataType = EPassiveBaseData;

   863             break;

   864         case ESConPassiveIncrementalData :

   865             transferDataType = EPassiveIncrementalData;

   866             break;

   867         case ESConActiveSnapshotData :

   868             transferDataType = EActiveSnapshotData;

   869             break;

   870         case ESConActiveBaseData :

   871             transferDataType = EActiveBaseData;

   872             break;

   873         case ESConActiveIncrementalData :

   874             transferDataType = EActiveIncrementalData;

   875             break;

   876         case ESConSystemData :

   877             packageDataType = ESystemData;

   878             packageData = ETrue;

   879             break;

   880         case ESConSystemSnapshotData:

   881             packageDataType = ESystemSnapshotData;

   882             packageData = ETrue;

   883             break;

   884         default :

   885             break;

   886         }

   887         

   888     

   889     //Get the drive number  

   890     TDriveNumber driveNumber = EDriveC;

   891     TDriveList driveList = iCurrentTask->iRequestDataParams->

   892         iDataOwner->iDriveList;

   893     

   894     for( TInt i = 0; i < KMaxDrives; i++ )

   895         {

   896         if( driveList[i] )

   897             {

   898             driveNumber = GetDriveNumber( i );

   899             break;

   900             }

   901         }

   902         

   903     //Get UID, SID or Java hash

   904     TUid uid;

   905     TSecureId sid;

   906             

   907     uid.iUid = 0;

   908     sid.iId = 0;

   909     

   910     if( packageData && !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )

   911         {

   912         uid = iCurrentTask->iRequestDataParams->iDataOwner->iUid;

   913         LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() uid: 0x%08x", uid.iUid);

   914         }

   915     else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )

   916         {

   917         sid = iCurrentTask->iRequestDataParams->iDataOwner->iUid;

   918         LOGGER_WRITE_1("CSConSBEClient::ProcessRequestDataL() sid: 0x%08x", sid.iId);

   919         }

   920             

   921     CSBPackageTransferType* ptt( NULL );

   922     CSBSIDTransferType* stt( NULL );

   923     CSBJavaTransferType* jtt( NULL );

   924     

   925     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \

   926     Begin - Data left: %d", iDataLeft );

   927     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \

   928     Begin - Package data: %d", packageData );

   929     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \

   930     Begin - iDataPos: %d", iDataPos );

   931         

   932     //Are there old data left to be transfered?

   933     if( !iDataLeft ) 

   934         {

   935         //No data left, request more from the server

   936         if( packageData && !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )

   937             {

   938             ptt = CSBPackageTransferType::NewL( uid, driveNumber, 

   939                 packageDataType );

   940             CleanupStack::PushL( ptt );

   941             LOGGER_WRITE( "iSBEClient->RequestDataL( ptt ) : start" );

   942             TRequestStatus status;

   943             iSBEClient->RequestDataL( *ptt, status );

   944             User::WaitForRequest( status );

   945             LOGGER_WRITE( "iSBEClint->RequestDataL( ptt ) : stop" );

   946             

   947             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : status.Int() %d", status.Int() );

   948             User::LeaveIfError( status.Int() );

   949                                     

   950             //Get the data and store the handle

   951             CSBGenericTransferType* gtt = NULL;

   952             LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );

   953             iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );

   954             LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : stop" );

   955             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

   956              Received data size %d", iDataPtr.Length() );

   957             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

   958              Received from DO 0x%08x", uid );

   959             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

   960              Is last chunk %d", iLastChunk );

   961             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

   962              Transfertype %d", iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );

   963              

   964              if( gtt )

   965                 {

   966                 delete gtt;

   967                 }

   968              

   969             CleanupStack::PopAndDestroy( ptt );

   970             }

   971         else if( !iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash )

   972             {

   973             stt = CSBSIDTransferType::NewL( sid, driveNumber, transferDataType );

   974             CleanupStack::PushL( stt );

   975             LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : start" );

   976             TRequestStatus status;

   977             iSBEClient->RequestDataL( *stt, status );

   978             User::WaitForRequest( status );

   979             LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : stop" );

   980             

   981             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

   982              status.Int() %d", status.Int() );

   983             User::LeaveIfError( status.Int() );

   984                         

   985             //Get the data and store the handle

   986             CSBGenericTransferType* gtt = NULL;

   987             LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );

   988             iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );

   989             LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : stop" );

   990             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

   991              Received data size %d", iDataPtr.Length() );

   992             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

   993              Is last chunk %d", iLastChunk );

   994             LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

   995              Transfertype %d", 

   996              iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );

   997              

   998             if( gtt )

   999                 {

  1000                 delete gtt;

  1001                 }

  1002              

  1003             CleanupStack::PopAndDestroy( stt );

  1004             }

  1005         else

  1006             {

  1007             TPtr javaHashPtr = iCurrentTask->iRequestDataParams->iDataOwner->iJavaHash->Des();

  1008             

  1009             //When ESystemData is requested, request EJavaMIDlet

  1010             if( packageDataType == ESystemData )

  1011                 {

  1012                 jtt = CSBJavaTransferType::NewL( javaHashPtr, driveNumber, EJavaMIDlet );

  1013                 }

  1014             //When EPassiveBaseData is requested, request EJavaMIDletData

  1015             else if( transferDataType == EPassiveBaseData )

  1016                 {

  1017                 jtt = CSBJavaTransferType::NewL( javaHashPtr, driveNumber, EJavaMIDletData );

  1018                 }

  1019                         

  1020             if( packageDataType == ESystemData || transferDataType == EPassiveBaseData )

  1021                 {

  1022                 CleanupStack::PushL( jtt );

  1023                 LOGGER_WRITE( "iSBEClient->RequestDataL( jtt ) : start" );

  1024                 TRequestStatus status;

  1025                 iSBEClient->RequestDataL( *jtt, status );

  1026                 User::WaitForRequest( status );

  1027                 LOGGER_WRITE( "iSBEClient->RequestDataL( jtt ) : stop" );

  1028                 

  1029                 LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

  1030                  status.Int() %d", status.Int() );

  1031                 User::LeaveIfError( status.Int() );

  1032                             

  1033                 //Get the data and store the handle

  1034                 CSBGenericTransferType* gtt = NULL;

  1035                 LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ) : start" );

  1036                 iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iLastChunk ) );

  1037                 LOGGER_WRITE( "iDataPtr.Set( iSBEClient->TransferDataInfoL( gtt, iSBEDataLeft ): stop" );

  1038                 LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

  1039                  Received data size %d", iDataPtr.Length() );

  1040                 LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

  1041                  Is last chunk %d", iLastChunk );

  1042                 LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :\

  1043                  Transfertype %d", 

  1044                  iCurrentTask->iRequestDataParams->iDataOwner->iTransDataType );

  1045                  

  1046                 if( gtt )

  1047                     {

  1048                     delete gtt;

  1049                     }

  1050                  

  1051                 CleanupStack::PopAndDestroy( jtt );   

  1052                 }

  1053             else

  1054                 {

  1055                 //No data

  1056                 iDataPtr.Set( KNullDesC8 );

  1057                 iLastChunk = ETrue;

  1058                 }

  1059             }

  1060         }   

  1061         

  1062     TInt dataBufLength = iDataPtr.Length();

  1063     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \

  1064     Data received: %d", dataBufLength );

  1065     

  1066     TInt maxLength = iMaxObjectSize - 1024;

  1067     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \

  1068     Max length: %d", maxLength );

  1069     

  1070     if( iCurrentTask->iRequestDataParams->iBackupData )

  1071         {

  1072         delete iCurrentTask->iRequestDataParams->iBackupData;

  1073         iCurrentTask->iRequestDataParams->iBackupData = NULL;

  1074         }

  1075     

  1076     //Initialize the task data buffer

  1077     iCurrentTask->iRequestDataParams->iBackupData = HBufC8::NewL( maxLength );

  1078     //Get descriptor task's buffer

  1079     TPtr8 backupDataPtr = iCurrentTask->iRequestDataParams->iBackupData->Des();

  1080     

  1081     TInt copyPos = 0;

  1082     

  1083     //Copy data to task buffer

  1084     for( ; iDataPos < dataBufLength && copyPos < maxLength;

  1085      iDataPos++ )

  1086         {

  1087         backupDataPtr.Append( iDataPtr[iDataPos] );

  1088         copyPos++;

  1089         }

  1090         

  1091     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \

  1092     End - copyPos: %d", copyPos );

  1093     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() : \

  1094     End - iDataPos: %d", iDataPos );

  1095             

  1096     //Are there more data left in the buffer

  1097     if( iDataPos < dataBufLength )

  1098         {

  1099         LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : There is more data in buffer" );

  1100         iDataLeft = ETrue;

  1101         iCurrentTask->iRequestDataParams->iMoreData = ETrue;

  1102         //Another task is needed to transfer the data to the client

  1103         ret = KErrCompletion;

  1104         }

  1105     else

  1106         {

  1107         //Check if the backup server has more data from the dataowner

  1108         if( !iLastChunk )

  1109             {

  1110             iCurrentTask->iRequestDataParams->iMoreData = ETrue; 

  1111             //Another task is needed to transfer the data to the client

  1112             ret = KErrCompletion;

  1113             LOGGER_WRITE( "iSBEClient->RequestDataL( stt ) : There are more data available from SBE" );

  1114             }

  1115         else

  1116             {

  1117             iCurrentTask->iRequestDataParams->iMoreData = EFalse;

  1118             }

  1119             

  1120         iDataPos = 0;   

  1121         iDataLeft = EFalse; 

  1122         }

  1123         

  1124     LOGGER_WRITE_1( "CSConSBEClient::ProcessRequestDataL() :  returned %d", ret );

  1125     return ret;

  1126     }

  1127     

  1128 // -----------------------------------------------------------------------------

  1129 // CSConSBEClient::ProcessGetDataOwnerStatusL()

  1130 // Executes GetDataOwnerStatus task

  1131 // -----------------------------------------------------------------------------

  1132 //  

  1133 void CSConSBEClient::ProcessGetDataOwnerStatusL()

  1134     {