// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// f32\sfsrv\cl_file.cpp

// 

//

#include <f32file.h>

#include <e32math.h>

#include <cstdio>

#include <errno.h>

#include <sys/stat.h>

#include <unistd.h>

class TFileInfo

	{

public:

	FILE* iHandle;

	TFileName iName;

	TUint iMode;

	};

#define GETFILEHANDLE(A,B) TFileInfo* A; memcpy(&A, B, 4);

#define FILEHANDLE(A) GETFILEHANDLE(A,this);

extern TInt mapErr(TInt);

extern const char* PosixFilename(const TDesC &aIn);

extern const char* PosixFilename(const TDesC &aIn, TDes8& aOut);

/**

Make a duplicate of the passed file handle in the same thread.

By default, any thread in the process can use the duplicated handle to access the 

file. However, specifying EOwnerThread as the second parameter to this function, 

means that only the creating thread can use the handle.

@param	aFile	The file handle to duplicate

@param	aType	An enumeration whose enumerators define the ownership of this 

				handle. If not explicitly specified, EOwnerProcess is taken

				as default.

@return	one of the other system-wide error codes.

*/

EXPORT_C TInt RFile::Duplicate(const RFile& aFile, TOwnerType aType)

	{

	GETFILEHANDLE(h,&aFile);

	TFileName name(h->iName);

	RFs fs;  // This doesn't actually get used in the Open function

	TUint mode = h->iMode;

	// Get the file position

	TInt pos = ftell(h->iHandle);

	if (pos < 0)

		return mapErr(errno);

	// Open the file

	TInt err = Open(fs, name, mode);

	if (err != KErrNone)

		return err;

	// Set the file position

	return Seek(ESeekStart, pos); 

	}

EXPORT_C TInt RFile::Name(TDes &aName) const

/**

Gets the final part of a filename

This is used to retrieve the name and extension of a file that has been 

passed from one process to another using the RFile::AdoptXXX() methods.

@param	aName	On return, contains the name of the file, including the name and 

				extension but excluding the drive letter and path.

@return KErrNone if successful, otherwise one of the other

        system-wide error codes.

*/

	{

    FILEHANDLE(h);

    TParsePtrC ptr(h->iName);

    aName = ptr.NameAndExt();

    return KErrNone;

	}

EXPORT_C TInt RFile::FullName(TDes& aName) const

/**

Gets the full filename

This is used to retrieve the full filename, including drive and path,

of a file that has been passed from one process to another using the 

RFile::AdoptXXX() methods.

@param	aName	On return, contains the full name of the file, including drive and path.

@return KErrNone if successful, otherwise one of the other

        system-wide error codes.

*/

	{

    FILEHANDLE(h);

    aName = h->iName;

    return KErrNone;

	}

/*

"r" 	Open a text file for reading

"r+" 	Open a text file for read/write

"rb" 	Open a binary file for reading

"rb+" 	Open a binary file for read/write

"w" 	Create a text file for writing

"w+" 	Create a text file for read/write

"wb" 	Create a binary file for writing

"wb+" 	Create a binary file for read/write

"a" 	Append to a text file

"ab" 	Append to a binary file

*/

void GetFileMode(TDes8& aBuf, TUint aFileMode, TBool aOpen)

	{

	if (aOpen)

		{

		if (aFileMode & EFileWrite)

			// Open a binary file for read/write

			aBuf = _L8("rb+");

		else

			// Open a binary file for reading

			aBuf = _L8("rb");

		}

	else

		// Create a binary file for read/write 

		aBuf = _L8("wb+");

	}

TInt DoOpen(RFile* aFile, const TDesC &aName, TUint aFileMode, TBool aOpen)

    {

	const char* name = PosixFilename(aName);

	TFileInfo* info = new TFileInfo;

	if (!info)

		return KErrNoMemory;

	TBuf8<4> mode;

	GetFileMode(mode, aFileMode, aOpen);

	info->iHandle = fopen(name, reinterpret_cast<const char*>(mode.PtrZ()));

#ifdef _DEBUG_LOGGING

    RDebug::Print(_L("DEBUG: DoOpen> file=%S id=%x\n"), &aName, info->iHandle);

#endif

    if (!info->iHandle)

    	{

    	delete info;

    	return mapErr(errno);

    	}

	// Symbian expects file pos at the begining

	if (aOpen && aFileMode|EFileWrite)

		{

		if (fseek(info->iHandle, 0, SEEK_SET) != 0)

			{

			fclose(info->iHandle);

			delete info;

	    	return mapErr(errno);

			}

		}

    info->iName = aName;

    info->iMode = aFileMode;

    memcpy(aFile, &info, 4);

    return KErrNone;

    }

EXPORT_C TInt RFile::Open(RFs& aFs, const TDesC& aName, TUint aFileMode)

/**

Opens an existing file for reading or writing.

If the file does not already exist, an error is returned.

Notes:

1. To close the file, use Close()

2. Attempting to open a file with the read-only attribute using the EFileWrite

   access mode results in an error.

3. Attempting to open a file which is greater than or equal to 2GByte (2,147,483,648 bytes)

   will fail with KErrTooBig

4. After a file has been opened, the current write position is set to the start

   of the file.

   If necessary, use RFile::Seek() to move to a different position within

   the file.

@param aFs   The file server session.

@param aName The name of the file. Any path components (i.e. drive letter

             or directory), which are not specified, are taken from

             the session path.

@param aMode The mode in which the file is opened. See TFileMode.

@return KErrNone if successful, otherwise one of the other system-wide

        error codes.

@see TFileMode

@capability Dependent If the path for aName is /Sys and aMode is neither

					  EFileShareReadersOnly nor EFileRead then Tcb capability is required.

@capability Dependent If the path for aName is /Sys and aMode is either

					  EFileShareReadersOnly or EFileRead then Allfiles capability is required.

@capability Dependent If the path for aName begins with /Private and does not match this process'

					  SID then AllFiles capability is required.

@capability Dependent If the path for aName begins with /Resource and aMode is neither

 					  EFileShareReadersOrWriters|EFileRead nor EFileShareReadersOnly 

 					  nor EFileRead then Tcb capability is required.

*/

    {

#ifdef _DEBUG_LOGGING

	RDebug::Print(_L("DEBUG: RFile::Open> name=%S mode=%x\n"), &aName, aFileMode);

#endif

    return DoOpen(this, aName, aFileMode, ETrue);

    }

EXPORT_C void RFile::Close()

/**

Closes the file.

Any open files are closed when the file server session is closed.

Close() is guaranteed to return, and provides no indication whether

it completed successfully or not. When closing a file you have written to,

you should ensure that data is committed to the file by invoking RFile::Flush()

before closing. If Flush() completes successfully, Close() is essentially a

no-operation.

*/

    {

    FILEHANDLE(h);

    if (h)

    	{

    	fflush(h->iHandle);

    	fclose(h->iHandle);

    	delete h;

		// Make sure the handle is null

        memset(this, 0, 4);

    	}

    }

EXPORT_C TInt RFile::Create(RFs& aFs, const TDesC& aName, TUint aFileMode)

/**

Creates and opens a new file for writing.

If the file already exists, an error is returned.

If the resulting path does not exist, then the operation cannot proceed and

the function returns an error code.

Notes:

1. To close the file, use Close()

2. It automatically sets the file's archive attribute.

@param aFs   The file server session.

@param aName The name of the file. Any path components (i.e. drive letter

             or directory), which are not specified, are taken from

             the session path.

@param aMode The mode in which the file is opened. The access mode is

             automatically set to EFileWrite. See TFileMode.

@return KErrNone if successful, otherwise one of the other system-wide

        error codes.

@see TFileMode

@capability Dependent If the path in aName starts with /Sys then capability Tcb is required

@capability Dependent If the path in aName starts with /Resource then capability Tcb is required

@capability Dependent If the path in aName starts with /Private and does not match this process'

					  SID then AllFiles capability is required.

*/

    {

#ifdef _DEBUG_LOGGING

    RDebug::Print(_L("DEBUG: RFile::Create> name=%S mode=%x\n"), &aName, aFileMode);

#endif

    TUint att;

    if (aFs.Att(aName, att) == KErrNone)

    	return KErrAlreadyExists;

    return DoOpen(this, aName, aFileMode|EFileWrite, EFalse);

    }

EXPORT_C TInt RFile::Replace(RFs& aFs, const TDesC& aName, TUint aFileMode)

/**

Opens a file for writing, replacing the content of any existing file of the

same name if it exists, or creating a new file if it does not exist.

If the resulting path exists, then:

- the length of an existing file with the same filename is re-set to zero 

- a new file is created, if no existing file with the same filename can be found.

If the resulting path does not exist, then the operation cannot proceed and

the function returns an error code.

Notes:

- To close the file, use Close(), defined in the base class RFsBase.

- It automatically sets the file's archive attribute.

@param aFs   The file server session.

@param aName The name of the file. Any path components (i.e. drive letter

             or directory), which are not specified, are taken from

             the session path.

@param aMode The mode in which the file is opened. The access mode is

             automatically set to EFileWrite. See TFileMode.

@return KErrNone if successful, otherwise one of the other system-wide

        error codes.

@see TFileMode

@capability Dependent If the path in aName starts with /Sys then capability Tcb is required

@capability Dependent If the path in aName starts with /Resource then capability Tcb is required

@capability Dependent If the path in aName starts with /Private and does not match this process'

					  SID then AllFiles capability is required.

*/

    {

#ifdef _DEBUG_LOGGING

    RDebug::Print(_L("DEBUG: RFile::Replace> name=%S mode=%x\n"), &aName, aFileMode);

#endif

    return DoOpen(this, aName, aFileMode|EFileWrite, EFalse);

    }

EXPORT_C TInt RFile::Temp(RFs& aFs, const TDesC& aPath, TFileName& aName, TUint aFileMode)

/**

Creates and opens a temporary file with a unique name for writing and reading.

Notes:

1. To close the file, use Close()

@param aFs   The file server session.

@param aPath The directory in which the file is created.

@param aName On return, contains the full path and file name of the file.

             The filename is guaranteed to be unique within the directory

             specified by aPath.

@param aMode The mode in which the file is opened. The access mode is

             automatically set to EFileWrite. See TFileMode.

@return KErrNone if successful, otherwise one of the other system-wide

        error codes.

@see TFileMode

@capability Dependent If aPath starts with /Sys then capability Tcb is required

@capability Dependent If aPath starts with /Resource then capability Tcb is required

@capability Dependent If aPath starts with /Private and does not match this process'

					  SID then AllFiles capability is required.

*/

	{

	// Check for a valid path

	if (aPath.Length() > 0 && aPath[aPath.Length() - 1] != '\\')

		return KErrBadName;

	// Create a temporary file name

	TFileName name;

	while(1)

		{

		name.Format(_L("%Ssymport%d.tmp"), &aPath, Math::Random());	

		TUint att;

		TInt err = aFs.Att(name, att);

		if (err == KErrNotFound)

			break;

		else if (err != KErrNone)

			return err;

		}

	TInt err = Create(aFs, name, aFileMode);

	if (err == KErrNone)

		{

		aName = name;

		return KErrNone;

		}

	// The path couldn't be found

	else if (err == KErrNotFound)

		return KErrBadName;

	return err;

	}

EXPORT_C TInt RFile::Read(TDes8& aDes) const

/**

Reads from the file at the current position.

This is a synchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into 

it. Therefore, when reading through a file,the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

@param aDes Descriptor into which binary data is read. Any existing contents 

            are overwritten. On return, its length is set to the number of

            bytes read.

@return KErrNone if successful, otherwise one of the other system-wide error 

        codes.

@see TDesC8::Length

*/

	{

	return Read(aDes, aDes.MaxLength());

	}

EXPORT_C TInt RFile::Read(TDes8& aDes, TInt aLength) const

/**

Reads the specified number of bytes of binary data from the file at the current position.

This is a synchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into 

it. Therefore, when reading through a file,the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

Assuming aLength is less than the maximum length of the descriptor, the only circumstances 

in which Read() can return fewer bytes than requested, is when the end of 

file is reached or if an error occurs.

@param aDes    Descriptor into which binary data is read. Any existing

               contents are overwritten. On return, its length is set to

               the number of bytes read.

@param aLength The number of bytes to be read from the file into the descriptor. 

               If an attempt is made to read more bytes than the descriptor's 

               maximum length, the function returns KErrOverflow.

               This value must not be negative, otherwise the function

               returns KErrArgument.

@return KErrNone if successful, otherwise one of the other system-wide error

        codes.

*/

	{

#ifdef _DEBUG_LOGGING

    RDebug::Print(_L("DEBUG: Read1> length=%d\n"), aLength);

#endif

    FILEHANDLE(h);

    if (aLength > aDes.MaxLength())

    	return KErrOverflow;

	// If the file has been written then you have set the position for a read to succeed

	fseek(h->iHandle, 0, SEEK_CUR);

    size_t len = fread(const_cast<TUint8*>(aDes.Ptr()), 1, aLength, h->iHandle);

	TInt err = ferror(h->iHandle);

	if (err != 0)

		return mapErr(err);

	aDes.SetLength(len);

    return KErrNone;

	}

EXPORT_C TInt RFile::Read(TInt aPos, TDes8& aDes) const

/**

Reads from the file at the specified offset within the file

This is a synchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into it.

Therefore, when reading through a file, the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

@param aPos Position of first byte to be read.  This is an offset from

            the start of the file. If no position is specified, reading

            begins at the current file position. 

            If aPos is beyond the end of the file, the function returns

            a zero length descriptor.

@param aDes The descriptor into which binary data is read. Any existing content

            is overwritten. On return, its length is set to the number of

            bytes read.

@return KErrNone if successful, otherwise one of the other system-wide error 

        codes.

@panic FSCLIENT 19 if aPos is negative.        

*/

	{

    return Read(aPos, aDes, aDes.MaxLength());

	}

EXPORT_C TInt RFile::Read(TInt aPos, TDes8& aDes, TInt aLength) const

/**

Reads the specified number of bytes of binary data from the file at a specified 

offset within the file.

This is a synchronous function.