response: We *are* blocking!

We're not using some event-driven async I/O, that's the whole point
of this crate. The sockets are not set up as non-blocking and it would
be very unexpected for the OS to return EWOULDBLOCK from recv().

examples/iterator.rs

@@ -5,18 +5,8 @@ fn main() -> Result<(), minreq::Error> {
     let mut buffer = Vec::new();
     for byte in minreq::get("http://example.com").send_lazy()? {
         // The connection could have a problem at any point during the
-        // download, so each byte needs to be unwrapped. An IO error
-        // of the WouldBlock kind may also be returned, but it is not
-        // a fatal error, it just means that we're still waiting for
-        // more bytes. Some operating systems just block while waiting
-        // for more bytes, others return a WouldBlock error.
-        let (byte, len) = match byte {
-            Ok((byte, len)) => (byte, len),
-            Err(minreq::Error::IoError(err)) if err.kind() == std::io::ErrorKind::WouldBlock => {
-                continue
-            }
-            Err(err) => return Err(err),
-        };
+        // download, so each byte needs to be unwrapped.
+        let (byte, len) = byte?;
 
         // The `byte` is the current u8 of data we're iterating
         // through.

src/response.rs

@@ -47,8 +47,8 @@ impl Response {
                         body.push(byte);
                     }
                     Err(Error::IoError(err)) if err.kind() == ErrorKind::WouldBlock => {
-                        // Busy waiting isn't ideal, but waiting for N milliseconds would be worse.
-                        std::thread::yield_now();
+                        // We're a blocking socket, so EWOULDBLOCK indicates a timeout
+                        return Err(Error::IoError(io::Error::from(ErrorKind::TimedOut)));
                     }
                     Err(err) => return Err(err),
                 }
@@ -547,8 +547,8 @@ fn read_line(
                 }
             }
             Err(err) if err.kind() == ErrorKind::WouldBlock => {
-                // Busy waiting isn't ideal, but waiting for N milliseconds would be worse.
-                std::thread::yield_now();
+                // We're a blocking socket, so EWOULDBLOCK indicates a timeout
+                return Err(Error::IoError(io::Error::from(ErrorKind::TimedOut)));
             }
             Err(err) => return Err(Error::IoError(err)),
         }