1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/centralrepository/cenrepsrv/backup.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,897 @@
1.4 +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32def.h>
1.20 +#include <e32property.h>
1.21 +#include <s32file.h>
1.22 +#include <connect/sbdefs.h>
1.23 +#include "srvres.h"
1.24 +#include "cachemgr.h"
1.25 +#include "srvparams.h"
1.26 +#include "shrepos.h"
1.27 +#include "sessnotf.h"
1.28 +#include "backup.h"
1.29 +
1.30 +#define UNUSED_VAR(a) a = a
1.31 +
1.32 +_LIT (KBackupFileName, "BACKUP") ;
1.33 +_LIT (KRestoreFileName, "RESTORE") ;
1.34 +_LIT(KBackupFileExt, ".bak");
1.35 +_LIT(KRestoreFileExt, ".rst");
1.36 +
1.37 +
1.38 +TRepositoryBackupState CRepositoryBackupClient::iBackupStatus ;
1.39 +
1.40 +
1.41 +//
1.42 +// Backup stream index class - Used to hold association between a UID (in
1.43 +// our case the UID of a repository) and a stream ID - Can't use CStreamDictionary
1.44 +// because that only lets you retrieve stream IDs by a (previously known) UID rather
1.45 +// than iterate through its contentsretrieving UID/StreamID pairs...
1.46 +//
1.47 +
1.48 +
1.49 +//
1.50 +// CRepositoryBackupStreamIndex::AddL
1.51 +//
1.52 +// Add a new repository UID and stream ID pair to the index
1.53 +void CRepositoryBackupStreamIndex::AddL(TUid aUid, TStreamId aSettingStreamId, TStreamId aDeletedSettingsStreamId, TStreamId aInstalledSettingsStreamId)
1.54 + {
1.55 + TRepositoryBackupStreamIndexElement newIndexElement;
1.56 + newIndexElement.Set(aUid,aSettingStreamId, aDeletedSettingsStreamId, aInstalledSettingsStreamId) ;
1.57 + iStreamIndex.AppendL(newIndexElement);
1.58 + }
1.59 +
1.60 +
1.61 +//
1.62 +// CRepositoryBackupStreamIndex::GetNext
1.63 +//
1.64 +// Iterate through the index retrieving the next Reposirory UID and Stream ID
1.65 +// pair.
1.66 +//
1.67 +TInt CRepositoryBackupStreamIndex::GetNext(TUid& aUid, TStreamId& aSettingsStreamId, TStreamId& aDeletedSettingsStreamId, TStreamId& aInstalledSettingsStreamId)
1.68 + {
1.69 + TInt error = KErrNone ;
1.70 + if (iIndex < iStreamIndex.Count())
1.71 + {
1.72 + iStreamIndex[iIndex++].Get(aUid, aSettingsStreamId, aDeletedSettingsStreamId, aInstalledSettingsStreamId) ;
1.73 + }
1.74 + else
1.75 + {
1.76 + error = KErrNotFound ;
1.77 + }
1.78 + return error ;
1.79 + }
1.80 +
1.81 +
1.82 +//
1.83 +// Backup client class.
1.84 +//
1.85 +// Has Active object functionality to monitor the state of the publish and subscribe
1.86 +// flags associated with backup and restore and also implements MActiveBackupDataClient
1.87 +// to perform active backup according to the "proxy data holder" model.
1.88 +//
1.89 +
1.90 +
1.91 +
1.92 +//
1.93 +// Usual 2 phase construction factory NewL NewLC classes
1.94 +//
1.95 +CRepositoryBackupClient* CRepositoryBackupClient::NewLC(RFs& aFs)
1.96 + {
1.97 + CRepositoryBackupClient* me = new(ELeave)CRepositoryBackupClient(aFs);
1.98 + CleanupStack::PushL(me) ;
1.99 + me->ConstructL() ;
1.100 + return me ;
1.101 + }
1.102 +
1.103 +
1.104 +CRepositoryBackupClient* CRepositoryBackupClient::NewL(RFs& aFs)
1.105 + {
1.106 + CRepositoryBackupClient* me = CRepositoryBackupClient::NewLC(aFs) ;
1.107 + CleanupStack::Pop(me) ;
1.108 + return me ;
1.109 + }
1.110 +
1.111 +
1.112 +
1.113 +//
1.114 +// Constructor - doesn't really do anything!
1.115 +//
1.116 +CRepositoryBackupClient::CRepositoryBackupClient(RFs& aFs) : CActive(EPriorityStandard), iFs(aFs), iRomScanDone(EFalse)
1.117 + {
1.118 + }
1.119 +
1.120 +
1.121 +//
1.122 +// Phase 2 constructor
1.123 +//
1.124 +void CRepositoryBackupClient::ConstructL()
1.125 + {
1.126 + // Create repository object
1.127 + iRepository = new(ELeave) CServerRepository;
1.128 +
1.129 + // Notifier needed to open repositories.
1.130 + iNotifier = new(ELeave)CSessionNotifier ;
1.131 +
1.132 + // Attach to Backup/Restore Pub/Sub property.
1.133 + User::LeaveIfError(iBackupRestoreProperty.Attach(KUidSystemCategory, KUidBackupRestoreKey)) ;
1.134 +
1.135 + // Add ourself to the active scheduler
1.136 + CActiveScheduler::Add(this) ;
1.137 +
1.138 + // Initialise backup/restore status
1.139 + iBackupStatus = ENoBackupActivty ;
1.140 +
1.141 + // Set active and request notification of changes to backup/restore
1.142 + // Pub/Sub property.
1.143 + StartL() ;
1.144 + }
1.145 +
1.146 +
1.147 +
1.148 +//
1.149 +// Destructor
1.150 +//
1.151 +CRepositoryBackupClient::~CRepositoryBackupClient()
1.152 + {
1.153 + Cancel();
1.154 +
1.155 + iBackupRestoreProperty.Close() ;
1.156 +
1.157 + if (iRepository)
1.158 + {
1.159 + iRepository->Close();
1.160 + delete(iRepository);
1.161 + }
1.162 +
1.163 + if (iNotifier)
1.164 + delete(iNotifier) ;
1.165 +
1.166 + if (iActiveBackupClient)
1.167 + delete(iActiveBackupClient) ;
1.168 +
1.169 + iRestoredRepositoriesArray.ResetAndDestroy();
1.170 + iRestoredRepositoriesArray.Close();
1.171 +
1.172 + iFile.Close();
1.173 + }
1.174 +
1.175 +
1.176 +
1.177 +
1.178 +//
1.179 +// DoCancel - mandatory for active objects.
1.180 +//
1.181 +void CRepositoryBackupClient::DoCancel()
1.182 + {
1.183 + iBackupRestoreProperty.Cancel() ;
1.184 + }
1.185 +
1.186 +
1.187 +
1.188 +//
1.189 +// RunError
1.190 +//
1.191 +TInt CRepositoryBackupClient::RunError(TInt aError)
1.192 + {
1.193 + iRestoredRepositoriesArray.ResetAndDestroy();
1.194 + UNUSED_VAR(aError);
1.195 + return KErrNone;
1.196 + }
1.197 +
1.198 +
1.199 +
1.200 +
1.201 +//
1.202 +// Test BUR Pub/Sub property set status, and notify BUR that we're
1.203 +// ready to go as appropriate.
1.204 +//
1.205 +void CRepositoryBackupClient::TestBURstatusL(void)
1.206 + {
1.207 + TInt BURstatus ;
1.208 + TRepositoryBackupState lastBackupStatus = ENoBackupActivty;
1.209 + if (iBackupRestoreProperty.Get(BURstatus) != KErrNotFound)
1.210 + {
1.211 + BURstatus &= KBURPartTypeMask ;
1.212 + switch (BURstatus)
1.213 + {
1.214 + case EBURUnset: // State not yet set. Treat as no backup/restore in progress.
1.215 + case EBURNormal:
1.216 + // No backup or restore in progress. Probably
1.217 + // means we've just completed an operation?
1.218 +
1.219 + lastBackupStatus = iBackupStatus;
1.220 + iBackupStatus = ENoBackupActivty ;
1.221 +
1.222 + // Back to normal, so enable cache
1.223 + TServerResources::iCacheManager->EnableCache();
1.224 + // delete the CActiveBackupClient
1.225 + if (iActiveBackupClient)
1.226 + {
1.227 + delete iActiveBackupClient ;
1.228 + iActiveBackupClient = NULL ;
1.229 + }
1.230 +
1.231 + // Notify the changed keys if a restoration was just completed
1.232 + if((lastBackupStatus == ERestoreInProgress))
1.233 + {
1.234 + for(TInt i = 0; i < iRestoredRepositoriesArray.Count(); i++)
1.235 + {
1.236 + iRepository->OpenL(iRestoredRepositoriesArray[i]->Uid(), *iNotifier, EFalse);
1.237 + iRepository->RestoreNotify(*iRestoredRepositoriesArray[i]);
1.238 + iRepository->Close();
1.239 + }
1.240 + iRestoredRepositoriesArray.ResetAndDestroy();
1.241 + }
1.242 +
1.243 + break ;
1.244 +
1.245 + case EBURBackupFull :
1.246 + case EBURBackupPartial :
1.247 + // We don't distinguish between full and partial backups
1.248 + // as the Backup engine will give us UIDs for all the
1.249 + // repository data owners that want their stuff backed up
1.250 + // anyway.
1.251 +
1.252 + // We don't want cache activity during backup
1.253 + TServerResources::iCacheManager->DisableCache();
1.254 +
1.255 + // Any (and all!) repositories which have been opened in the
1.256 + // course of system boot and normal operation will have been
1.257 + // added to TServerResources::iOwnerIdLookUpTable as they were
1.258 + // opened but there may well be repositories which need backing
1.259 + // up and haven't yet been opened so we need to make sure that
1.260 + // the lookup table is complete.
1.261 + CompleteOwnerIdLookupTableL();
1.262 +
1.263 + // Register with BUR engine
1.264 + if (!iActiveBackupClient)
1.265 + {
1.266 + iActiveBackupClient = CActiveBackupClient::NewL(this) ;
1.267 + }
1.268 + iActiveBackupClient->ConfirmReadyForBURL(KErrNone);
1.269 + iBackupStatus = EBackupInProgress ;
1.270 + break ;
1.271 +
1.272 + case EBURRestoreFull :
1.273 + case EBURRestorePartial :
1.274 + // We don't distinguish between full and partial restore
1.275 + // either!
1.276 +
1.277 + // We don't want cache activity during restore either!
1.278 + TServerResources::iCacheManager->DisableCache();
1.279 +
1.280 + // Register with BUR engine
1.281 + if (!iActiveBackupClient)
1.282 + {
1.283 + iActiveBackupClient = CActiveBackupClient::NewL(this) ;
1.284 + }
1.285 + iActiveBackupClient->ConfirmReadyForBURL(KErrNone);
1.286 + iBackupStatus = ERestoreInProgress ;
1.287 + break ;
1.288 +
1.289 + }
1.290 + }
1.291 + }
1.292 +
1.293 +
1.294 +//
1.295 +// Request notification of changes in BUR Pub/Sub status
1.296 +//
1.297 +void CRepositoryBackupClient::StartL()
1.298 + {
1.299 + if (!IsActive())
1.300 + {
1.301 + TestBURstatusL();
1.302 + NotifyChange();
1.303 + }
1.304 + }
1.305 +
1.306 +
1.307 +//
1.308 +// Request notification of changes in BUR Pub/Sub status
1.309 +//
1.310 +void CRepositoryBackupClient::NotifyChange()
1.311 + {
1.312 + // Watch for changes in the property state.
1.313 + iBackupRestoreProperty.Subscribe(iStatus) ;
1.314 + SetActive();
1.315 + }
1.316 +
1.317 +
1.318 +//
1.319 +// Handle changes of backup state through publish/subscribe
1.320 +//
1.321 +void CRepositoryBackupClient::RunL()
1.322 + {
1.323 + NotifyChange() ;
1.324 + TestBURstatusL();
1.325 + }
1.326 +
1.327 +
1.328 +//
1.329 +// We can't estimate data size without A) having the SID of the data owner who's data
1.330 +// is to be backed up and B) going through the whole process of preparing the backup.
1.331 +//
1.332 +// The only sensible thing we can do is return an arbitrary value!
1.333 +//
1.334 +TUint CRepositoryBackupClient::GetExpectedDataSize(TDriveNumber /* aDrive */)
1.335 + {
1.336 + return KArbitraryNumber ;
1.337 + }
1.338 +
1.339 +
1.340 +
1.341 +
1.342 +//
1.343 +// Called by BUR engine to request a chunk of backup data.
1.344 +//
1.345 +void CRepositoryBackupClient::GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinished)
1.346 + {
1.347 + const TInt chunkSize = aBuffer.MaxSize() ;
1.348 +
1.349 + aFinished = EFalse ;
1.350 +
1.351 + // Pass a chunk of our prepared backup data in aBuffer
1.352 + User::LeaveIfError(iFile.Read(aBuffer, chunkSize)) ;
1.353 + TInt bytesRead = aBuffer.Length() ;
1.354 +
1.355 + // Check to see if this was the last chunk of data.
1.356 + if (bytesRead < chunkSize)
1.357 + {
1.358 + // Set "finished" flag so that BUR knows we're through...
1.359 + aFinished = ETrue ;
1.360 +
1.361 + // ...and then tidy up by closing and deleting the backup file.
1.362 + iFile.Close() ;
1.363 + TParse backupFilePath ;
1.364 + User::LeaveIfError(backupFilePath.Set(KBackupFileName, TServerResources::iBURDirectory, &KBackupFileExt));
1.365 + TInt fileDeleteErr=iFs.Delete(backupFilePath.FullName()) ;
1.366 + #ifdef _DEBUG
1.367 + if (fileDeleteErr != KErrNone)
1.368 + {
1.369 + RDebug::Print(_L("CRepositoryBackupClient::GetBackupDataSectionL - Failed to delete file. Error = %d"), fileDeleteErr);
1.370 + }
1.371 + #else
1.372 + UNUSED_VAR(fileDeleteErr);
1.373 + #endif
1.374 +
1.375 + }
1.376 + }
1.377 +
1.378 +//
1.379 +// CRepositoryBackupClient::RestoreComplete
1.380 +//
1.381 +// Called when a Complete set of backup data has been received and written
1.382 +// to a file. We now need to open the file as a stream store, get the
1.383 +// index (list of repository UID and corresponding stream ID pairs, and then
1.384 +// reconstruct and save each repository in turn.
1.385 +//
1.386 +void CRepositoryBackupClient::RestoreComplete(TDriveNumber /* aDrive */)
1.387 + {
1.388 + }
1.389 +
1.390 +
1.391 +void CRepositoryBackupClient::RestoreRepositoryAndListL(TUid repositoryUid, CDirectFileStore* store, TStreamId settingsStreamId, TStreamId deletedSettingsStreamId, TInt& repIndex)
1.392 + {
1.393 + // Add the restored repository to the restored repositories list.
1.394 + // Pass its changed-keys list to further restoring functions to add entries for post-restoration notification.
1.395 + repIndex = AddRestoredRepositoryL(repositoryUid);
1.396 + iRepository->RestoreRepositoryContentsL(*store, settingsStreamId, deletedSettingsStreamId, *iRestoredRepositoriesArray[repIndex]);
1.397 + iRepository->CommitChangesL();
1.398 + }
1.399 +
1.400 +
1.401 +//
1.402 +// CRepositoryBackupClient::RestoreCompleteL
1.403 +//
1.404 +// Does the actual work of reconstructing repositories from backup data
1.405 +//
1.406 +//
1.407 +void CRepositoryBackupClient::RestoreCompleteL()
1.408 + {
1.409 + // All restore data recived so we can now recreate the repositories from the
1.410 + // backup store
1.411 + // Attempt to open the restore file as a CDirectFileStore
1.412 + TParse restoreFilePath ;
1.413 + User::LeaveIfError(restoreFilePath.Set(KRestoreFileName, TServerResources::iBURDirectory, &KRestoreFileExt));
1.414 + CDirectFileStore* store = CDirectFileStore::OpenLC (iFs,restoreFilePath.FullName(), EFileRead|EFileShareReadersOnly);
1.415 + if (store->Type()[0] != KDirectFileStoreLayoutUid)
1.416 + {
1.417 + // store wasn't quite what we were expecting - can't return an error, can't leave
1.418 + // so all we can do is close the file, tidy up as best we can, and bail out!!!!
1.419 + CleanupStack::PopAndDestroy(store);
1.420 + // If a debug build - record error
1.421 + TInt fileDeleteErr=iFs.Delete(restoreFilePath.FullName()) ;
1.422 + #ifdef _DEBUG
1.423 + if (fileDeleteErr != KErrNone)
1.424 + {
1.425 + RDebug::Print(_L("CRepositoryBackupClient::RestoreCompleteL - Failed to delete file. Error = %d"), fileDeleteErr);
1.426 + }
1.427 + #else
1.428 + UNUSED_VAR(fileDeleteErr);
1.429 + #endif
1.430 +
1.431 + User::Leave(KErrCorrupt);
1.432 + }
1.433 +
1.434 +
1.435 + // Get the root stream and attempt to read a backup file header from it
1.436 + TStreamId rootStreamId = store->Root() ;
1.437 + RStoreReadStream rootStream ;
1.438 + RStoreReadStream indexStream ;
1.439 + rootStream.OpenLC(*store, rootStreamId);
1.440 + TRepositoryBackupStreamHeader header ;
1.441 + TRAPD(err, header.InternalizeL(rootStream)) ;
1.442 +
1.443 + // Check for a valid header by checking that the UID matches the UID
1.444 + // of Central Repository and that the version number is sane.
1.445 + if (err == KErrNotSupported)
1.446 + {
1.447 + // Not a valid header - assume it's an old style backup stream,
1.448 + // set extensions supported to none, set index stream to be
1.449 + // root stream and reset read pointer to beginning.
1.450 + iBackupExtensionsSupported = ENoBackupExtensions ;
1.451 +
1.452 + CleanupStack::PopAndDestroy(&rootStream) ;
1.453 + CleanupStack::PopAndDestroy(store) ;
1.454 +
1.455 + // Try re-opening as old-style backup stream with index
1.456 + // as root stream.
1.457 + CDirectFileStore* store = CDirectFileStore::OpenLC (iFs,restoreFilePath.FullName(), EFileRead|EFileShareReadersOnly);
1.458 + indexStream.OpenLC(*store, rootStreamId) ;
1.459 + }
1.460 + else
1.461 + {
1.462 + // Got a valid header. Check for extensions supported by this
1.463 + // stream and get stream to read index from
1.464 + CleanupStack::PopAndDestroy(&rootStream) ;
1.465 + iBackupExtensionsSupported = header.getBackupExtensionsSupported();
1.466 + TStreamId indexStreamId = header.getIndexStreamId() ;
1.467 + indexStream.OpenLC (*store, indexStreamId) ;
1.468 + }
1.469 +
1.470 + CRepositoryBackupStreamIndex *restoreStreamIndex = CRepositoryBackupStreamIndex::NewLC();
1.471 + restoreStreamIndex->InternalizeL(indexStream, iBackupExtensionsSupported);
1.472 +
1.473 +
1.474 + // Iterate through index and attempt restore of each repository stream
1.475 + // we find in it.
1.476 + restoreStreamIndex->Reset();
1.477 + TUid repositoryUid;
1.478 + TStreamId settingsStreamId(KNullStreamIdValue);
1.479 + TStreamId deletedSettingsStreamId(KNullStreamIdValue);
1.480 + TStreamId installedSettingsStreamId(KNullStreamIdValue);
1.481 +
1.482 + while (restoreStreamIndex->GetNext(repositoryUid, settingsStreamId, deletedSettingsStreamId, installedSettingsStreamId) == KErrNone)
1.483 + {
1.484 + iRepository->OpenL(repositoryUid, *iNotifier, EFalse);
1.485 + iRepository->FailAllTransactions();
1.486 + TInt repIndex;
1.487 + TRAPD(err, RestoreRepositoryAndListL(repositoryUid, store, settingsStreamId, deletedSettingsStreamId, repIndex));
1.488 + iRepository->Close();
1.489 + User::LeaveIfError(err);
1.490 + // If the backup contains an installed repository containing default values for the settings, read them in
1.491 + if (installedSettingsStreamId != KNullStreamId)
1.492 + {
1.493 + // create an empty repository in install directory, and restore the data from backup file
1.494 + iRepository->RestoreInstallRepositoryL(repositoryUid, *store, installedSettingsStreamId, *iRestoredRepositoriesArray[repIndex]);
1.495 + // remove the .ini install file (if exists) because it will clash with the restored file
1.496 + TServerResources::DeleteCentrepFileL(repositoryUid, EInstall, EIni);
1.497 + }
1.498 + }
1.499 +
1.500 + CleanupStack::PopAndDestroy(restoreStreamIndex) ;
1.501 + CleanupStack::PopAndDestroy(&indexStream);
1.502 + CleanupStack::PopAndDestroy(store);
1.503 + // If a debug build - record error
1.504 + TInt fileDeleteErr=iFs.Delete(restoreFilePath.FullName());
1.505 + #ifdef _DEBUG
1.506 + if (fileDeleteErr != KErrNone)
1.507 + {
1.508 + RDebug::Print(_L("CRepositoryBackupClient::RestoreCompleteL (2nd) - Failed to delete file. Error = %d"), fileDeleteErr);
1.509 + }
1.510 + #else
1.511 + UNUSED_VAR(fileDeleteErr);
1.512 + #endif
1.513 +
1.514 + }
1.515 +
1.516 +//
1.517 +// CRepositoryBackupClient::CompleteOwnerIdLookupTableL
1.518 +//
1.519 +// Open each repository in TServerResources::iDataDirectory.
1.520 +// Save the Rep UID and Owner Id of the rep to be used by
1.521 +// InitialiseGetProxyBackupDataL.
1.522 +void CRepositoryBackupClient::CompleteOwnerIdLookupTableL()
1.523 + {
1.524 +
1.525 + // Read contents of persist, install, and ROM directories and
1.526 + // use them to build a list of repository candidates.
1.527 + RArray <TUint32> repositoryList ;
1.528 + CleanupClosePushL(repositoryList) ;
1.529 +
1.530 + for (TBackupDirectoryScan scanDir = EScanRom; scanDir <= EScanPersist; scanDir = (TBackupDirectoryScan)(scanDir+1))
1.531 + {
1.532 + TPtrC directoryName ;
1.533 + switch (scanDir)
1.534 + {
1.535 + case EScanRom :
1.536 + if (TServerResources::iRomDirectory)
1.537 + {
1.538 + directoryName.Set(TServerResources::iRomDirectory->Des()) ;
1.539 + }
1.540 + else
1.541 + {
1.542 + // if ROM directory doesn't exist or there are no files, skip scanning
1.543 + continue;
1.544 + }
1.545 + break ;
1.546 +
1.547 + case EScanInstall :
1.548 + directoryName.Set(TServerResources::iInstallDirectory->Des()) ;
1.549 + break ;
1.550 +
1.551 + case EScanPersist :
1.552 + directoryName.Set(TServerResources::iDataDirectory->Des()) ;
1.553 + break ;
1.554 + }
1.555 +
1.556 + RDir dir;
1.557 + CleanupClosePushL(dir);
1.558 + User::LeaveIfError(dir.Open(iFs, directoryName, KEntryAttNormal));
1.559 +
1.560 + TEntryArray dirEntries;
1.561 + TInt readError = KErrNone;
1.562 +
1.563 + while (readError != KErrEof)
1.564 + {
1.565 + readError = dir.Read(dirEntries);
1.566 +
1.567 + if(readError != KErrNone && readError != KErrEof)
1.568 + {
1.569 + User::Leave(readError);
1.570 + }
1.571 + else
1.572 + {
1.573 + const TInt dirCount = dirEntries.Count();
1.574 + for (TInt i=0; i<dirCount; i++)
1.575 + {
1.576 + // Attempt to extract a repository UID from directory entry
1.577 + TUid uid;
1.578 + TInt insertionError;
1.579 + if (KErrNone == TServerResources::GetUid(const_cast<TEntry&>(dirEntries[i]), uid))
1.580 + {
1.581 + insertionError=repositoryList.InsertInUnsignedKeyOrder(uid.iUid) ;
1.582 + // Should leave in all cases other than KErrNone or KErrAlreadyExists
1.583 + if((insertionError != KErrNone) && (insertionError != KErrAlreadyExists ))
1.584 + {
1.585 + User::Leave(insertionError);
1.586 + }
1.587 + }
1.588 + }
1.589 + }
1.590 + }
1.591 +
1.592 + CleanupStack::PopAndDestroy(&dir);
1.593 + }
1.594 +
1.595 + // Open all repositories in turn. Save repository UID and owner ID
1.596 + // in lookup table.
1.597 + for(TInt i = 0; i<repositoryList.Count(); i++)
1.598 + {
1.599 + // Look to see if this repository already has an entry in the owner ID lookup table
1.600 + if ( TServerResources::FindOwnerIdLookupMapping(repositoryList[i]) == KErrNotFound)
1.601 + {
1.602 + // Need to TRAP here as otherwise if ANY repository fails to open
1.603 + // (e.g. due to corruption) it would cause the entire backup to
1.604 + // fail
1.605 + TRAPD(err, iRepository->OpenL(TUid::Uid(repositoryList[i]), *iNotifier));
1.606 + if (err == KErrNoMemory)
1.607 + {
1.608 + User::Leave(err) ;
1.609 + }
1.610 +
1.611 + else if (err == KErrNone)
1.612 + {
1.613 + // The act of opening a repository will cause it to add itself to the
1.614 + // Repository/Owner UID mapping table so we don't need to do anything
1.615 + // and can close it immediately!
1.616 + iRepository->Close();
1.617 + }
1.618 + }
1.619 + }
1.620 +
1.621 + CleanupStack::PopAndDestroy() ; // repositoryList
1.622 + }
1.623 +
1.624 +// CRepositoryBackupClient::InitialiseGetProxyBackupDataL
1.625 +//
1.626 +// Prepare data to be backed up. We get the Sid/Uid of the entity whos data
1.627 +// is to be backed up. What we do is to open each repository in turn (identified
1.628 +// by directory listing), check its owner, and if it matches the Sid/Uid we've
1.629 +// been given by secure backup externalise it to a stream within a file store.
1.630 +//
1.631 +void CRepositoryBackupClient::InitialiseGetProxyBackupDataL(TSecureId aSID, TDriveNumber /* aDrive */)
1.632 + {
1.633 + // Prepare data for backup.
1.634 +
1.635 + // Create file store
1.636 + TParse backupFilePath ;
1.637 + User::LeaveIfError(backupFilePath.Set(KBackupFileName, TServerResources::iBURDirectory, &KBackupFileExt));
1.638 + CDirectFileStore* store = CDirectFileStore::ReplaceLC(iFs, backupFilePath.FullName(),
1.639 + (EFileWrite | EFileShareExclusive));
1.640 + const TUid uid2 = KNullUid ;
1.641 + store->SetTypeL(TUidType(KDirectFileStoreLayoutUid, uid2, KServerUid3)) ;
1.642 +
1.643 + // Create a Backup Stream index
1.644 + CRepositoryBackupStreamIndex* backupStreamIndex = CRepositoryBackupStreamIndex::NewLC();
1.645 +
1.646 + // Find the reps owned by aSID
1.647 + for(TInt i = 0; i < TServerResources::iOwnerIdLookUpTable.Count(); ++i)
1.648 + {
1.649 + const TOwnerIdMapping& lookupTableEntry = TServerResources::iOwnerIdLookUpTable[i];
1.650 +
1.651 + if ( lookupTableEntry.iOwner == aSID )
1.652 + {
1.653 + TStreamId settingStreamId(KNullStreamIdValue);
1.654 + TStreamId deletedSettingsStreamId(KNullStreamIdValue);
1.655 + TStreamId installedSettingStreamId(KNullStreamIdValue);
1.656 + // Found one match, open the repository and externalise content.
1.657 + TUid uid = TUid::Uid(lookupTableEntry.iRepUid);
1.658 + TRAPD(err,iRepository->OpenL(uid, *iNotifier));
1.659 + if (err == KErrNoMemory)
1.660 + {
1.661 + User::Leave(err) ;
1.662 + }
1.663 + else if (err == KErrNone)
1.664 + {
1.665 + iRepository->FailAllTransactions();
1.666 + // externalise repository contents
1.667 + iRepository->StoreRepositoryContentsL(*store, settingStreamId, deletedSettingsStreamId);
1.668 + // Close repository.
1.669 + iRepository->Close();
1.670 + }
1.671 +
1.672 + TBool installExists=TServerResources::InstallFileExistsL(uid);
1.673 + if(installExists)
1.674 + {
1.675 + // load existing repository from install directory (default values installed post-build by SWI)
1.676 + // and externalise installed repository contents
1.677 + TRAPD(err, iRepository->BackupInstallRepositoryL(uid, *store, installedSettingStreamId));
1.678 + // We trap and discard most errors to be able to continue backing up other repositories in the list
1.679 + if (err == KErrNoMemory)
1.680 + {
1.681 + User::Leave(err) ;
1.682 + }
1.683 + else if (err != KErrNone)
1.684 + {
1.685 + // If for any reason we haven't been able to back up the install repository,
1.686 + // we create an empty stream to preserve the format
1.687 + installedSettingStreamId = KNullStreamIdValue;
1.688 + }
1.689 + }
1.690 + // Add all to store index
1.691 + backupStreamIndex->AddL(uid, settingStreamId, deletedSettingsStreamId, installedSettingStreamId) ;
1.692 +
1.693 + }
1.694 + }
1.695 + // Write the stream index/dictionary as root stream within the store
1.696 + // so we can access it when we do a restore later on
1.697 + RStoreWriteStream indexStream ;
1.698 + TStreamId indexStreamId = indexStream.CreateLC(*store) ;
1.699 + backupStreamIndex->ExternalizeL(indexStream) ;
1.700 + indexStream.CommitL() ;
1.701 + CleanupStack::PopAndDestroy(&indexStream) ;
1.702 + CleanupStack::PopAndDestroy (backupStreamIndex) ;
1.703 +
1.704 + // Create the Header and write it as the root stream within the store
1.705 + // so we can access it when we do a restore later on
1.706 + TRepositoryBackupStreamHeader header (indexStreamId) ;
1.707 + RStoreWriteStream rootStream ;
1.708 + TStreamId rootStreamId = rootStream.CreateLC(*store) ;
1.709 + header.ExternalizeL(rootStream) ;
1.710 + rootStream.CommitL() ;
1.711 +
1.712 + CleanupStack::PopAndDestroy(&rootStream) ;
1.713 + store->SetRootL(rootStreamId);
1.714 + store->CommitL();
1.715 + CleanupStack::PopAndDestroy(store) ;
1.716 +
1.717 + // Attempt to open file containing store ready to read back and send to
1.718 + // BUR engine as a stream of bytes.
1.719 + User::LeaveIfError(iFile.Open(iFs, backupFilePath.FullName(), (EFileRead | EFileShareExclusive))) ;
1.720 + }
1.721 +
1.722 +
1.723 +
1.724 +
1.725 +//
1.726 +// CRepositoryBackupClient::InitialiseRestoreProxyBaseDataL
1.727 +//
1.728 +// Called when secure backup is about to start sending restore data.
1.729 +//
1.730 +void CRepositoryBackupClient::InitialiseRestoreProxyBaseDataL(TSecureId aSID, TDriveNumber /* aDrive*/)
1.731 + {
1.732 + // prepare for restore - Don't think we need to do anything here except prepare
1.733 + // data structures to receive incoming data
1.734 +
1.735 + // Save SID so we can check that it corresponds with the owner information
1.736 + // in the restored data.
1.737 + iSid = aSID ;
1.738 +
1.739 + // Open file to receive restored data
1.740 + TParse restoreFilePath ;
1.741 + User::LeaveIfError(restoreFilePath.Set(KRestoreFileName, TServerResources::iBURDirectory, &KRestoreFileExt));
1.742 + User::LeaveIfError(iFile.Replace (iFs, restoreFilePath.FullName(), (EFileWrite | EFileShareExclusive)));
1.743 + }
1.744 +
1.745 +
1.746 +
1.747 +
1.748 +//
1.749 +// CRepositoryBackupClient::RestoreBaseDataSectionL
1.750 +//
1.751 +// Called when secure backup has a chunk of restore data for us. Last data
1.752 +// segment identified by aFinished.
1.753 +//
1.754 +void CRepositoryBackupClient::RestoreBaseDataSectionL(TDesC8& aBuffer, TBool aFinished)
1.755 + {
1.756 + // Receive a chunk of restore data in aBuffer
1.757 + User::LeaveIfError(iFile.Write (aBuffer)) ;
1.758 + if (aFinished)
1.759 + {
1.760 + iFile.Close() ;
1.761 +
1.762 + // All restore data recived so we can now recreate the repositories from the
1.763 + // backup store
1.764 + RestoreCompleteL();
1.765 + }
1.766 + }
1.767 +
1.768 +void CRepositoryBackupClient::TerminateMultiStageOperation()
1.769 + {
1.770 + // Backup/Restore operation aborted!
1.771 + // Tidy up all temporary data.
1.772 + HBufC* burFileName = HBufC::New(KMaxFileName);
1.773 + if(burFileName==NULL)
1.774 + {
1.775 + return;
1.776 + }
1.777 + TPtr burFileNamePtr(burFileName->Des());
1.778 + iFile.FullName(burFileNamePtr); //get the full name of the temporary file
1.779 + iFile.Close(); // close the file
1.780 + // If a debug build - record error
1.781 + TInt fileDeleteErr=iFs.Delete(burFileNamePtr);
1.782 + #ifdef _DEBUG
1.783 + if (fileDeleteErr != KErrNone)
1.784 + {
1.785 + RDebug::Print(_L("CRepositoryBackupClient::TerminateMultiStageOperation - Failed to delete file. Error = %d"), fileDeleteErr);
1.786 + }
1.787 + #else
1.788 + UNUSED_VAR(fileDeleteErr);
1.789 + #endif
1.790 +
1.791 + delete burFileName;
1.792 + }
1.793 +
1.794 +
1.795 +//
1.796 +// CRepositoryBackupClient::GetDataChecksum
1.797 +//
1.798 +// Not required and we don't implement it.
1.799 +//
1.800 +TUint CRepositoryBackupClient::GetDataChecksum(TDriveNumber /* aDrive */)
1.801 + {
1.802 + return KArbitraryNumber;
1.803 + }
1.804 +
1.805 +//
1.806 +// CRepositoryBackupClient::GetSnapshotDataL
1.807 +//
1.808 +// Only required for incremental backup (which we don't support
1.809 +//
1.810 +void CRepositoryBackupClient::GetSnapshotDataL(TDriveNumber /* aDrive */, TPtr8& /* aBuffer */, TBool& /* aFinished */)
1.811 + {
1.812 + User::Leave(KErrNotSupported) ;
1.813 + }
1.814 +
1.815 +//
1.816 +// CRepositoryBackupClient::InitialiseGetBackupDataL
1.817 +//
1.818 +// Used by "normal" active backup to prepare data - we use
1.819 +// InitialiseRestoreProxyBaseDataL so this shouldn't be called!
1.820 +//
1.821 +void CRepositoryBackupClient::InitialiseGetBackupDataL(TDriveNumber /* aDrive */)
1.822 + {
1.823 + User::Leave(KErrNotSupported) ;
1.824 + }
1.825 +
1.826 +
1.827 +
1.828 +void CRepositoryBackupClient::InitialiseRestoreBaseDataL(TDriveNumber /* aDrive */)
1.829 + {
1.830 + // Check this! I Don't think this method should get called as we're a proxy
1.831 + // and so implement InitialiseGetProxyBackupDataL!!
1.832 + User::Leave(KErrNotSupported) ;
1.833 + }
1.834 +
1.835 +
1.836 +
1.837 +
1.838 +void CRepositoryBackupClient::InitialiseRestoreIncrementDataL(TDriveNumber /* aDrive */)
1.839 + {
1.840 + // Check this! I Don't think this method should get called as we're a proxy
1.841 + // so don't do incremental backup!!
1.842 + User::Leave(KErrNotSupported) ;
1.843 + }
1.844 +
1.845 +
1.846 +
1.847 +void CRepositoryBackupClient::RestoreIncrementDataSectionL(TDesC8& /* aBuffer */, TBool /* aFinished */)
1.848 + {
1.849 + // Check this! I Don't think this method should get called as we're a proxy
1.850 + // so don't do incremental backup!!
1.851 + User::Leave(KErrNotSupported) ;
1.852 + }
1.853 +
1.854 +
1.855 +//
1.856 +// Incremental backup isn't supported for the proxy data holder model so this
1.857 +// method should never be called.
1.858 +//
1.859 +// Not acceptable to leave even though it's an ...L function which we don't implement
1.860 +void CRepositoryBackupClient::AllSnapshotsSuppliedL()
1.861 + {
1.862 + ;
1.863 + }
1.864 +
1.865 +
1.866 +
1.867 +//
1.868 +// Incremental backup not supported
1.869 +//
1.870 +void CRepositoryBackupClient::ReceiveSnapshotDataL(TDriveNumber /* aDrive */, TDesC8& /* aBuffer */, TBool /* aLastSection */)
1.871 + {
1.872 + User::Leave(KErrNotSupported) ;
1.873 + }
1.874 +
1.875 +/**
1.876 +Adds a new entry to the restored repository list with the specified repository uid.
1.877 +
1.878 +Creates an object of the CRestoredRepository and inserts it to the list.
1.879 +If a repository of the specified uid is already on the list, the created object will
1.880 +be deleted and no repeated entry will be inserted to the list.
1.881 +
1.882 +@param aUid The uid of the repository to be added to this array.
1.883 +@return The index of the new or existing entry within the list.
1.884 +*/
1.885 +TInt CRepositoryBackupClient::AddRestoredRepositoryL(TUid aUid)
1.886 + {
1.887 + CRestoredRepository* rstRepos = new(ELeave) CRestoredRepository(aUid);
1.888 + CleanupStack::PushL(rstRepos);
1.889 + TInt err = iRestoredRepositoriesArray.InsertInOrder(rstRepos, TLinearOrder<CRestoredRepository>(CRestoredRepository::CompareUids));
1.890 + if(err != KErrNone && err != KErrAlreadyExists)
1.891 + User::Leave(err);
1.892 + TInt index = iRestoredRepositoriesArray.FindInOrderL(rstRepos, TLinearOrder<CRestoredRepository>(CRestoredRepository::CompareUids));
1.893 + CleanupStack::Pop();
1.894 +
1.895 + if(err == KErrAlreadyExists)
1.896 + {
1.897 + delete rstRepos;
1.898 + }
1.899 + return index;
1.900 + }