Stream should always write all bytes

native/jni/utils/include/stream.hpp

@@ -11,8 +11,7 @@ public:
     virtual ssize_t read(void *buf, size_t len);
     virtual ssize_t readFully(void *buf, size_t len);
     virtual ssize_t readv(const iovec *iov, int iovcnt);
-    virtual ssize_t write(const void *buf, size_t len);
-    virtual ssize_t writeFully(void *buf, size_t len);
+    virtual bool write(const void *buf, size_t len);
     virtual ssize_t writev(const iovec *iov, int iovcnt);
     virtual off_t seek(off_t off, int whence);
     virtual ~stream() = default;
@@ -26,7 +25,7 @@ public:
     filter_stream(stream_ptr &&base) : base(std::move(base)) {}
 
     ssize_t read(void *buf, size_t len) override;
-    ssize_t write(const void *buf, size_t len) override;
+    bool write(const void *buf, size_t len) override;
 
     // Seeking while filtering does not make sense
     off_t seek(off_t off, int whence) final { return stream::seek(off, whence); }
@@ -44,16 +43,16 @@ public:
     chunk_out_stream(stream_ptr &&base, size_t buf_sz = 4096)
     : chunk_out_stream(std::move(base), buf_sz, buf_sz) {}
 
-    ~chunk_out_stream() { delete[] _buf; }
+    ~chunk_out_stream() override { delete[] _buf; }
 
     // Reading does not make sense
     ssize_t read(void *buf, size_t len) final { return stream::read(buf, len); }
-    ssize_t write(const void *buf, size_t len) final;
+    bool write(const void *buf, size_t len) final;
 
 protected:
-    // Classes inheriting this class has to call close() in the destructor
+    // Classes inheriting this class has to call close() in its destructor
     void close();
-    virtual ssize_t write_chunk(const void *buf, size_t len) = 0;
+    virtual bool write_chunk(const void *buf, size_t len) = 0;
 
     size_t chunk_sz;
 
@@ -71,7 +70,7 @@ public:
     byte_stream(Byte *&buf, size_t &len) : byte_stream(reinterpret_cast<uint8_t *&>(buf), len) {}
 
     ssize_t read(void *buf, size_t len) override;
-    ssize_t write(const void *buf, size_t len) override;
+    bool write(const void *buf, size_t len) override;
     off_t seek(off_t off, int whence) override;
 
 private:
@@ -83,16 +82,23 @@ private:
     void resize(size_t new_pos, bool zero = false);
 };
 
+class file_stream : public stream {
+public:
+    bool write(const void *buf, size_t len) final;
+protected:
+    virtual ssize_t do_write(const void *buf, size_t len) = 0;
+};
+
 // File stream but does not close the file descriptor at any time
-class fd_stream : public stream {
+class fd_stream : public file_stream {
 public:
     fd_stream(int fd) : fd(fd) {}
     ssize_t read(void *buf, size_t len) override;
     ssize_t readv(const iovec *iov, int iovcnt) override;
-    ssize_t write(const void *buf, size_t len) override;
     ssize_t writev(const iovec *iov, int iovcnt) override;
     off_t seek(off_t off, int whence) override;
-
+protected:
+    ssize_t do_write(const void *buf, size_t len) override;
 private:
     int fd;
 };
@@ -102,15 +108,14 @@ private:
  * ****************************************/
 
 // sFILE -> stream_ptr
-class fp_stream final : public stream {
+class fp_stream final : public file_stream {
 public:
     fp_stream(FILE *fp = nullptr) : fp(fp, fclose) {}
     fp_stream(sFILE &&fp) : fp(std::move(fp)) {}
-
     ssize_t read(void *buf, size_t len) override;
-    ssize_t write(const void *buf, size_t len) override;
     off_t seek(off_t off, int whence) override;
-
+protected:
+    ssize_t do_write(const void *buf, size_t len) override;
 private:
     sFILE fp;
 };

native/jni/utils/stream.cpp

@@ -13,7 +13,9 @@ static int strm_read(void *v, char *buf, int len) {
 
 static int strm_write(void *v, const char *buf, int len) {
     auto strm = static_cast<stream *>(v);
-    return strm->write(buf, len);
+    if (!strm->write(buf, len))
+        return -1;
+    return len;
 }
 
 static fpos_t strm_seek(void *v, fpos_t off, int whence) {
@@ -64,33 +66,17 @@ ssize_t stream::readv(const iovec *iov, int iovcnt) {
     return read_sz;
 }
 
-ssize_t stream::write(const void *buf, size_t len) {
+bool 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;
+    return false;
 }
 
 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;
+        if (!write(iov[i].iov_base, iov[i].iov_len))
+            return write_sz;
+        write_sz += iov[i].iov_len;
     }
     return write_sz;
 }
@@ -105,7 +91,7 @@ ssize_t fp_stream::read(void *buf, size_t len) {
     return ret ? ret : (ferror(fp.get()) ? -1 : 0);
 }
 
-ssize_t fp_stream::write(const void *buf, size_t len) {
+ssize_t fp_stream::do_write(const void *buf, size_t len) {
     return fwrite(buf, 1, len, fp.get());
 }
 
@@ -117,12 +103,11 @@ ssize_t filter_stream::read(void *buf, size_t len) {
     return base->read(buf, len);
 }
 
-ssize_t filter_stream::write(const void *buf, size_t len) {
+bool filter_stream::write(const void *buf, size_t len) {
     return base->write(buf, len);
 }
 
-ssize_t chunk_out_stream::write(const void *_in, size_t len) {
-    ssize_t ret = 0;
+bool chunk_out_stream::write(const void *_in, size_t len) {
     auto in = static_cast<const uint8_t *>(_in);
     while (len) {
         if (buf_off + len >= chunk_sz) {
@@ -140,10 +125,8 @@ ssize_t chunk_out_stream::write(const void *_in, size_t len) {
                 in += chunk_sz;
                 len -= chunk_sz;
             }
-            auto r = write_chunk(src, chunk_sz);
-            if (r < 0)
-                return ret;
-            ret += r;
+            if (!write_chunk(src, chunk_sz))
+                return false;
         } else {
             // Buffer internally
             if (!_buf) {
@@ -154,7 +137,7 @@ ssize_t chunk_out_stream::write(const void *_in, size_t len) {
             break;
         }
     }
-    return ret;
+    return true;
 }
 
 void chunk_out_stream::close() {
@@ -177,12 +160,12 @@ ssize_t byte_stream::read(void *buf, size_t len) {
     return len;
 }
 
-ssize_t byte_stream::write(const void *buf, size_t len) {
+bool byte_stream::write(const void *buf, size_t len) {
     resize(_pos + len);
     memcpy(_buf + _pos, buf, len);
     _pos += len;
     _len = std::max(_len, _pos);
-    return len;
+    return true;
 }
 
 off_t byte_stream::seek(off_t off, int whence) {
@@ -227,7 +210,7 @@ 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) {
+ssize_t fd_stream::do_write(const void *buf, size_t len) {
     return ::write(fd, buf, len);
 }
 
@@ -238,3 +221,18 @@ ssize_t fd_stream::writev(const iovec *iov, int iovcnt) {
 off_t fd_stream::seek(off_t off, int whence) {
     return lseek(fd, off, whence);
 }
+
+bool file_stream::write(const void *buf, size_t len) {
+    size_t write_sz = 0;
+    ssize_t ret;
+    do {
+        ret = do_write((byte *) buf + write_sz, len - write_sz);
+        if (ret < 0) {
+            if (errno == EINTR)
+                continue;
+            return false;
+        }
+        write_sz += ret;
+    } while (write_sz != len && ret != 0);
+    return true;
+}