Refactor: Extract new method FileDesc::get_access_mode

ALso fixed a bug in the original implementation

Signed-off-by: Jiahao XU <[email protected]>

Author: NobodyXu

library/std/src/sys/anonymous_pipe.rs

@@ -161,42 +161,22 @@ mod unix {
         }
     }
 
-    enum AccessMode {
-        Readable,
-        Writable,
-    }
-
-    fn check_access_mode(pipe: AnonPipe, expected_access_mode: AccessMode) -> io::Result<AnonPipe> {
-        let ret = unsafe { libc::fcntl(pipe.as_raw_fd(), libc::F_GETFL) };
-        let access_mode = ret & libc::O_ACCMODE;
-        let expected_access_mode_str = match expected_access_mode {
-            AccessMode::Readable => "readable",
-            AccessMode::Writable => "writable",
-        };
-        let expected_access_mode = match expected_access_mode {
-            AccessMode::Readable => libc::O_RDONLY,
-            AccessMode::Writable => libc::O_WRONLY,
-        };
-
-        if ret == -1 {
-            Err(io::Error::last_os_error())
-        } else if access_mode == libc::O_RDWR && access_mode == expected_access_mode {
-            Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                format!("Pipe {} is not {}", pipe.as_raw_fd(), expected_access_mode_str),
-            ))
-        } else {
-            Ok(pipe)
-        }
-    }
-
     #[unstable(feature = "anonymous_pipe", issue = "127154")]
     impl TryFrom<OwnedFd> for PipeReader {
         type Error = io::Error;
 
         fn try_from(owned_fd: OwnedFd) -> Result<Self, Self::Error> {
             convert_to_pipe(owned_fd)
-                .and_then(|pipe| check_access_mode(pipe, AccessMode::Readable))
+                .and_then(|pipe| {
+                    if pipe.as_file_desc().get_access_mode()?.readable {
+                        Ok(pipe)
+                    } else {
+                        Err(io::Error::new(
+                            io::ErrorKind::InvalidInput,
+                            format!("Pipe {} is not readable", pipe.as_raw_fd()),
+                        ))
+                    }
+                })
                 .map(Self)
         }
     }
@@ -207,7 +187,16 @@ mod unix {
 
         fn try_from(owned_fd: OwnedFd) -> Result<Self, Self::Error> {
             convert_to_pipe(owned_fd)
-                .and_then(|pipe| check_access_mode(pipe, AccessMode::Writable))
+                .and_then(|pipe| {
+                    if pipe.as_file_desc().get_access_mode()?.writable {
+                        Ok(pipe)
+                    } else {
+                        Err(io::Error::new(
+                            io::ErrorKind::InvalidInput,
+                            format!("Pipe {} is not writable", pipe.as_raw_fd()),
+                        ))
+                    }
+                })
                 .map(Self)
         }
     }

library/std/src/sys/pal/unix/fd.rs

@@ -26,6 +26,11 @@ use libc::off64_t;
 )))]
 use libc::off_t as off64_t;
 
+pub struct AccessMode {
+    pub readable: bool,
+    pub writable: bool,
+}
+
 #[derive(Debug)]
 pub struct FileDesc(OwnedFd);
 
@@ -518,20 +523,27 @@ impl FileDesc {
         }
     }
 
+    fn get_flags(&self) -> io::Result<libc::c_int> {
+        unsafe { cvt(libc::fcntl(self.as_raw_fd(), libc::F_GETFL)) }
+    }
+
+    pub fn get_access_mode(&self) -> io::Result<AccessMode> {
+        let access_mode = self.get_flags()? & libc::O_ACCMODE;
+        Ok(AccessMode {
+            readable: access_mode == libc::O_RDWR || access_mode == libc::O_RDONLY,
+            writable: access_mode == libc::O_RDWR || access_mode == libc::O_WRONLY,
+        })
+    }
+
     #[cfg(not(target_os = "linux"))]
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
-        unsafe {
-            let previous = cvt(libc::fcntl(self.as_raw_fd(), libc::F_GETFL))?;
-            let new = if nonblocking {
-                previous | libc::O_NONBLOCK
-            } else {
-                previous & !libc::O_NONBLOCK
-            };
-            if new != previous {
-                cvt(libc::fcntl(self.as_raw_fd(), libc::F_SETFL, new))?;
-            }
-            Ok(())
+        let previous = self.get_flags()?;
+        let new =
+            if nonblocking { previous | libc::O_NONBLOCK } else { previous & !libc::O_NONBLOCK };
+        if new != previous {
+            unsafe { cvt(libc::fcntl(self.as_raw_fd(), libc::F_SETFL, new)) }?;
         }
+        Ok(())
     }
 
     #[inline]

library/std/src/sys/pal/unix/pipe.rs

@@ -84,6 +84,10 @@ impl AnonPipe {
     pub fn is_write_vectored(&self) -> bool {
         self.0.is_write_vectored()
     }
+
+    pub fn as_file_desc(&self) -> &FileDesc {
+        &self.0
+    }
 }
 
 impl IntoInner<FileDesc> for AnonPipe {