// Copyright (c) 1998-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

// 

//

#include "SYSIF.H"

#include "LPOSIX.H"

#include <reent.h>

#include <unistd.h>

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

#include <sys/ioctl.h>

#include <stdarg.h>

#include <sys/errno.h>

#include <stdio_r.h>		// for popen3

#include <stdlib_r.h>		// for system

#include <utf.h>

#include <string.h>

extern "C" {

/**

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

@return	On Success, a non-negative integer representing the lowest numbered unused file descriptor.

		On Failure, returns -1, errno may be set.		

*/

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

	{

	va_list ap;

	int ret;

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	va_start (ap, flags);

	ret = _open_r (r, file, flags, va_arg (ap, int));

	va_end (ap);

	return ret;

	}

/**

A wide_character version of a open().

*/

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

	{

	va_list ap;

	int ret;

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	va_start (ap, flags);

	ret = _wopen_r (r, file, flags, va_arg (ap, int));

	va_end (ap);

	return ret;

	}

/** A reentrant version of open().

*/

EXPORT_C int _open_r (struct _reent *r, const char *name, int mode, int perms)

	{

	wchar_t _widename[KMaxFileName+1];

	if (-1 != mbstowcs(_widename, name, KMaxFileName))

		{

		MSystemInterface& sysIf=Interface(r);

		return sysIf.open(_widename,mode,perms,r->_errno);

		}

	MapError(EILSEQ, r->_errno);		

	return 0;	//null file pointer

	}

/** A reentrant version of wopen().

*/

EXPORT_C int _wopen_r (struct _reent *r, const wchar_t *name, int mode, int perms)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.open(name,mode,perms,r->_errno);

	}

/**

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

@return On Success, return a non-negative integer indicating the number of bytes actually read.

		On Failure, returns -1, errno may be set.		

*/

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

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _read_r (r, fd, buf, cnt);

	}

/** A reentrant version of read().

*/

EXPORT_C int _read_r (struct _reent *r, int fd, char *buf, size_t nbyte)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.read(fd,buf,nbyte,r->_errno);

	}

/**

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

@return On Success, returns the number of bytes written to the file. The number

		shall never be greater than cnt.

		On Failure, returns -1, errno may be set.

*/

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

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _write_r (r, fd, buf, cnt);

	}

/** A reentrant version of write().

*/

EXPORT_C int _write_r (struct _reent *r, int fd, const char *buf, size_t nbyte)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.write(fd,buf,nbyte,r->_errno);

	}

/**

Close a file.

@return	On Success, returns 0. 

		On Failure, returns -1, errno may be set.

*/

EXPORT_C int close (int fd)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _close_r (r, fd);

	}

/** A reentrant version of close().

*/

EXPORT_C int _close_r (struct _reent *r, int fd)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.close(fd,r->_errno);

	}

/**

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

@param fd Is the file descriptor for the file to be synchronized.

@return On Success, returns 0. 

		On Failure, returns -1, errno may be set.

*/

EXPORT_C int fsync (int fd)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _fsync_r (r, fd);

	}

/** A reentrant version of fsync().

*/

EXPORT_C int _fsync_r (struct _reent *r, int fd)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.fsync(fd,r->_errno);

	}

/**

Repositions the read/write file offset.

@return a nonnegative integer that indicates the file pointer value. 

@param fd Is the file descriptor of an open file.

@param pos Specifies the number of bytes to offset the file pointer 

from a specified file origin.

@param whence Specifies the location from which to start seeking.

*/

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

	{

	return _lseek_r (_REENT, fd, pos, whence);

	}

/** A reentrant version of fseek().

*/

EXPORT_C off_t _lseek_r (struct _reent *r, int fd, off_t pos, int whence)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.lseek(fd,pos,whence,r->_errno);

	}

/**

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.

@param fd Is a file descriptor referring to a file for which status is returned.

@param st Points to a stat structure where status information about the file is to be placed.

@return On Success, returns 0. 

		On Failure, returns -1, errno may be set.

*/

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

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _fstat_r (r, fd, st);

	}

/** A reentrant version of fstat().

*/

EXPORT_C int _fstat_r (struct _reent *r, int fd, struct stat *st) 

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.fstat(fd,st,r->_errno);

	}

/**

Gets the size of a file. 

@return On Success, returns 0. 

		On Failure, returns -1, errno may be set.

*/

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

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _stat_r (r, name, st);

	}

/** A reentrant version of stat().

*/

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

	{

	wchar_t tmpbuf[KMaxFullName+1];	

	if (-1 != mbstowcs(tmpbuf, name, KMaxFullName))

		{

		MSystemInterface& sysIf=Interface(r);

		return sysIf.stat(tmpbuf, st, r->_errno);

		}

	MapError(EILSEQ, r->_errno);		

	return -1;

	}

/** 

A wide_character version of a stat().

*/

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

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _wstat_r (r, name, st);

	}

/** A reentrant version of wstat().

*/

EXPORT_C int _wstat_r (struct _reent *r, const wchar_t *name, struct stat *st) 

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.stat(name,st,r->_errno);

	}

/**

Duplicates an open file descriptor. 

@param aFid Is the file descriptor to duplicate.

@return On Success, returns a non-negative integer, namely the duplicated file descriptor, which

		is the lowest available descriptor. 

		On Failure, returns -1, errno may be set.

*/

EXPORT_C int dup (int aFid)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _dup_r(r, aFid);

	}

/** A reentrant version of dup().

*/

EXPORT_C int _dup_r (struct _reent *r, int aFid)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.dup(aFid,r->_errno);

	}

/**

Function duplicates an open file descriptor. 

@param aFid1 Is the file descriptor to duplicate.

@param aFid2 Is the file descriptor that filedes is duplicated onto.

@return On Success, returns a non-negative integer, namely the duplicated file descriptor, which

		is the lowest available descriptor. 

		On Failure, returns -1, errno may be set.

*/

EXPORT_C int dup2 (int aFid1, int aFid2)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _dup2_r(r, aFid1, aFid2);

	}

/** A reentrant version of dup2().

*/

EXPORT_C int _dup2_r (struct _reent *r, int aFid1, int aFid2)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.dup2(aFid1,aFid2,r->_errno);

	}

/**

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

@return On Success, returns a value other than -1 that depends upon the STREAMS device control function. 

        On Failure, return -1, errno may be set.

*/

EXPORT_C int ioctl (int aFid, int aCmd, void* aParam)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _ioctl_r(r, aFid, aCmd, aParam);

	}

/** A reentrant version of ioctl().

*/

EXPORT_C int _ioctl_r (struct _reent *r, int aFid, int aCmd, void* aParam)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.ioctl(aFid,aCmd,aParam,r->_errno);

	}

/**

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. 

@return If successful returns buf, if a non-null pointer was specified, 

or the address of the allocated memory otherwise. 

@param _buf Points to the buffer to copy the current working directory to, 

or NULL if getcwd() should allocate the buffer.

@param _size Is the size, in bytes, of the array of characters that buf points to.

*/

EXPORT_C char* getcwd (char *_buf, size_t _size)

	{

	return _getcwd_r(_REENT,_buf,_size);

	}

/** 

A wide_character version of a getcwd().

*/

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

	{

	return _wgetcwd_r(_REENT,_buf,_size);

	}

/** A reentrant version of getcwd().

*/

EXPORT_C char* _getcwd_r (struct _reent *r, char *_buf, size_t _size)

	{

	char * _ourbuf = _buf;

	if (_buf==0)

		{

		_ourbuf=(char*)User::Alloc(_size);

		if (_ourbuf==0)

			{

			r->_errno=ENOMEM;

			return _buf;

			}

		}

	//we are dealing with wide characters from here so we need a temporary buffer

	wchar_t tmpbuf[KMaxFullName];

	MSystemInterface& sysIf=Interface(r);

	wchar_t * rval = sysIf.getcwd((wchar_t*)tmpbuf, _size, r->_errno);

	if (rval)	//we have a path

		{

		//convert it to UTF8

		size_t x = wcstombs(_ourbuf, tmpbuf, _size);	//convert the buffer

		return _ourbuf;

		}

	//deal with the fact we may have allocated our own buffer

	if (_buf != _ourbuf)  //we allocated it.

		User::Free(_ourbuf);

	return NULL;

	}

/** A wide-character version of reentrant of getcwd().

*/

EXPORT_C wchar_t * _wgetcwd_r (struct _reent *r, wchar_t *_buf, size_t _size)

	{

	if (_buf==0)

		{

		_buf=(wchar_t *)User::Alloc(_size*sizeof(wchar_t));

		if (_buf==0)

			{

			r->_errno=ENOMEM;

			return _buf;

			}

		}

	MSystemInterface& sysIf=Interface(r);

	return sysIf.getcwd(_buf,_size,r->_errno);

	}

/**

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.

@param _path Is the path name of a directory.

@return On Success, returns 0. 

		On Failure, returns -1, errno may be set.

*/

EXPORT_C int chdir (const char *_path)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _chdir_r(r, _path);

	}

/** A reentrant version of chdir().

*/

EXPORT_C int _chdir_r (struct _reent *r, const char *_path)

	{

	//we need to use a wide buffer and convert

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

	if (-1 != mbstowcs(tmpbuf, _path, KMaxFullName))

		{

		MSystemInterface& sysIf=Interface(r);

		return sysIf.chdir(tmpbuf, r->_errno);

		}

	MapError(EILSEQ, r->_errno);		

	return -1;

	}

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

*/

EXPORT_C int wchdir (const wchar_t *_path)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _wchdir_r(r, _path);

	}

/** A reentrant version of wchdir().

*/

EXPORT_C int _wchdir_r (struct _reent *r, const wchar_t *_path)

	{

	MSystemInterface& sysIf=Interface(r);

	return sysIf.chdir(_path,r->_errno);

	}

/**

Removes an empty directory whose name is given by pathname.

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

@param _path Points to the directory that the rmdir() function removes.

@return On Success, returns 0. 

		On Failure, returns -1, errno may be set.

*/

EXPORT_C int rmdir (const char *_path)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _rmdir_r(r, _path);

	}

/** A reentrant version of rmdir().

*/

EXPORT_C int _rmdir_r (struct _reent *r, const char *_path)

	{

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

	if (-1 != mbstowcs(tmpbuf, _path, KMaxFullName))

		{

		MSystemInterface& sysIf=Interface(r);

		return sysIf.rmdir(tmpbuf, r->_errno);

		}

	MapError(EILSEQ, r->_errno);		

	return -1;

	}

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

*/

EXPORT_C int wrmdir (const wchar_t *_path)

	{

	struct _reent *r = _REENT2;

	if (!r)

		return -1; // Memory for library globals is not allocated (errno not set).

	return _wrmdir_r(r,_path);

	}

/** A reentrant version of wrmdir().

*/

EXPORT_C int _wrmdir_r (struct _reent *r, const wchar_t *_path)

	{

	MSystemInterface& sysIf=Interface(r);