fs: fix long symlinks in realpath

benchmark/fs/bench-realpath.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const path = require('path');
+const resolved_path = path.resolve(__dirname, '../../lib/');
+const relative_path = path.relative(__dirname, '../../lib/');
+
+const bench = common.createBenchmark(main, {
+  n: [1e4],
+  type: ['relative', 'resolved'],
+});
+
+
+function main(conf) {
+  const n = conf.n >>> 0;
+  const type = conf.type;
+
+  bench.start();
+  if (type === 'relative')
+    relativePath(n);
+  else if (type === 'resolved')
+    resolvedPath(n);
+  else
+    throw new Error('unknown "type": ' + type);
+}
+
+function relativePath(n) {
+  (function r(cntr) {
+    if (--cntr <= 0)
+      return bench.end(n);
+    fs.realpath(relative_path, function() {
+      r(cntr);
+    });
+  }(n));
+}
+
+function resolvedPath(n) {
+  (function r(cntr) {
+    if (--cntr <= 0)
+      return bench.end(n);
+    fs.realpath(resolved_path, function() {
+      r(cntr);
+    });
+  }(n));
+}

benchmark/fs/bench-realpathSync.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const path = require('path');
+const resolved_path = path.resolve(__dirname, '../../lib/');
+const relative_path = path.relative(__dirname, '../../lib/');
+
+const bench = common.createBenchmark(main, {
+  n: [1e4],
+  type: ['relative', 'resolved'],
+});
+
+
+function main(conf) {
+  const n = conf.n >>> 0;
+  const type = conf.type;
+
+  bench.start();
+  if (type === 'relative')
+    relativePath(n);
+  else if (type === 'resolved')
+    resolvedPath(n);
+  else
+    throw new Error('unknown "type": ' + type);
+  bench.end(n);
+}
+
+function relativePath(n) {
+  for (var i = 0; i < n; i++) {
+    fs.realpathSync(relative_path);
+  }
+}
+
+function resolvedPath(n) {
+  for (var i = 0; i < n; i++) {
+    fs.realpathSync(resolved_path);
+  }
+}

lib/fs.js

@@ -1590,12 +1590,68 @@ fs.realpath = function realpath(path, options, callback) {
   if (!nullCheck(path, callback))
     return;
   var req = new FSReqWrap();
-  req.oncomplete = callback;
+  req.oncomplete = function oncomplete(err, resolvedPath) {
+    interceptELOOP(err, resolvedPath, path, options, callback);
+  };
   binding.realpath(pathModule._makeLong(path), options.encoding, req);
   return;
 };
 
 
+function interceptELOOP(err, resolvedPath, path, options, callback) {
+  if (resolvedPath)
+    return callback(err, resolvedPath);
+  if (err && err.code !== 'ELOOP')
+    return callback(err);
+  var retPath = '';
+  // Start at -1 since first operation is to + 1.
+  var offset = -1;
+  var current = 0;
+  var slashCount = 0;
+  var callDepth = 0;
+
+  // Can assume '/' because uv_fs_realpath() cannot return UV_ELOOP on win.
+  (function pathResolver(err2, resolvedPath2) {
+    // No need to handle an error that was returned by a recursive call.
+    if (err2) return callback(err2);
+    // callDepth is too much. Return original error.
+    if (++callDepth > 100) return callback(err);
+    // Done iterating over the path.
+    if (offset === path.length) return callback(null, resolvedPath2);
+
+    retPath = resolvedPath2;
+    slashCount = countSlashes(retPath);
+    offset = get32SlashOffset(path, offset + 1, slashCount);
+
+    var tmpPath = retPath + path.slice(current, offset);
+    current = offset;
+    var req = new FSReqWrap();
+    req.oncomplete = pathResolver;
+    binding.realpath(pathModule._makeLong(tmpPath), options.encoding, req);
+  }(null, ''));
+}
+
+
+function get32SlashOffset(path, offset, slashCounter) {
+  // OSX libc bails with ELOOP when encountering more than MAXSYMLINKS, which
+  // is hard coded to in the kernel header to 32.
+  while ((offset = path.indexOf('/', offset + 1)) !== -1 &&
+         ++slashCounter < 32);
+  if (offset === -1)
+    offset = path.length;
+  return offset;
+}
+
+
+function countSlashes(path) {
+  var offset = -1;
+  var counter = 0;
+  while ((offset = path.indexOf('/', offset + 1)) !== -1)
+    counter++;
+  return counter;
+}
+
+
 fs.mkdtemp = function(prefix, options, callback) {
   if (!prefix || typeof prefix !== 'string')
     throw new TypeError('filename prefix is required');

src/node_file.cc

@@ -361,16 +361,19 @@ class fs_req_wrap {
 #define ASYNC_CALL(func, req, encoding, ...)                                  \
   ASYNC_DEST_CALL(func, req, nullptr, encoding, __VA_ARGS__)                  \
 
-#define SYNC_DEST_CALL(func, path, dest, ...)                                 \
-  fs_req_wrap req_wrap;                                                       \
+#define SYNC_CALL_NO_THROW(req_wrap, func, dest, ...)                         \
   env->PrintSyncTrace();                                                      \
   int err = uv_fs_ ## func(env->event_loop(),                                 \
-                         &req_wrap.req,                                       \
+                         &(req_wrap).req,                                     \
                          __VA_ARGS__,                                         \
-                         nullptr);                                            \
-  if (err < 0) {                                                              \
-    return env->ThrowUVException(err, #func, nullptr, path, dest);            \
-  }                                                                           \
+                         nullptr);
+
+#define SYNC_DEST_CALL(func, path, dest, ...)                                 \
+  fs_req_wrap req_wrap;                                                       \
+  SYNC_CALL_NO_THROW(req_wrap, func, dest, __VA_ARGS__)                       \
+  if (SYNC_RESULT < 0) {                                                      \
+    return env->ThrowUVException(SYNC_RESULT, #func, nullptr, path, dest);    \
+  }
 
 #define SYNC_CALL(func, path, ...)                                            \
   SYNC_DEST_CALL(func, path, nullptr, __VA_ARGS__)                            \
@@ -882,6 +885,77 @@ static void MKDir(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+
+static size_t CountSlashes(const char* str, size_t len) {
+  size_t cntr = 0;
+  for (size_t i = 0; i < len; i++) {
+    if (str[i] == '/') cntr++;
+  }
+  return cntr;
+}
+
+
+static int ResolveRealPathSync(Environment* env,
+                               std::string* ret_str,
+                               const char* path,
+                               size_t call_depth) {
+  fs_req_wrap req_wrap;
+  SYNC_CALL_NO_THROW(req_wrap, realpath, path, path);
+
+  call_depth++;
+  if (SYNC_RESULT != UV_ELOOP) {
+    if (SYNC_RESULT) return SYNC_RESULT;
+    *ret_str = std::string(static_cast<const char*>(SYNC_REQ.ptr));
+    return SYNC_RESULT;
+  // TODO(trevnorris): Instead of simply not allowing too many recursive
+  // calls, would it instead be a viable solution to attempt detection of
+  // recursive symlinks? Thus preventing false negatives.
+  } else if (SYNC_RESULT == UV_ELOOP && call_depth > 100) {
+    return UV_ELOOP;
+  }
+
+#ifdef _WIN32
+  const char separator = '\\';
+#else
+  const char separator = '/';
+#endif
+  std::string str_path(path);
+  size_t offset = 0;
+  size_t current = 0;
+  size_t slash_count = 0;
+
+  // Can assume '/' because uv_fs_realpath() cannot return UV_ELOOP on win.
+  while ((offset = str_path.find(separator, offset + 1)) != std::string::npos) {
+    // OSX libc bails with ELOOP when encountering more than MAXSYMLINKS,
+    // which is hard coded to in the kernel header to 32.
+    if (++slash_count < 32) {
+      continue;
+    }
+
+    std::string partial = *ret_str + str_path.substr(current, offset - current);
+    int err2 = ResolveRealPathSync(env, ret_str, partial.c_str(), call_depth);
+    // No need to handle an error that was returned by a recursive call.
+    if (err2) {
+      *ret_str = std::string();
+      return err2;
+    }
+
+    current = offset;
+    slash_count = CountSlashes(ret_str->c_str(), ret_str->length());
+  }
+
+  if (offset == std::string::npos) {
+    offset = str_path.length();
+  }
+  if (current >= offset) {
+    return 0;
+  }
+
+  std::string pass(*ret_str + str_path.substr(current, offset - current));
+  return ResolveRealPathSync(env, ret_str, pass.c_str(), call_depth);
+}
+
+
 static void RealPath(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
@@ -902,10 +976,14 @@ static void RealPath(const FunctionCallbackInfo<Value>& args) {
   if (callback->IsObject()) {
     ASYNC_CALL(realpath, callback, encoding, *path);
   } else {
-    SYNC_CALL(realpath, *path, *path);
-    const char* link_path = static_cast<const char*>(SYNC_REQ.ptr);
+    std::string rc_string;
+    // Resolve the symlink attempting simple amount of deep path resolution.
+    int err = ResolveRealPathSync(env, &rc_string, *path, 0);
+    if (err) {
+      return env->ThrowUVException(err, "realpath", nullptr, *path, *path);
+    }
     Local<Value> rc = StringBytes::Encode(env->isolate(),
-                                          link_path,
+                                          rc_string.c_str(),
                                           encoding);
     if (rc.IsEmpty()) {
       return env->ThrowUVException(UV_EINVAL,

src/uv.cc

@@ -3,9 +3,18 @@
 #include "env.h"
 #include "env-inl.h"
 
+#include <stdio.h>  // snprintf
+
 namespace node {
 namespace uv {
 
+#define RETURN_RANGE_ERROR(...)                                               \
+  do {                                                                        \
+    char buf[100];                                                            \
+    snprintf(buf, sizeof(buf), __VA_ARGS__);                                  \
+    return env->ThrowRangeError(buf);                                         \
+  } while (0)
+
 using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -19,19 +28,31 @@ using v8::Value;
 void ErrName(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   int err = args[0]->Int32Value();
-  if (err >= 0)
-    return env->ThrowError("err >= 0");
+  if (err >= 0 || err < UV_ERRNO_MAX)
+    RETURN_RANGE_ERROR("err is an invalid error code: %i", err);
   const char* name = uv_err_name(err);
   args.GetReturnValue().Set(OneByteString(env->isolate(), name));
 }
 
 
+void StrError(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  int err = args[0]->Int32Value();
+  if (err >= 0 || err < UV_ERRNO_MAX)
+    RETURN_RANGE_ERROR("err is an invalid error code: %i", err);
+  const char* name = uv_strerror(err);
+  args.GetReturnValue().Set(OneByteString(env->isolate(), name));
+}
+
+
 void Initialize(Local<Object> target,
                 Local<Value> unused,
                 Local<Context> context) {
   Environment* env = Environment::GetCurrent(context);
   target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "errname"),
               env->NewFunctionTemplate(ErrName)->GetFunction());
+  target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "strerror"),
+              env->NewFunctionTemplate(StrError)->GetFunction());
 #define V(name, _)                                                            \
   target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "UV_" # name),            \
               Integer::New(env->isolate(), UV_ ## name));