uv: upgrade to v0.11.12

* upgrade deps/uv/ to v0.11.12.
* update files in src/ after a libuv API change.

78 files changed, 1407 insertions, 1198 deletions

diff --git a/deps/uv/ChangeLog b/deps/uv/ChangeLog
index ba73c149d9..93af51f1f7 100644
--- a/deps/uv/ChangeLog
+++ b/deps/uv/ChangeLog
@@ -1,4 +1,37 @@
-2013.08.30, Version 0.11.11 (Unstable)
+2013.09.03, Version 0.11.12 (Unstable)
+
+Changes since version 0.11.11:
+
+* test: fix epoll_wait() usage in test-embed.c (Ben Noordhuis)
+
+* include: uv_alloc_cb now takes uv_buf_t* (Ben Noordhuis)
+
+* include: uv_read{2}_cb now takes const uv_buf_t* (Ben Noordhuis)
+
+* include: uv_ip[46]_addr now takes sockaddr_in* (Ben Noordhuis)
+
+* include: uv_tcp_bind{6} now takes sockaddr_in* (Ben Noordhuis)
+
+* include: uv_tcp_connect{6} now takes sockaddr_in* (Ben Noordhuis)
+
+* include: uv_udp_recv_cb now takes const uv_buf_t* (Ben Noordhuis)
+
+* include: uv_udp_bind{6} now takes sockaddr_in* (Ben Noordhuis)
+
+* include: uv_udp_send{6} now takes sockaddr_in* (Ben Noordhuis)
+
+* include: uv_spawn takes const uv_process_options_t* (Ben Noordhuis)
+
+* include: make uv_write{2} const correct (Ben Noordhuis)
+
+* windows: fix flags assignment in uv_fs_readdir() (Ben Noordhuis)
+
+* windows: fix stray comments (Ben Noordhuis)
+
+* windows: remove unused is_path_dir() function (Ben Noordhuis)
+
+
+2013.08.30, Version 0.11.11 (Unstable), ba876d53539ed0427c52039012419cd9374c6f0d
 
 Changes since version 0.11.10:
 
diff --git a/deps/uv/include/uv-unix.h b/deps/uv/include/uv-unix.h
index 408b44c6c2..38c18537c7 100644
--- a/deps/uv/include/uv-unix.h
+++ b/deps/uv/include/uv-unix.h
@@ -199,9 +199,9 @@ typedef struct {
 
 #define UV_WRITE_PRIVATE_FIELDS                                               \
   void* queue[2];                                                             \
-  int write_index;                                                            \
+  unsigned int write_index;                                                   \
   uv_buf_t* bufs;                                                             \
-  int bufcnt;                                                                 \
+  unsigned int nbufs;                                                         \
   int error;                                                                  \
   uv_buf_t bufsml[4];                                                         \
 
@@ -213,7 +213,7 @@ typedef struct {
 #define UV_UDP_SEND_PRIVATE_FIELDS                                            \
   void* queue[2];                                                             \
   struct sockaddr_in6 addr;                                                   \
-  int bufcnt;                                                                 \
+  unsigned int nbufs;                                                         \
   uv_buf_t* bufs;                                                             \
   ssize_t status;                                                             \
   uv_udp_send_cb send_cb;                                                     \
diff --git a/deps/uv/include/uv.h b/deps/uv/include/uv.h
index 5700f9413a..fcef08bb76 100644
--- a/deps/uv/include/uv.h
+++ b/deps/uv/include/uv.h
@@ -338,7 +338,7 @@ UV_EXTERN int uv_backend_timeout(const uv_loop_t*);
 
 
 /*
- * Should return a buffer that libuv can use to read data into.
+ * Should prepare a buffer that libuv can use to read data into.
  *
  * `suggested_size` is a hint. Returning a buffer that is smaller is perfectly
  * okay as long as `buf.len > 0`.
@@ -349,7 +349,9 @@ UV_EXTERN int uv_backend_timeout(const uv_loop_t*);
  * Note that returning a zero-length buffer does not stop the handle, call
  * uv_read_stop() or uv_udp_recv_stop() for that.
  */
-typedef uv_buf_t (*uv_alloc_cb)(uv_handle_t* handle, size_t suggested_size);
+typedef void (*uv_alloc_cb)(uv_handle_t* handle,
+                            size_t suggested_size,
+                            uv_buf_t* buf);
 
 /*
  * `nread` is > 0 if there is data available, 0 if libuv is done reading for
@@ -359,18 +361,22 @@ typedef uv_buf_t (*uv_alloc_cb)(uv_handle_t* handle, size_t suggested_size);
  * Trying to read from the stream again is undefined.
  *
  * The callee is responsible for freeing the buffer, libuv does not reuse it.
- * The buffer may be a null buffer (where buf.base=NULL and buf.len=0) on EOF
- * or error.
+ * The buffer may be a null buffer (where buf->base=NULL and buf->len=0) on
+ * EOF or error.
  */
-typedef void (*uv_read_cb)(uv_stream_t* stream, ssize_t nread, uv_buf_t buf);
+typedef void (*uv_read_cb)(uv_stream_t* stream,
+                           ssize_t nread,
+                           const uv_buf_t* buf);
 
 /*
  * Just like the uv_read_cb except that if the pending parameter is true
  * then you can use uv_accept() to pull the new handle into the process.
  * If no handle is pending then pending will be UV_UNKNOWN_HANDLE.
  */
-typedef void (*uv_read2_cb)(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
-    uv_handle_type pending);
+typedef void (*uv_read2_cb)(uv_pipe_t* pipe,
+                            ssize_t nread,
+                            const uv_buf_t* buf,
+                            uv_handle_type pending);
 
 typedef void (*uv_write_cb)(uv_write_t* req, int status);
 typedef void (*uv_connect_cb)(uv_connect_t* req, int status);
@@ -648,8 +654,11 @@ UV_EXTERN int uv_read2_start(uv_stream_t*, uv_alloc_cb alloc_cb,
  *   uv_write(&req2, stream, b, 2);
  *
  */
-UV_EXTERN int uv_write(uv_write_t* req, uv_stream_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_write_cb cb);
+UV_EXTERN int uv_write(uv_write_t* req,
+                       uv_stream_t* handle,
+                       const uv_buf_t bufs[],
+                       unsigned int nbufs,
+                       uv_write_cb cb);
 
 /*
  * Extended write function for sending handles over a pipe. The pipe must be
@@ -658,8 +667,12 @@ UV_EXTERN int uv_write(uv_write_t* req, uv_stream_t* handle,
  * (listening or connected state).  Bound sockets or pipes will be assumed to
  * be servers.
  */
-UV_EXTERN int uv_write2(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[],
-    int bufcnt, uv_stream_t* send_handle, uv_write_cb cb);
+UV_EXTERN int uv_write2(uv_write_t* req,
+                        uv_stream_t* handle,
+                        const uv_buf_t bufs[],
+                        unsigned int nbufs,
+                        uv_stream_t* send_handle,
+                        uv_write_cb cb);
 
 /* uv_write_t is a subclass of uv_req_t */
 struct uv_write_s {
@@ -753,8 +766,9 @@ UV_EXTERN int uv_tcp_keepalive(uv_tcp_t* handle,
  */
 UV_EXTERN int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable);
 
-UV_EXTERN int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in);
-UV_EXTERN int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6);
+UV_EXTERN int uv_tcp_bind(uv_tcp_t* handle, const struct sockaddr_in* addr);
+UV_EXTERN int uv_tcp_bind6(uv_tcp_t* handle, const struct sockaddr_in6* addr);
+
 UV_EXTERN int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name,
     int* namelen);
 UV_EXTERN int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name,
@@ -766,10 +780,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 {
@@ -814,8 +833,11 @@ typedef void (*uv_udp_send_cb)(uv_udp_send_t* req, int status);
  *  flags   One or more OR'ed UV_UDP_* constants.
  *          Right now only UV_UDP_PARTIAL is used.
  */
-typedef void (*uv_udp_recv_cb)(uv_udp_t* handle, ssize_t nread, uv_buf_t buf,
-    struct sockaddr* addr, unsigned flags);
+typedef void (*uv_udp_recv_cb)(uv_udp_t* handle,
+                               ssize_t nread,
+                               const uv_buf_t* buf,
+                               const struct sockaddr* addr,
+                               unsigned flags);
 
 /* uv_udp_t is a subclass of uv_handle_t */
 struct uv_udp_s {
@@ -875,8 +897,9 @@ UV_EXTERN int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock);
  * This behavior is something of an anomaly and may be replaced by an explicit
  * opt-in mechanism in future versions of libuv.
  */
-UV_EXTERN int uv_udp_bind(uv_udp_t* handle, struct sockaddr_in addr,
-    unsigned flags);
+UV_EXTERN int uv_udp_bind(uv_udp_t* handle,
+                          const struct sockaddr_in* addr,
+                          unsigned flags);
 
 /*
  * Bind to a IPv6 address and port.
@@ -889,8 +912,9 @@ UV_EXTERN int uv_udp_bind(uv_udp_t* handle, struct sockaddr_in addr,
  * Returns:
  *  0 on success, or an error code < 0 on failure.
  */
-UV_EXTERN int uv_udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr,
-    unsigned flags);
+UV_EXTERN int uv_udp_bind6(uv_udp_t* handle,
+                           const struct sockaddr_in6* addr,
+                           unsigned flags);
 
 UV_EXTERN int uv_udp_getsockname(uv_udp_t* handle, struct sockaddr* name,
     int* namelen);
@@ -974,16 +998,19 @@ UV_EXTERN int uv_udp_set_ttl(uv_udp_t* handle, int ttl);
  *  req       UDP request handle. Need not be initialized.
  *  handle    UDP handle. Should have been initialized with `uv_udp_init`.
  *  bufs      List of buffers to send.
- *  bufcnt    Number of buffers in `bufs`.
+ *  nbufs     Number of buffers in `bufs`.
  *  addr      Address of the remote peer. See `uv_ip4_addr`.
  *  send_cb   Callback to invoke when the data has been sent out.
  *
  * Returns:
  *  0 on success, or an error code < 0 on failure.
  */
-UV_EXTERN int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle,
-    uv_buf_t bufs[], int bufcnt, struct sockaddr_in addr,
-    uv_udp_send_cb send_cb);
+UV_EXTERN int uv_udp_send(uv_udp_send_t* req,
+                          uv_udp_t* handle,
+                          const uv_buf_t bufs[],
+                          unsigned int nbufs,
+                          const struct sockaddr_in* addr,
+                          uv_udp_send_cb send_cb);
 
 /*
  * Send data. If the socket has not previously been bound with `uv_udp_bind6`,
@@ -993,16 +1020,19 @@ UV_EXTERN int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle,
  *  req       UDP request handle. Need not be initialized.
  *  handle    UDP handle. Should have been initialized with `uv_udp_init`.
  *  bufs      List of buffers to send.
- *  bufcnt    Number of buffers in `bufs`.
+ *  nbufs     Number of buffers in `bufs`.
  *  addr      Address of the remote peer. See `uv_ip6_addr`.
  *  send_cb   Callback to invoke when the data has been sent out.
  *
  * Returns:
  *  0 on success, or an error code < 0 on failure.
  */
-UV_EXTERN int uv_udp_send6(uv_udp_send_t* req, uv_udp_t* handle,
-    uv_buf_t bufs[], int bufcnt, struct sockaddr_in6 addr,
-    uv_udp_send_cb send_cb);
+UV_EXTERN int uv_udp_send6(uv_udp_send_t* req,
+                           uv_udp_t* handle,
+                           const uv_buf_t bufs[],
+                           unsigned int nbufs,
+                           const struct sockaddr_in6* addr,
+                           uv_udp_send_cb send_cb);
 
 /*
  * Receive data. If the socket has not previously been bound with `uv_udp_bind`
@@ -1479,8 +1509,9 @@ struct uv_process_s {
 };
 
 /* Initializes uv_process_t and starts the process. */
-UV_EXTERN int uv_spawn(uv_loop_t*, uv_process_t*,
-    uv_process_options_t options);
+UV_EXTERN int uv_spawn(uv_loop_t* loop,
+                       uv_process_t* handle,
+                       const uv_process_options_t* options);
 
 
 /*
@@ -1872,8 +1903,8 @@ UV_EXTERN int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle,
 /* Utility */
 
 /* Convert string ip addresses to binary structures */
-UV_EXTERN struct sockaddr_in uv_ip4_addr(const char* ip, int port);
-UV_EXTERN struct sockaddr_in6 uv_ip6_addr(const char* ip, int port);
+UV_EXTERN int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr);
+UV_EXTERN int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr);
 
 /* Convert binary addresses to strings */
 UV_EXTERN int uv_ip4_name(struct sockaddr_in* src, char* dst, size_t size);
diff --git a/deps/uv/src/unix/process.c b/deps/uv/src/unix/process.c
index a9ecb45488..990ea15770 100644
--- a/deps/uv/src/unix/process.c
+++ b/deps/uv/src/unix/process.c
@@ -183,7 +183,7 @@ skip:
 
 
 /*
- * Used for initializing stdio streams like options.stdin_stream. Returns
+ * Used for initializing stdio streams like options->stdin_stream. Returns
  * zero on success.
  */
 static int uv__process_init_stdio(uv_stdio_container_t* container, int fds[2]) {
@@ -270,7 +270,7 @@ static void uv__write_int(int fd, int val) {
 }
 
 
-static void uv__process_child_init(uv_process_options_t options,
+static void uv__process_child_init(const uv_process_options_t* options,
                                    int stdio_count,
                                    int (*pipes)[2],
                                    int error_fd) {
@@ -278,7 +278,7 @@ static void uv__process_child_init(uv_process_options_t options,
   int use_fd;
   int fd;
 
-  if (options.flags & UV_PROCESS_DETACHED)
+  if (options->flags & UV_PROCESS_DETACHED)
     setsid();
 
   for (fd = 0; fd < stdio_count; fd++) {
@@ -313,29 +313,29 @@ static void uv__process_child_init(uv_process_options_t options,
       uv__nonblock(fd, 0);
   }
 
-  if (options.cwd && chdir(options.cwd)) {
+  if (options->cwd != NULL && chdir(options->cwd)) {
     uv__write_int(error_fd, -errno);
     perror("chdir()");
     _exit(127);
   }
 
-  if ((options.flags & UV_PROCESS_SETGID) && setgid(options.gid)) {
+  if ((options->flags & UV_PROCESS_SETGID) && setgid(options->gid)) {
     uv__write_int(error_fd, -errno);
     perror("setgid()");
     _exit(127);
   }
 
-  if ((options.flags & UV_PROCESS_SETUID) && setuid(options.uid)) {
+  if ((options->flags & UV_PROCESS_SETUID) && setuid(options->uid)) {
     uv__write_int(error_fd, -errno);
     perror("setuid()");
     _exit(127);
   }
 
-  if (options.env) {
-    environ = options.env;
+  if (options->env != NULL) {
+    environ = options->env;
   }
 
-  execvp(options.file, options.args);
+  execvp(options->file, options->args);
   uv__write_int(error_fd, -errno);
   perror("execvp()");
   _exit(127);
@@ -344,7 +344,7 @@ static void uv__process_child_init(uv_process_options_t options,
 
 int uv_spawn(uv_loop_t* loop,
              uv_process_t* process,
-             const uv_process_options_t options) {
+             const uv_process_options_t* options) {
   int signal_pipe[2] = { -1, -1 };
   int (*pipes)[2];
   int stdio_count;
@@ -354,17 +354,17 @@ int uv_spawn(uv_loop_t* loop,
   int err;
   int i;
 
-  assert(options.file != NULL);
-  assert(!(options.flags & ~(UV_PROCESS_DETACHED |
-                             UV_PROCESS_SETGID |
-                             UV_PROCESS_SETUID |
-                             UV_PROCESS_WINDOWS_HIDE |
-                             UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
+  assert(options->file != NULL);
+  assert(!(options->flags & ~(UV_PROCESS_DETACHED |
+                              UV_PROCESS_SETGID |
+                              UV_PROCESS_SETUID |
+                              UV_PROCESS_WINDOWS_HIDE |
+                              UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
 
   uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
   QUEUE_INIT(&process->queue);
 
-  stdio_count = options.stdio_count;
+  stdio_count = options->stdio_count;
   if (stdio_count < 3)
     stdio_count = 3;
 
@@ -378,8 +378,8 @@ int uv_spawn(uv_loop_t* loop,
     pipes[i][1] = -1;
   }
 
-  for (i = 0; i < options.stdio_count; i++) {
-    err = uv__process_init_stdio(options.stdio + i, pipes[i]);
+  for (i = 0; i < options->stdio_count; i++) {
+    err = uv__process_init_stdio(options->stdio + i, pipes[i]);
     if (err)
       goto error;
   }
@@ -442,13 +442,13 @@ int uv_spawn(uv_loop_t* loop,
 
   close(signal_pipe[0]);
 
-  for (i = 0; i < options.stdio_count; i++) {
-    err = uv__process_open_stream(options.stdio + i, pipes[i], i == 0);
+  for (i = 0; i < options->stdio_count; i++) {
+    err = uv__process_open_stream(options->stdio + i, pipes[i], i == 0);
     if (err == 0)
       continue;
 
     while (i--)
-      uv__process_close_stream(options.stdio + i);
+      uv__process_close_stream(options->stdio + i);
 
     goto error;
   }
@@ -457,7 +457,7 @@ int uv_spawn(uv_loop_t* loop,
   QUEUE_INSERT_TAIL(q, &process->queue);
 
   process->pid = pid;
-  process->exit_cb = options.exit_cb;
+  process->exit_cb = options->exit_cb;
   uv__handle_start(process);
 
   free(pipes);
diff --git a/deps/uv/src/unix/stream.c b/deps/uv/src/unix/stream.c
index 5f42c34433..c8e9f6d115 100644
--- a/deps/uv/src/unix/stream.c
+++ b/deps/uv/src/unix/stream.c
@@ -93,15 +93,15 @@ static int uv__open_cloexec(const char* path, int flags) {
 }
 
 
-static size_t uv__buf_count(uv_buf_t bufs[], int bufcnt) {
-  size_t total = 0;
-  int i;
+static size_t uv_count_bufs(const uv_buf_t bufs[], unsigned int nbufs) {
+  unsigned int i;
+  size_t bytes;
 
-  for (i = 0; i < bufcnt; i++) {
-    total += bufs[i].len;
-  }
+  bytes = 0;
+  for (i = 0; i < nbufs; i++)
+    bytes += bufs[i].len;
 
-  return total;
+  return bytes;
 }
 
 
@@ -656,8 +656,8 @@ static size_t uv__write_req_size(uv_write_t* req) {
   size_t size;
 
   assert(req->bufs != NULL);
-  size = uv__buf_count(req->bufs + req->write_index,
-                       req->bufcnt - req->write_index);
+  size = uv_count_bufs(req->bufs + req->write_index,
+                       req->nbufs - req->write_index);
   assert(req->handle->write_queue_size >= size);
 
   return size;
@@ -742,7 +742,7 @@ start:
    */
   assert(sizeof(uv_buf_t) == sizeof(struct iovec));
   iov = (struct iovec*) &(req->bufs[req->write_index]);
-  iovcnt = req->bufcnt - req->write_index;
+  iovcnt = req->nbufs - req->write_index;
 
   iovmax = uv__getiovmax();
 
@@ -819,7 +819,7 @@ start:
       uv_buf_t* buf = &(req->bufs[req->write_index]);
       size_t len = buf->len;
 
-      assert(req->write_index < req->bufcnt);
+      assert(req->write_index < req->nbufs);
 
       if ((size_t)n < len) {
         buf->base += n;
@@ -849,7 +849,7 @@ start:
         assert(stream->write_queue_size >= len);
         stream->write_queue_size -= len;
 
-        if (req->write_index == req->bufcnt) {
+        if (req->write_index == req->nbufs) {
           /* Then we're done! */
           assert(n == 0);
           uv__write_req_finish(req);
@@ -938,7 +938,7 @@ static uv_handle_type uv__handle_type(int fd) {
 
 static void uv__stream_read_cb(uv_stream_t* stream,
                                int status,
-                               uv_buf_t buf,
+                               const uv_buf_t* buf,
                                uv_handle_type type) {
   if (stream->read_cb != NULL)
     stream->read_cb(stream, status, buf);
@@ -947,7 +947,7 @@ static void uv__stream_read_cb(uv_stream_t* stream,
 }
 
 
-static void uv__stream_eof(uv_stream_t* stream, uv_buf_t buf) {
+static void uv__stream_eof(uv_stream_t* stream, const uv_buf_t* buf) {
   stream->flags |= UV_STREAM_READ_EOF;
   uv__io_stop(stream->loop, &stream->io_watcher, UV__POLLIN);
   if (!uv__io_active(&stream->io_watcher, UV__POLLOUT))
@@ -979,10 +979,10 @@ static void uv__read(uv_stream_t* stream) {
       && (count-- > 0)) {
     assert(stream->alloc_cb != NULL);
 
-    buf = stream->alloc_cb((uv_handle_t*)stream, 64 * 1024);
+    stream->alloc_cb((uv_handle_t*)stream, 64 * 1024, &buf);
     if (buf.len == 0) {
       /* User indicates it can't or won't handle the read. */
-      uv__stream_read_cb(stream, UV_ENOBUFS, buf, UV_UNKNOWN_HANDLE);
+      uv__stream_read_cb(stream, UV_ENOBUFS, &buf, UV_UNKNOWN_HANDLE);
       return;
     }
 
@@ -1019,23 +1019,23 @@ static void uv__read(uv_stream_t* stream) {
         if (stream->flags & UV_STREAM_READING) {
           uv__io_start(stream->loop, &stream->io_watcher, UV__POLLIN);
         }
-        uv__stream_read_cb(stream, 0, buf, UV_UNKNOWN_HANDLE);
+        uv__stream_read_cb(stream, 0, &buf, UV_UNKNOWN_HANDLE);
       } else {
         /* Error. User should call uv_close(). */
-        uv__stream_read_cb(stream, -errno, buf, UV_UNKNOWN_HANDLE);
+        uv__stream_read_cb(stream, -errno, &buf, UV_UNKNOWN_HANDLE);
         assert(!uv__io_active(&stream->io_watcher, UV__POLLIN) &&
                "stream->read_cb(status=-1) did not call uv_close()");
       }
       return;
     } else if (nread == 0) {
-      uv__stream_eof(stream, buf);
+      uv__stream_eof(stream, &buf);
       return;
     } else {
       /* Successful read */
       ssize_t buflen = buf.len;
 
       if (stream->read_cb) {
-        stream->read_cb(stream, nread, buf);
+        stream->read_cb(stream, nread, &buf);
       } else {
         assert(stream->read2_cb);
 
@@ -1070,10 +1070,12 @@ static void uv__read(uv_stream_t* stream) {
 
 
         if (stream->accepted_fd >= 0) {
-          stream->read2_cb((uv_pipe_t*)stream, nread, buf,
-              uv__handle_type(stream->accepted_fd));
+          stream->read2_cb((uv_pipe_t*) stream,
+                           nread,
+                           &buf,
+                           uv__handle_type(stream->accepted_fd));
         } else {
-          stream->read2_cb((uv_pipe_t*)stream, nread, buf, UV_UNKNOWN_HANDLE);
+          stream->read2_cb((uv_pipe_t*) stream, nread, &buf, UV_UNKNOWN_HANDLE);
         }
       }
 
@@ -1147,7 +1149,7 @@ static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
       (stream->flags & UV_STREAM_READ_PARTIAL) &&
       !(stream->flags & UV_STREAM_READ_EOF)) {
     uv_buf_t buf = { NULL, 0 };
-    uv__stream_eof(stream, buf);
+    uv__stream_eof(stream, &buf);
   }
 
   if (uv__stream_fd(stream) == -1)
@@ -1205,13 +1207,13 @@ static void uv__stream_connect(uv_stream_t* stream) {
 
 int uv_write2(uv_write_t* req,
               uv_stream_t* stream,
-              uv_buf_t bufs[],
-              int bufcnt,
+              const uv_buf_t bufs[],
+              unsigned int nbufs,
               uv_stream_t* send_handle,
               uv_write_cb cb) {
   int empty_queue;
 
-  assert(bufcnt > 0);
+  assert(nbufs > 0);
   assert((stream->type == UV_TCP ||
           stream->type == UV_NAMED_PIPE ||
           stream->type == UV_TTY) &&
@@ -1250,15 +1252,17 @@ int uv_write2(uv_write_t* req,
   req->send_handle = send_handle;
   QUEUE_INIT(&req->queue);
 
-  if (bufcnt <= (int) ARRAY_SIZE(req->bufsml))
-    req->bufs = req->bufsml;
-  else
-    req->bufs = malloc(sizeof(uv_buf_t) * bufcnt);
+  req->bufs = req->bufsml;
+  if (nbufs > ARRAY_SIZE(req->bufsml))
+    req->bufs = malloc(nbufs * sizeof(bufs[0]));
+
+  if (req->bufs == NULL)
+    return -ENOMEM;
 
-  memcpy(req->bufs, bufs, bufcnt * sizeof(uv_buf_t));
-  req->bufcnt = bufcnt;
+  memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
+  req->nbufs = nbufs;
   req->write_index = 0;
-  stream->write_queue_size += uv__buf_count(bufs, bufcnt);
+  stream->write_queue_size += uv_count_bufs(bufs, nbufs);
 
   /* Append the request to write_queue. */
   QUEUE_INSERT_TAIL(&stream->write_queue, &req->queue);
@@ -1290,9 +1294,12 @@ int uv_write2(uv_write_t* req,
 /* The buffers to be written must remain valid until the callback is called.
  * This is not required for the uv_buf_t array.
  */
-int uv_write(uv_write_t* req, uv_stream_t* stream, uv_buf_t bufs[], int bufcnt,
-    uv_write_cb cb) {
-  return uv_write2(req, stream, bufs, bufcnt, NULL, cb);
+int uv_write(uv_write_t* req,
+             uv_stream_t* handle,
+             const uv_buf_t bufs[],
+             unsigned int nbufs,
+             uv_write_cb cb) {
+  return uv_write2(req, handle, bufs, nbufs, NULL, cb);
 }
 
 
diff --git a/deps/uv/src/unix/tcp.c b/deps/uv/src/unix/tcp.c
index 6257f7d8eb..8ff26dcbde 100644
--- a/deps/uv/src/unix/tcp.c
+++ b/deps/uv/src/unix/tcp.c
@@ -56,14 +56,15 @@ static int maybe_new_socket(uv_tcp_t* handle, int domain, int flags) {
 }
 
 
-static int uv__bind(uv_tcp_t* tcp,
-                    int domain,
-                    struct sockaddr* addr,
-                    int addrsize) {
+int uv__tcp_bind(uv_tcp_t* tcp,
+                 const struct sockaddr* addr,
+                 unsigned int addrlen) {
   int err;
   int on;
 
-  err = maybe_new_socket(tcp, domain, UV_STREAM_READABLE | UV_STREAM_WRITABLE);
+  err = maybe_new_socket(tcp,
+                         addr->sa_family,
+                         UV_STREAM_READABLE | UV_STREAM_WRITABLE);
   if (err)
     return err;
 
@@ -72,7 +73,7 @@ static int uv__bind(uv_tcp_t* tcp,
     return -errno;
 
   errno = 0;
-  if (bind(tcp->io_watcher.fd, addr, addrsize) && errno != EADDRINUSE)
+  if (bind(tcp->io_watcher.fd, addr, addrlen) && errno != EADDRINUSE)
     return -errno;
 
   tcp->delayed_error = -errno;
@@ -80,11 +81,11 @@ static int uv__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;
 
@@ -133,22 +134,6 @@ static int uv__connect(uv_connect_t* req,
 }
 
 
-int uv__tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) {
-  return uv__bind(handle,
-                  AF_INET,
-                  (struct sockaddr*)&addr,
-                  sizeof(struct sockaddr_in));
-}
-
-
-int uv__tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) {
-  return uv__bind(handle,
-                  AF_INET6,
-                  (struct sockaddr*)&addr,
-                  sizeof(struct sockaddr_in6));
-}
-
-
 int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {
   return uv__stream_open((uv_stream_t*)handle,
                          sock,
@@ -232,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/deps/uv/src/unix/udp.c b/deps/uv/src/unix/udp.c
index 1413985ba8..47e8b035fe 100644
--- a/deps/uv/src/unix/udp.c
+++ b/deps/uv/src/unix/udp.c
@@ -35,13 +35,6 @@ static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents);
 static void uv__udp_recvmsg(uv_loop_t* loop, uv__io_t* w, unsigned int revents);
 static void uv__udp_sendmsg(uv_loop_t* loop, uv__io_t* w, unsigned int revents);
 static int uv__udp_maybe_deferred_bind(uv_udp_t* handle, int domain);
-static int uv__send(uv_udp_send_t* req,
-                    uv_udp_t* handle,
-                    uv_buf_t bufs[],
-                    int bufcnt,
-                    struct sockaddr* addr,
-                    socklen_t addrlen,
-                    uv_udp_send_cb send_cb);
 
 
 void uv__udp_close(uv_udp_t* handle) {
@@ -100,8 +93,8 @@ static void uv__udp_run_pending(uv_udp_t* handle) {
     h.msg_name = &req->addr;
     h.msg_namelen = (req->addr.sin6_family == AF_INET6 ?
       sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
-    h.msg_iov = (struct iovec*)req->bufs;
-    h.msg_iovlen = req->bufcnt;
+    h.msg_iov = (struct iovec*) req->bufs;
+    h.msg_iovlen = req->nbufs;
 
     do {
       size = sendmsg(handle->io_watcher.fd, &h, 0);
@@ -116,19 +109,6 @@ static void uv__udp_run_pending(uv_udp_t* handle) {
 
     req->status = (size == -1 ? -errno : size);
 
-#ifndef NDEBUG
-    /* Sanity check. */
-    if (size != -1) {
-      ssize_t nbytes;
-      int i;
-
-      for (nbytes = i = 0; i < req->bufcnt; i++)
-        nbytes += req->bufs[i].len;
-
-      assert(size == nbytes);
-    }
-#endif
-
     /* Sending a datagram is an atomic operation: either all data
      * is written or nothing is (and EMSGSIZE is raised). That is
      * why we don't handle partial writes. Just pop the request
@@ -205,9 +185,9 @@ static void uv__udp_recvmsg(uv_loop_t* loop,
   h.msg_name = &peer;
 
   do {
-    buf = handle->alloc_cb((uv_handle_t*) handle, 64 * 1024);
+    handle->alloc_cb((uv_handle_t*) handle, 64 * 1024, &buf);
     if (buf.len == 0) {
-      handle->recv_cb(handle, UV_ENOBUFS, buf, NULL, 0);
+      handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
       return;
     }
     assert(buf.base != NULL);
@@ -223,9 +203,9 @@ static void uv__udp_recvmsg(uv_loop_t* loop,
 
     if (nread == -1) {
       if (errno == EAGAIN || errno == EWOULDBLOCK)
-        handle->recv_cb(handle, 0, buf, NULL, 0);
+        handle->recv_cb(handle, 0, &buf, NULL, 0);
       else
-        handle->recv_cb(handle, -errno, buf, NULL, 0);
+        handle->recv_cb(handle, -errno, &buf, NULL, 0);
     }
     else {
       flags = 0;
@@ -235,8 +215,8 @@ static void uv__udp_recvmsg(uv_loop_t* loop,
 
       handle->recv_cb(handle,
                       nread,
-                      buf,
-                      (struct sockaddr*)&peer,
+                      &buf,
+                      (const struct sockaddr*) &peer,
                       flags);
     }
   }
@@ -305,11 +285,10 @@ static int uv__set_reuse(int fd) {
 }
 
 
-static int uv__bind(uv_udp_t* handle,
-                    int domain,
-                    struct sockaddr* addr,
-                    socklen_t len,
-                    unsigned flags) {
+int uv__udp_bind(uv_udp_t* handle,
+                 const struct sockaddr* addr,
+                 unsigned int addrlen,
+                 unsigned int flags) {
   int err;
   int yes;
   int fd;
@@ -322,12 +301,12 @@ static int uv__bind(uv_udp_t* handle,
     return -EINVAL;
 
   /* Cannot set IPv6-only mode on non-IPv6 socket. */
-  if ((flags & UV_UDP_IPV6ONLY) && domain != AF_INET6)
+  if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6)
     return -EINVAL;
 
   fd = handle->io_watcher.fd;
   if (fd == -1) {
-    fd = uv__socket(domain, SOCK_DGRAM, 0);
+    fd = uv__socket(addr->sa_family, SOCK_DGRAM, 0);
     if (fd == -1)
       return -errno;
     handle->io_watcher.fd = fd;
@@ -350,7 +329,7 @@ static int uv__bind(uv_udp_t* handle,
 #endif
   }
 
-  if (bind(fd, addr, len) == -1) {
+  if (bind(fd, addr, addrlen)) {
     err = -errno;
     goto out;
   }
@@ -397,20 +376,20 @@ static int uv__udp_maybe_deferred_bind(uv_udp_t* handle, int domain) {
     abort();
   }
 
-  return uv__bind(handle, domain, (struct sockaddr*)&taddr, addrlen, 0);
+  return uv__udp_bind(handle, (const struct sockaddr*) &taddr, addrlen, 0);
 }
 
 
-static int uv__send(uv_udp_send_t* req,
-                    uv_udp_t* handle,
-                    uv_buf_t bufs[],
-                    int bufcnt,
-                    struct sockaddr* addr,
-                    socklen_t addrlen,
-                    uv_udp_send_cb send_cb) {
+int uv__udp_send(uv_udp_send_t* req,
+                 uv_udp_t* handle,
+                 const uv_buf_t bufs[],
+                 unsigned int nbufs,
+                 const struct sockaddr* addr,
+                 unsigned int addrlen,
+                 uv_udp_send_cb send_cb) {
   int err;
 
-  assert(bufcnt > 0);
+  assert(nbufs > 0);
 
   err = uv__udp_maybe_deferred_bind(handle, addr->sa_family);
   if (err)
@@ -422,17 +401,16 @@ static int uv__send(uv_udp_send_t* req,
   memcpy(&req->addr, addr, addrlen);
   req->send_cb = send_cb;
   req->handle = handle;
-  req->bufcnt = bufcnt;
+  req->nbufs = nbufs;
 
-  if (bufcnt <= (int) ARRAY_SIZE(req->bufsml))
-    req->bufs = req->bufsml;
-  else
-    req->bufs = malloc(bufcnt * sizeof(*bufs));
+  req->bufs = req->bufsml;
+  if (nbufs > ARRAY_SIZE(req->bufsml))
+    req->bufs = malloc(nbufs * sizeof(bufs[0]));
 
   if (req->bufs == NULL)
     return -ENOMEM;
 
-  memcpy(req->bufs, bufs, bufcnt * sizeof(bufs[0]));
+  memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
   QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue);
   uv__io_start(handle->loop, &handle->io_watcher, UV__POLLOUT);
   uv__handle_start(handle);
@@ -452,24 +430,6 @@ int uv_udp_init(uv_loop_t* loop, uv_udp_t* handle) {
 }
 
 
-int uv__udp_bind(uv_udp_t* handle, struct sockaddr_in addr, unsigned flags) {
-  return uv__bind(handle,
-                  AF_INET,
-                  (struct sockaddr*)&addr,
-                  sizeof addr,
-                  flags);
-}
-
-
-int uv__udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr, unsigned flags) {
-  return uv__bind(handle,
-                  AF_INET6,
-                  (struct sockaddr*)&addr,
-                  sizeof addr,
-                  flags);
-}
-
-
 int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
   int err;
 
@@ -594,38 +554,6 @@ int uv_udp_getsockname(uv_udp_t* handle, struct sockaddr* name, int* namelen) {
 }
 
 
-int uv__udp_send(uv_udp_send_t* req,
-                 uv_udp_t* handle,
-                 uv_buf_t bufs[],
-                 int bufcnt,
-                 struct sockaddr_in addr,
-                 uv_udp_send_cb send_cb) {
-  return uv__send(req,
-                  handle,
-                  bufs,
-                  bufcnt,
-                  (struct sockaddr*)&addr,
-                  sizeof addr,
-                  send_cb);
-}
-
-
-int uv__udp_send6(uv_udp_send_t* req,
-                  uv_udp_t* handle,
-                  uv_buf_t bufs[],
-                  int bufcnt,
-                  struct sockaddr_in6 addr,
-                  uv_udp_send_cb send_cb) {
-  return uv__send(req,
-                  handle,
-                  bufs,
-                  bufcnt,
-                  (struct sockaddr*)&addr,
-                  sizeof addr,
-                  send_cb);
-}
-
-
 int uv__udp_recv_start(uv_udp_t* handle,
                        uv_alloc_cb alloc_cb,
                        uv_udp_recv_cb recv_cb) {
diff --git a/deps/uv/src/uv-common.c b/deps/uv/src/uv-common.c
index 95f5011f1d..bc96029f65 100644
--- a/deps/uv/src/uv-common.c
+++ b/deps/uv/src/uv-common.c
@@ -125,31 +125,26 @@ const char* uv_strerror(int err) {
 #undef UV_STRERROR_GEN
 
 
-struct sockaddr_in uv_ip4_addr(const char* ip, int port) {
-  struct sockaddr_in addr;
-
-  memset(&addr, 0, sizeof(struct sockaddr_in));
-
-  addr.sin_family = AF_INET;
-  addr.sin_port = htons(port);
-  addr.sin_addr.s_addr = inet_addr(ip);
-
-  return addr;
+int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr) {
+  memset(addr, 0, sizeof(*addr));
+  addr->sin_family = AF_INET;
+  addr->sin_port = htons(port);
+  /* TODO(bnoordhuis) Don't use inet_addr(), no good way to detect errors. */
+  addr->sin_addr.s_addr = inet_addr(ip);
+  return 0;
 }
 
 
-struct sockaddr_in6 uv_ip6_addr(const char* ip, int port) {
-  struct sockaddr_in6 addr;
+int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) {
 #if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS)
   char address_part[40];
   size_t address_part_size;
   const char* zone_index;
 #endif
 
-  memset(&addr, 0, sizeof(struct sockaddr_in6));
-
-  addr.sin6_family = AF_INET6;
-  addr.sin6_port = htons(port);
+  memset(addr, 0, sizeof(*addr));
+  addr->sin6_family = AF_INET6;
+  addr->sin6_port = htons(port);
 
 #if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS)
   zone_index = strchr(ip, '%');
@@ -165,17 +160,17 @@ struct sockaddr_in6 uv_ip6_addr(const char* ip, int port) {
     zone_index++; /* skip '%' */
     /* NOTE: unknown interface (id=0) is silently ignored */
 #ifdef _WIN32
-    addr.sin6_scope_id = atoi(zone_index);
+    addr->sin6_scope_id = atoi(zone_index);
 #else
-    addr.sin6_scope_id = if_nametoindex(zone_index);
+    addr->sin6_scope_id = if_nametoindex(zone_index);
 #endif
   }
 #endif
 
-  /* result code is ignored - we assume ip is a valid IPv6 address */
-  uv_inet_pton(AF_INET6, ip, &addr.sin6_addr);
+  /* TODO(bnoordhuis) Return an error when the address is bad. */
+  uv_inet_pton(AF_INET6, ip, &addr->sin6_addr);
 
-  return addr;
+  return 0;
 }
 
 
@@ -189,87 +184,113 @@ int uv_ip6_name(struct sockaddr_in6* src, char* dst, size_t size) {
 }
 
 
-int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) {
-  if (handle->type != UV_TCP || addr.sin_family != AF_INET)
-    return UV_EINVAL;
+int uv_tcp_bind(uv_tcp_t* handle, const struct sockaddr_in* addr) {
+  if (handle->type == UV_TCP && addr->sin_family == AF_INET)
+    return uv__tcp_bind(handle, (const struct sockaddr*) addr, sizeof(*addr));
   else
-    return uv__tcp_bind(handle, addr);
+    return UV_EINVAL;
 }
 
 
-int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) {
-  if (handle->type != UV_TCP || addr.sin6_family != AF_INET6)
-    return UV_EINVAL;
+int uv_tcp_bind6(uv_tcp_t* handle, const struct sockaddr_in6* addr) {
+  if (handle->type == UV_TCP && addr->sin6_family == AF_INET6)
+    return uv__tcp_bind(handle, (const struct sockaddr*) addr, sizeof(*addr));
   else
-    return uv__tcp_bind6(handle, addr);
+    return UV_EINVAL;
 }
 
 
 int uv_udp_bind(uv_udp_t* handle,
-                struct sockaddr_in addr,
+                const struct sockaddr_in* addr,
                 unsigned int flags) {
-  if (handle->type != UV_UDP || addr.sin_family != AF_INET)
-    return UV_EINVAL;
-  else
-    return uv__udp_bind(handle, addr, flags);
+  if (handle->type == UV_UDP && addr->sin_family == AF_INET) {
+    return uv__udp_bind(handle,
+                        (const struct sockaddr*) addr,
+                        sizeof(*addr),
+                        flags);
+  }
+  return UV_EINVAL;
 }
 
 
 int uv_udp_bind6(uv_udp_t* handle,
-                 struct sockaddr_in6 addr,
+                 const struct sockaddr_in6* addr,
                  unsigned int flags) {
-  if (handle->type != UV_UDP || addr.sin6_family != AF_INET6)
-    return UV_EINVAL;
-  else
-    return uv__udp_bind6(handle, addr, flags);
+  if (handle->type == UV_UDP && addr->sin6_family == AF_INET6) {
+    return uv__udp_bind(handle,
+                        (const struct sockaddr*) addr,
+                        sizeof(*addr),
+                        flags);
+  }
+  return UV_EINVAL;
 }
 
 
 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;
 }
 
 
 int uv_udp_send(uv_udp_send_t* req,
                 uv_udp_t* handle,
-                uv_buf_t bufs[],
-                int bufcnt,
-                struct sockaddr_in addr,
+                const uv_buf_t bufs[],
+                unsigned int nbufs,
+                const struct sockaddr_in* addr,
                 uv_udp_send_cb send_cb) {
-  if (handle->type != UV_UDP || addr.sin_family != AF_INET)
-    return UV_EINVAL;
-  else
-    return uv__udp_send(req, handle, bufs, bufcnt, addr, send_cb);
+  if (handle->type == UV_UDP && addr->sin_family == AF_INET) {
+    return uv__udp_send(req,
+                        handle,
+                        bufs,
+                        nbufs,
+                        (const struct sockaddr*) addr,
+                        sizeof(*addr),
+                        send_cb);
+  }
+  return UV_EINVAL;
 }
 
 
 int uv_udp_send6(uv_udp_send_t* req,
                  uv_udp_t* handle,
-                 uv_buf_t bufs[],
-                 int bufcnt,
-                 struct sockaddr_in6 addr,
+                 const uv_buf_t bufs[],
+                 unsigned int nbufs,
+                 const struct sockaddr_in6* addr,
                  uv_udp_send_cb send_cb) {
-  if (handle->type != UV_UDP || addr.sin6_family != AF_INET6)
-    return UV_EINVAL;
-  else
-    return uv__udp_send6(req, handle, bufs, bufcnt, addr, send_cb);
+  if (handle->type == UV_UDP && addr->sin6_family == AF_INET6) {
+    return uv__udp_send(req,
+                        handle,
+                        bufs,
+                        nbufs,
+                        (const struct sockaddr*) addr,
+                        sizeof(*addr),
+                        send_cb);
+  }
+  return UV_EINVAL;
 }
 
 
diff --git a/deps/uv/src/uv-common.h b/deps/uv/src/uv-common.h
index dc15091239..6fcc212a79 100644
--- a/deps/uv/src/uv-common.h
+++ b/deps/uv/src/uv-common.h
@@ -59,36 +59,29 @@ enum {
 # define UV__HANDLE_CLOSING   0x01
 #endif
 
-int uv__tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr);
-int uv__tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr);
-
-int uv__udp_bind(uv_udp_t* handle, struct sockaddr_in addr, unsigned flags);
-int uv__udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr, unsigned flags);
+int uv__tcp_bind(uv_tcp_t* tcp,
+                 const struct sockaddr* addr,
+                 unsigned int addrlen);
 
 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_bind(uv_udp_t* handle,
+                 const struct sockaddr* addr,
+                 unsigned int  addrlen,
+                 unsigned int flags);
 
 int uv__udp_send(uv_udp_send_t* req,
                  uv_udp_t* handle,
-                 uv_buf_t bufs[],
-                 int bufcnt,
-                 struct sockaddr_in addr,
+                 const uv_buf_t bufs[],
+                 unsigned int nbufs,
+                 const struct sockaddr* addr,
+                 unsigned int addrlen,
                  uv_udp_send_cb send_cb);
 
-int uv__udp_send6(uv_udp_send_t* req,
-                  uv_udp_t* handle,
-                  uv_buf_t bufs[],
-                  int bufcnt,
-                  struct sockaddr_in6 addr,
-                  uv_udp_send_cb send_cb);
-
 int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloccb,
                        uv_udp_recv_cb recv_cb);
 
diff --git a/deps/uv/src/version.c b/deps/uv/src/version.c
index c15506de63..9c9575bffa 100644
--- a/deps/uv/src/version.c
+++ b/deps/uv/src/version.c
@@ -31,7 +31,7 @@
 
 #define UV_VERSION_MAJOR 0
 #define UV_VERSION_MINOR 11
-#define UV_VERSION_PATCH 11
+#define UV_VERSION_PATCH 12
 #define UV_VERSION_IS_RELEASE 1
 
 
diff --git a/deps/uv/src/win/fs.c b/deps/uv/src/win/fs.c
index 8c35cabee2..879f1f1d14 100644
--- a/deps/uv/src/win/fs.c
+++ b/deps/uv/src/win/fs.c
@@ -229,17 +229,6 @@ INLINE static void uv_fs_req_init(uv_loop_t* loop, uv_fs_t* req,
 }
 
 
-static int is_path_dir(const WCHAR* path) {
-  DWORD attr = GetFileAttributesW(path);
-
-  if (attr != INVALID_FILE_ATTRIBUTES) {
-    return attr & FILE_ATTRIBUTE_DIRECTORY ? 1 : 0;
-  } else {
-    return 0;
-  }
-}
-
-
 INLINE static int fs__readlink_handle(HANDLE handle, char** target_ptr,
     uint64_t* target_len_ptr) {
   char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
@@ -1672,7 +1661,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
     return uv_translate_sys_error(err);
   }
 
-  req->file_flags;
+  req->file_flags = flags;
 
   if (cb) {
     QUEUE_FS_TP_JOB(loop, req);
diff --git a/deps/uv/src/win/internal.h b/deps/uv/src/win/internal.h
index 98c96a7c2b..6a4fb46bb4 100644
--- a/deps/uv/src/win/internal.h
+++ b/deps/uv/src/win/internal.h
@@ -106,7 +106,7 @@ int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client);
 int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
     uv_read_cb read_cb);
 int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_write_cb cb);
+    const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb);
 
 void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, uv_req_t* req);
 void uv_process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle,
@@ -150,9 +150,10 @@ int uv_pipe_read_start(uv_pipe_t* handle, uv_alloc_cb alloc_cb,
 int uv_pipe_read2_start(uv_pipe_t* handle, uv_alloc_cb alloc_cb,
     uv_read2_cb read_cb);
 int uv_pipe_write(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_write_cb cb);
+    const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb);
 int uv_pipe_write2(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_stream_t* send_handle, uv_write_cb cb);
+    const uv_buf_t bufs[], unsigned int nbufs, uv_stream_t* send_handle,
+    uv_write_cb cb);
 
 void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle,
     uv_req_t* req);
@@ -179,7 +180,7 @@ int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
     uv_read_cb read_cb);
 int uv_tty_read_stop(uv_tty_t* handle);
 int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_write_cb cb);
+    const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb);
 void uv_tty_close(uv_tty_t* handle);
 
 void uv_process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle,
@@ -311,8 +312,9 @@ void uv_fatal_error(const int errorno, const char* syscall);
 /*
  * Process stdio handles.
  */
-int uv__stdio_create(uv_loop_t* loop, uv_process_options_t* options,
-    BYTE** buffer_ptr);
+int uv__stdio_create(uv_loop_t* loop,
+                     const uv_process_options_t* options,
+                     BYTE** buffer_ptr);
 void uv__stdio_destroy(BYTE* buffer);
 void uv__stdio_noinherit(BYTE* buffer);
 int uv__stdio_verify(BYTE* buffer, WORD size);
diff --git a/deps/uv/src/win/pipe.c b/deps/uv/src/win/pipe.c
index 586adbfed1..bf98b7765c 100644
--- a/deps/uv/src/win/pipe.c
+++ b/deps/uv/src/win/pipe.c
@@ -1030,16 +1030,20 @@ static void uv_queue_non_overlapped_write(uv_pipe_t* handle) {
 }
 
 
-static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req,
-    uv_pipe_t* handle, uv_buf_t bufs[], int bufcnt,
-    uv_stream_t* send_handle, uv_write_cb cb) {
+static int uv_pipe_write_impl(uv_loop_t* loop,
+                              uv_write_t* req,
+                              uv_pipe_t* handle,
+                              const uv_buf_t bufs[],
+                              unsigned int nbufs,
+                              uv_stream_t* send_handle,
+                              uv_write_cb cb) {
   int err;
   int result;
   uv_tcp_t* tcp_send_handle;
   uv_write_t* ipc_header_req;
   uv_ipc_frame_uv_stream ipc_frame;
 
-  if (bufcnt != 1 && (bufcnt != 0 || !send_handle)) {
+  if (nbufs != 1 && (nbufs != 0 || !send_handle)) {
     return ERROR_NOT_SUPPORTED;
   }
 
@@ -1081,7 +1085,7 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req,
       }
     }
 
-    if (bufcnt == 1) {
+    if (nbufs == 1) {
       ipc_frame.header.flags |= UV_IPC_RAW_DATA;
       ipc_frame.header.raw_data_length = bufs[0].len;
     }
@@ -1189,7 +1193,7 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req,
     }
 
     /* Request queued by the kernel. */
-    req->queued_bytes = uv_count_bufs(bufs, bufcnt);
+    req->queued_bytes = uv_count_bufs(bufs, nbufs);
     handle->write_queue_size += req->queued_bytes;
   } else if (handle->flags & UV_HANDLE_BLOCKING_WRITES) {
     /* Using overlapped IO, but wait for completion before returning */
@@ -1245,7 +1249,7 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req,
       req->queued_bytes = 0;
     } else {
       /* Request queued by the kernel. */
-      req->queued_bytes = uv_count_bufs(bufs, bufcnt);
+      req->queued_bytes = uv_count_bufs(bufs, nbufs);
       handle->write_queue_size += req->queued_bytes;
     }
 
@@ -1270,19 +1274,28 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req,
 }
 
 
-int uv_pipe_write(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_write_cb cb) {
-  return uv_pipe_write_impl(loop, req, handle, bufs, bufcnt, NULL, cb);
+int uv_pipe_write(uv_loop_t* loop,
+                  uv_write_t* req,
+                  uv_pipe_t* handle,
+                  const uv_buf_t bufs[],
+                  unsigned int nbufs,
+                  uv_write_cb cb) {
+  return uv_pipe_write_impl(loop, req, handle, bufs, nbufs, NULL, cb);
 }
 
 
-int uv_pipe_write2(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_stream_t* send_handle, uv_write_cb cb) {
+int uv_pipe_write2(uv_loop_t* loop,
+                   uv_write_t* req,
+                   uv_pipe_t* handle,
+                   const uv_buf_t bufs[],
+                   unsigned int nbufs,
+                   uv_stream_t* send_handle,
+                   uv_write_cb cb) {
   if (!handle->ipc) {
     return WSAEINVAL;
   }
 
-  return uv_pipe_write_impl(loop, req, handle, bufs, bufcnt, send_handle, cb);
+  return uv_pipe_write_impl(loop, req, handle, bufs, nbufs, send_handle, cb);
 }
 
 
@@ -1296,9 +1309,9 @@ static void uv_pipe_read_eof(uv_loop_t* loop, uv_pipe_t* handle,
   uv_read_stop((uv_stream_t*) handle);
 
   if (handle->read2_cb) {
-    handle->read2_cb(handle, UV_EOF, uv_null_buf_, UV_UNKNOWN_HANDLE);
+    handle->read2_cb(handle, UV_EOF, &uv_null_buf_, UV_UNKNOWN_HANDLE);
   } else {
-    handle->read_cb((uv_stream_t*) handle, UV_EOF, uv_null_buf_);
+    handle->read_cb((uv_stream_t*) handle, UV_EOF, &uv_null_buf_);
   }
 }
 
@@ -1314,10 +1327,10 @@ static void uv_pipe_read_error(uv_loop_t* loop, uv_pipe_t* handle, int error,
   if (handle->read2_cb) {
     handle->read2_cb(handle,
                      uv_translate_sys_error(error),
-                     buf,
+                     &buf,
                      UV_UNKNOWN_HANDLE);
   } else {
-    handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(error), buf);
+    handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(error), &buf);
   }
 }
 
@@ -1429,12 +1442,12 @@ void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle,
         }
       }
 
-      buf = handle->alloc_cb((uv_handle_t*) handle, avail);
+      handle->alloc_cb((uv_handle_t*) handle, avail, &buf);
       if (buf.len == 0) {
         if (handle->read2_cb) {
-          handle->read2_cb(handle, UV_ENOBUFS, buf, UV_UNKNOWN_HANDLE);
+          handle->read2_cb(handle, UV_ENOBUFS, &buf, UV_UNKNOWN_HANDLE);
         } else if (handle->read_cb) {
-          handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, buf);
+          handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
         }
         break;
       }
@@ -1451,10 +1464,10 @@ void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle,
           handle->remaining_ipc_rawdata_bytes =
             handle->remaining_ipc_rawdata_bytes - bytes;
           if (handle->read2_cb) {
-            handle->read2_cb(handle, bytes, buf,
+            handle->read2_cb(handle, bytes, &buf,
               handle->pending_ipc_info.socket_info ? UV_TCP : UV_UNKNOWN_HANDLE);
           } else if (handle->read_cb) {
-            handle->read_cb((uv_stream_t*)handle, bytes, buf);
+            handle->read_cb((uv_stream_t*)handle, bytes, &buf);
           }
 
           if (handle->pending_ipc_info.socket_info) {
@@ -1462,7 +1475,7 @@ void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle,
             handle->pending_ipc_info.socket_info = NULL;
           }
         } else {
-          handle->read_cb((uv_stream_t*)handle, bytes, buf);
+          handle->read_cb((uv_stream_t*)handle, bytes, &buf);
         }
 
         /* Read again only if bytes == buf.len */
diff --git a/deps/uv/src/win/process-stdio.c b/deps/uv/src/win/process-stdio.c
index 612f6be9af..44a67fd1f3 100644
--- a/deps/uv/src/win/process-stdio.c
+++ b/deps/uv/src/win/process-stdio.c
@@ -195,7 +195,7 @@ static int uv__duplicate_handle(uv_loop_t* loop, HANDLE handle, HANDLE* dup) {
 
   /* _get_osfhandle will sometimes return -2 in case of an error. This seems */
   /* to happen when fd <= 2 and the process' corresponding stdio handle is */
-  /* set to NULL. Unfortunately DuplicateHandle will happily duplicate /*
+  /* set to NULL. Unfortunately DuplicateHandle will happily duplicate */
   /* (HANDLE) -2, so this situation goes unnoticed until someone tries to */
   /* use the duplicate. Therefore we filter out known-invalid handles here. */
   if (handle == INVALID_HANDLE_VALUE ||
@@ -260,8 +260,9 @@ int uv__create_nul_handle(HANDLE* handle_ptr,
 }
 
 
-int uv__stdio_create(uv_loop_t* loop, uv_process_options_t* options,
-    BYTE** buffer_ptr) {
+int uv__stdio_create(uv_loop_t* loop,
+                     const uv_process_options_t* options,
+                     BYTE** buffer_ptr) {
   BYTE* buffer;
   int count, i;
   int err;
diff --git a/deps/uv/src/win/process.c b/deps/uv/src/win/process.c
index 477e5e418a..218ea8f21b 100644
--- a/deps/uv/src/win/process.c
+++ b/deps/uv/src/win/process.c
@@ -802,8 +802,9 @@ void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle) {
 }
 
 
-int uv_spawn(uv_loop_t* loop, uv_process_t* process,
-    uv_process_options_t options) {
+int uv_spawn(uv_loop_t* loop,
+             uv_process_t* process,
+             const uv_process_options_t* options) {
   int i;
   int err = 0;
   WCHAR* path = NULL;
@@ -814,44 +815,45 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
   PROCESS_INFORMATION info;
   DWORD process_flags;
 
-  if (options.flags & (UV_PROCESS_SETGID | UV_PROCESS_SETUID)) {
+  if (options->flags & (UV_PROCESS_SETGID | UV_PROCESS_SETUID)) {
     return UV_ENOTSUP;
   }
 
-  if (options.file == NULL ||
-      options.args == NULL) {
+  if (options->file == NULL ||
+      options->args == NULL) {
     return UV_EINVAL;
   }
 
-  assert(options.file != NULL);
-  assert(!(options.flags & ~(UV_PROCESS_DETACHED |
-                             UV_PROCESS_SETGID |
-                             UV_PROCESS_SETUID |
-                             UV_PROCESS_WINDOWS_HIDE |
-                             UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
+  assert(options->file != NULL);
+  assert(!(options->flags & ~(UV_PROCESS_DETACHED |
+                              UV_PROCESS_SETGID |
+                              UV_PROCESS_SETUID |
+                              UV_PROCESS_WINDOWS_HIDE |
+                              UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
 
   uv_process_init(loop, process);
-  process->exit_cb = options.exit_cb;
+  process->exit_cb = options->exit_cb;
 
-  err = uv_utf8_to_utf16_alloc(options.file, &application);
+  err = uv_utf8_to_utf16_alloc(options->file, &application);
   if (err)
     goto immediate_failure;
 
-  err = make_program_args(options.args,
-                          options.flags & UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS,
-                          &arguments);
+  err = make_program_args(
+      options->args,
+      options->flags & UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS,
+      &arguments);
   if (err)
     goto immediate_failure;
 
-  if (options.env) {
-     err = make_program_env(options.env, &env);
+  if (options->env) {
+     err = make_program_env(options->env, &env);
      if (err)
        goto immediate_failure;
   }
 
-  if (options.cwd) {
+  if (options->cwd) {
     /* Explicit cwd */
-    err = uv_utf8_to_utf16_alloc(options.cwd, &cwd);
+    err = uv_utf8_to_utf16_alloc(options->cwd, &cwd);
     if (err)
       goto immediate_failure;
 
@@ -901,7 +903,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
     }
   }
 
-  err = uv__stdio_create(loop, &options, &process->child_stdio_buffer);
+  err = uv__stdio_create(loop, options, &process->child_stdio_buffer);
   if (err)
     goto immediate_failure;
 
@@ -929,7 +931,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
   startup.hStdOutput = uv__stdio_handle(process->child_stdio_buffer, 1);
   startup.hStdError = uv__stdio_handle(process->child_stdio_buffer, 2);
 
-  if (options.flags & UV_PROCESS_WINDOWS_HIDE) {
+  if (options->flags & UV_PROCESS_WINDOWS_HIDE) {
     /* Use SW_HIDE to avoid any potential process window. */
     startup.wShowWindow = SW_HIDE;
   } else {
@@ -938,7 +940,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
 
   process_flags = CREATE_UNICODE_ENVIRONMENT;
 
-  if (options.flags & UV_PROCESS_DETACHED) {
+  if (options->flags & UV_PROCESS_DETACHED) {
     /* Note that we're not setting the CREATE_BREAKAWAY_FROM_JOB flag. That
      * means that libuv might not let you create a fully deamonized process
      * when run under job control. However the type of job control that libuv
@@ -968,7 +970,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
 
     /* If the process isn't spawned as detached, assign to the global job */
     /* object so windows will kill it when the parent process dies. */
-    if (!(options.flags & UV_PROCESS_DETACHED)) {
+    if (!(options->flags & UV_PROCESS_DETACHED)) {
       uv_once(&uv_global_job_handle_init_guard_, uv__init_global_job_handle);
 
       if (!AssignProcessToJobObject(uv_global_job_handle_, info.hProcess)) {
@@ -989,8 +991,8 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
     }
 
     /* Set IPC pid to all IPC pipes. */
-    for (i = 0; i < options.stdio_count; i++) {
-      const uv_stdio_container_t* fdopt = &options.stdio[i];
+    for (i = 0; i < options->stdio_count; i++) {
+      const uv_stdio_container_t* fdopt = &options->stdio[i];
       if (fdopt->flags & UV_CREATE_PIPE &&
           fdopt->data.stream->type == UV_NAMED_PIPE &&
           ((uv_pipe_t*) fdopt->data.stream)->ipc) {
diff --git a/deps/uv/src/win/stream-inl.h b/deps/uv/src/win/stream-inl.h
index 3cde668af4..e4bf086368 100644
--- a/deps/uv/src/win/stream-inl.h
+++ b/deps/uv/src/win/stream-inl.h
@@ -53,13 +53,13 @@ INLINE static void uv_connection_init(uv_stream_t* handle) {
 }
 
 
-INLINE static size_t uv_count_bufs(uv_buf_t bufs[], int count) {
-  size_t bytes = 0;
-  int i;
+INLINE static size_t uv_count_bufs(const uv_buf_t bufs[], unsigned int nbufs) {
+  unsigned int i;
+  size_t bytes;
 
-  for (i = 0; i < count; i++) {
-    bytes += (size_t)bufs[i].len;
-  }
+  bytes = 0;
+  for (i = 0; i < nbufs; i++)
+    bytes += (size_t) bufs[i].len;
 
   return bytes;
 }
diff --git a/deps/uv/src/win/stream.c b/deps/uv/src/win/stream.c
index 2351dd37fd..e77ce1c68f 100644
--- a/deps/uv/src/win/stream.c
+++ b/deps/uv/src/win/stream.c
@@ -139,8 +139,11 @@ int uv_read_stop(uv_stream_t* handle) {
 }
 
 
-int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
-    uv_write_cb cb) {
+int uv_write(uv_write_t* req,
+             uv_stream_t* handle,
+             const uv_buf_t bufs[],
+             unsigned int nbufs,
+             uv_write_cb cb) {
   uv_loop_t* loop = handle->loop;
   int err;
 
@@ -151,13 +154,13 @@ int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
   err = ERROR_INVALID_PARAMETER;
   switch (handle->type) {
     case UV_TCP:
-      err = uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, bufcnt, cb);
+      err = uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, nbufs, cb);
       break;
     case UV_NAMED_PIPE:
-      err = uv_pipe_write(loop, req, (uv_pipe_t*) handle, bufs, bufcnt, cb);
+      err = uv_pipe_write(loop, req, (uv_pipe_t*) handle, bufs, nbufs, cb);
       break;
     case UV_TTY:
-      err = uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, bufcnt, cb);
+      err = uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, nbufs, cb);
       break;
     default:
       assert(0);
@@ -167,8 +170,12 @@ int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
 }
 
 
-int uv_write2(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
-    uv_stream_t* send_handle, uv_write_cb cb) {
+int uv_write2(uv_write_t* req,
+              uv_stream_t* handle,
+              const uv_buf_t bufs[],
+              unsigned int nbufs,
+              uv_stream_t* send_handle,
+              uv_write_cb cb) {
   uv_loop_t* loop = handle->loop;
   int err;
 
@@ -179,7 +186,13 @@ int uv_write2(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
   err = ERROR_INVALID_PARAMETER;
   switch (handle->type) {
     case UV_NAMED_PIPE:
-      err = uv_pipe_write2(loop, req, (uv_pipe_t*) handle, bufs, bufcnt, send_handle, cb);
+      err = uv_pipe_write2(loop,
+                           req,
+                           (uv_pipe_t*) handle,
+                           bufs,
+                           nbufs,
+                           send_handle,
+                           cb);
       break;
     default:
       assert(0);
diff --git a/deps/uv/src/win/tcp.c b/deps/uv/src/win/tcp.c
index 5ed7976c06..31526b688d 100644
--- a/deps/uv/src/win/tcp.c
+++ b/deps/uv/src/win/tcp.c
@@ -235,15 +235,14 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
 }
 
 
-static int uv__bind(uv_tcp_t* handle,
-                    int family,
-                    struct sockaddr* addr,
-                    int addrsize) {
+static int uv_tcp_try_bind(uv_tcp_t* handle,
+                           const struct sockaddr* addr,
+                           unsigned int addrlen) {
   DWORD err;
   int r;
 
   if (handle->socket == INVALID_SOCKET) {
-    SOCKET sock = socket(family, SOCK_STREAM, 0);
+    SOCKET sock = socket(addr->sa_family, SOCK_STREAM, 0);
     if (sock == INVALID_SOCKET) {
       return WSAGetLastError();
     }
@@ -255,14 +254,14 @@ static int uv__bind(uv_tcp_t* handle,
       return err;
     }
 
-    err = uv_tcp_set_socket(handle->loop, handle, sock, family, 0);
+    err = uv_tcp_set_socket(handle->loop, handle, sock, addr->sa_family, 0);
     if (err) {
       closesocket(sock);
       return err;
     }
   }
 
-  r = bind(handle->socket, addr, addrsize);
+  r = bind(handle->socket, addr, addrlen);
 
   if (r == SOCKET_ERROR) {
     err = WSAGetLastError();
@@ -281,18 +280,6 @@ static int uv__bind(uv_tcp_t* handle,
 }
 
 
-int uv__tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) {
-  return uv_translate_sys_error(
-      uv__bind(handle, AF_INET, (struct sockaddr*) &addr, sizeof(addr)));
-}
-
-
-int uv__tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) {
-  return uv_translate_sys_error(
-      uv__bind(handle, AF_INET6, (struct sockaddr*) &addr, sizeof(addr)));
-}
-
-
 static void CALLBACK post_completion(void* context, BOOLEAN timed_out) {
   uv_req_t* req;
   uv_tcp_t* handle;
@@ -434,9 +421,9 @@ static void uv_tcp_queue_read(uv_loop_t* loop, uv_tcp_t* handle) {
   */
   if (loop->active_tcp_streams < uv_active_tcp_streams_threshold) {
     handle->flags &= ~UV_HANDLE_ZERO_READ;
-    handle->read_buffer = handle->alloc_cb((uv_handle_t*) handle, 65536);
+    handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->read_buffer);
     if (handle->read_buffer.len == 0) {
-      handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, handle->read_buffer);
+      handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &handle->read_buffer);
       return;
     }
     assert(handle->read_buffer.base != NULL);
@@ -511,7 +498,9 @@ int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) {
   }
 
   if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv_tcp_bind(handle, uv_addr_ip4_any_);
+    err = uv_tcp_try_bind(handle,
+                          (const struct sockaddr*) &uv_addr_ip4_any_,
+                          sizeof(uv_addr_ip4_any_));
     if (err)
       return err;
   }
@@ -673,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;
@@ -688,7 +678,14 @@ int uv__tcp_connect(uv_connect_t* req,
   }
 
   if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv_tcp_bind(handle, 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;
   }
@@ -706,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,
@@ -730,61 +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_bind6(handle, 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;
@@ -827,8 +769,12 @@ int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name,
 }
 
 
-int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_write_cb cb) {
+int uv_tcp_write(uv_loop_t* loop,
+                 uv_write_t* req,
+                 uv_tcp_t* handle,
+                 const uv_buf_t bufs[],
+                 unsigned int nbufs,
+                 uv_write_cb cb) {
   int result;
   DWORD bytes;
 
@@ -850,8 +796,8 @@ int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
   }
 
   result = WSASend(handle->socket,
-                   (WSABUF*)bufs,
-                   bufcnt,
+                   (WSABUF*) bufs,
+                   nbufs,
                    &bytes,
                    0,
                    &req->overlapped,
@@ -866,7 +812,7 @@ int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
     uv_insert_pending_req(loop, (uv_req_t*) req);
   } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
     /* Request queued by the kernel. */
-    req->queued_bytes = uv_count_bufs(bufs, bufcnt);
+    req->queued_bytes = uv_count_bufs(bufs, nbufs);
     handle->reqs_pending++;
     handle->write_reqs_pending++;
     REGISTER_HANDLE_REQ(loop, handle, req);
@@ -916,7 +862,7 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
 
       handle->read_cb((uv_stream_t*)handle,
                       uv_translate_sys_error(err),
-                      buf);
+                      &buf);
     }
   } else {
     if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
@@ -925,7 +871,7 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
         /* Successful read */
         handle->read_cb((uv_stream_t*)handle,
                         req->overlapped.InternalHigh,
-                        handle->read_buffer);
+                        &handle->read_buffer);
         /* Read again only if bytes == buf.len */
         if (req->overlapped.InternalHigh < handle->read_buffer.len) {
           goto done;
@@ -940,16 +886,16 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
 
         buf.base = 0;
         buf.len = 0;
-        handle->read_cb((uv_stream_t*)handle, UV_EOF, handle->read_buffer);
+        handle->read_cb((uv_stream_t*)handle, UV_EOF, &handle->read_buffer);
         goto done;
       }
     }
 
     /* Do nonblocking reads until the buffer is empty */
     while (handle->flags & UV_HANDLE_READING) {
-      buf = handle->alloc_cb((uv_handle_t*) handle, 65536);
+      handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);
       if (buf.len == 0) {
-        handle->read_cb(handle, UV_ENOBUFS, buf);
+        handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
         break;
       }
       assert(buf.base != NULL);
@@ -964,7 +910,7 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
                   NULL) != SOCKET_ERROR) {
         if (bytes > 0) {
           /* Successful read */
-          handle->read_cb((uv_stream_t*)handle, bytes, buf);
+          handle->read_cb((uv_stream_t*)handle, bytes, &buf);
           /* Read again only if bytes == buf.len */
           if (bytes < buf.len) {
             break;
@@ -974,14 +920,14 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
           handle->flags &= ~(UV_HANDLE_READING | UV_HANDLE_READABLE);
           DECREASE_ACTIVE_COUNT(loop, handle);
 
-          handle->read_cb((uv_stream_t*)handle, UV_EOF, buf);
+          handle->read_cb((uv_stream_t*)handle, UV_EOF, &buf);
           break;
         }
       } else {
         err = WSAGetLastError();
         if (err == WSAEWOULDBLOCK) {
           /* Read buffer was completely empty, report a 0-byte read. */
-          handle->read_cb((uv_stream_t*)handle, 0, buf);
+          handle->read_cb((uv_stream_t*)handle, 0, &buf);
         } else {
           /* Ouch! serious error. */
           handle->flags &= ~UV_HANDLE_READING;
@@ -995,7 +941,7 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
 
           handle->read_cb((uv_stream_t*)handle,
                           uv_translate_sys_error(err),
-                          buf);
+                          &buf);
         }
         break;
       }
@@ -1084,7 +1030,7 @@ void uv_process_tcp_accept_req(uv_loop_t* loop, uv_tcp_t* handle,
     }
   } else {
     /* Error related to accepted socket is ignored because the server */
-    /* socket may still be healthy. If the server socket is broken
+    /* socket may still be healthy. If the server socket is broken */
     /* uv_queue_accept will detect it. */
     closesocket(req->accept_socket);
     req->accept_socket = INVALID_SOCKET;
@@ -1413,3 +1359,37 @@ int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {
 
   return 0;
 }
+
+
+/* This function is an egress point, i.e. it returns libuv errors rather than
+ * system errors.
+ */
+int uv__tcp_bind(uv_tcp_t* handle,
+                 const struct sockaddr* addr,
+                 unsigned int addrlen) {
+  int err;
+
+  err = uv_tcp_try_bind(handle, addr, addrlen);
+  if (err)
+    return uv_translate_sys_error(err);
+
+  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/deps/uv/src/win/tty.c b/deps/uv/src/win/tty.c
index e6077a9901..d380cd0b6c 100644
--- a/deps/uv/src/win/tty.c
+++ b/deps/uv/src/win/tty.c
@@ -347,9 +347,11 @@ static void uv_tty_queue_read_line(uv_loop_t* loop, uv_tty_t* handle) {
   req = &handle->read_req;
   memset(&req->overlapped, 0, sizeof(req->overlapped));
 
-  handle->read_line_buffer = handle->alloc_cb((uv_handle_t*) handle, 8192);
+  handle->alloc_cb((uv_handle_t*) handle, 8192, &handle->read_line_buffer);
   if (handle->read_line_buffer.len == 0) {
-    handle->read_cb(handle, UV_ENOBUFS, handle->read_line_buffer);
+    handle->read_cb((uv_stream_t*) handle,
+                    UV_ENOBUFS,
+                    &handle->read_line_buffer);
     return;
   }
   assert(handle->read_line_buffer.base != NULL);
@@ -486,7 +488,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
       handle->flags &= ~UV_HANDLE_READING;
       handle->read_cb((uv_stream_t*)handle,
                       uv_translate_sys_error(GET_REQ_ERROR(req)),
-                      uv_null_buf_);
+                      &uv_null_buf_);
     }
     goto out;
   }
@@ -497,7 +499,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
     DECREASE_ACTIVE_COUNT(loop, handle);
     handle->read_cb((uv_stream_t*)handle,
                     uv_translate_sys_error(GetLastError()),
-                    uv_null_buf_);
+                    &uv_null_buf_);
     goto out;
   }
 
@@ -518,7 +520,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
         DECREASE_ACTIVE_COUNT(loop, handle);
         handle->read_cb((uv_stream_t*) handle,
                         uv_translate_sys_error(GetLastError()),
-                        buf);
+                        &buf);
         goto out;
       }
       records_left--;
@@ -638,7 +640,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
           DECREASE_ACTIVE_COUNT(loop, handle);
           handle->read_cb((uv_stream_t*) handle,
                           uv_translate_sys_error(GetLastError()),
-                          buf);
+                          &buf);
           goto out;
         }
 
@@ -684,9 +686,9 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
       if (handle->last_key_offset < handle->last_key_len) {
         /* Allocate a buffer if needed */
         if (buf_used == 0) {
-          buf = handle->alloc_cb((uv_handle_t*) handle, 1024);
+          handle->alloc_cb((uv_handle_t*) handle, 1024, &buf);
           if (buf.len == 0) {
-            handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, buf);
+            handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
             goto out;
           }
           assert(buf.base != NULL);
@@ -696,7 +698,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
 
         /* If the buffer is full, emit it */
         if (buf_used == buf.len) {
-          handle->read_cb((uv_stream_t*) handle, buf_used, buf);
+          handle->read_cb((uv_stream_t*) handle, buf_used, &buf);
           buf = uv_null_buf_;
           buf_used = 0;
         }
@@ -717,7 +719,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
 
   /* Send the buffer back to the user */
   if (buf_used > 0) {
-    handle->read_cb((uv_stream_t*) handle, buf_used, buf);
+    handle->read_cb((uv_stream_t*) handle, buf_used, &buf);
   }
 
  out:
@@ -755,17 +757,17 @@ void uv_process_tty_read_line_req(uv_loop_t* loop, uv_tty_t* handle,
       DECREASE_ACTIVE_COUNT(loop, handle);
       handle->read_cb((uv_stream_t*) handle,
                       uv_translate_sys_error(GET_REQ_ERROR(req)),
-                      buf);
+                      &buf);
     } else {
       /* The read was cancelled, or whatever we don't care */
-      handle->read_cb((uv_stream_t*) handle, 0, buf);
+      handle->read_cb((uv_stream_t*) handle, 0, &buf);
     }
 
   } else {
     /* Read successful */
     /* TODO: read unicode, convert to utf-8 */
     DWORD bytes = req->overlapped.InternalHigh;
-    handle->read_cb((uv_stream_t*) handle, bytes, buf);
+    handle->read_cb((uv_stream_t*) handle, bytes, &buf);
   }
 
   /* Wait for more input events. */
@@ -828,10 +830,8 @@ int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
 
 
 int uv_tty_read_stop(uv_tty_t* handle) {
-  uv_loop_t* loop = handle->loop;
-
   handle->flags &= ~UV_HANDLE_READING;
-  DECREASE_ACTIVE_COUNT(loop, handle);
+  DECREASE_ACTIVE_COUNT(handle->loop, handle);
 
   /* Cancel raw read */
   if ((handle->flags & UV_HANDLE_READ_PENDING) &&
@@ -1316,13 +1316,15 @@ static int uv_tty_restore_state(uv_tty_t* handle,
 }
 
 
-static int uv_tty_write_bufs(uv_tty_t* handle, uv_buf_t bufs[], int bufcnt,
-    DWORD* error) {
+static int uv_tty_write_bufs(uv_tty_t* handle,
+                             const uv_buf_t bufs[],
+                             unsigned int nbufs,
+                             DWORD* error) {
   /* We can only write 8k characters at a time. Windows can't handle */
   /* much more characters in a single console write anyway. */
   WCHAR utf16_buf[8192];
   DWORD utf16_buf_used = 0;
-  int i;
+  unsigned int i;
 
 #define FLUSH_TEXT()                                                \
   do {                                                              \
@@ -1345,7 +1347,7 @@ static int uv_tty_write_bufs(uv_tty_t* handle, uv_buf_t bufs[], int bufcnt,
 
   EnterCriticalSection(&uv_tty_output_lock);
 
-  for (i = 0; i < bufcnt; i++) {
+  for (i = 0; i < nbufs; i++) {
     uv_buf_t buf = bufs[i];
     unsigned int j;
 
@@ -1743,8 +1745,12 @@ static int uv_tty_write_bufs(uv_tty_t* handle, uv_buf_t bufs[], int bufcnt,
 }
 
 
-int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle,
-    uv_buf_t bufs[], int bufcnt, uv_write_cb cb) {
+int uv_tty_write(uv_loop_t* loop,
+                 uv_write_t* req,
+                 uv_tty_t* handle,
+                 const uv_buf_t bufs[],
+                 unsigned int nbufs,
+                 uv_write_cb cb) {
   DWORD error;
 
   uv_req_init(loop, (uv_req_t*) req);
@@ -1758,7 +1764,7 @@ int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle,
 
   req->queued_bytes = 0;
 
-  if (!uv_tty_write_bufs(handle, bufs, bufcnt, &error)) {
+  if (!uv_tty_write_bufs(handle, bufs, nbufs, &error)) {
     SET_REQ_SUCCESS(req);
   } else {
     SET_REQ_ERROR(req, error);
diff --git a/deps/uv/src/win/udp.c b/deps/uv/src/win/udp.c
index ba21b545a9..49de701c7f 100644
--- a/deps/uv/src/win/udp.c
+++ b/deps/uv/src/win/udp.c
@@ -167,37 +167,36 @@ void uv_udp_endgame(uv_loop_t* loop, uv_udp_t* handle) {
 }
 
 
-static int uv__bind(uv_udp_t* handle,
-                    int family,
-                    struct sockaddr* addr,
-                    int addrsize,
-                    unsigned int flags) {
+static int uv_udp_try_bind(uv_udp_t* handle,
+                           const struct sockaddr* addr,
+                           unsigned int addrlen,
+                           unsigned int flags) {
   int r;
   int err;
   DWORD no = 0;
 
-  if ((flags & UV_UDP_IPV6ONLY) && family != AF_INET6) {
+  if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6) {
     /* UV_UDP_IPV6ONLY is supported only for IPV6 sockets */
     return ERROR_INVALID_PARAMETER;
   }
 
   if (handle->socket == INVALID_SOCKET) {
-    SOCKET sock = socket(family, SOCK_DGRAM, 0);
+    SOCKET sock = socket(addr->sa_family, SOCK_DGRAM, 0);
     if (sock == INVALID_SOCKET) {
       return WSAGetLastError();
     }
 
-    err = uv_udp_set_socket(handle->loop, handle, sock, family);
+    err = uv_udp_set_socket(handle->loop, handle, sock, addr->sa_family);
     if (err) {
       closesocket(sock);
       return err;
     }
 
-    if (family == AF_INET6)
+    if (addr->sa_family == AF_INET6)
       handle->flags |= UV_HANDLE_IPV6;
   }
 
-  if (family == AF_INET6 && !(flags & UV_UDP_IPV6ONLY)) {
+  if (addr->sa_family == AF_INET6 && !(flags & UV_UDP_IPV6ONLY)) {
     /* On windows IPV6ONLY is on by default. */
     /* If the user doesn't specify it libuv turns it off. */
 
@@ -211,7 +210,7 @@ static int uv__bind(uv_udp_t* handle,
                sizeof no);
   }
 
-  r = bind(handle->socket, addr, addrsize);
+  r = bind(handle->socket, addr, addrlen);
   if (r == SOCKET_ERROR) {
     return WSAGetLastError();
   }
@@ -222,36 +221,6 @@ static int uv__bind(uv_udp_t* handle,
 }
 
 
-int uv__udp_bind(uv_udp_t* handle,
-                 struct sockaddr_in addr,
-                 unsigned int flags) {
-  int err;
-
-  err = uv__bind(handle,
-                 AF_INET,
-                 (struct sockaddr*) &addr,
-                 sizeof(addr),
-                 flags);
-
-  return uv_translate_sys_error(err);
-}
-
-
-int uv__udp_bind6(uv_udp_t* handle,
-                  struct sockaddr_in6 addr,
-                  unsigned int flags) {
-  int err;
-
-  err = uv__bind(handle,
-                 AF_INET6,
-                 (struct sockaddr*) &addr,
-                 sizeof(addr),
-                 flags);
-
-  return uv_translate_sys_error(err);
-}
-
-
 static void uv_udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) {
   uv_req_t* req;
   uv_buf_t buf;
@@ -271,9 +240,9 @@ static void uv_udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) {
   if (loop->active_udp_streams < uv_active_udp_streams_threshold) {
     handle->flags &= ~UV_HANDLE_ZERO_READ;
 
-    handle->recv_buffer = handle->alloc_cb((uv_handle_t*) handle, 65536);
+    handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->recv_buffer);
     if (handle->recv_buffer.len == 0) {
-      handle->recv_cb(handle, UV_ENOBUFS, handle->recv_buffer, NULL, 0);
+      handle->recv_cb(handle, UV_ENOBUFS, &handle->recv_buffer, NULL, 0);
       return;
     }
     assert(handle->recv_buffer.base != NULL);
@@ -355,7 +324,10 @@ int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,
   }
 
   if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv_udp_bind(handle, uv_addr_ip4_any_, 0);
+    err = uv_udp_try_bind(handle,
+                          (const struct sockaddr*) &uv_addr_ip4_any_,
+                          sizeof(uv_addr_ip4_any_),
+                          0);
     if (err)
       return err;
   }
@@ -387,8 +359,13 @@ int uv__udp_recv_stop(uv_udp_t* handle) {
 }
 
 
-static int uv__send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
-    int bufcnt, struct sockaddr* addr, int addr_len, uv_udp_send_cb cb) {
+static int uv__send(uv_udp_send_t* req,
+                    uv_udp_t* handle,
+                    const uv_buf_t bufs[],
+                    unsigned int nbufs,
+                    const struct sockaddr* addr,
+                    unsigned int addrlen,
+                    uv_udp_send_cb cb) {
   uv_loop_t* loop = handle->loop;
   DWORD result, bytes;
 
@@ -400,11 +377,11 @@ static int uv__send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
 
   result = WSASendTo(handle->socket,
                      (WSABUF*)bufs,
-                     bufcnt,
+                     nbufs,
                      &bytes,
                      0,
                      addr,
-                     addr_len,
+                     addrlen,
                      &req->overlapped,
                      NULL);
 
@@ -416,7 +393,7 @@ static int uv__send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
     uv_insert_pending_req(loop, (uv_req_t*)req);
   } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
     /* Request queued by the kernel. */
-    req->queued_bytes = uv_count_bufs(bufs, bufcnt);
+    req->queued_bytes = uv_count_bufs(bufs, nbufs);
     handle->reqs_pending++;
     REGISTER_HANDLE_REQ(loop, handle, req);
   } else {
@@ -428,46 +405,6 @@ static int uv__send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
 }
 
 
-int uv__udp_send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
-    int bufcnt, struct sockaddr_in addr, uv_udp_send_cb cb) {
-  int err;
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv_udp_bind(handle, uv_addr_ip4_any_, 0);
-    if (err)
-      return err;
-  }
-
-  return uv__send(req,
-                  handle,
-                  bufs,
-                  bufcnt,
-                  (struct sockaddr*) &addr,
-                  sizeof addr,
-                  cb);
-}
-
-
-int uv__udp_send6(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
-    int bufcnt, struct sockaddr_in6 addr, uv_udp_send_cb cb) {
-  int err;
-
-  if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv_udp_bind6(handle, uv_addr_ip6_any_, 0);
-    if (err)
-      return err;
-  }
-
-  return uv__send(req,
-                  handle,
-                  bufs,
-                  bufcnt,
-                  (struct sockaddr*) &addr,
-                  sizeof addr,
-                  cb);
-}
-
-
 void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
     uv_req_t* req) {
   uv_buf_t buf;
@@ -497,7 +434,7 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
         uv_udp_recv_stop(handle);
         buf = (handle->flags & UV_HANDLE_ZERO_READ) ?
               uv_buf_init(NULL, 0) : handle->recv_buffer;
-        handle->recv_cb(handle, uv_translate_sys_error(err), buf, NULL, 0);
+        handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
       }
       goto done;
     }
@@ -508,8 +445,8 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
     partial = !REQ_SUCCESS(req);
     handle->recv_cb(handle,
                     req->overlapped.InternalHigh,
-                    handle->recv_buffer,
-                    (struct sockaddr*) &handle->recv_from,
+                    &handle->recv_buffer,
+                    (const struct sockaddr*) &handle->recv_from,
                     partial ? UV_UDP_PARTIAL : 0);
   } else if (handle->flags & UV_HANDLE_READING) {
     DWORD bytes, err, flags;
@@ -518,9 +455,9 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
 
     /* Do a nonblocking receive */
     /* TODO: try to read multiple datagrams at once. FIONREAD maybe? */
-    buf = handle->alloc_cb((uv_handle_t*) handle, 65536);
+    handle->alloc_cb((uv_handle_t*) handle, 65536, &buf);
     if (buf.len == 0) {
-      handle->recv_cb(handle, UV_ENOBUFS, buf, NULL, 0);
+      handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0);
       goto done;
     }
     assert(buf.base != NULL);
@@ -541,24 +478,24 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
                     NULL) != SOCKET_ERROR) {
 
       /* Message received */
-      handle->recv_cb(handle, bytes, buf, (struct sockaddr*) &from, 0);
+      handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0);
     } else {
       err = WSAGetLastError();
       if (err == WSAEMSGSIZE) {
         /* Message truncated */
         handle->recv_cb(handle,
                         bytes,
-                        buf,
-                        (struct sockaddr*) &from,
+                        &buf,
+                        (const struct sockaddr*) &from,
                         UV_UDP_PARTIAL);
       } if (err == WSAEWOULDBLOCK) {
         /* Kernel buffer empty */
-        handle->recv_cb(handle, 0, buf, NULL, 0);
+        handle->recv_cb(handle, 0, &buf, NULL, 0);
       } else if (err != WSAECONNRESET && err != WSAENETRESET) {
         /* Serious error. WSAECONNRESET/WSANETRESET is ignored because this */
         /* just indicates that a previous sendto operation failed. */
         uv_udp_recv_stop(handle);
-        handle->recv_cb(handle, uv_translate_sys_error(err), buf, NULL, 0);
+        handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0);
       }
     }
   }
@@ -602,7 +539,10 @@ int uv_udp_set_membership(uv_udp_t* handle, const char* multicast_addr,
 
   /* If the socket is unbound, bind to inaddr_any. */
   if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv__udp_bind(handle, uv_addr_ip4_any_, 0);
+    err = uv_udp_try_bind(handle,
+                          (const struct sockaddr*) &uv_addr_ip4_any_,
+                          sizeof(uv_addr_ip4_any_),
+                          0);
     if (err)
       return uv_translate_sys_error(err);
   }
@@ -650,7 +590,10 @@ int uv_udp_set_broadcast(uv_udp_t* handle, int value) {
 
   /* If the socket is unbound, bind to inaddr_any. */
   if (!(handle->flags & UV_HANDLE_BOUND)) {
-    err = uv__udp_bind(handle, uv_addr_ip4_any_, 0);
+    err = uv_udp_try_bind(handle,
+                          (const struct sockaddr*) &uv_addr_ip4_any_,
+                          sizeof(uv_addr_ip4_any_),
+                          0);
     if (err)
       return uv_translate_sys_error(err);
   }
@@ -701,7 +644,10 @@ int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
                                                                               \
     /* If the socket is unbound, bind to inaddr_any. */                       \
     if (!(handle->flags & UV_HANDLE_BOUND)) {                                 \
-      err = uv__udp_bind(handle, uv_addr_ip4_any_, 0);                        \
+      err = uv_udp_try_bind(handle,                                           \
+                            (const struct sockaddr*) &uv_addr_ip4_any_,       \
+                            sizeof(uv_addr_ip4_any_),                         \
+                            0);                                               \
       if (err)                                                                \
         return uv_translate_sys_error(err);                                   \
     }                                                                         \
@@ -749,3 +695,54 @@ SOCKOPT_SETTER(multicast_loop,
 #undef VALIDATE_TTL
 #undef VALIDATE_MULTICAST_TTL
 #undef VALIDATE_MULTICAST_LOOP
+
+
+/* This function is an egress point, i.e. it returns libuv errors rather than
+ * system errors.
+ */
+int uv__udp_bind(uv_udp_t* handle,
+                 const struct sockaddr* addr,
+                 unsigned int addrlen,
+                 unsigned int flags) {
+  int err;
+
+  err = uv_udp_try_bind(handle, addr, addrlen, flags);
+  if (err)
+    return uv_translate_sys_error(err);
+
+  return 0;
+}
+
+
+/* This function is an egress point, i.e. it returns libuv errors rather than
+ * system errors.
+ */
+int uv__udp_send(uv_udp_send_t* req,
+                 uv_udp_t* handle,
+                 const uv_buf_t bufs[],
+                 unsigned int nbufs,
+                 const struct sockaddr* addr,
+                 unsigned int addrlen,
+                 uv_udp_send_cb send_cb) {
+  const struct sockaddr* bind_addr;
+  int err;
+
+  if (!(handle->flags & UV_HANDLE_BOUND)) {
+    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_udp_try_bind(handle, bind_addr, addrlen, 0);
+    if (err)
+      return uv_translate_sys_error(err);
+  }
+
+  err = uv__send(req, handle, bufs, nbufs, addr, addrlen, send_cb);
+  if (err)
+    return uv_translate_sys_error(err);
+
+  return 0;
+}
diff --git a/deps/uv/src/win/winapi.h b/deps/uv/src/win/winapi.h
index b1cf0a9e8c..21d7fe4ac3 100644
--- a/deps/uv/src/win/winapi.h
+++ b/deps/uv/src/win/winapi.h
@@ -4076,7 +4076,7 @@
 # define STATUS_HASH_NOT_PRESENT ((NTSTATUS) 0xC000A101L)
 #endif
 
-/* This is not the NTSTATUS_FROM_WIN32 that the DDK provides, because the
+/* This is not the NTSTATUS_FROM_WIN32 that the DDK provides, because the */
 /* DDK got it wrong! */
 #ifdef NTSTATUS_FROM_WIN32
 # undef NTSTATUS_FROM_WIN32
diff --git a/deps/uv/src/win/winsock.c b/deps/uv/src/win/winsock.c
index cf6d031891..bf1c70f3b9 100644
--- a/deps/uv/src/win/winsock.c
+++ b/deps/uv/src/win/winsock.c
@@ -20,6 +20,7 @@
  */
 
 #include <assert.h>
+#include <stdlib.h>
 
 #include "uv.h"
 #include "internal.h"
@@ -92,8 +93,13 @@ void uv_winsock_init() {
   }
 
   /* Set implicit binding address used by connectEx */
-  uv_addr_ip4_any_ = uv_ip4_addr("0.0.0.0", 0);
-  uv_addr_ip6_any_ = uv_ip6_addr("::", 0);
+  if (uv_ip4_addr("0.0.0.0", 0, &uv_addr_ip4_any_)) {
+    abort();
+  }
+
+  if (uv_ip6_addr("::", 0, &uv_addr_ip6_any_)) {
+    abort();
+  }
 
   /* Detect non-IFS LSPs */
   dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
diff --git a/deps/uv/test/benchmark-multi-accept.c b/deps/uv/test/benchmark-multi-accept.c
index eb574648ef..81614bc52e 100644
--- a/deps/uv/test/benchmark-multi-accept.c
+++ b/deps/uv/test/benchmark-multi-accept.c
@@ -85,14 +85,18 @@ static void ipc_close_cb(uv_handle_t* handle);
 static void ipc_connect_cb(uv_connect_t* req, int status);
 static void ipc_read2_cb(uv_pipe_t* ipc_pipe,
                          ssize_t nread,
-                         uv_buf_t buf,
+                         const uv_buf_t* buf,
                          uv_handle_type type);
-static uv_buf_t ipc_alloc_cb(uv_handle_t* handle, size_t suggested_size);
+static void ipc_alloc_cb(uv_handle_t* handle,
+                         size_t suggested_size,
+                         uv_buf_t* buf);
 
 static void sv_async_cb(uv_async_t* handle, int status);
 static void sv_connection_cb(uv_stream_t* server_handle, int status);
-static void sv_read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf);
-static uv_buf_t sv_alloc_cb(uv_handle_t* handle, size_t suggested_size);
+static void sv_read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf);
+static void sv_alloc_cb(uv_handle_t* handle,
+                        size_t suggested_size,
+                        uv_buf_t* buf);
 
 static void cl_connect_cb(uv_connect_t* req, int status);
 static void cl_idle_cb(uv_idle_t* handle, int status);
@@ -157,16 +161,19 @@ static void ipc_connect_cb(uv_connect_t* req, int status) {
 }
 
 
-static uv_buf_t ipc_alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void ipc_alloc_cb(uv_handle_t* handle,
+                         size_t suggested_size,
+                         uv_buf_t* buf) {
   struct ipc_client_ctx* ctx;
   ctx = container_of(handle, struct ipc_client_ctx, ipc_pipe);
-  return uv_buf_init(ctx->scratch, sizeof(ctx->scratch));
+  buf->base = ctx->scratch;
+  buf->len = sizeof(ctx->scratch);
 }
 
 
 static void ipc_read2_cb(uv_pipe_t* ipc_pipe,
                          ssize_t nread,
-                         uv_buf_t buf,
+                         const uv_buf_t* buf,
                          uv_handle_type type) {
   struct ipc_client_ctx* ctx;
   uv_loop_t* loop;
@@ -202,7 +209,7 @@ static void send_listen_handles(uv_handle_type type,
 
   if (type == UV_TCP) {
     ASSERT(0 == uv_tcp_init(loop, (uv_tcp_t*) &ctx.server_handle));
-    ASSERT(0 == uv_tcp_bind((uv_tcp_t*) &ctx.server_handle, listen_addr));
+    ASSERT(0 == uv_tcp_bind((uv_tcp_t*) &ctx.server_handle, &listen_addr));
   }
   else
     ASSERT(0);
@@ -295,13 +302,18 @@ static void sv_connection_cb(uv_stream_t* server_handle, int status) {
 }
 
 
-static uv_buf_t sv_alloc_cb(uv_handle_t* handle, size_t suggested_size) {
-  static char buf[32];
-  return uv_buf_init(buf, sizeof(buf));
+static void sv_alloc_cb(uv_handle_t* handle,
+                        size_t suggested_size,
+                        uv_buf_t* buf) {
+  static char slab[32];
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
-static void sv_read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+static void sv_read_cb(uv_stream_t* handle,
+                       ssize_t nread,
+                       const uv_buf_t* buf) {
   ASSERT(nread == UV_EOF);
   uv_close((uv_handle_t*) handle, (uv_close_cb) free);
 }
@@ -334,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));
 }
 
@@ -347,7 +359,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) {
   unsigned int i;
   double time;
 
-  listen_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &listen_addr));
   loop = uv_default_loop();
 
   servers = calloc(num_servers, sizeof(servers[0]));
@@ -375,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/deps/uv/test/benchmark-ping-pongs.c b/deps/uv/test/benchmark-ping-pongs.c
index 0012cfd53b..c5c11feed0 100644
--- a/deps/uv/test/benchmark-ping-pongs.c
+++ b/deps/uv/test/benchmark-ping-pongs.c
@@ -53,27 +53,24 @@ static int completed_pingers = 0;
 static int64_t start_time;
 
 
-static uv_buf_t buf_alloc(uv_handle_t* tcp, size_t size) {
+static void buf_alloc(uv_handle_t* tcp, size_t size, uv_buf_t* buf) {
   buf_t* ab;
 
   ab = buf_freelist;
-
-  if (ab != NULL) {
+  if (ab != NULL)
     buf_freelist = ab->next;
-    return ab->uv_buf_t;
+  else {
+    ab = malloc(size + sizeof(*ab));
+    ab->uv_buf_t.len = size;
+    ab->uv_buf_t.base = (char*) (ab + 1);
   }
 
-  ab = (buf_t*) malloc(size + sizeof *ab);
-  ab->uv_buf_t.len = size;
-  ab->uv_buf_t.base = ((char*) ab) + sizeof *ab;
-
-  return ab->uv_buf_t;
+  *buf = ab->uv_buf_t;
 }
 
 
-static void buf_free(uv_buf_t uv_buf_t) {
-  buf_t* ab = (buf_t*) (uv_buf_t.base - sizeof *ab);
-
+static void buf_free(const uv_buf_t* buf) {
+  buf_t* ab = (buf_t*) buf->base - 1;
   ab->next = buf_freelist;
   buf_freelist = ab;
 }
@@ -123,7 +120,9 @@ static void pinger_shutdown_cb(uv_shutdown_t* req, int status) {
 }
 
 
-static void pinger_read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void pinger_read_cb(uv_stream_t* tcp,
+                           ssize_t nread,
+                           const uv_buf_t* buf) {
   ssize_t i;
   pinger_t* pinger;
 
@@ -132,7 +131,7 @@ static void pinger_read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
   if (nread < 0) {
     ASSERT(nread == UV_EOF);
 
-    if (buf.base) {
+    if (buf->base) {
       buf_free(buf);
     }
 
@@ -144,7 +143,7 @@ static void pinger_read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
 
   /* Now we count the pings */
   for (i = 0; i < nread; i++) {
-    ASSERT(buf.base[i] == PING[pinger->state]);
+    ASSERT(buf->base[i] == PING[pinger->state]);
     pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);
     if (pinger->state == 0) {
       pinger->pongs++;
@@ -175,12 +174,14 @@ static void pinger_connect_cb(uv_connect_t* req, int status) {
 
 
 static void pinger_new(void) {
-  int r;
-  struct sockaddr_in client_addr = uv_ip4_addr("0.0.0.0", 0);
-  struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in client_addr;
+  struct sockaddr_in server_addr;
   pinger_t *pinger;
+  int r;
 
-  pinger = (pinger_t*)malloc(sizeof(*pinger));
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
+  pinger = malloc(sizeof(*pinger));
   pinger->state = 0;
   pinger->pongs = 0;
 
@@ -190,9 +191,12 @@ static void pinger_new(void) {
 
   pinger->tcp.data = pinger;
 
-  uv_tcp_bind(&pinger->tcp, client_addr);
+  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/deps/uv/test/benchmark-pound.c b/deps/uv/test/benchmark-pound.c
index df19c980c6..7531f55be6 100644
--- a/deps/uv/test/benchmark-pound.c
+++ b/deps/uv/test/benchmark-pound.c
@@ -75,18 +75,18 @@ static uint64_t start; /* in ms  */
 static int closed_streams;
 static int conns_failed;
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size);
+static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);
 static void connect_cb(uv_connect_t* conn_req, int status);
-static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf);
+static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
 static void close_cb(uv_handle_t* handle);
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[65536];
-  uv_buf_t buf;
-  buf.base = slab;
-  buf.len = sizeof(slab);
-  return buf;
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
@@ -135,7 +135,7 @@ static void connect_cb(uv_connect_t* req, int status) {
 }
 
 
-static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
 
   ASSERT(stream != NULL);
 
@@ -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);
 
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  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/deps/uv/test/benchmark-pump.c b/deps/uv/test/benchmark-pump.c
index 5b4db3c0e3..ac132cbfdc 100644
--- a/deps/uv/test/benchmark-pump.c
+++ b/deps/uv/test/benchmark-pump.c
@@ -41,8 +41,8 @@ static void maybe_connect_some();
 static uv_req_t* req_alloc();
 static void req_free(uv_req_t* uv_req);
 
-static uv_buf_t buf_alloc(uv_handle_t*, size_t size);
-static void buf_free(uv_buf_t uv_buf_t);
+static void buf_alloc(uv_handle_t* handle, size_t size, uv_buf_t* buf);
+static void buf_free(const uv_buf_t* buf);
 
 static uv_loop_t* loop;
 
@@ -158,7 +158,7 @@ static void start_stats_collection(void) {
 }
 
 
-static void read_cb(uv_stream_t* stream, ssize_t bytes, uv_buf_t buf) {
+static void read_cb(uv_stream_t* stream, ssize_t bytes, const uv_buf_t* buf) {
   if (nrecv_total == 0) {
     ASSERT(start_time == 0);
     uv_update_time(loop);
@@ -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++];
@@ -331,28 +331,26 @@ typedef struct buf_list_s {
 static buf_list_t* buf_freelist = NULL;
 
 
-static uv_buf_t buf_alloc(uv_handle_t* handle, size_t size) {
-  buf_list_t* buf;
+static void buf_alloc(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+  buf_list_t* ab;
 
-  buf = buf_freelist;
-  if (buf != NULL) {
-    buf_freelist = buf->next;
-    return buf->uv_buf_t;
+  ab = buf_freelist;
+  if (ab != NULL)
+    buf_freelist = ab->next;
+  else {
+    ab = malloc(size + sizeof(*ab));
+    ab->uv_buf_t.len = size;
+    ab->uv_buf_t.base = (char*) (ab + 1);
   }
 
-  buf = (buf_list_t*) malloc(size + sizeof *buf);
-  buf->uv_buf_t.len = (unsigned int)size;
-  buf->uv_buf_t.base = ((char*) buf) + sizeof *buf;
-
-  return buf->uv_buf_t;
+  *buf = ab->uv_buf_t;
 }
 
 
-static void buf_free(uv_buf_t uv_buf_t) {
-  buf_list_t* buf = (buf_list_t*) (uv_buf_t.base - sizeof *buf);
-
-  buf->next = buf_freelist;
-  buf_freelist = buf;
+static void buf_free(const uv_buf_t* buf) {
+  buf_list_t* ab = (buf_list_t*) buf->base - 1;
+  ab->next = buf_freelist;
+  buf_freelist = ab;
 }
 
 
@@ -362,13 +360,13 @@ HELPER_IMPL(tcp_pump_server) {
   type = TCP;
   loop = uv_default_loop();
 
-  listen_addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &listen_addr));
 
   /* Server */
   server = (uv_stream_t*)&tcpServer;
   r = uv_tcp_init(loop, &tcpServer);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&tcpServer, listen_addr);
+  r = uv_tcp_bind(&tcpServer, &listen_addr);
   ASSERT(r == 0);
   r = uv_listen((uv_stream_t*)&tcpServer, MAX_WRITE_HANDLES, connection_cb);
   ASSERT(r == 0);
@@ -408,7 +406,7 @@ static void tcp_pump(int n) {
 
   loop = uv_default_loop();
 
-  connect_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &connect_addr));
 
   /* Start making connections */
   maybe_connect_some();
diff --git a/deps/uv/test/benchmark-spawn.c b/deps/uv/test/benchmark-spawn.c
index 140bfa76bc..9cae41a83a 100644
--- a/deps/uv/test/benchmark-spawn.c
+++ b/deps/uv/test/benchmark-spawn.c
@@ -73,11 +73,11 @@ static void exit_cb(uv_process_t* process,
 }
 
 
-static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
-  uv_buf_t buf;
-  buf.base = output + output_used;
-  buf.len = OUTPUT_SIZE - output_used;
-  return buf;
+static void on_alloc(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
+  buf->base = output + output_used;
+  buf->len = OUTPUT_SIZE - output_used;
 }
 
 
@@ -88,7 +88,7 @@ static void pipe_close_cb(uv_handle_t* pipe) {
 }
 
 
-static void on_read(uv_stream_t* pipe, ssize_t nread, uv_buf_t buf) {
+static void on_read(uv_stream_t* pipe, ssize_t nread, const uv_buf_t* buf) {
   if (nread > 0) {
     ASSERT(pipe_open == 1);
     output_used += nread;
@@ -122,7 +122,7 @@ static void spawn(void) {
   options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
   options.stdio[1].data.stream = (uv_stream_t*)&out;
 
-  r = uv_spawn(loop, &process, options);
+  r = uv_spawn(loop, &process, &options);
   ASSERT(r == 0);
 
   process_open = 1;
diff --git a/deps/uv/test/benchmark-tcp-write-batch.c b/deps/uv/test/benchmark-tcp-write-batch.c
index 978cde0fd3..09b93c244a 100644
--- a/deps/uv/test/benchmark-tcp-write-batch.c
+++ b/deps/uv/test/benchmark-tcp-write-batch.c
@@ -112,12 +112,12 @@ BENCHMARK_IMPL(tcp_write_batch) {
   }
 
   loop = uv_default_loop();
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
   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/deps/uv/test/benchmark-udp-pummel.c b/deps/uv/test/benchmark-udp-pummel.c
index 2590f579af..3dec2631a2 100644
--- a/deps/uv/test/benchmark-udp-pummel.c
+++ b/deps/uv/test/benchmark-udp-pummel.c
@@ -59,10 +59,13 @@ static int timed;
 static int exiting;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[65536];
-  ASSERT(suggested_size <= sizeof slab);
-  return uv_buf_init(slab, sizeof slab);
+  ASSERT(suggested_size <= sizeof(slab));
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
@@ -97,7 +100,7 @@ send:
                           &s->udp_handle,
                           bufs,
                           ARRAY_SIZE(bufs),
-                          s->addr,
+                          &s->addr,
                           send_cb));
   send_cb_called++;
 }
@@ -105,8 +108,8 @@ send:
 
 static void recv_cb(uv_udp_t* handle,
                     ssize_t nread,
-                    uv_buf_t buf,
-                    struct sockaddr* addr,
+                    const uv_buf_t* buf,
+                    const struct sockaddr* addr,
                     unsigned flags) {
   if (nread == 0)
     return;
@@ -117,7 +120,7 @@ static void recv_cb(uv_udp_t* handle,
   }
 
   ASSERT(addr->sa_family == AF_INET);
-  ASSERT(!memcmp(buf.base, EXPECTED, nread));
+  ASSERT(!memcmp(buf->base, EXPECTED, nread));
 
   recv_cb_called++;
 }
@@ -168,9 +171,10 @@ static int pummel(unsigned int n_senders,
 
   for (i = 0; i < n_receivers; i++) {
     struct receiver_state* s = receivers + i;
-    struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", BASE_PORT + i);
+    struct sockaddr_in addr;
+    ASSERT(0 == uv_ip4_addr("0.0.0.0", BASE_PORT + i, &addr));
     ASSERT(0 == uv_udp_init(loop, &s->udp_handle));
-    ASSERT(0 == uv_udp_bind(&s->udp_handle, addr, 0));
+    ASSERT(0 == uv_udp_bind(&s->udp_handle, &addr, 0));
     ASSERT(0 == uv_udp_recv_start(&s->udp_handle, alloc_cb, recv_cb));
     uv_unref((uv_handle_t*)&s->udp_handle);
   }
@@ -183,13 +187,15 @@ static int pummel(unsigned int n_senders,
 
   for (i = 0; i < n_senders; i++) {
     struct sender_state* s = senders + i;
-    s->addr = uv_ip4_addr("127.0.0.1", BASE_PORT + (i % n_receivers));
+    ASSERT(0 == uv_ip4_addr("127.0.0.1",
+                            BASE_PORT + (i % n_receivers),
+                            &s->addr));
     ASSERT(0 == uv_udp_init(loop, &s->udp_handle));
     ASSERT(0 == uv_udp_send(&s->send_req,
                             &s->udp_handle,
                             bufs,
                             ARRAY_SIZE(bufs),
-                            s->addr,
+                            &s->addr,
                             send_cb));
   }
 
diff --git a/deps/uv/test/blackhole-server.c b/deps/uv/test/blackhole-server.c
index ade49b48cc..75f845638e 100644
--- a/deps/uv/test/blackhole-server.c
+++ b/deps/uv/test/blackhole-server.c
@@ -33,8 +33,8 @@ typedef struct {
 static uv_tcp_t tcp_server;
 
 static void connection_cb(uv_stream_t* stream, int status);
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size);
-static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf);
+static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);
+static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
 static void shutdown_cb(uv_shutdown_t* req, int status);
 static void close_cb(uv_handle_t* handle);
 
@@ -60,13 +60,16 @@ static void connection_cb(uv_stream_t* stream, int status) {
 }
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
-  static char buf[65536];
-  return uv_buf_init(buf, sizeof buf);
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
+  static char slab[65536];
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
-static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
   conn_rec* conn;
   int r;
 
@@ -100,12 +103,12 @@ HELPER_IMPL(tcp4_blackhole_server) {
   int r;
 
   loop = uv_default_loop();
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
   r = uv_tcp_init(loop, &tcp_server);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(&tcp_server, addr);
+  r = uv_tcp_bind(&tcp_server, &addr);
   ASSERT(r == 0);
 
   r = uv_listen((uv_stream_t*)&tcp_server, 128, connection_cb);
diff --git a/deps/uv/test/dns-server.c b/deps/uv/test/dns-server.c
index 17e7ecf2d6..aabded5539 100644
--- a/deps/uv/test/dns-server.c
+++ b/deps/uv/test/dns-server.c
@@ -54,7 +54,7 @@ static uv_tcp_t server;
 
 
 static void after_write(uv_write_t* req, int status);
-static void after_read(uv_stream_t*, ssize_t nread, uv_buf_t buf);
+static void after_read(uv_stream_t*, ssize_t nread, const uv_buf_t* buf);
 static void on_close(uv_handle_t* peer);
 static void on_connection(uv_stream_t*, int status);
 
@@ -124,7 +124,9 @@ static void addrsp(write_req_t* wr, char* hdr) {
   wr->buf.len += rsplen;
 }
 
-static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+static void process_req(uv_stream_t* handle,
+                        ssize_t nread,
+                        const uv_buf_t* buf) {
   write_req_t* wr;
   dnshandle* dns = (dnshandle*)handle;
   char hdrbuf[DNSREC_LEN];
@@ -144,7 +146,7 @@ static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
     readbuf_remaining = dns->state.prevbuf_rem;
     usingprev = 1;
   } else {
-    dnsreq = buf.base;
+    dnsreq = buf->base;
     readbuf_remaining = nread;
   }
   hdrstart = dnsreq;
@@ -194,7 +196,7 @@ static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
     if (usingprev == 1) {
       /* free previous buffer */
       free(dns->state.prevbuf_ptr);
-      dnsreq = buf.base;
+      dnsreq = buf->base;
       readbuf_remaining = nread;
       usingprev = 0;
     } else {
@@ -211,27 +213,29 @@ static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
 
   if (readbuf_remaining > 0) {
     /* save start of record position, so we can continue on next read */
-    dns->state.prevbuf_ptr = buf.base;
-    dns->state.prevbuf_pos = hdrstart - buf.base;
+    dns->state.prevbuf_ptr = buf->base;
+    dns->state.prevbuf_pos = hdrstart - buf->base;
     dns->state.prevbuf_rem = nread - dns->state.prevbuf_pos;
   } else {
     /* nothing left in this buffer */
     dns->state.prevbuf_ptr = NULL;
     dns->state.prevbuf_pos = 0;
     dns->state.prevbuf_rem = 0;
-    free(buf.base);
+    free(buf->base);
   }
 }
 
-static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+static void after_read(uv_stream_t* handle,
+                       ssize_t nread,
+                       const uv_buf_t* buf) {
   uv_shutdown_t* req;
 
   if (nread < 0) {
     /* Error or EOF */
     ASSERT(nread == UV_EOF);
 
-    if (buf.base) {
-      free(buf.base);
+    if (buf->base) {
+      free(buf->base);
     }
 
     req = malloc(sizeof *req);
@@ -242,7 +246,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
 
   if (nread == 0) {
     /* Everything OK, but nothing read. */
-    free(buf.base);
+    free(buf->base);
     return;
   }
   /* process requests and send responses */
@@ -255,11 +259,11 @@ static void on_close(uv_handle_t* peer) {
 }
 
 
-static uv_buf_t buf_alloc(uv_handle_t* handle, size_t suggested_size) {
-  uv_buf_t buf;
-  buf.base = (char*) malloc(suggested_size);
-  buf.len = suggested_size;
-  return buf;
+static void buf_alloc(uv_handle_t* handle,
+                      size_t suggested_size,
+                      uv_buf_t* buf) {
+  buf->base = malloc(suggested_size);
+  buf->len = suggested_size;
 }
 
 
@@ -289,9 +293,11 @@ static void on_connection(uv_stream_t* server, int status) {
 
 
 static int dns_start(int port) {
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
+  struct sockaddr_in addr;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", port, &addr));
+
   r = uv_tcp_init(loop, &server);
   if (r) {
     /* TODO: Error codes */
@@ -299,7 +305,7 @@ static int dns_start(int port) {
     return 1;
   }
 
-  r = uv_tcp_bind(&server, addr);
+  r = uv_tcp_bind(&server, &addr);
   if (r) {
     /* TODO: Error codes */
     fprintf(stderr, "Bind error\n");
diff --git a/deps/uv/test/echo-server.c b/deps/uv/test/echo-server.c
index a9891d25c8..69742019de 100644
--- a/deps/uv/test/echo-server.c
+++ b/deps/uv/test/echo-server.c
@@ -39,7 +39,7 @@ static uv_pipe_t pipeServer;
 static uv_handle_t* server;
 
 static void after_write(uv_write_t* req, int status);
-static void after_read(uv_stream_t*, ssize_t nread, uv_buf_t buf);
+static void after_read(uv_stream_t*, ssize_t nread, const uv_buf_t* buf);
 static void on_close(uv_handle_t* peer);
 static void on_server_close(uv_handle_t* handle);
 static void on_connection(uv_stream_t*, int status);
@@ -72,7 +72,9 @@ static void after_shutdown(uv_shutdown_t* req, int status) {
 }
 
 
-static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+static void after_read(uv_stream_t* handle,
+                       ssize_t nread,
+                       const uv_buf_t* buf) {
   int i;
   write_req_t *wr;
   uv_shutdown_t* req;
@@ -81,8 +83,8 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
     /* Error or EOF */
     ASSERT(nread == UV_EOF);
 
-    if (buf.base) {
-      free(buf.base);
+    if (buf->base) {
+      free(buf->base);
     }
 
     req = (uv_shutdown_t*) malloc(sizeof *req);
@@ -93,7 +95,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
 
   if (nread == 0) {
     /* Everything OK, but nothing read. */
-    free(buf.base);
+    free(buf->base);
     return;
   }
 
@@ -103,9 +105,9 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
    */
   if (!server_closed) {
     for (i = 0; i < nread; i++) {
-      if (buf.base[i] == 'Q') {
-        if (i + 1 < nread && buf.base[i + 1] == 'S') {
-          free(buf.base);
+      if (buf->base[i] == 'Q') {
+        if (i + 1 < nread && buf->base[i + 1] == 'S') {
+          free(buf->base);
           uv_close((uv_handle_t*)handle, on_close);
           return;
         } else {
@@ -118,7 +120,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
 
   wr = (write_req_t*) malloc(sizeof *wr);
 
-  wr->buf = uv_buf_init(buf.base, nread);
+  wr->buf = uv_buf_init(buf->base, nread);
   if (uv_write(&wr->req, handle, &wr->buf, 1, after_write)) {
     FATAL("uv_write failed");
   }
@@ -130,8 +132,11 @@ static void on_close(uv_handle_t* peer) {
 }
 
 
-static uv_buf_t echo_alloc(uv_handle_t* handle, size_t suggested_size) {
-  return uv_buf_init(malloc(suggested_size), suggested_size);
+static void echo_alloc(uv_handle_t* handle,
+                       size_t suggested_size,
+                       uv_buf_t* buf) {
+  buf->base = malloc(suggested_size);
+  buf->len = suggested_size;
 }
 
 
@@ -185,10 +190,11 @@ static void on_send(uv_udp_send_t* req, int status);
 
 static void on_recv(uv_udp_t* handle,
                     ssize_t nread,
-                    uv_buf_t buf,
-                    struct sockaddr* addr,
+                    const uv_buf_t* rcvbuf,
+                    const struct sockaddr* addr,
                     unsigned flags) {
   uv_udp_send_t* req;
+  uv_buf_t sndbuf;
   int r;
 
   ASSERT(nread > 0);
@@ -197,7 +203,13 @@ static void on_recv(uv_udp_t* handle,
   req = malloc(sizeof(*req));
   ASSERT(req != NULL);
 
-  r = uv_udp_send(req, handle, &buf, 1, *(struct sockaddr_in*)addr, on_send);
+  sndbuf = *rcvbuf;
+  r = uv_udp_send(req,
+                  handle,
+                  &sndbuf,
+                  1,
+                  (const struct sockaddr_in*) addr,
+                  on_send);
   ASSERT(r == 0);
 }
 
@@ -209,9 +221,11 @@ static void on_send(uv_udp_send_t* req, int status) {
 
 
 static int tcp4_echo_start(int port) {
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
+  struct sockaddr_in addr;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", port, &addr));
+
   server = (uv_handle_t*)&tcpServer;
   serverType = TCP;
 
@@ -222,7 +236,7 @@ static int tcp4_echo_start(int port) {
     return 1;
   }
 
-  r = uv_tcp_bind(&tcpServer, addr);
+  r = uv_tcp_bind(&tcpServer, &addr);
   if (r) {
     /* TODO: Error codes */
     fprintf(stderr, "Bind error\n");
@@ -241,9 +255,11 @@ static int tcp4_echo_start(int port) {
 
 
 static int tcp6_echo_start(int port) {
-  struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port);
+  struct sockaddr_in6 addr6;
   int r;
 
+  ASSERT(0 == uv_ip6_addr("::1", port, &addr6));
+
   server = (uv_handle_t*)&tcpServer;
   serverType = TCP;
 
@@ -255,7 +271,7 @@ static int tcp6_echo_start(int port) {
   }
 
   /* IPv6 is optional as not all platforms support it */
-  r = uv_tcp_bind6(&tcpServer, addr6);
+  r = uv_tcp_bind6(&tcpServer, &addr6);
   if (r) {
     /* show message but return OK */
     fprintf(stderr, "IPv6 not supported\n");
diff --git a/deps/uv/test/test-callback-stack.c b/deps/uv/test/test-callback-stack.c
index 1774fdf488..ff6e93c4ef 100644
--- a/deps/uv/test/test-callback-stack.c
+++ b/deps/uv/test/test-callback-stack.c
@@ -45,12 +45,10 @@ static int bytes_received = 0;
 static int shutdown_cb_called = 0;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
-  uv_buf_t buf;
-  buf.len = size;
-  buf.base = (char*) malloc(size);
-  ASSERT(buf.base);
-  return buf;
+static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+  buf->len = size;
+  buf->base = malloc(size);
+  ASSERT(buf->base != NULL);
 }
 
 
@@ -69,11 +67,11 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
 }
 
 
-static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
   ASSERT(nested == 0 && "read_cb must be called from a fresh stack");
 
   printf("Read. nread == %d\n", (int)nread);
-  free(buf.base);
+  free(buf->base);
 
   if (nread == 0) {
     return;
@@ -173,7 +171,9 @@ static void connect_cb(uv_connect_t* req, int status) {
 
 
 TEST_IMPL(callback_stack) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
+
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
   if (uv_tcp_init(uv_default_loop(), &client)) {
     FATAL("uv_tcp_init failed");
@@ -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/deps/uv/test/test-connection-fail.c b/deps/uv/test/test-connection-fail.c
index 8dfb38ea9d..8009930600 100644
--- a/deps/uv/test/test-connection-fail.c
+++ b/deps/uv/test/test-connection-fail.c
@@ -90,10 +90,10 @@ static void connection_fail(uv_connect_cb connect_cb) {
   struct sockaddr_in client_addr, server_addr;
   int r;
 
-  client_addr = uv_ip4_addr("0.0.0.0", 0);
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));
 
   /* There should be no servers listening on this port. */
-  server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
 
   /* Try to connect to the server and do NUM_PINGS ping-pongs. */
   r = uv_tcp_init(uv_default_loop(), &tcp);
@@ -101,8 +101,8 @@ 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);
+  uv_tcp_bind(&tcp, &client_addr);
+  r = uv_tcp_connect(&req, &tcp, &server_addr, connect_cb);
   ASSERT(!r);
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
diff --git a/deps/uv/test/test-delayed-accept.c b/deps/uv/test/test-delayed-accept.c
index cd0b026923..a7d31883b3 100644
--- a/deps/uv/test/test-delayed-accept.c
+++ b/deps/uv/test/test-delayed-accept.c
@@ -30,11 +30,9 @@ static int close_cb_called = 0;
 static int connect_cb_called = 0;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
-  uv_buf_t buf;
-  buf.base = (char*)malloc(size);
-  buf.len = size;
-  return buf;
+static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+  buf->base = malloc(size);
+  buf->len = size;
 }
 
 
@@ -101,15 +99,16 @@ static void connection_cb(uv_stream_t* tcp, int status) {
 
 
 static void start_server(void) {
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
+  struct sockaddr_in addr;
   uv_tcp_t* server = (uv_tcp_t*)malloc(sizeof *server);
   int r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
   ASSERT(server != NULL);
 
   r = uv_tcp_init(uv_default_loop(), server);
   ASSERT(r == 0);
-  r = uv_tcp_bind(server, addr);
+  r = uv_tcp_bind(server, &addr);
   ASSERT(r == 0);
 
   r = uv_listen((uv_stream_t*)server, 128, connection_cb);
@@ -117,11 +116,11 @@ static void start_server(void) {
 }
 
 
-static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
   /* The server will not send anything, it should close gracefully. */
 
-  if (buf.base) {
-    free(buf.base);
+  if (buf->base) {
+    free(buf->base);
   }
 
   if (nread >= 0) {
@@ -152,18 +151,19 @@ static void connect_cb(uv_connect_t* req, int status) {
 
 
 static void client_connect(void) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   uv_tcp_t* client = (uv_tcp_t*)malloc(sizeof *client);
   uv_connect_t* connect_req = malloc(sizeof *connect_req);
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   ASSERT(client != NULL);
   ASSERT(connect_req != NULL);
 
   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/deps/uv/test/test-embed.c b/deps/uv/test/test-embed.c
index 7f485d1ae4..ac1b3b6750 100644
--- a/deps/uv/test/test-embed.c
+++ b/deps/uv/test/test-embed.c
@@ -78,7 +78,10 @@ static void embed_thread_runner(void* arg) {
       ts.tv_nsec = (timeout % 1000) * 1000000;
       r = kevent(fd, NULL, 0, NULL, 0, &ts);
 #elif defined(HAVE_EPOLL)
-      r = epoll_wait(fd, NULL, 0, timeout);
+      {
+        struct epoll_event ev;
+        r = epoll_wait(fd, &ev, 1, timeout);
+      }
 #endif
     } while (r == -1 && errno == EINTR);
     uv_async_send(&embed_async);
diff --git a/deps/uv/test/test-getsockname.c b/deps/uv/test/test-getsockname.c
index e3f09ec4e4..87bb616d04 100644
--- a/deps/uv/test/test-getsockname.c
+++ b/deps/uv/test/test-getsockname.c
@@ -42,11 +42,9 @@ static uv_udp_t udpServer;
 static uv_udp_send_t send_req;
 
 
-static uv_buf_t alloc(uv_handle_t* handle, size_t suggested_size) {
-  uv_buf_t buf;
-  buf.base = (char*) malloc(suggested_size);
-  buf.len = suggested_size;
-  return buf;
+static void alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
+  buf->base = malloc(suggested_size);
+  buf->len = suggested_size;
 }
 
 
@@ -62,12 +60,14 @@ static void after_shutdown(uv_shutdown_t* req, int status) {
 }
 
 
-static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+static void after_read(uv_stream_t* handle,
+                       ssize_t nread,
+                       const uv_buf_t* buf) {
   uv_shutdown_t* req;
   int r;
 
-  if (buf.base) {
-    free(buf.base);
+  if (buf->base) {
+    free(buf->base);
   }
 
   req = (uv_shutdown_t*) malloc(sizeof *req);
@@ -79,10 +79,12 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
 static void check_sockname(struct sockaddr* addr, const char* compare_ip,
   int compare_port, const char* context) {
   struct sockaddr_in check_addr = *(struct sockaddr_in*) addr;
-  struct sockaddr_in compare_addr = uv_ip4_addr(compare_ip, compare_port);
+  struct sockaddr_in compare_addr;
   char check_ip[17];
   int r;
 
+  ASSERT(0 == uv_ip4_addr(compare_ip, compare_port, &compare_addr));
+
   /* Both addresses should be ipv4 */
   ASSERT(check_addr.sin_family == AF_INET);
   ASSERT(compare_addr.sin_family == AF_INET);
@@ -165,18 +167,20 @@ static void on_connect(uv_connect_t* req, int status) {
 
 
 static int tcp_listener(void) {
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
+  struct sockaddr_in addr;
   struct sockaddr sockname, peername;
   int namelen;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));
+
   r = uv_tcp_init(loop, &tcpServer);
   if (r) {
     fprintf(stderr, "Socket creation error\n");
     return 1;
   }
 
-  r = uv_tcp_bind(&tcpServer, addr);
+  r = uv_tcp_bind(&tcpServer, &addr);
   if (r) {
     fprintf(stderr, "Bind error\n");
     return 1;
@@ -205,15 +209,17 @@ static int tcp_listener(void) {
 
 
 static void tcp_connector(void) {
-  struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", server_port);
+  struct sockaddr_in server_addr;
   struct sockaddr sockname;
   int r, namelen;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
+
   r = uv_tcp_init(loop, &tcp);
   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. */
@@ -228,15 +234,15 @@ static void tcp_connector(void) {
 
 static void udp_recv(uv_udp_t* handle,
                      ssize_t nread,
-                     uv_buf_t buf,
-                     struct sockaddr* addr,
+                     const uv_buf_t* buf,
+                     const struct sockaddr* addr,
                      unsigned flags) {
   struct sockaddr sockname;
   int namelen;
   int r;
 
   ASSERT(nread >= 0);
-  free(buf.base);
+  free(buf->base);
 
   if (nread == 0) {
     return;
@@ -260,18 +266,20 @@ static void udp_send(uv_udp_send_t* req, int status) {
 
 
 static int udp_listener(void) {
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
+  struct sockaddr_in addr;
   struct sockaddr sockname;
   int namelen;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));
+
   r = uv_udp_init(loop, &udpServer);
   if (r) {
     fprintf(stderr, "Socket creation error\n");
     return 1;
   }
 
-  r = uv_udp_bind(&udpServer, addr, 0);
+  r = uv_udp_bind(&udpServer, &addr, 0);
   if (r) {
     fprintf(stderr, "Bind error\n");
     return 1;
@@ -300,9 +308,9 @@ static void udp_sender(void) {
   ASSERT(!r);
 
   buf = uv_buf_init("PING", 4);
-  server_addr = uv_ip4_addr("127.0.0.1", server_port);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
 
-  r = uv_udp_send(&send_req, &udp, &buf, 1, server_addr, udp_send);
+  r = uv_udp_send(&send_req, &udp, &buf, 1, &server_addr, udp_send);
   ASSERT(!r);
 }
 
diff --git a/deps/uv/test/test-ip6-addr.c b/deps/uv/test/test-ip6-addr.c
index 91891bffb9..ddd0812285 100644
--- a/deps/uv/test/test-ip6-addr.c
+++ b/deps/uv/test/test-ip6-addr.c
@@ -84,7 +84,7 @@ TEST_IMPL(ip6_addr_link_local) {
          iface_index,
          device_name);
 
-    addr = uv_ip6_addr(scoped_addr, TEST_PORT);
+    ASSERT(0 == uv_ip6_addr(scoped_addr, TEST_PORT, &addr));
     LOGF("Got scope_id 0x%02x\n", addr.sin6_scope_id);
     ASSERT(iface_index == addr.sin6_scope_id);
   }
diff --git a/deps/uv/test/test-ipc-send-recv.c b/deps/uv/test/test-ipc-send-recv.c
index 90ac69f39e..5119b3171f 100644
--- a/deps/uv/test/test-ipc-send-recv.c
+++ b/deps/uv/test/test-ipc-send-recv.c
@@ -50,16 +50,19 @@ static struct echo_ctx ctx;
 static int num_recv_handles;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   /* we're not actually reading anything so a small buffer is okay */
-  static char buf[8];
-  return uv_buf_init(buf, sizeof(buf));
+  static char slab[8];
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
 static void recv_cb(uv_pipe_t* handle,
                     ssize_t nread,
-                    uv_buf_t buf,
+                    const uv_buf_t* buf,
                     uv_handle_type pending) {
   int r;
 
@@ -132,14 +135,17 @@ TEST_IMPL(ipc_send_recv_pipe) {
 
 
 TEST_IMPL(ipc_send_recv_tcp) {
+  struct sockaddr_in addr;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
   ctx.expected_type = UV_TCP;
 
   r = uv_tcp_init(uv_default_loop(), &ctx.send.tcp);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(&ctx.send.tcp, uv_ip4_addr("127.0.0.1", TEST_PORT));
+  r = uv_tcp_bind(&ctx.send.tcp, &addr);
   ASSERT(r == 0);
 
   r = run_test();
@@ -161,15 +167,16 @@ static void write2_cb(uv_write_t* req, int status) {
 
 static void read2_cb(uv_pipe_t* handle,
                      ssize_t nread,
-                     uv_buf_t buf,
+                     const uv_buf_t* rdbuf,
                      uv_handle_type pending) {
+  uv_buf_t wrbuf;
   int r;
 
   ASSERT(pending == UV_NAMED_PIPE || pending == UV_TCP);
   ASSERT(handle == &ctx.channel);
   ASSERT(nread >= 0);
 
-  buf = uv_buf_init(".", 1);
+  wrbuf = uv_buf_init(".", 1);
 
   if (pending == UV_NAMED_PIPE)
     r = uv_pipe_init(ctx.channel.loop, &ctx.recv.pipe, 0);
@@ -184,7 +191,8 @@ static void read2_cb(uv_pipe_t* handle,
 
   r = uv_write2(&ctx.write_req,
                 (uv_stream_t*)&ctx.channel,
-                &buf, 1,
+                &wrbuf,
+                1,
                 &ctx.recv.stream,
                 write2_cb);
   ASSERT(r == 0);
diff --git a/deps/uv/test/test-ipc.c b/deps/uv/test/test-ipc.c
index 0918a92755..7085ea3cb6 100644
--- a/deps/uv/test/test-ipc.c
+++ b/deps/uv/test/test-ipc.c
@@ -94,8 +94,11 @@ static void exit_cb(uv_process_t* process,
 }
 
 
-static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
-  return uv_buf_init(malloc(suggested_size), suggested_size);
+static void on_alloc(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
+  buf->base = malloc(suggested_size);
+  buf->len = suggested_size;
 }
 
 
@@ -122,9 +125,12 @@ static void make_many_connections(void) {
     r = uv_tcp_init(uv_default_loop(), &conn->conn);
     ASSERT(r == 0);
 
-    addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+    ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
-    r = uv_tcp_connect(&conn->conn_req, (uv_tcp_t*)&conn->conn, addr, connect_cb);
+    r = uv_tcp_connect(&conn->conn_req,
+                       (uv_tcp_t*) &conn->conn,
+                       &addr,
+                       connect_cb);
     ASSERT(r == 0);
 
     conn->conn.data = conn;
@@ -132,20 +138,22 @@ static void make_many_connections(void) {
 }
 
 
-static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
-    uv_handle_type pending) {
+static void on_read(uv_pipe_t* pipe,
+                    ssize_t nread,
+                    const uv_buf_t* buf,
+                    uv_handle_type pending) {
   int r;
   uv_buf_t outbuf;
 
   if (nread == 0) {
     /* Everything OK, but nothing read. */
-    free(buf.base);
+    free(buf->base);
     return;
   }
 
   if (nread < 0) {
     if (nread == UV_EOF) {
-      free(buf.base);
+      free(buf->base);
       return;
     }
 
@@ -156,7 +164,7 @@ static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
   fprintf(stderr, "got %d bytes\n", (int)nread);
 
   if (!tcp_server_listening) {
-    ASSERT(nread > 0 && buf.base && pending != UV_UNKNOWN_HANDLE);
+    ASSERT(nread > 0 && buf->base && pending != UV_UNKNOWN_HANDLE);
     read2_cb_called++;
 
     /* Accept the pending TCP server, and start listening on it. */
@@ -173,7 +181,7 @@ static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
     tcp_server_listening = 1;
 
     /* Make sure that the expected data is correctly multiplexed. */
-    ASSERT(memcmp("hello\n", buf.base, nread) == 0);
+    ASSERT(memcmp("hello\n", buf->base, nread) == 0);
 
     outbuf = uv_buf_init("world\n", 6);
     r = uv_write(&write_req, (uv_stream_t*)pipe, &outbuf, 1, NULL);
@@ -181,14 +189,14 @@ static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
 
     /* Create a bunch of connections to get both servers to accept. */
     make_many_connections();
-  } else if (memcmp("accepted_connection\n", buf.base, nread) == 0) {
+  } else if (memcmp("accepted_connection\n", buf->base, nread) == 0) {
     /* Remote server has accepted a connection.  Close the channel. */
     ASSERT(pending == UV_UNKNOWN_HANDLE);
     remote_conn_accepted = 1;
     uv_close((uv_handle_t*)&channel, NULL);
   }
 
-  free(buf.base);
+  free(buf->base);
 }
 
 
@@ -226,7 +234,7 @@ void spawn_helper(uv_pipe_t* channel,
   options.stdio[0].data.stream = (uv_stream_t*)channel;
   options.stdio_count = 1;
 
-  r = uv_spawn(uv_default_loop(), process, options);
+  r = uv_spawn(uv_default_loop(), process, &options);
   ASSERT(r == 0);
 }
 
@@ -238,19 +246,19 @@ static void on_tcp_write(uv_write_t* req, int status) {
 }
 
 
-static uv_buf_t on_read_alloc(uv_handle_t* handle, size_t suggested_size) {
-  uv_buf_t buf;
-  buf.base = (char*)malloc(suggested_size);
-  buf.len = suggested_size;
-  return buf;
+static void on_read_alloc(uv_handle_t* handle,
+                          size_t suggested_size,
+                          uv_buf_t* buf) {
+  buf->base = malloc(suggested_size);
+  buf->len = suggested_size;
 }
 
 
-static void on_tcp_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void on_tcp_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
   ASSERT(nread > 0);
-  ASSERT(memcmp("hello again\n", buf.base, nread) == 0);
+  ASSERT(memcmp("hello again\n", buf->base, nread) == 0);
   ASSERT(tcp == (uv_stream_t*)&tcp_connection);
-  free(buf.base);
+  free(buf->base);
 
   tcp_read_cb_called++;
 
@@ -259,20 +267,22 @@ static void on_tcp_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
 }
 
 
-static void on_read_connection(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
-    uv_handle_type pending) {
+static void on_read_connection(uv_pipe_t* pipe,
+                               ssize_t nread,
+                               const uv_buf_t* buf,
+                               uv_handle_type pending) {
   int r;
   uv_buf_t outbuf;
 
   if (nread == 0) {
     /* Everything OK, but nothing read. */
-    free(buf.base);
+    free(buf->base);
     return;
   }
 
   if (nread < 0) {
     if (nread == UV_EOF) {
-      free(buf.base);
+      free(buf->base);
       return;
     }
 
@@ -282,7 +292,7 @@ static void on_read_connection(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
 
   fprintf(stderr, "got %d bytes\n", (int)nread);
 
-  ASSERT(nread > 0 && buf.base && pending != UV_UNKNOWN_HANDLE);
+  ASSERT(nread > 0 && buf->base && pending != UV_UNKNOWN_HANDLE);
   read2_cb_called++;
 
   /* Accept the pending TCP connection */
@@ -294,7 +304,7 @@ static void on_read_connection(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
   ASSERT(r == 0);
 
   /* Make sure that the expected data is correctly multiplexed. */
-  ASSERT(memcmp("hello\n", buf.base, nread) == 0);
+  ASSERT(memcmp("hello\n", buf->base, nread) == 0);
 
   /* Write/read to/from the connection */
   outbuf = uv_buf_init("world\n", 6);
@@ -305,7 +315,7 @@ static void on_read_connection(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
   r = uv_read_start((uv_stream_t*)&tcp_connection, on_read_alloc, on_tcp_read);
   ASSERT(r == 0);
 
-  free(buf.base);
+  free(buf->base);
 }
 
 
@@ -358,12 +368,14 @@ TEST_IMPL(ipc_tcp_connection) {
 TEST_IMPL(listen_with_simultaneous_accepts) {
   uv_tcp_t server;
   int r;
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
+  struct sockaddr_in addr;
+
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
 
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(&server, addr);
+  r = uv_tcp_bind(&server, &addr);
   ASSERT(r == 0);
 
   r = uv_tcp_simultaneous_accepts(&server, 1);
@@ -381,12 +393,14 @@ TEST_IMPL(listen_with_simultaneous_accepts) {
 TEST_IMPL(listen_no_simultaneous_accepts) {
   uv_tcp_t server;
   int r;
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
+  struct sockaddr_in addr;
+
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
 
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(&server, addr);
+  r = uv_tcp_bind(&server, &addr);
   ASSERT(r == 0);
 
   r = uv_tcp_simultaneous_accepts(&server, 0);
@@ -427,13 +441,15 @@ static void tcp_connection_write_cb(uv_write_t* req, int status) {
 }
 
 
-static void on_tcp_child_process_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void on_tcp_child_process_read(uv_stream_t* tcp,
+                                      ssize_t nread,
+                                      const uv_buf_t* buf) {
   uv_buf_t outbuf;
   int r;
 
   if (nread < 0) {
     if (nread == UV_EOF) {
-      free(buf.base);
+      free(buf->base);
       return;
     }
 
@@ -442,9 +458,9 @@ static void on_tcp_child_process_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t
   }
 
   ASSERT(nread > 0);
-  ASSERT(memcmp("world\n", buf.base, nread) == 0);
+  ASSERT(memcmp("world\n", buf->base, nread) == 0);
   on_pipe_read_called++;
-  free(buf.base);
+  free(buf->base);
 
   /* Write to the socket */
   outbuf = uv_buf_init("hello again\n", 12);
@@ -517,7 +533,9 @@ static void ipc_on_connection_tcp_conn(uv_stream_t* server, int status) {
     (uv_stream_t*)conn, NULL);
   ASSERT(r == 0);
 
-  r = uv_read_start((uv_stream_t*)conn, on_read_alloc, on_tcp_child_process_read);
+  r = uv_read_start((uv_stream_t*) conn,
+                    on_read_alloc,
+                    on_tcp_child_process_read);
   ASSERT(r == 0);
 
   uv_close((uv_handle_t*)conn, close_cb);
@@ -529,11 +547,13 @@ int ipc_helper(int listen_after_write) {
    * This is launched from test-ipc.c. stdin is a duplex channel that we
    * over which a handle will be transmitted.
    */
-
+  struct sockaddr_in addr;
   uv_write_t write_req;
   int r;
   uv_buf_t buf;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
+
   r = uv_pipe_init(uv_default_loop(), &channel, 1);
   ASSERT(r == 0);
 
@@ -546,7 +566,7 @@ int ipc_helper(int listen_after_write) {
   r = uv_tcp_init(uv_default_loop(), &tcp_server);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(&tcp_server, uv_ip4_addr("0.0.0.0", TEST_PORT));
+  r = uv_tcp_bind(&tcp_server, &addr);
   ASSERT(r == 0);
 
   if (!listen_after_write) {
@@ -596,7 +616,9 @@ int ipc_helper_tcp_connection(void) {
   r = uv_tcp_init(uv_default_loop(), &tcp_server);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(&tcp_server, uv_ip4_addr("0.0.0.0", TEST_PORT));
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
+
+  r = uv_tcp_bind(&tcp_server, &addr);
   ASSERT(r == 0);
 
   r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection_tcp_conn);
@@ -606,8 +628,12 @@ int ipc_helper_tcp_connection(void) {
   r = uv_tcp_init(uv_default_loop(), &conn.conn);
   ASSERT(r == 0);
 
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
-  r = uv_tcp_connect(&conn.conn_req, (uv_tcp_t*)&conn.conn, addr, connect_child_process_cb);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
+  r = uv_tcp_connect(&conn.conn_req,
+                     (uv_tcp_t*) &conn.conn,
+                     &addr,
+                     connect_child_process_cb);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
diff --git a/deps/uv/test/test-multiple-listen.c b/deps/uv/test/test-multiple-listen.c
index 4d52be12c6..c19ec71b7f 100644
--- a/deps/uv/test/test-multiple-listen.c
+++ b/deps/uv/test/test-multiple-listen.c
@@ -45,13 +45,15 @@ static void connection_cb(uv_stream_t* tcp, int status) {
 
 
 static void start_server(void) {
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
+  struct sockaddr_in addr;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
+
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(&server, addr);
+  r = uv_tcp_bind(&server, &addr);
   ASSERT(r == 0);
 
   r = uv_listen((uv_stream_t*)&server, 128, connection_cb);
@@ -72,16 +74,17 @@ static void connect_cb(uv_connect_t* req, int status) {
 
 
 static void client_connect(void) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   uv_connect_t* connect_req = malloc(sizeof *connect_req);
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   ASSERT(connect_req != NULL);
 
   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/deps/uv/test/test-osx-select.c b/deps/uv/test/test-osx-select.c
index bf4c3952b7..e5e1bf8b46 100644
--- a/deps/uv/test/test-osx-select.c
+++ b/deps/uv/test/test-osx-select.c
@@ -30,14 +30,14 @@
 static int read_count;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
-  static char buf[1024];
-
-  return uv_buf_init(buf, ARRAY_SIZE(buf));
+static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+  static char slab[1024];
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
-static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
   fprintf(stdout, "got data %d\n", ++read_count);
 
   if (read_count == 3)
diff --git a/deps/uv/test/test-ping-pong.c b/deps/uv/test/test-ping-pong.c
index 719f2d19db..0c880d7d09 100644
--- a/deps/uv/test/test-ping-pong.c
+++ b/deps/uv/test/test-ping-pong.c
@@ -48,8 +48,9 @@ typedef struct {
 } pinger_t;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
-  return uv_buf_init(malloc(size), size);
+static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+  buf->base = malloc(size);
+  buf->len = size;
 }
 
 
@@ -85,7 +86,9 @@ static void pinger_write_ping(pinger_t* pinger) {
 }
 
 
-static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
+static void pinger_read_cb(uv_stream_t* stream,
+                           ssize_t nread,
+                           const uv_buf_t* buf) {
   ssize_t i;
   pinger_t* pinger;
 
@@ -95,7 +98,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
     ASSERT(nread == UV_EOF);
 
     puts("got EOF");
-    free(buf.base);
+    free(buf->base);
 
     uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);
 
@@ -104,7 +107,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
 
   /* Now we count the pings */
   for (i = 0; i < nread; i++) {
-    ASSERT(buf.base[i] == PING[pinger->state]);
+    ASSERT(buf->base[i] == PING[pinger->state]);
     pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);
 
     if (pinger->state != 0)
@@ -121,7 +124,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
     }
   }
 
-  free(buf.base);
+  free(buf->base);
 }
 
 
@@ -145,10 +148,11 @@ static void pinger_on_connect(uv_connect_t *req, int status) {
 /* same ping-pong test, but using IPv6 connection */
 static void tcp_pinger_v6_new(void) {
   int r;
-  struct sockaddr_in6 server_addr = uv_ip6_addr("::1", TEST_PORT);
+  struct sockaddr_in6 server_addr;
   pinger_t *pinger;
 
-  pinger = (pinger_t*)malloc(sizeof(*pinger));
+  ASSERT(0 ==uv_ip6_addr("::1", TEST_PORT, &server_addr));
+  pinger = malloc(sizeof(*pinger));
   pinger->state = 0;
   pinger->pongs = 0;
 
@@ -159,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. */
@@ -170,10 +176,11 @@ static void tcp_pinger_v6_new(void) {
 
 static void tcp_pinger_new(void) {
   int r;
-  struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in server_addr;
   pinger_t *pinger;
 
-  pinger = (pinger_t*)malloc(sizeof(*pinger));
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
+  pinger = malloc(sizeof(*pinger));
   pinger->state = 0;
   pinger->pongs = 0;
 
@@ -184,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/deps/uv/test/test-poll.c b/deps/uv/test/test-poll.c
index 1ca9c92135..135c72974d 100644
--- a/deps/uv/test/test-poll.c
+++ b/deps/uv/test/test-poll.c
@@ -496,11 +496,13 @@ static void server_poll_cb(uv_poll_t* handle, int status, int events) {
 
 
 static void start_server(void) {
-  uv_os_sock_t sock;
   server_context_t* context;
+  struct sockaddr_in addr;
+  uv_os_sock_t sock;
   int r;
 
-  sock = create_nonblocking_bound_socket(uv_ip4_addr("127.0.0.1", TEST_PORT));
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+  sock = create_nonblocking_bound_socket(addr);
   context = create_server_context(sock);
 
   r = listen(sock, 100);
@@ -514,10 +516,14 @@ static void start_server(void) {
 static void start_client(void) {
   uv_os_sock_t sock;
   connection_context_t* context;
-  struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in server_addr;
+  struct sockaddr_in addr;
   int r;
 
-  sock = create_nonblocking_bound_socket(uv_ip4_addr("0.0.0.0", 0));
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr));
+
+  sock = create_nonblocking_bound_socket(addr);
   context = create_connection_context(sock, 0);
 
   context->events = UV_READABLE | UV_WRITABLE;
diff --git a/deps/uv/test/test-ref.c b/deps/uv/test/test-ref.c
index 37279ac89a..7bb4277add 100644
--- a/deps/uv/test/test-ref.c
+++ b/deps/uv/test/test-ref.c
@@ -254,10 +254,11 @@ TEST_IMPL(tcp_ref2b) {
 
 
 TEST_IMPL(tcp_ref3) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   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);
@@ -269,10 +270,11 @@ TEST_IMPL(tcp_ref3) {
 
 
 TEST_IMPL(tcp_ref4) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   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);
@@ -296,10 +298,11 @@ TEST_IMPL(udp_ref) {
 
 
 TEST_IMPL(udp_ref2) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   uv_udp_t h;
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   uv_udp_init(uv_default_loop(), &h);
-  uv_udp_bind(&h, addr, 0);
+  uv_udp_bind(&h, &addr, 0);
   uv_udp_recv_start(&h, (uv_alloc_cb)fail_cb, (uv_udp_recv_cb)fail_cb);
   uv_unref((uv_handle_t*)&h);
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -310,13 +313,14 @@ TEST_IMPL(udp_ref2) {
 
 
 TEST_IMPL(udp_ref3) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   uv_buf_t buf = uv_buf_init("PING", 4);
   uv_udp_send_t req;
   uv_udp_t h;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   uv_udp_init(uv_default_loop(), &h);
-  uv_udp_send(&req, &h, &buf, 1, addr, (uv_udp_send_cb)req_cb);
+  uv_udp_send(&req, &h, &buf, 1, &addr, (uv_udp_send_cb)req_cb);
   uv_unref((uv_handle_t*)&h);
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
   ASSERT(req_cb_called == 1);
@@ -399,7 +403,7 @@ TEST_IMPL(process_ref) {
   options.args = argv;
   options.exit_cb = NULL;
 
-  r = uv_spawn(uv_default_loop(), &h, options);
+  r = uv_spawn(uv_default_loop(), &h, &options);
   ASSERT(r == 0);
 
   uv_unref((uv_handle_t*)&h);
diff --git a/deps/uv/test/test-shutdown-close.c b/deps/uv/test/test-shutdown-close.c
index 957fc889bc..ca308572ee 100644
--- a/deps/uv/test/test-shutdown-close.c
+++ b/deps/uv/test/test-shutdown-close.c
@@ -65,13 +65,14 @@ static void connect_cb(uv_connect_t* req, int status) {
 
 
 TEST_IMPL(shutdown_close_tcp) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   uv_tcp_t h;
   int r;
 
+  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/deps/uv/test/test-shutdown-eof.c b/deps/uv/test/test-shutdown-eof.c
index 9c848916b5..92e7312401 100644
--- a/deps/uv/test/test-shutdown-eof.c
+++ b/deps/uv/test/test-shutdown-eof.c
@@ -39,33 +39,31 @@ static int called_timer_close_cb;
 static int called_timer_cb;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
-  uv_buf_t buf;
-  buf.base = (char*)malloc(size);
-  buf.len = size;
-  return buf;
+static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+  buf->base = malloc(size);
+  buf->len = size;
 }
 
 
-static void read_cb(uv_stream_t* t, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) {
   ASSERT((uv_tcp_t*)t == &tcp);
 
   if (nread == 0) {
-    free(buf.base);
+    free(buf->base);
     return;
   }
 
   if (!got_q) {
     ASSERT(nread == 1);
     ASSERT(!got_eof);
-    ASSERT(buf.base[0] == 'Q');
-    free(buf.base);
+    ASSERT(buf->base[0] == 'Q');
+    free(buf->base);
     got_q = 1;
     puts("got Q");
   } else {
     ASSERT(nread == UV_EOF);
-    if (buf.base) {
-      free(buf.base);
+    if (buf->base) {
+      free(buf->base);
     }
     got_eof = 1;
     puts("got EOF");
@@ -158,11 +156,11 @@ TEST_IMPL(shutdown_eof) {
 
   uv_timer_start(&timer, timer_cb, 100, 0);
 
-  server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
   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/deps/uv/test/test-spawn.c b/deps/uv/test/test-spawn.c
index 96cc307aab..97d08d5286 100644
--- a/deps/uv/test/test-spawn.c
+++ b/deps/uv/test/test-spawn.c
@@ -118,15 +118,15 @@ static void detach_failure_cb(uv_process_t* process, int64_t exit_status, int te
   exit_cb_called++;
 }
 
-static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
-  uv_buf_t buf;
-  buf.base = output + output_used;
-  buf.len = OUTPUT_SIZE - output_used;
-  return buf;
+static void on_alloc(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
+  buf->base = output + output_used;
+  buf->len = OUTPUT_SIZE - output_used;
 }
 
 
-static void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
   if (nread > 0) {
     output_used += nread;
   } else if (nread < 0) {
@@ -166,7 +166,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
 TEST_IMPL(spawn_fails) {
   init_process_options("", exit_cb_expect_enoent);
   options.file = options.args[0] = "program-that-had-better-not-exist";
-  ASSERT(0 == uv_spawn(uv_default_loop(), &process, options));
+  ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options));
   ASSERT(0 != uv_is_active((uv_handle_t*)&process));
   ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
   ASSERT(1 == exit_cb_called);
@@ -181,7 +181,7 @@ TEST_IMPL(spawn_exit_code) {
 
   init_process_options("spawn_helper1", exit_cb);
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -209,7 +209,7 @@ TEST_IMPL(spawn_stdout) {
   options.stdio[1].data.stream = (uv_stream_t*)&out;
   options.stdio_count = 2;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@@ -252,7 +252,7 @@ TEST_IMPL(spawn_stdout_to_file) {
   options.stdio[1].data.fd = file;
   options.stdio_count = 2;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -301,7 +301,7 @@ TEST_IMPL(spawn_stdin) {
   options.stdio[1].data.stream = (uv_stream_t*)&out;
   options.stdio_count = 2;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   buf.base = buffer;
@@ -340,7 +340,7 @@ TEST_IMPL(spawn_stdio_greater_than_3) {
   options.stdio[3].data.stream = (uv_stream_t*)&pipe;
   options.stdio_count = 4;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_read_start((uv_stream_t*) &pipe, on_alloc, on_read);
@@ -367,7 +367,7 @@ TEST_IMPL(spawn_ignored_stdio) {
   options.stdio = NULL;
   options.stdio_count = 0;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -386,7 +386,7 @@ TEST_IMPL(spawn_and_kill) {
 
   init_process_options("spawn_helper4", kill_cb);
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_timer_init(uv_default_loop(), &timer);
@@ -426,7 +426,7 @@ TEST_IMPL(spawn_preserve_env) {
   /* Explicitly set options.env to NULL to test for env clobbering. */
   options.env = NULL;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@@ -453,7 +453,7 @@ TEST_IMPL(spawn_detached) {
 
   options.flags |= UV_PROCESS_DETACHED;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   uv_unref((uv_handle_t*)&process);
@@ -502,7 +502,7 @@ TEST_IMPL(spawn_and_kill_with_std) {
   options.stdio[2].data.stream = (uv_stream_t*)&err;
   options.stdio_count = 3;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   buf = uv_buf_init(message, sizeof message);
@@ -551,7 +551,7 @@ TEST_IMPL(spawn_and_ping) {
   options.stdio[1].data.stream = (uv_stream_t*)&out;
   options.stdio_count = 2;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   /* Sending signum == 0 should check if the
@@ -588,7 +588,7 @@ TEST_IMPL(kill) {
 
   init_process_options("spawn_helper4", kill_cb);
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   /* Sending signum == 0 should check if the
@@ -641,7 +641,7 @@ TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) {
                                 NULL);
   ASSERT(pipe_handle != INVALID_HANDLE_VALUE);
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@@ -806,7 +806,7 @@ TEST_IMPL(spawn_setuid_setgid) {
   options.gid = pw->pw_gid;
   options.flags = UV_PROCESS_SETUID | UV_PROCESS_SETGID;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -840,7 +840,7 @@ TEST_IMPL(spawn_setuid_fails) {
   options.flags |= UV_PROCESS_SETUID;
   options.uid = 0;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -872,7 +872,7 @@ TEST_IMPL(spawn_setgid_fails) {
   options.flags |= UV_PROCESS_SETGID;
   options.gid = 0;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == 0);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -904,7 +904,7 @@ TEST_IMPL(spawn_setuid_fails) {
   options.flags |= UV_PROCESS_SETUID;
   options.uid = (uv_uid_t) -42424242;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == UV_ENOTSUP);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -925,7 +925,7 @@ TEST_IMPL(spawn_setgid_fails) {
   options.flags |= UV_PROCESS_SETGID;
   options.gid = (uv_gid_t) -42424242;
 
-  r = uv_spawn(uv_default_loop(), &process, options);
+  r = uv_spawn(uv_default_loop(), &process, &options);
   ASSERT(r == UV_ENOTSUP);
 
   r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -941,7 +941,7 @@ TEST_IMPL(spawn_setgid_fails) {
 
 TEST_IMPL(spawn_auto_unref) {
   init_process_options("spawn_helper1", NULL);
-  ASSERT(0 == uv_spawn(uv_default_loop(), &process, options));
+  ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options));
   ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
   ASSERT(0 == uv_is_closing((uv_handle_t*) &process));
   uv_close((uv_handle_t*) &process, NULL);
diff --git a/deps/uv/test/test-stdio-over-pipes.c b/deps/uv/test/test-stdio-over-pipes.c
index 1d6191e771..5f2226cd08 100644
--- a/deps/uv/test/test-stdio-over-pipes.c
+++ b/deps/uv/test/test-stdio-over-pipes.c
@@ -74,8 +74,11 @@ static void init_process_options(char* test, uv_exit_cb exit_cb) {
 }
 
 
-static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
-  return uv_buf_init(output + output_used, OUTPUT_SIZE - output_used);
+static void on_alloc(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
+  buf->base = output + output_used;
+  buf->len = OUTPUT_SIZE - output_used;
 }
 
 
@@ -92,7 +95,7 @@ static void after_write(uv_write_t* req, int status) {
 }
 
 
-static void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t rdbuf) {
+static void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* rdbuf) {
   uv_write_t* req;
   uv_buf_t wrbuf;
   int r;
@@ -133,7 +136,7 @@ TEST_IMPL(stdio_over_pipes) {
   options.stdio[1].data.stream = (uv_stream_t*)&out;
   options.stdio_count = 2;
 
-  r = uv_spawn(loop, &process, options);
+  r = uv_spawn(loop, &process, &options);
   ASSERT(r == 0);
 
   r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@@ -161,12 +164,12 @@ static int after_write_called;
 static uv_pipe_t stdin_pipe;
 static uv_pipe_t stdout_pipe;
 
-static void on_pipe_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void on_pipe_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
   ASSERT(nread > 0);
-  ASSERT(memcmp("hello world\n", buf.base, nread) == 0);
+  ASSERT(memcmp("hello world\n", buf->base, nread) == 0);
   on_pipe_read_called++;
 
-  free(buf.base);
+  free(buf->base);
 
   uv_close((uv_handle_t*)&stdin_pipe, close_cb);
   uv_close((uv_handle_t*)&stdout_pipe, close_cb);
@@ -179,8 +182,11 @@ static void after_pipe_write(uv_write_t* req, int status) {
 }
 
 
-static uv_buf_t on_read_alloc(uv_handle_t* handle, size_t suggested_size) {
-  return uv_buf_init(malloc(suggested_size), suggested_size);
+static void on_read_alloc(uv_handle_t* handle,
+                          size_t suggested_size,
+                          uv_buf_t* buf) {
+  buf->base = malloc(suggested_size);
+  buf->len = suggested_size;
 }
 
 
@@ -236,8 +242,7 @@ int stdio_over_pipes_helper(void) {
   uv_ref((uv_handle_t*)&stdout_pipe);
   uv_ref((uv_handle_t*)&stdin_pipe);
 
-  r = uv_read_start((uv_stream_t*)&stdin_pipe, on_read_alloc,
-    on_pipe_read);
+  r = uv_read_start((uv_stream_t*)&stdin_pipe, on_read_alloc, on_pipe_read);
   ASSERT(r == 0);
 
   uv_run(loop, UV_RUN_DEFAULT);
diff --git a/deps/uv/test/test-tcp-bind-error.c b/deps/uv/test/test-tcp-bind-error.c
index 2b2106ed5e..306372a779 100644
--- a/deps/uv/test/test-tcp-bind-error.c
+++ b/deps/uv/test/test-tcp-bind-error.c
@@ -35,18 +35,19 @@ static void close_cb(uv_handle_t* handle) {
 
 
 TEST_IMPL(tcp_bind_error_addrinuse) {
-  struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
+  struct sockaddr_in addr;
   uv_tcp_t server1, server2;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
   r = uv_tcp_init(uv_default_loop(), &server1);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&server1, addr);
+  r = uv_tcp_bind(&server1, &addr);
   ASSERT(r == 0);
 
   r = uv_tcp_init(uv_default_loop(), &server2);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&server2, addr);
+  r = uv_tcp_bind(&server2, &addr);
   ASSERT(r == 0);
 
   r = uv_listen((uv_stream_t*)&server1, 128, NULL);
@@ -67,15 +68,17 @@ TEST_IMPL(tcp_bind_error_addrinuse) {
 
 
 TEST_IMPL(tcp_bind_error_addrnotavail_1) {
-  struct sockaddr_in addr = uv_ip4_addr("127.255.255.255", TEST_PORT);
+  struct sockaddr_in addr;
   uv_tcp_t server;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.255.255.255", TEST_PORT, &addr));
+
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
 
   /* It seems that Linux is broken here - bind succeeds. */
-  r = uv_tcp_bind(&server, addr);
+  r = uv_tcp_bind(&server, &addr);
   ASSERT(r == 0 || r == UV_EADDRNOTAVAIL);
 
   uv_close((uv_handle_t*)&server, close_cb);
@@ -90,13 +93,15 @@ TEST_IMPL(tcp_bind_error_addrnotavail_1) {
 
 
 TEST_IMPL(tcp_bind_error_addrnotavail_2) {
-  struct sockaddr_in addr = uv_ip4_addr("4.4.4.4", TEST_PORT);
+  struct sockaddr_in addr;
   uv_tcp_t server;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("4.4.4.4", TEST_PORT, &addr));
+
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&server, addr);
+  r = uv_tcp_bind(&server, &addr);
   ASSERT(r == UV_EADDRNOTAVAIL);
 
   uv_close((uv_handle_t*)&server, close_cb);
@@ -120,7 +125,7 @@ TEST_IMPL(tcp_bind_error_fault) {
 
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&server, *garbage_addr);
+  r = uv_tcp_bind(&server, garbage_addr);
   ASSERT(r == UV_EINVAL);
 
   uv_close((uv_handle_t*)&server, close_cb);
@@ -136,16 +141,19 @@ TEST_IMPL(tcp_bind_error_fault) {
 /* Notes: On Linux uv_bind(server, NULL) will segfault the program.  */
 
 TEST_IMPL(tcp_bind_error_inval) {
-  struct sockaddr_in addr1 = uv_ip4_addr("0.0.0.0", TEST_PORT);
-  struct sockaddr_in addr2 = uv_ip4_addr("0.0.0.0", TEST_PORT_2);
+  struct sockaddr_in addr1;
+  struct sockaddr_in addr2;
   uv_tcp_t server;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr1));
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT_2, &addr2));
+
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&server, addr1);
+  r = uv_tcp_bind(&server, &addr1);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&server, addr2);
+  r = uv_tcp_bind(&server, &addr2);
   ASSERT(r == UV_EINVAL);
 
   uv_close((uv_handle_t*)&server, close_cb);
@@ -160,14 +168,15 @@ TEST_IMPL(tcp_bind_error_inval) {
 
 
 TEST_IMPL(tcp_bind_localhost_ok) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
-
+  struct sockaddr_in addr;
   uv_tcp_t server;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&server, addr);
+  r = uv_tcp_bind(&server, &addr);
   ASSERT(r == 0);
 
   MAKE_VALGRIND_HAPPY();
diff --git a/deps/uv/test/test-tcp-bind6-error.c b/deps/uv/test/test-tcp-bind6-error.c
index 46e147b89c..e92afef7e4 100644
--- a/deps/uv/test/test-tcp-bind6-error.c
+++ b/deps/uv/test/test-tcp-bind6-error.c
@@ -35,18 +35,20 @@ static void close_cb(uv_handle_t* handle) {
 
 
 TEST_IMPL(tcp_bind6_error_addrinuse) {
-  struct sockaddr_in6 addr = uv_ip6_addr("::", TEST_PORT);
+  struct sockaddr_in6 addr;
   uv_tcp_t server1, server2;
   int r;
 
+  ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr));
+
   r = uv_tcp_init(uv_default_loop(), &server1);
   ASSERT(r == 0);
-  r = uv_tcp_bind6(&server1, addr);
+  r = uv_tcp_bind6(&server1, &addr);
   ASSERT(r == 0);
 
   r = uv_tcp_init(uv_default_loop(), &server2);
   ASSERT(r == 0);
-  r = uv_tcp_bind6(&server2, addr);
+  r = uv_tcp_bind6(&server2, &addr);
   ASSERT(r == 0);
 
   r = uv_listen((uv_stream_t*)&server1, 128, NULL);
@@ -67,13 +69,15 @@ TEST_IMPL(tcp_bind6_error_addrinuse) {
 
 
 TEST_IMPL(tcp_bind6_error_addrnotavail) {
-  struct sockaddr_in6 addr = uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT);
+  struct sockaddr_in6 addr;
   uv_tcp_t server;
   int r;
 
+  ASSERT(0 == uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT, &addr));
+
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_bind6(&server, addr);
+  r = uv_tcp_bind6(&server, &addr);
   ASSERT(r == UV_EADDRNOTAVAIL);
 
   uv_close((uv_handle_t*)&server, close_cb);
@@ -97,7 +101,7 @@ TEST_IMPL(tcp_bind6_error_fault) {
 
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_bind6(&server, *garbage_addr);
+  r = uv_tcp_bind6(&server, garbage_addr);
   ASSERT(r == UV_EINVAL);
 
   uv_close((uv_handle_t*)&server, close_cb);
@@ -113,16 +117,19 @@ TEST_IMPL(tcp_bind6_error_fault) {
 /* Notes: On Linux uv_bind6(server, NULL) will segfault the program.  */
 
 TEST_IMPL(tcp_bind6_error_inval) {
-  struct sockaddr_in6 addr1 = uv_ip6_addr("::", TEST_PORT);
-  struct sockaddr_in6 addr2 = uv_ip6_addr("::", TEST_PORT_2);
+  struct sockaddr_in6 addr1;
+  struct sockaddr_in6 addr2;
   uv_tcp_t server;
   int r;
 
+  ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr1));
+  ASSERT(0 == uv_ip6_addr("::", TEST_PORT_2, &addr2));
+
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_bind6(&server, addr1);
+  r = uv_tcp_bind6(&server, &addr1);
   ASSERT(r == 0);
-  r = uv_tcp_bind6(&server, addr2);
+  r = uv_tcp_bind6(&server, &addr2);
   ASSERT(r == UV_EINVAL);
 
   uv_close((uv_handle_t*)&server, close_cb);
@@ -137,14 +144,15 @@ TEST_IMPL(tcp_bind6_error_inval) {
 
 
 TEST_IMPL(tcp_bind6_localhost_ok) {
-  struct sockaddr_in6 addr = uv_ip6_addr("::1", TEST_PORT);
-
+  struct sockaddr_in6 addr;
   uv_tcp_t server;
   int r;
 
+  ASSERT(0 == uv_ip6_addr("::1", TEST_PORT, &addr));
+
   r = uv_tcp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
-  r = uv_tcp_bind6(&server, addr);
+  r = uv_tcp_bind6(&server, &addr);
   ASSERT(r == 0);
 
   MAKE_VALGRIND_HAPPY();
diff --git a/deps/uv/test/test-tcp-close-while-connecting.c b/deps/uv/test/test-tcp-close-while-connecting.c
index d3d12fd09e..9e83552683 100644
--- a/deps/uv/test/test-tcp-close-while-connecting.c
+++ b/deps/uv/test/test-tcp-close-while-connecting.c
@@ -60,11 +60,10 @@ TEST_IMPL(tcp_close_while_connecting) {
   struct sockaddr_in addr;
   uv_loop_t* loop;
 
-  addr = uv_ip4_addr("1.2.3.4", TEST_PORT);
   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/deps/uv/test/test-tcp-close.c b/deps/uv/test/test-tcp-close.c
index 5902932641..183e9af0e8 100644
--- a/deps/uv/test/test-tcp-close.c
+++ b/deps/uv/test/test-tcp-close.c
@@ -77,12 +77,15 @@ static void connection_cb(uv_stream_t* server, int status) {
 
 
 static void start_server(uv_loop_t* loop, uv_tcp_t* handle) {
+  struct sockaddr_in addr;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
   r = uv_tcp_init(loop, handle);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(handle, uv_ip4_addr("127.0.0.1", TEST_PORT));
+  r = uv_tcp_bind(handle, &addr);
   ASSERT(r == 0);
 
   r = uv_listen((uv_stream_t*)handle, 128, connection_cb);
@@ -96,10 +99,13 @@ static void start_server(uv_loop_t* loop, uv_tcp_t* handle) {
  * invoked when the handle is closed.
  */
 TEST_IMPL(tcp_close) {
-  uv_loop_t* loop;
+  struct sockaddr_in addr;
   uv_tcp_t tcp_server;
+  uv_loop_t* loop;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
   loop = uv_default_loop();
 
   /* We can't use the echo server, it doesn't handle ECONNRESET. */
@@ -108,10 +114,7 @@ TEST_IMPL(tcp_close) {
   r = uv_tcp_init(loop, &tcp_handle);
   ASSERT(r == 0);
 
-  r = uv_tcp_connect(&connect_req,
-                     &tcp_handle,
-                     uv_ip4_addr("127.0.0.1", TEST_PORT),
-                     connect_cb);
+  r = uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb);
   ASSERT(r == 0);
 
   ASSERT(write_cb_called == 0);
diff --git a/deps/uv/test/test-tcp-connect-error-after-write.c b/deps/uv/test/test-tcp-connect-error-after-write.c
index 4c8fdc2c83..b437bf3b37 100644
--- a/deps/uv/test/test-tcp-connect-error-after-write.c
+++ b/deps/uv/test/test-tcp-connect-error-after-write.c
@@ -68,7 +68,7 @@ TEST_IMPL(tcp_connect_error_after_write) {
   return 0; /* windows slackers... */
 #endif
 
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   buf = uv_buf_init("TEST", 4);
 
   r = uv_tcp_init(uv_default_loop(), &conn);
@@ -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/deps/uv/test/test-tcp-connect-error.c b/deps/uv/test/test-tcp-connect-error.c
index 836e62f7e5..278548ab2c 100644
--- a/deps/uv/test/test-tcp-connect-error.c
+++ b/deps/uv/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/deps/uv/test/test-tcp-connect-timeout.c b/deps/uv/test/test-tcp-connect-timeout.c
index 8be4c642cc..a14a89de39 100644
--- a/deps/uv/test/test-tcp-connect-timeout.c
+++ b/deps/uv/test/test-tcp-connect-timeout.c
@@ -64,7 +64,7 @@ TEST_IMPL(tcp_connect_timeout) {
   struct sockaddr_in addr;
   int r;
 
-  addr = uv_ip4_addr("8.8.8.8", 9999);
+  ASSERT(0 == uv_ip4_addr("8.8.8.8", 9999, &addr));
 
   r = uv_timer_init(uv_default_loop(), &timer);
   ASSERT(r == 0);
@@ -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/deps/uv/test/test-tcp-connect6-error.c b/deps/uv/test/test-tcp-connect6-error.c
index ad5d2e49ea..c0e8262e89 100644
--- a/deps/uv/test/test-tcp-connect6-error.c
+++ b/deps/uv/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/deps/uv/test/test-tcp-open.c b/deps/uv/test/test-tcp-open.c
index cd69035b80..ddf8d50037 100644
--- a/deps/uv/test/test-tcp-open.c
+++ b/deps/uv/test/test-tcp-open.c
@@ -71,10 +71,13 @@ static uv_os_sock_t create_tcp_socket(void) {
 }
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[65536];
-  ASSERT(suggested_size <= sizeof slab);
-  return uv_buf_init(slab, sizeof slab);
+  ASSERT(suggested_size <= sizeof(slab));
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
@@ -93,12 +96,12 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
 }
 
 
-static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
   ASSERT(tcp != NULL);
 
   if (nread >= 0) {
     ASSERT(nread == 4);
-    ASSERT(memcmp("PING", buf.base, nread) == 0);
+    ASSERT(memcmp("PING", buf->base, nread) == 0);
   }
   else {
     ASSERT(nread == UV_EOF);
@@ -145,11 +148,13 @@ static void connect_cb(uv_connect_t* req, int status) {
 
 
 TEST_IMPL(tcp_open) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   uv_tcp_t client;
   uv_os_sock_t sock;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
   startup();
   sock = create_tcp_socket();
 
@@ -159,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/deps/uv/test/test-tcp-read-stop.c b/deps/uv/test/test-tcp-read-stop.c
index cc6dd2eaef..3dc9d87d98 100644
--- a/deps/uv/test/test-tcp-read-stop.c
+++ b/deps/uv/test/test-tcp-read-stop.c
@@ -62,10 +62,10 @@ TEST_IMPL(tcp_read_stop) {
   uv_connect_t connect_req;
   struct sockaddr_in addr;
 
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  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/deps/uv/test/test-tcp-shutdown-after-write.c b/deps/uv/test/test-tcp-shutdown-after-write.c
index a2e9e0f543..de6f5575c1 100644
--- a/deps/uv/test/test-tcp-shutdown-after-write.c
+++ b/deps/uv/test/test-tcp-shutdown-after-write.c
@@ -49,9 +49,12 @@ static void close_cb(uv_handle_t* handle) {
 }
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[64];
-  return uv_buf_init(slab, sizeof(slab));
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
@@ -70,7 +73,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
 }
 
 
-static void read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
 }
 
 
@@ -103,7 +106,7 @@ TEST_IMPL(tcp_shutdown_after_write) {
   uv_loop_t* loop;
   int r;
 
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   loop = uv_default_loop();
 
   r = uv_timer_init(loop, &timer);
@@ -115,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/deps/uv/test/test-tcp-unexpected-read.c b/deps/uv/test/test-tcp-unexpected-read.c
index e8fc53c34e..14fd6826bb 100644
--- a/deps/uv/test/test-tcp-unexpected-read.c
+++ b/deps/uv/test/test-tcp-unexpected-read.c
@@ -47,14 +47,14 @@ static void timer_cb(uv_timer_t* handle, int status) {
 }
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   ASSERT(0 && "alloc_cb should not have been called");
-  /* Satisfy the compiler. */
-  return uv_buf_init(NULL, 0);
 }
 
 
-static void read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
   ASSERT(0 && "read_cb should not have been called");
 }
 
@@ -88,7 +88,7 @@ TEST_IMPL(tcp_unexpected_read) {
   struct sockaddr_in addr;
   uv_loop_t* loop;
 
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
   loop = uv_default_loop();
 
   ASSERT(0 == uv_timer_init(loop, &timer_handle));
@@ -98,9 +98,9 @@ TEST_IMPL(tcp_unexpected_read) {
   ASSERT(0 == uv_tcp_init(loop, &server_handle));
   ASSERT(0 == uv_tcp_init(loop, &client_handle));
   ASSERT(0 == uv_tcp_init(loop, &peer_handle));
-  ASSERT(0 == uv_tcp_bind(&server_handle, addr));
+  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/deps/uv/test/test-tcp-write-to-half-open-connection.c b/deps/uv/test/test-tcp-write-to-half-open-connection.c
index e3557bc807..b33deee6fa 100644
--- a/deps/uv/test/test-tcp-write-to-half-open-connection.c
+++ b/deps/uv/test/test-tcp-write-to-half-open-connection.c
@@ -29,8 +29,8 @@
 static void connection_cb(uv_stream_t* server, int status);
 static void connect_cb(uv_connect_t* req, int status);
 static void write_cb(uv_write_t* req, int status);
-static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf);
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size);
+static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
+static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);
 
 static uv_tcp_t tcp_server;
 static uv_tcp_t tcp_client;
@@ -65,13 +65,16 @@ static void connection_cb(uv_stream_t* server, int status) {
 }
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[1024];
-  return uv_buf_init(slab, sizeof slab);
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
-static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
   if (nread < 0) {
     fprintf(stderr, "read_cb error: %s\n", uv_err_name(nread));
     ASSERT(nread == UV_ECONNRESET || nread == UV_EOF);
@@ -100,16 +103,19 @@ static void write_cb(uv_write_t* req, int status) {
 
 
 TEST_IMPL(tcp_write_to_half_open_connection) {
+  struct sockaddr_in addr;
   uv_loop_t* loop;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
   loop = uv_default_loop();
   ASSERT(loop != NULL);
 
   r = uv_tcp_init(loop, &tcp_server);
   ASSERT(r == 0);
 
-  r = uv_tcp_bind(&tcp_server, uv_ip4_addr("127.0.0.1", TEST_PORT));
+  r = uv_tcp_bind(&tcp_server, &addr);
   ASSERT(r == 0);
 
   r = uv_listen((uv_stream_t*)&tcp_server, 1, connection_cb);
@@ -118,10 +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,
-                     uv_ip4_addr("127.0.0.1", TEST_PORT),
-                     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/deps/uv/test/test-tcp-writealot.c b/deps/uv/test/test-tcp-writealot.c
index e83aeb9b08..88f499b59e 100644
--- a/deps/uv/test/test-tcp-writealot.c
+++ b/deps/uv/test/test-tcp-writealot.c
@@ -46,8 +46,9 @@ static uv_shutdown_t shutdown_req;
 static uv_write_t write_reqs[WRITES];
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
-  return uv_buf_init(malloc(size), size);
+static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+  buf->base = malloc(size);
+  buf->len = size;
 }
 
 
@@ -76,7 +77,7 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
 }
 
 
-static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
   ASSERT(tcp != NULL);
 
   if (nread >= 0) {
@@ -88,7 +89,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
     uv_close((uv_handle_t*)tcp, close_cb);
   }
 
-  free(buf.base);
+  free(buf->base);
 }
 
 
@@ -140,17 +141,19 @@ static void connect_cb(uv_connect_t* req, int status) {
 
 
 TEST_IMPL(tcp_writealot) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   uv_tcp_t client;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
   send_buffer = calloc(1, TOTAL_BYTES);
   ASSERT(send_buffer != NULL);
 
   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);
diff --git a/deps/uv/test/test-udp-dgram-too-big.c b/deps/uv/test/test-udp-dgram-too-big.c
index bb8cc6b09a..ecbafa96fc 100644
--- a/deps/uv/test/test-udp-dgram-too-big.c
+++ b/deps/uv/test/test-udp-dgram-too-big.c
@@ -68,9 +68,9 @@ TEST_IMPL(udp_dgram_too_big) {
   ASSERT(r == 0);
 
   buf = uv_buf_init(dgram, sizeof dgram);
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
-  r = uv_udp_send(&req_, &handle_, &buf, 1, addr, send_cb);
+  r = uv_udp_send(&req_, &handle_, &buf, 1, &addr, send_cb);
   ASSERT(r == 0);
 
   ASSERT(close_cb_called == 0);
diff --git a/deps/uv/test/test-udp-ipv6.c b/deps/uv/test/test-udp-ipv6.c
index 247fe8bf95..f545f81b1f 100644
--- a/deps/uv/test/test-udp-ipv6.c
+++ b/deps/uv/test/test-udp-ipv6.c
@@ -44,10 +44,13 @@ static int recv_cb_called;
 static int close_cb_called;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[65536];
   CHECK_HANDLE(handle);
-  return uv_buf_init(slab, sizeof slab);
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
@@ -67,8 +70,8 @@ static void send_cb(uv_udp_send_t* req, int status) {
 
 static void ipv6_recv_fail(uv_udp_t* handle,
                            ssize_t nread,
-                           uv_buf_t buf,
-                           struct sockaddr* addr,
+                           const uv_buf_t* buf,
+                           const struct sockaddr* addr,
                            unsigned flags) {
   ASSERT(0 && "this function should not have been called");
 }
@@ -76,8 +79,8 @@ static void ipv6_recv_fail(uv_udp_t* handle,
 
 static void ipv6_recv_ok(uv_udp_t* handle,
                          ssize_t nread,
-                         uv_buf_t buf,
-                         struct sockaddr* addr,
+                         const uv_buf_t* buf,
+                         const struct sockaddr* addr,
                          unsigned flags) {
   CHECK_HANDLE(handle);
   ASSERT(nread >= 0);
@@ -100,12 +103,12 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
   uv_buf_t buf;
   int r;
 
-  addr6 = uv_ip6_addr("::0", TEST_PORT);
+  ASSERT(0 == uv_ip6_addr("::0", TEST_PORT, &addr6));
 
   r = uv_udp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
 
-  r = uv_udp_bind6(&server, addr6, bind_flags);
+  r = uv_udp_bind6(&server, &addr6, bind_flags);
   ASSERT(r == 0);
 
   r = uv_udp_recv_start(&server, alloc_cb, recv_cb);
@@ -115,9 +118,9 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
   ASSERT(r == 0);
 
   buf = uv_buf_init("PING", 4);
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
-  r = uv_udp_send(&req_, &client, &buf, 1, addr, send_cb);
+  r = uv_udp_send(&req_, &client, &buf, 1, &addr, send_cb);
   ASSERT(r == 0);
 
   r = uv_timer_init(uv_default_loop(), &timeout);
diff --git a/deps/uv/test/test-udp-multicast-join.c b/deps/uv/test/test-udp-multicast-join.c
index 83ec46b8d1..0e750d840f 100644
--- a/deps/uv/test/test-udp-multicast-join.c
+++ b/deps/uv/test/test-udp-multicast-join.c
@@ -38,13 +38,14 @@ static int sv_send_cb_called;
 
 static int close_cb_called;
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[65536];
-
   CHECK_HANDLE(handle);
-  ASSERT(suggested_size <= sizeof slab);
-
-  return uv_buf_init(slab, sizeof slab);
+  ASSERT(suggested_size <= sizeof(slab));
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
@@ -67,8 +68,8 @@ static void sv_send_cb(uv_udp_send_t* req, int status) {
 
 static void cl_recv_cb(uv_udp_t* handle,
                        ssize_t nread,
-                       uv_buf_t buf,
-                       struct sockaddr* addr,
+                       const uv_buf_t* buf,
+                       const struct sockaddr* addr,
                        unsigned flags) {
   CHECK_HANDLE(handle);
   ASSERT(flags == 0);
@@ -88,7 +89,7 @@ static void cl_recv_cb(uv_udp_t* handle,
 
   ASSERT(addr != NULL);
   ASSERT(nread == 4);
-  ASSERT(!memcmp("PING", buf.base, nread));
+  ASSERT(!memcmp("PING", buf->base, nread));
 
   /* we are done with the client handle, we can close it */
   uv_close((uv_handle_t*) &client, close_cb);
@@ -99,7 +100,9 @@ TEST_IMPL(udp_multicast_join) {
   int r;
   uv_udp_send_t req;
   uv_buf_t buf;
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
+
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
   r = uv_udp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
@@ -108,7 +111,7 @@ TEST_IMPL(udp_multicast_join) {
   ASSERT(r == 0);
 
   /* bind to the desired port */
-  r = uv_udp_bind(&client, addr, 0);
+  r = uv_udp_bind(&client, &addr, 0);
   ASSERT(r == 0);
 
   /* join the multicast channel */
@@ -121,7 +124,7 @@ TEST_IMPL(udp_multicast_join) {
   buf = uv_buf_init("PING", 4);
 
   /* server sends "PING" */
-  r = uv_udp_send(&req, &server, &buf, 1, addr, sv_send_cb);
+  r = uv_udp_send(&req, &server, &buf, 1, &addr, sv_send_cb);
   ASSERT(r == 0);
 
   ASSERT(close_cb_called == 0);
diff --git a/deps/uv/test/test-udp-multicast-ttl.c b/deps/uv/test/test-udp-multicast-ttl.c
index 6d36983673..390ea579f1 100644
--- a/deps/uv/test/test-udp-multicast-ttl.c
+++ b/deps/uv/test/test-udp-multicast-ttl.c
@@ -57,12 +57,13 @@ TEST_IMPL(udp_multicast_ttl) {
   int r;
   uv_udp_send_t req;
   uv_buf_t buf;
-  struct sockaddr_in addr = uv_ip4_addr("239.255.0.1", TEST_PORT);
+  struct sockaddr_in addr;
 
   r = uv_udp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
 
-  r = uv_udp_bind(&server, uv_ip4_addr("0.0.0.0", 0), 0);
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr));
+  r = uv_udp_bind(&server, &addr, 0);
   ASSERT(r == 0);
 
   r = uv_udp_set_multicast_ttl(&server, 32);
@@ -70,7 +71,8 @@ TEST_IMPL(udp_multicast_ttl) {
 
   /* server sends "PING" */
   buf = uv_buf_init("PING", 4);
-  r = uv_udp_send(&req, &server, &buf, 1, addr, sv_send_cb);
+  ASSERT(0 == uv_ip4_addr("239.255.0.1", TEST_PORT, &addr));
+  r = uv_udp_send(&req, &server, &buf, 1, &addr, sv_send_cb);
   ASSERT(r == 0);
 
   ASSERT(close_cb_called == 0);
diff --git a/deps/uv/test/test-udp-open.c b/deps/uv/test/test-udp-open.c
index 5d27bdc0b3..3d64b00f73 100644
--- a/deps/uv/test/test-udp-open.c
+++ b/deps/uv/test/test-udp-open.c
@@ -67,10 +67,13 @@ static uv_os_sock_t create_udp_socket(void) {
 }
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[65536];
-  ASSERT(suggested_size <= sizeof slab);
-  return uv_buf_init(slab, sizeof slab);
+  ASSERT(suggested_size <= sizeof(slab));
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
@@ -82,8 +85,8 @@ static void close_cb(uv_handle_t* handle) {
 
 static void recv_cb(uv_udp_t* handle,
                        ssize_t nread,
-                       uv_buf_t buf,
-                       struct sockaddr* addr,
+                       const uv_buf_t* buf,
+                       const struct sockaddr* addr,
                        unsigned flags) {
   int r;
 
@@ -102,7 +105,7 @@ static void recv_cb(uv_udp_t* handle,
 
   ASSERT(addr != NULL);
   ASSERT(nread == 4);
-  ASSERT(memcmp("PING", buf.base, nread) == 0);
+  ASSERT(memcmp("PING", buf->base, nread) == 0);
 
   r = uv_udp_recv_stop(handle);
   ASSERT(r == 0);
@@ -120,12 +123,14 @@ static void send_cb(uv_udp_send_t* req, int status) {
 
 
 TEST_IMPL(udp_open) {
-  struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  struct sockaddr_in addr;
   uv_buf_t buf = uv_buf_init("PING", 4);
   uv_udp_t client;
   uv_os_sock_t sock;
   int r;
 
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
+
   startup();
   sock = create_udp_socket();
 
@@ -135,13 +140,13 @@ TEST_IMPL(udp_open) {
   r = uv_udp_open(&client, sock);
   ASSERT(r == 0);
 
-  r = uv_udp_bind(&client, addr, 0);
+  r = uv_udp_bind(&client, &addr, 0);
   ASSERT(r == 0);
 
   r = uv_udp_recv_start(&client, alloc_cb, recv_cb);
   ASSERT(r == 0);
 
-  r = uv_udp_send(&send_req, &client, &buf, 1, addr, send_cb);
+  r = uv_udp_send(&send_req, &client, &buf, 1, &addr, send_cb);
   ASSERT(r == 0);
 
   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
diff --git a/deps/uv/test/test-udp-options.c b/deps/uv/test/test-udp-options.c
index 610892f056..af90a57518 100644
--- a/deps/uv/test/test-udp-options.c
+++ b/deps/uv/test/test-udp-options.c
@@ -29,10 +29,13 @@
 
 TEST_IMPL(udp_options) {
   static int invalid_ttls[] = { -1, 0, 256 };
+  struct sockaddr_in addr;
   uv_loop_t* loop;
   uv_udp_t h;
   int i, r;
 
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
+
   loop = uv_default_loop();
 
   r = uv_udp_init(loop, &h);
@@ -40,7 +43,7 @@ TEST_IMPL(udp_options) {
 
   uv_unref((uv_handle_t*)&h); /* don't keep the loop alive */
 
-  r = uv_udp_bind(&h, uv_ip4_addr("0.0.0.0", TEST_PORT), 0);
+  r = uv_udp_bind(&h, &addr, 0);
   ASSERT(r == 0);
 
   r = uv_udp_set_broadcast(&h, 1);
diff --git a/deps/uv/test/test-udp-send-and-recv.c b/deps/uv/test/test-udp-send-and-recv.c
index 1ffa6aa88a..d8da37b7bb 100644
--- a/deps/uv/test/test-udp-send-and-recv.c
+++ b/deps/uv/test/test-udp-send-and-recv.c
@@ -41,13 +41,14 @@ static int sv_recv_cb_called;
 static int close_cb_called;
 
 
-static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
+static void alloc_cb(uv_handle_t* handle,
+                     size_t suggested_size,
+                     uv_buf_t* buf) {
   static char slab[65536];
-
   CHECK_HANDLE(handle);
-  ASSERT(suggested_size <= sizeof slab);
-
-  return uv_buf_init(slab, sizeof slab);
+  ASSERT(suggested_size <= sizeof(slab));
+  buf->base = slab;
+  buf->len = sizeof(slab);
 }
 
 
@@ -60,8 +61,8 @@ static void close_cb(uv_handle_t* handle) {
 
 static void cl_recv_cb(uv_udp_t* handle,
                        ssize_t nread,
-                       uv_buf_t buf,
-                       struct sockaddr* addr,
+                       const uv_buf_t* buf,
+                       const struct sockaddr* addr,
                        unsigned flags) {
   CHECK_HANDLE(handle);
   ASSERT(flags == 0);
@@ -79,7 +80,7 @@ static void cl_recv_cb(uv_udp_t* handle,
 
   ASSERT(addr != NULL);
   ASSERT(nread == 4);
-  ASSERT(!memcmp("PONG", buf.base, nread));
+  ASSERT(!memcmp("PONG", buf->base, nread));
 
   cl_recv_cb_called++;
 
@@ -115,10 +116,11 @@ static void sv_send_cb(uv_udp_send_t* req, int status) {
 
 static void sv_recv_cb(uv_udp_t* handle,
                        ssize_t nread,
-                       uv_buf_t buf,
-                       struct sockaddr* addr,
+                       const uv_buf_t* rcvbuf,
+                       const struct sockaddr* addr,
                        unsigned flags) {
   uv_udp_send_t* req;
+  uv_buf_t sndbuf;
   int r;
 
   if (nread < 0) {
@@ -137,7 +139,7 @@ static void sv_recv_cb(uv_udp_t* handle,
 
   ASSERT(addr != NULL);
   ASSERT(nread == 4);
-  ASSERT(!memcmp("PING", buf.base, nread));
+  ASSERT(!memcmp("PING", rcvbuf->base, nread));
 
   /* FIXME? `uv_udp_recv_stop` does what it says: recv_cb is not called
     * anymore. That's problematic because the read buffer won't be returned
@@ -149,13 +151,12 @@ static void sv_recv_cb(uv_udp_t* handle,
   req = malloc(sizeof *req);
   ASSERT(req != NULL);
 
-  buf = uv_buf_init("PONG", 4);
-
+  sndbuf = uv_buf_init("PONG", 4);
   r = uv_udp_send(req,
                   handle,
-                  &buf,
+                  &sndbuf,
                   1,
-                  *(struct sockaddr_in*)addr,
+                  (const struct sockaddr_in*) addr,
                   sv_send_cb);
   ASSERT(r == 0);
 
@@ -169,18 +170,18 @@ TEST_IMPL(udp_send_and_recv) {
   uv_buf_t buf;
   int r;
 
-  addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
 
   r = uv_udp_init(uv_default_loop(), &server);
   ASSERT(r == 0);
 
-  r = uv_udp_bind(&server, addr, 0);
+  r = uv_udp_bind(&server, &addr, 0);
   ASSERT(r == 0);
 
   r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb);
   ASSERT(r == 0);
 
-  addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+  ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
 
   r = uv_udp_init(uv_default_loop(), &client);
   ASSERT(r == 0);
@@ -188,7 +189,7 @@ TEST_IMPL(udp_send_and_recv) {
   /* client sends "PING", expects "PONG" */
   buf = uv_buf_init("PING", 4);
 
-  r = uv_udp_send(&req, &client, &buf, 1, addr, cl_send_cb);
+  r = uv_udp_send(&req, &client, &buf, 1, &addr, cl_send_cb);
   ASSERT(r == 0);
 
   ASSERT(close_cb_called == 0);
diff --git a/src/process_wrap.cc b/src/process_wrap.cc
index aebed822e7..1784a163da 100644
--- a/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@ -232,7 +232,7 @@ class ProcessWrap : public HandleWrap {
       options.flags |= UV_PROCESS_DETACHED;
     }
 
-    int err = uv_spawn(uv_default_loop(), &wrap->process_, options);
+    int err = uv_spawn(uv_default_loop(), &wrap->process_, &options);
 
     if (err == 0) {
       assert(wrap->process_.data == wrap);
diff --git a/src/stream_wrap.cc b/src/stream_wrap.cc
index e2c68430aa..6a5ff168d4 100644
--- a/src/stream_wrap.cc
+++ b/src/stream_wrap.cc
@@ -127,10 +127,12 @@ void StreamWrap::ReadStop(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-uv_buf_t StreamWrap::OnAlloc(uv_handle_t* handle, size_t suggested_size) {
+void StreamWrap::OnAlloc(uv_handle_t* handle,
+                         size_t suggested_size,
+                         uv_buf_t* buf) {
   StreamWrap* wrap = static_cast<StreamWrap*>(handle->data);
   assert(wrap->stream() == reinterpret_cast<uv_stream_t*>(handle));
-  return wrap->callbacks()->DoAlloc(handle, suggested_size);
+  wrap->callbacks()->DoAlloc(handle, suggested_size, buf);
 }
 
 
@@ -157,7 +159,7 @@ static Local<Object> AcceptHandle(uv_stream_t* pipe) {
 
 void StreamWrap::OnReadCommon(uv_stream_t* handle,
                               ssize_t nread,
-                              uv_buf_t buf,
+                              const uv_buf_t* buf,
                               uv_handle_type pending) {
   HandleScope scope(node_isolate);
 
@@ -179,13 +181,17 @@ void StreamWrap::OnReadCommon(uv_stream_t* handle,
 }
 
 
-void StreamWrap::OnRead(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
+void StreamWrap::OnRead(uv_stream_t* handle,
+                        ssize_t nread,
+                        const uv_buf_t* buf) {
   OnReadCommon(handle, nread, buf, UV_UNKNOWN_HANDLE);
 }
 
 
-void StreamWrap::OnRead2(uv_pipe_t* handle, ssize_t nread, uv_buf_t buf,
-    uv_handle_type pending) {
+void StreamWrap::OnRead2(uv_pipe_t* handle,
+                         ssize_t nread,
+                         const uv_buf_t* buf,
+                         uv_handle_type pending) {
   OnReadCommon(reinterpret_cast<uv_stream_t*>(handle), nread, buf, pending);
 }
 
@@ -544,20 +550,23 @@ void StreamWrapCallbacks::AfterWrite(WriteWrap* w) {
 }
 
 
-uv_buf_t StreamWrapCallbacks::DoAlloc(uv_handle_t* handle,
-                                      size_t suggested_size) {
-  char* data = static_cast<char*>(malloc(suggested_size));
-  if (data == NULL && suggested_size > 0) {
-    FatalError("node::StreamWrapCallbacks::DoAlloc(uv_handle_t*, size_t)",
-               "Out Of Memory");
+void StreamWrapCallbacks::DoAlloc(uv_handle_t* handle,
+                                  size_t suggested_size,
+                                  uv_buf_t* buf) {
+  buf->base = static_cast<char*>(malloc(suggested_size));
+  buf->len = suggested_size;
+
+  if (buf->base == NULL && suggested_size > 0) {
+    FatalError(
+        "node::StreamWrapCallbacks::DoAlloc(uv_handle_t*, size_t, uv_buf_t*)",
+        "Out Of Memory");
   }
-  return uv_buf_init(data, suggested_size);
 }
 
 
 void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
                                  ssize_t nread,
-                                 uv_buf_t buf,
+                                 const uv_buf_t* buf,
                                  uv_handle_type pending) {
   HandleScope scope(node_isolate);
 
@@ -568,21 +577,21 @@ void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
   };
 
   if (nread < 0)  {
-    if (buf.base != NULL)
-      free(buf.base);
+    if (buf->base != NULL)
+      free(buf->base);
     MakeCallback(Self(), onread_sym, ARRAY_SIZE(argv), argv);
     return;
   }
 
   if (nread == 0) {
-    if (buf.base != NULL)
-      free(buf.base);
+    if (buf->base != NULL)
+      free(buf->base);
     return;
   }
 
-  buf.base = static_cast<char*>(realloc(buf.base, nread));
-  assert(static_cast<size_t>(nread) <= buf.len);
-  argv[1] = Buffer::Use(buf.base, nread);
+  char* base = static_cast<char*>(realloc(buf->base, nread));
+  assert(static_cast<size_t>(nread) <= buf->len);
+  argv[1] = Buffer::Use(base, nread);
 
   Local<Object> pending_obj;
   if (pending == UV_TCP) {
diff --git a/src/stream_wrap.h b/src/stream_wrap.h
index 7f8f74af9f..6731fdbf75 100644
--- a/src/stream_wrap.h
+++ b/src/stream_wrap.h
@@ -79,10 +79,12 @@ class StreamWrapCallbacks {
                       uv_stream_t* send_handle,
                       uv_write_cb cb);
   virtual void AfterWrite(WriteWrap* w);
-  virtual uv_buf_t DoAlloc(uv_handle_t* handle, size_t suggested_size);
+  virtual void DoAlloc(uv_handle_t* handle,
+                       size_t suggested_size,
+                       uv_buf_t* buf);
   virtual void DoRead(uv_stream_t* handle,
                       ssize_t nread,
-                      uv_buf_t buf,
+                      const uv_buf_t* buf,
                       uv_handle_type pending);
   virtual int DoShutdown(ShutdownWrap* req_wrap, uv_shutdown_cb cb);
 
@@ -161,14 +163,22 @@ class StreamWrap : public HandleWrap {
  private:
   // Callbacks for libuv
   static void AfterWrite(uv_write_t* req, int status);
-  static uv_buf_t OnAlloc(uv_handle_t* handle, size_t suggested_size);
+  static void OnAlloc(uv_handle_t* handle,
+                      size_t suggested_size,
+                      uv_buf_t* buf);
   static void AfterShutdown(uv_shutdown_t* req, int status);
 
-  static void OnRead(uv_stream_t* handle, ssize_t nread, uv_buf_t buf);
-  static void OnRead2(uv_pipe_t* handle, ssize_t nread, uv_buf_t buf,
-      uv_handle_type pending);
-  static void OnReadCommon(uv_stream_t* handle, ssize_t nread,
-      uv_buf_t buf, uv_handle_type pending);
+  static void OnRead(uv_stream_t* handle,
+                     ssize_t nread,
+                     const uv_buf_t* buf);
+  static void OnRead2(uv_pipe_t* handle,
+                      ssize_t nread,
+                      const uv_buf_t* buf,
+                      uv_handle_type pending);
+  static void OnReadCommon(uv_stream_t* handle,
+                           ssize_t nread,
+                           const uv_buf_t* buf,
+                           uv_handle_type pending);
 
   template <enum encoding encoding>
   static void WriteStringImpl(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index d24fb5071b..43a6f900b3 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -269,8 +269,10 @@ void TCPWrap::Bind(const FunctionCallbackInfo<Value>& args) {
   String::AsciiValue ip_address(args[0]);
   int port = args[1]->Int32Value();
 
-  struct sockaddr_in address = uv_ip4_addr(*ip_address, port);
-  int err = uv_tcp_bind(&wrap->handle_, address);
+  sockaddr_in addr;
+  int err = uv_ip4_addr(*ip_address, port, &addr);
+  if (err == 0)
+    err = uv_tcp_bind(&wrap->handle_, &addr);
 
   args.GetReturnValue().Set(err);
 }
@@ -285,8 +287,10 @@ void TCPWrap::Bind6(const FunctionCallbackInfo<Value>& args) {
   String::AsciiValue ip6_address(args[0]);
   int port = args[1]->Int32Value();
 
-  struct sockaddr_in6 address = uv_ip6_addr(*ip6_address, port);
-  int err = uv_tcp_bind6(&wrap->handle_, address);
+  sockaddr_in6 addr;
+  int err = uv_ip6_addr(*ip6_address, port, &addr);
+  if (err == 0)
+    err = uv_tcp_bind6(&wrap->handle_, &addr);
 
   args.GetReturnValue().Set(err);
 }
@@ -378,19 +382,15 @@ void TCPWrap::Connect(const FunctionCallbackInfo<Value>& args) {
   String::AsciiValue ip_address(args[1]);
   int port = args[2]->Uint32Value();
 
-  struct sockaddr_in address = uv_ip4_addr(*ip_address, port);
+  sockaddr_in addr;
+  int err = uv_ip4_addr(*ip_address, port, &addr);
 
-  // I hate when people program C++ like it was C, and yet I do it too.
-  // I'm too lazy to come up with the perfect class hierarchy here. Let's
-  // just do some type munging.
-  ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
-
-  int err = uv_tcp_connect(&req_wrap->req_,
-                           &wrap->handle_,
-                           address,
-                           AfterConnect);
-  req_wrap->Dispatched();
-  if (err) delete req_wrap;
+  if (err == 0) {
+    ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
+    err = uv_tcp_connect(&req_wrap->req_, &wrap->handle_, &addr, AfterConnect);
+    req_wrap->Dispatched();
+    if (err) delete req_wrap;
+  }
 
   args.GetReturnValue().Set(err);
 }
@@ -410,16 +410,15 @@ void TCPWrap::Connect6(const FunctionCallbackInfo<Value>& args) {
   String::AsciiValue ip_address(args[1]);
   int port = args[2]->Int32Value();
 
-  struct sockaddr_in6 address = uv_ip6_addr(*ip_address, port);
+  sockaddr_in6 addr;
+  int err = uv_ip6_addr(*ip_address, port, &addr);
 
-  ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
-
-  int err = uv_tcp_connect6(&req_wrap->req_,
-                            &wrap->handle_,
-                            address,
-                            AfterConnect);
-  req_wrap->Dispatched();
-  if (err) delete req_wrap;
+  if (err == 0) {
+    ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
+    err = uv_tcp_connect6(&req_wrap->req_, &wrap->handle_, &addr, AfterConnect);
+    req_wrap->Dispatched();
+    if (err) delete req_wrap;
+  }
 
   args.GetReturnValue().Set(err);
 }
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index f2e27ee88f..cff2cded8c 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -512,16 +512,17 @@ void TLSCallbacks::AfterWrite(WriteWrap* w) {
 }
 
 
-uv_buf_t TLSCallbacks::DoAlloc(uv_handle_t* handle, size_t suggested_size) {
-  size_t size = suggested_size;
-  char* data = NodeBIO::FromBIO(enc_in_)->PeekWritable(&size);
-  return uv_buf_init(data, size);
+void TLSCallbacks::DoAlloc(uv_handle_t* handle,
+                           size_t suggested_size,
+                           uv_buf_t* buf) {
+  buf->base = NodeBIO::FromBIO(enc_in_)->PeekWritable(&suggested_size);
+  buf->len = suggested_size;
 }
 
 
 void TLSCallbacks::DoRead(uv_stream_t* handle,
                           ssize_t nread,
-                          uv_buf_t buf,
+                          const uv_buf_t* buf,
                           uv_handle_type pending) {
   if (nread < 0)  {
     // Error should be emitted only after all data was read
diff --git a/src/tls_wrap.h b/src/tls_wrap.h
index 6470643b79..83f54c3b92 100644
--- a/src/tls_wrap.h
+++ b/src/tls_wrap.h
@@ -50,10 +50,12 @@ class TLSCallbacks : public crypto::SSLWrap<TLSCallbacks>,
               uv_stream_t* send_handle,
               uv_write_cb cb);
   void AfterWrite(WriteWrap* w);
-  uv_buf_t DoAlloc(uv_handle_t* handle, size_t suggested_size);
+  void DoAlloc(uv_handle_t* handle,
+               size_t suggested_size,
+               uv_buf_t* buf);
   void DoRead(uv_stream_t* handle,
               ssize_t nread,
-              uv_buf_t buf,
+              const uv_buf_t* buf,
               uv_handle_type pending);
   int DoShutdown(ShutdownWrap* req_wrap, uv_shutdown_cb cb);
 
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index d72727a58f..8ea93450e0 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -159,11 +159,21 @@ void UDPWrap::DoBind(const FunctionCallbackInfo<Value>& args, int family) {
 
   switch (family) {
   case AF_INET:
-    err = uv_udp_bind(&wrap->handle_, uv_ip4_addr(*address, port), flags);
-    break;
+    {
+      sockaddr_in addr;
+      err = uv_ip4_addr(*address, port, &addr);
+      if (err == 0)
+        err = uv_udp_bind(&wrap->handle_, &addr, flags);
+      break;
+    }
   case AF_INET6:
-    err = uv_udp_bind6(&wrap->handle_, uv_ip6_addr(*address, port), flags);
-    break;
+    {
+      sockaddr_in6 addr;
+      err = uv_ip6_addr(*address, port, &addr);
+      if (err == 0)
+        err = uv_udp_bind6(&wrap->handle_, &addr, flags);
+      break;
+    }
   default:
     assert(0 && "unexpected address family");
     abort();
@@ -270,21 +280,33 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
 
   switch (family) {
   case AF_INET:
-    err = uv_udp_send(&req_wrap->req_,
-                      &wrap->handle_,
-                      &buf,
-                      1,
-                      uv_ip4_addr(*address, port),
-                      OnSend);
-    break;
+    {
+      sockaddr_in addr;
+      err = uv_ip4_addr(*address, port, &addr);
+      if (err == 0) {
+        err = uv_udp_send(&req_wrap->req_,
+                          &wrap->handle_,
+                          &buf,
+                          1,
+                          &addr,
+                          OnSend);
+      }
+      break;
+    }
   case AF_INET6:
-    err = uv_udp_send6(&req_wrap->req_,
-                       &wrap->handle_,
-                       &buf,
-                       1,
-                       uv_ip6_addr(*address, port),
-                       OnSend);
-    break;
+    {
+      sockaddr_in6 addr;
+      err = uv_ip6_addr(*address, port, &addr);
+      if (err == 0) {
+        err = uv_udp_send6(&req_wrap->req_,
+                           &wrap->handle_,
+                           &buf,
+                           1,
+                           &addr,
+                           OnSend);
+      }
+      break;
+    }
   default:
     assert(0 && "unexpected address family");
     abort();
@@ -365,24 +387,27 @@ void UDPWrap::OnSend(uv_udp_send_t* req, int status) {
 }
 
 
-uv_buf_t UDPWrap::OnAlloc(uv_handle_t* handle, size_t suggested_size) {
-  char* data = static_cast<char*>(malloc(suggested_size));
-  if (data == NULL && suggested_size > 0) {
-    FatalError("node::UDPWrap::OnAlloc(uv_handle_t*, size_t)",
+void UDPWrap::OnAlloc(uv_handle_t* handle,
+                      size_t suggested_size,
+                      uv_buf_t* buf) {
+  buf->base = static_cast<char*>(malloc(suggested_size));
+  buf->len = suggested_size;
+
+  if (buf->base == NULL && suggested_size > 0) {
+    FatalError("node::UDPWrap::OnAlloc(uv_handle_t*, size_t, uv_buf_t*)",
                "Out Of Memory");
   }
-  return uv_buf_init(data, suggested_size);
 }
 
 
 void UDPWrap::OnRecv(uv_udp_t* handle,
                      ssize_t nread,
-                     uv_buf_t buf,
-                     struct sockaddr* addr,
-                     unsigned flags) {
+                     const uv_buf_t* buf,
+                     const struct sockaddr* addr,
+                     unsigned int flags) {
   if (nread == 0) {
-    if (buf.base != NULL)
-      free(buf.base);
+    if (buf->base != NULL)
+      free(buf->base);
     return;
   }
 
@@ -398,15 +423,14 @@ void UDPWrap::OnRecv(uv_udp_t* handle,
   };
 
   if (nread < 0) {
-    if (buf.base != NULL)
-      free(buf.base);
+    if (buf->base != NULL)
+      free(buf->base);
     MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv);
     return;
   }
 
-  buf.base = static_cast<char*>(realloc(buf.base, nread));
-
-  argv[2] = Buffer::Use(buf.base, nread);
+  char* base = static_cast<char*>(realloc(buf->base, nread));
+  argv[2] = Buffer::Use(base, nread);
   argv[3] = AddressToJS(addr);
   MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv);
 }
diff --git a/src/udp_wrap.h b/src/udp_wrap.h
index fb73647045..e0cfc7ba26 100644
--- a/src/udp_wrap.h
+++ b/src/udp_wrap.h
@@ -64,13 +64,15 @@ class UDPWrap: public HandleWrap {
   static void SetMembership(const v8::FunctionCallbackInfo<v8::Value>& args,
                             uv_membership membership);
 
-  static uv_buf_t OnAlloc(uv_handle_t* handle, size_t suggested_size);
+  static void OnAlloc(uv_handle_t* handle,
+                      size_t suggested_size,
+                      uv_buf_t* buf);
   static void OnSend(uv_udp_send_t* req, int status);
   static void OnRecv(uv_udp_t* handle,
                      ssize_t nread,
-                     uv_buf_t buf,
-                     struct sockaddr* addr,
-                     unsigned flags);
+                     const uv_buf_t* buf,
+                     const struct sockaddr* addr,
+                     unsigned int flags);
 
   uv_udp_t handle_;
 };