/* * Copyright (c) 1990, 2007 The Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, * advertising materials, and other materials related to such * distribution and use acknowledge that the software was developed * by the University of California, Berkeley. The name of the * University may not be used to endorse or promote products derived * from this software without specific prior written permission. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ /* FUNCTION <<freopen>>---open a file using an existing file descriptor INDEX freopen INDEX _freopen_r ANSI_SYNOPSIS #include <stdio.h> FILE *freopen(const char *<[file]>, const char *<[mode]>, FILE *<[fp]>); FILE *_freopen_r(struct _reent *<[ptr]>, const char *<[file]>, const char *<[mode]>, FILE *<[fp]>); TRAD_SYNOPSIS #include <stdio.h> FILE *freopen(<[file]>, <[mode]>, <[fp]>) char *<[file]>; char *<[mode]>; FILE *<[fp]>; FILE *_freopen_r(<[ptr]>, <[file]>, <[mode]>, <[fp]>) struct _reent *<[ptr]>; char *<[file]>; char *<[mode]>; FILE *<[fp]>; DESCRIPTION Use this variant of <<fopen>> if you wish to specify a particular file descriptor <[fp]> (notably <<stdin>>, <<stdout>>, or <<stderr>>) for the file. If <[fp]> was associated with another file or stream, <<freopen>> closes that other file or stream (but ignores any errors while closing it). <[file]> and <[mode]> are used just as in <<fopen>>. If <[file]> is <<NULL>>, the underlying stream is modified rather than closed. The file cannot be given a more permissive access mode (for example, a <[mode]> of "w" will fail on a read-only file descriptor), but can change status such as append or binary mode. If modification is not possible, failure occurs. RETURNS If successful, the result is the same as the argument <[fp]>. If the file cannot be opened as specified, the result is <<NULL>>. PORTABILITY ANSI C requires <<freopen>>. Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>, <<lseek>>, <<open>>, <<read>>, <<sbrk>>, <<write>>. */ #include <_ansi.h> #include <reent.h> #include <time.h> #include <stdio.h> #include <string.h> #include <errno.h> #include <fcntl.h> #include <stdlib.h> #include <sys/lock.h> #include "local.h" /* * Re-direct an existing, open (probably) file to some other file. */ FILE * _DEFUN(_freopen_r, (ptr, file, mode, fp), struct _reent *ptr _AND const char *file _AND const char *mode _AND register FILE *fp) { register int f; int flags, oflags; int e = 0; CHECK_INIT (ptr, fp); _flockfile (fp); if ((flags = __sflags (ptr, mode, &oflags)) == 0) { _funlockfile (fp); _fclose_r (ptr, fp); return NULL; } /* * Remember whether the stream was open to begin with, and * which file descriptor (if any) was associated with it. * If it was attached to a descriptor, defer closing it, * so that, e.g., freopen("/dev/stdin", "r", stdin) works. * This is unnecessary if it was not a Unix file. */ if (fp->_flags == 0) fp->_flags = __SEOF; /* hold on to it */ else { if (fp->_flags & __SWR) _fflush_r (ptr, fp); /* * If close is NULL, closing is a no-op, hence pointless. * If file is NULL, the file should not be closed. */ if (fp->_close != NULL && file != NULL) fp->_close (ptr, fp->_cookie); } /* * Now get a new descriptor to refer to the new file, or reuse the * existing file descriptor if file is NULL. */ if (file != NULL) { f = _open_r (ptr, (char *) file, oflags, 0666); e = ptr->_errno; } else { #ifdef HAVE_FCNTL int oldflags; /* * Reuse the file descriptor, but only if the new access mode is * equal or less permissive than the old. F_SETFL correctly * ignores creation flags. */ f = fp->_file; if ((oldflags = _fcntl_r (ptr, f, F_GETFL, 0)) == -1 || ! ((oldflags & O_ACCMODE) == O_RDWR || ((oldflags ^ oflags) & O_ACCMODE) == 0) || _fcntl_r (ptr, f, F_SETFL, oflags) == -1) f = -1; #else /* We cannot modify without fcntl support. */ f = -1; #endif #ifdef __SCLE /* * F_SETFL doesn't change textmode. Don't mess with modes of ttys. */ if (0 <= f && ! _isatty_r (ptr, f) && setmode (f, oflags & (O_BINARY | O_TEXT)) == -1) f = -1; #endif if (f < 0) { e = EBADF; if (fp->_close != NULL) fp->_close (ptr, fp->_cookie); } } /* * Finish closing fp. Even if the open succeeded above, * we cannot keep fp->_base: it may be the wrong size. * This loses the effect of any setbuffer calls, * but stdio has always done this before. */ if (fp->_flags & __SMBF) _free_r (ptr, (char *) fp->_bf._base); fp->_w = 0; fp->_r = 0; fp->_p = NULL; fp->_bf._base = NULL; fp->_bf._size = 0; fp->_lbfsize = 0; if (HASUB (fp)) FREEUB (ptr, fp); fp->_ub._size = 0; if (HASLB (fp)) FREELB (ptr, fp); fp->_lb._size = 0; fp->_flags & ~__SORD; fp->_flags2 = 0; memset (&fp->_mbstate, 0, sizeof (_mbstate_t)); if (f < 0) { /* did not get it after all */ __sfp_lock_acquire (); fp->_flags = 0; /* set it free */ ptr->_errno = e; /* restore in case _close clobbered */ _funlockfile (fp); #ifndef __SINGLE_THREAD__ __lock_close_recursive (fp->_lock); #endif __sfp_lock_release (); return NULL; } fp->_flags = flags; fp->_file = f; fp->_cookie = (_PTR) fp; fp->_read = __sread; fp->_write = __swrite; fp->_seek = __sseek; fp->_close = __sclose; #ifdef __SCLE if (__stextmode (fp->_file)) fp->_flags |= __SCLE; #endif _funlockfile (fp); return fp; } #ifndef _REENT_ONLY FILE * _DEFUN(freopen, (file, mode, fp), _CONST char *file _AND _CONST char *mode _AND register FILE *fp) { return _freopen_r (_REENT, file, mode, fp); } #endif /*!_REENT_ONLY */