Changes in uspace/lib/c/generic/io/io.c [6fa9a99d:6afc9d7] in mainline

File:

• uspace/lib/c/generic/io/io.c (modified) (24 diffs)

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

@@ -231 +231 @@
         if (stream->buf == NULL) {
                 errno = ENOMEM;
-                return -1;
+                return EOF;
         }
         
@@ -299 +299 @@
 }
 
-int fclose(FILE *stream)
+
+static int _fclose_nofree(FILE *stream)
 {
         int rc = 0;
@@ -312 +313 @@
         
         list_remove(&stream->link);
+        
+        if (rc != 0) {
+                /* errno was set by close() */
+                return EOF;
+        }
+        
+        return 0;
+}
+
+int fclose(FILE *stream)
+{
+        int rc = _fclose_nofree(stream);
         
         if ((stream != &stdin_null)
@@ -318 +331 @@
                 free(stream);
         
-        stream = NULL;
-        
-        if (rc != 0) {
-                /* errno was set by close() */
-                return EOF;
-        }
-        
-        return 0;
+        return rc;
+}
+
+FILE *freopen(const char *path, const char *mode, FILE *stream)
+{
+        FILE *nstr;
+        
+        if (path == NULL) {
+                /* Changing mode is not supported */
+                return NULL;
+        }
+        
+        (void) _fclose_nofree(stream);
+        nstr = fopen(path, mode);
+        if (nstr == NULL) {
+                free(stream);
+                return NULL;
+        }
+        
+        list_remove(&nstr->link);
+        *stream = *nstr;
+        list_append(&stream->link, &files);
+        
+        free(nstr);
+        
+        return stream;
 }
 
@@ -334 +365 @@
  * @param nmemb  Number of records to read.
  * @param stream Pointer to the stream.
+ *
+ * @return Number of elements successfully read. On error this is less than
+ *         nmemb, stream error indicator is set and errno is set.
  */
 static size_t _fread(void *buf, size_t size, size_t nmemb, FILE *stream)
@@ -348 +382 @@
                 ssize_t rd = read(stream->fd, buf + done, left);
                 
-                if (rd < 0)
+                if (rd < 0) {
+                        /* errno was set by read() */
                         stream->error = true;
-                else if (rd == 0)
+                } else if (rd == 0) {
                         stream->eof = true;
-                else {
+                } else {
                         left -= rd;
                         done += rd;
@@ -367 +402 @@
  * @param nmemb  Number of records to write.
  * @param stream Pointer to the stream.
+ *
+ * @return Number of elements successfully written. On error this is less than
+ *         nmemb, stream error indicator is set and errno is set.
  */
 static size_t _fwrite(const void *buf, size_t size, size_t nmemb, FILE *stream)
@@ -372 +410 @@
         size_t left;
         size_t done;
+        int rc;
 
         if (size == 0 || nmemb == 0)
@@ -381 +420 @@
         while ((left > 0) && (!stream->error)) {
                 ssize_t wr;
+                size_t uwr;
                 
-                if (stream->kio)
-                        wr = kio_write(buf + done, left);
-                else
+                if (stream->kio) {
+                        uwr = 0;
+                        rc = kio_write(buf + done, left, &uwr);
+                        if (rc != EOK)
+                                errno = rc;
+                } else {
                         wr = write(stream->fd, buf + done, left);
+                        if (wr >= 0) {
+                                uwr = (size_t)wr;
+                                rc = EOK;
+                        } else {
+                                /* errno was set by write */
+                                uwr = 0;
+                                rc = errno;
+                        }
+                }
                 
-                if (wr <= 0)
+                if (rc != EOK) {
+                        /* errno was set above */
                         stream->error = true;
-                else {
-                        left -= wr;
-                        done += wr;
+                } else {
+                        left -= uwr;
+                        done += uwr;
                 }
         }
@@ -401 +454 @@
 }
 
-/** Read some data in stream buffer. */
+/** Read some data in stream buffer.
+ *
+ * On error, stream error indicator is set and errno is set.
+ */
 static void _ffillbuf(FILE *stream)
 {
@@ -410 +466 @@
         rc = read(stream->fd, stream->buf, stream->buf_size);
         if (rc < 0) {
+                /* errno was set by read() */
                 stream->error = true;
                 return;
@@ -434 +491 @@
 
         /* If buffer has prefetched read data, we need to seek back. */
-        if (bytes_used > 0 && stream->buf_state == _bs_read)
-                lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
+        if (bytes_used > 0 && stream->buf_state == _bs_read) {
+                off64_t rc;
+                rc = lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
+                if (rc == (off64_t)-1) {
+                        /* errno was set by lseek */
+                        stream->error = 1;
+                        return;
+                }
+        }
 
         /* If buffer has unwritten data, we need to write them out. */
-        if (bytes_used > 0 && stream->buf_state == _bs_write)
+        if (bytes_used > 0 && stream->buf_state == _bs_write) {
                 (void) _fwrite(stream->buf_tail, 1, bytes_used, stream);
+                /* On error stream error indicator and errno are set by _fwrite */
+                if (stream->error)
+                        return;
+        }
 
         stream->buf_head = stream->buf;
@@ -466 +534 @@
                 return 0;
 
+        bytes_left = size * nmemb;
+        total_read = 0;
+        dp = (uint8_t *) dest;
+
+        /* Bytes from ungetc() buffer */
+        while (stream->ungetc_chars > 0 && bytes_left > 0) {
+                *dp++ = stream->ungetc_buf[--stream->ungetc_chars];
+                ++total_read;
+                --bytes_left;
+        }
+
         /* If not buffered stream, read in directly. */
         if (stream->btype == _IONBF) {
-                now = _fread(dest, size, nmemb, stream);
-                return now;
+                total_read += _fread(dest, 1, bytes_left, stream);
+                return total_read / size;
         }
 
@@ -482 +561 @@
         }
 
-        bytes_left = size * nmemb;
-        total_read = 0;
-        dp = (uint8_t *) dest;
-
         while ((!stream->error) && (!stream->eof) && (bytes_left > 0)) {
                 if (stream->buf_head == stream->buf_tail)
                         _ffillbuf(stream);
 
-                if (stream->error || stream->eof)
+                if (stream->error || stream->eof) {
+                        /* On error errno was set by _ffillbuf() */
                         break;
+                }
 
                 data_avail = stream->buf_head - stream->buf_tail;
@@ -546 +623 @@
         if (stream->buf_state == _bs_read)
                 _fflushbuf(stream);
-
 
         /* Perform lazy allocation of stream buffer. */
@@ -584 +660 @@
                         /* Only need to drain buffer. */
                         _fflushbuf(stream);
-                        need_flush = false;
+                        if (!stream->error)
+                                need_flush = false;
                 }
         }
@@ -618 +695 @@
 int fputs(const char *str, FILE *stream)
 {
-        return fwrite(str, str_size(str), 1, stream);
+        (void) fwrite(str, str_size(str), 1, stream);
+        if (ferror(stream))
+                return EOF;
+        return 0;
 }
 
@@ -674 +754 @@
 }
 
+int ungetc(int c, FILE *stream)
+{
+        if (c == EOF)
+                return EOF;
+
+        if (stream->ungetc_chars >= UNGETC_MAX)
+                return EOF;
+
+        stream->ungetc_buf[stream->ungetc_chars++] =
+            (uint8_t)c;
+
+        stream->eof = false;
+        return (uint8_t)c;
+}
+
 int fseek(FILE *stream, off64_t offset, int whence)
 {
         off64_t rc;
 
+        if (stream->error)
+                return EOF;
+
         _fflushbuf(stream);
+        if (stream->error) {
+                /* errno was set by _fflushbuf() */
+                return EOF;
+        }
+
+        stream->ungetc_chars = 0;
 
         rc = lseek(stream->fd, offset, whence);
         if (rc == (off64_t) (-1)) {
-                /* errno has been set by lseek64. */
-                return -1;
+                /* errno has been set by lseek() */
+                return EOF;
         }
 
@@ -692 +796 @@
 off64_t ftell(FILE *stream)
 {
+        off64_t pos;
+        
+        if (stream->error)
+                return EOF;
+        
         _fflushbuf(stream);
-        return lseek(stream->fd, 0, SEEK_CUR);
+        if (stream->error) {
+                /* errno was set by _fflushbuf() */
+                return EOF;
+        }
+
+        pos = lseek(stream->fd, 0, SEEK_CUR);
+        if (pos == (off64_t) -1) {
+                /* errno was set by lseek */
+                return (off64_t) -1;
+        }
+        
+        return pos - stream->ungetc_chars;
 }
 
@@ -703 +823 @@
 int fflush(FILE *stream)
 {
+        if (stream->error)
+                return EOF;
+        
         _fflushbuf(stream);
+        if (stream->error) {
+                /* errno was set by _fflushbuf() */
+                return EOF;
+        }
         
         if (stream->kio) {
                 kio_update();
-                return EOK;
+                return 0;
         }
         
@@ -716 +843 @@
                  */
                 stream->need_sync = false;
-                return fsync(stream->fd);
-        }
-        
-        return ENOENT;
+                if (fsync(stream->fd) != 0) {
+                        /* errno was set by fsync() */
+                        return EOF;
+                }
+
+                return 0;
+        }
+        
+        return 0;
 }
 
@@ -742 +874 @@
         if (stream->kio) {
                 errno = EBADF;
-                return -1;
+                return EOF;
         }
         
@@ -748 +880 @@
 }
 
-async_sess_t *fsession(exch_mgmt_t mgmt, FILE *stream)
+async_sess_t *vfs_fsession(FILE *stream, iface_t iface)
 {
         if (stream->fd >= 0) {
                 if (stream->sess == NULL)
-                        stream->sess = fd_session(mgmt, stream->fd);
+                        stream->sess = vfs_fd_session(stream->fd, iface);
                 
                 return stream->sess;
@@ -760 +892 @@
 }
 
-int fhandle(FILE *stream, int *handle)
+int vfs_fhandle(FILE *stream, int *handle)
 {
         if (stream->fd >= 0) {