diff --git a/include/uv.h b/include/uv.h
index 1043c517..3ae0da86 100644
--- a/include/uv.h
+++ b/include/uv.h
@@ -773,10 +773,15 @@ UV_EXTERN int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name,
  * initialized TCP handle and an uninitialized uv_connect_t*. The callback
  * will be made when the connection is established.
  */
-UV_EXTERN int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle,
-    struct sockaddr_in address, uv_connect_cb cb);
-UV_EXTERN int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle,
-    struct sockaddr_in6 address, uv_connect_cb cb);
+UV_EXTERN int uv_tcp_connect(uv_connect_t* req,
+                             uv_tcp_t* handle,
+                             const struct sockaddr_in* addr,
+                             uv_connect_cb cb);
+
+UV_EXTERN int uv_tcp_connect6(uv_connect_t* req,
+                              uv_tcp_t* handle,
+                              const struct sockaddr_in6* addr,
+                              uv_connect_cb cb);
 
 /* uv_connect_t is a subclass of uv_req_t */
 struct uv_connect_s {
diff --git a/src/unix/tcp.c b/src/unix/tcp.c
index 63622b96..8ff26dcb 100644
--- a/src/unix/tcp.c
+++ b/src/unix/tcp.c
@@ -81,11 +81,11 @@ int uv__tcp_bind(uv_tcp_t* tcp,
 }
 
 
-static int uv__connect(uv_connect_t* req,
-                       uv_tcp_t* handle,
-                       struct sockaddr* addr,
-                       socklen_t addrlen,
-                       uv_connect_cb cb) {
+int 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;
 
@@ -217,22 +217,6 @@ int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
 }
 
 
-int uv__tcp_connect(uv_connect_t* req,
-                    uv_tcp_t* handle,
-                    struct sockaddr_in addr,
-                    uv_connect_cb cb) {
-  return uv__connect(req, handle, (struct sockaddr*) &addr, sizeof addr, cb);
-}
-
-
-int uv__tcp_connect6(uv_connect_t* req,
-                     uv_tcp_t* handle,
-                     struct sockaddr_in6 addr,
-                     uv_connect_cb cb) {
-  return uv__connect(req, handle, (struct sockaddr*) &addr, sizeof addr, cb);
-}
-
-
 int uv__tcp_nodelay(int fd, int on) {
   return setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
 }
diff --git a/src/uv-common.c b/src/uv-common.c
index 6b71f986..944ca64d 100644
--- a/src/uv-common.c
+++ b/src/uv-common.c
@@ -222,23 +222,31 @@ int uv_udp_bind6(uv_udp_t* handle,
 
 int uv_tcp_connect(uv_connect_t* req,
                    uv_tcp_t* handle,
-                   struct sockaddr_in address,
+                   const struct sockaddr_in* addr,
                    uv_connect_cb cb) {
-  if (handle->type != UV_TCP || address.sin_family != AF_INET)
-    return UV_EINVAL;
-  else
-    return uv__tcp_connect(req, handle, address, cb);
+  if (handle->type == UV_TCP && addr->sin_family == AF_INET) {
+    return uv__tcp_connect(req,
+                           handle,
+                           (const struct sockaddr*) addr,
+                           sizeof(*addr),
+                           cb);
+  }
+  return UV_EINVAL;
 }
 
 
 int uv_tcp_connect6(uv_connect_t* req,
                     uv_tcp_t* handle,
-                    struct sockaddr_in6 address,
+                    const struct sockaddr_in6* addr,
                     uv_connect_cb cb) {
-  if (handle->type != UV_TCP || address.sin6_family != AF_INET6)
-    return UV_EINVAL;
-  else
-    return uv__tcp_connect6(req, handle, address, cb);
+  if (handle->type == UV_TCP && addr->sin6_family == AF_INET6) {
+    return uv__tcp_connect(req,
+                           handle,
+                           (const struct sockaddr*) addr,
+                           sizeof(*addr),
+                           cb);
+  }
+  return UV_EINVAL;
 }
 
 
diff --git a/src/uv-common.h b/src/uv-common.h
index 4c88f2a6..f1e88602 100644
--- a/src/uv-common.h
+++ b/src/uv-common.h
@@ -68,14 +68,10 @@ int uv__udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr, unsigned flags);
 
 int uv__tcp_connect(uv_connect_t* req,
                    uv_tcp_t* handle,
-                   struct sockaddr_in address,
+                   const struct sockaddr* addr,
+                   unsigned int addrlen,
                    uv_connect_cb cb);
 
-int uv__tcp_connect6(uv_connect_t* req,
-                    uv_tcp_t* handle,
-                    struct sockaddr_in6 address,
-                    uv_connect_cb cb);
-
 int uv__udp_send(uv_udp_send_t* req,
                  uv_udp_t* handle,
                  uv_buf_t bufs[],
diff --git a/src/win/tcp.c b/src/win/tcp.c
index 2e99a537..64323ca3 100644
--- a/src/win/tcp.c
+++ b/src/win/tcp.c
@@ -662,12 +662,13 @@ int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
 }
 
 
-int uv__tcp_connect(uv_connect_t* req,
-                    uv_tcp_t* handle,
-                    struct sockaddr_in address,
-                    uv_connect_cb cb) {
+static int uv_tcp_try_connect(uv_connect_t* req,
+                              uv_tcp_t* handle,
+                              const struct sockaddr* addr,
+                              unsigned int addrlen,
+                              uv_connect_cb cb) {
   uv_loop_t* loop = handle->loop;
-  int addrsize = sizeof(struct sockaddr_in);
+  const struct sockaddr* bind_addr;
   BOOL success;
   DWORD bytes;
   int err;
@@ -677,9 +678,14 @@ int uv__tcp_connect(uv_connect_t* req,
   }
 
   if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv_tcp_try_bind(handle,
-                          (const struct sockaddr*) &uv_addr_ip4_any_,
-                          sizeof(uv_addr_ip4_any_));
+    if (addrlen == sizeof(uv_addr_ip4_any_)) {
+      bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_;
+    } else if (addrlen == sizeof(uv_addr_ip6_any_)) {
+      bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_;
+    } else {
+      abort();
+    }
+    err = uv_tcp_try_bind(handle, bind_addr, addrlen);
     if (err)
       return err;
   }
@@ -697,8 +703,8 @@ int uv__tcp_connect(uv_connect_t* req,
   memset(&req->overlapped, 0, sizeof(req->overlapped));
 
   success = handle->func_connectex(handle->socket,
-                                   (struct sockaddr*) &address,
-                                   addrsize,
+                                   addr,
+                                   addrlen,
                                    NULL,
                                    0,
                                    &bytes,
@@ -721,63 +727,6 @@ int uv__tcp_connect(uv_connect_t* req,
 }
 
 
-int uv__tcp_connect6(uv_connect_t* req,
-                     uv_tcp_t* handle,
-                     struct sockaddr_in6 address,
-                     uv_connect_cb cb) {
-  uv_loop_t* loop = handle->loop;
-  int addrsize = sizeof(struct sockaddr_in6);
-  BOOL success;
-  DWORD bytes;
-  int err;
-
-  if (handle->flags & UV_HANDLE_BIND_ERROR) {
-    return handle->bind_error;
-  }
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv_tcp_try_bind(handle,
-                          (const struct sockaddr*) &uv_addr_ip6_any_,
-                          sizeof(uv_addr_ip6_any_));
-    if (err)
-      return err;
-  }
-
-  if (!handle->func_connectex) {
-    if (!uv_get_connectex_function(handle->socket, &handle->func_connectex)) {
-      return WSAEAFNOSUPPORT;
-    }
-  }
-
-  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));
-
-  success = handle->func_connectex(handle->socket,
-                                   (struct sockaddr*) &address,
-                                   addrsize,
-                                   NULL,
-                                   0,
-                                   &bytes,
-                                   &req->overlapped);
-
-  if (UV_SUCCEEDED_WITHOUT_IOCP(success)) {
-    handle->reqs_pending++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-    uv_insert_pending_req(loop, (uv_req_t*)req);
-  } else if (UV_SUCCEEDED_WITH_IOCP(success)) {
-    handle->reqs_pending++;
-    REGISTER_HANDLE_REQ(loop, handle, req);
-  } else {
-    return WSAGetLastError();
-  }
-
-  return 0;
-}
-
-
 int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name,
     int* namelen) {
   int result;
@@ -1422,3 +1371,21 @@ int uv__tcp_bind(uv_tcp_t* handle,
 
   return 0;
 }
+
+
+/* This function is an egress point, i.e. it returns libuv errors rather than
+ * system errors.
+ */
+int uv__tcp_connect(uv_connect_t* req,
+                    uv_tcp_t* handle,
+                    const struct sockaddr* addr,
+                    unsigned int addrlen,
+                    uv_connect_cb cb) {
+  int err;
+
+  err = uv_tcp_try_connect(req, handle, addr, addrlen, cb);
+  if (err)
+    return uv_translate_sys_error(err);
+
+  return 0;
+}
diff --git a/test/benchmark-multi-accept.c b/test/benchmark-multi-accept.c
index 4fffbb7e..81614bc5 100644
--- a/test/benchmark-multi-accept.c
+++ b/test/benchmark-multi-accept.c
@@ -346,7 +346,7 @@ static void cl_close_cb(uv_handle_t* handle) {
   ASSERT(0 == uv_tcp_init(handle->loop, (uv_tcp_t*) &ctx->client_handle));
   ASSERT(0 == uv_tcp_connect(&ctx->connect_req,
                              (uv_tcp_t*) &ctx->client_handle,
-                             listen_addr,
+                             &listen_addr,
                              cl_connect_cb));
 }
 
@@ -387,7 +387,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) {
     ASSERT(0 == uv_tcp_init(loop, handle));
     ASSERT(0 == uv_tcp_connect(&ctx->connect_req,
                                handle,
-                               listen_addr,
+                               &listen_addr,
                                cl_connect_cb));
     ASSERT(0 == uv_idle_init(loop, &ctx->idle_handle));
   }
diff --git a/test/benchmark-ping-pongs.c b/test/benchmark-ping-pongs.c
index f945a946..c5c11fee 100644
--- a/test/benchmark-ping-pongs.c
+++ b/test/benchmark-ping-pongs.c
@@ -193,7 +193,10 @@ static void pinger_new(void) {
 
   uv_tcp_bind(&pinger->tcp, &client_addr);
 
-  r = uv_tcp_connect(&pinger->connect_req, &pinger->tcp, server_addr, pinger_connect_cb);
+  r = uv_tcp_connect(&pinger->connect_req,
+                     &pinger->tcp,
+                     &server_addr,
+                     pinger_connect_cb);
   ASSERT(!r);
 }
 
diff --git a/test/benchmark-pound.c b/test/benchmark-pound.c
index bd2a6923..7531f55b 100644
--- a/test/benchmark-pound.c
+++ b/test/benchmark-pound.c
@@ -194,14 +194,17 @@ static void pipe_do_setup(int num, void* arg) {
 
 static void tcp_make_connect(conn_rec* p) {
   struct sockaddr_in addr;
+  tcp_conn_rec* tp;
   int r;
 
+  tp = (tcp_conn_rec*) p;
+
   r = uv_tcp_init(loop, (uv_tcp_t*)&p->stream);
   ASSERT(r == 0);
 
   ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
-  r = uv_tcp_connect(&((tcp_conn_rec*)p)->conn_req, (uv_tcp_t*)&p->stream, addr, connect_cb);
+  r = uv_tcp_connect(&tp->conn_req, (uv_tcp_t*) &p->stream, &addr, connect_cb);
   if (r) {
     fprintf(stderr, "uv_tcp_connect error %s\n", uv_err_name(r));
     ASSERT(0);
diff --git a/test/benchmark-pump.c b/test/benchmark-pump.c
index 1c1d4753..ac132cbf 100644
--- a/test/benchmark-pump.c
+++ b/test/benchmark-pump.c
@@ -240,7 +240,7 @@ static void maybe_connect_some(void) {
       ASSERT(r == 0);
 
       req = (uv_connect_t*) req_alloc();
-      r = uv_tcp_connect(req, tcp, connect_addr, connect_cb);
+      r = uv_tcp_connect(req, tcp, &connect_addr, connect_cb);
       ASSERT(r == 0);
     } else {
       pipe = &pipe_write_handles[max_connect_socket++];
diff --git a/test/benchmark-tcp-write-batch.c b/test/benchmark-tcp-write-batch.c
index 59fd3af1..09b93c24 100644
--- a/test/benchmark-tcp-write-batch.c
+++ b/test/benchmark-tcp-write-batch.c
@@ -117,7 +117,7 @@ BENCHMARK_IMPL(tcp_write_batch) {
   r = uv_tcp_init(loop, &tcp_client);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(&connect_req, &tcp_client, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &tcp_client, &addr, connect_cb);
   ASSERT(r == 0);
 
   start = uv_hrtime();
diff --git a/test/test-callback-stack.c b/test/test-callback-stack.c
index 0c03a2c7..ff6e93c4 100644
--- a/test/test-callback-stack.c
+++ b/test/test-callback-stack.c
@@ -183,7 +183,7 @@ TEST_IMPL(callback_stack) {
 
   nested++;
 
-  if (uv_tcp_connect(&connect_req, &client, addr, connect_cb)) {
+  if (uv_tcp_connect(&connect_req, &client, &addr, connect_cb)) {
     FATAL("uv_tcp_connect failed");
   }
   nested--;
diff --git a/test/test-connection-fail.c b/test/test-connection-fail.c
index 9f1b80af..80099306 100644
--- a/test/test-connection-fail.c
+++ b/test/test-connection-fail.c
@@ -102,7 +102,7 @@ static void connection_fail(uv_connect_cb connect_cb) {
   /* We are never doing multiple reads/connects at a time anyway. */
   /* so these handles can be pre-initialized. */
   uv_tcp_bind(&tcp, &client_addr);
-  r = uv_tcp_connect(&req, &tcp, server_addr, connect_cb);
+  r = uv_tcp_connect(&req, &tcp, &server_addr, connect_cb);
   ASSERT(!r);
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
diff --git a/test/test-delayed-accept.c b/test/test-delayed-accept.c
index d1fffefa..a7d31883 100644
--- a/test/test-delayed-accept.c
+++ b/test/test-delayed-accept.c
@@ -163,7 +163,7 @@ static void client_connect(void) {
   r = uv_tcp_init(uv_default_loop(), client);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(connect_req, client, addr, connect_cb);
+  r = uv_tcp_connect(connect_req, client, &addr, connect_cb);
   ASSERT(r == 0);
 }
 
diff --git a/test/test-getsockname.c b/test/test-getsockname.c
index 8e991185..d97700e2 100644
--- a/test/test-getsockname.c
+++ b/test/test-getsockname.c
@@ -219,7 +219,7 @@ static void tcp_connector(void) {
   tcp.data = &connect_req;
   ASSERT(!r);
 
-  r = uv_tcp_connect(&connect_req, &tcp, server_addr, on_connect);
+  r = uv_tcp_connect(&connect_req, &tcp, &server_addr, on_connect);
   ASSERT(!r);
 
   /* Fetch the actual port used by the connecting socket. */
diff --git a/test/test-ipc.c b/test/test-ipc.c
index adbc23a5..333c754f 100644
--- a/test/test-ipc.c
+++ b/test/test-ipc.c
@@ -129,7 +129,7 @@ static void make_many_connections(void) {
 
     r = uv_tcp_connect(&conn->conn_req,
                        (uv_tcp_t*) &conn->conn,
-                       addr,
+                       &addr,
                        connect_cb);
     ASSERT(r == 0);
 
@@ -632,7 +632,7 @@ int ipc_helper_tcp_connection(void) {
 
   r = uv_tcp_connect(&conn.conn_req,
                      (uv_tcp_t*) &conn.conn,
-                     addr,
+                     &addr,
                      connect_child_process_cb);
   ASSERT(r == 0);
 
diff --git a/test/test-multiple-listen.c b/test/test-multiple-listen.c
index 8ecacd0a..c19ec71b 100644
--- a/test/test-multiple-listen.c
+++ b/test/test-multiple-listen.c
@@ -84,7 +84,7 @@ static void client_connect(void) {
   r = uv_tcp_init(uv_default_loop(), &client);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(connect_req, &client, addr, connect_cb);
+  r = uv_tcp_connect(connect_req, &client, &addr, connect_cb);
   ASSERT(r == 0);
 }
 
diff --git a/test/test-ping-pong.c b/test/test-ping-pong.c
index 0a494985..0c880d7d 100644
--- a/test/test-ping-pong.c
+++ b/test/test-ping-pong.c
@@ -163,8 +163,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_connect6(&pinger->connect_req, &pinger->stream.tcp, server_addr,
-      pinger_on_connect);
+  r = uv_tcp_connect6(&pinger->connect_req,
+                      &pinger->stream.tcp,
+                      &server_addr,
+                      pinger_on_connect);
   ASSERT(!r);
 
   /* Synchronous connect callbacks are not allowed. */
@@ -189,8 +191,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, server_addr,
-      pinger_on_connect);
+  r = uv_tcp_connect(&pinger->connect_req,
+                     &pinger->stream.tcp,
+                     &server_addr,
+                     pinger_on_connect);
   ASSERT(!r);
 
   /* Synchronous connect callbacks are not allowed. */
diff --git a/test/test-ref.c b/test/test-ref.c
index d08148f3..a77a731f 100644
--- a/test/test-ref.c
+++ b/test/test-ref.c
@@ -258,7 +258,7 @@ TEST_IMPL(tcp_ref3) {
   uv_tcp_t h;
   ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   uv_tcp_init(uv_default_loop(), &h);
-  uv_tcp_connect(&connect_req, &h, addr, connect_and_shutdown);
+  uv_tcp_connect(&connect_req, &h, &addr, connect_and_shutdown);
   uv_unref((uv_handle_t*)&h);
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
   ASSERT(connect_cb_called == 1);
@@ -274,7 +274,7 @@ TEST_IMPL(tcp_ref4) {
   uv_tcp_t h;
   ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   uv_tcp_init(uv_default_loop(), &h);
-  uv_tcp_connect(&connect_req, &h, addr, connect_and_write);
+  uv_tcp_connect(&connect_req, &h, &addr, connect_and_write);
   uv_unref((uv_handle_t*)&h);
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
   ASSERT(connect_cb_called == 1);
diff --git a/test/test-shutdown-close.c b/test/test-shutdown-close.c
index 5b19ccb4..ca308572 100644
--- a/test/test-shutdown-close.c
+++ b/test/test-shutdown-close.c
@@ -72,7 +72,7 @@ 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, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &h, &addr, connect_cb);
   ASSERT(r == 0);
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
   ASSERT(r == 0);
diff --git a/test/test-shutdown-eof.c b/test/test-shutdown-eof.c
index c9a9ae5b..92e73124 100644
--- a/test/test-shutdown-eof.c
+++ b/test/test-shutdown-eof.c
@@ -160,7 +160,7 @@ TEST_IMPL(shutdown_eof) {
   r = uv_tcp_init(uv_default_loop(), &tcp);
   ASSERT(!r);
 
-  r = uv_tcp_connect(&connect_req, &tcp, server_addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &tcp, &server_addr, connect_cb);
   ASSERT(!r);
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
diff --git a/test/test-tcp-close-while-connecting.c b/test/test-tcp-close-while-connecting.c
index a7e4fa66..9e835526 100644
--- a/test/test-tcp-close-while-connecting.c
+++ b/test/test-tcp-close-while-connecting.c
@@ -63,7 +63,7 @@ TEST_IMPL(tcp_close_while_connecting) {
   loop = uv_default_loop();
   ASSERT(0 == uv_ip4_addr("1.2.3.4", TEST_PORT, &addr));
   ASSERT(0 == uv_tcp_init(loop, &tcp_handle));
-  ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb));
+  ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb));
   ASSERT(0 == uv_timer_init(loop, &timer1_handle));
   ASSERT(0 == uv_timer_start(&timer1_handle, timer1_cb, 50, 0));
   ASSERT(0 == uv_timer_init(loop, &timer2_handle));
diff --git a/test/test-tcp-close.c b/test/test-tcp-close.c
index c692493f..183e9af0 100644
--- a/test/test-tcp-close.c
+++ b/test/test-tcp-close.c
@@ -114,7 +114,7 @@ TEST_IMPL(tcp_close) {
   r = uv_tcp_init(loop, &tcp_handle);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb);
   ASSERT(r == 0);
 
   ASSERT(write_cb_called == 0);
diff --git a/test/test-tcp-connect-error-after-write.c b/test/test-tcp-connect-error-after-write.c
index 28dbd77d..b437bf3b 100644
--- a/test/test-tcp-connect-error-after-write.c
+++ b/test/test-tcp-connect-error-after-write.c
@@ -77,7 +77,7 @@ TEST_IMPL(tcp_connect_error_after_write) {
   r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb);
   ASSERT(r == UV_EBADF);
 
-  r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
   ASSERT(r == 0);
 
   r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb);
diff --git a/test/test-tcp-connect-error.c b/test/test-tcp-connect-error.c
index 836e62f7..278548ab 100644
--- a/test/test-tcp-connect-error.c
+++ b/test/test-tcp-connect-error.c
@@ -44,17 +44,18 @@ static void close_cb(uv_handle_t* handle) {
 
 
 TEST_IMPL(tcp_connect_error_fault) {
-  char garbage[] = "blah blah blah blah blah blah blah blah blah blah blah blah";
-  struct sockaddr_in* garbage_addr;
+  const char garbage[] =
+      "blah blah blah blah blah blah blah blah blah blah blah blah";
+  const struct sockaddr_in* garbage_addr;
   uv_tcp_t server;
   int r;
   uv_connect_t req;
 
-  garbage_addr = (struct sockaddr_in*) &garbage;
+  garbage_addr = (const struct sockaddr_in*) &garbage;
 
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_connect(&req, &server, *garbage_addr, connect_cb);
+  r = uv_tcp_connect(&req, &server, garbage_addr, connect_cb);
   ASSERT(r == UV_EINVAL);
 
   uv_close((uv_handle_t*)&server, close_cb);
diff --git a/test/test-tcp-connect-timeout.c b/test/test-tcp-connect-timeout.c
index 75911267..a14a89de 100644
--- a/test/test-tcp-connect-timeout.c
+++ b/test/test-tcp-connect-timeout.c
@@ -75,7 +75,7 @@ TEST_IMPL(tcp_connect_timeout) {
   r = uv_tcp_init(uv_default_loop(), &conn);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
diff --git a/test/test-tcp-connect6-error.c b/test/test-tcp-connect6-error.c
index ad5d2e49..c0e8262e 100644
--- a/test/test-tcp-connect6-error.c
+++ b/test/test-tcp-connect6-error.c
@@ -42,17 +42,18 @@ static void close_cb(uv_handle_t* handle) {
 
 
 TEST_IMPL(tcp_connect6_error_fault) {
-  char garbage[] = "blah blah blah blah blah blah blah blah blah blah blah blah";
-  struct sockaddr_in6* garbage_addr;
+  const char garbage[] =
+      "blah blah blah blah blah blah blah blah blah blah blah blah";
+  const struct sockaddr_in6* garbage_addr;
   uv_tcp_t server;
   int r;
   uv_connect_t req;
 
-  garbage_addr = (struct sockaddr_in6*) &garbage;
+  garbage_addr = (const struct sockaddr_in6*) &garbage;
 
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_connect6(&req, &server, *garbage_addr, connect_cb);
+  r = uv_tcp_connect6(&req, &server, garbage_addr, connect_cb);
   ASSERT(r == UV_EINVAL);
 
   uv_close((uv_handle_t*)&server, close_cb);
diff --git a/test/test-tcp-open.c b/test/test-tcp-open.c
index 39e65151..ddf8d500 100644
--- a/test/test-tcp-open.c
+++ b/test/test-tcp-open.c
@@ -164,7 +164,7 @@ TEST_IMPL(tcp_open) {
   r = uv_tcp_open(&client, sock);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(&connect_req, &client, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &client, &addr, connect_cb);
   ASSERT(r == 0);
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
diff --git a/test/test-tcp-read-stop.c b/test/test-tcp-read-stop.c
index dbc0ca51..3dc9d87d 100644
--- a/test/test-tcp-read-stop.c
+++ b/test/test-tcp-read-stop.c
@@ -65,7 +65,7 @@ TEST_IMPL(tcp_read_stop) {
   ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   ASSERT(0 == uv_timer_init(uv_default_loop(), &timer_handle));
   ASSERT(0 == uv_tcp_init(uv_default_loop(), &tcp_handle));
-  ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb));
+  ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb));
   ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
   MAKE_VALGRIND_HAPPY();
 
diff --git a/test/test-tcp-shutdown-after-write.c b/test/test-tcp-shutdown-after-write.c
index 2e86b2b3..de6f5575 100644
--- a/test/test-tcp-shutdown-after-write.c
+++ b/test/test-tcp-shutdown-after-write.c
@@ -118,7 +118,7 @@ TEST_IMPL(tcp_shutdown_after_write) {
   r = uv_tcp_init(loop, &conn);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
   ASSERT(r == 0);
 
   r = uv_run(loop, UV_RUN_DEFAULT);
diff --git a/test/test-tcp-unexpected-read.c b/test/test-tcp-unexpected-read.c
index 377cc298..14fd6826 100644
--- a/test/test-tcp-unexpected-read.c
+++ b/test/test-tcp-unexpected-read.c
@@ -100,7 +100,7 @@ TEST_IMPL(tcp_unexpected_read) {
   ASSERT(0 == uv_tcp_init(loop, &peer_handle));
   ASSERT(0 == uv_tcp_bind(&server_handle, &addr));
   ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 1, connection_cb));
-  ASSERT(0 == uv_tcp_connect(&connect_req, &client_handle, addr, connect_cb));
+  ASSERT(0 == uv_tcp_connect(&connect_req, &client_handle, &addr, connect_cb));
   ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
 
   /* This is somewhat inexact but the idea is that the event loop should not
diff --git a/test/test-tcp-write-to-half-open-connection.c b/test/test-tcp-write-to-half-open-connection.c
index fa197007..b33deee6 100644
--- a/test/test-tcp-write-to-half-open-connection.c
+++ b/test/test-tcp-write-to-half-open-connection.c
@@ -124,7 +124,7 @@ TEST_IMPL(tcp_write_to_half_open_connection) {
   r = uv_tcp_init(loop, &tcp_client);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(&connect_req, &tcp_client, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &tcp_client, &addr, connect_cb);
   ASSERT(r == 0);
 
   r = uv_run(loop, UV_RUN_DEFAULT);
diff --git a/test/test-tcp-writealot.c b/test/test-tcp-writealot.c
index c6051245..88f499b5 100644
--- a/test/test-tcp-writealot.c
+++ b/test/test-tcp-writealot.c
@@ -153,7 +153,7 @@ TEST_IMPL(tcp_writealot) {
   r = uv_tcp_init(uv_default_loop(), &client);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(&connect_req, &client, addr, connect_cb);
+  r = uv_tcp_connect(&connect_req, &client, &addr, connect_cb);
   ASSERT(r == 0);
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);