Extend stream support

native/jni/utils/stream.cpp

@@ -1,23 +1,27 @@
+#include <cstddef>
+
 #include <utils.hpp>
 #include <stream.hpp>
 
+using namespace std;
+
 static int strm_read(void *v, char *buf, int len) {
-    auto strm = reinterpret_cast<stream *>(v);
+    auto strm = static_cast<stream *>(v);
     return strm->read(buf, len);
 }
 
 static int strm_write(void *v, const char *buf, int len) {
-    auto strm = reinterpret_cast<stream *>(v);
+    auto strm = static_cast<stream *>(v);
     return strm->write(buf, len);
 }
 
 static fpos_t strm_seek(void *v, fpos_t off, int whence) {
-    auto strm = reinterpret_cast<stream *>(v);
+    auto strm = static_cast<stream *>(v);
     return strm->seek(off, whence);
 }
 
 static int strm_close(void *v) {
-    auto strm = reinterpret_cast<stream *>(v);
+    auto strm = static_cast<stream *>(v);
     delete strm;
     return 0;
 }
@@ -28,26 +32,79 @@ sFILE make_stream_fp(stream_ptr &&strm) {
     return fp;
 }
 
-int stream::read(void *buf, size_t len)  {
-    LOGE("This stream does not support read\n");
+ssize_t stream::read(void *buf, size_t len)  {
+    LOGE("This stream does not implement read\n");
     return -1;
 }
 
-int stream::write(const void *buf, size_t len) {
-    LOGE("This stream does not support write\n");
+ssize_t stream::readFully(void *buf, size_t len) {
+    size_t read_sz = 0;
+    ssize_t ret;
+    do {
+        ret = read((byte *) buf + read_sz, len - read_sz);
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+            return ret;
+        }
+        read_sz += ret;
+    } while (read_sz != len && ret != 0);
+    return read_sz;
+}
+
+ssize_t stream::readv(const iovec *iov, int iovcnt) {
+    size_t read_sz = 0;
+    for (int i = 0; i < iovcnt; ++i) {
+        auto ret = readFully(iov[i].iov_base, iov[i].iov_len);
+        if (ret < 0)
+            return ret;
+        read_sz += ret;
+    }
+    return read_sz;
+}
+
+ssize_t stream::write(const void *buf, size_t len) {
+    LOGE("This stream does not implement write\n");
     return -1;
 }
 
+ssize_t stream::writeFully(void *buf, size_t len) {
+    size_t write_sz = 0;
+    ssize_t ret;
+    do {
+        ret = write((byte *) buf + write_sz, len - write_sz);
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+            return ret;
+        }
+        write_sz += ret;
+    } while (write_sz != len && ret != 0);
+    return write_sz;
+}
+
+ssize_t stream::writev(const iovec *iov, int iovcnt) {
+    size_t write_sz = 0;
+    for (int i = 0; i < iovcnt; ++i) {
+        auto ret = writeFully(iov[i].iov_base, iov[i].iov_len);
+        if (ret < 0)
+            return ret;
+        write_sz += ret;
+    }
+    return write_sz;
+}
+
 off_t stream::seek(off_t off, int whence) {
-    LOGE("This stream does not support seek\n");
+    LOGE("This stream does not implement seek\n");
     return -1;
 }
 
-int fp_stream::read(void *buf, size_t len) {
-    return fread(buf, 1, len, fp.get());
+ssize_t fp_stream::read(void *buf, size_t len) {
+    auto ret = fread(buf, 1, len, fp.get());
+    return ret ? ret : (ferror(fp.get()) ? -1 : 0);
 }
 
-int fp_stream::write(const void *buf, size_t len) {
+ssize_t fp_stream::write(const void *buf, size_t len) {
     return fwrite(buf, 1, len, fp.get());
 }
 
@@ -55,11 +112,11 @@ off_t fp_stream::seek(off_t off, int whence) {
     return fseek(fp.get(), off, whence);
 }
 
-int filter_stream::read(void *buf, size_t len) {
+ssize_t filter_stream::read(void *buf, size_t len) {
     return base->read(buf, len);
 }
 
-int filter_stream::write(const void *buf, size_t len) {
+ssize_t filter_stream::write(const void *buf, size_t len) {
     return base->write(buf, len);
 }
 
@@ -68,13 +125,13 @@ byte_stream::byte_stream(uint8_t *&buf, size_t &len) : _buf(buf), _len(len) {
     len = 0;
 }
 
-int byte_stream::read(void *buf, size_t len) {
-    len = std::min(len, _len - _pos);
+ssize_t byte_stream::read(void *buf, size_t len) {
+    len = std::min((size_t) len, _len - _pos);
     memcpy(buf, _buf + _pos, len);
     return len;
 }
 
-int byte_stream::write(const void *buf, size_t len) {
+ssize_t byte_stream::write(const void *buf, size_t len) {
     resize(_pos + len);
     memcpy(_buf + _pos, buf, len);
     _pos += len;
@@ -116,14 +173,22 @@ void byte_stream::resize(size_t new_pos, bool zero) {
     }
 }
 
-int fd_stream::read(void *buf, size_t len) {
+ssize_t fd_stream::read(void *buf, size_t len) {
     return ::read(fd, buf, len);
 }
 
-int fd_stream::write(const void *buf, size_t len) {
+ssize_t fd_stream::readv(const iovec *iov, int iovcnt) {
+    return ::readv(fd, iov, iovcnt);
+}
+
+ssize_t fd_stream::write(const void *buf, size_t len) {
     return ::write(fd, buf, len);
 }
 
+ssize_t fd_stream::writev(const iovec *iov, int iovcnt) {
+    return ::writev(fd, iov, iovcnt);
+}
+
 off_t fd_stream::seek(off_t off, int whence) {
     return lseek(fd, off, whence);
 }