work around gz functions not being posix-compatible

The C source assumes that when a write succeeds it writes all bytes. that is not strictly required, but effectively true in most cases where zlib is used. However, miri does not respect this. So when running miri, explicitly loop until all bytes are written

Author: folkertdev

libz-rs-sys-cdylib/src/gz.rs

@@ -1808,6 +1808,41 @@ fn gz_init(state: &mut GzState) -> Result<(), ()> {
     Ok(())
 }
 
+#[cfg(not(miri))]
+unsafe fn write(fd: c_int, buf: *const c_void, count: size_t) -> libc::ssize_t {
+    unsafe { libc::write(fd, buf, count) }
+}
+
+/// Deal with miri often not writing the full buffer in one go. That is valid, but zlib assumes
+/// that writes are to true files and succeed unless e.g. the disk is full.
+#[cfg(miri)]
+unsafe fn write(fd: c_int, buf: *const c_void, count: size_t) -> libc::ssize_t {
+    let mut total_written = 0isize;
+    loop {
+        let ret = unsafe {
+            libc::write(
+                fd,
+                buf.add(total_written as usize),
+                count - total_written as usize,
+            )
+        };
+
+        match ret.cmp(&0) {
+            Ordering::Less => return ret,
+            Ordering::Equal => return total_written,
+            Ordering::Greater => {
+                total_written += ret;
+
+                if total_written as usize == count {
+                    break;
+                }
+            }
+        }
+    }
+
+    total_written
+}
+
 // Compress whatever is at avail_in and next_in (unless in direct mode) and write
 // to the output file.
 //
@@ -1824,7 +1859,7 @@ fn gz_comp(state: &mut GzState, flush: c_int) -> Result<(), ()> {
     // Write directly if requested.
     if state.direct {
         let got = unsafe {
-            libc::write(
+            write(
                 state.fd,
                 state.stream.next_in.cast::<c_void>(),
                 state.stream.avail_in as _,
@@ -1868,7 +1903,7 @@ fn gz_comp(state: &mut GzState, flush: c_int) -> Result<(), ()> {
                 return Err(());
             }
             if have != 0 {
-                let ret = unsafe { libc::write(state.fd, state.next.cast::<c_void>(), have as _) };
+                let ret = unsafe { write(state.fd, state.next.cast::<c_void>(), have as _) };
                 if ret != have as _ {
                     unsafe { gz_error(state, Some((Z_ERRNO, "write error"))) };
                     return Err(());

test-libz-rs-sys/src/gz.rs

@@ -35,6 +35,43 @@ fn binary_mode(mode: c_int) -> c_int {
     }
 }
 
+#[cfg(not(miri))]
+unsafe fn write(fd: c_int, buf: *const c_void, count: size_t) -> libc::ssize_t {
+    unsafe { libc::write(fd, buf, count) }
+}
+
+/// Deal with miri often not writing the full buffer in one go. That is valid, but zlib assumes
+/// that writes are to true files and succeed unless e.g. the disk is full.
+#[cfg(miri)]
+unsafe fn write(fd: c_int, buf: *const c_void, count: size_t) -> libc::ssize_t {
+    use std::cmp::Ordering;
+
+    let mut total_written = 0isize;
+    loop {
+        let ret = unsafe {
+            libc::write(
+                fd,
+                buf.add(total_written as usize),
+                count - total_written as usize,
+            )
+        };
+
+        match ret.cmp(&0) {
+            Ordering::Less => return ret,
+            Ordering::Equal => return total_written,
+            Ordering::Greater => {
+                total_written += ret;
+
+                if total_written as usize == count {
+                    break;
+                }
+            }
+        }
+    }
+
+    total_written
+}
+
 // Try to gzopen a file path with a specified mode, and panic if the result is unexpected.
 // NOTE: This is a macro, instead of a function, so that the test runner will report errors
 // with the line number where it is invoked.
@@ -331,7 +368,7 @@ fn gzread_special_cases() {
     };
     assert_ne!(fd, -1);
     assert_eq!(
-        unsafe { libc::write(fd, STRING2.as_ptr().cast::<c_void>(), STRING2.len() as _) },
+        unsafe { write(fd, STRING2.as_ptr().cast::<c_void>(), STRING2.len() as _) },
         STRING2.len() as _
     );
     assert_eq!(unsafe { libc::close(fd) }, 0);
@@ -793,7 +830,7 @@ fn gzoffset_gztell_read() {
     };
     assert_ne!(fd, -1);
     assert_eq!(
-        unsafe { libc::write(fd, PADDING.as_ptr().cast::<c_void>(), OFFSET as _) },
+        unsafe { write(fd, PADDING.as_ptr().cast::<c_void>(), OFFSET as _) },
         OFFSET as _
     );
     let source_name = crate_path("src/test-data/issue-109.gz");
@@ -809,7 +846,7 @@ fn gzoffset_gztell_read() {
             break;
         }
         assert_eq!(
-            unsafe { libc::write(fd, buf.as_ptr().cast(), ret as _) },
+            unsafe { write(fd, buf.as_ptr().cast(), ret as _) },
             ret as _
         );
     }
@@ -1703,7 +1740,7 @@ fn gzseek_read() {
             break;
         }
         assert_eq!(
-            unsafe { libc::write(fd, buf.as_mut_ptr().cast::<c_void>(), ret as _) },
+            unsafe { write(fd, buf.as_mut_ptr().cast::<c_void>(), ret as _) },
             ret as _
         );
     }