lib/libc/stdio/stdio.c

   1 /*-
   2  * Copyright (c) 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Chris Torek.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36
  37 #if defined(LIBC_SCCS) && !defined(lint)
  38 static char sccsid[] = "@(#)stdio.c     8.1 (Berkeley) 6/4/93";
  39 #endif /* LIBC_SCCS and not lint */
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD$");
  42
  43 #include "namespace.h"
  44 #include <errno.h>
  45 #include <fcntl.h>
  46 #include <limits.h>
  47 #include <stdio.h>
  48 #include <unistd.h>
  49 #include "un-namespace.h"
  50 #include "local.h"
  51
  52 /*
  53  * Small standard I/O/seek/close functions.
  54  */
  55 int
  56 __sread(cookie, buf, n)
  57         void *cookie;
  58         char *buf;
  59         int n;
  60 {
  61         FILE *fp = cookie;
  62
  63         return(_read(fp->_file, buf, (size_t)n));
  64 }
  65
  66 int
  67 __swrite(cookie, buf, n)
  68         void *cookie;
  69         char const *buf;
  70         int n;
  71 {
  72         FILE *fp = cookie;
  73
  74         return (_write(fp->_file, buf, (size_t)n));
  75 }
  76
  77 fpos_t
  78 __sseek(cookie, offset, whence)
  79         void *cookie;
  80         fpos_t offset;
  81         int whence;
  82 {
  83         FILE *fp = cookie;
  84
  85         return (lseek(fp->_file, (off_t)offset, whence));
  86 }
  87
  88 int
  89 __sclose(cookie)
  90         void *cookie;
  91 {
  92
  93         return (_close(((FILE *)cookie)->_file));
  94 }
  95
  96 /*
  97  * Higher level wrappers.
  98  */
  99 int
 100 _sread(fp, buf, n)
 101         FILE *fp;
 102         char *buf;
 103         int n;
 104 {
 105         int ret;
 106
 107         ret = (*fp->_read)(fp->_cookie, buf, n);
 108         if (ret > 0) {
 109                 if (fp->_flags & __SOFF) {
 110                         if (fp->_offset <= OFF_MAX - ret)
 111                                 fp->_offset += ret;
 112                         else
 113                                 fp->_flags &= ~__SOFF;
 114                 }
 115         } else if (ret < 0)
 116                 fp->_flags &= ~__SOFF;
 117         return (ret);
 118 }
 119
 120 int
 121 _swrite(fp, buf, n)
 122         FILE *fp;
 123         char const *buf;
 124         int n;
 125 {
 126         int ret;
 127         int serrno;
 128
 129         if (fp->_flags & __SAPP) {
 130                 serrno = errno;
 131                 if (_sseek(fp, (fpos_t)0, SEEK_END) == -1 &&
 132                     (fp->_flags & __SOPT))
 133                         return (-1);
 134                 errno = serrno;
 135         }
 136         ret = (*fp->_write)(fp->_cookie, buf, n);
 137         /* __SOFF removed even on success in case O_APPEND mode is set. */
 138         if (ret >= 0) {
 139                 if ((fp->_flags & (__SAPP|__SOFF)) == (__SAPP|__SOFF) &&
 140                     fp->_offset <= OFF_MAX - ret)
 141                         fp->_offset += ret;
 142                 else
 143                         fp->_flags &= ~__SOFF;
 144
 145         } else if (ret < 0)
 146                 fp->_flags &= ~__SOFF;
 147         return (ret);
 148 }
 149
 150 fpos_t
 151 _sseek(fp, offset, whence)
 152         FILE *fp;
 153         fpos_t offset;
 154         int whence;
 155 {
 156         fpos_t ret;
 157         int serrno, errret;
 158
 159         serrno = errno;
 160         errno = 0;
 161         ret = (*fp->_seek)(fp->_cookie, offset, whence);
 162         errret = errno;
 163         if (errno == 0)
 164                 errno = serrno;
 165         /*
 166          * Disallow negative seeks per POSIX.
 167          * It is needed here to help upper level caller
 168          * in the cases it can't detect.
 169          */
 170         if (ret < 0) {
 171                 if (errret == 0) {
 172                         if (offset != 0 || whence != SEEK_CUR) {
 173                                 if (HASUB(fp))
 174                                         FREEUB(fp);
 175                                 fp->_p = fp->_bf._base;
 176                                 fp->_r = 0;
 177                                 fp->_flags &= ~__SEOF;
 178                         }
 179                         fp->_flags |= __SERR;
 180                         errno = EINVAL;
 181                 } else if (errret == ESPIPE)
 182                         fp->_flags &= ~__SAPP;
 183                 fp->_flags &= ~__SOFF;
 184                 ret = -1;
 185         } else if (fp->_flags & __SOPT) {
 186                 fp->_flags |= __SOFF;
 187                 fp->_offset = ret;
 188         }
 189         return (ret);
 190 }