Fixes from PR

- is_ebadf always returns false
- Allow reading partial characters to buffer

Signed-off-by: Ayush Singh <ayushdevel1325@gmail.com>

Author: Ayush1325

library/std/src/sys/uefi/stdio.rs

@@ -5,54 +5,71 @@ use crate::os::uefi;
 use crate::ptr::NonNull;
 
 pub struct Stdin {
-    pending: Option<char>,
+    pending: [Option<u8>; 2],
 }
 
 pub struct Stdout;
 pub struct Stderr;
 
 impl Stdin {
     pub const fn new() -> Stdin {
-        Stdin { pending: None }
+        Stdin { pending: [None; 2] }
     }
 }
 
 impl io::Read for Stdin {
-    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        if buf.is_empty() {
+            return Ok(0);
+        }
+
         let st: NonNull<r_efi::efi::SystemTable> = uefi::env::system_table().cast();
         let stdin = unsafe { (*st.as_ptr()).con_in };
+        let mut count: usize = 0;
 
         // Write any pending character
-        if let Some(ch) = self.pending {
-            if ch.len_utf8() > buf.len() {
-                return Ok(0);
+        while let Some(byte) = self.pending[0] {
+            buf[count] = byte;
+            count += 1;
+            self.pending[0] = self.pending[1].take();
+
+            if count >= buf.len() {
+                return Ok(count);
             }
-            ch.encode_utf8(buf);
-            buf = &mut buf[ch.len_utf8()..];
-            self.pending = None;
         }
 
-        // Try reading any pending data
-        let inp = read(stdin)?;
-
-        // Check if the key is printiable character
+        // Try reading new character
+        let inp = simple_text_input_read(stdin)?;
         if inp == 0x00 {
             return Err(io::const_io_error!(io::ErrorKind::Interrupted, "Special Key Press"));
         }
 
-        // The option unwrap is safe since iterator will have 1 element.
-        let ch: char = char::decode_utf16([inp])
-            .next()
-            .unwrap()
-            .map_err(|_| io::const_io_error!(io::ErrorKind::InvalidInput, "Invalid Input"))?;
-        if ch.len_utf8() > buf.len() {
-            self.pending = Some(ch);
-            return Ok(0);
+        let Some(Ok(ch)) = char::decode_utf16([inp]).next() else {
+            return Err(io::const_io_error!(io::ErrorKind::InvalidInput, "Invalid Input"));
+        };
+
+        // This will always be > 0
+        let buf_free_count = buf.len() - count;
+        assert!(buf_free_count > 0);
+
+        if ch.len_utf8() > buf_free_count {
+            let mut temp = [0u8; 3];
+            ch.encode_utf8(&mut temp);
+
+            buf[count..].copy_from_slice(&temp[..buf_free_count]);
+            count += buf_free_count;
+
+            for (i, v) in temp[buf_free_count..].into_iter().enumerate() {
+                self.pending[i] = Some(*v);
+            }
+
+            return Ok(count);
         }
 
         ch.encode_utf8(buf);
+        count += ch.len_utf8();
 
-        Ok(ch.len_utf8())
+        Ok(count)
     }
 }
 
@@ -97,8 +114,8 @@ impl io::Write for Stderr {
 // UCS-2 character should occupy 3 bytes at most in UTF-8
 pub const STDIN_BUF_SIZE: usize = 3;
 
-pub fn is_ebadf(err: &io::Error) -> bool {
-    err.raw_os_error() == Some(r_efi::efi::Status::UNSUPPORTED.as_usize())
+pub fn is_ebadf(_err: &io::Error) -> bool {
+    false
 }
 
 pub fn panic_output() -> Option<impl io::Write> {
@@ -116,6 +133,7 @@ fn write(
     };
 
     let mut utf16: Vec<u16> = utf8.encode_utf16().collect();
+    // NULL terminate the string
     utf16.push(0);
 
     unsafe { simple_text_output(protocol, &mut utf16) }?;
@@ -131,7 +149,9 @@ unsafe fn simple_text_output(
     if res.is_error() { Err(io::Error::from_raw_os_error(res.as_usize())) } else { Ok(()) }
 }
 
-fn read(stdin: *mut r_efi::protocols::simple_text_input::Protocol) -> io::Result<u16> {
+fn simple_text_input_read(
+    stdin: *mut r_efi::protocols::simple_text_input::Protocol,
+) -> io::Result<u16> {
     loop {
         match read_key_stroke(stdin) {
             Ok(x) => return Ok(x.unicode_char),