Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/io/io.c

    re86a617a r6fa9a99d  
    231231        if (stream->buf == NULL) {
    232232                errno = ENOMEM;
    233                 return EOF;
     233                return -1;
    234234        }
    235235       
    … …  
    271271        stream->need_sync = false;
    272272        _setvbuf(stream);
    273         stream->ungetc_chars = 0;
    274273       
    275274        list_append(&stream->link, &files);
    … …  
    294293        stream->need_sync = false;
    295294        _setvbuf(stream);
    296         stream->ungetc_chars = 0;
    297295       
    298296        list_append(&stream->link, &files);
    … …  
    301299}
    302300
    303 
    304 static int _fclose_nofree(FILE *stream)
     301int fclose(FILE *stream)
    305302{
    306303        int rc = 0;
    … …  
    315312       
    316313        list_remove(&stream->link);
    317        
    318         if (rc != 0) {
    319                 /* errno was set by close() */
    320                 return EOF;
    321         }
    322        
    323         return 0;
    324 }
    325 
    326 int fclose(FILE *stream)
    327 {
    328         int rc = _fclose_nofree(stream);
    329314       
    330315        if ((stream != &stdin_null)
    … …  
    333318                free(stream);
    334319       
    335         return rc;
    336 }
    337 
    338 FILE *freopen(const char *path, const char *mode, FILE *stream)
    339 {
    340         FILE *nstr;
    341        
    342         if (path == NULL) {
    343                 /* Changing mode is not supported */
    344                 return NULL;
    345         }
    346        
    347         (void) _fclose_nofree(stream);
    348         nstr = fopen(path, mode);
    349         if (nstr == NULL) {
    350                 free(stream);
    351                 return NULL;
    352         }
    353        
    354         list_remove(&nstr->link);
    355         *stream = *nstr;
    356         list_append(&stream->link, &files);
    357        
    358         free(nstr);
    359        
    360         return stream;
     320        stream = NULL;
     321       
     322        if (rc != 0) {
     323                /* errno was set by close() */
     324                return EOF;
     325        }
     326       
     327        return 0;
    361328}
    362329
    … …  
    367334 * @param nmemb  Number of records to read.
    368335 * @param stream Pointer to the stream.
    369  *
    370  * @return Number of elements successfully read. On error this is less than
    371  *         nmemb, stream error indicator is set and errno is set.
    372336 */
    373337static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
    … …  
    384348                ssize_t rd = read(stream->fd, buf + done, left);
    385349               
    386                 if (rd < 0) {
    387                         /* errno was set by read() */
     350                if (rd < 0)
    388351                        stream->error = true;
    389                 } else if (rd == 0) {
     352                else if (rd == 0)
    390353                        stream->eof = true;
    391                 } else {
     354                else {
    392355                        left -= rd;
    393356                        done += rd;
    … …  
    404367 * @param nmemb  Number of records to write.
    405368 * @param stream Pointer to the stream.
    406  *
    407  * @return Number of elements successfully written. On error this is less than
    408  *         nmemb, stream error indicator is set and errno is set.
    409369 */
    410370static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
    … …  
    412372        size_t left;
    413373        size_t done;
    414         int rc;
    415374
    416375        if (size == 0 || nmemb == 0)
    … …  
    422381        while ((left > 0) && (!stream->error)) {
    423382                ssize_t wr;
    424                 size_t uwr;
    425                
    426                 if (stream->kio) {
    427                         uwr = 0;
    428                         rc = kio_write(buf + done, left, &uwr);
    429                         if (rc != EOK)
    430                                 errno = rc;
    431                 } else {
     383               
     384                if (stream->kio)
     385                        wr = kio_write(buf + done, left);
     386                else
    432387                        wr = write(stream->fd, buf + done, left);
    433                         if (wr >= 0) {
    434                                 uwr = (size_t)wr;
    435                                 rc = EOK;
    436                         } else {
    437                                 /* errno was set by write */
    438                                 uwr = 0;
    439                                 rc = errno;
    440                         }
    441                 }
    442                
    443                 if (rc != EOK) {
    444                         /* errno was set above */
     388               
     389                if (wr <= 0)
    445390                        stream->error = true;
    446                 } else {
    447                         left -= uwr;
    448                         done += uwr;
     391                else {
     392                        left -= wr;
     393                        done += wr;
    449394                }
    450395        }
    … …  
    456401}
    457402
    458 /** Read some data in stream buffer.
    459  *
    460  * On error, stream error indicator is set and errno is set.
    461  */
     403/** Read some data in stream buffer. */
    462404static void _ffillbuf(FILE *stream)
    463405{
    … …  
    468410        rc = read(stream->fd, stream->buf, stream->buf_size);
    469411        if (rc < 0) {
    470                 /* errno was set by read() */
    471412                stream->error = true;
    472413                return;
    … …  
    493434
    494435        /* If buffer has prefetched read data, we need to seek back. */
    495         if (bytes_used > 0 && stream->buf_state == _bs_read) {
    496                 off64_t rc;
    497                 rc = lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
    498                 if (rc == (off64_t)-1) {
    499                         /* errno was set by lseek */
    500                         stream->error = 1;
    501                         return;
    502                 }
    503         }
     436        if (bytes_used > 0 && stream->buf_state == _bs_read)
     437                lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
    504438
    505439        /* If buffer has unwritten data, we need to write them out. */
    506         if (bytes_used > 0 && stream->buf_state == _bs_write) {
     440        if (bytes_used > 0 && stream->buf_state == _bs_write)
    507441                (void) _fwrite(stream->buf_tail, 1, bytes_used, stream);
    508                 /* On error stream error indicator and errno are set by _fwrite */
    509                 if (stream->error)
    510                         return;
    511         }
    512442
    513443        stream->buf_head = stream->buf;
    … …  
    536466                return 0;
    537467
    538         bytes_left = size * nmemb;
    539         total_read = 0;
    540         dp = (uint8_t *) dest;
    541 
    542         /* Bytes from ungetc() buffer */
    543         while (stream->ungetc_chars > 0 && bytes_left > 0) {
    544                 *dp++ = stream->ungetc_buf[--stream->ungetc_chars];
    545                 ++total_read;
    546                 --bytes_left;
    547         }
    548 
    549468        /* If not buffered stream, read in directly. */
    550469        if (stream->btype == _IONBF) {
    551                 total_read += _fread(dest, 1, bytes_left, stream);
    552                 return total_read / size;
     470                now = _fread(dest, size, nmemb, stream);
     471                return now;
    553472        }
    554473
    … …  
    563482        }
    564483
     484        bytes_left = size * nmemb;
     485        total_read = 0;
     486        dp = (uint8_t *) dest;
     487
    565488        while ((!stream->error) && (!stream->eof) && (bytes_left > 0)) {
    566489                if (stream->buf_head == stream->buf_tail)
    567490                        _ffillbuf(stream);
    568491
    569                 if (stream->error || stream->eof) {
    570                         /* On error errno was set by _ffillbuf() */
     492                if (stream->error || stream->eof)
    571493                        break;
    572                 }
    573494
    574495                data_avail = stream->buf_head - stream->buf_tail;
    … …  
    626547                _fflushbuf(stream);
    627548
     549
    628550        /* Perform lazy allocation of stream buffer. */
    629551        if (stream->buf == NULL) {
    … …  
    662584                        /* Only need to drain buffer. */
    663585                        _fflushbuf(stream);
    664                         if (!stream->error)
    665                                 need_flush = false;
     586                        need_flush = false;
    666587                }
    667588        }
    … …  
    697618int fputs(const char *str, FILE *stream)
    698619{
    699         (void) fwrite(str, str_size(str), 1, stream);
    700         if (ferror(stream))
    701                 return EOF;
    702         return 0;
     620        return fwrite(str, str_size(str), 1, stream);
    703621}
    704622
    … …  
    756674}
    757675
    758 int ungetc(int c, FILE *stream)
    759 {
    760         if (c == EOF)
    761                 return EOF;
    762 
    763         if (stream->ungetc_chars >= UNGETC_MAX)
    764                 return EOF;
    765 
    766         stream->ungetc_buf[stream->ungetc_chars++] =
    767             (uint8_t)c;
    768 
    769         stream->eof = false;
    770         return (uint8_t)c;
    771 }
    772 
    773676int fseek(FILE *stream, off64_t offset, int whence)
    774677{
    775678        off64_t rc;
    776679
    777         if (stream->error)
    778                 return EOF;
    779 
    780680        _fflushbuf(stream);
    781         if (stream->error) {
    782                 /* errno was set by _fflushbuf() */
    783                 return EOF;
    784         }
    785 
    786         stream->ungetc_chars = 0;
    787681
    788682        rc = lseek(stream->fd, offset, whence);
    789683        if (rc == (off64_t) (-1)) {
    790                 /* errno has been set by lseek() */
    791                 return EOF;
     684                /* errno has been set by lseek64. */
     685                return -1;
    792686        }
    793687
    … …  
    798692off64_t ftell(FILE *stream)
    799693{
    800         off64_t pos;
    801        
    802         if (stream->error)
    803                 return EOF;
    804        
    805694        _fflushbuf(stream);
    806         if (stream->error) {
    807                 /* errno was set by _fflushbuf() */
    808                 return EOF;
    809         }
    810 
    811         pos = lseek(stream->fd, 0, SEEK_CUR);
    812         if (pos == (off64_t) -1) {
    813                 /* errno was set by lseek */
    814                 return (off64_t) -1;
    815         }
    816        
    817         return pos - stream->ungetc_chars;
     695        return lseek(stream->fd, 0, SEEK_CUR);
    818696}
    819697
    … …  
    825703int fflush(FILE *stream)
    826704{
    827         if (stream->error)
    828                 return EOF;
    829        
    830705        _fflushbuf(stream);
    831         if (stream->error) {
    832                 /* errno was set by _fflushbuf() */
    833                 return EOF;
    834         }
    835706       
    836707        if (stream->kio) {
    837708                kio_update();
    838                 return 0;
     709                return EOK;
    839710        }
    840711       
    … …  
    845716                 */
    846717                stream->need_sync = false;
    847                 if (fsync(stream->fd) != 0) {
    848                         /* errno was set by fsync() */
    849                         return EOF;
    850                 }
    851 
    852                 return 0;
    853         }
    854        
    855         return 0;
     718                return fsync(stream->fd);
     719        }
     720       
     721        return ENOENT;
    856722}
    857723
    … …  
    876742        if (stream->kio) {
    877743                errno = EBADF;
    878                 return EOF;
     744                return -1;
    879745        }
    880746       
    … …  
    882748}
    883749
    884 async_sess_t *vfs_fsession(FILE *stream, iface_t iface)
     750async_sess_t *fsession(exch_mgmt_t mgmt, FILE *stream)
    885751{
    886752        if (stream->fd >= 0) {
    887753                if (stream->sess == NULL)
    888                         stream->sess = vfs_fd_session(stream->fd, iface);
     754                        stream->sess = fd_session(mgmt, stream->fd);
    889755               
    890756                return stream->sess;
    … …  
    894760}
    895761
    896 int vfs_fhandle(FILE *stream, int *handle)
     762int fhandle(FILE *stream, int *handle)
    897763{
    898764        if (stream->fd >= 0) {
Note: See TracChangeset for help on using the changeset viewer.