fix(client): race in connection errors propagation

Fix a race condition in the legacy HTTP client's connection setup where
connection errors (e.g., TLS failures, unexpected server responses) were
discarded, resulting in vague ChannelClosed errors.

seanmonstar/reqwest#2649

Author: dare3path

src/client/legacy/client.rs

@@ -582,16 +582,41 @@ where
                                     trace!(
                                         "http1 handshake complete, spawning background dispatcher task"
                                     );
+                                    let (err_tx, err_rx) = tokio::sync::oneshot::channel();
                                     executor.execute(
                                         conn.with_upgrades()
-                                            .map_err(|e| debug!("client connection error: {}", e))
+                                            .map_err(|e| {
+                                                debug!("client connection error: {:?}", e);
+                                                trace!("sending connection error to error channel");
+                                                let _ =err_tx.send(e);
+                                            })
                                             .map(|_| ()),
                                     );
-
-                                    // Wait for 'conn' to ready up before we
-                                    // declare this tx as usable
-                                    tx.ready().await.map_err(Error::tx)?;
-                                    PoolTx::Http1(tx)
+                                    trace!("waiting for connection to be ready");
+                                    match tx.ready().await {
+                                        Ok(_) => {
+                                            trace!("connection is ready");
+                                            drop(err_rx);
+                                            PoolTx::Http1(tx)
+                                        }
+                                        Err(e) if e.is_closed() => {
+                                            trace!("connection channel closed, checking for connection error");
+                                            match err_rx.await {
+                                                Ok(err) => {
+                                                    trace!("received connection error: {:?}", err);
+                                                    return Err(Error::tx(err));
+                                                }
+                                                Err(_) => {
+                                                    trace!("error channel closed, returning the vague ChannelClosed error");
+                                                    return Err(Error::tx(e));
+                                                }
+                                            }
+                                        }
+                                        Err(e) => {
+                                            trace!("connection readiness failed: {:?}", e);
+                                            return Err(Error::tx(e));
+                                        }
+                                    }
                                 }
                                 #[cfg(not(feature = "http1"))] {
                                     panic!("http1 feature is not enabled");