lib: fix fs.readdir recursive async

Fixes: #56006 PR-URL: #56041 Reviewed-By: Ethan Arrowood <[email protected]> Reviewed-By: Juan José Arboleda <[email protected]>

Author: RafaelGSS

lib/fs.js

@@ -1372,6 +1372,102 @@ function mkdirSync(path, options){
 }
 }
 
+/*
+ * An recursive algorithm for reading the entire contents of the `basePath` directory.
+ * This function does not validate `basePath` as a directory. It is passed directly to
+ * `binding.readdir`.
+ * @param{string} basePath
+ * @param{{encoding: string, withFileTypes: boolean }} options
+ * @param{(
+ * err?: Error,
+ * files?: string[] | Buffer[] | Dirent[]
+ * ) => any} callback
+ * @returns{void}
+*/
+functionreaddirRecursive(basePath,options,callback){
+constcontext={
+withFileTypes: Boolean(options.withFileTypes),
+encoding: options.encoding,
+ basePath,
+readdirResults: [],
+pathsQueue: [basePath],
+};
+
+leti=0;
+
+functionread(path){
+constreq=newFSReqCallback();
+req.oncomplete=(err,result)=>{
+if(err){
+callback(err);
+return;
+}
+
+if(result===undefined){
+callback(null,context.readdirResults);
+return;
+}
+
+processReaddirResult({
+ result,
+currentPath: path,
+ context,
+});
+
+if(i<context.pathsQueue.length){
+read(context.pathsQueue[i++]);
+}else{
+callback(null,context.readdirResults);
+}
+};
+
+binding.readdir(
+path,
+context.encoding,
+context.withFileTypes,
+req,
+);
+}
+
+read(context.pathsQueue[i++]);
+}
+
+// Calling `readdir` with `withFileTypes=true`, the result is an array of arrays.
+// The first array is the names, and the second array is the types.
+// They are guaranteed to be the same length; hence, setting `length` to the length
+// of the first array within the result.
+constprocessReaddirResult=(args)=>(args.context.withFileTypes ? handleDirents(args) : handleFilePaths(args));
+
+functionhandleDirents({ result, currentPath, context }){
+const{0: names,1: types}=result;
+const{ length }=names;
+
+for(leti=0;i<length;i++){
+// Avoid excluding symlinks, as they are not directories.
+// Refs: https://github.com/nodejs/node/issues/52663
+constfullPath=pathModule.join(currentPath,names[i]);
+constdirent=getDirent(currentPath,names[i],types[i]);
+ArrayPrototypePush(context.readdirResults,dirent);
+
+if(dirent.isDirectory()||binding.internalModuleStat(binding,fullPath)===1){
+ArrayPrototypePush(context.pathsQueue,fullPath);
+}
+}
+}
+
+functionhandleFilePaths({ result, currentPath, context }){
+for(leti=0;i<result.length;i++){
+constresultPath=pathModule.join(currentPath,result[i]);
+constrelativeResultPath=pathModule.relative(context.basePath,resultPath);
+conststat=binding.internalModuleStat(binding,resultPath);
+ArrayPrototypePush(context.readdirResults,relativeResultPath);
+
+if(stat===1){
+ArrayPrototypePush(context.pathsQueue,resultPath);
+}
+}
+}
+
 /**
  * An iterative algorithm for reading the entire contents of the `basePath` directory.
  * This function does not validate `basePath` as a directory. It is passed directly to
@@ -1381,58 +1477,37 @@ function mkdirSync(path, options){
  * @returns{string[] | Dirent[]}
  */
 functionreaddirSyncRecursive(basePath,options){
-constwithFileTypes=Boolean(options.withFileTypes);
-constencoding=options.encoding;
-
-constreaddirResults=[];
-constpathsQueue=[basePath];
+constcontext={
+withFileTypes: Boolean(options.withFileTypes),
+encoding: options.encoding,
+ basePath,
+readdirResults: [],
+pathsQueue: [basePath],
+};
 
 functionread(path){
 constreaddirResult=binding.readdir(
 path,
-encoding,
-withFileTypes,
+context.encoding,
+context.withFileTypes,
 );
 
 if(readdirResult===undefined){
 return;
 }
 
-if(withFileTypes){
-// Calling `readdir` with `withFileTypes=true`, the result is an array of arrays.
-// The first array is the names, and the second array is the types.
-// They are guaranteed to be the same length; hence, setting `length` to the length
-// of the first array within the result.
-constlength=readdirResult[0].length;
-for(leti=0;i<length;i++){
-// Avoid excluding symlinks, as they are not directories.
-// Refs: https://github.com/nodejs/node/issues/52663
-conststat=binding.internalModuleStat(binding,pathModule.join(path,readdirResult[0][i]));
-constdirent=getDirent(path,readdirResult[0][i],readdirResult[1][i]);
-ArrayPrototypePush(readdirResults,dirent);
-if(dirent.isDirectory()||stat===1){
-ArrayPrototypePush(pathsQueue,pathModule.join(dirent.parentPath,dirent.name));
-}
-}
-}else{
-for(leti=0;i<readdirResult.length;i++){
-constresultPath=pathModule.join(path,readdirResult[i]);
-constrelativeResultPath=pathModule.relative(basePath,resultPath);
-conststat=binding.internalModuleStat(binding,resultPath);
-ArrayPrototypePush(readdirResults,relativeResultPath);
-// 1 indicates directory
-if(stat===1){
-ArrayPrototypePush(pathsQueue,resultPath);
-}
-}
-}
+processReaddirResult({
+result: readdirResult,
+currentPath: path,
+ context,
+});
 }
 
-for(leti=0;i<pathsQueue.length;i++){
-read(pathsQueue[i]);
+for(leti=0;i<context.pathsQueue.length;i++){
+read(context.pathsQueue[i]);
 }
 
-returnreaddirResults;
+returncontext.readdirResults;
 }
 
 /**
@@ -1458,7 +1533,7 @@ function readdir(path, options, callback){
 }
 
 if(options.recursive){
-callback(null,readdirSyncRecursive(path,options));
+readdirRecursive(path,options,callback);
 return;
 }
 

test/fixtures/permission/fs-read.js

@@ -289,6 +289,11 @@ const regularFile = __filename;
 permission: 'FileSystemRead',
 resource: path.toNamespacedPath(blockedFolder),
 }));
+fs.readdir(blockedFolder,{recursive: true},common.expectsError({
+code: 'ERR_ACCESS_DENIED',
+permission: 'FileSystemRead',
+resource: path.toNamespacedPath(blockedFolder),
+}));
 assert.throws(()=>{
 fs.readdirSync(blockedFolder);
 },common.expectsError({