common/sfio/sfread.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1985-2010 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                  Common Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*            http://www.opensource.org/licenses/cpl1.0.txt             *
*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                  David Korn <dgk@research.att.com>                   *
*                   Phong Vo <kpv@research.att.com>                    *
*                                                                      *
***********************************************************************/
#include    "sfhdr.h"

/*  Read n bytes from a stream into a buffer
**
**  Written by Kiem-Phong Vo.
*/

#if __STD_C
ssize_t sfread(Sfio_t* f, Void_t* buf, size_t n)
#else
ssize_t sfread(f,buf,n)
Sfio_t*     f;  /* read from this stream.   */
Void_t*     buf;    /* buffer to read into      */
size_t      n;  /* number of bytes to be read.  */
#endif
{
    reg uchar   *s, *begs;
    reg ssize_t r;
    reg int     local, justseek;
    SFMTXDECL(f);

    SFMTXENTER(f, (ssize_t)(-1));

    GETLOCAL(f,local);
    justseek = f->bits&SF_JUSTSEEK; f->bits &= ~SF_JUSTSEEK;

    if(!buf)
        SFMTXRETURN(f, (ssize_t)(n == 0 ? 0 : -1) );

    /* release peek lock */
    if(f->mode&SF_PEEK)
    {   if(!(f->mode&SF_READ) )
            SFMTXRETURN(f, (ssize_t)(-1));

        if(f->mode&SF_GETR)
        {   if(((uchar*)buf + f->val) != f->next &&
               (!f->rsrv || f->rsrv->data != (uchar*)buf) )
                SFMTXRETURN(f, (ssize_t)(-1));
            f->mode &= ~SF_PEEK;
            SFMTXRETURN(f, 0);
        }
        else
        {   if((uchar*)buf != f->next)
                SFMTXRETURN(f, (ssize_t)(-1));
            f->mode &= ~SF_PEEK;
            if(f->mode&SF_PKRD)
            {   /* actually read the data now */
                f->mode &= ~SF_PKRD;
                if(n > 0)
                    n = (r = sysreadf(f->file,f->data,n)) < 0 ? 0 : r;
                f->endb = f->data+n;
                f->here += n;
            }
            f->next += n;
            f->endr = f->endb;
            SFMTXRETURN(f, n);
        }
    }

    s = begs = (uchar*)buf;
    for(;; f->mode &= ~SF_LOCK)
    {   /* check stream mode */
        if(SFMODE(f,local) != SF_READ && _sfmode(f,SF_READ,local) < 0)
        {   n = s > begs ? s-begs : (size_t)(-1);
            SFMTXRETURN(f, (ssize_t)n);
        }

        SFLOCK(f,local);

        if((r = f->endb - f->next) > 0) /* has buffered data */
        {   if(r > (ssize_t)n)
                r = (ssize_t)n;
            if(s != f->next)
                memcpy(s, f->next, r);
            f->next += r;
            s += r;
            n -= r;
        }

        if(n <= 0)  /* all done */
            break;

        if(!(f->flags&SF_STRING) && !(f->bits&SF_MMAP) )
        {   f->next = f->endb = f->data;

            /* exact IO is desirable for these cases */
            if(SFDIRECT(f,n) ||
               ((f->flags&SF_SHARE) && f->extent < 0) )
                r = (ssize_t)n;
            else if(justseek && n <= f->iosz && f->iosz <= f->size)
                r = f->iosz;    /* limit buffering */
            else    r = f->size;    /* full buffering */

            /* if read almost full size, then just do it direct */
            if(r > (ssize_t)n && (r - r/8) <= (ssize_t)n)
                r = (ssize_t)n;

            /* read directly to user's buffer */
            if(r == (ssize_t)n && (r = SFRD(f,s,r,f->disc)) >= 0)
            {   s += r;
                n -= r;
                if(r == 0 || n == 0) /* eof or eob */
                    break;
            }
            else    goto do_filbuf;
        }
        else
        { do_filbuf:
            if(justseek)
                f->bits |= SF_JUSTSEEK;
            if(SFFILBUF(f,-1) <= 0)
                break;
        }
    }

    SFOPEN(f,local);
    r = s-begs;
    SFMTXRETURN(f, r);
}