From 022926019bed1686deebf2d3ae9921ab49d874c4 Mon Sep 17 00:00:00 2001
From: Pat Hickey <pat@moreproductive.org>
Date: Mon, 24 Apr 2023 15:08:42 -0700
Subject: [PATCH] adapter poll_oneoff: when descriptors.get_*_stream(fd) fails,
 die with that error (#154)

* adapter poll_oneoff: when descriptors.get_*_stream(fd) fails, die with that error

There was a special case in poll_oneoff that put in a fake clock stream
when a read/write stream for a descriptor wasn't available. The
poll_oneoff_files test (in `test_fd_readwrite_invalid_fd()`) checks that
poll_oneoff returns a BADF when an invalid fd is subscribed to.

I'm not sure what the special case was patching over, but this passes
all of the other tests right now.

* poll_oneoff_files fails on windows with god knows what error
diff --git a/host/tests/command.rs b/host/tests/command.rs
index 7af7bd0..67c8c0b 100644
--- a/host/tests/command.rs
+++ b/host/tests/command.rs
@@ -466,10 +466,11 @@ async fn run_path_symlink_trailing_slashes(store: Store<WasiCtx>, wasi: Command)
 }

 async fn run_poll_oneoff_files(store: Store<WasiCtx>, wasi: Command) -> Result<()> {
-    // trapping upwrap in poll_oneoff in adapter.
-    // maybe this is related to the "if fd isnt a stream, request a pollable which completes
-    // immediately so itll immediately fail" behavior, which i think breaks internal invariant...
-    run_with_temp_dir(store, wasi).await
+    if cfg!(windows) {
+        expect_fail(run_with_temp_dir(store, wasi).await)
+    } else {
+        run_with_temp_dir(store, wasi).await
+    }
 }

 async fn run_poll_oneoff_stdio(store: Store<WasiCtx>, wasi: Command) -> Result<()> {
---
 src/lib.rs | 30 ++++++++----------------------
 1 file changed, 8 insertions(+), 22 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index ab7c555925..1ffc153585 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1585,7 +1585,6 @@ pub unsafe extern "C" fn poll_oneoff(
                 )
                 .trapping_unwrap()
     );
-
     // Store the pollable handles at the beginning, and the bool results at the
     // end, so that we don't clobber the bool results when writting the events.
     let pollables = out as *mut c_void as *mut Pollable;
@@ -1653,36 +1652,23 @@ pub unsafe extern "C" fn poll_oneoff(
                 }
 
                 EVENTTYPE_FD_READ => {
-                    match state
+                    let stream = state
                         .descriptors()
-                        .get_read_stream(subscription.u.u.fd_read.file_descriptor)
-                    {
-                        Ok(stream) => streams::subscribe_to_input_stream(stream),
-                        // If the file descriptor isn't a stream, request a
-                        // pollable which completes immediately so that it'll
-                        // immediately fail.
-                        Err(ERRNO_BADF) => monotonic_clock::subscribe(0, false),
-                        Err(e) => return Err(e),
-                    }
+                        .get_read_stream(subscription.u.u.fd_read.file_descriptor)?;
+                    streams::subscribe_to_input_stream(stream)
                 }
 
                 EVENTTYPE_FD_WRITE => {
-                    match state
+                    let stream = state
                         .descriptors()
-                        .get_write_stream(subscription.u.u.fd_write.file_descriptor)
-                    {
-                        Ok(stream) => streams::subscribe_to_output_stream(stream),
-                        // If the file descriptor isn't a stream, request a
-                        // pollable which completes immediately so that it'll
-                        // immediately fail.
-                        Err(ERRNO_BADF) => monotonic_clock::subscribe(0, false),
-                        Err(e) => return Err(e),
-                    }
+                        .get_write_stream(subscription.u.u.fd_write.file_descriptor)?;
+                    streams::subscribe_to_output_stream(stream)
                 }
 
                 _ => return Err(ERRNO_INVAL),
             });
         }
+
         let vec = state.import_alloc.with_buffer(
             results,
             nsubscriptions
@@ -1776,7 +1762,7 @@ pub unsafe extern "C" fn poll_oneoff(
                     type_ = wasi::EVENTTYPE_FD_WRITE;
                     let ds = state.descriptors();
                     let desc = ds
-                        .get(subscription.u.u.fd_read.file_descriptor)
+                        .get(subscription.u.u.fd_write.file_descriptor)
                         .trapping_unwrap();
                     match desc {
                         Descriptor::Streams(streams) => match streams.type_ {