noderb 0.0.8 → 0.0.9

data/ext/noderb_extension/libuv/src/unix/core.c

@@ -18,10 +18,6 @@
  * IN THE SOFTWARE.
  */
 
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE /* O_CLOEXEC, accept4(), etc. */
-#endif
-
 #include "uv.h"
 #include "unix/internal.h"
 
@@ -42,26 +38,6 @@
 #include <limits.h> /* PATH_MAX */
 #include <sys/uio.h> /* writev */
 
-#if defined(__linux__)
-
-#include <linux/version.h>
-#include <features.h>
-
-#undef HAVE_PIPE2
-#undef HAVE_ACCEPT4
-
-/* pipe2() requires linux >= 2.6.27 and glibc >= 2.9 */
-#if LINUX_VERSION_CODE >= 0x2061B && __GLIBC_PREREQ(2, 9)
-#define HAVE_PIPE2
-#endif
-
-/* accept4() requires linux >= 2.6.28 and glib >= 2.10 */
-#if LINUX_VERSION_CODE >= 0x2061C && __GLIBC_PREREQ(2, 10)
-#define HAVE_ACCEPT4
-#endif
-
-#endif /* __linux__ */
-
 #ifdef __sun
 # include <sys/types.h>
 # include <sys/wait.h>
@@ -89,17 +65,6 @@ static void uv__finish_close(uv_handle_t* handle);
 #endif
 
 
-void uv_init() {
-  default_loop_ptr = &default_loop_struct;
-#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
-  default_loop_struct.ev = ev_default_loop(EVBACKEND_KQUEUE);
-#else
-  default_loop_struct.ev = ev_default_loop(EVFLAG_AUTO);
-#endif
-  ev_set_userdata(default_loop_struct.ev, default_loop_ptr);
-}
-
-
 void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
   uv_udp_t* udp;
   uv_async_t* async;
@@ -200,6 +165,15 @@ void uv_loop_delete(uv_loop_t* loop) {
 
 
 uv_loop_t* uv_default_loop() {
+  if (!default_loop_ptr) {
+    default_loop_ptr = &default_loop_struct;
+#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
+    default_loop_struct.ev = ev_default_loop(EVBACKEND_KQUEUE);
+#else
+    default_loop_struct.ev = ev_default_loop(EVFLAG_AUTO);
+#endif
+    ev_set_userdata(default_loop_struct.ev, default_loop_ptr);
+  }
   assert(default_loop_ptr->ev == EV_DEFAULT_UC);
   return default_loop_ptr;
 }
@@ -259,6 +233,8 @@ void uv__finish_close(uv_handle_t* handle) {
     case UV_TCP:
       assert(!ev_is_active(&((uv_stream_t*)handle)->read_watcher));
       assert(!ev_is_active(&((uv_stream_t*)handle)->write_watcher));
+      assert(((uv_stream_t*)handle)->fd == -1);
+      uv__stream_destroy((uv_stream_t*)handle);
       break;
 
     case UV_UDP:
@@ -300,27 +276,6 @@ void uv__next(EV_P_ ev_idle* watcher, int revents) {
 }
 
 
-int uv_getsockname(uv_handle_t* handle, struct sockaddr* name, int* namelen) {
-  socklen_t socklen;
-  int saved_errno;
-
-  /* Don't clobber errno. */
-  saved_errno = errno;
-
-  /* sizeof(socklen_t) != sizeof(int) on some systems. */
-  socklen = (socklen_t)*namelen;
-
-  if (getsockname(handle->fd, name, &socklen) == -1) {
-    uv_err_new(handle->loop, errno);
-  } else {
-    *namelen = (int)socklen;
-  }
-
-  errno = saved_errno;
-  return 0;
-}
-
-
 void uv_ref(uv_loop_t* loop) {
   ev_ref(loop->ev);
 }
@@ -344,7 +299,6 @@ int64_t uv_now(uv_loop_t* loop) {
 void uv__req_init(uv_req_t* req) {
   /* loop->counters.req_init++; */
   req->type = UV_UNKNOWN_REQ;
-  req->data = NULL;
 }
 
 
@@ -653,7 +607,7 @@ static void getaddrinfo_thread_proc(eio_req *req) {
 
 
 /* stub implementation of uv_getaddrinfo */
-int uv_getaddrinfo(uv_loop_t* loop, 
+int uv_getaddrinfo(uv_loop_t* loop,
                    uv_getaddrinfo_t* handle,
                    uv_getaddrinfo_cb cb,
                    const char* hostname,
@@ -668,7 +622,10 @@ int uv_getaddrinfo(uv_loop_t* loop,
     return -1;
   }
 
-  memset(handle, 0, sizeof(uv_getaddrinfo_t));
+  uv__req_init((uv_req_t*)handle);
+  handle->type = UV_GETADDRINFO;
+  handle->loop = loop;
+  handle->cb = cb;
 
   /* TODO don't alloc so much. */
 
@@ -679,10 +636,10 @@ int uv_getaddrinfo(uv_loop_t* loop,
 
   /* TODO security! check lengths, check return values. */
 
-  handle->loop = loop;
-  handle->cb = cb;
   handle->hostname = hostname ? strdup(hostname) : NULL;
   handle->service = service ? strdup(service) : NULL;
+  handle->res = NULL;
+  handle->retcode = 0;
 
   /* TODO check handle->hostname == NULL */
   /* TODO check handle->service == NULL */
@@ -810,10 +767,8 @@ size_t uv__strlcpy(char* dst, const char* src, size_t size) {
   }
 
   org = src;
-  while (size > 1) {
-    if ((*dst++ = *src++) == '\0') {
-      return org - src;
-    }
+  while (--size && *src) {
+    *dst++ = *src++;
   }
   *dst = '\0';
 

data/ext/noderb_extension/libuv/src/unix/darwin.c

@@ -24,6 +24,7 @@
 #include <CoreServices/CoreServices.h>
 #include <mach/mach.h>
 #include <mach/mach_time.h>
+#include <mach-o/dyld.h> /* _NSGetExecutablePath */
 
 
 uint64_t uv_hrtime() {

data/ext/noderb_extension/libuv/src/unix/eio/config_netbsd.h

@@ -0,0 +1,81 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* fdatasync(2) is available */
+/* #undef HAVE_FDATASYNC */
+
+/* utimes(2) is available */
+#define HAVE_UTIMES 1
+
+/* futimes(2) is available */
+#define HAVE_FUTIMES 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* pread(2) and pwrite(2) are available */
+#define HAVE_PREADWRITE 1
+
+/* readahead(2) is available (linux) */
+/* #undef HAVE_READAHEAD */
+
+/* sendfile(2) is available and supported */
+#define HAVE_SENDFILE 0
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* sync_file_range(2) is available */
+/* #undef HAVE_SYNC_FILE_RANGE */
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "libeio"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "1.0"

data/ext/noderb_extension/libuv/src/unix/error.c

@@ -30,6 +30,8 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <assert.h>
 
 
 /* TODO Expose callback to user to handle fatal error like V8 does. */
@@ -64,9 +66,10 @@ char* uv_strerror(uv_err_t err) {
 }
 
 
-static uv_err_code uv_translate_sys_error(int sys_errno) {
+uv_err_code uv_translate_sys_error(int sys_errno) {
   switch (sys_errno) {
     case 0: return UV_OK;
+    case ENOENT: return UV_ENOENT;
     case EACCES: return UV_EACCESS;
     case EBADF: return UV_EBADF;
     case EPIPE: return UV_EPIPE;
@@ -79,8 +82,13 @@ static uv_err_code uv_translate_sys_error(int sys_errno) {
     case ECONNREFUSED: return UV_ECONNREFUSED;
     case EADDRINUSE: return UV_EADDRINUSE;
     case EADDRNOTAVAIL: return UV_EADDRNOTAVAIL;
+    case ENOTCONN: return UV_ENOTCONN;
+    case EEXIST: return UV_EEXIST;
     default: return UV_UNKNOWN;
   }
+
+  assert(0 && "unreachable");
+  return -1;
 }
 
 

data/ext/noderb_extension/libuv/src/unix/ev/config_netbsd.h

@@ -0,0 +1,120 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the `clock_gettime' function. */
+/* #undef HAVE_CLOCK_GETTIME */
+
+/* "use syscall interface for clock_gettime" */
+/* #undef HAVE_CLOCK_SYSCALL */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you have the `epoll_ctl' function. */
+/* #undef HAVE_EPOLL_CTL */
+
+/* Define to 1 if you have the `eventfd' function. */
+/* #undef HAVE_EVENTFD */
+
+/* Define to 1 if you have the `inotify_init' function. */
+/* #undef HAVE_INOTIFY_INIT */
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `kqueue' function. */
+#define HAVE_KQUEUE 1
+
+/* Define to 1 if you have the `m' library (-lm). */
+#define HAVE_LIBM 1
+
+/* Define to 1 if you have the `rt' library (-lrt). */
+/* #undef HAVE_LIBRT */
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `nanosleep' function. */
+/* #undef HAVE_NANOSLEEP */
+
+/* Define to 1 if you have the `poll' function. */
+#define HAVE_POLL 1
+
+/* Define to 1 if you have the <poll.h> header file. */
+#define HAVE_POLL_H 1
+
+/* Define to 1 if you have the `port_create' function. */
+/* #undef HAVE_PORT_CREATE */
+
+/* Define to 1 if you have the <port.h> header file. */
+/* #undef HAVE_PORT_H */
+
+/* Define to 1 if you have the `select' function. */
+#define HAVE_SELECT 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#define HAVE_STRINGS_H 1
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the <sys/epoll.h> header file. */
+/* #undef HAVE_SYS_EPOLL_H */
+
+/* Define to 1 if you have the <sys/eventfd.h> header file. */
+/* #undef HAVE_SYS_EVENTFD_H */
+
+/* Define to 1 if you have the <sys/event.h> header file. */
+#define HAVE_SYS_EVENT_H 1
+
+/* Define to 1 if you have the <sys/inotify.h> header file. */
+/* #undef HAVE_SYS_INOTIFY_H */
+
+/* Define to 1 if you have the <sys/queue.h> header file. */
+#define HAVE_SYS_QUEUE_H 1
+
+/* Define to 1 if you have the <sys/select.h> header file. */
+#define HAVE_SYS_SELECT_H 1
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#define HAVE_UNISTD_H 1
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "libev"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME ""
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING ""
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION ""
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "3.9"

data/ext/noderb_extension/libuv/src/unix/fs.c

@@ -32,6 +32,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <utime.h>
+#include <sys/time.h>
 
 
 #define ARGS1(a)       (a)
@@ -40,28 +41,28 @@
 #define ARGS4(a,b,c,d) (a), (b), (c), (d)
 
 #define WRAP_EIO(type, eiofunc, func, args) \
-  uv_fs_req_init(loop, req, type, cb); \
+  uv_fs_req_init(loop, req, type, path, cb); \
   if (cb) { \
     /* async */ \
-    uv_ref(loop); \
     req->eio = eiofunc(args, EIO_PRI_DEFAULT, uv__fs_after, req); \
     if (!req->eio) { \
       uv_err_new(loop, ENOMEM); \
       return -1; \
     } \
+    uv_ref(loop); \
   } else { \
     /* sync */ \
     req->result = func(args); \
     if (req->result) { \
       uv_err_new(loop, errno); \
-      return -1; \
     }  \
+    return req->result; \
   } \
   return 0;
 
 
 static void uv_fs_req_init(uv_loop_t* loop, uv_fs_t* req, uv_fs_type fs_type,
-    uv_fs_cb cb) {
+    const char* path, uv_fs_cb cb) {
   /* Make sure the thread pool is initialized. */
   uv_eio_init(loop);
 
@@ -72,15 +73,20 @@ static void uv_fs_req_init(uv_loop_t* loop, uv_fs_t* req, uv_fs_type fs_type,
   req->cb = cb;
   req->result = 0;
   req->ptr = NULL;
+  req->path = path ? strdup(path) : NULL;
   req->errorno = 0;
   req->eio = NULL;
 }
 
 
 void uv_fs_req_cleanup(uv_fs_t* req) {
+  free(req->path);
+  req->path = NULL;
+
   switch (req->fs_type) {
     case UV_FS_READDIR:
-      assert(req->ptr);
+      assert((req->result == -1 && req->ptr == NULL)
+          || (req->result >= 0 && req->ptr != NULL));
       free(req->ptr);
       req->ptr = NULL;
       break;
@@ -106,13 +112,16 @@ static int uv__fs_after(eio_req* eio) {
   assert(req->cb);
 
   req->result = req->eio->result;
-  req->errorno = req->eio->errorno;
+  req->errorno = uv_translate_sys_error(req->eio->errorno);
 
   switch (req->fs_type) {
     case UV_FS_READDIR:
+      if (req->eio->result == -1)
+        break; /* opendir() or readdir() operation failed. */
+
       /*
        * XXX This is pretty bad.
-       * We alloc and copy the large null termiated string list from libeio.
+       * We alloc and copy the large null terminated string list from libeio.
        * This is done because libeio is going to free eio->ptr2 after this
        * callback. We must keep it until uv_fs_req_cleanup. If we get rid of
        * libeio this can be avoided.
@@ -130,12 +139,31 @@ static int uv__fs_after(eio_req* eio) {
       req->ptr = malloc(buflen);
       memcpy(req->ptr, req->eio->ptr2, buflen);
       break;
+
     case UV_FS_STAT:
     case UV_FS_LSTAT:
     case UV_FS_FSTAT:
       req->ptr = req->eio->ptr2;
       break;
 
+    case UV_FS_READLINK:
+      if (req->result == -1) {
+        req->ptr = NULL;
+      } else {
+        assert(req->result > 0);
+
+        if ((name = realloc(req->eio->ptr2, req->result + 1)) == NULL) {
+          /* Not enough memory. Reuse buffer, chop off last byte. */
+          name = req->eio->ptr2;
+          req->result--;
+        }
+
+        name[req->result] = '\0';
+        req->ptr = name;
+        req->result = 0;
+      }
+      break;
+
     default:
       break;
   }
@@ -149,13 +177,14 @@ static int uv__fs_after(eio_req* eio) {
 
 
 int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
+  char* path = NULL;
   WRAP_EIO(UV_FS_CLOSE, eio_close, close, ARGS1(file));
 }
 
 
 int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
     int mode, uv_fs_cb cb) {
-  uv_fs_req_init(loop, req, UV_FS_OPEN, cb);
+  uv_fs_req_init(loop, req, UV_FS_OPEN, path, cb);
 
   if (cb) {
     /* async */
@@ -175,6 +204,8 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
     }
 
     uv__cloexec(req->result, 1);
+
+    return req->result;
   }
 
   return 0;
@@ -183,7 +214,7 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
 
 int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file fd, void* buf,
     size_t length, off_t offset, uv_fs_cb cb) {
-  uv_fs_req_init(loop, req, UV_FS_READ, cb);
+  uv_fs_req_init(loop, req, UV_FS_READ, NULL, cb);
 
   if (cb) {
     /* async */
@@ -206,6 +237,8 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file fd, void* buf,
       uv_err_new(loop, errno);
       return -1;
     }
+
+    return req->result;
   }
 
   return 0;
@@ -219,7 +252,7 @@ int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
 
 int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
     size_t length, off_t offset, uv_fs_cb cb) {
-  uv_fs_req_init(loop, req, UV_FS_WRITE, cb);
+  uv_fs_req_init(loop, req, UV_FS_WRITE, NULL, cb);
 
   if (cb) {
     /* async */
@@ -241,6 +274,8 @@ int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
       uv_err_new(loop, errno);
       return -1;
     }
+
+    return req->result;
   }
 
   return 0;
@@ -265,7 +300,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
   size_t size = 0;
   size_t d_namlen = 0;
 
-  uv_fs_req_init(loop, req, UV_FS_READDIR, cb);
+  uv_fs_req_init(loop, req, UV_FS_READDIR, path, cb);
 
   if (cb) {
     /* async */
@@ -281,25 +316,40 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
     DIR* dir = opendir(path);
     if (!dir) {
       uv_err_new(loop, errno);
+      req->result = -1;
       return -1;
     }
 
+    /* req->result stores number of entries */
+    req->result = 0;
+
     while ((entry = readdir(dir))) {
       d_namlen = strlen(entry->d_name);
+
+      /* Skip . and .. */
+      if ((d_namlen == 1 && entry->d_name[0] == '.') ||
+          (d_namlen == 2 && entry->d_name[0] == '.' &&
+           entry->d_name[1] == '.')) {
+        continue;
+      }
+
       req->ptr = realloc(req->ptr, size + d_namlen + 1);
       /* TODO check ENOMEM */
-      /* TODO skip . and .. */
       memcpy((char*)req->ptr + size, entry->d_name, d_namlen);
       size += d_namlen;
       ((char*)req->ptr)[size] = '\0';
       size++;
+      req->result++;
     }
 
     r = closedir(dir);
     if (r) {
       uv_err_new(loop, errno);
+      req->result = -1;
       return -1;
     }
+
+    return req->result;
   }
 
   return 0;
@@ -307,10 +357,10 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
 
 
 int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  char* pathdup = path;
+  char* pathdup;
   int pathlen;
 
-  uv_fs_req_init(loop, req, UV_FS_STAT, cb);
+  uv_fs_req_init(loop, req, UV_FS_STAT, path, cb);
 
   /* TODO do this without duplicating the string. */
   /* TODO security */
@@ -346,6 +396,7 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
     }
 
     req->ptr = &req->statbuf;
+    return req->result;
   }
 
   return 0;
@@ -353,7 +404,7 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
 
 
 int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
-  uv_fs_req_init(loop, req, UV_FS_FSTAT, cb);
+  uv_fs_req_init(loop, req, UV_FS_FSTAT, NULL, cb);
 
   if (cb) {
     /* async */
@@ -375,6 +426,7 @@ int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
     }
 
     req->ptr = &req->statbuf;
+    return req->result;
   }
 
   return 0;
@@ -388,23 +440,27 @@ int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* ne
 
 
 int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
+  char* path = NULL;
   WRAP_EIO(UV_FS_FSYNC, eio_fsync, fsync, ARGS1(file))
 }
 
 
 int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
+  char* path = NULL;
   WRAP_EIO(UV_FS_FDATASYNC, eio_fdatasync, fdatasync, ARGS1(file))
 }
 
 
 int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file, off_t offset,
     uv_fs_cb cb) {
+  char* path = NULL;
   WRAP_EIO(UV_FS_FTRUNCATE, eio_ftruncate, ftruncate, ARGS2(file, offset))
 }
 
 
 int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd, uv_file in_fd,
     off_t in_offset, size_t length, uv_fs_cb cb) {
+  char* path = NULL;
   WRAP_EIO(UV_FS_SENDFILE, eio_sendfile, eio_sendfile_sync,
       ARGS4(out_fd, in_fd, in_offset, length))
 }
@@ -430,18 +486,42 @@ int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
 }
 
 
+#if defined(HAVE_FUTIMES)
+static int _futime(const uv_file file, double atime, double mtime) {
+  struct timeval tv[2];
+
+  /* FIXME possible loss of precision in floating-point arithmetic? */
+  tv[0].tv_sec = atime;
+  tv[0].tv_usec = (unsigned long)(atime * 1000000) % 1000000;
+
+  tv[1].tv_sec = mtime;
+  tv[1].tv_usec = (unsigned long)(mtime * 1000000) % 1000000;
+
+  return futimes(file, tv);
+}
+#endif
+
+
 int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime,
     double mtime, uv_fs_cb cb) {
-  assert(0 && "implement me");
+#if defined(HAVE_FUTIMES)
+  const char* path = NULL;
+
+  uv_fs_req_init(loop, req, UV_FS_FUTIME, path, cb);
+
+  WRAP_EIO(UV_FS_FUTIME, eio_futime, _futime, ARGS3(file, atime, mtime))
+#else
+  uv_err_new(loop, ENOSYS);
   return -1;
+#endif
 }
 
 
 int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
-  char* pathdup = path;
+  char* pathdup;
   int pathlen;
 
-  uv_fs_req_init(loop, req, UV_FS_LSTAT, cb);
+  uv_fs_req_init(loop, req, UV_FS_LSTAT, path, cb);
 
   /* TODO do this without duplicating the string. */
   /* TODO security */
@@ -477,6 +557,7 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
     }
 
     req->ptr = &req->statbuf;
+    return req->result;
   }
 
   return 0;
@@ -490,20 +571,68 @@ int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
 
 
 int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
-    const char* new_path, uv_fs_cb cb) {
+    const char* new_path, int flags, uv_fs_cb cb) {
   WRAP_EIO(UV_FS_SYMLINK, eio_symlink, symlink, ARGS2(path, new_path))
 }
 
 
 int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
     uv_fs_cb cb) {
-  assert(0 && "implement me");
-  return -1;
+  ssize_t size;
+  int status;
+  char* buf;
+
+  status = -1;
+
+  uv_fs_req_init(loop, req, UV_FS_READLINK, path, cb);
+
+  if (cb) {
+    if ((req->eio = eio_readlink(path, EIO_PRI_DEFAULT, uv__fs_after, req))) {
+      uv_ref(loop);
+      return 0;
+    } else {
+      uv_err_new(loop, ENOMEM);
+      return -1;
+    }
+  } else {
+    /* pathconf(_PC_PATH_MAX) may return -1 to signify that path
+     * lengths have no upper limit or aren't suitable for malloc'ing.
+     */
+    if ((size = pathconf(path, _PC_PATH_MAX)) == -1) {
+#if defined(PATH_MAX)
+      size = PATH_MAX;
+#else
+      size = 4096;
+#endif
+    }
+
+    if ((buf = malloc(size + 1)) == NULL) {
+      uv_err_new(loop, ENOMEM);
+      return -1;
+    }
+
+    if ((size = readlink(path, buf, size)) == -1) {
+      req->errorno = errno;
+      req->result = -1;
+      free(buf);
+    } else {
+      /* Cannot conceivably fail since it shrinks the buffer. */
+      buf = realloc(buf, size + 1);
+      buf[size] = '\0';
+      req->result = 0;
+      req->ptr = buf;
+    }
+
+    return req->result;
+  }
+
+  assert(0 && "unreachable");
 }
 
 
 int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode,
     uv_fs_cb cb) {
+  char* path = NULL;
   WRAP_EIO(UV_FS_FCHMOD, eio_fchmod, fchmod, ARGS2(file, mode))
 }
 
@@ -516,6 +645,7 @@ int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, int uid,
 
 int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file file, int uid, int gid,
     uv_fs_cb cb) {
+  char* path = NULL;
   WRAP_EIO(UV_FS_FCHOWN, eio_fchown, fchown, ARGS3(file, uid, gid))
 }