text: /* Copyright (C) 2004       Manuel Novoa III    <mjn3@codepoet.org>
   *
   * GNU Library General Public License (LGPL) version 2 or later.
   *
   * Dedicated to Toni.  See uClibc/DEDICATION.mjn3 for details.
   */
  
  #include "_stdio.h"
  
  /*DWD*/
  #if 0
  libc_hidden_proto(isatty)
  libc_hidden_proto(open)
  libc_hidden_proto(fcntl)
  #else
  extern __typeof(open) __libc_open;
  libc_hidden_proto(__libc_open)
  extern __typeof(fcntl) __libc_fcntl;
  libc_hidden_proto(__libc_fcntl)
  #endif
  
  /*
   * Cases:
   *  fopen64  : filename != NULL, stream == NULL, filedes == -2
   *  fopen    : filename != NULL, stream == NULL, filedes == -1
   *  freopen  : filename != NULL, stream != NULL, filedes == -1
   *  fdopen   : filename == NULL, stream == NULL, filedes valid
   *
   *  fsfopen  : filename != NULL, stream != NULL, filedes == -1
   */
  
  #if (O_ACCMODE != 3) || (O_RDONLY != 0) || (O_WRONLY != 1) || (O_RDWR != 2)
  #error Assumption violated - mode constants
  #endif
  
  #ifndef O_LARGEFILE
  #define O_LARGEFILE 0
  #endif
  
  /* Internal function -- reentrant (locks open file list) */
  
  FILE attribute_hidden *_stdio_fopen(intptr_t fname_or_mode,
  				   register const char * __restrict mode,
  				   register FILE * __restrict stream, int filedes)
  {
  	__mode_t open_mode;
  	int i;
  
  	/* Parse the specified mode. */
  	open_mode = O_RDONLY;
  	if (*mode != 'r') {			/* Not read... */
  		open_mode = (O_WRONLY | O_CREAT | O_TRUNC);
  		if (*mode != 'w') {		/* Not write (create or truncate)... */
  			open_mode = (O_WRONLY | O_CREAT | O_APPEND);
  			if (*mode != 'a') {	/* Not write (create or append)... */
  			DO_EINVAL:
  				__set_errno(EINVAL); /* So illegal mode. */
  				if (stream) {
  				FREE_STREAM:
  					assert(!(stream->__modeflags & __FLAG_FREEBUF));
  					__STDIO_STREAM_FREE_FILE(stream);
  				}
  				return NULL;
  			}
  		}
  	}
  
  	if ((mode[1] == 'b')) {		/* Binary mode (NO-OP currently). */
  		++mode;
  	}
  
  	if (mode[1] == '+') {			/* Read and Write. */
  		++mode;
  		open_mode |= (O_RDONLY | O_WRONLY);
  		open_mode += (O_RDWR - (O_RDONLY | O_WRONLY));
  	}
  
  #ifdef __UCLIBC_MJN3_ONLY__
  #warning CONSIDER: Implement glibc ccs option to bind a codeset?
  #warning CONSIDER: Implement glibc mmap option for readonly files?
  #warning CONSIDER: Implement a text mode using custom read/write funcs?
  #endif
  #if defined(__UCLIBC_HAS_FOPEN_EXCLUSIVE_MODE__) || defined(__UCLIBC_HAS_FOPEN_LARGEFILE_MODE__)
  
  	while (*++mode) {
  # ifdef __UCLIBC_HAS_FOPEN_EXCLUSIVE_MODE__
  		if (*mode == 'x') {	   /* Open exclusive (a glibc extension). */
  			open_mode |= O_EXCL;
  			continue;
  		}
  # endif
  # ifdef __UCLIBC_HAS_FOPEN_LARGEFILE_MODE__
  		if (*mode == 'F') {		/* Open as large file (uClibc extension). */
  			open_mode |= O_LARGEFILE;
  			continue;
  		}
  # endif
   	}
  
  #endif
  
  	if (!stream) {		  /* Need to allocate a FILE (not freopen). */
  		if ((stream = malloc(sizeof(FILE))) == NULL) {
  			return stream;
  		}
  		stream->__modeflags = __FLAG_FREEFILE;
  #ifdef __STDIO_BUFFERS
  		stream->__bufstart = NULL; /* We allocate a buffer below. */
  #endif
  #ifdef __UCLIBC_HAS_THREADS__
  		/* We only initialize the mutex in the non-freopen case. */
  		/* stream->__user_locking = _stdio_user_locking; */
  		__stdio_init_mutex(&stream->__lock);
  #endif
  	}
  
  #ifdef __UCLIBC_MJN3_ONLY__
  #warning TODO: Verify fdopen append behavior of glibc.
  #endif
  
  	if (filedes >= 0) {			/* Handle fdopen trickery. */
  		stream->__filedes = filedes;
  		/* NOTE: it is insufficient to just check R/W/RW agreement.
  		 * We must also check largefile compatibility if applicable.
  		 * Also, if append mode is desired for fdopen but O_APPEND isn't
  		 * currently set, then set it as recommended by SUSv3.  However,
  		 * if append mode is not specified for fdopen but O_APPEND is set,
  		 * leave it set (glibc compat). */
  		i = (open_mode & (O_ACCMODE|O_LARGEFILE)) + 1;
  
  		/* NOTE: fopencookie needs changing if the basic check changes! */
  		if (((i & (((int) fname_or_mode) + 1)) != i) /* Basic agreement? */
  			|| (((open_mode & ~((__mode_t) fname_or_mode)) & O_APPEND)
          /*DWD*/
  				//&& fcntl(filedes, F_SETFL, O_APPEND))	/* Need O_APPEND. */
  				&& __libc_fcntl(filedes, F_SETFL, O_APPEND))	/* Need O_APPEND. */
  			) {
  			goto DO_EINVAL;
  		}
  		/* For later... to reflect largefile setting in stream flags. */
  		__STDIO_WHEN_LFS( open_mode |= (((__mode_t) fname_or_mode)
  										& O_LARGEFILE) );
  	} else {
  		__STDIO_WHEN_LFS( if (filedes < -1) open_mode |= O_LARGEFILE );
      /*DWD*/
  		//if ((stream->__filedes = open(((const char *) fname_or_mode),
  		if ((stream->__filedes = __libc_open(((const char *) fname_or_mode),
  									  open_mode, 0666)) < 0) {
  			goto FREE_STREAM;
  		}
  	}
  
  	stream->__modeflags &= __FLAG_FREEFILE;
  /* 	stream->__modeflags &= ~(__FLAG_READONLY|__FLAG_WRITEONLY); */
  
  	stream->__modeflags |=		/* Note: Makes assumptions about flag vals! */
  #if (O_APPEND != __FLAG_APPEND) || ((O_LARGEFILE != __FLAG_LARGEFILE) && (O_LARGEFILE != 0))
  # if (O_APPEND != __FLAG_APPEND)
  		((open_mode & O_APPEND) ? __FLAG_APPEND : 0) |
  # else
  		(open_mode & O_APPEND) |
  # endif
  # if (O_LARGEFILE != __FLAG_LARGEFILE) && (O_LARGEFILE != 0)
  		((open_mode & O_LARGEFILE) ? __FLAG_LARGEFILE : 0) |
  # else
  		(open_mode & O_LARGEFILE) |
  # endif
  #else
  		(open_mode & (O_APPEND|O_LARGEFILE)) | /* i386 linux and elks */
  #endif
  		((((open_mode & O_ACCMODE) + 1) ^ 0x03) * __FLAG_WRITEONLY);
  
  #ifdef __STDIO_BUFFERS
  	i = errno;					/* Preserve errno against isatty call. */
  	stream->__modeflags |= (isatty(stream->__filedes) * __FLAG_LBF);
  	__set_errno(i);
  
  	if (!stream->__bufstart) {
  		if ((stream->__bufstart = malloc(BUFSIZ)) != NULL) {
  			stream->__bufend = stream->__bufstart + BUFSIZ;
  			stream->__modeflags |= __FLAG_FREEBUF;
  		} else {
  # if __STDIO_BUILTIN_BUF_SIZE > 0
  			stream->__bufstart = stream->__builtinbuf;
  			stream->__bufend = stream->__builtinbuf + sizeof(stream->__builtinbuf);
  # else  /* __STDIO_BUILTIN_BUF_SIZE > 0 */
  			stream->__bufend = stream->__bufstart;
  # endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */
  		}
  	}
  
  	__STDIO_STREAM_DISABLE_GETC(stream);
  	__STDIO_STREAM_DISABLE_PUTC(stream);
  	__STDIO_STREAM_INIT_BUFREAD_BUFPOS(stream);
  #endif
  
  	__STDIO_STREAM_RESET_GCS(stream);
  
  #ifdef __UCLIBC_HAS_WCHAR__
  	stream->__ungot_width[0] = 0;
  #endif
  #ifdef __STDIO_MBSTATE
  	__INIT_MBSTATE(&(stream->__state));
  #endif
  
  #ifdef __UCLIBC_HAS_THREADS__
  	/* Even in the freopen case, we reset the user locking flag. */
  	stream->__user_locking = _stdio_user_locking;
  	/* __stdio_init_mutex(&stream->__lock); */
  #endif
  
  #ifdef __STDIO_HAS_OPENLIST
  #if defined(__UCLIBC_HAS_THREADS__) && defined(__STDIO_BUFFERS)
  	if (!(stream->__modeflags & __FLAG_FREEFILE))
  	{
  		/* An freopen call so the file was never removed from the list. */
  	}
  	else
  #endif
  	{
  		/* We have to lock the del mutex in case another thread wants to fclose()
  		 * the last file. */
  		__STDIO_THREADLOCK_OPENLIST_DEL;
  		__STDIO_THREADLOCK_OPENLIST_ADD;
  		stream->__nextopen = _stdio_openlist; /* New files are inserted at */
  		_stdio_openlist = stream;			  /*   the head of the list. */
  		__STDIO_THREADUNLOCK_OPENLIST_ADD;
  		__STDIO_THREADUNLOCK_OPENLIST_DEL;
  	}
  #endif
  
  	__STDIO_STREAM_VALIDATE(stream);
  
  	return stream;
  }
  