/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: connectors for re-entrant system calls

*/

// connectors for re-entrant system calls

#include "sysif.h"

#include "lposix.h"

#include <unistd.h>

#include <fcntl.h>		// for open()

#include <sys/ioctl.h>

#include <stdarg.h> 

#include <sys/errno.h>

#include <sys/stat.h>

#include <utf.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include "sysreent.h"

#include <sys/aeselect.h>

#include "aeselectreent.h"

#include "fdesc.h"

#include "stdio_r.h"		// for popen3

#include "stdlib_r.h"		// for system

#if (defined(__SYMBIAN32__) && (defined(__WINSCW__) || defined(__WINS__)))

#include "libc_wsd_defs.h"

#endif

#define	MAXPATHLEN	260	/* E32STD.H: KMaxFullName + 4 to avoid data loss */

extern "C" {

/*

Opens the file which name is stored in the file string.

*/

EXPORT_C int open (const char *file, int flags, ...)

	{

	va_list argList; 

	register int perms;

	if(!file) 

		{

    	errno = EFAULT ;

    	return -1 ;	//null file pointer

		}

	va_start (argList, flags);

	perms = va_arg(argList,int);

	va_end (argList);

	//If mode is invalid

	if( perms  > (S_IRWXU | S_IRWXG | S_IRWXO ) )

		{

		//make it read-write for all

		perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;

		}

	wchar_t _widename[MAXPATHLEN+1];

	if ((size_t)-1 != mbstowcs(_widename, file, MAXPATHLEN))

		{

		return _open_r (&errno, _widename, flags, perms);  

		}

	else

		{

		errno = EILSEQ;		

		return -1;	// Illegal Sequence of wide characeters

		}

	}

/*

A wide_character version of a open().

*/

EXPORT_C int wopen (const wchar_t *file, int flags, ...)

	{

	va_list ap;

	int ret;

	register int perms;

	if(!file)

		{

    	errno = EFAULT ;

    	return -1 ;	

		}

	va_start (ap, flags);

	perms = va_arg(ap,int);

	va_end (ap);

	//If mode is invalid

	if( perms  > (S_IRWXU | S_IRWXG | S_IRWXO ) )

		{

		//make it read-write for all

		perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;

		}

	ret = _wopen_r (&errno, file, flags, perms);

	return ret;

	}

/*

Reads a block of data of the length specified by cnt.

*/

EXPORT_C int read (int fd, void *buf, size_t cnt)

	{

	if((int)cnt == 0)       

		{

			return 0 ;

		}	

	if((int)cnt < 0) 

		{

	  	errno = EINVAL ;

	  	return -1 ;

		}

	if(!buf)

	  	{

	  	errno = EFAULT ;

	  	return -1 ;

	  	}

	//If the fd corresponding to STDIN

	if(fd == STDIN_FILENO && (Backend()->GetDesc(STDIN_FILENO))->Attributes() == KConsoleFd) 

		{

		int len = 0;

		char ch = '\0';

		int ret = -1;

		do

			{

			ret = _read_r(&errno, STDIN_FILENO, &ch, 1);

			//Copy requested count of data, ignore the rest

			if(ret > 0 && len < cnt )

				{

				((char*)buf)[len] = ch;

				len++;

				}

			else if(ret < 0)

				{

				break;

				}

			}while(ch != '\n');

		//Handle error case.

		if(ret == -1)

			{

			return ret;

			}

		return len;

		}

	else

		{

		return _read_r(&errno, fd, (char*)buf, cnt);

		}

	}

/*

Writes a block of data of the length specified by cnt.

*/

EXPORT_C int write (int fd, const void *buf, size_t cnt)

	{

		if((int)cnt == 0) 

		{

	   	return 0;

		}

	if((int)cnt < 0) 

		{

	   	errno = EINVAL;

	   	return -1;

		}

	if(!buf) 

	   	{

	   	errno = EFAULT ;

	   	return -1 ;

	   	}

	return _write_r(&errno, fd, (char*)buf, cnt);

	}

/*

Close a file.

*/

EXPORT_C int close (int fd)

	{

	return  _close_r(&errno, fd);

	}

/*

Synchronizes a file's in-memory state with that on the physical medium.

*/

EXPORT_C int fsync (int fd)

	{

	return _fsync_r(&errno, fd);

	}

/*

Repositions the read/write file offset.

*/

EXPORT_C off_t lseek (int fd, off_t pos, int whence)

	{

	return _lseek_r(&errno, fd, pos, whence);

	}

/*

Gets information about the named file and writes it to the area that buf points to.

The system must be able to search all directories leading to the file; 

however, read, write, or execute permission of the file is not required.

*/

EXPORT_C int fstat (int fd, struct stat *st)

	{

	if(!st)

	   {

	    errno = EFAULT ;

	    return -1 ;	

	   }

	return _fstat_r(&errno, fd, st);

	}

/*

Gets the size of a file. 

*/

EXPORT_C int stat (const char *name, struct stat *st)

	{

	if(!st)

	   {

	    errno = EFAULT ;

	    return -1 ;	

	   }

    wchar_t tmpbuf[MAXPATHLEN+1];	

	if ((size_t)-1 != mbstowcs(tmpbuf, name, MAXPATHLEN))

		{

		return _stat_r(&errno, tmpbuf, st);

		}

	errno = EILSEQ;		

	return -1;

	}

EXPORT_C int utime (const char *name, const struct utimbuf *filetimes)

	{

	if(!name) 

		{

		errno = EFAULT ;

		return -1 ;

		}

	wchar_t tmpbuf[MAXPATHLEN+1];	

	if ((size_t)-1 != mbstowcs(tmpbuf, name, MAXPATHLEN))

		{

		return _utime_r (&errno, tmpbuf, filetimes);

		}

	errno = EILSEQ;		

	return -1;

	}

/*

A wide_character version of a stat().

*/

EXPORT_C int wstat (const wchar_t *name, struct stat *st)

	{

			if( !name || !st )

			{

					errno = EFAULT;

					return -1;

			}

	return _wstat_r (&errno, name, st);

	}

/*

duplicates an open file descriptor.

*/

EXPORT_C int dup (int aFid)

	{

	return _dup_r(&errno, aFid);

	}

/*

function duplicates an open file descriptor.

*/

EXPORT_C int dup2 (int aFid1, int aFid2)

	{

	return _dup2_r(&errno, aFid1, aFid2);

	}

/*

sorms a variety of device-specific control functions on device special files.

*/

EXPORT_C int ioctl (int aFid, unsigned long aCmd, ...)

	{

	void* aParam ;

	va_list  Vlist ;

	int ret;

	va_start(Vlist , aCmd ) ;

	aParam = va_arg(Vlist , void *)  ;

	if(!aParam) 

		{

		errno = EFAULT ; 

		return -1 ;

		}

	ret = _ioctl_r(&errno, aFid, aCmd, aParam);

	va_end(Vlist) ;

	return ret;

	}

/*

Gets the path name of the current working directory.

If a buffer is specified, the path name is placed in that buffer,

and the address of the buffer is returned.

*/

/*

A wide_character version of a getcwd().

*/

EXPORT_C wchar_t* wgetcwd (wchar_t *_buf, size_t _size)

	{

	return _wgetcwd_r(&errno, _buf, _size);

	}

/*

Changes the current working directory to be pathname. 

The current directory is the beginning point for file 

searches when path names are not absolute. 

If the chdir() function fails, the current working directory remains unchanged.

*/

EXPORT_C int chdir (const char *_path)

	{

	if(!_path) 

		{

		errno = EFAULT;

		return -1;

	  	}

	//we need to use a wide buffer and convert

	wchar_t tmpbuf[MAXPATHLEN+1];		//use the max path length possible

	if ((size_t)-1 != mbstowcs(tmpbuf, _path, MAXPATHLEN))

		{

		return _chdir_r(&errno, tmpbuf);

		}

	errno = EILSEQ;		

	return -1;

	}

/* A wide-character version of chdir().

*/

EXPORT_C int wchdir (const wchar_t *_path)

	{

	if(!_path) 

		{

		errno = EFAULT;

		return -1;

	  	}

	return _wchdir_r(&errno, _path);

	}

/*

Removes an empty directory whose name is given by pathname.

The directory must not have any entries other than dot (.) and dot-dot (..).

*/

EXPORT_C int rmdir (const char *_path)

	{

	if(!_path)

		{

		errno = EFAULT ;

		return -1 ;

		}

	if(!strcmp((_path + strlen(_path) -1 ) , ".") ) 

		{

		errno = EINVAL ;

		return -1 ;  

		}

	wchar_t tmpbuf[MAXPATHLEN+1];		//use the max path length possible

	if ((size_t)-1 != mbstowcs(tmpbuf, _path, MAXPATHLEN))

		{

		return _rmdir_r(&errno, tmpbuf);

		}

	errno = EILSEQ;		

	return -1;

	}

/* A wide-character version of rmdir().

*/

EXPORT_C int wrmdir (const wchar_t *_path)

	{

			if( !_path )

			{

				 errno = EFAULT;

				 return -1;

			}

	return _wrmdir_r(&errno, _path);

	}

/*

Creates a new directory with the specified path name. 

The file permissions of the new directory are initialized from the specified mode. 

*/

EXPORT_C int mkdir (const char *_path, mode_t _mode)

	{

	if(!_path)

		{

		errno = EFAULT ;

		return -1 ;

		}

	//we need to use a wide buffer and convert

	wchar_t tmpbuf[MAXPATHLEN+1];		//use the max path length possible

	if ((size_t)-1 != mbstowcs(tmpbuf, _path, MAXPATHLEN))

		{

		return _mkdir_r(&errno, tmpbuf, _mode);

		}

	errno = EILSEQ;		

	return -1;

	}

/* A wide-character version of mkdir().

*/

EXPORT_C int wmkdir (const wchar_t *_path, mode_t _mode)

	{

	if(!_path)

		{

		errno = EFAULT ;

		return -1 ;

		}

	return _wmkdir_r(&errno, _path, _mode);

	}

/*

Sets the access permissions for the file 

whose name is given by pathname to the bit pattern contained in mode. 

For this call to succeed, the effective user ID of the process must match 

the owner of the file, or the process must have appropriate privileges. 

The owner of the file pathname always has privileges to change permission modes 

and file attributes.

*/

EXPORT_C int chmod (const char *_path, mode_t _mode)

	{

	if(!_path)

		{

		errno = EFAULT ;

		return -1 ;

		}

	wchar_t tmpbuf[MAXPATHLEN+1];	

	if ((size_t)-1 != mbstowcs(tmpbuf, _path, MAXPATHLEN))

		{

		return _chmod_r(&errno, tmpbuf, _mode);

		}

	errno = EILSEQ;		

	return -1;

	}

/*

Sets the access permissions for the file specifed by file descriptor

whose name is given by pathname to the bit pattern contained in mode. 

For this call to succeed, the effective user ID of the process must match 

the owner of the file, or the process must have appropriate privileges. 

The owner of the file pathname always has privileges to change permission modes 

and file attributes.

*/

EXPORT_C int fchmod (int fd , mode_t _mode)

	{

		return _fchmod_r(&errno, fd, _mode);

	}

/* A wide-character version of chmod().

*/

EXPORT_C int wchmod (const wchar_t *_path, mode_t _mode)

	{

	if(!_path)

		{

		errno = EFAULT ;

		return -1 ;

		}

	return _wchmod_r(&errno, _path, _mode);

	}