API change: defer everything to the callback

include/uv.h

@@ -510,10 +510,10 @@ UV_EXTERN int uv_tcp_getsockname(const uv_tcp_t* handle,
 UV_EXTERN int uv_tcp_getpeername(const uv_tcp_t* handle,
                                  struct sockaddr* name,
                                  int* namelen);
-UV_EXTERN int uv_tcp_connect(uv_connect_t* req,
-                             uv_tcp_t* handle,
-                             const struct sockaddr* addr,
-                             uv_connect_cb cb);
+UV_EXTERN void uv_tcp_connect(uv_connect_t* req,
+                              uv_tcp_t* handle,
+                              const struct sockaddr* addr,
+                              uv_connect_cb cb);
 
 /* uv_connect_t is a subclass of uv_req_t. */
 struct uv_connect_s {

src/unix/tcp.c

@@ -102,26 +102,29 @@ int uv__tcp_bind(uv_tcp_t* tcp,
 }
 
 
-int uv__tcp_connect(uv_connect_t* req,
-                    uv_tcp_t* handle,
-                    const struct sockaddr* addr,
-                    unsigned int addrlen,
-                    uv_connect_cb cb) {
+void uv__tcp_connect(uv_connect_t* req,
+                     uv_tcp_t* handle,
+                     const struct sockaddr* addr,
+                     unsigned int addrlen,
+                     uv_connect_cb cb) {
   int err;
   int r;
 
   assert(handle->type == UV_TCP);
 
-  if (handle->connect_req != NULL)
-    return -EALREADY;  /* FIXME(bnoordhuis) -EINVAL or maybe -EBUSY. */
+  if (handle->connect_req != NULL) {
+    handle->delayed_error = -EALREADY;  /* FIXME(bnoordhuis) -EINVAL or maybe -EBUSY. */
+    goto out;
+  }
 
   err = maybe_new_socket(handle,
                          addr->sa_family,
                          UV_STREAM_READABLE | UV_STREAM_WRITABLE);
-  if (err)
-    return err;
+  if (err) {
+    handle->delayed_error = err;
+    goto out;
+  }
 
-  handle->delayed_error = 0;
 
   do
     r = connect(uv__stream_fd(handle), addr, addrlen);
@@ -130,16 +133,15 @@ int uv__tcp_connect(uv_connect_t* req,
   if (r == -1) {
     if (errno == EINPROGRESS)
       ; /* not an error */
-    else if (errno == ECONNREFUSED)
-    /* If we get a ECONNREFUSED wait until the next tick to report the
-     * error. Solaris wants to report immediately--other unixes want to
-     * wait.
+    else
+    /* Note that Solaris wants to report ECONNREFUSED immediately,
+     * other unixes want to wait
      */
       handle->delayed_error = -errno;
-    else
-      return -errno;
   }
 
+out:
+
   uv__req_init(handle->loop, req, UV_CONNECT);
   req->cb = cb;
   req->handle = (uv_stream_t*) handle;
@@ -150,8 +152,6 @@ int uv__tcp_connect(uv_connect_t* req,
 
   if (handle->delayed_error)
     uv__io_feed(handle->loop, &handle->io_watcher);
-
-  return 0;
 }
 
 

src/uv-common.c

@@ -177,23 +177,26 @@ int uv_udp_bind(uv_udp_t* handle,
 }
 
 
-int uv_tcp_connect(uv_connect_t* req,
-                   uv_tcp_t* handle,
-                   const struct sockaddr* addr,
-                   uv_connect_cb cb) {
+void uv_tcp_connect(uv_connect_t* req,
+                    uv_tcp_t* handle,
+                    const struct sockaddr* addr,
+                    uv_connect_cb cb) {
   unsigned int addrlen;
+  int err;
+
+  err = 0;
 
   if (handle->type != UV_TCP)
-    return UV_EINVAL;
+    err = ERROR_INVALID_PARAMETER;
 
   if (addr->sa_family == AF_INET)
     addrlen = sizeof(struct sockaddr_in);
   else if (addr->sa_family == AF_INET6)
     addrlen = sizeof(struct sockaddr_in6);
   else
-    return UV_EINVAL;
+    err = ERROR_INVALID_PARAMETER;
 
-  return uv__tcp_connect(req, handle, addr, addrlen, cb);
+  uv__tcp_connect(req, handle, addr, addrlen, cb, err);
 }
 
 

src/uv-common.h

@@ -64,11 +64,12 @@ int uv__tcp_bind(uv_tcp_t* tcp,
                  unsigned int addrlen,
                  unsigned int flags);
 
-int uv__tcp_connect(uv_connect_t* req,
-                   uv_tcp_t* handle,
-                   const struct sockaddr* addr,
-                   unsigned int addrlen,
-                   uv_connect_cb cb);
+void uv__tcp_connect(uv_connect_t* req,
+                     uv_tcp_t* handle,
+                     const struct sockaddr* addr,
+                     unsigned int addrlen,
+                     uv_connect_cb cb,
+                     int err);
 
 int uv__udp_bind(uv_udp_t* handle,
                  const struct sockaddr* addr,

src/win/tcp.c

@@ -1435,16 +1435,29 @@ int uv__tcp_bind(uv_tcp_t* handle,
 /* This function is an egress point, i.e. it returns libuv errors rather than
  * system errors.
  */
-int uv__tcp_connect(uv_connect_t* req,
+void uv__tcp_connect(uv_connect_t* req,
                     uv_tcp_t* handle,
                     const struct sockaddr* addr,
                     unsigned int addrlen,
-                    uv_connect_cb cb) {
-  int err;
+                    uv_connect_cb cb,
+                    int err) {
+  uv_loop_t *loop;
 
-  err = uv_tcp_try_connect(req, handle, addr, addrlen, cb);
-  if (err)
-    return uv_translate_sys_error(err);
+  if (!err)
+    err = uv_tcp_try_connect(req, handle, addr, addrlen, cb);
 
-  return 0;
+  if (err) {
+    loop = handle->loop;
+
+    uv_req_init(loop, (uv_req_t*) req);
+    req->type = UV_CONNECT;
+    req->handle = (uv_stream_t*) handle;
+    req->cb = cb;
+    memset(&req->overlapped, 0, sizeof(req->overlapped));
+    SET_REQ_ERROR(req, err);
+
+    handle->reqs_pending++;
+    REGISTER_HANDLE_REQ(loop, handle, req);
+    uv_insert_pending_req(loop, (uv_req_t*)req);
+  }
 }

test/test-callback-stack.c

@@ -149,6 +149,9 @@ static void write_cb(uv_write_t* req, int status) {
 static void connect_cb(uv_connect_t* req, int status) {
   uv_buf_t buf;
 
+  if (status)
+    FATAL("uv_tcp_connect failed");
+
   puts("Connected. Write some data to echo server...");
 
   ASSERT(status == 0);
@@ -182,12 +185,10 @@ TEST_IMPL(callback_stack) {
 
   nested++;
 
-  if (uv_tcp_connect(&connect_req,
-                     &client,
-                     (const struct sockaddr*) &addr,
-                     connect_cb)) {
-    FATAL("uv_tcp_connect failed");
-  }
+  uv_tcp_connect(&connect_req,
+                 &client,
+                 (const struct sockaddr*) &addr,
+                 connect_cb);
   nested--;
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);

test/test-connection-fail.c

@@ -102,11 +102,10 @@ static void connection_fail(uv_connect_cb connect_cb) {
   /* so these handles can be pre-initialized. */
   ASSERT(0 == uv_tcp_bind(&tcp, (const struct sockaddr*) &client_addr, 0));
 
-  r = uv_tcp_connect(&req,
-                     &tcp,
-                     (const struct sockaddr*) &server_addr,
-                     connect_cb);
-  ASSERT(!r);
+  uv_tcp_connect(&req,
+                 &tcp,
+                 (const struct sockaddr*) &server_addr,
+                 connect_cb);
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
 

test/test-delayed-accept.c

@@ -162,11 +162,10 @@ static void client_connect(void) {
   r = uv_tcp_init(uv_default_loop(), client);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(connect_req,
-                     client,
-                     (const struct sockaddr*) &addr,
-                     connect_cb);
-  ASSERT(r == 0);
+  uv_tcp_connect(connect_req,
+                 client,
+                 (const struct sockaddr*) &addr,
+                 connect_cb);
 }
 
 

test/test-emfile.c

@@ -73,10 +73,10 @@ TEST_IMPL(emfile) {
    * handling logic in src/unix/stream.c should ensure that connect_cb() runs
    * whereas connection_cb() should *not* run.
    */
-  ASSERT(0 == uv_tcp_connect(&connect_req,
-                             &client_handle,
-                             (const struct sockaddr*) &addr,
-                             connect_cb));
+  uv_tcp_connect(&connect_req,
+                 &client_handle,
+                 (const struct sockaddr*) &addr,
+                             connect_cb);
   ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
   ASSERT(1 == connect_cb_called);
 

test/test-getsockname.c

@@ -219,10 +219,10 @@ static void tcp_connector(void) {
   tcp.data = &connect_req;
   ASSERT(!r);
 
-  r = uv_tcp_connect(&connect_req,
-                     &tcp,
-                     (const struct sockaddr*) &server_addr,
-                     on_connect);
+  uv_tcp_connect(&connect_req,
+                 &tcp,
+                 (const struct sockaddr*) &server_addr,
+                 on_connect);
   ASSERT(!r);
 
   /* Fetch the actual port used by the connecting socket. */

test/test-ipc.c

@@ -126,10 +126,10 @@ static void make_many_connections(void) {
 
     ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
-    r = uv_tcp_connect(&conn->conn_req,
-                       (uv_tcp_t*) &conn->conn,
-                       (const struct sockaddr*) &addr,
-                       connect_cb);
+    uv_tcp_connect(&conn->conn_req,
+                   (uv_tcp_t*) &conn->conn,
+                   (const struct sockaddr*) &addr,
+                   connect_cb);
     ASSERT(r == 0);
 
     conn->conn.data = conn;
@@ -712,10 +712,10 @@ int ipc_helper_tcp_connection(void) {
 
   ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
-  r = uv_tcp_connect(&conn.conn_req,
-                     (uv_tcp_t*) &conn.conn,
-                     (const struct sockaddr*) &addr,
-                     connect_child_process_cb);
+  uv_tcp_connect(&conn.conn_req,
+                 (uv_tcp_t*) &conn.conn,
+                 (const struct sockaddr*) &addr,
+                 connect_child_process_cb);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);

test/test-multiple-listen.c

@@ -84,10 +84,10 @@ static void client_connect(void) {
   r = uv_tcp_init(uv_default_loop(), &client);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(connect_req,
-                     &client,
-                     (const struct sockaddr*) &addr,
-                     connect_cb);
+  uv_tcp_connect(connect_req,
+                 &client,
+                 (const struct sockaddr*) &addr,
+                 connect_cb);
   ASSERT(r == 0);
 }
 

test/test-ping-pong.c

@@ -169,11 +169,10 @@ static void tcp_pinger_v6_new(void) {
 
   /* We are never doing multiple reads/connects at a time anyway. */
   /* so these handles can be pre-initialized. */
-  r = uv_tcp_connect(&pinger->connect_req,
-                     &pinger->stream.tcp,
-                     (const struct sockaddr*) &server_addr,
-                     pinger_on_connect);
-  ASSERT(!r);
+  uv_tcp_connect(&pinger->connect_req,
+                 &pinger->stream.tcp,
+                 (const struct sockaddr*) &server_addr,
+                 pinger_on_connect);
 
   /* Synchronous connect callbacks are not allowed. */
   ASSERT(pinger_on_connect_count == 0);
@@ -198,11 +197,10 @@ static void tcp_pinger_new(void) {
 
   /* We are never doing multiple reads/connects at a time anyway. */
   /* so these handles can be pre-initialized. */
-  r = uv_tcp_connect(&pinger->connect_req,
-                     &pinger->stream.tcp,
-                     (const struct sockaddr*) &server_addr,
-                     pinger_on_connect);
-  ASSERT(!r);
+  uv_tcp_connect(&pinger->connect_req,
+                 &pinger->stream.tcp,
+                 (const struct sockaddr*) &server_addr,
+                 pinger_on_connect);
 
   /* Synchronous connect callbacks are not allowed. */
   ASSERT(pinger_on_connect_count == 0);

test/test-shutdown-close.c

@@ -72,11 +72,10 @@ TEST_IMPL(shutdown_close_tcp) {
   ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   r = uv_tcp_init(uv_default_loop(), &h);
   ASSERT(r == 0);
-  r = uv_tcp_connect(&connect_req,
-                     &h,
-                     (const struct sockaddr*) &addr,
-                     connect_cb);
-  ASSERT(r == 0);
+  uv_tcp_connect(&connect_req,
+                 &h,
+                 (const struct sockaddr*) &addr,
+                 connect_cb);
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
   ASSERT(r == 0);
 

test/test-shutdown-eof.c

@@ -160,11 +160,10 @@ TEST_IMPL(shutdown_eof) {
   r = uv_tcp_init(uv_default_loop(), &tcp);
   ASSERT(!r);
 
-  r = uv_tcp_connect(&connect_req,
-                     &tcp,
-                     (const struct sockaddr*) &server_addr,
-                     connect_cb);
-  ASSERT(!r);
+  uv_tcp_connect(&connect_req,
+                 &tcp,
+                 (const struct sockaddr*) &server_addr,
+                 connect_cb);
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
 

test/test-shutdown-twice.c

@@ -68,10 +68,10 @@ TEST_IMPL(shutdown_twice) {
 
   r = uv_tcp_init(loop, &h);
 
-  r = uv_tcp_connect(&connect_req,
-                     &h,
-                     (const struct sockaddr*) &addr,
-                     connect_cb);
+  uv_tcp_connect(&connect_req,
+                 &h,
+                 (const struct sockaddr*) &addr,
+                 connect_cb);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);