1 /*

     2 * Copyright (c) 2000 - 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: Provides file handling functions.

    15 *

    16 */

    17 

    18 

    19 

    20 #include <f32file.h>

    21 #include "fileutil.h"

    22 

    23 TFileUtil::TFileUtil(RFs& aFs) : iFs(aFs)

    24     {

    25     }

    26     

    27 TFileName TFileUtil::ReplaceExtension(const TFileName& aFileName,

    28                                       const TDesC& aExtension)

    29     {

    30     TFileName newFileName;

    31     

    32     TInt extensionOffset = aFileName.LocateReverse('.');

    33     

    34     if (extensionOffset == KErrNotFound)

    35         {

    36         newFileName = aFileName;

    37         newFileName.Append('.');

    38         newFileName.Append(aExtension);

    39         }

    40     else

    41         {

    42         newFileName = aFileName.Left(extensionOffset + 1);

    43         newFileName.Append(aExtension);

    44         }

    45 

    46     return newFileName;

    47     }

    48 

    49 TBool TFileUtil::FileExists(const TFileName& aFileName)

    50     {

    51     TUint fileAttr;

    52 

    53     if (iFs.Att(aFileName, fileAttr) == KErrNone)

    54         {

    55         return ETrue;

    56         }

    57     else

    58         {

    59         return EFalse;

    60         }

    61     }

    62 

    63 HBufC8* TFileUtil::LoadFileDataL(const TFileName& aFileName)

    64     {

    65     RFile file;

    66     CleanupClosePushL(file);

    67 

    68     User::LeaveIfError(file.Open(iFs, aFileName, EFileRead));

    69 

    70     TInt fileSize;

    71     User::LeaveIfError(file.Size(fileSize));

    72 

    73     HBufC8* fileData = HBufC8::NewLC(fileSize);

    74     TPtr8 ptrFileData = fileData->Des();

    75 

    76     User::LeaveIfError(file.Read(ptrFileData));

    77 

    78     CleanupStack::Pop(); // fileData

    79     CleanupStack::PopAndDestroy(); // file

    80 

    81     return fileData;

    82     }

    83 

    84 HBufC* TFileUtil::LoadFileDataUL(const TFileName& aFileName)

    85     {

    86     HBufC8* fileData8 = LoadFileDataL(aFileName);

    87     CleanupStack::PushL(fileData8);

    88 

    89     HBufC* fileData = To16BitL(*fileData8);

    90     

    91     CleanupStack::PopAndDestroy(); // fileData8

    92 

    93     return fileData;

    94     }

    95 

    96 void TFileUtil::SaveFileDataL(const TFileName& aFileName,

    97                               const TDesC& aFileData)

    98     {

    99     HBufC8* fileData8 = To8BitL(aFileData);

   100     CleanupStack::PushL(fileData8);

   101 

   102     SaveFileDataL(aFileName, *fileData8);

   103 

   104     CleanupStack::PopAndDestroy(); // fileData8

   105     }

   106     

   107 void TFileUtil::SaveFileDataL(const TFileName& aFileName,

   108                               const TDesC8& aFileData)

   109     {

   110     RFile file;

   111     CleanupClosePushL(file);

   112 

   113     User::LeaveIfError(file.Replace(iFs, aFileName, EFileWrite));

   114 

   115     User::LeaveIfError(file.Write(aFileData));

   116 

   117     CleanupStack::PopAndDestroy(); // file

   118     }

   119 

   120 HBufC* TFileUtil::MakeFileNameLC(const TDesC& aDir, const TDesC& aName,

   121                                   const TDesC& aExtension)

   122     {

   123     HBufC* fileName = HBufC::NewL(aDir.Length() + aName.Length() + aExtension.Length());

   124     CleanupStack::PushL(fileName);

   125     TPtr fileNamePtr = fileName->Des();

   126     fileNamePtr.Append(aDir);

   127     fileNamePtr.Append(aName);

   128     fileNamePtr.Append(aExtension);

   129 

   130     return fileName;

   131     }

   132 

   133 TFileName TFileUtil::MakeFileName(const TDesC& aDir, const TDesC& aNameAndExtension)

   134     {

   135     TFileName fileName;

   136     

   137     fileName.Copy(aDir);

   138     fileName.Append(aNameAndExtension);

   139 

   140     return fileName;

   141     }

   142     

   143 HBufC* TFileUtil::GetPolFileNameLC(const TVpnPolicyId& aPolicyId)

   144     {

   145    	TPath privateDir;

   146 	User::LeaveIfError(iFs.PrivatePath(privateDir));

   147 	

   148 	return MakeFileNameLC(privateDir, aPolicyId, KPolFileExt);

   149     }

   150 

   151 HBufC* TFileUtil::GetPolFileNameL(const TVpnPolicyId& aPolicyId)

   152     {

   153     HBufC* ret(NULL);

   154    	TPath privateDir;

   155 	User::LeaveIfError(iFs.PrivatePath(privateDir));

   156 	ret = MakeFileNameLC(privateDir, aPolicyId, KPolFileExt);

   157 	CleanupStack::Pop();

   158 	return ret;

   159     }

   160 

   161 HBufC* TFileUtil::GetPinFileNameLC(const TVpnPolicyId& aPolicyId)

   162     {

   163     TPath privateDir;

   164     User::LeaveIfError(iFs.PrivatePath(privateDir));

   165     return MakeFileNameLC(privateDir, aPolicyId, KPinFileExt);

   166     }

   167 

   168 HBufC* TFileUtil::GetPinFileNameL(const TVpnPolicyId& aPolicyId)

   169     {

   170     HBufC* ret(NULL);

   171     TPath privateDir;

   172     User::LeaveIfError(iFs.PrivatePath(privateDir));

   173     ret = MakeFileNameLC(privateDir, aPolicyId, KPinFileExt);

   174     CleanupStack::Pop();

   175     return ret;

   176     }

   177 

   178 TFileName TFileUtil::PolListFileNameL()

   179     {

   180     TPath privateDir;

   181     TInt err = iFs.PrivatePath(privateDir);

   182     return MakeFileName(privateDir, KPolListFile);

   183     }

   184 

   185 void TFileUtil::DeleteFileL(const TFileName& aFileName)

   186     {

   187     User::LeaveIfError(iFs.Delete(aFileName));

   188     }

   189 

   190 void TFileUtil::DeleteFilesL(const TFileName& aFileFilter)

   191     {

   192     CFileMan* fileMan = CFileMan::NewL(iFs);

   193     CleanupStack::PushL(fileMan);

   194 

   195     User::LeaveIfError(fileMan->Delete(aFileFilter));

   196 

   197     CleanupStack::PopAndDestroy(); // fileMan

   198     }

   199 

   200 void TFileUtil::MoveFileL(const TFileName& aSrcFileName, const TFileName& aDstFileName)

   201     {

   202     User::LeaveIfError(iFs.Rename(aSrcFileName, aDstFileName));

   203     }

   204 

   205 void TFileUtil::CopyFileL(const TFileName& aSrcFileName, const TFileName& aDstFileName)

   206     {

   207     CFileMan* fileMan = CFileMan::NewL(iFs);

   208     CleanupStack::PushL(fileMan);

   209 

   210     User::LeaveIfError(fileMan->Copy(aSrcFileName, aDstFileName));

   211 

   212     CleanupStack::PopAndDestroy(); // fileMan

   213     }

   214     

   215 void TFileUtil::CreateDirIfNeededL(const TFileName& aDirName)

   216     {

   217     TFileName dirName;

   218     

   219     dirName.Copy(aDirName);

   220     

   221     if (dirName[dirName.Length() - 1] != '\\')

   222         {

   223         dirName.Append('\\');

   224         }

   225     

   226     if (!FileExists(dirName))

   227         {

   228         User::LeaveIfError(iFs.MkDirAll(dirName));

   229         }

   230     }

   231     

   232 HBufC8* TFileUtil::To8BitL(const TDesC16& aDes)

   233     {

   234     HBufC8* desCopy;

   235     

   236     TInt desLength = aDes.Length();

   237     

   238     if (desLength > 0)

   239         {

   240         desCopy = HBufC8::NewL(desLength);

   241         desCopy->Des().Copy(aDes);

   242         }

   243     else

   244         {

   245         desCopy = HBufC8::NewL(1);

   246         }

   247 

   248     return desCopy;

   249     }

   250 

   251 HBufC16* TFileUtil::To16BitL(const TDesC8& aDes)

   252     {

   253     HBufC16* desCopy;

   254     

   255     TInt desLength = aDes.Length();

   256     

   257     if (desLength > 0)

   258         {

   259         desCopy = HBufC16::NewL(desLength);

   260         desCopy->Des().Copy(aDes);

   261         }

   262     else

   263         {

   264         desCopy = HBufC16::NewL(1);

   265         }

   266 

   267     return desCopy;

   268     }

   269 

   270 void TFileUtil::DeleteDirL(const TFileName& aDirName)

   271     {

   272     if (FileExists(aDirName))

   273         {

   274         CFileMan* fileMan = CFileMan::NewL(iFs);

   275         CleanupStack::PushL(fileMan);

   276 

   277         User::LeaveIfError(fileMan->RmDir(aDirName));

   278         

   279         CleanupStack::PopAndDestroy(); // fileMan

   280         }

   281     }