Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/io/io.c

    rf77c1c9 r456c086  
    3838#include <errno.h>
    3939#include <stdbool.h>
    40 #include <stdlib.h>
     40#include <malloc.h>
    4141#include <async.h>
    4242#include <io/kio.h>
     
    108108         * This will probably be removed later.
    109109         */
     110         
    110111        int infd = inbox_get("stdin");
    111112        if (infd >= 0) {
    112                 int stdinfd = -1;
    113                 (void) vfs_clone(infd, -1, false, &stdinfd);
     113                int stdinfd = vfs_clone(infd, -1, false);
    114114                assert(stdinfd == 0);
    115115                vfs_open(stdinfd, MODE_READ);
     
    122122        int outfd = inbox_get("stdout");
    123123        if (outfd >= 0) {
    124                 int stdoutfd = -1;
    125                 (void) vfs_clone(outfd, -1, false, &stdoutfd);
     124                int stdoutfd = vfs_clone(outfd, -1, false);
    126125                assert(stdoutfd <= 1);
    127126                while (stdoutfd < 1)
    128                         (void) vfs_clone(outfd, -1, false, &stdoutfd);
     127                        stdoutfd = vfs_clone(outfd, -1, false);
    129128                vfs_open(stdoutfd, MODE_APPEND);
    130129                stdout = fdopen(stdoutfd, "a");
     
    136135        int errfd = inbox_get("stderr");
    137136        if (errfd >= 0) {
    138                 int stderrfd = -1;
    139                 (void) vfs_clone(errfd, -1, false, &stderrfd);
     137                int stderrfd = vfs_clone(errfd, -1, false);
    140138                assert(stderrfd <= 2);
    141139                while (stderrfd < 2)
    142                         (void) vfs_clone(errfd, -1, false, &stderrfd);
     140                        stderrfd = vfs_clone(errfd, -1, false);
    143141                vfs_open(stderrfd, MODE_APPEND);
    144142                stderr = fdopen(stderrfd, "a");
     
    296294        if (create)
    297295                flags |= WALK_MAY_CREATE;
    298         int file;
    299         int rc = vfs_lookup(path, flags, &file);
    300         if (rc != EOK) {
    301                 errno = rc;
     296        int file = vfs_lookup(path, flags);
     297        if (file < 0) {
     298                errno = file;
    302299                free(stream);
    303300                return NULL;
    304301        }
    305302
    306         rc = vfs_open(file, mode);
     303        int rc = vfs_open(file, mode);
    307304        if (rc != EOK) {
    308305                errno = rc;
     
    376373        list_remove(&stream->link);
    377374       
    378         if (rc != EOK) {
    379                 errno = rc;
     375        if (rc != 0) {
     376                /* errno was set by close() */
    380377                return EOF;
    381378        }
     
    433430static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
    434431{
    435         int rc;
    436         size_t nread;
    437 
    438432        if (size == 0 || nmemb == 0)
    439433                return 0;
    440434
    441         rc = vfs_read(stream->fd, &stream->pos, buf, size * nmemb, &nread);
    442         if (rc != EOK) {
    443                 errno = rc;
     435        ssize_t rd = vfs_read(stream->fd, &stream->pos, buf, size * nmemb);
     436        if (rd < 0) {
     437                errno = rd;
    444438                stream->error = true;
    445         } else if (nread == 0) {
     439                rd = 0;
     440        } else if (rd == 0) {
    446441                stream->eof = true;
    447442        }
    448 
    449         return (nread / size);
     443       
     444        return (rd / size);
    450445}
    451446
     
    462457static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
    463458{
    464         int rc;
    465         size_t nwritten;
    466 
    467459        if (size == 0 || nmemb == 0)
    468460                return 0;
    469461
     462        ssize_t wr;
    470463        if (stream->kio) {
    471                 rc = kio_write(buf, size * nmemb, &nwritten);
    472                 if (rc != EOK) {
     464                size_t nwritten;
     465                wr = kio_write(buf, size * nmemb, &nwritten);
     466                if (wr != EOK) {
    473467                        stream->error = true;
    474                         nwritten = 0;
     468                        wr = 0;
     469                } else {
     470                        wr = nwritten;
    475471                }
    476472        } else {
    477                 rc = vfs_write(stream->fd, &stream->pos, buf, size * nmemb,
    478                     &nwritten);
    479                 if (rc != EOK) {
    480                         errno = rc;
     473                wr = vfs_write(stream->fd, &stream->pos, buf, size * nmemb);
     474                if (wr < 0) {
     475                        errno = wr;
    481476                        stream->error = true;
     477                        wr = 0;
    482478                }
    483479        }
    484480
    485         if (nwritten > 0)
     481        if (wr > 0)
    486482                stream->need_sync = true;
    487 
    488         return (nwritten / size);
     483       
     484        return (wr / size);
    489485}
    490486
     
    495491static void _ffillbuf(FILE *stream)
    496492{
    497         int rc;
    498         size_t nread;
     493        ssize_t rc;
    499494
    500495        stream->buf_head = stream->buf_tail = stream->buf;
    501496
    502         rc = vfs_read(stream->fd, &stream->pos, stream->buf, stream->buf_size,
    503             &nread);
    504         if (rc != EOK) {
     497        rc = vfs_read(stream->fd, &stream->pos, stream->buf, stream->buf_size);
     498        if (rc < 0) {
    505499                errno = rc;
    506500                stream->error = true;
     
    508502        }
    509503
    510         if (nread == 0) {
     504        if (rc == 0) {
    511505                stream->eof = true;
    512506                return;
    513507        }
    514508
    515         stream->buf_head += nread;
     509        stream->buf_head += rc;
    516510        stream->buf_state = _bs_read;
    517511}
Note: See TracChangeset for help on using the changeset viewer.