Make TCP connect handle EINTR correctly

According to the POSIX standard, if connect() is interrupted by a
signal that is caught while blocked waiting to establish a connection,
connect() shall fail and set errno to EINTR, but the connection
request shall not be aborted, and the connection shall be established
asynchronously. When the connection has been established asynchronously,
select() and poll() shall indicate that the file descriptor for the
socket is ready for writing.

The previous implementation differs from the recomendation: in a
case of the EINTR we tried to reconnect in a loop and sometimes
get EISCONN error (this problem was originally detected on MacOS).

Author: darthunix

library/std/src/sys_common/net.rs

@@ -228,7 +228,39 @@ impl TcpStream {
         let sock = Socket::new(addr, c::SOCK_STREAM)?;
 
         let (addr, len) = addr.into_inner();
-        cvt_r(|| unsafe { c::connect(sock.as_raw(), addr.as_ptr(), len) })?;
+
+        cfg_if::cfg_if! {
+            if #[cfg(any(
+                target_os = "android",
+                target_os = "linux",
+                target_os = "windows",
+            ))] {
+                cvt_r(|| unsafe { c::connect(sock.as_raw(), addr.as_ptr(), len) })?;
+            } else {
+
+                let ret = unsafe { c::connect(sock.as_raw(), addr.as_ptr(), len) };
+                if ret < 0 {
+                    let err = io::Error::last_os_error();
+                    if !err.is_interrupted() {
+                        return Err(err);
+                    }
+
+                    let mut pollfd = libc::pollfd { fd: sock.as_raw(), events: libc::POLLOUT, revents: 0 };
+                    loop {
+                        let ret = unsafe { libc::poll(&mut pollfd, 1, -1) };
+                        if ret < 0 {
+                            let err = io::Error::last_os_error();
+                            if err.is_interrupted() {
+                                continue;
+                            }
+                            return Err(err);
+                        }
+                        break;
+                    }
+                    sock.take_error()?;
+                }
+            }
+        }
         Ok(TcpStream { inner: sock })
     }