[fastboot]: fix clippy errors

Return errors on short writes.

Fun fact: we cannot use `write_all` for this as in TCP Fastboot mode, we
write _more_ than the passed buffer (the first 8 bytes we write is the
length of the actual message we are sending), and `write_all` will panic
as it thinkss we are trying a buffer overflow as we report back that we
wrote more than we sent.

See:

https://github.com/rust-lang/futures-rs/blob/master/futures-util/src/io/write_all.rs#L33

And

https://doc.rust-lang.org/src/core/slice/mod.rs.html#1886

Instead report back if there are short writes and error

Fixed: b/42177040
Bug: b/42177040
Change-Id: I048cd4d9087168263aec5a4f7576e44341ca67bd
Reviewed-on: https://fuchsia-review.googlesource.com/c/fuchsia/+/1036216
Reviewed-by: Andrew Davies <[email protected]>
Fuchsia-Auto-Submit: Colin Nelson <[email protected]>
Commit-Queue: Auto-Submit <[email protected]>
Reviewed-by: Casey Dahlin <[email protected]>

Author: orthros

src/developer/fastboot/src/lib.rs

@@ -35,6 +35,8 @@ lazy_static! {
 pub enum SendError {
     #[error("timed out reading a reply from device")]
     Timeout,
+    #[error("Did not write correct number of bytes. Got {:?}. Want {}", written, expected)]
+    ShortWrite { written: usize, expected: usize },
 }
 
 #[derive(Debug, Error)]
@@ -171,7 +173,6 @@ async fn read_with_timeout<T: AsyncRead + Unpin>(
     }
 }
 
-#[allow(clippy::unused_io_amount)] // TODO(https://fxbug.dev/42177040)
 pub async fn send_with_listener<T: AsyncRead + AsyncWrite + Unpin>(
     cmd: Command,
     interface: &mut T,
@@ -180,24 +181,28 @@ pub async fn send_with_listener<T: AsyncRead + AsyncWrite + Unpin>(
     let _lock = SEND_LOCK.lock().await;
     let bytes = Vec::<u8>::try_from(&cmd)?;
     tracing::debug!("Fastboot: writing command {cmd:?}: {}", String::from_utf8_lossy(&bytes));
-    interface.write(&bytes).await?;
+    let written = interface.write(&bytes).await?;
+    if written < bytes.len() {
+        return Err(anyhow!(SendError::ShortWrite { written, expected: bytes.len() }));
+    }
     read(interface, listener).await
 }
 
 #[tracing::instrument(skip(interface))]
-#[allow(clippy::unused_io_amount)] // TODO(https://fxbug.dev/42177040)
 pub async fn send<T: AsyncRead + AsyncWrite + Unpin>(
     cmd: Command,
     interface: &mut T,
 ) -> Result<Reply> {
     let _lock = SEND_LOCK.lock().await;
     let bytes = Vec::<u8>::try_from(&cmd)?;
     tracing::debug!("Fastboot: writing command {cmd:?}: {}", String::from_utf8_lossy(&bytes));
-    interface.write(&bytes).await?;
+    let written = interface.write(&bytes).await?;
+    if written < bytes.len() {
+        return Err(anyhow!(SendError::ShortWrite { written, expected: bytes.len() }));
+    }
     read_and_log_info(interface).await
 }
 
-#[allow(clippy::unused_io_amount)] // TODO(https://fxbug.dev/42177040)
 pub async fn send_with_timeout<T: AsyncRead + AsyncWrite + Unpin>(
     cmd: Command,
     interface: &mut T,
@@ -206,7 +211,10 @@ pub async fn send_with_timeout<T: AsyncRead + AsyncWrite + Unpin>(
     let _lock = SEND_LOCK.lock().await;
     let bytes = Vec::<u8>::try_from(&cmd)?;
     tracing::debug!("Fastboot: writing command {cmd:?}: {}", String::from_utf8_lossy(&bytes));
-    interface.write(&bytes).await?;
+    let written = interface.write(&bytes).await?;
+    if written < bytes.len() {
+        return Err(anyhow!(SendError::ShortWrite { written, expected: bytes.len() }));
+    }
     read_with_timeout(interface, &LogInfoListener {}, timeout).await
 }
 
@@ -263,7 +271,13 @@ pub async fn upload_with_read_timeout<T: AsyncRead + AsyncWrite + Unpin, R: Read
                                 listener.on_error(&err).await?;
                                 bail!(err);
                             }
-                            _ => {
+                            Ok(written) => {
+                                if written < n {
+                                    return Err(anyhow!(SendError::ShortWrite {
+                                        written,
+                                        expected: n
+                                    }));
+                                }
                                 listener.on_progress(n.try_into().unwrap()).await?;
                                 tracing::trace!("fastboot: wrote {} bytes", n);
                             }

src/developer/ffx/lib/fastboot/interface/src/fastboot_interface.rs

@@ -111,6 +111,9 @@ pub enum FastbootError {
 
     #[error("Failed to get all variables: {}", .0 )]
     GetAllVarsFailed(String),
+
+    #[error("Did not write correct number of bytes. Got {:?}. Want {}", written, expected)]
+    ShortWrite { written: usize, expected: usize },
 }
 
 #[derive(thiserror::Error, Debug)]

src/developer/ffx/lib/fastboot/interface/src/fastboot_proxy.rs

@@ -278,6 +278,12 @@ impl<T: AsyncRead + AsyncWrite + Unpin + Debug> Fastboot for FastbootProxy<T> {
                             };
                             Err(FastbootError::FlashError(FlashError::TimeoutError(message)))
                         }
+                        SendError::ShortWrite { written, expected } => {
+                            Err(FastbootError::ShortWrite {
+                                written: *written,
+                                expected: *expected,
+                            })
+                        }
                     }
                 } else {
                     Err(FastbootError::FlashError(

src/developer/ffx/tests/target/src/tests.rs

@@ -279,6 +279,7 @@ async fn enter_fastboot(
         let line = res.unwrap();
         eprintln!("{}", line);
         if line.contains("Press f to enter fastboot.") {
+            eprintln!("TEST: About to press f");
             writer.write_all(b"f").await.expect("failed to press f");
             break;
         }