1 /*

     2 * Copyright (c) 2005-2008 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: CMMCScBkupDataOwnerCollection implementation

    15 *

    16 *

    17 */

    18 

    19 #include "CMMCScBkupDataOwnerCollection.h"

    20 

    21 // User includes

    22 #include "MMCScBkupLogger.h"

    23 #include "TMMCScBkupDriveAndSize.h"

    24 #include "CMMCScBkupDataOwnerInfo.h"

    25 #include "MMCScBkupSBEUtils.h"

    26 #include "MMMCScBkupDriver.h"

    27 #include "CMMCScBkupDriveDataSizeManager.h"

    28 #include "RMMCScBkupProgressSizer.h"

    29 #ifdef RD_FILE_MANAGER_BACKUP

    30 #include "CMMCScBkupArchiveInfo.h"

    31 #include "BkupEngine.hrh"

    32 #endif

    33 

    34 // Constants

    35 const TInt KMMCScBkupDataOwnerGranularity = 20;

    36 

    37 

    38 

    39 

    40 // ========================= MEMBER FUNCTIONS ================================

    41 

    42 // ---------------------------------------------------------------------------

    43 // CMMCScBkupDataOwnerCollection::CMMCScBkupDataOwnerCollection()

    44 // 

    45 // C++ constructor.

    46 // ---------------------------------------------------------------------------

    47 CMMCScBkupDataOwnerCollection::CMMCScBkupDataOwnerCollection( MMMCScBkupDriver& aDriver, TBitFlags aCategory )

    48 :   iDriver( aDriver ), iOwners(KMMCScBkupDataOwnerGranularity), iCategory( aCategory )

    49     {

    50     }

    51 

    52 // ---------------------------------------------------------------------------

    53 // CMMCScBkupDataOwnerCollection::~CMMCScBkupDataOwnerCollection()

    54 // 

    55 // Destructor.

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

    57 CMMCScBkupDataOwnerCollection::~CMMCScBkupDataOwnerCollection()

    58     {

    59     Reset();

    60     iOwners.Close();

    61     delete iRestoreSizer;

    62     }

    63 

    64 

    65 // ---------------------------------------------------------------------------

    66 // CMMCScBkupDataOwnerCollection::ConstructL()

    67 // 

    68 // 

    69 // ---------------------------------------------------------------------------

    70 void CMMCScBkupDataOwnerCollection::ConstructL()

    71     {

    72     // The restore sizer data type is not relevant. It holds

    73     // the combined disk space requirements for all drives

    74     // for all data types. 

    75     iRestoreSizer = CMMCScBkupDriveSizer::NewLC( EMMCScBkupOwnerDataTypeAny );

    76     CleanupStack::Pop( iRestoreSizer );

    77     }

    78 

    79 

    80 // ---------------------------------------------------------------------------

    81 // CMMCScBkupDataOwnerCollection::NewL()

    82 // 

    83 // 

    84 // ---------------------------------------------------------------------------

    85 CMMCScBkupDataOwnerCollection* CMMCScBkupDataOwnerCollection::NewL( MMMCScBkupDriver& aDriver, TBitFlags aCategory )

    86     {

    87     CMMCScBkupDataOwnerCollection* self = new(ELeave) CMMCScBkupDataOwnerCollection( aDriver, aCategory );

    88     CleanupStack::PushL(self);

    89     self->ConstructL();

    90     CleanupStack::Pop(self);

    91     return self;

    92     }

    93 

    94 

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

    96 // CMMCScBkupDataOwnerCollection::AssignL()

    97 // 

    98 // 

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

   100 #ifdef RD_FILE_MANAGER_BACKUP

   101 TBool CMMCScBkupDataOwnerCollection::AssignL( const CMMCScBkupDataOwnerInfo& dataOwnerInfo )

   102     {

   103     const CMMCScBkupArchiveInfo& archive = iDriver.DrvParamsBase().ArchiveInfo( Category() );

   104     const RArray<TSecureId>& secureIds = archive.SIDs( Category() );

   105     const RArray<TSecureId>& excludedSecureIds = archive.ExcludedSIDs( Category() );

   106     TBitFlags flags = archive.SpecialFlags();

   107     TBitFlags excludedFlags = archive.ExcludedSpecialFlags();

   108 

   109     // Check whether data owner belongs to this category

   110     if( BelongsToL( dataOwnerInfo, flags, excludedFlags, secureIds, excludedSecureIds) )

   111         {

   112         iOwners.AppendL(&dataOwnerInfo);

   113         return ETrue;

   114         }

   115     

   116     return EFalse;

   117     }

   118 #else

   119 void CMMCScBkupDataOwnerCollection::AssignL( RDataOwnerInfoArray& aArray )

   120     {

   121     const TInt count = aArray.Count();

   122     //

   123     for(TInt i=count-1; i>=0; i--)

   124         {

   125         // Ownership is immediately transferred to the backup owner info object

   126         // so we should remove it from the array prior to passing into NewLC

   127         conn::CDataOwnerInfo* sbDataOwner = aArray[i];

   128         aArray.Remove(i); // Ensures it won't be deleted twice

   129         //

   130         CMMCScBkupDataOwnerInfo* info = CMMCScBkupDataOwnerInfo::NewLC( sbDataOwner );

   131         iOwners.AppendL(info);

   132         CleanupStack::Pop(info);

   133         }

   134     }

   135 #endif

   136 

   137 // ---------------------------------------------------------------------------

   138 // CMMCScBkupDataOwnerCollection::AppendL()

   139 // 

   140 // 

   141 // ---------------------------------------------------------------------------

   142 void CMMCScBkupDataOwnerCollection::AppendL( CMMCScBkupDataOwnerInfo* aNewEntry )

   143     {

   144     iOwners.AppendL( aNewEntry );

   145     }

   146 

   147 

   148 // ---------------------------------------------------------------------------

   149 // CMMCScBkupDataOwnerCollection::Count()

   150 // 

   151 // 

   152 // ---------------------------------------------------------------------------

   153 TInt CMMCScBkupDataOwnerCollection::Count() const

   154     {

   155     return iOwners.Count();

   156     }

   157 

   158 

   159 // ---------------------------------------------------------------------------

   160 // CMMCScBkupDataOwnerCollection::Owner()

   161 // 

   162 // 

   163 // ---------------------------------------------------------------------------

   164 CMMCScBkupDataOwnerInfo& CMMCScBkupDataOwnerCollection::Owner(TInt aIndex)

   165     {

   166     CMMCScBkupDataOwnerInfo* info = iOwners[aIndex];

   167     return *info;

   168     }

   169 

   170 

   171 // ---------------------------------------------------------------------------

   172 // CMMCScBkupDataOwnerCollection::Owner()

   173 // 

   174 // 

   175 // ---------------------------------------------------------------------------

   176 const CMMCScBkupDataOwnerInfo& CMMCScBkupDataOwnerCollection::Owner(TInt aIndex) const

   177     {

   178     const CMMCScBkupDataOwnerInfo* info = iOwners[aIndex];

   179     return *info;

   180     }

   181 

   182 

   183 // ---------------------------------------------------------------------------

   184 // CMMCScBkupDataOwnerCollection::OwnerL()

   185 // 

   186 // 

   187 // ---------------------------------------------------------------------------

   188 CMMCScBkupDataOwnerInfo& CMMCScBkupDataOwnerCollection::OwnerL( TSecureId aSID )

   189     {

   190     TInt index = KErrNotFound;

   191     CMMCScBkupDataOwnerInfo* ret = CMMCScBkupDataOwnerInfo::New( aSID );

   192     if  (ret)

   193         {

   194         TIdentityRelation<CMMCScBkupDataOwnerInfo> relation(CMMCScBkupDataOwnerInfo::CompareDataOwnerBySIDL);

   195         index = iOwners.Find( ret, relation );

   196         delete ret;

   197         ret = NULL;

   198         }

   199     //

   200     if  (index >= 0)

   201         {

   202         ret = iOwners[index];

   203         }

   204     else

   205         {

   206         User::Leave(KErrNotFound);

   207         }

   208     //

   209     return *ret;

   210     }

   211 

   212 

   213 // ---------------------------------------------------------------------------

   214 // CMMCScBkupDataOwnerCollection::OwnerL()

   215 // 

   216 // 

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

   218 const CMMCScBkupDataOwnerInfo& CMMCScBkupDataOwnerCollection::OwnerL( TSecureId aSID ) const

   219     {

   220     CMMCScBkupDataOwnerCollection& self = *const_cast<CMMCScBkupDataOwnerCollection*>(this);

   221     CMMCScBkupDataOwnerInfo& ret = self.OwnerL( aSID );

   222     return ret;

   223     }

   224 

   225 

   226 // ---------------------------------------------------------------------------

   227 // CMMCScBkupDataOwnerCollection::OwnerL()

   228 // 

   229 // 

   230 // ---------------------------------------------------------------------------

   231 CMMCScBkupDataOwnerInfo& CMMCScBkupDataOwnerCollection::OwnerL( TUid aPackageId )

   232     {

   233     CMMCScBkupDataOwnerInfo* ret = NULL;

   234     const TInt count = iOwners.Count();

   235     //

   236     for(TInt i=0; i<count; i++)

   237         {

   238         CMMCScBkupDataOwnerInfo* entry = iOwners[ i ];

   239         //

   240         const TUid packageId = MMCScBkupSBEUtils::PackageIdFromGenericL( entry->Owner().Identifier() );

   241         if  ( packageId == aPackageId )

   242             {

   243             ret = entry;

   244             }

   245         }

   246     //

   247     if  ( !ret )

   248         {

   249         User::Leave(KErrNotFound);

   250         }

   251     //

   252     return *ret;

   253     }

   254 

   255 

   256 // ---------------------------------------------------------------------------

   257 // CMMCScBkupDataOwnerCollection::OwnerL()

   258 // 

   259 // 

   260 // ---------------------------------------------------------------------------

   261 const CMMCScBkupDataOwnerInfo& CMMCScBkupDataOwnerCollection::OwnerL( TUid aPackageId ) const

   262     {

   263     CMMCScBkupDataOwnerCollection& self = *const_cast<CMMCScBkupDataOwnerCollection*>(this);

   264     CMMCScBkupDataOwnerInfo& ret = self.OwnerL( aPackageId );

   265     return ret;

   266     }

   267 

   268 

   269 // ---------------------------------------------------------------------------

   270 // CMMCScBkupDataOwnerCollection::OwnerL()

   271 // 

   272 // 

   273 // ---------------------------------------------------------------------------

   274 CMMCScBkupDataOwnerInfo& CMMCScBkupDataOwnerCollection::OwnerL( const TDesC& aHash )

   275     {

   276     CMMCScBkupDataOwnerInfo* ret = NULL;

   277     const TInt count = iOwners.Count();

   278     //

   279     for(TInt i=0; i<count; i++)

   280         {

   281         CMMCScBkupDataOwnerInfo* entry = iOwners[ i ];

   282         

   283         // Check if its a java item...

   284         const TSBDerivedType type = entry->Owner().Identifier().DerivedTypeL();

   285         if  ( type == EJavaDerivedType || type == EJavaTransferDerivedType )

   286             {

   287             // Get hash

   288             HBufC* hash = MMCScBkupSBEUtils::JavaHashFromGenericLC( entry->Owner().Identifier() );

   289             const TBool foundMatch = ( *hash == aHash );

   290             CleanupStack::PopAndDestroy( hash );

   291 

   292             if  ( foundMatch )

   293                 {

   294                 ret = entry;

   295                 break;

   296                 }

   297             }

   298         }

   299     //

   300     if  ( !ret )

   301         {

   302         User::Leave(KErrNotFound);

   303         }

   304     //

   305     return *ret;

   306     }

   307 

   308 

   309 // ---------------------------------------------------------------------------

   310 // CMMCScBkupDataOwnerCollection::OwnerL()

   311 // 

   312 // 

   313 // ---------------------------------------------------------------------------

   314 const CMMCScBkupDataOwnerInfo& CMMCScBkupDataOwnerCollection::OwnerL( const TDesC& aHash ) const

   315     {

   316     CMMCScBkupDataOwnerCollection& self = *const_cast<CMMCScBkupDataOwnerCollection*>(this);

   317     CMMCScBkupDataOwnerInfo& ret = self.OwnerL( aHash );

   318     return ret;

   319     }

   320 

   321 

   322 // ---------------------------------------------------------------------------

   323 // CMMCScBkupDataOwnerCollection::Remove()

   324 // 

   325 // 

   326 // ---------------------------------------------------------------------------

   327 void CMMCScBkupDataOwnerCollection::Remove( TInt aIndex )

   328     {

   329     CMMCScBkupDataOwnerInfo* info = iOwners[aIndex];

   330     delete info;

   331     iOwners.Remove(aIndex);

   332     }

   333 

   334 

   335 // ---------------------------------------------------------------------------

   336 // CMMCScBkupDataOwnerCollection::Reset()

   337 // 

   338 // 

   339 // ---------------------------------------------------------------------------

   340 void CMMCScBkupDataOwnerCollection::Reset()

   341     {

   342     iOwners.ResetAndDestroy();

   343     }

   344 

   345 

   346 // ---------------------------------------------------------------------------

   347 // CMMCScBkupDataOwnerCollection::TotalOperationalSizeL()

   348 // 

   349 // 

   350 // ---------------------------------------------------------------------------

   351 TInt64 CMMCScBkupDataOwnerCollection::TotalOperationalSizeL() const

   352     {

   353     RMMCScBkupProgressSizer sizer( iDriver.DrvParamsBase().DriveAndOperations() );

   354     TInt64 size = 0;

   355     //

   356     const TInt count = Count();

   357     for(TInt i=0; i<count; i++)

   358         {

   359         const CMMCScBkupDataOwnerInfo& owner = Owner( i );

   360         //

   361         const TInt64 restoreSizeForDO = sizer.RestoreCombinedDataSizeL( owner );

   362 

   363         __LOG2("CMMCScBkupDataOwnerCollection::TotalOperationalSizeL() - data transfer amount required for DO: 0x%08x is: %8Ld", owner.SecureId().iId, restoreSizeForDO );

   364 

   365         size += restoreSizeForDO;

   366         }

   367     //

   368     return size;

   369     }

   370 

   371 

   372 // ---------------------------------------------------------------------------

   373 // CMMCScBkupDataOwnerCollection::RebootRequired()

   374 // 

   375 // 

   376 // ---------------------------------------------------------------------------

   377 TBool CMMCScBkupDataOwnerCollection::RebootRequired() const

   378     {

   379     TBool rebootRequired = EFalse;

   380     //

   381     const TInt count = iOwners.Count();

   382     for(TInt i=count-1; i>=0; i--)

   383         {

   384         // We check the SBE's common settings (for each Data Owner) to identify

   385         // if a reboot is required. So long as one data owner requires a

   386         // reboot, then we must reset the machine.. hence we break

   387         // out of the loop immediately.

   388         const CMMCScBkupDataOwnerInfo& info = *iOwners[i];

   389         const CDataOwnerInfo& sbeDataOwnerInfo = info.Owner();

   390         //

   391         if  ( sbeDataOwnerInfo.CommonSettings() & ERequiresReboot )

   392             {

   393             rebootRequired = ETrue;

   394             break;

   395             }

   396         }

   397     //

   398     return rebootRequired;

   399     }

   400 

   401 

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

   403 // CMMCScBkupDataOwnerCollection::DiskSpaceRequiredForRestore()

   404 // 

   405 // 

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

   407 TInt64 CMMCScBkupDataOwnerCollection::DiskSpaceRequiredForRestore( TDriveNumber aDrive ) const

   408     {

   409     return iRestoreSizer->Size( aDrive );

   410     }

   411 

   412 

   413 // ---------------------------------------------------------------------------

   414 // CMMCScBkupDataOwnerCollection::CalculateDiskSpaceRequiredForRestoreL()

   415 // 

   416 // 

   417 // ---------------------------------------------------------------------------

   418 void CMMCScBkupDataOwnerCollection::CalculateDiskSpaceRequiredForRestoreL()

   419     {

   420     iRestoreSizer->Reset();

   421     //

   422     RArray<TMMCScBkupDriveAndSize> driveSizes;

   423     CleanupClosePushL( driveSizes );

   424     //

   425     const TInt count = iOwners.Count();

   426     for(TInt i=count-1; i>=0; i--)

   427         {

   428         const CMMCScBkupDataOwnerInfo& owner = *iOwners[i];

   429         __LOG(" ");

   430         __LOG1("CMMCScBkupDataOwnerCollection::CalculateDiskSpaceRequiredForRestoreL() - owner: 0x%08x...", owner.SecureId().iId);

   431         //

   432         owner.OperationalSizesL( driveSizes );

   433         //

   434         const TInt driveSizesCount = driveSizes.Count();

   435         for( TInt j=0; j<driveSizesCount; j++ )

   436             {

   437             const TMMCScBkupDriveAndSize& entry = driveSizes[ j ];

   438             __LOG2("CMMCScBkupDataOwnerCollection::CalculateDiskSpaceRequiredForRestoreL() -    drive: %c:, size: %8Ld", entry.Drive() + 'A', entry.Size());

   439             //

   440             iRestoreSizer->AddToSizeL( entry.Size(), entry.Drive() );

   441             }

   442         }

   443     //

   444     CleanupStack::PopAndDestroy( &driveSizes );

   445 

   446 #ifdef __MMCSCBKUPLOGGING_ENABLED__

   447     __LOG(" ");

   448     __LOG(" ");

   449     __LOG(" ");

   450     __LOG(" ");

   451     __LOG("CMMCScBkupDataOwnerCollection::CalculateDiskSpaceRequiredForRestoreL() - SUMMARY:");

   452     __LOG(" ");

   453 

   454     for( TInt d = EDriveA; d<=EDriveZ; d++ )

   455         {

   456         // Get the size of each data type for this drive.

   457         const TDriveNumber drive = static_cast< TDriveNumber >( d );

   458         const TInt64 size = DiskSpaceRequiredForRestore( drive );

   459 

   460         if  ( size > 0 )

   461             {

   462             __LOG2("CMMCScBkupDataOwnerCollection::CalculateDiskSpaceRequiredForRestoreL() - %8Ld bytes required for drive: %c:", size, drive + 'A' );

   463             }

   464         }

   465 #endif

   466     }

   467 

   468 #ifdef RD_FILE_MANAGER_BACKUP

   469 // ---------------------------------------------------------------------------

   470 // CMMCScBkupDataOwnerCollection::BelongsToL()

   471 // 

   472 // 

   473 // ---------------------------------------------------------------------------

   474 TBool CMMCScBkupDataOwnerCollection::BelongsToL(const CMMCScBkupDataOwnerInfo& aInfo, 

   475     TBitFlags aFlags, TBitFlags aExcludedFlags,

   476     const RArray<TSecureId> aSecureIds, const RArray<TSecureId> aExcludedSecureIds) const

   477     {

   478     // First of all check if data owner has system or java data. If it has and these

   479     // types have been declared as excluded data types, then skip owner in this catecory.

   480     // Public data is more common to data owners together with other data types meaning it

   481     // cannot be a reason to invalidate data owner. System's user data folder (e.g. C:\Data) files

   482     // are being skipped later on in public data backup phase if category is not EBUCatUserFiles

   483     // It would be possible to just skip excluded types per data owner, but it

   484     // might make data owner unstable after restore

   485 

   486     if( ((aExcludedFlags.Value() & EBUCatSpecSystem) && aInfo.HasSystemDataL()) ||

   487         ((aExcludedFlags.Value() & EBUCatSpecJava) && aInfo.HasJavaDataL()) ||

   488         ((aExcludedFlags.Value() & EBUCatSpecPublic) && aInfo.HasPublicDataL()) )

   489         {

   490         return EFalse;

   491         }

   492         

   493     // Then check whether all specified and SID not in list of excluded owners

   494     if( (aFlags.Value() & EBUCatSpecAll) )

   495         {

   496         TBool excluded = EFalse;

   497         

   498         for(TInt i = 0; i < aExcludedSecureIds.Count(); i++)

   499             {

   500             if(aInfo.SecureId().iId == aExcludedSecureIds[i].iId)

   501                 {

   502                 excluded = ETrue;

   503                 break;

   504                 }

   505             }

   506             

   507         return !excluded;

   508         }

   509     

   510     // Then check whether special rules apply

   511     if( ((aFlags.Value() & EBUCatSpecSystem) && aInfo.HasSystemDataL()) ||

   512         ((aFlags.Value() & EBUCatSpecJava) && aInfo.HasJavaDataL()) ||

   513         ((aFlags.Value() & EBUCatSpecPublic) && aInfo.HasPublicDataL()) )

   514         {

   515         return ETrue;

   516         }

   517         

   518     // Finally check whether SID matches

   519     for(TInt i = 0; i < aSecureIds.Count(); i++)

   520         {

   521         if(aInfo.SecureId().iId == aSecureIds[i].iId)

   522             {

   523             return ETrue;

   524             }

   525         }

   526         

   527     return EFalse;

   528     }

   529 #endif

   530 

   531 // ---------------------------------------------------------------------------

   532 // CMMCScBkupDataOwnerCollection::InternalizeL()

   533 // 

   534 // 

   535 // ---------------------------------------------------------------------------

   536 void CMMCScBkupDataOwnerCollection::InternalizeL( RReadStream& aStream )

   537     {

   538     aStream.ReadInt32L(); // EStreamFormatVersion1 

   539     aStream.ReadInt32L(); // spare1

   540     aStream.ReadInt32L(); // spare2

   541     aStream.ReadInt32L(); // spare3

   542 

   543     CMMCScBkupDriveSizer* restoreSizer = CMMCScBkupDriveSizer::NewLC( aStream );

   544     delete iRestoreSizer;

   545     iRestoreSizer = restoreSizer;

   546     CleanupStack::Pop( restoreSizer );

   547     }

   548 

   549 

   550 // ---------------------------------------------------------------------------

   551 // CMMCScBkupDataOwnerCollection::ExternalizeL()

   552 // 

   553 // 

   554 // ---------------------------------------------------------------------------

   555 void CMMCScBkupDataOwnerCollection::ExternalizeL( RWriteStream& aStream ) const

   556     {

   557     aStream.WriteInt32L( EStreamFormatVersion1 );

   558     aStream.WriteInt32L( 0 ); // spare1

   559     aStream.WriteInt32L( 0 ); // spare2

   560     aStream.WriteInt32L( 0 ); // spare3

   561 

   562     aStream << *iRestoreSizer;

   563     }

   564 

   565 

   566 

   567