// 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_cli.cpp

// 

//

#include <f32file.h>

#include <e32debug.h>

#include "cl_std.h"

#ifdef _WIN32

#include <cstdio>

#include <io.h>

#include <sys/stat.h>

#include <string>

#else

#include <time.h>

#include <sys/stat.h>

#include <unistd.h>

#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#endif

// ***

// Map a Posix error to a Symbian error code

//

TInt mapErrSwitch(TInt aErr)

	{

	switch (aErr)

		{

	case ENOENT:

		return KErrNotFound;

	case EACCES:

	case EPIPE:

	case EROFS:

		return KErrAccessDenied;

	case EINVAL:

	case EISDIR:

	case ENOTDIR:

		return KErrArgument;

	case ENOTEMPTY:

	case EBUSY:

		return KErrInUse;

	case EEXIST:

		return KErrAlreadyExists;

	case EBADF:

		return KErrBadHandle;

	case ENOMEM:

		return KErrNoMemory;

	case EFBIG:

		return KErrTooBig;

	default:

		return -aErr;

		}

	return aErr;

	}

// ***

// Map a Posix error to a Symbian error code

//

TInt mapErr(TInt aErr)

	{

	TInt symErr = mapErrSwitch(aErr);

#ifdef _DEBUG_LOGGING

	if (aErr != KErrNone)

		RDebug::Print(_L("DEBUG: mapErr> %d => %d\n"), aErr, symErr);

#endif

	return symErr;

	}

#ifdef _WIN32

const char KNativeSlashChar = '\\';

#else

const char KNativeSlashChar = '/';

#endif

// ***

// Is the character a Symbian path separator?

//

TBool IsPathSep(TChar aChar)

	{

	return aChar == TChar('\\');

	}

// ***

// Perform posix filename conversions

//

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

	{

	aOut.Zero();

	for(TInt pos = 0; pos < aIn.Length(); pos++)

		{

		TChar c(aIn[pos]);

		// Magic for using epocroot

		if (pos == 0 && aIn.Length() >= 7 && IsPathSep(aIn[0]) && aIn.Mid(1, 6).CompareF(_L("epoc32")) == 0)

			{

			char* epocroot = getenv("EPOCROOT");

			if (epocroot)

				{

				aOut.Append(TPtrC8(reinterpret_cast<const TUint8*>(epocroot), strlen(epocroot)));

				// If the last character of EPOCROOT is not a slash then we have to add one

				if (aOut[aOut.Length() - 1] != KNativeSlashChar)

					aOut.Append(KNativeSlashChar);

				continue;

				}

			}

#ifndef _WIN32

		// Drive letters ignored - go back home!

		if (pos == 0 && aIn[1] == ':' && IsPathSep(aIn[2]))

			{

			char* home = getenv("HOME");

			if (home)

				aOut.Append(TPtrC8(reinterpret_cast<const TUint8*>(home), strlen(home)));

			pos++;

			continue;

			}

		// Convert backslashes to forward slashes

		if (c == '\\')

			{

			aOut.Append('/');

			continue;

			}

		// Lower case everything

		c = c.GetLowerCase();

#endif

		aOut.Append(c);

		}

	const char* ret = reinterpret_cast<const char*>(aOut.PtrZ());

#ifdef _DEBUG_LOGGING

    RDebug::Printf("DEBUG: PosixFilename> %s\n", ret);

#endif

	return ret;

	}

TBuf8<0x200> gFilenameBuf;

const char* PosixFilename(const TDesC &aIn)

	{

	// Return the result

	return PosixFilename(aIn, gFilenameBuf);

	}

EXPORT_C TBool RFs::IsValidDrive(TInt aDrive)

/**

Tests whether the specified drive number is valid.

A valid drive number is any number between 0 and (KMaxDrives-1) inclusive,

or the specific value KDefaultDrive (implying the session default drive).

@param aDrive The drive number.

@return True if the drive is valid; false if not.				

@see TDriveNumber 				

*/

	{

	return((aDrive>=0 && aDrive<KMaxDrives) || aDrive==KDefaultDrive);

	}

EXPORT_C TInt RFs::CharToDrive(TChar aChar,TInt& aDrive)

/**

Maps a drive character to a drive number.

The drive character must be in the range A to Z or a to z. For example, drive A (or a)

corresponds to zero, drive B (or b) corresponds to 1 etc. For the drive number

enumeration, see TDriveNumber.

@param aChar  The drive character.

@param aDrive On return, contains the drive number.

@return KErrNone, if successful;

        KErrArgument, if the drive character is not in the range A to Z or a to z.

@see TDriveNumber        

*/

	{

	aChar.UpperCase();

	if (aChar>='A' && aChar<='Z')

		{

		aDrive=(TInt)aChar-'A';

		return(KErrNone);

		}

	return(KErrArgument);

	}

EXPORT_C TInt RFs::DriveToChar(TInt aDrive,TChar& aChar)

/**

Maps a drive number to the corresponding character.

The drive number must be in the range 0 to (KMaxDrives-1). For example, drive

number zero (EDriveA) corresponds to drive A, one (EDriveB)

corresponds to drive B. For the drive number enumeration, see TDriveNumber.

The drive number can also be KDefaultDrive, implying the default drive. In this

case the current drive is taken and converted.

@param aDrive The drive number.

@param aChar  On return, contains the drive character.

@return KErrNone, if successful;

        KErrArgument, if the drive number is invalid;

        otherwise one of the other system-wide error codes.

*/

	{

	if (aDrive==KDefaultDrive)

		{

#ifdef _WIN32

		RFs fs;

		TFileName path;

		TInt r=fs.Connect();

		if (r!=KErrNone)

			return(r);

		r=fs.SessionPath(path);

		fs.Close();

		if (r!=KErrNone)

			return(r);

		aChar=path[0];

		return(KErrNone);

#else

		aChar='C';

		return KErrNone;

#endif

		}

	if (!IsValidDrive(aDrive))

		return(KErrArgument);

	aChar=aDrive+'A';

	return(KErrNone);

	}

/** 

Obtain the system drive number.

The System Drive is a defined drive on the device which is:

 - Read/Writeable

 - Internal: Always available and not removable from the device

 - Non-Volatile (e.g. Flash memory, battery-backed RAM)

 - Only Accessible via Rfs (e.g. not available via USB mass storage)

The System drive is utilised as:

 - Storage for Persistent settings from system and application software

 - Storage for Localisation resources

 - A Default Drive for user data

 - A Target Drive for Software installations

It the system drive is not set previously (see RFs::SetSystemDrive) EDriveC is returned by default.

@see RFs::GetSystemDriveChar

@see RFs::SetSystemDrive   

@see TDriveNumber

@return TDriveNumber contains the drive number of the system drive.

 */

EXPORT_C TDriveNumber RFs::GetSystemDrive()

	{

	return EDriveC;

	}

/**

This is a wrapper around GetSystemDrive() function. It returns the character corresponding to the system drive.

@parameter aDriveChar On return, contains the system drive character

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

@see RFs::GetSystemDrive

*/

EXPORT_C TChar RFs::GetSystemDriveChar()

	{

	return 'A' + GetSystemDrive();

	}

EXPORT_C TInt RFs::Connect(TInt)

/**

Connects a client to the file server.

To end the file server session, use Close().

@param aMessageSlots The number of message slots required. The default value of

				     KFileServerDefaultMessageSlots indicates that message

				     slots will be acquired dynamically from the system

				     wide pool. Override this value with a fixed number, if

				     a fixed number of slots are to be allocated to the session.

				     If overriding, note that the number of message slots

				     represents the number of operations, such as reads

				     and writes, that can be outstanding at once;

				     always remember to provide a spare slot for

				     the cancel operation.

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

        error codes.

*/

	{

	return KErrNone;

	}

EXPORT_C TInt RFs::Drive(TDriveInfo& anInfo, TInt aDrive) const

/**

Gets information about a drive and the medium mounted on it.

Note that Volume() can also be used to give information about the drive and

the volume mounted on it. These two functions are separate because, while

the characteristics of a drive cannot change, those of a

volume can, by mounting different media, reformatting etc.

@param anInfo On return, contains information describing the drive

			  and the medium mounted on it. The value of TDriveInfo::iType

			  shows whether the drive contains media.

@param aDrive The drive for which information is requested.

              Specify KDefaultDrive for the session default drive.

			  Specify a drive in the range EDriveA to EDriveZ for drives

			  A to Z respectively.

@return       KErrNone, if successful, otherwise one of the other

              system-wide error codes.

@see RFs::Volume

*/

	{

	if (aDrive != EDriveC && aDrive != KDefaultDrive)

		return KErrBadName;

	anInfo.iType = EMediaHardDisk;

	anInfo.iBattery = EBatNotSupported;

	anInfo.iDriveAtt = KDriveAttLocal|KDriveAttInternal;

	anInfo.iMediaAtt = 0;

	return KErrNone;

	}

EXPORT_C TInt RFs::SessionPath(TDes& aPath) const

/**

Gets the session path.

When a client connects to the file server, its session path is initialised to

the system default path. The session path of an existing client can only be

changed by this function.

@param aPath On return, contains the session path, including a trailing

             backslash.

@return KErrNone if successful, otherwise one of the other

        system-wide error codes.

*/

	{

#ifdef _DEBUG_LOGGING

    RDebug::Print(_L("DEBUG: SessionPath\n"), &aPath);

#endif

	TBuf8<KMaxFileName + 1> copy;

	copy.Copy(aPath.Left(KMaxFileName));

	// As the system for the current work directory

	const char* path = reinterpret_cast<const char*>(copy.PtrZ());

	if (getcwd(const_cast<char*>(path), copy.MaxLength() - 1) == NULL)

		return mapErr(errno);

	// Get the length of the data

	TInt len = strlen(path);	

	copy.SetLength(len);

	// We need one extra character of space for the backslash on the end

	if (len == KMaxFileName)

		return KErrOverflow;

	// Make sure we use backslash rather than forward 

	while(len--)

		{

		if (copy[len] == '/')

			copy[len] = '\\';

		}

	// Copy the data and append a back slash, as Symbian expects it

	aPath.Copy(copy);

	aPath.Append(TChar('\\'));

	return KErrNone;

	}

EXPORT_C TInt RFs::SetSessionPath(const TDesC& aPath)

/**

Sets the session path for the current file server client.

When the client first connects to the file server, its session path

is initialised to the system default path.

Note that the session path is text-only. It does not cause any locking.

Thus, although the path must be syntactically correct, its components

do not need to be valid at the time the path is set, and any component may be

deleted, removed or unmounted while the path is set.

On TOOLS2 this function modifies the session path for ALL RFs sessions.

@param aPath The new session path. Consists of a drive and path. Normally, a

             drive should be specified, but if not, the drive specified in

             the existing session path is preserved. If a file is specified,

             then the function fails and returns an error code. Therefore,

             the final component in the path must have a trailing backslash

             to indicate that it is a directory. All components of the

             path must be syntactically correct, for example, wildcard

             characters and double backslashes are not allowed in any

             part of it.

@return KErrNone if successful, otherwise one of the other

        system-wide error codes.

@capability Dependent If aPath is /Sys then AllFiles capability is required.

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

					  then AllFiles capability is required.

*/

	{

#ifdef _DEBUG_LOGGING

    RDebug::Print(_L("DEBUG: SetSessionPath> path=%S\n"), &aPath);

#endif

	const char* name = PosixFilename(aPath);

	if (chdir(name) != 0)

		return mapErr(errno);

	return KErrNone;

	}

/**

Makes a directory.

It should be a sub-directory of an existing	directory and its name should be

unique within its parent directory, otherwise the function returns error code KErrAlreadyExists.

Note that if a filename is specified in the argument, it is	ignored.

Therefore, there should be a trailing backslash after the final

directory name in the argument to indicate that it is a directory, not a filename. 

For example, following code will create directory "C:\\DIR1\\"

@code

fs.MkDir(_L("C:\\DIR1\\"));

@endcode

The last line in the following example will result in KErrAlreadyExists because "DIR2" doesn't have a trailing backslash, 

therefore is considered as a file name and discarded. Directory "C:\\DIR1\\" has already been created.

@code

fs.MkDir(_L("C:\\DIR1\\"));     // shall create DIR1 in the root directory

fs.MkDir(_L("C:\\DIR1\\DIR2")); // No trailing backslash, fails with KErrAlreadyExists

@endcode

This example will always fail because "DIR1" doesn't have a trailing backslash and discarded while the root

directory always exists. 

@code

fs.MkDir(_L("C:\\DIR1"));  // No trailing backslash, will always fail with KErrAlreadyExists

@endcode

Note, the following case

@code

fs.MkDir(_L("C:\\example.txt\\"));	// would normally create a directory "c:\\example.txt\\" with KErrNone

@endcode

But if there is a file named "example.txt", which exists at the same location, KErrAccessDenied is returned.    

Note also that because this method can return an error code (eg. because

the disk is full) before checking whether the path already exists, it

is not appropriate to use it just to work out whether a path exists or not.

See MkDirAll(), which may also create intermediate directories.

@param aPath The name of the new directory. Any path components which are

             not specified here will be taken from the session path.

@return KErrNone if successful, otherwise one of the other

        system-wide error codes. Even if another error code is returned,

		(for example, if the disk is full) it is still possible that the 

		path may already exist.

@capability Dependent If aPath is /Sys then Tcb capability is required.

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

					  then AllFiles capability is required.

@capability Dependent If aPath is /Resource then Tcb capability is required.

@see RFs::MkDirAll       

*/

EXPORT_C TInt RFs::MkDir(const TDesC& aPath)

	{

#ifdef _DEBUG_LOGGING

    RDebug::Print(_L("DEBUG: MkDir> path=%S\n"), &aPath);

#endif

	// Skip the file on the end

	TInt len = aPath.Length();

	while(len > 0 && !IsPathSep(aPath[len-1]))

		len--;