Support Host I/O operations

src/gdbstub_impl/mod.rs

@@ -561,9 +561,7 @@ impl<T: Target, C: Connection> GdbStubImpl<T, C> {
     ) -> Result<HandlerStatus, Error<T::Error, C::Error>> {
         match cmd {
             Command::Unknown(cmd) => {
-                // cmd must be ASCII, as the slice originated from a PacketBuf, which checks for
-                // ASCII as part of the initial validation.
-                info!("Unknown command: {}", core::str::from_utf8(cmd).unwrap());
+                info!("Unknown command: {:?}", core::str::from_utf8(cmd));
                 Ok(HandlerStatus::Handled)
             }
             // `handle_X` methods are defined in the `ext` module

src/protocol/commands.rs

@@ -6,7 +6,9 @@ use crate::target::Target;
 pub(self) mod prelude {
     pub use super::ParseCommand;
     pub use crate::common::*;
-    pub use crate::protocol::common::hex::{decode_hex, decode_hex_buf, is_hex, HexString};
+    pub use crate::protocol::common::hex::{
+        decode_bin_buf, decode_hex, decode_hex_buf, is_hex, HexString,
+    };
     pub use crate::protocol::common::lists;
     pub use crate::protocol::common::thread_id::{
         IdKind, SpecificIdKind, SpecificThreadId, ThreadId,

src/protocol/commands/_vFile_pwrite.rs

@@ -19,7 +19,7 @@ impl<'a> ParseCommand<'a> for vFilePwrite<'a> {
                 let mut body = body.splitn_mut_no_panic(3, |b| *b == b',');
                 let fd = decode_hex(body.next()?).ok()?;
                 let offset = decode_hex_buf(body.next()?).ok()?;
-                let data = body.next()?;
+                let data = decode_bin_buf(body.next()?).ok()?;
                 Some(vFilePwrite{fd, offset, data})
             },
             _ => None,

src/protocol/common/hex.rs

@@ -168,7 +168,34 @@ pub fn decode_hex_buf(base_buf: &mut [u8]) -> Result<&mut [u8], DecodeHexBufErro
     Ok(&mut base_buf[..decoded_len + odd_adust])
 }
 
-#[allow(dead_code)]
+#[derive(Debug)]
+pub enum DecodeBinBufError {
+    UnexpectedEnd,
+}
+
+/// Decode GDB escaped binary bytes into origin bytes _in place_.
+pub fn decode_bin_buf(buf: &mut [u8]) -> Result<&mut [u8], DecodeBinBufError> {
+    use DecodeBinBufError::*;
+    let mut i = 0;
+    let mut j = 0;
+    let len = buf.len();
+    while i < len {
+        if buf[i] == b'}' {
+            if i == len - 1 {
+                return Err(UnexpectedEnd);
+            } else {
+                buf[j] = buf[i + 1] ^ 0x20;
+                i += 1;
+            }
+        } else {
+            buf[j] = buf[i];
+        }
+        i += 1;
+        j += 1;
+    }
+    Ok(&mut buf[..j])
+}
+
 #[derive(Debug)]
 pub enum EncodeHexBufError {
     SmallBuffer,
@@ -268,4 +295,11 @@ mod tests {
         let res = decode_hex_buf(&mut payload).unwrap();
         assert_eq!(res, [0x1]);
     }
+
+    #[test]
+    fn decode_bin_buf_escaped() {
+        let mut payload = b"}\x03}\x04}]}\n".to_vec();
+        let res = decode_bin_buf(&mut payload).unwrap();
+        assert_eq!(res, [0x23, 0x24, 0x7d, 0x2a]);
+    }
 }

src/protocol/packet.rs

@@ -10,7 +10,6 @@ pub enum PacketParseError {
     MissingChecksum,
     MalformedChecksum,
     MalformedCommand,
-    NotAscii,
     UnexpectedHeader(u8),
 }
 
@@ -57,11 +56,6 @@ impl<'a> PacketBuf<'a> {
             .get(..2)
             .ok_or(PacketParseError::MalformedChecksum)?;
 
-        // validate that the body is valid ASCII
-        if !body.is_ascii() {
-            return Err(PacketParseError::NotAscii);
-        }
-
         // validate the checksum
         let checksum = decode_hex(checksum).map_err(|_| PacketParseError::MalformedChecksum)?;
         let calculated = body.iter().fold(0u8, |a, x| a.wrapping_add(*x));
@@ -84,11 +78,6 @@ impl<'a> PacketBuf<'a> {
     /// the header/checksum trimming stage. ASCII validation is still performed.
     #[cfg(test)]
     pub fn new_with_raw_body(body: &'a mut [u8]) -> Result<PacketBuf<'a>, PacketParseError> {
-        // validate the packet is valid ASCII
-        if !body.is_ascii() {
-            return Err(PacketParseError::NotAscii);
-        }
-
         let len = body.len();
         Ok(PacketBuf {
             buf: body,

src/protocol/response_writer.rs

@@ -54,7 +54,7 @@ impl<'a, C: Connection + 'a> ResponseWriter<'a, C> {
         #[cfg(feature = "std")]
         trace!(
             "--> ${}#{:02x?}",
-            core::str::from_utf8(&self.msg).unwrap(), // buffers are always ascii
+            String::from_utf8_lossy(&self.msg),
             checksum
         );