installationservices/swi/source/integrityservices/operationfunctions.cpp
changeset 0 ba25891c3a9e
child 17 741e5bba2bd1
equal deleted inserted replaced
-1:000000000000 0:ba25891c3a9e
       
     1 /*
       
     2 * Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of the License "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: 
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 /**
       
    20  @file 
       
    21  @released
       
    22  @internalTechnology
       
    23 */
       
    24 
       
    25 #include "operationfunctions.h"
       
    26 
       
    27 #include "integritytree.h"
       
    28 #include "log.h"
       
    29 
       
    30 using namespace Swi;
       
    31 
       
    32 void Swi::IntegrityDeleteFileL(const TDesC& aPath, CIntegrityTreeLeaf* aLeaf, RFs& aFs, 
       
    33 							   RLoader& aLoader, CFileMan& aFileMan)
       
    34 	{
       
    35 	RBuf name;
       
    36 	name.CreateL(aPath, KMaxFileName);
       
    37 	CleanupClosePushL(name);
       
    38 	name.Append(aLeaf->Name());
       
    39 
       
    40 	TEntry entry;
       
    41 	TInt err = aFs.Entry(name, entry);
       
    42 	if (err == KErrNone)
       
    43 		{
       
    44 		aFs.SetAtt(name, 0, KEntryAttReadOnly);
       
    45 		if(entry.IsDir())
       
    46 			{
       
    47 			// Make sure to append slash before calling RmDir - otherwise it deletes the parent directory			
       
    48 			if (name[name.Length()-1] != KPathDelimiter) 
       
    49 	  			{
       
    50   				name.Append(KPathDelimiter);
       
    51   				}
       
    52 			
       
    53 			TInt err = aFileMan.RmDir(name);
       
    54 			DEBUG_PRINTF3(_L("Integrity Services - Remove Directory %S err = %d"), &name, err);
       
    55 			User::LeaveIfError(err);
       
    56 			}
       
    57 		else
       
    58 			{			
       
    59 			TInt err = aLoader.Delete(name);
       
    60 			DEBUG_PRINTF3(_L("Integrity Services - Delete File %S err = %d"), &name, err);
       
    61 			User::LeaveIfError(err);
       
    62 			}
       
    63 			
       
    64 		// prune the directory tree if possible
       
    65 		RemoveDirectoryTreeL(aFs, name);
       
    66 		}
       
    67 	else if(err != KErrNotFound && err != KErrPathNotFound)
       
    68 		{
       
    69 		DEBUG_PRINTF3(_L("Integrity Services - error %d removing %S"), err, &name);
       
    70 		User::Leave(err);
       
    71 		}
       
    72 	CleanupStack::PopAndDestroy(&name);
       
    73 	}
       
    74 
       
    75 void Swi::IntegrityRestoreFileL(const TDesC& aPath, CIntegrityTreeLeaf* aLeaf, RFs& aFs, 
       
    76 								RLoader& /*aLoader*/, CFileMan& /*aFileMan*/)
       
    77 	{
       
    78 	RBuf name;
       
    79 	name.CreateL(aPath, KMaxFileName);
       
    80 	CleanupClosePushL(name);
       
    81 	name.Append(aLeaf->Name());
       
    82 
       
    83 	// find the peer file, and check it's a backup.
       
    84 	CIntegrityTreeLeaf* peer = aLeaf->Peer();
       
    85 	if (peer->Type() != EBackupFile)
       
    86 		{
       
    87 		User::Leave(KErrCorrupt);
       
    88 		}
       
    89 	
       
    90 	TParsePtrC parse(peer->Journal());
       
    91 	RBuf backup;
       
    92 	backup.CreateL(parse.DriveAndPath(), KMaxFileName);
       
    93 	CleanupClosePushL(backup);
       
    94 	backup.Append(parse.Name());
       
    95 	backup.Append(KPathDelimiter);
       
    96 	backup.Append(peer->Name());
       
    97 
       
    98 	TInt err = aFs.MkDirAll(name);
       
    99 	if(err != KErrNone && err != KErrAlreadyExists)
       
   100 		{
       
   101 		User::Leave(err);
       
   102 		}
       
   103 			
       
   104 	err = aFs.Rename(backup, name);
       
   105 	if (err != KErrNone)
       
   106 		{
       
   107 		// we may have already moved it back during a previous recovery
       
   108 		// attempt, check for its presence in the original location
       
   109 		if(err == KErrNotFound || err == KErrPathNotFound)
       
   110 			{
       
   111 			TEntry restoredEntry;
       
   112 			err = aFs.Entry(name, restoredEntry);
       
   113 			}
       
   114 		User::LeaveIfError(err);
       
   115 		}
       
   116 	else
       
   117 		{
       
   118 		// prune the backup directory tree if possible.
       
   119 		RemoveDirectoryTreeL(aFs, backup);
       
   120 		}
       
   121 	CleanupStack::PopAndDestroy(2, &name);	// backup
       
   122 	}
       
   123 	
       
   124 void Swi::RemoveDirectoryTreeL(RFs& aFs, const TDesC& aFileName)
       
   125 	{
       
   126 	TParse directory;
       
   127 	User::LeaveIfError(directory.SetNoWild(aFileName, NULL, NULL));
       
   128 	while(!directory.IsRoot())
       
   129 		{
       
   130 		// try to remove this directory
       
   131 		TInt err = aFs.RmDir(directory.DriveAndPath());
       
   132 		if(err == KErrInUse || err == KErrAccessDenied)
       
   133 			{
       
   134 			break;
       
   135 			}
       
   136 		if(err != KErrNone && err != KErrNotFound && err != KErrPathNotFound)
       
   137 			{
       
   138 			User::Leave(err);
       
   139 			}
       
   140 		// move to deleted directory's parent
       
   141 		User::LeaveIfError(directory.PopDir());
       
   142 		}	
       
   143 	}