1 /*

     2 * Copyright (c) 2005-2010 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 const TInt KDataBufExpandSize( 1024 );

    28 const TInt KMaxObjectSize( 1048576 - 1024 ); // Max chunk size is 1MB, but give some space for ConML wbxml

    29 _LIT( KSConNoDrive, "\x0" );

    30 _LIT( KSConDriveExists, "\x1" );

    31 // ============================= MEMBER FUNCTIONS ==============================

    32 

    33 // -----------------------------------------------------------------------------

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

    35 // Two-phase constructor

    36 // -----------------------------------------------------------------------------

    37 //  

    38 CSConSBEClient* CSConSBEClient::NewL( RFs& aFs )

    39     {

    40     TRACE_FUNC;

    41     CSConSBEClient* self = new (ELeave) CSConSBEClient( aFs );

    42     return self;

    43     }

    44     

    45 // -----------------------------------------------------------------------------

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

    47 // Constructor

    48 // -----------------------------------------------------------------------------

    49 //

    50 CSConSBEClient::CSConSBEClient( RFs& aFs ) : 

    51         CActive( EPriorityStandard ), iBURModeNormal( ETrue ), iFs( aFs )

    52     {

    53     CActiveScheduler::Add( this );

    54     }

    55 

    56 // -----------------------------------------------------------------------------

    57 // CSConSBEClient::~CSConSBEClient()

    58 // Initializes member data

    59 // -----------------------------------------------------------------------------

    60 //  

    61 CSConSBEClient::~CSConSBEClient()

    62     {

    63     TRACE_FUNC_ENTRY;

    64     Cancel();

    65     TInt err( KErrNone );

    66     

    67     if( !iBURModeNormal && iSBEClient )

    68         {

    69         TDriveList driveList;

    70         

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

    72             {

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

    74                 {

    75                 driveList.Append( KSConDriveExists );

    76                 }

    77             else

    78                 {

    79                 driveList.Append( KSConNoDrive );

    80                 }

    81             }

    82         

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

    84         }

    85     

    86     if( iSBEClient )

    87         {

    88         delete iSBEClient;

    89         iSBEClient = NULL;

    90         }

    91     

    92     delete iDataBuffer;

    93     TRACE_FUNC_EXIT;

    94     }

    95 

    96 // -----------------------------------------------------------------------------

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

    98 // Set backup/restore mode

    99 // -----------------------------------------------------------------------------

   100 //  

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

   102     {

   103     TRACE_FUNC_ENTRY;

   104     iCallerStatus = &aStatus;

   105     *iCallerStatus = KRequestPending;

   106     

   107     iCurrentTask = aTask;

   108 

   109     TRequestStatus* status = &iStatus; 

   110     User::RequestComplete( status, KErrNone ); 

   111     SetActive();

   112     TRACE_FUNC_EXIT;

   113     }

   114 

   115 // -----------------------------------------------------------------------------

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

   117 //                                  CSConTask*& aTask )

   118 // Lists public files from data owners

   119 // -----------------------------------------------------------------------------

   120 //  

   121 void CSConSBEClient::ListPublicFiles( TRequestStatus& aStatus, 

   122                                     CSConTask*& aTask )

   123     {

   124     TRACE_FUNC_ENTRY;

   125     iCallerStatus = &aStatus;

   126     *iCallerStatus = KRequestPending;

   127     

   128     iCurrentTask = aTask;

   129     

   130     TRequestStatus* status = &iStatus; 

   131     User::RequestComplete( status, KErrNone ); 

   132     SetActive();    

   133     TRACE_FUNC_EXIT;

   134     }

   135     

   136 // -----------------------------------------------------------------------------

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

   138 // Lists participant data owners

   139 // -----------------------------------------------------------------------------

   140 //  

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

   142     {

   143     TRACE_FUNC_ENTRY;

   144     iCallerStatus = &aStatus;

   145     *iCallerStatus = KRequestPending;

   146     

   147     iCurrentTask = aTask;

   148     

   149     TRequestStatus* status = &iStatus; 

   150     User::RequestComplete( status, KErrNone ); 

   151     SetActive();

   152     TRACE_FUNC_EXIT;

   153     }

   154     

   155 // -----------------------------------------------------------------------------

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

   157 // Lists data sizes from data owners

   158 // -----------------------------------------------------------------------------

   159 //  

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

   161     {

   162     TRACE_FUNC_ENTRY;

   163     iCallerStatus = &aStatus;

   164     *iCallerStatus = KRequestPending;

   165     

   166     iCurrentTask = aTask;

   167     

   168     TRequestStatus* status = &iStatus; 

   169     User::RequestComplete( status, KErrNone ); 

   170     SetActive();

   171     TRACE_FUNC_EXIT;

   172     }

   173 

   174 // -----------------------------------------------------------------------------

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

   176 // Request a data from a data owner

   177 // -----------------------------------------------------------------------------

   178 //  

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

   180     {

   181     TRACE_FUNC_ENTRY;

   182     iCallerStatus = &aStatus;

   183     *iCallerStatus = KRequestPending;

   184     

   185     iCurrentTask = aTask;

   186     

   187     TRequestStatus* status = &iStatus;

   188     User::RequestComplete( status, KErrNone );          

   189     SetActive();    

   190     TRACE_FUNC_EXIT;

   191     }

   192     

   193 // -----------------------------------------------------------------------------

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

   195 //                                      CSConTask*& aTask )

   196 // Lists the status of data owners

   197 // -----------------------------------------------------------------------------

   198 //  

   199 void CSConSBEClient::GetDataOwnerStatus( TRequestStatus& aStatus, 

   200                                         CSConTask*& aTask )

   201     {

   202     TRACE_FUNC_ENTRY;

   203     iCallerStatus = &aStatus;

   204     *iCallerStatus = KRequestPending;

   205     

   206     iCurrentTask = aTask;

   207     

   208     TRequestStatus* status = &iStatus; 

   209     User::RequestComplete( status, KErrNone ); 

   210     SetActive();

   211         

   212     TRACE_FUNC_EXIT;

   213     }

   214     

   215 // -----------------------------------------------------------------------------

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

   217 // Supplies a data to a data owner

   218 // -----------------------------------------------------------------------------

   219 //  

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

   221     {

   222     TRACE_FUNC_ENTRY;

   223     iCallerStatus = &aStatus;

   224     *iCallerStatus = KRequestPending;

   225     

   226     iCurrentTask = aTask;

   227     

   228     TRequestStatus* status = &iStatus; 

   229     User::RequestComplete( status, KErrNone ); 

   230     SetActive();    

   231     TRACE_FUNC_EXIT;

   232     }

   233     

   234 // -----------------------------------------------------------------------------

   235 // CSConSBEClient::DoCancel()

   236 // Implementation of CActive::DoCancel()

   237 // -----------------------------------------------------------------------------

   238 //          

   239 void CSConSBEClient::DoCancel()

   240     {

   241     TRACE_FUNC;

   242     }

   243 

   244 // -----------------------------------------------------------------------------

   245 // CSConSBEClient::RunL()

   246 // Implementation of CActive::RunL()

   247 // -----------------------------------------------------------------------------

   248 //              

   249 void CSConSBEClient::RunL()

   250     {

   251     TRACE_FUNC_ENTRY;

   252     TInt err( KErrNone );

   253     TInt ret( KErrNone );

   254     

   255     //Initialize a connection to the backup server

   256     if( !iSBEClient )

   257         {

   258         iSBEClient = CSBEClient::NewL();

   259         }   

   260     

   261     switch( iCurrentTask->GetServiceId() )

   262         {

   263         case ESetBURMode :

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

   265             TRAP( err, ProcessSetBURModeL() );

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

   267             break;

   268         case EListPublicFiles :

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

   270             TRAP( err, ProcessListPublicFilesL() );

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

   272             break;

   273         case EListDataOwners :

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

   275             TRAP( err, ProcessListDataOwnersL() );

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

   277             break;

   278         case EGetDataSize :

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

   280             TRAP( err, ProcessGetDataSizeL() );

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

   282             break;

   283         case ERequestData :

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

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

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

   287             break;  

   288         case EGetDataOwnerStatus :

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

   290             TRAP( err, ProcessGetDataOwnerStatusL() );

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

   292             break;

   293         case ESupplyData :

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

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

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

   297             break;

   298         default :

   299             err = KErrNotSupported;

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

   301             break;

   302         }

   303     

   304     if ( err )

   305         {

   306         HandleSBEErrorL( err );

   307         }

   308     else

   309         {

   310         err = ret;

   311         }

   312     User::RequestComplete( iCallerStatus, err );

   313             

   314     TRACE_FUNC_EXIT;

   315     }

   316     

   317 // -----------------------------------------------------------------------------

   318 // CSConSBEClient::ProcessSetBURModeL()

   319 // Executes SetBURMode task

   320 // -----------------------------------------------------------------------------

   321 //  

   322 void CSConSBEClient::ProcessSetBURModeL()

   323     {

   324     TRACE_FUNC_ENTRY;

   325     

   326     iAllSnapshotsSuppliedCalled = EFalse;

   327     iLastChunk = EFalse;

   328     

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

   330     

   331     TBURPartType partialType = EBURUnset;

   332     iRestoreMode = EFalse;

   333     

   334     switch( iCurrentTask->iBURModeParams->iPartialType )

   335         {

   336         case ESConBurNormal :

   337             partialType = EBURNormal;

   338             break;

   339         case ESConBurBackupFull :

   340             partialType = EBURBackupFull;

   341             break;

   342         case ESConBurBackupPartial :

   343             partialType = EBURBackupPartial;

   344             break;

   345         case ESConBurRestoreFull :

   346             partialType = EBURRestoreFull;

   347             iRestoreMode = ETrue;

   348             break;

   349         case ESConBurRestorePartial :

   350             partialType = EBURRestorePartial;

   351             iRestoreMode = ETrue;

   352             break;

   353         default :

   354             partialType = EBURUnset;

   355             break;

   356         }

   357     

   358     if ( partialType == EBURBackupFull || partialType == ESConBurBackupPartial )

   359         {

   360         // initialize buffer

   361         if ( !iDataBuffer )

   362             iDataBuffer = CBufFlat::NewL( KDataBufExpandSize );

   363         else

   364             iDataBuffer->Reset();

   365         iDataBufferSize=0;

   366         }

   367     else

   368         {

   369         delete iDataBuffer;

   370         iDataBuffer = 0;

   371         }

   372     

   373     TBackupIncType incType = ENoBackup;

   374     

   375     switch( iCurrentTask->iBURModeParams->iIncType )    

   376         {

   377         case ESConNoBackup :

   378             incType = ENoBackup;

   379             break;

   380         case ESConBackupBase :

   381             incType = EBackupBase;

   382             break;

   383         case ESConBackupIncrement :

   384             incType = EBackupIncrement;

   385             break;

   386         default :

   387             incType = ENoBackup;

   388             break;

   389         }

   390     

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

   392     

   393     if( partialType != EBURNormal )

   394         {

   395         iBURModeNormal = EFalse;

   396         }

   397     else

   398         {

   399         iBURModeNormal = ETrue;

   400         }

   401     TRACE_FUNC_EXIT;

   402     }

   403 

   404 // -----------------------------------------------------------------------------

   405 // CSConSBEClient::ProcessListPublicFilesL()

   406 // Executes ListPublicFiles task

   407 // -----------------------------------------------------------------------------

   408 //

   409 void CSConSBEClient::ProcessListPublicFilesL()

   410     {

   411     TRACE_FUNC_ENTRY;

   412     //Get the secure id

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

   414     TSecureId packageSid;

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

   416     TPtrC packageName(KNullDesC);

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

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

   419     

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

   421     

   422     if ( packageNameLength > KSConUidLength )

   423         {

   424         // remove uid from package name

   425         packageName.Set( 

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

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

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

   429         

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

   431                 iPackageName.Right( KSConUidLength ) );

   432         TLex lex(sidPtr);

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

   434         if ( err )

   435             {

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

   437             packageName.Set( KNullDesC );

   438             packageSid.iId = 0;

   439             }

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

   441         }

   442     

   443     //Get the drive list

   444     TDriveList driveList = 

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

   446     

   447     RFileArray files;

   448     CleanupClosePushL( files );

   449     //Go through all the drives in the list

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

   451         {

   452         if( driveList[i] )

   453             {

   454             //Get files from the drive

   455             TDriveNumber driveNumber = GetDriveNumber( i );

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

   457             

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

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

   460             CleanupStack::PushL( secureId );

   461             

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

   463             

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

   465                 {

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

   467                 User::LeaveIfError( err );

   468                 }

   469             

   470             CleanupStack::PopAndDestroy( secureId );

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

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

   473             

   474             if ( packageName.Length() > 0 )

   475                 {

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

   477                 

   478                 CSBPackageId* packageId = CSBPackageId::NewL(

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

   480                         packageSid,

   481                         packageName );

   482                 CleanupStack::PushL( packageId );

   483                 

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

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

   486                     {

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

   488                     User::LeaveIfError( err );

   489                     }

   490                 CleanupStack::PopAndDestroy( packageId );

   491                 

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

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

   494                 }

   495             

   496             files.Reset();

   497             }

   498         }

   499     CleanupStack::PopAndDestroy( &files );

   500     TRACE_FUNC_EXIT;

   501     }

   502 

   503     

   504 // -----------------------------------------------------------------------------

   505 // CSConSBEClient::ProcessListDataOwnersL()

   506 // Executes ListDataOwners task

   507 // -----------------------------------------------------------------------------

   508 //

   509 void CSConSBEClient::ProcessListDataOwnersL()

   510     {

   511     TRACE_FUNC_ENTRY;

   512     TBool includeToList( ETrue );

   513     RPointerArray<CDataOwnerInfo> dataOwners;

   514     RArray<TUid> packageArray;

   515     CleanupResetAndDestroyPushL( dataOwners );

   516     CleanupClosePushL( packageArray );

   517     

   518     iSBEClient->ListOfDataOwnersL( dataOwners );

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

   520     

   521     

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

   523         {

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

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

   526         CleanupStack::PushL( dataOwner );

   527         // default values

   528         TSecureId sid( 0 );

   529         includeToList = ETrue;

   530         

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

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

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

   534         

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

   536         if( commonOptions & EActiveBUR && commonOptions & EPassiveBUR )

   537             {

   538             dataOwner->iType = EHybridDataOwner;

   539             }       

   540         else if( commonOptions & EActiveBUR )

   541             {

   542             dataOwner->iType = EActiveDataOwner;

   543             }

   544         else if( commonOptions & EPassiveBUR )

   545             {

   546             dataOwner->iType = EPassiveDataOwner;

   547             }

   548                 

   549         //requires reboot? (common)

   550         if( commonOptions & ERequiresReboot )

   551             {

   552             dataOwner->iReqReboot = ETrue;

   553             }

   554         else

   555             {

   556             dataOwner->iReqReboot = EFalse;

   557             }

   558             

   559         //has system files? (common)

   560         if( commonOptions & EHasSystemFiles )

   561             {

   562             dataOwner->iHasFiles = ESystemFiles;

   563             }

   564             

   565         //supports selective? (common)

   566         if( commonOptions & ESupportsSelective )

   567             {

   568             dataOwner->iSupportsSel = ETrue;

   569             }

   570         else

   571             {

   572             dataOwner->iSupportsSel = EFalse;

   573             }

   574             

   575         //has public files? (passive)

   576         if( passiveOptions & EHasPublicFiles )

   577             {

   578             if( dataOwner->iHasFiles == ESystemFiles )

   579                 {

   580                 dataOwner->iHasFiles = EPublicSystemFiles;

   581                 }

   582             else

   583                 {

   584                 dataOwner->iHasFiles = EPublicFiles;    

   585                 }

   586             }

   587             

   588         //supports incremental? (active and passive)

   589         if( activeOptions & EActiveSupportsInc || 

   590                 passiveOptions & EPassiveSupportsInc  )

   591             {

   592             dataOwner->iSupportsInc = ETrue;

   593             }

   594         else

   595             {

   596             dataOwner->iSupportsInc = EFalse;

   597             }

   598             

   599         //delay to prepare data? (active)

   600         if( activeOptions & EDelayToPrepareData )

   601             {

   602             dataOwner->iDelayToPrep = ETrue;

   603             }

   604         else

   605             {

   606             dataOwner->iDelayToPrep = EFalse;

   607             }

   608             

   609         //fill drivelist

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

   611         //filter the drive list

   612         FilterDriveList( dataOwner->iDriveList );

   613                         

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

   615         TSBDerivedType derived = genericData->DerivedTypeL();

   616         

   617         if( derived == ESIDDerivedType )

   618             {

   619             //Uif of the data owner

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

   621             CleanupStack::PushL( secureId );

   622             sid = secureId->SecureIdL();

   623         

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

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

   626         

   627             CleanupStack::PopAndDestroy( secureId );

   628             }

   629         else if( derived == EPackageDerivedType )

   630             {

   631             //Package name and uid of the data owner

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

   633             CleanupStack::PushL( packageId );

   634         

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

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

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

   638             sid = packageId->SecureIdL();

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

   640             

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

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

   643             const TInt KSidFormatLength = 11;

   644             TBuf<KSidFormatLength> sidFormat;

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

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

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

   648                 {

   649                 dataOwner->iPackageName.Append( sidFormat );

   650                 }

   651             else

   652                 {

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

   654                 }

   655             

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

   657             if( sid )

   658                 {

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

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

   661                                         CSConSBEClient::Match ) != KErrNotFound )

   662                     {

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

   664                     //Don't include dataowner to list again

   665                     includeToList = EFalse;

   666                     }

   667                 else

   668                     {

   669                     //Store package's id for filtering

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

   671                     packageArray.Append( dataOwner->iUid ); 

   672                     }

   673                 }

   674             

   675             CleanupStack::PopAndDestroy( packageId );

   676             }

   677         else if( derived == EJavaDerivedType )

   678             {

   679             //Hash

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

   681             CleanupStack::PushL( javaId );

   682             

   683             //Initialize with hash data length and copy hash

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

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

   686             

   687             //For ConML: set as passive package

   688             dataOwner->iType = EPassiveDataOwner;

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

   690             

   691 #ifdef _DEBUG

   692             LOGGER_WRITE("EJavaDerivedType" );

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

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

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

   696 #endif

   697             

   698             CleanupStack::PopAndDestroy( javaId );

   699             }

   700         else

   701             {

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

   703             //Unknown type => ignore from list

   704             includeToList = EFalse;

   705             }

   706         

   707         if( includeToList ) 

   708             {

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

   710             iCurrentTask->iListDataOwnersParams->iDataOwners.AppendL( dataOwner );

   711             CleanupStack::Pop( dataOwner );

   712             }

   713         

   714         if( sid )

   715             {

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

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

   718             CleanupStack::PushL( packageDataOwner );

   719             //Clear package name

   720             packageDataOwner->iPackageName = KNullDesC();

   721             //Add sid

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

   723             iCurrentTask->iListDataOwnersParams->iDataOwners.AppendL( packageDataOwner );

   724             CleanupStack::Pop( packageDataOwner );

   725             }

   726         

   727         if( !includeToList )

   728             {

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

   730             CleanupStack::PopAndDestroy( dataOwner );

   731             }

   732         }

   733         

   734     packageArray.Reset();

   735     CleanupStack::PopAndDestroy( &packageArray );

   736     CleanupStack::PopAndDestroy( &dataOwners );

   737     TRACE_FUNC_EXIT;

   738     }

   739     

   740 // -----------------------------------------------------------------------------

   741 // CSConSBEClient::ProcessGetDataSizeL()

   742 // Executes GetDataSize task

   743 // -----------------------------------------------------------------------------

   744 //  

   745 void CSConSBEClient::ProcessGetDataSizeL()

   746     {

   747     TRACE_FUNC_ENTRY;

   748     

   749     if ( !iAllSnapshotsSuppliedCalled )

   750         {

   751         TInt err(KErrNone);

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

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

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

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

   756         iAllSnapshotsSuppliedCalled = ETrue;

   757         }

   758     

   759     

   760     TBool packageData( EFalse );

   761     

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

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

   764         i++ )

   765         {

   766         packageData = EFalse;

   767         CSConDataOwner* dataOwner = 

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

   769             

   770         TTransferDataType tdt( ERegistrationData );

   771         TPackageDataType pdt( ESystemData );

   772         

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

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

   775         switch( dataOwner->iTransDataType )

   776             {

   777             case ESConRegistrationData :

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

   779                 tdt = ERegistrationData;

   780                 break;

   781             case ESConPassiveSnapshotData :

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

   783                 tdt = EPassiveSnapshotData;

   784                 break;

   785             case ESConPassiveBaseData :

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

   787                 tdt = EPassiveBaseData;

   788                 break;

   789             case ESConPassiveIncrementalData :

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

   791                 tdt = EPassiveIncrementalData;

   792                 break;

   793             case ESConActiveSnapshotData :

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

   795                 tdt = EActiveSnapshotData;

   796                 break;

   797             case ESConActiveBaseData :

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

   799                 tdt = EActiveBaseData;

   800                 break;

   801             case ESConActiveIncrementalData :

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

   803                 tdt = EActiveIncrementalData;

   804                 break;

   805             case ESConSystemData :

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

   807                 pdt = ESystemData;

   808                 packageData = ETrue;

   809                 break;

   810             case ESConSystemSnapshotData :

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

   812                 pdt = ESystemSnapshotData;

   813                 packageData = ETrue;

   814                 break;

   815             default :

   816                 break;

   817             }

   818         

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

   820             {

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

   822             }

   823         else if( !dataOwner->iJavaHash )

   824             {

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

   826             }

   827         else

   828             {

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

   830                     dataOwner->iDriveList );

   831             }

   832         }

   833     

   834     TRACE_FUNC_EXIT;

   835     }

   836 

   837 

   838 // -----------------------------------------------------------------------------

   839 // CSConSBEClient::ProcessRequestDataL()

   840 // Executes RequestData task

   841 // -----------------------------------------------------------------------------

   842 //      

   843 TInt CSConSBEClient::ProcessRequestDataL()

   844     {

   845     TRACE_FUNC_ENTRY;

   846     TInt ret( KErrNone );

   847         

   848     TBool packageData = EFalse;

   849     TTransferDataType transferDataType( ERegistrationData );

   850     TPackageDataType packageDataType( ESystemSnapshotData );    

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

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

   853     

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

   855         {

   856         case ESConRegistrationData :

   857             transferDataType = ERegistrationData;

   858             break;

   859         case ESConPassiveSnapshotData :

   860             transferDataType = EPassiveSnapshotData;

   861             break;

   862         case ESConPassiveBaseData :

   863             transferDataType = EPassiveBaseData;

   864             break;

   865         case ESConPassiveIncrementalData :

   866             transferDataType = EPassiveIncrementalData;

   867             break;

   868         case ESConActiveSnapshotData :

   869             transferDataType = EActiveSnapshotData;

   870             break;

   871         case ESConActiveBaseData :

   872             transferDataType = EActiveBaseData;

   873             break;

   874         case ESConActiveIncrementalData :

   875             transferDataType = EActiveIncrementalData;

   876             break;

   877         case ESConSystemData :

   878             packageDataType = ESystemData;

   879             packageData = ETrue;

   880             break;

   881         case ESConSystemSnapshotData:

   882             packageDataType = ESystemSnapshotData;

   883             packageData = ETrue;

   884             break;

   885         default :

   886             break;

   887         }

   888         

   889     

   890     //Get the drive number  

   891     TDriveNumber driveNumber = EDriveC;

   892     TDriveList driveList = iCurrentTask->iRequestDataParams->

   893         iDataOwner->iDriveList;

   894     

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

   896         {

   897         if( driveList[i] )

   898             {

   899             driveNumber = GetDriveNumber( i );

   900             break;

   901             }

   902         }

   903         

   904     //Get UID, SID or Java hash

   905     TUid uid;

   906     TSecureId sid;

   907             

   908     uid.iUid = 0;

   909     sid.iId = 0;

   910     

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

   912         {

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

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

   915         }

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

   917         {

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

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

   920         }

   921     

   922 

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

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

   925 

   926     LOGGER_WRITE_1("iLastChunk: %d", (TInt) iLastChunk );

   927     LOGGER_WRITE_1("iDataBufferSize: %d", iDataBufferSize );

   928         

   929     // if was't last chunk and there are free space left on our packet

   930     if( !iLastChunk && iDataBufferSize < KMaxObjectSize ) 

   931         {

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

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

   934             {

   935             CSBPackageTransferType* ptt = CSBPackageTransferType::NewL(

   936                     uid, driveNumber, packageDataType );

   937             CleanupStack::PushL( ptt );

   938             

   939             RequestDataL( *ptt );

   940             

   941             CleanupStack::PopAndDestroy( ptt );

   942             }

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

   944             {

   945             CSBSIDTransferType* stt = CSBSIDTransferType::NewL(

   946                     sid, driveNumber, transferDataType );

   947             CleanupStack::PushL( stt );

   948             

   949             RequestDataL( *stt );

   950             

   951             CleanupStack::PopAndDestroy( stt );

   952             }

   953         else

   954             {

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

   956             CSBJavaTransferType* jtt( NULL );

   957             //When ESystemData is requested, request EJavaMIDlet

   958             if( packageDataType == ESystemData )

   959                 {

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

   961                 }

   962             //When EPassiveBaseData is requested, request EJavaMIDletData

   963             else if( transferDataType == EPassiveBaseData )

   964                 {

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

   966                 }

   967                         

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

   969                 {

   970                 CleanupStack::PushL( jtt );

   971                 

   972                 RequestDataL( *jtt );

   973                 

   974                 CleanupStack::PopAndDestroy( jtt );   

   975                 }

   976             else

   977                 {

   978                 //No data

   979                 iDataBuffer->Reset();

   980                 iDataBufferSize = 0;

   981                 iLastChunk = ETrue;

   982                 }

   983             }

   984         }

   985     

   986     LOGGER_WRITE_1("readed iLastChunk: %d", (TInt) iLastChunk );

   987     LOGGER_WRITE_1("readed iDataBufferSize: %d", iDataBufferSize );

   988         

   989     

   990     

   991     if( iCurrentTask->iRequestDataParams->iBackupData )

   992         {

   993         delete iCurrentTask->iRequestDataParams->iBackupData;

   994         iCurrentTask->iRequestDataParams->iBackupData = NULL;

   995         }

   996     

   997     TInt dataToRead = KMaxObjectSize;

   998     if ( dataToRead > iDataBufferSize )

   999         dataToRead = iDataBufferSize;

  1000     

  1001     //Initialize the task data buffer

  1002     iCurrentTask->iRequestDataParams->iBackupData = HBufC8::NewL( dataToRead );

  1003     //Get descriptor task's buffer

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

  1005     

  1006     

  1007     iDataBuffer->Read(0, backupDataPtr, dataToRead );

  1008     iDataBuffer->Delete(0, dataToRead);

  1009     iDataBufferSize -= dataToRead;

  1010     

  1011     if ( !iLastChunk || iDataBufferSize>0 )

  1012         {

  1013         LOGGER_WRITE( "CSConSBEClient::ProcessRequestDataL() : There are more data available" );

  1014         iCurrentTask->iRequestDataParams->iMoreData = ETrue;

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

  1016         ret = KErrCompletion;

  1017         }

  1018     else

  1019         {

  1020         LOGGER_WRITE( "CSConSBEClient::ProcessRequestDataL() : All data readed" );

  1021         iDataBuffer->Reset();

  1022         iDataBufferSize = 0;

  1023         // task will be completed, initialize iLastChunk value for next operation

  1024         iLastChunk = EFalse;

  1025         }

  1026     

  1027         

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

  1029     return ret;

  1030     }

  1031 

  1032 void CSConSBEClient::RequestDataL( CSBGenericTransferType& aGenericTransferType )

  1033     {

  1034     TRACE_FUNC_ENTRY;

  1035     if ( !iDataBuffer )

  1036         User::Leave( KErrArgument );

  1037     

  1038     do

  1039         {

  1040         LOGGER_WRITE( "iSBEClient->RequestDataL() : start" );

  1041         TRequestStatus status;

  1042         iSBEClient->RequestDataL( aGenericTransferType, status );

  1043         User::WaitForRequest( status );

  1044         LOGGER_WRITE_1( "iSBEClient->RequestDataL() : status.Int() %d", status.Int() );

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

  1046                     

  1047         //Get the data and store the handle

  1048         CSBGenericTransferType* gtt = NULL;

  1049         const TPtrC8& dataPtr = iSBEClient->TransferDataInfoL( gtt, iLastChunk );

  1050         LOGGER_WRITE_1("data size: %d", dataPtr.Length());

  1051         delete gtt;

  1052         iDataBuffer->ExpandL( iDataBufferSize, dataPtr.Length() );

  1053         iDataBuffer->Write(iDataBufferSize, dataPtr);

  1054         iDataBufferSize += dataPtr.Length();

  1055         LOGGER_WRITE_1("total buffer size: %d", iDataBufferSize);

  1056         }

  1057     // Continue if there are more data, and our packet is not full

  1058     while ( !iLastChunk && iDataBufferSize < KMaxObjectSize );

  1059     

  1060     TRACE_FUNC_EXIT;

  1061     }

  1062     

  1063 // -----------------------------------------------------------------------------

  1064 // CSConSBEClient::ProcessGetDataOwnerStatusL()

  1065 // Executes GetDataOwnerStatus task

  1066 // -----------------------------------------------------------------------------

  1067 //  

  1068 void CSConSBEClient::ProcessGetDataOwnerStatusL()

  1069     {

  1070     TRACE_FUNC_ENTRY;

  1071     

  1072     //If restore-mode, call AllSystemFilesRestored()

  1073     if( iRestoreMode )

  1074         {

  1075         LOGGER_WRITE( "CSConSBEClient::ProcessGetDataOwnerStatusL() : iSBEClient->AllSystemFilesRestored() start" );

  1076         iSBEClient->AllSystemFilesRestored();

  1077         LOGGER_WRITE( "CSConSBEClient::ProcessGetDataOwnerStatusL() : iSBEClient->AllSystemFilesRestored() end" );

  1078         }

  1079     

  1080     RSIDStatusArray sidStatus;

  1081     CleanupClosePushL(sidStatus);

  1082         

  1083     for( TInt i = 0; i < iCurrentTask->iGetDataOwnerParams->iDataOwners.Count();

  1084      i++ )

  1085         {

  1086         CSConDataOwner* dataOwner = 

  1087             iCurrentTask->iGetDataOwnerParams->iDataOwners[i];

  1088         TSecureId sid( dataOwner->iUid );

  1089         TDataOwnerStatus dataOwnerStatus = EUnset;

  1090         TInt dataOwnerError = 0;

  1091         

  1092         TDataOwnerAndStatus dataOwnerAndStatus( sid, dataOwnerStatus, 

  1093             dataOwnerError );

  1094                 

  1095         sidStatus.Append( dataOwnerAndStatus );

  1096         }

  1097     

  1098     iSBEClient->SIDStatusL( sidStatus );

  1099     

  1100     for( TInt j = 0; j < sidStatus.Count(); j++ )

  1101         {

  1102         switch( sidStatus[j].iStatus )

  1103             {

  1104             case EUnset :

  1105                 iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->

  1106                 iDataOwnStatus = ESConUnset;

  1107                 break;

  1108             case EDataOwnerNotFound :

  1109                 iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->

  1110                 iDataOwnStatus = ESConNotFound;

  1111                 break;

  1112             case EDataOwnerReady :

  1113                 iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->

  1114                 iDataOwnStatus = ESConReady;

  1115                 break;

  1116             case EDataOwnerNotReady :

  1117                 iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->

  1118                 iDataOwnStatus = ESConNotReady;

  1119                 break;

  1120             case EDataOwnerFailed :

  1121                 iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->

  1122                 iDataOwnStatus = ESConFailed;

  1123                 break;

  1124             case EDataOwnerNotConnected :

  1125                 iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->

  1126                 iDataOwnStatus = ESConNotConnected;

  1127                 break;

  1128             case EDataOwnerReadyNoImpl :

  1129                 iCurrentTask->iGetDataOwnerParams->iDataOwners[j]->

  1130                 iDataOwnStatus = ESConNotImplemented;

  1131                 break;

  1132             default :

  1133                 break;

  1134             }