fix impl_nio_read_iovec/impl_nio_write_iovec bug

Author: loongs-zhang

core/src/syscall/unix/mod.rs

@@ -566,7 +566,9 @@ macro_rules! impl_nio_read_iovec {
                 let mut received = 0usize;
                 let mut r = -1;
                 let mut index = 0;
-                'outer: for iovec in &vec {
+                for iovec in &vec {
+                    let stage = length;
+                    let mut offset = received.saturating_sub(stage);
                     length += iovec.iov_len;
                     if received > length {
                         index += 1;
@@ -577,6 +579,13 @@ macro_rules! impl_nio_read_iovec {
                         arg.push(*i);
                     }
                     while received < length && left_time > 0 {
+                        // Assuming iov_len is 4, but only 1 is read, at this point we should continue trying to fill the current iovec
+                        if 0 != offset {
+                            arg[0] = libc::iovec {
+                                iov_base: (arg[0].iov_base as usize + offset) as *mut std::ffi::c_void,
+                                iov_len: arg[0].iov_len - offset,
+                            };
+                        }
                         r = self.inner.$syscall(
                             fn_ptr,
                             $fd,
@@ -596,9 +605,11 @@ macro_rules! impl_nio_read_iovec {
                         } else if r != -1 {
                             $crate::syscall::reset_errno();
                             received += libc::size_t::try_from(r).expect("r overflow");
-                            r = received.try_into().expect("received overflow");
-                            // readv returns as soon as any data is received
-                            break 'outer;
+                            if received >= length {
+                                r = received.try_into().expect("received overflow");
+                                break;
+                            }
+                            offset = received.saturating_sub(stage);
                         }
                         let error_kind = std::io::Error::last_os_error().kind();
                         if error_kind == std::io::ErrorKind::WouldBlock {

core/src/syscall/windows/mod.rs

@@ -533,8 +533,9 @@ macro_rules! impl_nio_read_iovec {
                 let mut received = 0usize;
                 let mut r = windows_sys::Win32::Networking::WinSock::SOCKET_ERROR;
                 let mut index = 0;
-                'outer: for iovec in &vec {
-                    let mut offset = received.saturating_sub(length);
+                for iovec in &vec {
+                    let stage = length;
+                    let mut offset = received.saturating_sub(stage);
                     length += iovec.len as usize;
                     if received > length {
                         index += 1;
@@ -545,6 +546,7 @@ macro_rules! impl_nio_read_iovec {
                         arg.push(*i);
                     }
                     while received < length && left_time > 0 {
+                         // Assuming len is 4, but only 1 is read, at this point we should continue trying to fill the current WSABUF
                         if 0 != offset {
                             arg[0] = windows_sys::Win32::Networking::WinSock::WSABUF {
                                 buf: (arg[0].buf as usize + offset) as windows_sys::core::PSTR,
@@ -561,14 +563,24 @@ macro_rules! impl_nio_read_iovec {
                             $recvd,
                             $($arg, )*
                         );
-                        if r != windows_sys::Win32::Networking::WinSock::SOCKET_ERROR {
-                            $crate::syscall::reset_errno();
-                            // WSARecv returns 0 on success; actual byte count is in *$recvd
-                            received += unsafe { *$recvd } as usize;
+                         if unsafe{ *$recvd == 0 } {
                             r = 0;
                             unsafe{ $recvd.write(received.try_into().expect("overflow")) };
-                            // WSARecv returns as soon as any data is received
-                            break 'outer;
+                            std::mem::forget(vec);
+                            if blocking {
+                                $crate::syscall::set_blocking($fd);
+                            }
+                            // as success
+                            return r;
+                        } else if r != windows_sys::Win32::Networking::WinSock::SOCKET_ERROR {
+                            $crate::syscall::reset_errno();
+                            received += unsafe{ usize::try_from(*$recvd).expect("overflow") };
+                            if received >= length {
+                                r = 0;
+                                unsafe{ $recvd.write(received.try_into().expect("overflow")) };
+                                break;
+                            }
+                            offset = received.saturating_sub(stage);
                         }
                         let error_kind = std::io::Error::last_os_error().kind();
                         if error_kind == std::io::ErrorKind::WouldBlock {
@@ -802,8 +814,7 @@ macro_rules! impl_nio_write_iovec {
                         );
                         if r != windows_sys::Win32::Networking::WinSock::SOCKET_ERROR {
                             $crate::syscall::reset_errno();
-                            // WSASend returns 0 on success; actual byte count is in *$sent
-                            sent += unsafe { *$sent } as usize;
+                            sent += unsafe{ usize::try_from(*$sent).expect("overflow")};
                             if sent >= length {
                                 r = 0;
                                 unsafe{ $sent.write(sent.try_into().expect("overflow")) };