On Windows, patch Node's lstat to work around permissions error. Fixes #1101

Author: SteveSandersonMS

src/Microsoft.AspNetCore.NodeServices/Content/Node/entrypoint-http.js

@@ -55,10 +55,11 @@
 	// Limit dependencies to core Node modules. This means the code in this file has to be very low-level and unattractive,
 	// but simplifies things for the consumer of this module.
 	__webpack_require__(2);
-	var http = __webpack_require__(3);
-	var path = __webpack_require__(4);
-	var ArgsUtil_1 = __webpack_require__(5);
-	var ExitWhenParentExits_1 = __webpack_require__(6);
+	__webpack_require__(4);
+	var http = __webpack_require__(5);
+	var path = __webpack_require__(3);
+	var ArgsUtil_1 = __webpack_require__(6);
+	var ExitWhenParentExits_1 = __webpack_require__(7);
 	// Webpack doesn't support dynamic requires for files not present at compile time, so grab a direct
 	// reference to Node's runtime 'require' function.
 	var dynamicRequire = eval('require');
@@ -142,6 +143,64 @@
 
 /***/ },
 /* 2 */
+/***/ function(module, exports, __webpack_require__) {
+
+	"use strict";
+	var path = __webpack_require__(3);
+	var startsWith = function (str, prefix) { return str.substring(0, prefix.length) === prefix; };
+	var appRootDir = process.cwd();
+	function patchedLStat(pathToStatLong) {
+	    try {
+	        // If the lstat completes without errors, we don't modify its behavior at all
+	        return origLStat.apply(this, arguments);
+	    }
+	    catch (ex) {
+	        var shouldOverrideError = startsWith(ex.message, 'EPERM') // It's a permissions error
+	            && typeof appRootDirLong === 'string'
+	            && startsWith(appRootDirLong, pathToStatLong) // ... for an ancestor directory
+	            && ex.stack.indexOf('Object.realpathSync ') >= 0; // ... during symlink resolution
+	        if (shouldOverrideError) {
+	            // Fake the result to give the same result as an 'lstat' on the app root dir.
+	            // This stops Node failing to load modules just because it doesn't know whether
+	            // ancestor directories are symlinks or not. If there's a genuine file
+	            // permissions issue, it will still surface later when Node actually
+	            // tries to read the file.
+	            return origLStat.call(this, appRootDir);
+	        }
+	        else {
+	            // In any other case, preserve the original error
+	            throw ex;
+	        }
+	    }
+	}
+	;
+	// It's only necessary to apply this workaround on Windows
+	var appRootDirLong = null;
+	var origLStat = null;
+	if (/^win/.test(process.platform)) {
+	    try {
+	        // Get the app's root dir in Node's internal "long" format (e.g., \\?\C:\dir\subdir)
+	        appRootDirLong = path._makeLong(appRootDir);
+	        // Actually apply the patch, being as defensive as possible
+	        var bindingFs = process.binding('fs');
+	        origLStat = bindingFs.lstat;
+	        if (typeof origLStat === 'function') {
+	            bindingFs.lstat = patchedLStat;
+	        }
+	    }
+	    catch (ex) {
+	    }
+	}
+
+
+/***/ },
+/* 3 */
+/***/ function(module, exports) {
+
+	module.exports = require("path");
+
+/***/ },
+/* 4 */
 /***/ function(module, exports) {
 
 	// When Node writes to stdout/strerr, we capture that and convert the lines into calls on the
@@ -182,19 +241,13 @@
 
 
 /***/ },
-/* 3 */
+/* 5 */
 /***/ function(module, exports) {
 
 	module.exports = require("http");
 
 /***/ },
-/* 4 */
-/***/ function(module, exports) {
-
-	module.exports = require("path");
-
-/***/ },
-/* 5 */
+/* 6 */
 /***/ function(module, exports) {
 
 	"use strict";
@@ -220,7 +273,7 @@
 
 
 /***/ },
-/* 6 */
+/* 7 */
 /***/ function(module, exports) {
 
 	/*

src/Microsoft.AspNetCore.NodeServices/TypeScript/HttpNodeInstanceEntryPoint.ts

@@ -1,5 +1,6 @@
 // Limit dependencies to core Node modules. This means the code in this file has to be very low-level and unattractive,
 // but simplifies things for the consumer of this module.
+import './Util/PatchModuleResolutionLStat';
 import './Util/OverrideStdOutputs';
 import * as http from 'http';
 import * as path from 'path';

src/Microsoft.AspNetCore.NodeServices/TypeScript/Util/PatchModuleResolutionLStat.ts

@@ -0,0 +1,48 @@
+import * as path from 'path';
+const startsWith = (str: string, prefix: string) => str.substring(0, prefix.length) === prefix;
+const appRootDir = process.cwd();
+
+function patchedLStat(pathToStatLong: string) {
+    try {
+        // If the lstat completes without errors, we don't modify its behavior at all
+        return origLStat.apply(this, arguments);
+    } catch(ex) {
+        const shouldOverrideError =
+            startsWith(ex.message, 'EPERM')                     // It's a permissions error
+            && typeof appRootDirLong === 'string'
+            && startsWith(appRootDirLong, pathToStatLong)       // ... for an ancestor directory
+            && ex.stack.indexOf('Object.realpathSync ') >= 0;   // ... during symlink resolution
+
+        if (shouldOverrideError) {
+            // Fake the result to give the same result as an 'lstat' on the app root dir.
+            // This stops Node failing to load modules just because it doesn't know whether
+            // ancestor directories are symlinks or not. If there's a genuine file
+            // permissions issue, it will still surface later when Node actually
+            // tries to read the file.
+            return origLStat.call(this, appRootDir);
+        } else {
+            // In any other case, preserve the original error
+            throw ex;
+        }
+    }
+};
+
+// It's only necessary to apply this workaround on Windows
+let appRootDirLong: string = null;
+let origLStat: Function = null;
+if (/^win/.test(process.platform)) {
+    try {
+        // Get the app's root dir in Node's internal "long" format (e.g., \\?\C:\dir\subdir)
+        appRootDirLong = (path as any)._makeLong(appRootDir);
+
+        // Actually apply the patch, being as defensive as possible
+        const bindingFs = (process as any).binding('fs');
+        origLStat = bindingFs.lstat;
+        if (typeof origLStat === 'function') {
+            bindingFs.lstat = patchedLStat;
+        }
+    } catch(ex) {
+        // If some future version of Node throws (e.g., to prevent use of process.binding()),
+        // don't apply the patch, but still let the application run.
+    }
+}