BSD 4_3_Net_2 release

[unix-history] / usr / src / lib / libc / stdio / freopen.c

diff --git a/usr/src/lib/libc/stdio/freopen.c b/usr/src/lib/libc/stdio/freopen.c
index e81db9b..62e06d4 100644 (file)
--- a/usr/src/lib/libc/stdio/freopen.c
+++ b/usr/src/lib/libc/stdio/freopen.c
@@ -1,59 +1,155 @@
-/*
- * Copyright (c) 1980 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.

  */
 
 #if defined(LIBC_SCCS) && !defined(lint)
  */
 
 #if defined(LIBC_SCCS) && !defined(lint)

-static char sccsid[] = "@(#)freopen.c  5.2 (Berkeley) 3/9/86";
-#endif LIBC_SCCS and not lint
+static char sccsid[] = "@(#)freopen.c  5.6 (Berkeley) 2/24/91";
+#endif /* LIBC_SCCS and not lint */

 
 #include <sys/types.h>
 
 #include <sys/types.h>

-#include <sys/file.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>

 #include <stdio.h>
 #include <stdio.h>

+#include <stdlib.h>
+#include "local.h"

 
 

+/* 
+ * Re-direct an existing, open (probably) file to some other file. 
+ * ANSI is written such that the original file gets closed if at
+ * all possible, no matter what.
+ */

 FILE *
 FILE *

-freopen(file, mode, iop)
-       char *file;
-       register char *mode;
-       register FILE *iop;
+freopen(file, mode, fp)
+       const char *file, *mode;
+       register FILE *fp;

 {
 {

-       register f, rw, oflags;
-
-       rw = (mode[1] == '+');
-
-       fclose(iop);
-
-       switch (*mode) {
-       case 'a':
-               oflags = O_CREAT | (rw ? O_RDWR : O_WRONLY);
-               break;
-       case 'r':
-               oflags = rw ? O_RDWR : O_RDONLY;
-               break;
-       case 'w':
-               oflags = O_TRUNC | O_CREAT | (rw ? O_RDWR : O_WRONLY);
-               break;
-       default:
+       register int f;
+       int flags, isopen, oflags, sverrno, wantfd;
+
+       if ((flags = __sflags(mode, &oflags)) == 0) {
+               (void) fclose(fp);

                return (NULL);
        }
 
                return (NULL);
        }
 

-       f = open(file, oflags, 0666);
-       if (f < 0)
+       if (!__sdidinit)
+               __sinit();
+
+       /*
+        * There are actually programs that depend on being able to "freopen"
+        * descriptors that weren't originally open.  Keep this from breaking.
+        * 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; freopen("/dev/stdin", "r", stdin)
+        * should work.  This is unnecessary if it was not a Unix file.
+        */
+       if (fp->_flags == 0) {
+               fp->_flags = __SEOF;    /* hold on to it */
+               isopen = 0;
+               wantfd = -1;
+       } else {
+               /* flush the stream; ANSI doesn't require this. */
+               if (fp->_flags & __SWR)
+                       (void) __sflush(fp);
+               /* if close is NULL, closing is a no-op, hence pointless */
+               isopen = fp->_close != NULL;
+               if ((wantfd = fp->_file) < 0 && isopen) {
+                       (void) (*fp->_close)(fp->_cookie);
+                       isopen = 0;
+               }
+       }
+
+       /* Get a new descriptor to refer to the new file. */
+       f = open(file, oflags, DEFFILEMODE);
+       if (f < 0 && isopen) {
+               /* If out of fd's close the old one and try again. */
+               if (errno == ENFILE || errno == EMFILE) {
+                       (void) (*fp->_close)(fp->_cookie);
+                       isopen = 0;
+                       f = open(file, oflags, DEFFILEMODE);
+               }
+       }
+       sverrno = errno;
+
+       /*
+        * 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 (isopen)
+               (void) (*fp->_close)(fp->_cookie);
+       if (fp->_flags & __SMBF)
+               free((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(fp);
+       fp->_ub._size = 0;
+       if (HASLB(fp))
+               FREELB(fp);
+       fp->_lb._size = 0;
+
+       if (f < 0) {                    /* did not get it after all */
+               fp->_flags = 0;         /* set it free */
+               errno = sverrno;        /* restore in case _close clobbered */

                return (NULL);
                return (NULL);

+       }
+
+       /*
+        * If reopening something that was open before on a real file, try
+        * to maintain the descriptor.  Various C library routines (perror)
+        * assume stderr is always fd STDERR_FILENO, even if being freopen'd.
+        */
+       if (wantfd >= 0 && f != wantfd) {
+               if (dup2(f, wantfd) >= 0) {
+                       (void) close(f);
+                       f = wantfd;
+               }
+       }

 
 

-       if (*mode == 'a')
-               lseek(f, (off_t)0, L_XTND);
-
-       iop->_cnt = 0;
-       iop->_file = f;
-       iop->_bufsiz = 0;
-       if (rw)
-               iop->_flag = _IORW;
-       else if (*mode == 'r')
-               iop->_flag = _IOREAD;
-       else
-               iop->_flag = _IOWRT;
-       iop->_base = iop->_ptr = NULL;
-       return (iop);
+       fp->_flags = flags;
+       fp->_file = f;
+       fp->_cookie = fp;
+       fp->_read = __sread;
+       fp->_write = __swrite;
+       fp->_seek = __sseek;
+       fp->_close = __sclose;
+       return (fp);

 }
 }