33 #include <ezcompressor.h> |
32 #include <ezcompressor.h> |
34 #include <ezdecompressor.h> |
33 #include <ezdecompressor.h> |
35 #include <swi/sisregistrypackage.h> |
34 #include <swi/sisregistrypackage.h> |
36 #include <swi/sisregistryentry.h> |
35 #include <swi/sisregistryentry.h> |
37 #include <swi/swispubsubdefs.h> |
36 #include <swi/swispubsubdefs.h> |
|
37 #include "OstTraceDefinitions.h" |
|
38 #include "sbtrace.h" |
|
39 #ifdef OST_TRACE_COMPILER_IN_USE |
|
40 #include "sbedataownermanagerTraces.h" |
|
41 #endif |
38 |
42 |
39 namespace conn |
43 namespace conn |
40 { |
44 { |
41 const TInt KSID = 0x10202D56; |
45 const TInt KSID = 0x10202D56; |
42 _LIT_SECURITY_POLICY_S0(KWritePolicy, KSID); |
46 _LIT_SECURITY_POLICY_S0(KWritePolicy, KSID); |
45 |
49 |
46 CDataOwnerContainer* CDataOwnerContainer::NewL(TSecureId aSecureId, CDataOwnerManager* apDataOwnerManager) |
50 CDataOwnerContainer* CDataOwnerContainer::NewL(TSecureId aSecureId, CDataOwnerManager* apDataOwnerManager) |
47 /** Symbian OS static constructor |
51 /** Symbian OS static constructor |
48 */ |
52 */ |
49 { |
53 { |
|
54 OstTraceFunctionEntry0( CDATAOWNERCONTAINER_NEWL_ENTRY ); |
50 CDataOwnerContainer* self = new(ELeave) CDataOwnerContainer(aSecureId); |
55 CDataOwnerContainer* self = new(ELeave) CDataOwnerContainer(aSecureId); |
51 CleanupStack::PushL(self); |
56 CleanupStack::PushL(self); |
52 self->ConstructL(apDataOwnerManager); |
57 self->ConstructL(apDataOwnerManager); |
53 CleanupStack::Pop(self); |
58 CleanupStack::Pop(self); |
54 |
59 |
|
60 OstTraceFunctionExit0( CDATAOWNERCONTAINER_NEWL_EXIT ); |
55 return self; |
61 return self; |
56 } |
62 } |
57 |
63 |
58 CDataOwnerContainer::CDataOwnerContainer(TSecureId aSecureId) : |
64 CDataOwnerContainer::CDataOwnerContainer(TSecureId aSecureId) : |
59 iSecureId(aSecureId) |
65 iSecureId(aSecureId) |
60 /** Standard C++ constructor |
66 /** Standard C++ constructor |
61 */ |
67 */ |
62 { |
68 { |
|
69 OstTraceFunctionEntry0( CDATAOWNERCONTAINER_CDATAOWNERCONTAINER_CONS_ENTRY ); |
|
70 OstTraceFunctionExit0( CDATAOWNERCONTAINER_CDATAOWNERCONTAINER_CONS_EXIT ); |
63 } |
71 } |
64 |
72 |
65 CDataOwnerContainer::~CDataOwnerContainer() |
73 CDataOwnerContainer::~CDataOwnerContainer() |
66 { |
74 { |
|
75 OstTraceFunctionEntry0( CDATAOWNERCONTAINER_CDATAOWNERCONTAINER_DES_ENTRY ); |
67 delete ipDataOwner; |
76 delete ipDataOwner; |
|
77 OstTraceFunctionExit0( CDATAOWNERCONTAINER_CDATAOWNERCONTAINER_DES_EXIT ); |
68 } |
78 } |
69 |
79 |
70 void CDataOwnerContainer::ConstructL(CDataOwnerManager* apDataOwnerManager) |
80 void CDataOwnerContainer::ConstructL(CDataOwnerManager* apDataOwnerManager) |
71 /* Symbian second phase constructor |
81 /* Symbian second phase constructor |
72 */ |
82 */ |
73 { |
83 { |
|
84 OstTraceFunctionEntry0( CDATAOWNERCONTAINER_CONSTRUCTL_ENTRY ); |
74 ipDataOwner = CDataOwner::NewL(iSecureId, apDataOwnerManager); |
85 ipDataOwner = CDataOwner::NewL(iSecureId, apDataOwnerManager); |
|
86 OstTraceFunctionExit0( CDATAOWNERCONTAINER_CONSTRUCTL_EXIT ); |
75 } |
87 } |
76 |
88 |
77 TSecureId CDataOwnerContainer::SecureId() const |
89 TSecureId CDataOwnerContainer::SecureId() const |
78 /** Secure Id accessor |
90 /** Secure Id accessor |
79 |
91 |
147 */ |
165 */ |
148 : ipABServer(NULL), iBufferFileReader(NULL), iDecompressor(NULL), |
166 : ipABServer(NULL), iBufferFileReader(NULL), iDecompressor(NULL), |
149 iResetAfterRestore(EFalse), iJavaDOM(NULL), iSIDListForPartial(NULL), |
167 iResetAfterRestore(EFalse), iJavaDOM(NULL), iSIDListForPartial(NULL), |
150 iConfig(NULL), iBaBackupSession(NULL) |
168 iConfig(NULL), iBaBackupSession(NULL) |
151 { |
169 { |
|
170 OstTraceFunctionEntry0( CDATAOWNERMANAGER_CDATAOWNERMANAGER_CONS_ENTRY ); |
|
171 OstTraceFunctionExit0( CDATAOWNERMANAGER_CDATAOWNERMANAGER_CONS_EXIT ); |
152 } |
172 } |
153 |
173 |
154 void CDataOwnerManager::ConstructL() |
174 void CDataOwnerManager::ConstructL() |
155 /** Symbian OS second phase contrutor |
175 /** Symbian OS second phase contrutor |
156 */ |
176 */ |
157 { |
177 { |
158 User::LeaveIfError(iFs.Connect()); |
178 OstTraceFunctionEntry0( CDATAOWNERMANAGER_CONSTRUCTL_ENTRY ); |
159 TInt err = RProperty::Define(TUid::Uid(KUidSystemCategoryValue), |
179 TInt err = iFs.Connect(); |
|
180 LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP4_CDATAOWNERMANAGER_CONSTRUCTL, "Leave: %d", err)); |
|
181 err = RProperty::Define(TUid::Uid(KUidSystemCategoryValue), |
160 KUidBackupRestoreKey, |
182 KUidBackupRestoreKey, |
161 RProperty::EInt, KReadPolicy, KWritePolicy, 0); |
183 RProperty::EInt, KReadPolicy, KWritePolicy, 0); |
162 if ((err != KErrNone) && (err != KErrAlreadyExists)) |
184 if ((err != KErrNone) && (err != KErrAlreadyExists)) |
163 { |
185 { |
|
186 OstTrace1(TRACE_ERROR, DUP3_CDATAOWNERMANAGER_CONSTRUCTL, "Leave: %d", err); |
164 User::Leave(err); |
187 User::Leave(err); |
165 } |
188 } |
166 |
189 |
167 // Load a reference plugin with implementation Uid 0x2000D926 |
190 // Load a reference plugin with implementation Uid 0x2000D926 |
168 const TUid aImplementationUid = { 0x2000D926 }; |
191 const TUid aImplementationUid = { 0x2000D926 }; |
171 iDecompressor = CSBEDecompressAndEncrypt::NewL(); |
194 iDecompressor = CSBEDecompressAndEncrypt::NewL(); |
172 iConfig = CSBEConfig::NewL(iFs); |
195 iConfig = CSBEConfig::NewL(iFs); |
173 TRAP(err, iConfig->ParseL()); |
196 TRAP(err, iConfig->ParseL()); |
174 if (err != KErrNone) |
197 if (err != KErrNone) |
175 { |
198 { |
176 __LOG1("Error trying to parse sbeconfig.xml : %d", err); |
199 OstTrace1(TRACE_NORMAL, CDATAOWNERMANAGER_CONSTRUCTL, "Error trying to parse sbeconfig.xml : %d", err); |
177 __LOG("Using Default Settings !"); |
200 OstTrace0(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_CONSTRUCTL, "Using Default Settings !"); |
178 iConfig->SetDefault(); |
201 iConfig->SetDefault(); |
179 } |
202 } |
180 else |
203 else |
181 { |
204 { |
182 __LOG("sbeconfig.xml parsed sucessfully"); |
205 OstTrace0(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_CONSTRUCTL, "sbeconfig.xml parsed sucessfully"); |
183 } |
206 } |
184 iBaBackupSession = CBaBackupSessionWrapper::NewL(); |
207 iBaBackupSession = CBaBackupSessionWrapper::NewL(); |
185 iParserProxy = CSBEParserProxy::NewL(iFs); |
208 iParserProxy = CSBEParserProxy::NewL(iFs); |
|
209 OstTraceFunctionExit0( CDATAOWNERMANAGER_CONSTRUCTL_EXIT ); |
186 } |
210 } |
187 |
211 |
188 |
212 |
189 CDataOwnerManager::~CDataOwnerManager() |
213 CDataOwnerManager::~CDataOwnerManager() |
190 /** C++ Destructor |
214 /** C++ Destructor |
213 iSIDListForPartial->Close(); |
238 iSIDListForPartial->Close(); |
214 delete iSIDListForPartial; |
239 delete iSIDListForPartial; |
215 } |
240 } |
216 delete iConfig; |
241 delete iConfig; |
217 delete iBaBackupSession; |
242 delete iBaBackupSession; |
|
243 OstTraceFunctionExit0( CDATAOWNERMANAGER_CDATAOWNERMANAGER_DES_EXIT ); |
218 } |
244 } |
219 |
245 |
220 void CDataOwnerManager::AllSystemFilesRestoredL() |
246 void CDataOwnerManager::AllSystemFilesRestoredL() |
221 /** |
247 /** |
222 Handle send from the client informing us that the reg files have now all been supplied and |
248 Handle send from the client informing us that the reg files have now all been supplied and |
223 we can parse/start active data owners etc. |
249 we can parse/start active data owners etc. |
224 */ |
250 */ |
225 { |
251 { |
|
252 OstTraceFunctionEntry0( CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL_ENTRY ); |
226 if(iBURType == EBURRestoreFull || iBURType == EBURRestorePartial) |
253 if(iBURType == EBURRestoreFull || iBURType == EBURRestorePartial) |
227 { |
254 { |
228 __LOG("CDataOwnerManager::AllSystemFilesRestored() - called, parse reg files & start active DO's"); |
255 OstTrace0(TRACE_NORMAL, CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "called, parse reg files & start active DO's"); |
229 // Build the list of dataOwners |
256 // Build the list of dataOwners |
230 |
257 |
231 TInt err; |
258 TInt err; |
232 TRAP(err, FindDataOwnersL()); |
259 TRAP(err, FindDataOwnersL()); |
233 if (err != KErrNone) |
260 if (err != KErrNone) |
234 { |
261 { |
235 __LOG1("CDataOwnerManager::AllSystemFilesRestored() - Error while finding data owners: %d", err); |
262 OstTrace1(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Error while finding data owners: %d", err); |
236 } |
263 } |
237 |
264 |
238 TInt doCount = iDataOwners.Count(); |
265 TInt doCount = iDataOwners.Count(); |
239 |
266 |
240 // Loop throught the list |
267 // Loop throught the list |
249 |
276 |
250 // update partial state of active data owners |
277 // update partial state of active data owners |
251 TRAP(err, UpdateDataOwnersPartialStateL()); |
278 TRAP(err, UpdateDataOwnersPartialStateL()); |
252 if (err != KErrNone) |
279 if (err != KErrNone) |
253 { |
280 { |
254 __LOG1("CDataOwnerManager::AllSystemFilesRestored() - Error while updating state: %d", err); |
281 OstTrace1(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Error while updating state: %d", err); |
255 } |
282 } |
256 |
283 |
257 for (TInt index = 0; index < doCount; index++) |
284 for (TInt index = 0; index < doCount; index++) |
258 { |
285 { |
259 // Start data owning process if necessary for active data owners |
286 // Start data owning process if necessary for active data owners |
260 TRAP(err, iDataOwners[index]->DataOwner().StartProcessIfNecessaryL()); |
287 TRAP(err, iDataOwners[index]->DataOwner().StartProcessIfNecessaryL()); |
261 if (err != KErrNone) |
288 if (err != KErrNone) |
262 { |
289 { |
263 __LOG1("CDataOwnerManager::AllSystemFilesRestored() - Error while starting process if necessary: %d", err); |
290 OstTrace1(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Error while starting process if necessary: %d", err); |
264 } |
291 } |
265 |
292 |
266 // Set up the internal state of the data owners now that all reg files and proxies are back |
293 // Set up the internal state of the data owners now that all reg files and proxies are back |
267 TRAP(err, iDataOwners[index]->DataOwner().BuildDriveStateArrayL()); |
294 TRAP(err, iDataOwners[index]->DataOwner().BuildDriveStateArrayL()); |
268 if (err != KErrNone) |
295 if (err != KErrNone) |
269 { |
296 { |
270 __LOG1("CDataOwnerManager::AllSystemFilesRestored() - Error while building drive array: %d", err); |
297 OstTrace1(TRACE_NORMAL, DUP4_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Error while building drive array: %d", err); |
271 } |
298 } |
272 } |
299 } |
273 |
300 |
274 if(iJavaDOM) |
301 if(iJavaDOM) |
275 { |
302 { |
276 TRAP_IGNORE(iJavaDOM->AllSystemFilesRestored()); |
303 TRAP_IGNORE(iJavaDOM->AllSystemFilesRestored()); |
277 } |
304 } |
278 else |
305 else |
279 { |
306 { |
280 __LOG("CDataOwnerManager::AllSystemFilesRestored() - Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
307 OstTrace0(TRACE_NORMAL, DUP5_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
281 } |
308 } |
282 |
309 |
283 // now deal with special case packages |
310 // now deal with special case packages |
284 CDesCArray* files = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity); |
311 CDesCArray* files = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity); |
285 CleanupStack::PushL(files); |
312 CleanupStack::PushL(files); |
301 TRAP(err, pDataTransfer->SetRegistrationFileL(fileName)); |
328 TRAP(err, pDataTransfer->SetRegistrationFileL(fileName)); |
302 if (err == KErrNone) |
329 if (err == KErrNone) |
303 { |
330 { |
304 TRAP(err, pDataTransfer->ParseL()); |
331 TRAP(err, pDataTransfer->ParseL()); |
305 } |
332 } |
306 __LOG2("CDataOwnerManager::AllSystemFilesRestored() - found reg file: %S for Package: 0x%08x", &fileName, sid.iId); |
333 OstTraceExt2(TRACE_NORMAL, DUP6_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "found reg file: %S for Package: 0x%08x", fileName, sid.iId); |
307 } |
334 } |
308 if (err == KErrNoMemory) |
335 if (err == KErrNoMemory) |
309 { |
336 { |
|
337 OstTrace0(TRACE_ERROR, DUP8_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "Leave: KErrNoMemory"); |
310 User::Leave(KErrNoMemory); |
338 User::Leave(KErrNoMemory); |
311 } |
339 } |
312 } |
340 } |
313 } // for |
341 } // for |
314 |
342 |
315 CleanupStack::PopAndDestroy(files); |
343 CleanupStack::PopAndDestroy(files); |
316 |
344 |
317 } // end if |
345 } // end if |
318 else |
346 else |
319 { |
347 { |
320 __LOG("CDataOwnerManager::AllSystemFilesRestored() - *Error: called when device is not in Restore mode !"); |
348 OstTrace0(TRACE_NORMAL, DUP7_CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL, "*Error: called when device is not in Restore mode !"); |
321 } |
349 } |
322 |
350 |
|
351 OstTraceFunctionExit0( CDATAOWNERMANAGER_ALLSYSTEMFILESRESTOREDL_EXIT ); |
323 } |
352 } |
324 |
353 |
325 |
354 |
326 void CDataOwnerManager::SetBURModeL(const TDriveList& aDriveList, TBURPartType aBURType, |
355 void CDataOwnerManager::SetBURModeL(const TDriveList& aDriveList, TBURPartType aBURType, |
327 TBackupIncType aBackupIncType) |
356 TBackupIncType aBackupIncType) |
331 @param aBURType the type |
360 @param aBURType the type |
332 @param aBackupIncType the incremental type |
361 @param aBackupIncType the incremental type |
333 @leave KErrInUse a Software install is in progress, plus system wide errors |
362 @leave KErrInUse a Software install is in progress, plus system wide errors |
334 */ |
363 */ |
335 { |
364 { |
336 __LOG2("CDataOwnerManager::SetBURModeL() - Request new BURType (0x%08x), IncType (0x%08x)", aBURType, aBackupIncType); |
365 OstTraceFunctionEntry0( CDATAOWNERMANAGER_SETBURMODEL_ENTRY ); |
337 __LOG2("CDataOwnerManager::SetBURModeL() - Previous BURType (0x%08x), IncType (0x%08x)", iBURType, iIncType); |
366 OstTraceExt2(TRACE_NORMAL, CDATAOWNERMANAGER_SETBURMODEL, "Request new BURType (0x%08x), IncType (0x%08x)", aBURType, aBackupIncType); |
|
367 OstTraceExt2(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_SETBURMODEL, "CDataOwnerManager::SetBURModeL() - Previous BURType (0x%08x), IncType (0x%08x)", iBURType, iIncType); |
338 // Ensure that the device can't transition directly from backup to restore mode. It must |
368 // Ensure that the device can't transition directly from backup to restore mode. It must |
339 // go through a normal state first. Allow the state to be set to the same. |
369 // go through a normal state first. Allow the state to be set to the same. |
340 switch(aBURType) |
370 switch(aBURType) |
341 { |
371 { |
342 case EBURNormal: |
372 case EBURNormal: |
343 // allow to set Normal mode in any case. no need to do anything if previous mode was Normal |
373 // allow to set Normal mode in any case. no need to do anything if previous mode was Normal |
344 if (iBURType == EBURNormal) |
374 if (iBURType == EBURNormal) |
345 { |
375 { |
|
376 OstTraceFunctionExit0( CDATAOWNERMANAGER_SETBURMODEL_EXIT ); |
346 return; |
377 return; |
347 } |
378 } |
348 break; |
379 break; |
349 case EBURUnset: |
380 case EBURUnset: |
350 // don't do anything if previous modes were Normal or Unset |
381 // don't do anything if previous modes were Normal or Unset |
351 if (iBURType == EBURNormal || iBURType == EBURUnset) |
382 if (iBURType == EBURNormal || iBURType == EBURUnset) |
352 { |
383 { |
|
384 OstTraceFunctionExit0( DUP1_CDATAOWNERMANAGER_SETBURMODEL_EXIT ); |
353 return; |
385 return; |
354 } |
386 } |
355 break; |
387 break; |
356 case EBURBackupFull: |
388 case EBURBackupFull: |
357 case EBURBackupPartial: |
389 case EBURBackupPartial: |
358 case EBURRestoreFull: |
390 case EBURRestoreFull: |
359 case EBURRestorePartial: |
391 case EBURRestorePartial: |
360 // don't allow mode change unless , device was put into normal mode before |
392 // don't allow mode change unless , device was put into normal mode before |
361 if (iBURType != EBURNormal && iBURType != EBURUnset) |
393 if (iBURType != EBURNormal && iBURType != EBURUnset) |
362 { |
394 { |
363 __LOG2("CDataOwnerManager::SetBURModeL() - *Error: BUR type has not transitioned between modes correctly, %d became %d", iBURType, aBURType); |
395 OstTraceExt2(TRACE_ERROR, DUP2_CDATAOWNERMANAGER_SETBURMODEL, "*Error: BUR type has not transitioned between modes correctly, %d became %d", iBURType, aBURType); |
364 User::Leave(KErrCorrupt); |
396 User::Leave(KErrCorrupt); |
365 } |
397 } |
366 break; |
398 break; |
367 } // switch |
399 } // switch |
368 |
400 |
369 TBURPartType previousBURType = iBURType; |
401 TBURPartType previousBURType = iBURType; |
370 |
402 |
371 // Need to reset the list of data owners, and old style babackup |
403 // Need to reset the list of data owners, and old style babackup |
372 if ((aBURType == EBURNormal) || (aBURType == EBURUnset)) |
404 if ((aBURType == EBURNormal) || (aBURType == EBURUnset)) |
373 { |
405 { |
374 __LOG1("CDataOwnerManager::SetBURModeL() - Going Normal/Unset/NoBackup (%d)", aBURType); |
406 OstTrace1(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_SETBURMODEL, "Going Normal/Unset/NoBackup (%d)", aBURType); |
375 // If we've transitioned from a Restore to a Normal mode, we need to send a RestoreComplete |
407 // If we've transitioned from a Restore to a Normal mode, we need to send a RestoreComplete |
376 if (previousBURType == EBURRestoreFull || previousBURType == EBURRestorePartial) |
408 if (previousBURType == EBURRestoreFull || previousBURType == EBURRestorePartial) |
377 { |
409 { |
378 __LOG("CDataOwnerManager::SetBURModeL() - Calling RestoreCompleteL on all active data owners"); |
410 OstTrace0(TRACE_NORMAL, DUP4_CDATAOWNERMANAGER_SETBURMODEL, "Calling RestoreCompleteL on all active data owners"); |
379 TInt restoreCompleteCount = iDataOwners.Count(); |
411 TInt restoreCompleteCount = iDataOwners.Count(); |
380 |
412 |
381 for (TInt index = 0; index < restoreCompleteCount; index++) |
413 for (TInt index = 0; index < restoreCompleteCount; index++) |
382 { |
414 { |
383 // Start data owning process if necessary for active data owners |
415 // Start data owning process if necessary for active data owners |
399 } |
431 } |
400 |
432 |
401 iResetAfterRestore = EFalse; |
433 iResetAfterRestore = EFalse; |
402 iDataOwners.ResetAndDestroy(); |
434 iDataOwners.ResetAndDestroy(); |
403 iPackageDataOwners.ResetAndDestroy(); |
435 iPackageDataOwners.ResetAndDestroy(); |
404 __LOG("CDataOwnerManager::SetBURModeL() - Restart All Non-System Applications"); |
436 OstTrace0(TRACE_NORMAL, DUP5_CDATAOWNERMANAGER_SETBURMODEL, "Restart All Non-System Applications"); |
405 iBaBackupSession->NotifyBackupOperationL(TBackupOperationAttributes(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd)); |
437 iBaBackupSession->NotifyBackupOperationL(TBackupOperationAttributes(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd)); |
406 iBaBackupSession->RestartAll(); |
438 iBaBackupSession->RestartAll(); |
407 } |
439 } |
408 else |
440 else |
409 { |
441 { |
410 // Check that SWInstall are not doing anything. |
442 // Check that SWInstall are not doing anything. |
411 TInt value; |
443 TInt value; |
412 TInt regErr = RProperty::Get(KUidSystemCategory, Swi::KUidSoftwareInstallKey, value); |
444 TInt regErr = RProperty::Get(KUidSystemCategory, Swi::KUidSoftwareInstallKey, value); |
413 if (regErr == KErrNone && value != Swi::ESwisNone) |
445 if (regErr == KErrNone && value != Swi::ESwisNone) |
414 { |
446 { |
415 __LOG("CDataOwnerManager::SetBURModeL() - *Error: Leave software Install in progress."); |
447 OstTrace0(TRACE_ERROR, DUP6_CDATAOWNERMANAGER_SETBURMODEL, "*Error: Leave software Install in progress."); |
416 User::Leave(KErrInUse); |
448 User::Leave(KErrInUse); |
417 } // if |
449 } // if |
418 else if (regErr != KErrNotFound && regErr != KErrNone) |
450 else if (regErr != KErrNotFound && regErr != KErrNone) |
419 { |
451 { |
420 __LOG("CDataOwnerManager::SetBURModeL() - *Error: Leave could not get KUidSoftwareInsallKey"); |
452 OstTrace0(TRACE_ERROR, DUP7_CDATAOWNERMANAGER_SETBURMODEL, "*Error: Leave could not get KUidSoftwareInsallKey"); |
421 User::Leave(regErr); |
453 User::Leave(regErr); |
422 } // else |
454 } // else |
423 |
455 |
424 // Clobber files that are locked open |
456 // Clobber files that are locked open |
425 TRequestStatus status; |
457 TRequestStatus status; |
426 __LOG("CDataOwnerManager::SetBURModeL() - Calling CloseAll()"); |
458 OstTrace0(TRACE_NORMAL, DUP8_CDATAOWNERMANAGER_SETBURMODEL, "Calling CloseAll()"); |
427 if(aBURType == EBURBackupFull || aBURType == EBURBackupPartial) |
459 if(aBURType == EBURBackupFull || aBURType == EBURBackupPartial) |
428 { |
460 { |
429 TBackupOperationAttributes atts(MBackupObserver::EReleaseLockReadOnly, MBackupOperationObserver::EStart); |
461 TBackupOperationAttributes atts(MBackupObserver::EReleaseLockReadOnly, MBackupOperationObserver::EStart); |
430 iBaBackupSession->NotifyBackupOperationL(atts); |
462 iBaBackupSession->NotifyBackupOperationL(atts); |
431 iBaBackupSession->CloseAll(MBackupObserver::EReleaseLockReadOnly, status); |
463 iBaBackupSession->CloseAll(MBackupObserver::EReleaseLockReadOnly, status); |
453 { |
485 { |
454 // Start data owning process if necessary for active data owners |
486 // Start data owning process if necessary for active data owners |
455 TRAPD(err, iDataOwners[index]->DataOwner().StartProcessIfNecessaryL()); |
487 TRAPD(err, iDataOwners[index]->DataOwner().StartProcessIfNecessaryL()); |
456 if (err != KErrNone) |
488 if (err != KErrNone) |
457 { |
489 { |
458 __LOG2("CDataOwnerManager::SetBURModeL() - Data owner (or proxy) with SID 0x%08x errored (%d) whilst starting", iDataOwners[index]->SecureId().iId, err); |
490 OstTraceExt2(TRACE_NORMAL, DUP10_CDATAOWNERMANAGER_SETBURMODEL, "Data owner (or proxy) with SID 0x%08x errored (%d) whilst starting", iDataOwners[index]->SecureId().iId, static_cast<TInt32>(err)); |
459 } |
491 } |
460 } |
492 } |
461 } |
493 } |
462 } |
494 } |
463 |
495 |
464 TInt setError = RProperty::Set(TUid::Uid(KUidSystemCategoryValue), KUidBackupRestoreKey, aBURType | aBackupIncType); |
496 TInt setError = RProperty::Set(TUid::Uid(KUidSystemCategoryValue), KUidBackupRestoreKey, aBURType | aBackupIncType); |
465 __LOG3("CDataOwnerManager::SetBURModeL() - Setting P&S flag to BURType (0x%08x), IncType (0x%08x), err: ", aBURType, aBackupIncType, setError); |
497 OstTraceExt3(TRACE_NORMAL, DUP11_CDATAOWNERMANAGER_SETBURMODEL, "Setting P&S flag to BURType (0x%08x), IncType (0x%08x), err: %d", static_cast<TUint>(aBURType), static_cast<TUint>(aBackupIncType), setError); |
466 User::LeaveIfError(setError); |
498 LEAVEIFERROR(setError, OstTrace1(TRACE_ERROR, DUP13_CDATAOWNERMANAGER_SETBURMODEL, "Leave: %d", setError)); |
467 |
499 |
468 // This configurable delay allows extra time to close all non-system apps. |
500 // This configurable delay allows extra time to close all non-system apps. |
469 TUint closeDelay = iConfig->AppCloseDelay(); |
501 TUint closeDelay = iConfig->AppCloseDelay(); |
470 if((closeDelay>0) && (aBURType == EBURBackupFull || aBURType == EBURBackupPartial || |
502 if((closeDelay>0) && (aBURType == EBURBackupFull || aBURType == EBURBackupPartial || |
471 aBURType == EBURRestoreFull || aBURType == EBURRestorePartial)) |
503 aBURType == EBURRestoreFull || aBURType == EBURRestorePartial)) |
479 |
511 |
480 //When we set back to normal mode, invalidate all current available |
512 //When we set back to normal mode, invalidate all current available |
481 //CABSessions,since they could not be used in sequent backup/restore event |
513 //CABSessions,since they could not be used in sequent backup/restore event |
482 if (aBURType == EBURUnset || aBURType == EBURNormal) |
514 if (aBURType == EBURUnset || aBURType == EBURNormal) |
483 { |
515 { |
484 __LOG1("Invalidate all ABSessions after set Setting P&S flag to 0x%08x", aBURType); |
516 OstTrace1(TRACE_NORMAL, DUP12_CDATAOWNERMANAGER_SETBURMODEL, "Invalidate all ABSessions after set Setting P&S flag to 0x%08x", aBURType); |
485 ipABServer->InvalidateABSessions(); |
517 ipABServer->InvalidateABSessions(); |
486 } |
518 } |
|
519 OstTraceFunctionExit0( DUP2_CDATAOWNERMANAGER_SETBURMODEL_EXIT ); |
487 } |
520 } |
488 |
521 |
489 |
522 |
490 void CDataOwnerManager::GetDataOwnersL(RPointerArray<CDataOwnerInfo>& aDataOwners) |
523 void CDataOwnerManager::GetDataOwnersL(RPointerArray<CDataOwnerInfo>& aDataOwners) |
491 /** Gets the Information about data owners |
524 /** Gets the Information about data owners |
492 |
525 |
493 @param aDataOwners on return the list of data owners |
526 @param aDataOwners on return the list of data owners |
494 */ |
527 */ |
495 { |
528 { |
|
529 OstTraceFunctionEntry0( CDATAOWNERMANAGER_GETDATAOWNERSL_ENTRY ); |
496 if (iBURType != EBURNormal && iBURType != EBURUnset) |
530 if (iBURType != EBURNormal && iBURType != EBURUnset) |
497 { |
531 { |
498 __LOG("CDataOwnerManager::GetDataOwnersL() - *Error: ListOfDataOnwers called when device isn't in Normal/Unset mode"); |
532 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_GETDATAOWNERSL, "*Error: ListOfDataOnwers called when device isn't in Normal/Unset mode"); |
499 User::Leave(KErrAccessDenied); |
533 User::Leave(KErrAccessDenied); |
500 } |
534 } |
501 |
535 |
502 // Build the list of dataOwners |
536 // Build the list of dataOwners |
503 FindDataOwnersL(); |
537 FindDataOwnersL(); |
504 Swi::RSisRegistrySession registrySession; |
538 Swi::RSisRegistrySession registrySession; |
505 User::LeaveIfError(registrySession.Connect()); |
539 TInt err = registrySession.Connect(); |
|
540 LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP9_CDATAOWNERMANAGER_GETDATAOWNERSL, "Leave: %d", err)); |
506 CleanupClosePushL(registrySession); |
541 CleanupClosePushL(registrySession); |
507 |
542 |
508 TInt err = KErrNone; |
543 err = KErrNone; |
509 TUint count = iDataOwners.Count(); |
544 TUint count = iDataOwners.Count(); |
510 // Loop throught the list |
545 // Loop throught the list |
511 while(count--) |
546 while(count--) |
512 { |
547 { |
513 CDataOwnerContainer* pContainer = iDataOwners[count]; |
548 CDataOwnerContainer* pContainer = iDataOwners[count]; |
522 |
557 |
523 // parse registration files |
558 // parse registration files |
524 TRAP(err, dataOwner.ParseFilesL()); |
559 TRAP(err, dataOwner.ParseFilesL()); |
525 if (err != KErrNone) |
560 if (err != KErrNone) |
526 { |
561 { |
527 __LOG2("CDataOwnerManager::GetDataOwnersL() - ParseFilesL() - Error in sid: 0x%08x (%d)", secureId.iId, err); |
562 OstTraceExt2(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_GETDATAOWNERSL, "ParseFilesL() - Error in sid: 0x%08x (%d)", secureId.iId, static_cast<TInt32>(err)); |
528 } // if |
563 } // if |
529 else |
564 else |
530 { |
565 { |
531 // Reset the state for these data owners |
566 // Reset the state for these data owners |
532 TRAP(err, dataOwner.BuildDriveStateArrayL()); |
567 TRAP(err, dataOwner.BuildDriveStateArrayL()); |
533 if (err != KErrNone) |
568 if (err != KErrNone) |
534 { |
569 { |
535 __LOG2("CDataOwnerManager::GetDataOwnersL() - BuildDriveStateArrayL() - Error in sid: 0x%08x (%d)", secureId.iId, err); |
570 OstTraceExt2(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_GETDATAOWNERSL, "BuildDriveStateArrayL() - Error in sid: 0x%08x (%d)", secureId.iId, static_cast<TInt32>(err)); |
536 }//if |
571 }//if |
537 else |
572 else |
538 { |
573 { |
539 // Get drive list (this is needed to update drive list for packages) |
574 // Get drive list (this is needed to update drive list for packages) |
540 TRAP(err, dataOwner.GetDriveListL(driveList)); |
575 TRAP(err, dataOwner.GetDriveListL(driveList)); |
541 if (err != KErrNone) |
576 if (err != KErrNone) |
542 { |
577 { |
543 __LOG2("CDataOwnerManager::GetDataOwnersL() - GetDriveListL() - Error in sid: 0x%08x (%d)", secureId.iId, err); |
578 OstTraceExt2(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_GETDATAOWNERSL, "GetDriveListL() - Error in sid: 0x%08x (%d)", secureId.iId, static_cast<TInt32>(err)); |
544 }//if |
579 }//if |
545 else |
580 else |
546 { |
581 { |
547 TRAP(err, commonSettings = dataOwner.CommonSettingsL()); |
582 TRAP(err, commonSettings = dataOwner.CommonSettingsL()); |
548 if (err != KErrNone) |
583 if (err != KErrNone) |
549 { |
584 { |
550 __LOG2("CDataOwnerManager::GetDataOwnersL() - CommonSettingsL() - Error in sid: 0x%08x (%d)", secureId.iId, err); |
585 OstTraceExt2(TRACE_NORMAL, DUP4_CDATAOWNERMANAGER_GETDATAOWNERSL, "CommonSettingsL() - Error in sid: 0x%08x (%d)", secureId.iId, static_cast<TInt32>(err)); |
551 }//if |
586 }//if |
552 }//else |
587 }//else |
553 } |
588 } |
554 }//else |
589 }//else |
555 |
590 |
562 Swi::CSisRegistryPackage* pRegistryPackage = NULL; |
597 Swi::CSisRegistryPackage* pRegistryPackage = NULL; |
563 TRAPD(error, pRegistryPackage = registrySession.SidToPackageL(secureId)); |
598 TRAPD(error, pRegistryPackage = registrySession.SidToPackageL(secureId)); |
564 if ((error == KErrNone)) |
599 if ((error == KErrNone)) |
565 { |
600 { |
566 TUid packageUid = pRegistryPackage->Uid(); |
601 TUid packageUid = pRegistryPackage->Uid(); |
567 __LOG2("CDataOwnerManager::GetDataOwnersL() - Found package for secure id 0x%08x, package id 0x%08x", secureId.iId, packageUid); |
602 OstTraceExt2(TRACE_NORMAL, DUP5_CDATAOWNERMANAGER_GETDATAOWNERSL, "Found package for secure id 0x%08x, package id 0x%08x", secureId.iId, packageUid.iUid); |
568 |
603 |
569 CleanupStack::PushL(pRegistryPackage); |
604 CleanupStack::PushL(pRegistryPackage); |
570 pId = CSBPackageId::NewL(packageUid, secureId, pRegistryPackage->Name()); |
605 pId = CSBPackageId::NewL(packageUid, secureId, pRegistryPackage->Name()); |
571 CleanupStack::PopAndDestroy(pRegistryPackage); |
606 CleanupStack::PopAndDestroy(pRegistryPackage); |
572 CleanupStack::PushL(pId); |
607 CleanupStack::PushL(pId); |
575 CPackageDataTransfer* pak = FindPackageDataContainerL(packageUid); |
610 CPackageDataTransfer* pak = FindPackageDataContainerL(packageUid); |
576 //renews the drive list |
611 //renews the drive list |
577 TRAP(err, pak->GetDriveListL(driveList)); |
612 TRAP(err, pak->GetDriveListL(driveList)); |
578 if( err == KErrNotSupported) |
613 if( err == KErrNotSupported) |
579 { |
614 { |
580 __LOG("CDataOwnerManager::GetDataOwnersL() - Error KErrNotSupported"); |
615 OstTrace0(TRACE_NORMAL, DUP6_CDATAOWNERMANAGER_GETDATAOWNERSL, "Error KErrNotSupported"); |
581 err = KErrNone; |
616 err = KErrNone; |
582 } |
617 } |
583 } // if |
618 } // if |
584 else |
619 else |
585 { |
620 { |
586 __LOG2("CDataOwnerManager::GetDataOwnersL() - Error(%d) retrieving package data for sid 0x%08x", error, secureId.iId); |
621 OstTraceExt2(TRACE_NORMAL, DUP7_CDATAOWNERMANAGER_GETDATAOWNERSL, "Error(%d) retrieving package data for sid 0x%08x", static_cast<TInt32>(error), secureId.iId); |
587 } // else |
622 } // else |
588 } // if |
623 } // if |
589 } // if |
624 } // if |
590 |
625 |
591 if (pId == NULL) // not a package or error happend |
626 if (pId == NULL) // not a package or error happend |
636 { |
671 { |
637 iJavaDOM->GetDataOwnersL(aDataOwners); |
672 iJavaDOM->GetDataOwnersL(aDataOwners); |
638 } |
673 } |
639 else |
674 else |
640 { |
675 { |
641 __LOG("CDataOwnerManager::GetDataOwnersL() - Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
676 OstTrace0(TRACE_NORMAL, DUP8_CDATAOWNERMANAGER_GETDATAOWNERSL, "Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
642 } |
677 } |
|
678 OstTraceFunctionExit0( CDATAOWNERMANAGER_GETDATAOWNERSL_EXIT ); |
643 } |
679 } |
644 |
680 |
645 CDataOwner& CDataOwnerManager::DataOwnerL(TSecureId aSID) |
681 CDataOwner& CDataOwnerManager::DataOwnerL(TSecureId aSID) |
646 /** |
682 /** |
647 Called by the ABServer when creating a session in order for the session to query the DataOwner |
683 Called by the ABServer when creating a session in order for the session to query the DataOwner |
648 |
684 |
649 @param aSID The SID of the active data owner |
685 @param aSID The SID of the active data owner |
650 */ |
686 */ |
651 { |
687 { |
|
688 OstTraceFunctionEntry0( CDATAOWNERMANAGER_DATAOWNERL_ENTRY ); |
652 CDataOwnerContainer* pDOContainer = NULL; |
689 CDataOwnerContainer* pDOContainer = NULL; |
653 |
690 |
654 pDOContainer = FindL(aSID); |
691 pDOContainer = FindL(aSID); |
655 |
692 |
656 if (!pDOContainer) |
693 if (!pDOContainer) |
657 { |
694 { |
|
695 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_DATAOWNERL, "Leave: KErrNotFound"); |
658 User::Leave(KErrNotFound); |
696 User::Leave(KErrNotFound); |
659 } |
697 } |
660 |
698 |
661 return pDOContainer->DataOwner(); |
699 CDataOwner& dataOwner = pDOContainer->DataOwner(); |
|
700 OstTraceFunctionExit0( CDATAOWNERMANAGER_DATAOWNERL_EXIT ); |
|
701 return dataOwner; |
662 } |
702 } |
663 |
703 |
664 void CDataOwnerManager::GetExpectedDataSizeL(CSBGenericTransferType* apGenericTransferType, TUint& aSize) |
704 void CDataOwnerManager::GetExpectedDataSizeL(CSBGenericTransferType* apGenericTransferType, TUint& aSize) |
665 /** Gets the expected data size of a backup for the given information |
705 /** Gets the expected data size of a backup for the given information |
666 |
706 |
669 @post deletes the apGenericTransferType |
709 @post deletes the apGenericTransferType |
670 @leave KErrNotSupported unsupported transfer type |
710 @leave KErrNotSupported unsupported transfer type |
671 @leave KErrNotFound object relating to apGenericTransferType not found |
711 @leave KErrNotFound object relating to apGenericTransferType not found |
672 */ |
712 */ |
673 { |
713 { |
|
714 OstTraceFunctionEntry0( CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL_ENTRY ); |
674 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
715 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
675 { |
716 { |
676 __LOG("CDataOwnerManager::GetExpectedDataSizeL() - *Error: GetExpectedDataSizeL called when device is not in Backup mode !"); |
717 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL, "*Error: GetExpectedDataSizeL called when device is not in Backup mode !"); |
677 User::Leave(KErrAccessDenied); |
718 User::Leave(KErrAccessDenied); |
678 } |
719 } |
679 |
720 |
680 switch (apGenericTransferType->DerivedTypeL()) |
721 switch (apGenericTransferType->DerivedTypeL()) |
681 { |
722 { |
682 case ESIDTransferDerivedType: |
723 case ESIDTransferDerivedType: |
683 { |
724 { |
684 __LOG("CDataOwnerManager::GetExpectedDataSizeL() - ESIDTransferDerivedType"); |
725 OstTrace0(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL, "ESIDTransferDerivedType"); |
685 CSBSIDTransferType* pSIDTransferType = CSBSIDTransferType::NewL(apGenericTransferType); |
726 CSBSIDTransferType* pSIDTransferType = CSBSIDTransferType::NewL(apGenericTransferType); |
686 CleanupStack::PushL(pSIDTransferType); |
727 CleanupStack::PushL(pSIDTransferType); |
687 |
728 |
688 DataOwnerL(pSIDTransferType->SecureIdL()).GetExpectedDataSizeL(pSIDTransferType->DataTypeL(), pSIDTransferType->DriveNumberL(), aSize); |
729 DataOwnerL(pSIDTransferType->SecureIdL()).GetExpectedDataSizeL(pSIDTransferType->DataTypeL(), pSIDTransferType->DriveNumberL(), aSize); |
689 CleanupStack::PopAndDestroy(pSIDTransferType); |
730 CleanupStack::PopAndDestroy(pSIDTransferType); |
690 break; |
731 break; |
691 }; |
732 }; |
692 case EPackageTransferDerivedType: |
733 case EPackageTransferDerivedType: |
693 { |
734 { |
694 __LOG("CDataOwnerManager::GetExpectedDataSizeL() - EPackageTransferDerivedType"); |
735 OstTrace0(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL, "EPackageTransferDerivedType"); |
695 |
736 |
696 // This code should be changed. Ideally, the GetExpectedDataSizeL method should be virtual, rendering |
737 // This code should be changed. Ideally, the GetExpectedDataSizeL method should be virtual, rendering |
697 // this switch statement unnecessary. When java support is added this will become even more important. |
738 // this switch statement unnecessary. When java support is added this will become even more important. |
698 // |
739 // |
699 // For the moment, to avoid re-structuring the data owner class, |
740 // For the moment, to avoid re-structuring the data owner class, |
704 // |
745 // |
705 const TUid packageId = pPackageTransferType->PackageIdL(); |
746 const TUid packageId = pPackageTransferType->PackageIdL(); |
706 const TPackageDataType dataType = pPackageTransferType->DataTypeL(); |
747 const TPackageDataType dataType = pPackageTransferType->DataTypeL(); |
707 const TDriveNumber driveNumber = pPackageTransferType->DriveNumberL(); |
748 const TDriveNumber driveNumber = pPackageTransferType->DriveNumberL(); |
708 // |
749 // |
709 __LOG3("CDataOwnerManager::GetExpectedDataSizeL() - package id: 0x%08x, dataType: %d, drive: %c ", packageId.iUid, dataType, driveNumber + 'A'); |
750 OstTraceExt3(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL, "package id: 0x%08x, dataType: %d, drive: %c ", packageId.iUid, static_cast<TInt32>(dataType), static_cast<TInt8>(driveNumber + 'A')); |
710 CPackageDataTransfer* pDataTransfer = FindPackageDataContainerL(pPackageTransferType->PackageIdL()); |
751 CPackageDataTransfer* pDataTransfer = FindPackageDataContainerL(pPackageTransferType->PackageIdL()); |
711 pDataTransfer->GetExpectedDataSizeL(dataType, driveNumber, aSize); |
752 pDataTransfer->GetExpectedDataSizeL(dataType, driveNumber, aSize); |
712 CleanupStack::PopAndDestroy(pPackageTransferType); |
753 CleanupStack::PopAndDestroy(pPackageTransferType); |
713 break; |
754 break; |
714 } |
755 } |
715 |
756 |
716 case EJavaTransferDerivedType: |
757 case EJavaTransferDerivedType: |
717 { |
758 { |
718 __LOG("CDataOwnerManager::GetExpectedDataSizeL() - EJavaTransferDerivedType"); |
759 OstTrace0(TRACE_NORMAL, DUP4_CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL, "EJavaTransferDerivedType"); |
719 |
760 |
720 // Call the Java DOM to calculate and return the expected size of the data specified in |
761 // Call the Java DOM to calculate and return the expected size of the data specified in |
721 // apGenericTransferType |
762 // apGenericTransferType |
722 if(iJavaDOM) |
763 if(iJavaDOM) |
723 { |
764 { |
724 iJavaDOM->GetExpectedDataSizeL(apGenericTransferType, aSize); |
765 iJavaDOM->GetExpectedDataSizeL(apGenericTransferType, aSize); |
725 } |
766 } |
726 else |
767 else |
727 { |
768 { |
728 __LOG("CDataOwnerManager::GetExpectedDataSizeL() - Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
769 OstTrace0(TRACE_NORMAL, DUP5_CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL, "Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
729 } |
770 } |
730 |
771 |
731 break; |
772 break; |
732 } |
773 } |
733 |
774 |
734 default: |
775 default: |
735 { |
776 { |
736 __LOG("CDataOwnerManager::GetExpectedDataSizeL() - ERROR - unsupported transfer type"); |
777 OstTrace0(TRACE_ERROR, DUP6_CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL, "unsupported transfer type"); |
737 User::Leave(KErrNotSupported); |
778 User::Leave(KErrNotSupported); |
738 } |
779 } |
739 } // switch |
780 } // switch |
740 __LOG1("CDataOwnerManager::GetExpectedDataSizeL() - END - size is: %d", aSize); |
781 OstTrace1(TRACE_NORMAL, DUP7_CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL, "size is: %d", aSize); |
|
782 OstTraceFunctionExit0( CDATAOWNERMANAGER_GETEXPECTEDDATASIZEL_EXIT ); |
741 } |
783 } |
742 |
784 |
743 |
785 |
744 void CDataOwnerManager::GetPublicFileListL(CSBGenericDataType* aGenericDataType, |
786 void CDataOwnerManager::GetPublicFileListL(CSBGenericDataType* aGenericDataType, |
745 TDriveNumber aDriveNumber, |
787 TDriveNumber aDriveNumber, |
749 @param aSID the Secure Id of the data owner you are requesting information for |
791 @param aSID the Secure Id of the data owner you are requesting information for |
750 @param aDriveNumber the drive number to obtain the public files for |
792 @param aDriveNumber the drive number to obtain the public files for |
751 @param aFiles on return the list of public files |
793 @param aFiles on return the list of public files |
752 */ |
794 */ |
753 { |
795 { |
|
796 OstTraceFunctionEntry0( CDATAOWNERMANAGER_GETPUBLICFILELISTL_ENTRY ); |
754 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
797 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
755 { |
798 { |
756 __LOG("CDataOwnerManager::GetPublicFileListL() - *Error: GetPublicFileListL called when device is not in Backup mode !"); |
799 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_GETPUBLICFILELISTL, "*Error: GetPublicFileListL called when device is not in Backup mode !"); |
757 User::Leave(KErrAccessDenied); |
800 User::Leave(KErrAccessDenied); |
758 } |
801 } |
759 |
802 |
760 if (!(iDriveList[aDriveNumber])) |
803 if (!(iDriveList[aDriveNumber])) |
761 { |
804 { |
762 __LOG("CDataOwnerManager::GetPublicFileListL() - The drive in the argument is not in the list of the drives for backup/restore"); |
805 OstTrace0(TRACE_ERROR, DUP1_CDATAOWNERMANAGER_GETPUBLICFILELISTL, "The drive in the argument is not in the list of the drives for backup/restore"); |
763 User::Leave(KErrArgument); |
806 User::Leave(KErrArgument); |
764 } |
807 } |
765 |
808 |
766 switch (aGenericDataType->DerivedTypeL()) |
809 switch (aGenericDataType->DerivedTypeL()) |
767 { |
810 { |
790 { |
833 { |
791 iJavaDOM->GetPublicFileListL(aGenericDataType, aDriveNumber, aFiles); |
834 iJavaDOM->GetPublicFileListL(aGenericDataType, aDriveNumber, aFiles); |
792 } |
835 } |
793 else |
836 else |
794 { |
837 { |
795 __LOG("CDataOwnerManager::GetPublicFileListL() - Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
838 OstTrace0(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_GETPUBLICFILELISTL, "Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
796 } |
839 } |
797 break; |
840 break; |
798 } |
841 } |
799 |
842 |
800 default: |
843 default: |
801 { |
844 { |
|
845 OstTrace0(TRACE_ERROR, DUP3_CDATAOWNERMANAGER_GETPUBLICFILELISTL, "Leave: KErrNotSupported"); |
802 User::Leave(KErrNotSupported); |
846 User::Leave(KErrNotSupported); |
803 } |
847 } |
804 } |
848 } |
|
849 OstTraceFunctionExit0( CDATAOWNERMANAGER_GETPUBLICFILELISTL_EXIT ); |
805 } |
850 } |
806 |
851 |
807 |
852 |
808 void CDataOwnerManager::GetRawPublicFileListL(CSBGenericDataType* aGenericDataType, TDriveNumber aDriveNumber, |
853 void CDataOwnerManager::GetRawPublicFileListL(CSBGenericDataType* aGenericDataType, TDriveNumber aDriveNumber, |
809 RRestoreFileFilterArray& aFileFilter) |
854 RRestoreFileFilterArray& aFileFilter) |
812 @param aSID the secure id |
857 @param aSID the secure id |
813 @param aDriveNumber the drive number |
858 @param aDriveNumber the drive number |
814 @param aFileFilter on return an array of TRestoreFileFilter |
859 @param aFileFilter on return an array of TRestoreFileFilter |
815 */ |
860 */ |
816 { |
861 { |
|
862 OstTraceFunctionEntry0( CDATAOWNERMANAGER_GETRAWPUBLICFILELISTL_ENTRY ); |
817 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
863 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
818 { |
864 { |
819 __LOG("CDataOwnerManager::GetRawPublicFileListL() - *Error: GetRawPublicFileListL called when device is not in Backup mode !"); |
865 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_GETRAWPUBLICFILELISTL, "*Error: GetRawPublicFileListL called when device is not in Backup mode !"); |
820 User::Leave(KErrAccessDenied); |
866 User::Leave(KErrAccessDenied); |
821 } |
867 } |
822 |
868 |
823 if (!(iDriveList[aDriveNumber])) |
869 if (!(iDriveList[aDriveNumber])) |
824 { |
870 { |
825 __LOG("CDataOwnerManager::GetRawPublicFileListL() - The drive in the argument is not in the list of the drives for backup/restore"); |
871 OstTrace0(TRACE_ERROR, DUP1_CDATAOWNERMANAGER_GETRAWPUBLICFILELISTL, "The drive in the argument is not in the list of the drives for backup/restore"); |
826 User::Leave(KErrArgument); |
872 User::Leave(KErrArgument); |
827 } |
873 } |
828 |
874 |
829 switch (aGenericDataType->DerivedTypeL()) |
875 switch (aGenericDataType->DerivedTypeL()) |
830 { |
876 { |
854 { |
900 { |
855 iJavaDOM->GetRawPublicFileListL(aGenericDataType, aDriveNumber, aFileFilter); |
901 iJavaDOM->GetRawPublicFileListL(aGenericDataType, aDriveNumber, aFileFilter); |
856 } |
902 } |
857 else |
903 else |
858 { |
904 { |
859 __LOG("CDataOwnerManager::GetRawPublicFileListL() - Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
905 OstTrace0(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_GETRAWPUBLICFILELISTL, "Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
860 } |
906 } |
861 break; |
907 break; |
862 } |
908 } |
863 |
909 |
864 default: |
910 default: |
865 { |
911 { |
|
912 OstTrace0(TRACE_ERROR, DUP3_CDATAOWNERMANAGER_GETRAWPUBLICFILELISTL, "Leave: KErrNotSupported"); |
866 User::Leave(KErrNotSupported); |
913 User::Leave(KErrNotSupported); |
867 } |
914 } |
868 } |
915 } |
|
916 OstTraceFunctionExit0( CDATAOWNERMANAGER_GETRAWPUBLICFILELISTL_EXIT ); |
869 } |
917 } |
870 |
918 |
871 |
919 |
872 void CDataOwnerManager::GetXMLPublicFileListL(TSecureId /*aSID*/, TDriveNumber /*aDriveNumber*/, |
920 void CDataOwnerManager::GetXMLPublicFileListL(TSecureId /*aSID*/, TDriveNumber /*aDriveNumber*/, |
873 HBufC*& /*aBuffer*/) |
921 HBufC*& /*aBuffer*/) |
877 @param aDriveNumber the drive number |
925 @param aDriveNumber the drive number |
878 @param aBuffer the buffer to write the data too |
926 @param aBuffer the buffer to write the data too |
879 |
927 |
880 */ |
928 */ |
881 { |
929 { |
|
930 OstTraceFunctionEntry0( CDATAOWNERMANAGER_GETXMLPUBLICFILELISTL_ENTRY ); |
882 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
931 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
883 { |
932 { |
884 __LOG("CDataOwnerManager::GetXMLPublicFileListL() - *Error: GetXMLPublicFileListL called when device is not in Backup mode !"); |
933 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_GETXMLPUBLICFILELISTL, "*Error: GetXMLPublicFileListL called when device is not in Backup mode !"); |
885 User::Leave(KErrAccessDenied); |
934 User::Leave(KErrAccessDenied); |
886 } |
935 } |
887 else |
936 else |
888 { |
937 { |
889 //will need to check if the drive exists in our list |
938 //will need to check if the drive exists in our list |
890 __LOG("CDataOwnerManager::GetXMLPublicFileListL() - *Error: GetXMLPublicFileListL Not Yet Implemented"); |
939 OstTrace0(TRACE_ERROR, DUP1_CDATAOWNERMANAGER_GETXMLPUBLICFILELISTL, "*Error: GetXMLPublicFileListL Not Yet Implemented"); |
891 User::Leave(KErrNotSupported); |
940 User::Leave(KErrNotSupported); |
892 } |
941 } |
|
942 OstTraceFunctionExit0( CDATAOWNERMANAGER_GETXMLPUBLICFILELISTL_EXIT ); |
893 } |
943 } |
894 |
944 |
895 void CDataOwnerManager::SetSIDListForPartialBURL(TDesC8& aFlatArrayPtr) |
945 void CDataOwnerManager::SetSIDListForPartialBURL(TDesC8& aFlatArrayPtr) |
896 /** |
946 /** |
897 Sets the list of Active SID's participating in a backup or restore |
947 Sets the list of Active SID's participating in a backup or restore |
898 |
948 |
899 @param aFlatArrayPtr Flat Array Pointer |
949 @param aFlatArrayPtr Flat Array Pointer |
900 */ |
950 */ |
901 { |
951 { |
|
952 OstTraceFunctionEntry0( CDATAOWNERMANAGER_SETSIDLISTFORPARTIALBURL_ENTRY ); |
902 if (iBURType != EBURNormal && iBURType != EBURUnset) |
953 if (iBURType != EBURNormal && iBURType != EBURUnset) |
903 { |
954 { |
904 __LOG("CDataOwnerManager::SetSIDListForPartialBURL() - *Error: called when device isn't in Normal/Unset mode"); |
955 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_SETSIDLISTFORPARTIALBURL, "*Error: called when device isn't in Normal/Unset mode"); |
905 User::Leave(KErrAccessDenied); |
956 User::Leave(KErrAccessDenied); |
906 } |
957 } |
907 |
958 |
908 if (iSIDListForPartial != NULL) |
959 if (iSIDListForPartial != NULL) |
909 { |
960 { |
911 delete iSIDListForPartial; |
962 delete iSIDListForPartial; |
912 iSIDListForPartial = NULL; |
963 iSIDListForPartial = NULL; |
913 } |
964 } |
914 |
965 |
915 iSIDListForPartial = RSIDArray::InternaliseL(aFlatArrayPtr); |
966 iSIDListForPartial = RSIDArray::InternaliseL(aFlatArrayPtr); |
|
967 OstTraceFunctionExit0( CDATAOWNERMANAGER_SETSIDLISTFORPARTIALBURL_EXIT ); |
916 } |
968 } |
917 |
969 |
918 void CDataOwnerManager::UpdateDataOwnersPartialStateL() |
970 void CDataOwnerManager::UpdateDataOwnersPartialStateL() |
919 /** |
971 /** |
920 Specifies the list of SID's that are to be backed up in a partial backup |
972 Specifies the list of SID's that are to be backed up in a partial backup |
921 |
973 |
922 */ |
974 */ |
923 { |
975 { |
|
976 OstTraceFunctionEntry0( CDATAOWNERMANAGER_UPDATEDATAOWNERSPARTIALSTATEL_ENTRY ); |
924 if (iSIDListForPartial != NULL) |
977 if (iSIDListForPartial != NULL) |
925 { |
978 { |
926 TUint count = iSIDListForPartial->Count(); |
979 TUint count = iSIDListForPartial->Count(); |
927 |
980 |
928 while(count--) |
981 while(count--) |
929 { |
982 { |
930 // Find the data owner responsible for this SID and set it's partial backup flag to ETrue |
983 // Find the data owner responsible for this SID and set it's partial backup flag to ETrue |
931 DataOwnerL((*iSIDListForPartial)[count]).SetBackedUpAsPartial(ETrue); |
984 DataOwnerL((*iSIDListForPartial)[count]).SetBackedUpAsPartial(ETrue); |
932 } // for |
985 } // for |
933 } // if |
986 } // if |
|
987 OstTraceFunctionExit0( CDATAOWNERMANAGER_UPDATEDATAOWNERSPARTIALSTATEL_EXIT ); |
934 } |
988 } |
935 |
989 |
936 void CDataOwnerManager::SIDStatusL(RSIDStatusArray& aSIDStatus) |
990 void CDataOwnerManager::SIDStatusL(RSIDStatusArray& aSIDStatus) |
937 /** |
991 /** |
938 Returns the ready statuses of selected Data Owner's |
992 Returns the ready statuses of selected Data Owner's |
939 |
993 |
940 @param aSIDStatus Array of SID's and their associated statuses. The statuses will be populated upon return |
994 @param aSIDStatus Array of SID's and their associated statuses. The statuses will be populated upon return |
941 */ |
995 */ |
942 { |
996 { |
|
997 OstTraceFunctionEntry0( CDATAOWNERMANAGER_SIDSTATUSL_ENTRY ); |
943 if (iBURType == EBURNormal || iBURType == EBURUnset) |
998 if (iBURType == EBURNormal || iBURType == EBURUnset) |
944 { |
999 { |
945 __LOG("CDataOwnerManager::SIDStatusL() - *Error: called when device is in Normal/Unset mode"); |
1000 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_SIDSTATUSL, "*Error: called when device is in Normal/Unset mode"); |
946 User::Leave(KErrAccessDenied); |
1001 User::Leave(KErrAccessDenied); |
947 } |
1002 } |
948 |
1003 |
949 TUint count = aSIDStatus.Count(); |
1004 TUint count = aSIDStatus.Count(); |
950 CDataOwnerContainer* pDOContainer = NULL; |
1005 CDataOwnerContainer* pDOContainer = NULL; |
1016 @param aReset set true to start reading from the beginning of the list |
1072 @param aReset set true to start reading from the beginning of the list |
1017 @param aDriveNumber the drive to retrieve the public files for |
1073 @param aDriveNumber the drive to retrieve the public files for |
1018 @param aEntry on return the next entry in the list, an empty entry indicates the end of the list has been reached |
1074 @param aEntry on return the next entry in the list, an empty entry indicates the end of the list has been reached |
1019 */ |
1075 */ |
1020 { |
1076 { |
1021 __LOG("CDataOwnerManager::GetNextPublicFileL() - Begin"); |
1077 OstTraceFunctionEntry0( CDATAOWNERMANAGER_GETNEXTPUBLICFILEL_ENTRY ); |
1022 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
1078 if (iBURType != EBURBackupPartial && iBURType != EBURBackupFull) |
1023 { |
1079 { |
1024 __LOG("CDataOwnerManager::GetNextPublicFileL() - *Error: GetPublicFileListL called when device is not in Backup mode !"); |
1080 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_GETNEXTPUBLICFILEL, "*Error: GetPublicFileListL called when device is not in Backup mode !"); |
1025 User::Leave(KErrAccessDenied); |
1081 User::Leave(KErrAccessDenied); |
1026 } |
1082 } |
1027 |
1083 |
1028 if (!(iDriveList[aDriveNumber])) |
1084 if (!(iDriveList[aDriveNumber])) |
1029 { |
1085 { |
1030 __LOG("CDataOwnerManager::GetNextPublicFileL() - The drive in the argument is not in the list of the drives for backup/restore"); |
1086 OstTrace0(TRACE_ERROR, DUP1_CDATAOWNERMANAGER_GETNEXTPUBLICFILEL, "The drive in the argument is not in the list of the drives for backup/restore"); |
1031 User::Leave(KErrArgument); |
1087 User::Leave(KErrArgument); |
1032 } |
1088 } |
1033 |
1089 |
1034 if (aGenericDataType->DerivedTypeL() == ESIDDerivedType) |
1090 if (aGenericDataType->DerivedTypeL() == ESIDDerivedType) |
1035 { |
1091 { |
1056 @param aLastSection is this the last section. |
1113 @param aLastSection is this the last section. |
1057 @leave KErrNotSupported Unknown transfer type |
1114 @leave KErrNotSupported Unknown transfer type |
1058 @leave KErrNotFound Unknown object |
1115 @leave KErrNotFound Unknown object |
1059 */ |
1116 */ |
1060 { |
1117 { |
1061 __LOG1("CDataOwnerManager::SupplyDataL() - START - about to decompress %d bytes of data", aBuffer.Length()); |
1118 OstTraceFunctionEntry0( CDATAOWNERMANAGER_SUPPLYDATAL_ENTRY ); |
|
1119 OstTrace1(TRACE_NORMAL, CDATAOWNERMANAGER_SUPPLYDATAL, "about to decompress %d bytes of data", aBuffer.Length()); |
1062 |
1120 |
1063 if (iBURType == EBURNormal || iBURType == EBURUnset) |
1121 if (iBURType == EBURNormal || iBURType == EBURUnset) |
1064 { |
1122 { |
1065 __LOG("CDataOwnerManager::SupplyDataL() - *Error: called not when device in Normal/Unset mode"); |
1123 OstTrace0(TRACE_ERROR, DUP1_CDATAOWNERMANAGER_SUPPLYDATAL, "*Error: called not when device in Normal/Unset mode"); |
1066 User::Leave(KErrAccessDenied); |
1124 User::Leave(KErrAccessDenied); |
1067 } |
1125 } |
1068 |
1126 |
1069 // The buffer that we are given is compressed. We need to uncompress this into |
1127 // The buffer that we are given is compressed. We need to uncompress this into |
1070 // 64K chunks and then pass through the code |
1128 // 64K chunks and then pass through the code |
1079 while (moreData && packageContinue) |
1137 while (moreData && packageContinue) |
1080 { |
1138 { |
1081 uncompressedData = NULL; |
1139 uncompressedData = NULL; |
1082 if (!iDecompressor->NextLC(uncompressedData, moreData)) |
1140 if (!iDecompressor->NextLC(uncompressedData, moreData)) |
1083 { |
1141 { |
1084 __LOG("CDataOwnerManager::SupplyDataL() - iDecompressor->NextLC returned EFalse"); |
1142 OstTrace0(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_SUPPLYDATAL, "iDecompressor->NextLC returned EFalse"); |
1085 if (uncompressedData != NULL) |
1143 if (uncompressedData != NULL) |
1086 { |
1144 { |
1087 __LOG("CDataOwnerManager::SupplyDataL() - uncompressedData not NULL so cleaning up"); |
1145 OstTrace0(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_SUPPLYDATAL, "uncompressedData not NULL so cleaning up"); |
1088 CleanupStack::PopAndDestroy(uncompressedData); |
1146 CleanupStack::PopAndDestroy(uncompressedData); |
1089 } |
1147 } |
1090 break; |
1148 break; |
1091 } |
1149 } |
1092 |
1150 |
1093 if (uncompressedData == NULL) |
1151 if (uncompressedData == NULL) |
1094 { |
1152 { |
1095 __LOG("CDataOwnerManager::SupplyDataL() - uncompressedData is NULL after NextLC, corrupt data"); |
1153 OstTrace0(TRACE_ERROR, DUP4_CDATAOWNERMANAGER_SUPPLYDATAL, "uncompressedData is NULL after NextLC, corrupt data"); |
1096 User::Leave(KErrCorrupt); |
1154 User::Leave(KErrCorrupt); |
1097 } |
1155 } |
1098 |
1156 |
1099 TPtr8 dataPtr(uncompressedData->Des()); |
1157 TPtr8 dataPtr(uncompressedData->Des()); |
1100 __LOG1("CDataOwnerManager::SupplyDataL() - decompressed data length: %d", dataPtr.Length()); |
1158 OstTrace1(TRACE_NORMAL, DUP5_CDATAOWNERMANAGER_SUPPLYDATAL, "decompressed data length: %d", dataPtr.Length()); |
1101 |
1159 |
1102 // Check aLastSection |
1160 // Check aLastSection |
1103 TBool lastSection = aLastSection && !moreData; |
1161 TBool lastSection = aLastSection && !moreData; |
1104 |
1162 |
1105 switch(apGenericTransferType->DerivedTypeL()) |
1163 switch(apGenericTransferType->DerivedTypeL()) |
1106 { |
1164 { |
1107 case ESIDTransferDerivedType: |
1165 case ESIDTransferDerivedType: |
1108 { |
1166 { |
1109 __LOG("CDataOwnerManager::SupplyDataL() - ESIDTransferDerivedType"); |
1167 OstTrace0(TRACE_NORMAL, DUP6_CDATAOWNERMANAGER_SUPPLYDATAL, "ESIDTransferDerivedType"); |
1110 CSBSIDTransferType* pSIDTransferType = CSBSIDTransferType::NewL(apGenericTransferType); |
1168 CSBSIDTransferType* pSIDTransferType = CSBSIDTransferType::NewL(apGenericTransferType); |
1111 CleanupStack::PushL(pSIDTransferType); |
1169 CleanupStack::PushL(pSIDTransferType); |
1112 |
1170 |
1113 // Is this the data for registration files? These are now not supported |
1171 // Is this the data for registration files? These are now not supported |
1114 if (pSIDTransferType->DataTypeL() == ERegistrationData) |
1172 if (pSIDTransferType->DataTypeL() == ERegistrationData) |
1115 { |
1173 { |
|
1174 OstTrace0(TRACE_ERROR, DUP12_CDATAOWNERMANAGER_SUPPLYDATAL, "Leave: KErrNotSupported"); |
1116 User::Leave(KErrNotSupported); |
1175 User::Leave(KErrNotSupported); |
1117 } // if |
1176 } // if |
1118 else |
1177 else |
1119 { |
1178 { |
1120 // Does this dataowner require a reboot? |
1179 // Does this dataowner require a reboot? |
1121 const TSecureId sid = pSIDTransferType->SecureIdL(); |
1180 const TSecureId sid = pSIDTransferType->SecureIdL(); |
1122 const TDriveNumber driveNumber = pSIDTransferType->DriveNumberL(); |
1181 const TDriveNumber driveNumber = pSIDTransferType->DriveNumberL(); |
1123 CDataOwner& dataOwner = DataOwnerL(sid); |
1182 CDataOwner& dataOwner = DataOwnerL(sid); |
1124 __LOG2("CDataOwnerManager::SupplyDataL() - trying to restore data for SID: 0x%08x, drive: %c", sid.iId, 'A' + driveNumber); |
1183 OstTraceExt2(TRACE_NORMAL, DUP7_CDATAOWNERMANAGER_SUPPLYDATAL, "trying to restore data for SID: 0x%08x, drive: %c", sid.iId, static_cast<TInt8>('A' + driveNumber)); |
1125 |
1184 |
1126 if ((dataOwner.CommonSettingsL() & ERequiresReboot) == ERequiresReboot) |
1185 if ((dataOwner.CommonSettingsL() & ERequiresReboot) == ERequiresReboot) |
1127 { |
1186 { |
1128 __LOG1("CDataOwnerManager::SupplyDataL() - data owner 0x%08x requires a REBOOT!", sid.iId); |
1187 OstTrace1(TRACE_NORMAL, DUP8_CDATAOWNERMANAGER_SUPPLYDATAL, "data owner 0x%08x requires a REBOOT!", sid.iId); |
1129 iResetAfterRestore = ETrue; |
1188 iResetAfterRestore = ETrue; |
1130 } |
1189 } |
1131 |
1190 |
1132 dataOwner.SupplyDataL(driveNumber, pSIDTransferType->DataTypeL(), dataPtr, lastSection); |
1191 dataOwner.SupplyDataL(driveNumber, pSIDTransferType->DataTypeL(), dataPtr, lastSection); |
1133 } // else |
1192 } // else |
1135 CleanupStack::PopAndDestroy(pSIDTransferType); |
1194 CleanupStack::PopAndDestroy(pSIDTransferType); |
1136 break; |
1195 break; |
1137 } |
1196 } |
1138 case EPackageTransferDerivedType: |
1197 case EPackageTransferDerivedType: |
1139 { |
1198 { |
1140 __LOG("CDataOwnerManager::SupplyDataL() - EPackageTransferDerivedType"); |
1199 OstTrace0(TRACE_NORMAL, DUP9_CDATAOWNERMANAGER_SUPPLYDATAL, "EPackageTransferDerivedType"); |
1141 // Ideally, we would use the same CDataOwner class, or a class derived |
1200 // Ideally, we would use the same CDataOwner class, or a class derived |
1142 // from it to handle the package backup/restore, however to do this would |
1201 // from it to handle the package backup/restore, however to do this would |
1143 // require a re-design. |
1202 // require a re-design. |
1144 CSBPackageTransferType *pPackageTransferType = CSBPackageTransferType::NewL(apGenericTransferType); |
1203 CSBPackageTransferType *pPackageTransferType = CSBPackageTransferType::NewL(apGenericTransferType); |
1145 CleanupStack::PushL(pPackageTransferType); |
1204 CleanupStack::PushL(pPackageTransferType); |
1155 break; |
1214 break; |
1156 } |
1215 } |
1157 |
1216 |
1158 case EJavaTransferDerivedType: |
1217 case EJavaTransferDerivedType: |
1159 { |
1218 { |
1160 __LOG("CDataOwnerManager::SupplyDataL() - EJavaTransferDerivedType"); |
1219 OstTrace0(TRACE_NORMAL, DUP10_CDATAOWNERMANAGER_SUPPLYDATAL, "EJavaTransferDerivedType"); |
1161 if(iJavaDOM) |
1220 if(iJavaDOM) |
1162 { |
1221 { |
1163 iJavaDOM->SupplyDataL(apGenericTransferType, dataPtr, lastSection); |
1222 iJavaDOM->SupplyDataL(apGenericTransferType, dataPtr, lastSection); |
1164 } |
1223 } |
1165 else |
1224 else |
1166 { |
1225 { |
1167 __LOG("CDataOwnerManager::SupplyDataL() - Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
1226 OstTrace0(TRACE_NORMAL, DUP11_CDATAOWNERMANAGER_SUPPLYDATAL, "Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
1168 } |
1227 } |
1169 break; |
1228 break; |
1170 } |
1229 } |
1171 |
1230 |
1172 default: |
1231 default: |
1173 { |
1232 { |
|
1233 OstTrace0(TRACE_ERROR, DUP13_CDATAOWNERMANAGER_SUPPLYDATAL, "Leave: KErrNotSupported"); |
1174 User::Leave(KErrNotSupported); |
1234 User::Leave(KErrNotSupported); |
1175 } |
1235 } |
1176 } // switch |
1236 } // switch |
1177 |
1237 |
1178 // Cleanup |
1238 // Cleanup |
1179 CleanupStack::PopAndDestroy(uncompressedData); |
1239 CleanupStack::PopAndDestroy(uncompressedData); |
1180 } // while |
1240 } // while |
1181 __LOG("CDataOwnerManager::SupplyDataL() - END"); |
1241 OstTraceFunctionExit0( CDATAOWNERMANAGER_SUPPLYDATAL_EXIT ); |
1182 } |
1242 } |
1183 |
1243 |
1184 |
1244 |
1185 void CDataOwnerManager::RequestDataL(CSBGenericTransferType* apGenericTransferType, |
1245 void CDataOwnerManager::RequestDataL(CSBGenericTransferType* apGenericTransferType, |
1186 TPtr8& aBuffer, TBool& aLastSection) |
1246 TPtr8& aBuffer, TBool& aLastSection) |
1191 @param aLastSection is this the last section. |
1251 @param aLastSection is this the last section. |
1192 @leave KErrNotSupported Unknown transfer type |
1252 @leave KErrNotSupported Unknown transfer type |
1193 @leave KErrNotFound Unknown object |
1253 @leave KErrNotFound Unknown object |
1194 */ |
1254 */ |
1195 { |
1255 { |
1196 __LOG2("CDataOwnerManager::RequestDataL() - START - aBuffer.Ptr(): 0x%08x, aBuffer.Length(): %d", aBuffer.Ptr(), aBuffer.Length()); |
1256 OstTraceFunctionEntry0( CDATAOWNERMANAGER_REQUESTDATAL_ENTRY ); |
|
1257 OstTraceExt2(TRACE_NORMAL, CDATAOWNERMANAGER_REQUESTDATAL, "aBuffer.Ptr(): 0x%08x, aBuffer.Length(): %d", reinterpret_cast<TInt32>(aBuffer.Ptr()), static_cast<TInt32>(aBuffer.Length())); |
1197 if (iBURType == EBURNormal || iBURType == EBURUnset) |
1258 if (iBURType == EBURNormal || iBURType == EBURUnset) |
1198 { |
1259 { |
1199 __LOG("CDataOwnerManager::RequestDataL() - *Error: called when device is in Normal/Unset mode"); |
1260 OstTrace0(TRACE_ERROR, DUP1_CDATAOWNERMANAGER_REQUESTDATAL, "*Error: called when device is in Normal/Unset mode"); |
1200 User::Leave(KErrAccessDenied); |
1261 User::Leave(KErrAccessDenied); |
1201 } |
1262 } |
1202 |
1263 |
1203 // Reserve space to perform inline compression later |
1264 // Reserve space to perform inline compression later |
1204 CSBECompressAndEncrypt* pCE = CSBECompressAndEncrypt::NewLC(apGenericTransferType, aBuffer); |
1265 CSBECompressAndEncrypt* pCE = CSBECompressAndEncrypt::NewLC(apGenericTransferType, aBuffer); |
1240 { |
1301 { |
1241 iJavaDOM->RequestDataL(apGenericTransferType, aBuffer, aLastSection); |
1302 iJavaDOM->RequestDataL(apGenericTransferType, aBuffer, aLastSection); |
1242 } |
1303 } |
1243 else |
1304 else |
1244 { |
1305 { |
1245 __LOG("CDataOwnerManager::RequestDataL() - Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
1306 OstTrace0(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_REQUESTDATAL, "Java Backup-Restore Plug-In not loaded, java files won't be backed or restored"); |
1246 } |
1307 } |
1247 break; |
1308 break; |
1248 } |
1309 } |
1249 |
1310 |
1250 default: |
1311 default: |
1251 { |
1312 { |
|
1313 OstTrace0(TRACE_ERROR, DUP5_CDATAOWNERMANAGER_REQUESTDATAL, "Leave: KErrNotSupported"); |
1252 User::Leave(KErrNotSupported); |
1314 User::Leave(KErrNotSupported); |
1253 } |
1315 } |
1254 } // switch |
1316 } // switch |
1255 |
1317 |
1256 // Compress the data block |
1318 // Compress the data block |
1257 if (aBuffer.Size() > 0) // Dont compress no data |
1319 if (aBuffer.Size() > 0) // Dont compress no data |
1258 { |
1320 { |
1259 __LOG1("CDataOwnerManager::RequestDataL() - got %d bytes of uncompressed data, about to pack it...", aBuffer.Length()); |
1321 OstTrace1(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_REQUESTDATAL, "got %d bytes of uncompressed data, about to pack it...", aBuffer.Length()); |
1260 pCE->PackL(aBuffer); |
1322 pCE->PackL(aBuffer); |
1261 } |
1323 } |
1262 else |
1324 else |
1263 { |
1325 { |
1264 __LOG1("CDataOwnerManager::RequestDataL() - got %d bytes of uncompressed data, free reserved space...", aBuffer.Length()); |
1326 OstTrace1(TRACE_NORMAL, DUP4_CDATAOWNERMANAGER_REQUESTDATAL, "got %d bytes of uncompressed data, free reserved space...", aBuffer.Length()); |
1265 pCE->FreeReservedSpace(aBuffer); |
1327 pCE->FreeReservedSpace(aBuffer); |
1266 } |
1328 } |
1267 |
1329 |
1268 |
1330 |
1269 CleanupStack::PopAndDestroy(pCE); |
1331 CleanupStack::PopAndDestroy(pCE); |
1270 __LOG("CDataOwnerManager::RequestDataL() - End"); |
1332 OstTraceFunctionExit0( CDATAOWNERMANAGER_REQUESTDATAL_EXIT ); |
1271 } |
1333 } |
1272 |
1334 |
1273 // Accessors |
1335 // Accessors |
1274 void CDataOwnerManager::SetActiveBackupServer(CABServer* aABServer) |
1336 void CDataOwnerManager::SetActiveBackupServer(CABServer* aABServer) |
1275 { |
1337 { |
1276 ipABServer = aABServer; |
1338 ipABServer = aABServer; |
1277 } |
1339 } |
1278 |
1340 |
1279 RFs& CDataOwnerManager::GetRFs() |
1341 RFs& CDataOwnerManager::GetRFs() |
1280 { |
1342 { |
1281 return iFs; |
1343 return iFs; |
1287 @param aDataOwners appended list of data owners infos |
1349 @param aDataOwners appended list of data owners infos |
1288 |
1350 |
1289 */ |
1351 */ |
1290 void CDataOwnerManager::FindImportPackagesL(Swi::RSisRegistrySession& aRegistry, RPointerArray<CDataOwnerInfo>& aDataOwners) |
1352 void CDataOwnerManager::FindImportPackagesL(Swi::RSisRegistrySession& aRegistry, RPointerArray<CDataOwnerInfo>& aDataOwners) |
1291 { |
1353 { |
1292 __LOG("CDataOwnerManager::FindImportPackagesL() - Begin"); |
1354 OstTraceFunctionEntry0( CDATAOWNERMANAGER_FINDIMPORTPACKAGESL_ENTRY ); |
1293 CDesCArray* files = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity); |
1355 CDesCArray* files = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity); |
1294 CleanupStack::PushL(files); |
1356 CleanupStack::PushL(files); |
1295 FindRegistrationFilesL(KImportDir, *files); |
1357 FindRegistrationFilesL(KImportDir, *files); |
1296 const TInt count = files->Count(); |
1358 const TInt count = files->Count(); |
1297 |
1359 |
1308 if (err == KErrNone) // If there was an error then ignore it as it is probally not a dir |
1370 if (err == KErrNone) // If there was an error then ignore it as it is probally not a dir |
1309 { |
1371 { |
1310 err = entry.Open(aRegistry, sid); |
1372 err = entry.Open(aRegistry, sid); |
1311 if (err == KErrNone) |
1373 if (err == KErrNone) |
1312 { |
1374 { |
1313 __LOG2("CDataOwnerManager::FindImportPackagesL() - found reg file: %S for Package: 0x%08x", &fileName, sid.iId); |
1375 OstTraceExt2(TRACE_NORMAL, CDATAOWNERMANAGER_FINDIMPORTPACKAGESL, "found reg file: %S for Package: 0x%08x", fileName, sid.iId); |
1314 CPackageDataTransfer* pDataTransfer = FindPackageDataContainerL(sid); |
1376 CPackageDataTransfer* pDataTransfer = FindPackageDataContainerL(sid); |
1315 |
1377 |
1316 TRAP(err, pDataTransfer->SetRegistrationFileL(fileName)); |
1378 TRAP(err, pDataTransfer->SetRegistrationFileL(fileName)); |
1317 if (err == KErrNone) |
1379 if (err == KErrNone) |
1318 { |
1380 { |
1319 TRAP(err, pDataTransfer->ParseL()); |
1381 TRAP(err, pDataTransfer->ParseL()); |
1320 } |
1382 } |
1321 if (err == KErrNoMemory) |
1383 if (err == KErrNoMemory) |
1322 { |
1384 { |
|
1385 OstTrace0(TRACE_ERROR, DUP8_CDATAOWNERMANAGER_FINDIMPORTPACKAGESL, "Leave: KErrNoMemory"); |
1323 User::Leave(KErrNoMemory); |
1386 User::Leave(KErrNoMemory); |
1324 } |
1387 } |
1325 // create generic data type |
1388 // create generic data type |
1326 HBufC* pkgName = entry.PackageNameL(); |
1389 HBufC* pkgName = entry.PackageNameL(); |
1327 CleanupStack::PushL(pkgName); |
1390 CleanupStack::PushL(pkgName); |
1332 TDriveList driveList; |
1395 TDriveList driveList; |
1333 TRAP(err, pDataTransfer->GetDriveListL(driveList)); |
1396 TRAP(err, pDataTransfer->GetDriveListL(driveList)); |
1334 if (err != KErrNone) |
1397 if (err != KErrNone) |
1335 {//Non-removable, ignore this data owner |
1398 {//Non-removable, ignore this data owner |
1336 CleanupStack::PopAndDestroy(pId); |
1399 CleanupStack::PopAndDestroy(pId); |
|
1400 entry.Close(); |
1337 continue; |
1401 continue; |
1338 } |
1402 } |
1339 // create a data owner info |
1403 // create a data owner info |
1340 CDataOwnerInfo* pDataOwnerInfo = CDataOwnerInfo::NewL(pId, pDataTransfer->CommonSettingsL(), |
1404 CDataOwnerInfo* pDataOwnerInfo = CDataOwnerInfo::NewL(pId, pDataTransfer->CommonSettingsL(), |
1341 pDataTransfer->PassiveSettingsL(), pDataTransfer->ActiveSettingsL(), |
1405 pDataTransfer->PassiveSettingsL(), pDataTransfer->ActiveSettingsL(), |
1355 if ( passiveErr == KErrNone && EHasPublicFiles & passiveBURSettings ) |
1419 if ( passiveErr == KErrNone && EHasPublicFiles & passiveBURSettings ) |
1356 { |
1420 { |
1357 CDataOwnerContainer* pDataOwner = FindL(sid); |
1421 CDataOwnerContainer* pDataOwner = FindL(sid); |
1358 if (pDataOwner == NULL) // If it does not exist we need to create it |
1422 if (pDataOwner == NULL) // If it does not exist we need to create it |
1359 { |
1423 { |
1360 __LOG1("CDataOwnerManager::FindImportPackagesL() - Package has the public files for SID: 0x%08x", sid.iId); |
1424 OstTrace1(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_FINDIMPORTPACKAGESL, "Package has the public files for SID: 0x%08x", sid.iId); |
1361 |
1425 |
1362 pDataOwner = CDataOwnerContainer::NewL(sid, this); |
1426 pDataOwner = CDataOwnerContainer::NewL(sid, this); |
1363 CleanupStack::PushL(pDataOwner); |
1427 CleanupStack::PushL(pDataOwner); |
1364 |
1428 |
1365 iDataOwners.InsertInOrder(pDataOwner, CDataOwnerContainer::Compare); |
1429 iDataOwners.InsertInOrder(pDataOwner, CDataOwnerContainer::Compare); |
1366 CleanupStack::Pop(pDataOwner); |
1430 CleanupStack::Pop(pDataOwner); |
1367 } // if |
1431 } // if |
1368 else |
1432 else |
1369 { |
1433 { |
1370 __LOG1("CDataOwnerManager::FindImportPackagesL() - SID already exists in the list SID: 0x%08x", sid.iId); |
1434 OstTrace1(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_FINDIMPORTPACKAGESL, "SID already exists in the list SID: 0x%08x", sid.iId); |
1371 } |
1435 } |
1372 |
1436 |
1373 TRAP_IGNORE(pDataOwner->DataOwner().AddRegistrationFilesL(fileName)); |
1437 TRAP_IGNORE(pDataOwner->DataOwner().AddRegistrationFilesL(fileName)); |
1374 |
1438 |
1375 // forwards declarations |
1439 // forwards declarations |
1379 |
1443 |
1380 // parse registration files |
1444 // parse registration files |
1381 TRAP(err, pDataOwner->DataOwner().ParseFilesL()); |
1445 TRAP(err, pDataOwner->DataOwner().ParseFilesL()); |
1382 if (err != KErrNone) |
1446 if (err != KErrNone) |
1383 { |
1447 { |
1384 __LOG2("CDataOwnerManager::GetDataOwnersL() - ParseFilesL() - Error in sid: 0x%08x (%d)", sid.iId, err); |
1448 OstTraceExt2(TRACE_NORMAL, DUP3_CDATAOWNERMANAGER_FINDIMPORTPACKAGESL, "ParseFilesL() - Error in sid: 0x%08x (%d)", sid.iId, static_cast<TInt32>(err)); |
1385 } // if |
1449 } // if |
1386 else |
1450 else |
1387 { |
1451 { |
1388 // Reset the state for these data owners |
1452 // Reset the state for these data owners |
1389 TRAP(err, pDataOwner->DataOwner().BuildDriveStateArrayL()); |
1453 TRAP(err, pDataOwner->DataOwner().BuildDriveStateArrayL()); |
1390 if (err != KErrNone) |
1454 if (err != KErrNone) |
1391 { |
1455 { |
1392 __LOG2("CDataOwnerManager::GetDataOwnersL() - BuildDriveStateArrayL() - Error in sid: 0x%08x (%d)", sid.iId, err); |
1456 OstTraceExt2(TRACE_NORMAL, DUP4_CDATAOWNERMANAGER_FINDIMPORTPACKAGESL, "BuildDriveStateArrayL() - Error in sid: 0x%08x (%d)", sid.iId, static_cast<TInt32>(err)); |
1393 }//if |
1457 }//if |
1394 else |
1458 else |
1395 { |
1459 { |
1396 // Get drive list (this is needed to update drive list for packages) |
1460 // Get drive list (this is needed to update drive list for packages) |
1397 TRAP(err, pDataOwner->DataOwner().GetDriveListL(driveList)); |
1461 TRAP(err, pDataOwner->DataOwner().GetDriveListL(driveList)); |
1398 if (err != KErrNone) |
1462 if (err != KErrNone) |
1399 { |
1463 { |
1400 __LOG2("CDataOwnerManager::GetDataOwnersL() - GetDriveListL() - Error in sid: 0x%08x (%d)", sid.iId, err); |
1464 OstTraceExt2(TRACE_NORMAL, DUP5_CDATAOWNERMANAGER_FINDIMPORTPACKAGESL, "GetDriveListL() - Error in sid: 0x%08x (%d)", sid.iId, static_cast<TInt32>(err)); |
1401 }//if |
1465 }//if |
1402 else |
1466 else |
1403 { |
1467 { |
1404 TRAP(err, pDataOwner->DataOwner().CommonSettingsL()); |
1468 TRAP(err, pDataOwner->DataOwner().CommonSettingsL()); |
1405 if (err != KErrNone) |
1469 if (err != KErrNone) |
1406 { |
1470 { |
1407 __LOG2("CDataOwnerManager::GetDataOwnersL() - CommonSettingsL() - Error in sid: 0x%08x (%d)", sid.iId, err); |
1471 OstTraceExt2(TRACE_NORMAL, DUP6_CDATAOWNERMANAGER_FINDIMPORTPACKAGESL, "CommonSettingsL() - Error in sid: 0x%08x (%d)", sid.iId, static_cast<TInt32>(err)); |
1408 }//if |
1472 }//if |
1409 }//else |
1473 }//else |
1410 } |
1474 } |
1411 }//else |
1475 }//else |
1412 |
1476 |
1438 } // for x |
1502 } // for x |
1439 |
1503 |
1440 |
1504 |
1441 CleanupStack::PopAndDestroy(&entry); |
1505 CleanupStack::PopAndDestroy(&entry); |
1442 |
1506 |
1443 CleanupStack::PopAndDestroy(files); |
1507 CleanupStack::PopAndDestroy(files); |
1444 __LOG("CDataOwnerManager::FindImportPackagesL() - End"); |
1508 OstTraceFunctionExit0( CDATAOWNERMANAGER_FINDIMPORTPACKAGESL_EXIT ); |
1445 } |
1509 } |
1446 |
1510 |
1447 void CDataOwnerManager::FindRegistrationFilesL(const TDesC& aPath, CDesCArray& aFiles) |
1511 void CDataOwnerManager::FindRegistrationFilesL(const TDesC& aPath, CDesCArray& aFiles) |
1448 /** Searches the device for registration files |
1512 /** Searches the device for registration files |
1449 |
1513 |
1450 @param aFiles on return a list of registration files on the device |
1514 @param aFiles on return a list of registration files on the device |
1451 */ |
1515 */ |
1452 { |
1516 { |
1453 __LOG("CDataOwnerManager::FindRegistrationFilesL() - START"); |
1517 OstTraceFunctionEntry0( CDATAOWNERMANAGER_FINDREGISTRATIONFILESL_ENTRY ); |
1454 |
1518 |
1455 // Find private directorys |
1519 // Find private directorys |
1456 TFindFile findDir(iFs); |
1520 TFindFile findDir(iFs); |
1457 CDir* pDir = NULL; |
1521 CDir* pDir = NULL; |
1458 TInt errD = findDir.FindWildByDir(KStar, aPath, pDir); |
1522 TInt errD = findDir.FindWildByDir(KStar, aPath, pDir); |
1500 |
1564 |
1501 // Check next drive |
1565 // Check next drive |
1502 errD = findDir.FindWild(pDir); |
1566 errD = findDir.FindWild(pDir); |
1503 } // while |
1567 } // while |
1504 |
1568 |
1505 __LOG1("CDataOwnerManager::FindRegistrationFilesL() - END - total files %d", aFiles.Count()); |
1569 OstTrace1(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_FINDREGISTRATIONFILESL, "total files %d", aFiles.Count()); |
|
1570 OstTraceFunctionExit0( CDATAOWNERMANAGER_FINDREGISTRATIONFILESL_EXIT ); |
1506 } |
1571 } |
1507 |
1572 |
1508 CDataOwnerContainer* CDataOwnerManager::FindL(TSecureId aSID) |
1573 CDataOwnerContainer* CDataOwnerManager::FindL(TSecureId aSID) |
1509 /** Finds a data owner in the array given a secure id |
1574 /** Finds a data owner in the array given a secure id |
1510 |
1575 |
1511 @param aSID the Secure Id of the data owner you want |
1576 @param aSID the Secure Id of the data owner you want |
1512 @leave KErrNotFound no such secure id |
1577 @leave KErrNotFound no such secure id |
1513 */ |
1578 */ |
1514 { |
1579 { |
|
1580 OstTraceFunctionEntry0( CDATAOWNERMANAGER_FINDL_ENTRY ); |
1515 CDataOwnerContainer* tempCont = CDataOwnerContainer::NewL(aSID, this); |
1581 CDataOwnerContainer* tempCont = CDataOwnerContainer::NewL(aSID, this); |
1516 TInt res = iDataOwners.Find(tempCont, CDataOwnerContainer::Match); |
1582 TInt res = iDataOwners.Find(tempCont, CDataOwnerContainer::Match); |
1517 delete tempCont; |
1583 delete tempCont; |
1518 |
1584 |
1519 if (res == KErrNotFound) |
1585 if (res == KErrNotFound) |
1520 { |
1586 { |
|
1587 OstTraceFunctionExit0( CDATAOWNERMANAGER_FINDL_EXIT ); |
1521 return NULL; |
1588 return NULL; |
1522 } |
1589 } |
1523 else |
1590 else |
1524 { |
1591 { |
|
1592 OstTraceFunctionExit0( DUP1_CDATAOWNERMANAGER_FINDL_EXIT ); |
1525 return iDataOwners[res]; |
1593 return iDataOwners[res]; |
1526 } |
1594 } |
1527 } |
1595 } |
1528 |
1596 |
1529 |
1597 |
1531 /** Finds the package data container |
1599 /** Finds the package data container |
1532 |
1600 |
1533 @param aPid The process id |
1601 @param aPid The process id |
1534 */ |
1602 */ |
1535 { |
1603 { |
|
1604 OstTraceFunctionEntry0( CDATAOWNERMANAGER_FINDPACKAGEDATACONTAINERL_ENTRY ); |
1536 CPackageDataTransfer* pPackageTransfer = CPackageDataTransfer::NewL(aPid, this); |
1605 CPackageDataTransfer* pPackageTransfer = CPackageDataTransfer::NewL(aPid, this); |
1537 CleanupStack::PushL(pPackageTransfer); |
1606 CleanupStack::PushL(pPackageTransfer); |
1538 TInt res = iPackageDataOwners.Find(pPackageTransfer, CPackageDataTransfer::Match); |
1607 TInt res = iPackageDataOwners.Find(pPackageTransfer, CPackageDataTransfer::Match); |
1539 if (res == KErrNotFound) |
1608 if (res == KErrNotFound) |
1540 { |
1609 { |
1541 User::LeaveIfError(iPackageDataOwners.InsertInOrder(pPackageTransfer, CPackageDataTransfer::Compare)); |
1610 TInt err = iPackageDataOwners.InsertInOrder(pPackageTransfer, CPackageDataTransfer::Compare); |
|
1611 LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, CDATAOWNERMANAGER_FINDPACKAGEDATACONTAINERL, "Leave: %d", err)); |
1542 CleanupStack::Pop(pPackageTransfer); |
1612 CleanupStack::Pop(pPackageTransfer); |
|
1613 OstTraceFunctionExit0( CDATAOWNERMANAGER_FINDPACKAGEDATACONTAINERL_EXIT ); |
1543 return pPackageTransfer; |
1614 return pPackageTransfer; |
1544 } |
1615 } |
1545 else |
1616 else |
1546 { |
1617 { |
1547 CleanupStack::PopAndDestroy(pPackageTransfer); |
1618 CleanupStack::PopAndDestroy(pPackageTransfer); |
|
1619 OstTraceFunctionExit0( DUP1_CDATAOWNERMANAGER_FINDPACKAGEDATACONTAINERL_EXIT ); |
1548 return iPackageDataOwners[res]; |
1620 return iPackageDataOwners[res]; |
1549 } |
1621 } |
1550 } |
1622 } |
1551 |
1623 |
1552 void CDataOwnerManager::StripSecureIdL(const TDesC& aStrip, TSecureId& aSecureId) |
1624 void CDataOwnerManager::StripSecureIdL(const TDesC& aStrip, TSecureId& aSecureId) |
1553 /** Strips a Secure Id from a text string |
1625 /** Strips a Secure Id from a text string |
1554 |
1626 |
1555 Looks for a "//private//" directory in the string and strips the SID after it. |
1627 Looks for a "//private//" directory in the string and strips the SID after it. |
1556 */ |
1628 */ |
1557 { |
1629 { |
|
1630 OstTraceFunctionEntry0( CDATAOWNERMANAGER_STRIPSECUREIDL_ENTRY ); |
1558 |
1631 |
1559 TInt start = aStrip.FindF(KImportDir); |
1632 TInt start = aStrip.FindF(KImportDir); |
1560 if (start == KErrNotFound) |
1633 if (start == KErrNotFound) |
1561 { |
1634 { |
1562 start = aStrip.FindF(KPrivate); |
1635 start = aStrip.FindF(KPrivate); |
1563 if (start == KErrNotFound) |
1636 if (start == KErrNotFound) |
1564 { |
1637 { |
|
1638 OstTrace0(TRACE_ERROR, CDATAOWNERMANAGER_STRIPSECUREIDL, "Leave: KErrArgument"); |
1565 User::Leave(KErrArgument); |
1639 User::Leave(KErrArgument); |
1566 } |
1640 } |
1567 start += KPrivate().Length(); |
1641 start += KPrivate().Length(); |
1568 } |
1642 } |
1569 else |
1643 else |
1578 // Create the secure Id |
1652 // Create the secure Id |
1579 TLex sIdLex(aStrip.Mid(start, end - start + 1)); |
1653 TLex sIdLex(aStrip.Mid(start, end - start + 1)); |
1580 // If we cant do the convert then ignore as it is a directory that is not a SID. |
1654 // If we cant do the convert then ignore as it is a directory that is not a SID. |
1581 if (sIdLex.Val(aSecureId.iId, EHex) != KErrNone) |
1655 if (sIdLex.Val(aSecureId.iId, EHex) != KErrNone) |
1582 { |
1656 { |
|
1657 OstTrace0(TRACE_ERROR, DUP1_CDATAOWNERMANAGER_STRIPSECUREIDL, "Leave: KErrArgument"); |
1583 User::Leave(KErrArgument); |
1658 User::Leave(KErrArgument); |
1584 } |
1659 } |
|
1660 OstTraceFunctionExit0( CDATAOWNERMANAGER_STRIPSECUREIDL_EXIT ); |
1585 } |
1661 } |
1586 |
1662 |
1587 |
1663 |
1588 void CDataOwnerManager::FindDataOwnersL() |
1664 void CDataOwnerManager::FindDataOwnersL() |
1589 /** Gets a list of data owners |
1665 /** Gets a list of data owners |
1590 |
1666 |
1591 This list only contains the Secure ID's for applications that have a backup |
1667 This list only contains the Secure ID's for applications that have a backup |
1592 registration files. |
1668 registration files. |
1593 */ |
1669 */ |
1594 { |
1670 { |
1595 __LOG("CDataOwnerManager::FindDataOwnersL() - Begin"); |
1671 OstTraceFunctionEntry0( CDATAOWNERMANAGER_FINDDATAOWNERSL_ENTRY ); |
1596 // Clear out any current list |
1672 // Clear out any current list |
1597 iDataOwners.ResetAndDestroy(); |
1673 iDataOwners.ResetAndDestroy(); |
1598 |
1674 |
1599 // Find all registration files on the device |
1675 // Find all registration files on the device |
1600 CDesCArray* registrationFiles = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity); |
1676 CDesCArray* registrationFiles = new(ELeave) CDesCArrayFlat(KDesCArrayGranularity); |
1601 CleanupStack::PushL(registrationFiles); |
1677 CleanupStack::PushL(registrationFiles); |
1602 FindRegistrationFilesL(KPrivate, *registrationFiles); |
1678 FindRegistrationFilesL(KPrivate, *registrationFiles); |
1603 __LOG(" "); |
1679 OstTrace0(TRACE_NORMAL, CDATAOWNERMANAGER_FINDDATAOWNERSL, " "); |
1604 |
1680 |
1605 // Add registration files to iDataOwners |
1681 // Add registration files to iDataOwners |
1606 const TInt count = registrationFiles->Count(); |
1682 const TInt count = registrationFiles->Count(); |
1607 for (TInt x = 0; x < count; x++) |
1683 for (TInt x = 0; x < count; x++) |
1608 { |
1684 { |
1613 if (err == KErrNone) // If there was an error then ignore it as it is probally not a dir |
1689 if (err == KErrNone) // If there was an error then ignore it as it is probally not a dir |
1614 { |
1690 { |
1615 CDataOwnerContainer* pDataOwner = FindL(sid); |
1691 CDataOwnerContainer* pDataOwner = FindL(sid); |
1616 if (pDataOwner == NULL) // If it does not exist we need to create it |
1692 if (pDataOwner == NULL) // If it does not exist we need to create it |
1617 { |
1693 { |
1618 __LOG2("CDataOwnerManager::FindDataOwnersL() - found reg file: %S for sid: 0x%08x", &fileName, sid.iId); |
1694 OstTraceExt2(TRACE_NORMAL, DUP1_CDATAOWNERMANAGER_FINDDATAOWNERSL, "found reg file: %S for sid: 0x%08x", fileName, sid.iId); |
1619 |
1695 |
1620 pDataOwner = CDataOwnerContainer::NewL(sid, this); |
1696 pDataOwner = CDataOwnerContainer::NewL(sid, this); |
1621 CleanupStack::PushL(pDataOwner); |
1697 CleanupStack::PushL(pDataOwner); |
1622 |
1698 |
1623 iDataOwners.InsertInOrder(pDataOwner, CDataOwnerContainer::Compare); |
1699 iDataOwners.InsertInOrder(pDataOwner, CDataOwnerContainer::Compare); |
1624 CleanupStack::Pop(pDataOwner); |
1700 CleanupStack::Pop(pDataOwner); |
1625 } // if |
1701 } // if |
1626 else |
1702 else |
1627 { |
1703 { |
1628 __LOG2("CDataOwnerManager::FindDataOwnersL() - found reg file: %S for existing sid: 0x%08x", &fileName, sid.iId); |
1704 OstTraceExt2(TRACE_NORMAL, DUP2_CDATAOWNERMANAGER_FINDDATAOWNERSL, "found reg file: %S for existing sid: 0x%08x", fileName, sid.iId); |
1629 } |
1705 } |
1630 |
1706 |
1631 pDataOwner->DataOwner().AddRegistrationFilesL(fileName); |
1707 pDataOwner->DataOwner().AddRegistrationFilesL(fileName); |
1632 } // if |
1708 } // if |
1633 } // for x |
1709 } // for x |
1634 |
1710 |
1635 CleanupStack::PopAndDestroy(registrationFiles); |
1711 CleanupStack::PopAndDestroy(registrationFiles); |
1636 __LOG("CDataOwnerManager::FindDataOwnersL() - End"); |
1712 OstTraceFunctionExit0( CDATAOWNERMANAGER_FINDDATAOWNERSL_EXIT ); |
1637 } |
1713 } |
1638 |
1714 |
1639 CSBEConfig& CDataOwnerManager::Config() |
1715 CSBEConfig& CDataOwnerManager::Config() |
1640 /** Getter for the Secure Backup configuration |
1716 /** Getter for the Secure Backup configuration |
1641 @return Reference to the CSBEConfig instance |
1717 @return Reference to the CSBEConfig instance |