gonzui

    1: /*      $OpenBSD: fvwrite.c,v 1.17 2009/11/09 00:18:27 kurt Exp $ */
    2: /*-
    3:  * Copyright (c) 1990, 1993
    4:  *      The Regents of the University of California.  All rights reserved.
    5:  *
    6:  * This code is derived from software contributed to Berkeley by
    7:  * Chris Torek.
    8:  *
    9:  * Redistribution and use in source and binary forms, with or without
   10:  * modification, are permitted provided that the following conditions
   11:  * are met:
   12:  * 1. Redistributions of source code must retain the above copyright
   13:  *    notice, this list of conditions and the following disclaimer.
   14:  * 2. Redistributions in binary form must reproduce the above copyright
   15:  *    notice, this list of conditions and the following disclaimer in the
   16:  *    documentation and/or other materials provided with the distribution.
   17:  * 3. Neither the name of the University nor the names of its contributors
   18:  *    may be used to endorse or promote products derived from this software
   19:  *    without specific prior written permission.
   20:  *
   21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31:  * SUCH DAMAGE.
   32:  */
   33: 
   34: #include <stdio.h>
   35: #include <stdlib.h>
   36: #include <string.h>
   37: #include <errno.h>
   38: #include "local.h"
   39: #include "fvwrite.h"
   40: 
   41: /*
   42:  * Write some memory regions.  Return zero on success, EOF on error.
   43:  *
   44:  * This routine is large and unsightly, but most of the ugliness due
   45:  * to the three different kinds of output buffering is handled here.
   46:  */
   47: int
   48: __sfvwrite(FILE *fp, struct __suio *uio)
   49: {
   50:         size_t len;
   51:         char *p;
   52:         struct __siov *iov;
   53:         int w, s;
   54:         char *nl;
   55:         int nlknown, nldist;
   56: 
   57:         if ((len = uio->uio_resid) == 0)
   58:                 return (0);
   59:         /* make sure we can write */
   60:         if (cantwrite(fp)) {
   61:                 __sseterr(fp, EBADF);
   62:                 return (EOF);
   63:         }
   64: 
   65: #define MIN(a, b) ((a) < (b) ? (a) : (b))
   66: #define COPY(n)   (void)memcpy((void *)fp->_p, (void *)p, (size_t)(n))
   67: 
   68:         iov = uio->uio_iov;
   69:         p = iov->iov_base;
   70:         len = iov->iov_len;
   71:         iov++;
   72: #define GETIOV(extra_work) \
   73:         while (len == 0) { \
   74:                 extra_work; \
   75:                 p = iov->iov_base; \
   76:                 len = iov->iov_len; \
   77:                 iov++; \
   78:         }
   79:         if (fp->_flags & __SNBF) {
   80:                 /*
   81:                  * Unbuffered: write up to BUFSIZ bytes at a time.
   82:                  */
   83:                 do {
   84:                         GETIOV(;);
   85:                         w = (*fp->_write)(fp->_cookie, p, MIN(len, BUFSIZ));
   86:                         if (w <= 0)
   87:                                 goto err;
   88:                         p += w;
   89:                         len -= w;
   90:                 } while ((uio->uio_resid -= w) != 0);
   91:         } else if ((fp->_flags & __SLBF) == 0) {
   92:                 /*
   93:                  * Fully buffered: fill partially full buffer, if any,
   94:                  * and then flush.  If there is no partial buffer, write
   95:                  * one _bf._size byte chunk directly (without copying).
   96:                  *
   97:                  * String output is a special case: write as many bytes
   98:                  * as fit, but pretend we wrote everything.  This makes
   99:                  * snprintf() return the number of bytes needed, rather
  100:                  * than the number used, and avoids its write function
  101:                  * (so that the write function can be invalid).
  102:                  */
  103:                 do {
  104:                         GETIOV(;);
  105:                         if ((fp->_flags & (__SALC | __SSTR)) ==
  106:                             (__SALC | __SSTR) && fp->_w < len) {
  107:                                 size_t blen = fp->_p - fp->_bf._base;
  108:                                 unsigned char *_base;
  109:                                 int _size;
  110: 
  111:                                 /* Allocate space exponentially. */
  112:                                 _size = fp->_bf._size;
  113:                                 do {
  114:                                         _size = (_size << 1) + 1;
  115:                                 } while (_size < blen + len);
  116:                                 _base = realloc(fp->_bf._base, _size + 1);
  117:                                 if (_base == NULL)
  118:                                         goto err;
  119:                                 fp->_w += _size - fp->_bf._size;
  120:                                 fp->_bf._base = _base;
  121:                                 fp->_bf._size = _size;
  122:                                 fp->_p = _base + blen;
  123:                         }
  124:                         w = fp->_w;
  125:                         if (fp->_flags & __SSTR) {
  126:                                 if (len < w)
  127:                                         w = len;
  128:                                 COPY(w);    /* copy MIN(fp->_w,len), */
  129:                                 fp->_w -= w;
  130:                                 fp->_p += w;
  131:                                 w = len;    /* but pretend copied all */
  132:                         } else if (fp->_p > fp->_bf._base && len > w) {
  133:                                 /* fill and flush */
  134:                                 COPY(w);
  135:                                 /* fp->_w -= w; */ /* unneeded */
  136:                                 fp->_p += w;
  137:                                 if (__sflush(fp))
  138:                                         goto err;
  139:                         } else if (len >= (w = fp->_bf._size)) {
  140:                                 /* write directly */
  141:                                 w = (*fp->_write)(fp->_cookie, p, w);
  142:                                 if (w <= 0)
  143:                                         goto err;
  144:                         } else {
  145:                                 /* fill and done */
  146:                                 w = len;
  147:                                 COPY(w);
  148:                                 fp->_w -= w;
  149:                                 fp->_p += w;
  150:                         }
  151:                         p += w;
  152:                         len -= w;
  153:                 } while ((uio->uio_resid -= w) != 0);
  154:         } else {
  155:                 /*
  156:                  * Line buffered: like fully buffered, but we
  157:                  * must check for newlines.  Compute the distance
  158:                  * to the first newline (including the newline),
  159:                  * or `infinity' if there is none, then pretend
  160:                  * that the amount to write is MIN(len,nldist).
  161:                  */
  162:                 nlknown = 0;
  163:                 nldist = 0;   /* XXX just to keep gcc happy */
  164:                 do {
  165:                         GETIOV(nlknown = 0);
  166:                         if (!nlknown) {
  167:                                 nl = memchr((void *)p, '\n', len);
  168:                                 nldist = nl ? nl + 1 - p : len + 1;
  169:                                 nlknown = 1;
  170:                         }
  171:                         s = MIN(len, nldist);
  172:                         w = fp->_w + fp->_bf._size;
  173:                         if (fp->_p > fp->_bf._base && s > w) {
  174:                                 COPY(w);
  175:                                 /* fp->_w -= w; */
  176:                                 fp->_p += w;
  177:                                 if (__sflush(fp))
  178:                                         goto err;
  179:                         } else if (s >= (w = fp->_bf._size)) {
  180:                                 w = (*fp->_write)(fp->_cookie, p, w);
  181:                                 if (w <= 0)
  182:                                     goto err;
  183:                         } else {
  184:                                 w = s;
  185:                                 COPY(w);
  186:                                 fp->_w -= w;
  187:                                 fp->_p += w;
  188:                         }
  189:                         if ((nldist -= w) == 0) {
  190:                                 /* copied the newline: flush and forget */
  191:                                 if (__sflush(fp))
  192:                                         goto err;
  193:                                 nlknown = 0;
  194:                         }
  195:                         p += w;
  196:                         len -= w;
  197:                 } while ((uio->uio_resid -= w) != 0);
  198:         }
  199:         return (0);
  200: 
  201: err:
  202:         fp->_flags |= __SERR;
  203:         return (EOF);
  204: }