delegate read_password() to read_password_with_config()

Author: conradkleinespel

src/lib.rs

@@ -204,9 +204,9 @@ mod wasm {
 
 #[cfg(target_family = "unix")]
 mod unix {
-    use super::{Config, FeedbackState, PasswordFeedback, SafeString};
+    use super::{Config, ConfigBuilder, FeedbackState};
     use libc::{c_int, tcsetattr, termios, ECHO, ECHONL, ICANON, ISIG, TCSANOW, VMIN, VTIME};
-    use std::io::{self, BufRead, Write};
+    use std::io::{self, Write};
     use std::mem;
     use std::os::unix::io::AsRawFd;
 
@@ -217,41 +217,6 @@ mod unix {
     const CTRL_U: u8 = 0x15;
     const ESC: u8 = 0x1B;
 
-    struct HiddenInput {
-        fd: i32,
-        term_orig: termios,
-    }
-
-    impl HiddenInput {
-        fn new(fd: i32) -> io::Result<HiddenInput> {
-            // Make two copies of the terminal settings. The first one will be modified
-            // and the second one will act as a backup for when we want to set the
-            // terminal back to its original state.
-            let mut term = safe_tcgetattr(fd)?;
-            let term_orig = safe_tcgetattr(fd)?;
-
-            // Hide the password. This is what makes this function useful.
-            term.c_lflag &= !ECHO;
-
-            // But don't hide the NL character when the user hits ENTER.
-            term.c_lflag |= ECHONL;
-
-            // Save the settings for now.
-            io_result(unsafe { tcsetattr(fd, TCSANOW, &term) })?;
-
-            Ok(HiddenInput { fd, term_orig })
-        }
-    }
-
-    impl Drop for HiddenInput {
-        fn drop(&mut self) {
-            // Set the mode back to normal
-            unsafe {
-                tcsetattr(self.fd, TCSANOW, &self.term_orig);
-            }
-        }
-    }
-
     /// Turns a C function return into an IO Result
     fn io_result(ret: c_int) -> std::io::Result<()> {
         match ret {
@@ -268,27 +233,7 @@ mod unix {
 
     /// Reads a password from the TTY
     pub fn read_password() -> std::io::Result<String> {
-        let tty = std::fs::File::open("/dev/tty")?;
-        let fd = tty.as_raw_fd();
-        let mut reader = io::BufReader::new(tty);
-
-        read_password_from_fd_with_hidden_input(&mut reader, fd)
-    }
-
-    /// Reads a password from a given file descriptor
-    fn read_password_from_fd_with_hidden_input(
-        reader: &mut impl BufRead,
-        fd: i32,
-    ) -> std::io::Result<String> {
-        let mut password = SafeString::new();
-
-        let hidden_input = HiddenInput::new(fd)?;
-
-        reader.read_line(&mut password)?;
-
-        std::mem::drop(hidden_input);
-
-        super::fix_line_issues(password.into_inner())
+        read_password_with_config(ConfigBuilder::new().build())
     }
 
     struct RawModeInput {
@@ -321,10 +266,6 @@ mod unix {
 
     /// Reads a password from TTY using the given config
     pub fn read_password_with_config(config: Config) -> std::io::Result<String> {
-        if config.feedback == PasswordFeedback::Hide {
-            return read_password();
-        }
-
         let mut tty = std::fs::OpenOptions::new()
             .read(true)
             .write(true)
@@ -452,7 +393,7 @@ mod unix {
 
 #[cfg(target_family = "windows")]
 mod windows {
-    use super::{Config, FeedbackState, PasswordFeedback, SafeString};
+    use super::{Config, ConfigBuilder, FeedbackState, PasswordFeedback, SafeString};
     use std::io::{self, BufRead, BufReader, Write};
     use std::os::windows::io::FromRawHandle;
     use windows_sys::core::PCSTR;
@@ -474,82 +415,9 @@ mod windows {
     const CTRL_U: char = '\x15';
     const ESC: char = '\x1B';
 
-    struct HiddenInput {
-        mode: u32,
-        handle: HANDLE,
-    }
-
-    impl HiddenInput {
-        fn new(handle: HANDLE) -> io::Result<HiddenInput> {
-            let mut mode = 0;
-
-            // Get the old mode so we can reset back to it when we are done
-            if unsafe { GetConsoleMode(handle, &mut mode as *mut CONSOLE_MODE) } == 0 {
-                return Err(std::io::Error::last_os_error());
-            }
-
-            // We want to be able to read line by line, and we still want backspace to work
-            let new_mode_flags = ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT;
-            if unsafe { SetConsoleMode(handle, new_mode_flags) } == 0 {
-                return Err(std::io::Error::last_os_error());
-            }
-
-            Ok(HiddenInput { mode, handle })
-        }
-    }
-
-    impl Drop for HiddenInput {
-        fn drop(&mut self) {
-            // Set the mode back to normal
-            unsafe {
-                SetConsoleMode(self.handle, self.mode);
-            }
-        }
-    }
-
     /// Reads a password from the TTY
     pub fn read_password() -> std::io::Result<String> {
-        let handle = unsafe {
-            CreateFileA(
-                b"CONIN$\x00".as_ptr() as PCSTR,
-                GENERIC_READ | GENERIC_WRITE,
-                FILE_SHARE_READ | FILE_SHARE_WRITE,
-                std::ptr::null(),
-                OPEN_EXISTING,
-                0,
-                INVALID_HANDLE_VALUE,
-            )
-        };
-
-        if handle == INVALID_HANDLE_VALUE {
-            return Err(std::io::Error::last_os_error());
-        }
-
-        let mut stream = BufReader::new(unsafe { std::fs::File::from_raw_handle(handle as _) });
-        read_password_from_handle_with_hidden_input(&mut stream, handle)
-    }
-
-    /// Reads a password from a given file handle
-    fn read_password_from_handle_with_hidden_input(
-        reader: &mut impl BufRead,
-        handle: HANDLE,
-    ) -> io::Result<String> {
-        let mut password = SafeString::new();
-
-        let hidden_input = HiddenInput::new(handle)?;
-
-        let reader_return = reader.read_line(&mut password);
-
-        // Newline for windows which otherwise prints on the same line.
-        println!();
-
-        if reader_return.is_err() {
-            return Err(reader_return.unwrap_err());
-        }
-
-        std::mem::drop(hidden_input);
-
-        super::fix_line_issues(password.into_inner())
+        read_password_with_config(ConfigBuilder::new().build())
     }
 
     struct RawModeInput {