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( const TInt aMaxObjectSize, RFs& aFs )

    39     {

    40     TRACE_FUNC;

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

    42     return self;

    43     }

    44     

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

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

    47 // Constructor

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

    49 //

    50 CSConSBEClient::CSConSBEClient( const TInt /*aMaxObjectSize*/, RFs& aFs ) : 

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

    52     {

    53     

    54     }

    55 

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

    57 // CSConSBEClient::~CSConSBEClient()

    58 // Initializes member data

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

    60 //  

    61 CSConSBEClient::~CSConSBEClient()

    62     {

    63     TRACE_FUNC_ENTRY;

    64     TInt err( KErrNone );

    65     

    66     if( !iBURModeNormal && iSBEClient )

    67         {

    68         TDriveList driveList;

    69         

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

    71             {

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

    73                 {

    74                 driveList.Append( KSConDriveExists );

    75                 }

    76             else

    77                 {

    78                 driveList.Append( KSConNoDrive );

    79                 }

    80             }

    81         

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

    83         }

    84     

    85     if( iSBEClient )

    86         {

    87         delete iSBEClient;

    88         iSBEClient = NULL;

    89         }

    90     

    91     delete iDataBuffer;

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

   267         case EListPublicFiles :

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

   269             TRAP( err, ProcessListPublicFilesL() );

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

   271             break;

   272         case EListDataOwners :

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

   274             TRAP( err, ProcessListDataOwnersL() );

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

   276             break;

   277         case EGetDataSize :

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

   279             TRAP( err, ProcessGetDataSizeL() );

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

   281             break;

   282         case ERequestData :

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

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

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

   286             break;  

   287         case EGetDataOwnerStatus :

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

   289             TRAP( err, ProcessGetDataOwnerStatusL() );

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

   291             break;

   292         case ESupplyData :

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

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

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

   296             break;

   297         default :

   298             err = KErrNotSupported;

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

   300             break;

   301         }

   302     

   303     if ( err )

   304         {

   305         HandleSBEErrorL( err );

   306         }

   307     else

   308         {

   309         err = ret;

   310         }

   311     User::RequestComplete( iCallerStatus, err );

   312             

   313     TRACE_FUNC_EXIT;

   314     }

   315     

   316 // -----------------------------------------------------------------------------

   317 // CSConSBEClient::ProcessSetBURModeL()

   318 // Executes SetBURMode task

   319 // -----------------------------------------------------------------------------

   320 //  

   321 void CSConSBEClient::ProcessSetBURModeL()

   322     {

   323     TRACE_FUNC_ENTRY;

   324     

   325     iAllSnapshotsSuppliedCalled = EFalse;

   326     iLastChunk = EFalse;

   327     

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

   329     

   330     TBURPartType partialType = EBURUnset;

   331     iRestoreMode = EFalse;

   332     

   333     switch( iCurrentTask->iBURModeParams->iPartialType )

   334         {

   335         case ESConBurNormal :

   336             partialType = EBURNormal;

   337             break;

   338         case ESConBurBackupFull :

   339             partialType = EBURBackupFull;

   340             break;

   341         case ESConBurBackupPartial :

   342             partialType = EBURBackupPartial;

   343             break;

   344         case ESConBurRestoreFull :

   345             partialType = EBURRestoreFull;

   346             iRestoreMode = ETrue;

   347             break;

   348         case ESConBurRestorePartial :

   349             partialType = EBURRestorePartial;

   350             iRestoreMode = ETrue;

   351             break;

   352         default :

   353             partialType = EBURUnset;

   354             break;

   355         }

   356     

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

   358         {

   359         // initialize buffer

   360         if ( !iDataBuffer )

   361             iDataBuffer = CBufFlat::NewL( KDataBufExpandSize );

   362         else

   363             iDataBuffer->Reset();

   364         iDataBufferSize=0;

   365         }

   366     else

   367         {

   368         delete iDataBuffer;

   369         iDataBuffer = 0;

   370         }

   371     

   372     TBackupIncType incType = ENoBackup;

   373     

   374     switch( iCurrentTask->iBURModeParams->iIncType )    

   375         {

   376         case ESConNoBackup :

   377             incType = ENoBackup;

   378             break;

   379         case ESConBackupBase :

   380             incType = EBackupBase;

   381             break;

   382         case ESConBackupIncrement :

   383             incType = EBackupIncrement;

   384             break;

   385         default :

   386             incType = ENoBackup;

   387             break;

   388         }

   389     

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

   391     

   392     if( partialType != EBURNormal )

   393         {

   394         iBURModeNormal = EFalse;

   395         }

   396     else

   397         {

   398         iBURModeNormal = ETrue;

   399         }

   400     TRACE_FUNC_EXIT;

   401     }

   402 

   403 // -----------------------------------------------------------------------------

   404 // CSConSBEClient::ProcessListPublicFilesL()

   405 // Executes ListPublicFiles task

   406 // -----------------------------------------------------------------------------

   407 //

   408 void CSConSBEClient::ProcessListPublicFilesL()

   409     {

   410     TRACE_FUNC_ENTRY;

   411     //Get the secure id

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

   413     TSecureId packageSid;

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

   415     TPtrC packageName(KNullDesC);

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

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

   418     

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

   420     

   421     if ( packageNameLength > KSConUidLength )

   422         {

   423         // remove uid from package name

   424         packageName.Set( 

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

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

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

   428         

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

   430                 iPackageName.Right( KSConUidLength ) );

   431         TLex lex(sidPtr);

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

   433         if ( err )

   434             {

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

   436             packageName.Set( KNullDesC );

   437             packageSid.iId = 0;

   438             }

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

   440         }

   441     

   442     //Get the drive list

   443     TDriveList driveList = 

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

   445     

   446     RFileArray files;

   447     CleanupClosePushL( files );

   448     //Go through all the drives in the list

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

   450         {

   451         if( driveList[i] )

   452             {

   453             //Get files from the drive

   454             TDriveNumber driveNumber = GetDriveNumber( i );

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

   456             

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

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

   459             CleanupStack::PushL( secureId );

   460             

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

   462             

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

   464                 {

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

   466                 User::LeaveIfError( err );

   467                 }

   468             

   469             CleanupStack::PopAndDestroy( secureId );

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

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

   472             

   473             if ( packageName.Length() > 0 )

   474                 {

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

   476                 

   477                 CSBPackageId* packageId = CSBPackageId::NewL(

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

   479                         packageSid,

   480                         packageName );

   481                 CleanupStack::PushL( packageId );

   482                 

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

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

   485                     {

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

   487                     User::LeaveIfError( err );

   488                     }

   489                 CleanupStack::PopAndDestroy( packageId );

   490                 

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

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

   493                 }

   494             

   495             files.Reset();

   496             }

   497         }

   498     CleanupStack::PopAndDestroy( &files );

   499     TRACE_FUNC_EXIT;

   500     }

   501 

   502     

   503 // -----------------------------------------------------------------------------

   504 // CSConSBEClient::ProcessListDataOwnersL()

   505 // Executes ListDataOwners task

   506 // -----------------------------------------------------------------------------

   507 //

   508 void CSConSBEClient::ProcessListDataOwnersL()

   509     {

   510     TRACE_FUNC_ENTRY;

   511     TBool includeToList( ETrue );

   512     RPointerArray<CDataOwnerInfo> dataOwners;

   513     RArray<TUid> packageArray;

   514     CleanupResetAndDestroyPushL( dataOwners );

   515     CleanupClosePushL( packageArray );

   516     

   517     iSBEClient->ListOfDataOwnersL( dataOwners );

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

   519     

   520     

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

   522         {

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

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

   525         CleanupStack::PushL( dataOwner );

   526         // default values

   527         TSecureId sid( 0 );

   528         includeToList = ETrue;

   529         

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

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

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

   533         

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

   535         if( commonOptions & EActiveBUR && commonOptions & EPassiveBUR )

   536             {

   537             dataOwner->iType = EHybridDataOwner;

   538             }       

   539         else if( commonOptions & EActiveBUR )

   540             {

   541             dataOwner->iType = EActiveDataOwner;

   542             }

   543         else if( commonOptions & EPassiveBUR )

   544             {

   545             dataOwner->iType = EPassiveDataOwner;

   546             }

   547                 

   548         //requires reboot? (common)

   549         if( commonOptions & ERequiresReboot )

   550             {

   551             dataOwner->iReqReboot = ETrue;

   552             }

   553         else

   554             {

   555             dataOwner->iReqReboot = EFalse;

   556             }

   557             

   558         //has system files? (common)

   559         if( commonOptions & EHasSystemFiles )

   560             {

   561             dataOwner->iHasFiles = ESystemFiles;

   562             }

   563             

   564         //supports selective? (common)

   565         if( commonOptions & ESupportsSelective )

   566             {

   567             dataOwner->iSupportsSel = ETrue;

   568             }

   569         else

   570             {

   571             dataOwner->iSupportsSel = EFalse;

   572             }

   573             

   574         //has public files? (passive)

   575         if( passiveOptions & EHasPublicFiles )

   576             {

   577             if( dataOwner->iHasFiles == ESystemFiles )

   578                 {

   579                 dataOwner->iHasFiles = EPublicSystemFiles;

   580                 }

   581             else

   582                 {

   583                 dataOwner->iHasFiles = EPublicFiles;    

   584                 }

   585             }

   586             

   587         //supports incremental? (active and passive)

   588         if( activeOptions & EActiveSupportsInc || 

   589                 passiveOptions & EPassiveSupportsInc  )

   590             {

   591             dataOwner->iSupportsInc = ETrue;

   592             }

   593         else

   594             {

   595             dataOwner->iSupportsInc = EFalse;

   596             }

   597             

   598         //delay to prepare data? (active)

   599         if( activeOptions & EDelayToPrepareData )

   600             {

   601             dataOwner->iDelayToPrep = ETrue;

   602             }

   603         else

   604             {

   605             dataOwner->iDelayToPrep = EFalse;

   606             }

   607             

   608         //fill drivelist

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

   610         //filter the drive list

   611         FilterDriveList( dataOwner->iDriveList );

   612                         

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

   614         TSBDerivedType derived = genericData->DerivedTypeL();

   615         

   616         if( derived == ESIDDerivedType )

   617             {

   618             //Uif of the data owner

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

   620             CleanupStack::PushL( secureId );

   621             sid = secureId->SecureIdL();

   622         

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

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

   625         

   626             CleanupStack::PopAndDestroy( secureId );

   627             }

   628         else if( derived == EPackageDerivedType )

   629             {

   630             //Package name and uid of the data owner

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

   632             CleanupStack::PushL( packageId );

   633         

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

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

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

   637             sid = packageId->SecureIdL();

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

   639             

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

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

   642             const TInt KSidFormatLength = 11;

   643             TBuf<KSidFormatLength> sidFormat;

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

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

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

   647                 {

   648                 dataOwner->iPackageName.Append( sidFormat );

   649                 }

   650             else

   651                 {

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

   653                 }

   654             

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

   656             if( sid )

   657                 {

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

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

   660                                         CSConSBEClient::Match ) != KErrNotFound )

   661                     {

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

   663                     //Don't include dataowner to list again

   664                     includeToList = EFalse;

   665                     }

   666                 else

   667                     {

   668                     //Store package's id for filtering

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

   670                     packageArray.Append( dataOwner->iUid ); 

   671                     }

   672                 }

   673             

   674             CleanupStack::PopAndDestroy( packageId );

   675             }

   676         else if( derived == EJavaDerivedType )

   677             {

   678             //Hash

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

   680             CleanupStack::PushL( javaId );

   681             

   682             //Initialize with hash data length and copy hash

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

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

   685             

   686             //For ConML: set as passive package

   687             dataOwner->iType = EPassiveDataOwner;

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

   689             

   690 #ifdef _DEBUG

   691             LOGGER_WRITE("EJavaDerivedType" );

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

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

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

   695 #endif

   696             

   697             CleanupStack::PopAndDestroy( javaId );

   698             }

   699         else

   700             {

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

   702             //Unknown type => ignore from list

   703             includeToList = EFalse;

   704             }

   705         

   706         if( includeToList ) 

   707             {

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

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

   710             CleanupStack::Pop( dataOwner );

   711             }

   712         

   713         if( sid )

   714             {

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

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

   717             CleanupStack::PushL( packageDataOwner );

   718             //Clear package name

   719             packageDataOwner->iPackageName = KNullDesC();

   720             //Add sid

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

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

   723             CleanupStack::Pop( packageDataOwner );

   724             }

   725         

   726         if( !includeToList )

   727             {

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

   729             CleanupStack::PopAndDestroy( dataOwner );

   730             }

   731         }

   732         

   733     packageArray.Reset();

   734     CleanupStack::PopAndDestroy( &packageArray );

   735     CleanupStack::PopAndDestroy( &dataOwners );

   736     TRACE_FUNC_EXIT;

   737     }

   738     

   739 // -----------------------------------------------------------------------------

   740 // CSConSBEClient::ProcessGetDataSizeL()

   741 // Executes GetDataSize task

   742 // -----------------------------------------------------------------------------

   743 //  

   744 void CSConSBEClient::ProcessGetDataSizeL()

   745     {

   746     TRACE_FUNC_ENTRY;

   747     

   748     if ( !iAllSnapshotsSuppliedCalled )

   749         {

   750         TInt err(KErrNone);

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

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

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

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

   755         iAllSnapshotsSuppliedCalled = ETrue;

   756         }

   757     

   758     

   759     TBool packageData( EFalse );

   760     

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

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

   763         i++ )

   764         {

   765         packageData = EFalse;

   766         CSConDataOwner* dataOwner = 

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

   768             

   769         TTransferDataType tdt( ERegistrationData );

   770         TPackageDataType pdt( ESystemData );

   771         

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

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

   774         switch( dataOwner->iTransDataType )

   775             {

   776             case ESConRegistrationData :

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

   778                 tdt = ERegistrationData;

   779                 break;

   780             case ESConPassiveSnapshotData :

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

   782                 tdt = EPassiveSnapshotData;

   783                 break;

   784             case ESConPassiveBaseData :

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

   786                 tdt = EPassiveBaseData;

   787                 break;

   788             case ESConPassiveIncrementalData :

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

   790                 tdt = EPassiveIncrementalData;

   791                 break;

   792             case ESConActiveSnapshotData :

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

   794                 tdt = EActiveSnapshotData;

   795                 break;

   796             case ESConActiveBaseData :

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

   798                 tdt = EActiveBaseData;

   799                 break;

   800             case ESConActiveIncrementalData :

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

   802                 tdt = EActiveIncrementalData;

   803                 break;

   804             case ESConSystemData :

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

   806                 pdt = ESystemData;

   807                 packageData = ETrue;

   808                 break;

   809             case ESConSystemSnapshotData :

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

   811                 pdt = ESystemSnapshotData;

   812                 packageData = ETrue;

   813                 break;

   814             default :

   815                 break;

   816             }

   817         

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

   819             {

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

   821             }

   822         else if( !dataOwner->iJavaHash )

   823             {

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

   825             }

   826         else

   827             {

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

   829                     dataOwner->iDriveList );

   830             }

   831         }

   832     

   833     TRACE_FUNC_EXIT;

   834     }

   835 

   836 

   837 // -----------------------------------------------------------------------------

   838 // CSConSBEClient::ProcessRequestDataL()

   839 // Executes RequestData task

   840 // -----------------------------------------------------------------------------

   841 //      

   842 TInt CSConSBEClient::ProcessRequestDataL()

   843     {

   844     TRACE_FUNC_ENTRY;

   845     TInt ret( KErrNone );

   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 

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

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

   924 

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

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

   927         

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

   929     if( !iLastChunk && iDataBufferSize < KMaxObjectSize ) 

   930         {

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

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

   933             {

   934             CSBPackageTransferType* ptt = CSBPackageTransferType::NewL(

   935                     uid, driveNumber, packageDataType );

   936             CleanupStack::PushL( ptt );

   937             

   938             RequestDataL( *ptt );

   939             

   940             CleanupStack::PopAndDestroy( ptt );

   941             }

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

   943             {

   944             CSBSIDTransferType* stt = CSBSIDTransferType::NewL(

   945                     sid, driveNumber, transferDataType );

   946             CleanupStack::PushL( stt );

   947             

   948             RequestDataL( *stt );

   949             

   950             CleanupStack::PopAndDestroy( stt );

   951             }

   952         else

   953             {

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

   955             CSBJavaTransferType* jtt( NULL );

   956             //When ESystemData is requested, request EJavaMIDlet

   957             if( packageDataType == ESystemData )

   958                 {

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

   960                 }

   961             //When EPassiveBaseData is requested, request EJavaMIDletData

   962             else if( transferDataType == EPassiveBaseData )

   963                 {

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

   965                 }

   966                         

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

   968                 {

   969                 CleanupStack::PushL( jtt );

   970                 

   971                 RequestDataL( *jtt );

   972                 

   973                 CleanupStack::PopAndDestroy( jtt );   

   974                 }

   975             else

   976                 {

   977                 //No data

   978                 iDataBuffer->Reset();

   979                 iDataBufferSize = 0;

   980                 iLastChunk = ETrue;

   981                 }

   982             }

   983         }

   984     

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

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

   987         

   988     

   989     

   990     if( iCurrentTask->iRequestDataParams->iBackupData )

   991         {

   992         delete iCurrentTask->iRequestDataParams->iBackupData;

   993         iCurrentTask->iRequestDataParams->iBackupData = NULL;

   994         }

   995     

   996     TInt dataToRead = KMaxObjectSize;

   997     if ( dataToRead > iDataBufferSize )

   998         dataToRead = iDataBufferSize;

   999     

  1000     //Initialize the task data buffer

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

  1002     //Get descriptor task's buffer

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

  1004     

  1005     

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

  1007     iDataBuffer->Delete(0, dataToRead);

  1008     iDataBufferSize -= dataToRead;

  1009     

  1010     if ( !iLastChunk || iDataBufferSize>0 )

  1011         {

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

  1013         iCurrentTask->iRequestDataParams->iMoreData = ETrue;

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

  1015         ret = KErrCompletion;

  1016         }

  1017     else

  1018         {

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

  1020         iDataBuffer->Reset();

  1021         iDataBufferSize = 0;

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

  1023         iLastChunk = EFalse;

  1024         }

  1025     

  1026         

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

  1028     return ret;

  1029     }

  1030 

  1031 void CSConSBEClient::RequestDataL( CSBGenericTransferType& aGenericTransferType )

  1032     {

  1033     TRACE_FUNC_ENTRY;

  1034     if ( !iDataBuffer )

  1035         User::Leave( KErrArgument );

  1036     

  1037     do

  1038         {

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

  1040         TRequestStatus status;

  1041         iSBEClient->RequestDataL( aGenericTransferType, status );

  1042         User::WaitForRequest( status );

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

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

  1045                     

  1046         //Get the data and store the handle

  1047         CSBGenericTransferType* gtt = NULL;

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

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

  1050         delete gtt;

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

  1052         iDataBuffer->Write(iDataBufferSize, dataPtr);

  1053         iDataBufferSize += dataPtr.Length();

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

  1055         }

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

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

  1058     

  1059     TRACE_FUNC_EXIT;

  1060     }

  1061     

  1062 // -----------------------------------------------------------------------------

  1063 // CSConSBEClient::ProcessGetDataOwnerStatusL()

  1064 // Executes GetDataOwnerStatus task

  1065 // -----------------------------------------------------------------------------

  1066 //  

  1067 void CSConSBEClient::ProcessGetDataOwnerStatusL()

  1068     {

  1069     TRACE_FUNC_ENTRY;

  1070     

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

  1072     if( iRestoreMode )

  1073         {

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

  1075         iSBEClient->AllSystemFilesRestored();

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

  1077         }

  1078     

  1079     RSIDStatusArray sidStatus;

  1080     CleanupClosePushL(sidStatus);

  1081         

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

  1083      i++ )

  1084         {

  1085         CSConDataOwner* dataOwner = 

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

  1087         TSecureId sid( dataOwner->iUid );

  1088         TDataOwnerStatus dataOwnerStatus = EUnset;

  1089         TInt dataOwnerError = 0;

  1090         

  1091         TDataOwnerAndStatus dataOwnerAndStatus( sid, dataOwnerStatus, 

  1092             dataOwnerError );

  1093                 

  1094         sidStatus.Append( dataOwnerAndStatus );

  1095         }

  1096     

  1097     iSBEClient->SIDStatusL( sidStatus );

  1098     

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

  1100         {

  1101         switch( sidStatus[j].iStatus )

  1102             {

  1103             case EUnset :

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

  1105                 iDataOwnStatus = ESConUnset;

  1106                 break;

  1107             case EDataOwnerNotFound :

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

  1109                 iDataOwnStatus = ESConNotFound;

  1110                 break;

  1111             case EDataOwnerReady :

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

  1113                 iDataOwnStatus = ESConReady;

  1114                 break;

  1115             case EDataOwnerNotReady :

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

  1117                 iDataOwnStatus = ESConNotReady;

  1118                 break;

  1119             case EDataOwnerFailed :

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

  1121                 iDataOwnStatus = ESConFailed;

  1122                 break;

  1123             case EDataOwnerNotConnected :

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

  1125                 iDataOwnStatus = ESConNotConnected;

  1126                 break;

  1127             case EDataOwnerReadyNoImpl :

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

  1129                 iDataOwnStatus = ESConNotImplemented;

  1130                 break;

  1131             default :

  1132                 break;

  1133             }

  1134         }