// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

// Maintainers, keep in mind that ES1-style octal literals (`0666`) are not

// allowed in strict mode. Use ES6-style octal literals instead (`0o666`).

'use strict';

const { Math, Object } = primordials;

const { fs: constants } = internalBinding('constants');

const {

S_IFIFO,

S_IFLNK,

S_IFMT,

S_IFREG,

S_IFSOCK,

F_OK,

R_OK,

W_OK,

X_OK,

O_WRONLY,

O_SYMLINK

} = constants;

const pathModule = require('path');

const { isArrayBufferView } = require('internal/util/types');

const binding = internalBinding('fs');

const { Buffer, kMaxLength } = require('buffer');

const {

codes: {

ERR_FS_FILE_TOO_LARGE,

ERR_INVALID_ARG_VALUE,

ERR_INVALID_ARG_TYPE,

ERR_INVALID_CALLBACK

},

uvException

} = require('internal/errors');

const { FSReqCallback, statValues } = binding;

const { toPathIfFileURL } = require('internal/url');

const internalUtil = require('internal/util');

const {

copyObject,

Dirent,

getDirents,

getOptions,

getValidatedPath,

nullCheck,

preprocessSymlinkDestination,

Stats,

getStatsFromBinding,

realpathCacheKey,

stringToFlags,

stringToSymlinkType,

toUnixTimestamp,

validateBufferArray,

validateOffsetLengthRead,

validateOffsetLengthWrite,

validatePath,

validateRmdirOptions,

warnOnNonPortableTemplate

} = require('internal/fs/utils');

const {

CHAR_FORWARD_SLASH,

CHAR_BACKWARD_SLASH,

} = require('internal/constants');

const {

isUint32,

parseMode,

validateBuffer,

validateInteger,

validateInt32,

validateUint32

} = require('internal/validators');

let truncateWarn = true;

let fs;

// Lazy loaded

let promises = null;

let watchers;

let ReadFileContext;

let ReadStream;

let WriteStream;

let rimraf;

let rimrafSync;

// These have to be separate because of how graceful-fs happens to do it's

// monkeypatching.

let FileReadStream;

let FileWriteStream;

const isWindows = process.platform === 'win32';

function showTruncateDeprecation() {

if (truncateWarn) {

process.emitWarning(

'Using fs.truncate with a file descriptor is deprecated. Please use ' +

'fs.ftruncate with a file descriptor instead.',

'DeprecationWarning', 'DEP0081');

truncateWarn = false;

}

}

function handleErrorFromBinding(ctx) {

if (ctx.errno !== undefined) { // libuv error numbers

const err = uvException(ctx);

// eslint-disable-next-line no-restricted-syntax

Error.captureStackTrace(err, handleErrorFromBinding);

throw err;

}

if (ctx.error !== undefined) { // Errors created in C++ land.

// TODO(joyeecheung): currently, ctx.error are encoding errors

// usually caused by memory problems. We need to figure out proper error

// code(s) for this.

// eslint-disable-next-line no-restricted-syntax

Error.captureStackTrace(ctx.error, handleErrorFromBinding);

throw ctx.error;

}

}

function maybeCallback(cb) {

if (typeof cb === 'function')

return cb;

throw new ERR_INVALID_CALLBACK(cb);

}

// Ensure that callbacks run in the global context. Only use this function

// for callbacks that are passed to the binding layer, callbacks that are

// invoked from JS already run in the proper scope.

function makeCallback(cb) {

if (typeof cb !== 'function') {

throw new ERR_INVALID_CALLBACK(cb);

}

return (...args) => cb(...args);

}

// Special case of `makeCallback()` that is specific to async `*stat()` calls as

// an optimization, since the data passed back to the callback needs to be

// transformed anyway.

function makeStatsCallback(cb) {

if (typeof cb !== 'function') {

throw new ERR_INVALID_CALLBACK(cb);

}

return (err, stats) => {

if (err) return cb(err);

cb(err, getStatsFromBinding(stats));

};

}

const isFd = isUint32;

function isFileType(stats, fileType) {

// Use stats array directly to avoid creating an fs.Stats instance just for

// our internal use.

return (stats[1/* mode */] & S_IFMT) === fileType;

}

function access(path, mode, callback) {

if (typeof mode === 'function') {

callback = mode;

mode = F_OK;

}

path = getValidatedPath(path);

mode = mode | 0;

const req = new FSReqCallback();

req.oncomplete = makeCallback(callback);

binding.access(pathModule.toNamespacedPath(path), mode, req);

}

function accessSync(path, mode) {

path = getValidatedPath(path);

if (mode === undefined)

mode = F_OK;

else

mode = mode | 0;

const ctx = { path };

binding.access(pathModule.toNamespacedPath(path), mode, undefined, ctx);

handleErrorFromBinding(ctx);

}

function exists(path, callback) {

maybeCallback(callback);

function suppressedCallback(err) {

callback(err ? false : true);

}

try {

fs.access(path, F_OK, suppressedCallback);

} catch {

return callback(false);

}

}

Object.defineProperty(exists, internalUtil.promisify.custom, {

value: (path) => {

return new Promise((resolve) => fs.exists(path, resolve));

}

});

// fs.existsSync never throws, it only returns true or false.

// Since fs.existsSync never throws, users have established

// the expectation that passing invalid arguments to it, even like

// fs.existsSync(), would only get a false in return, so we cannot signal

// validation errors to users properly out of compatibility concerns.

// TODO(joyeecheung): deprecate the never-throw-on-invalid-arguments behavior

function existsSync(path) {

try {

path = getValidatedPath(path);

} catch {

return false;

}

const ctx = { path };

binding.access(pathModule.toNamespacedPath(path), F_OK, undefined, ctx);

return ctx.errno === undefined;

}

function readFileAfterOpen(err, fd) {

const context = this.context;

if (err) {

context.callback(err);

return;

}

context.fd = fd;

const req = new FSReqCallback();

req.oncomplete = readFileAfterStat;

req.context = context;

binding.fstat(fd, false, req);

}

function readFileAfterStat(err, stats) {

const context = this.context;

if (err)

return context.close(err);

const size = context.size = isFileType(stats, S_IFREG) ? stats[8] : 0;

if (size > kMaxLength) {

err = new ERR_FS_FILE_TOO_LARGE(size);

return context.close(err);

}

try {

if (size === 0) {

context.buffers = [];

} else {

context.buffer = Buffer.allocUnsafeSlow(size);

}

} catch (err) {

return context.close(err);

}

context.read();

}

function readFile(path, options, callback) {

callback = maybeCallback(callback || options);

options = getOptions(options, { flag: 'r' });

if (!ReadFileContext)

ReadFileContext = require('internal/fs/read_file_context');

const context = new ReadFileContext(callback, options.encoding);

context.isUserFd = isFd(path); // File descriptor ownership

const req = new FSReqCallback();

req.context = context;

req.oncomplete = readFileAfterOpen;

if (context.isUserFd) {

process.nextTick(function tick() {

req.oncomplete(null, path);

});

return;

}

path = getValidatedPath(path);

binding.open(pathModule.toNamespacedPath(path),

stringToFlags(options.flag || 'r'),

0o666,

req);

}

function tryStatSync(fd, isUserFd) {

const ctx = {};

const stats = binding.fstat(fd, false, undefined, ctx);

if (ctx.errno !== undefined && !isUserFd) {

fs.closeSync(fd);

throw uvException(ctx);

}

return stats;

}

function tryCreateBuffer(size, fd, isUserFd) {

let threw = true;

let buffer;

try {

if (size > kMaxLength) {

throw new ERR_FS_FILE_TOO_LARGE(size);

}

buffer = Buffer.allocUnsafe(size);

threw = false;

} finally {

if (threw && !isUserFd) fs.closeSync(fd);

}

return buffer;

}

function tryReadSync(fd, isUserFd, buffer, pos, len) {

let threw = true;

let bytesRead;

try {

bytesRead = fs.readSync(fd, buffer, pos, len);

threw = false;

} finally {

if (threw && !isUserFd) fs.closeSync(fd);

}

return bytesRead;

}

function readFileSync(path, options) {

options = getOptions(options, { flag: 'r' });

const isUserFd = isFd(path); // File descriptor ownership

const fd = isUserFd ? path : fs.openSync(path, options.flag, 0o666);

const stats = tryStatSync(fd, isUserFd);

const size = isFileType(stats, S_IFREG) ? stats[8] : 0;

let pos = 0;

let buffer; // Single buffer with file data

let buffers; // List for when size is unknown

if (size === 0) {

buffers = [];

} else {

buffer = tryCreateBuffer(size, fd, isUserFd);

}

let bytesRead;

if (size !== 0) {

do {

bytesRead = tryReadSync(fd, isUserFd, buffer, pos, size - pos);

pos += bytesRead;

} while (bytesRead !== 0 && pos < size);

} else {

do {

// The kernel lies about many files.

// Go ahead and try to read some bytes.

buffer = Buffer.allocUnsafe(8192);

bytesRead = tryReadSync(fd, isUserFd, buffer, 0, 8192);

if (bytesRead !== 0) {

buffers.push(buffer.slice(0, bytesRead));

}

pos += bytesRead;

} while (bytesRead !== 0);

}

if (!isUserFd)

fs.closeSync(fd);

if (size === 0) {

// Data was collected into the buffers list.

buffer = Buffer.concat(buffers, pos);

} else if (pos < size) {

buffer = buffer.slice(0, pos);

}

if (options.encoding) buffer = buffer.toString(options.encoding);

return buffer;

}

function close(fd, callback) {

validateInt32(fd, 'fd', 0);

const req = new FSReqCallback();

req.oncomplete = makeCallback(callback);

binding.close(fd, req);

}

function closeSync(fd) {

validateInt32(fd, 'fd', 0);

const ctx = {};

binding.close(fd, undefined, ctx);

handleErrorFromBinding(ctx);

}

function open(path, flags, mode, callback) {

path = getValidatedPath(path);

if (arguments.length < 3) {

callback = flags;

flags = 'r';

mode = 0o666;

} else if (typeof mode === 'function') {

callback = mode;

mode = 0o666;

}

const flagsNumber = stringToFlags(flags);

if (arguments.length >= 4) {

mode = parseMode(mode, 'mode', 0o666);

}

callback = makeCallback(callback);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.open(pathModule.toNamespacedPath(path),

flagsNumber,

mode,

req);

}

function openSync(path, flags, mode) {

path = getValidatedPath(path);

const flagsNumber = stringToFlags(flags || 'r');

mode = parseMode(mode, 'mode', 0o666);

const ctx = { path };

const result = binding.open(pathModule.toNamespacedPath(path),

flagsNumber, mode,

undefined, ctx);

handleErrorFromBinding(ctx);

return result;

}

function read(fd, buffer, offset, length, position, callback) {

validateInt32(fd, 'fd', 0);

validateBuffer(buffer);

callback = maybeCallback(callback);

offset |= 0;

length |= 0;

if (length === 0) {

return process.nextTick(function tick() {

callback(null, 0, buffer);

});

}

if (buffer.byteLength === 0) {

throw new ERR_INVALID_ARG_VALUE('buffer', buffer,

'is empty and cannot be written');

}

validateOffsetLengthRead(offset, length, buffer.byteLength);

if (!Number.isSafeInteger(position))

position = -1;

function wrapper(err, bytesRead) {

// Retain a reference to buffer so that it can't be GC'ed too soon.

callback(err, bytesRead || 0, buffer);

}

const req = new FSReqCallback();

req.oncomplete = wrapper;

binding.read(fd, buffer, offset, length, position, req);

}

Object.defineProperty(read, internalUtil.customPromisifyArgs,

{ value: ['bytesRead', 'buffer'], enumerable: false });

function readSync(fd, buffer, offset, length, position) {

validateInt32(fd, 'fd', 0);

validateBuffer(buffer);

offset |= 0;

length |= 0;

if (length === 0) {

return 0;

}

if (buffer.byteLength === 0) {

throw new ERR_INVALID_ARG_VALUE('buffer', buffer,

'is empty and cannot be written');

}

validateOffsetLengthRead(offset, length, buffer.byteLength);

if (!Number.isSafeInteger(position))

position = -1;

const ctx = {};

const result = binding.read(fd, buffer, offset, length, position,

undefined, ctx);

handleErrorFromBinding(ctx);

return result;

}

// usage:

// fs.write(fd, buffer[, offset[, length[, position]]], callback);

// OR

// fs.write(fd, string[, position[, encoding]], callback);

function write(fd, buffer, offset, length, position, callback) {

function wrapper(err, written) {

// Retain a reference to buffer so that it can't be GC'ed too soon.

callback(err, written || 0, buffer);

}

validateInt32(fd, 'fd', 0);

const req = new FSReqCallback();

req.oncomplete = wrapper;

if (isArrayBufferView(buffer)) {

callback = maybeCallback(callback || position || length || offset);

if (typeof offset !== 'number')

offset = 0;

if (typeof length !== 'number')

length = buffer.length - offset;

if (typeof position !== 'number')

position = null;

validateOffsetLengthWrite(offset, length, buffer.byteLength);

return binding.writeBuffer(fd, buffer, offset, length, position, req);

}

if (typeof buffer !== 'string')

buffer += '';

if (typeof position !== 'function') {

if (typeof offset === 'function') {

position = offset;

offset = null;

} else {

position = length;

}

length = 'utf8';

}

callback = maybeCallback(position);

return binding.writeString(fd, buffer, offset, length, req);

}

Object.defineProperty(write, internalUtil.customPromisifyArgs,

{ value: ['bytesWritten', 'buffer'], enumerable: false });

// Usage:

// fs.writeSync(fd, buffer[, offset[, length[, position]]]);

// OR

// fs.writeSync(fd, string[, position[, encoding]]);

function writeSync(fd, buffer, offset, length, position) {

validateInt32(fd, 'fd', 0);

const ctx = {};

let result;

if (isArrayBufferView(buffer)) {

if (position === undefined)

position = null;

if (typeof offset !== 'number')

offset = 0;

if (typeof length !== 'number')

length = buffer.byteLength - offset;

validateOffsetLengthWrite(offset, length, buffer.byteLength);

result = binding.writeBuffer(fd, buffer, offset, length, position,

undefined, ctx);

} else {

if (typeof buffer !== 'string')

buffer += '';

if (offset === undefined)

offset = null;

result = binding.writeString(fd, buffer, offset, length,

undefined, ctx);

}

handleErrorFromBinding(ctx);

return result;

}

// usage:

// fs.writev(fd, buffers[, position], callback);

function writev(fd, buffers, position, callback) {

function wrapper(err, written) {

callback(err, written || 0, buffers);

}

validateInt32(fd, 'fd', 0);

validateBufferArray(buffers);

const req = new FSReqCallback();

req.oncomplete = wrapper;

callback = maybeCallback(callback || position);

if (typeof position !== 'number')

position = null;

return binding.writeBuffers(fd, buffers, position, req);

}

Object.defineProperty(writev, internalUtil.customPromisifyArgs, {

value: ['bytesWritten', 'buffer'],

enumerable: false

});

function writevSync(fd, buffers, position) {

validateInt32(fd, 'fd', 0);

validateBufferArray(buffers);

const ctx = {};

if (typeof position !== 'number')

position = null;

const result = binding.writeBuffers(fd, buffers, position, undefined, ctx);

handleErrorFromBinding(ctx);

return result;

}

function rename(oldPath, newPath, callback) {

callback = makeCallback(callback);

oldPath = getValidatedPath(oldPath, 'oldPath');

newPath = getValidatedPath(newPath, 'newPath');

const req = new FSReqCallback();

req.oncomplete = callback;

binding.rename(pathModule.toNamespacedPath(oldPath),

pathModule.toNamespacedPath(newPath),

req);

}

function renameSync(oldPath, newPath) {

oldPath = getValidatedPath(oldPath, 'oldPath');

newPath = getValidatedPath(newPath, 'newPath');

const ctx = { path: oldPath, dest: newPath };

binding.rename(pathModule.toNamespacedPath(oldPath),

pathModule.toNamespacedPath(newPath), undefined, ctx);

handleErrorFromBinding(ctx);

}

function truncate(path, len, callback) {

if (typeof path === 'number') {

showTruncateDeprecation();

return fs.ftruncate(path, len, callback);

}

if (typeof len === 'function') {

callback = len;

len = 0;

} else if (len === undefined) {

len = 0;

}

validateInteger(len, 'len');

callback = maybeCallback(callback);

fs.open(path, 'r+', (er, fd) => {

if (er) return callback(er);

const req = new FSReqCallback();

req.oncomplete = function oncomplete(er) {

fs.close(fd, (er2) => {

callback(er || er2);

});

};

binding.ftruncate(fd, len, req);

});

}

function truncateSync(path, len) {

if (typeof path === 'number') {

// legacy

showTruncateDeprecation();

return fs.ftruncateSync(path, len);

}

if (len === undefined) {

len = 0;

}

// Allow error to be thrown, but still close fd.

const fd = fs.openSync(path, 'r+');

let ret;

try {

ret = fs.ftruncateSync(fd, len);

} finally {

fs.closeSync(fd);

}

return ret;

}

function ftruncate(fd, len = 0, callback) {

if (typeof len === 'function') {

callback = len;

len = 0;

}

validateInt32(fd, 'fd', 0);

validateInteger(len, 'len');

len = Math.max(0, len);

const req = new FSReqCallback();

req.oncomplete = makeCallback(callback);

binding.ftruncate(fd, len, req);

}

function ftruncateSync(fd, len = 0) {

validateInt32(fd, 'fd', 0);

validateInteger(len, 'len');

len = Math.max(0, len);

const ctx = {};

binding.ftruncate(fd, len, undefined, ctx);

handleErrorFromBinding(ctx);

}

function lazyLoadRimraf() {

if (rimraf === undefined)

({ rimraf, rimrafSync } = require('internal/fs/rimraf'));

}

function rmdir(path, options, callback) {

if (typeof options === 'function') {

callback = options;

options = undefined;

}

callback = makeCallback(callback);

path = pathModule.toNamespacedPath(getValidatedPath(path));

options = validateRmdirOptions(options);

if (options.recursive) {

lazyLoadRimraf();

return rimraf(path, options, callback);

}

const req = new FSReqCallback();

req.oncomplete = callback;

binding.rmdir(path, req);

}

function rmdirSync(path, options) {

path = getValidatedPath(path);

options = validateRmdirOptions(options);

if (options.recursive) {

lazyLoadRimraf();

return rimrafSync(pathModule.toNamespacedPath(path), options);

}

const ctx = { path };

binding.rmdir(pathModule.toNamespacedPath(path), undefined, ctx);

handleErrorFromBinding(ctx);

}

function fdatasync(fd, callback) {

validateInt32(fd, 'fd', 0);

const req = new FSReqCallback();

req.oncomplete = makeCallback(callback);

binding.fdatasync(fd, req);

}

function fdatasyncSync(fd) {

validateInt32(fd, 'fd', 0);

const ctx = {};

binding.fdatasync(fd, undefined, ctx);

handleErrorFromBinding(ctx);

}

function fsync(fd, callback) {

validateInt32(fd, 'fd', 0);

const req = new FSReqCallback();

req.oncomplete = makeCallback(callback);

binding.fsync(fd, req);

}

function fsyncSync(fd) {

validateInt32(fd, 'fd', 0);

const ctx = {};

binding.fsync(fd, undefined, ctx);

handleErrorFromBinding(ctx);

}

function mkdir(path, options, callback) {

if (typeof options === 'function') {

callback = options;

options = {};

} else if (typeof options === 'number' || typeof options === 'string') {

options = { mode: options };

}

const {

recursive = false,

mode = 0o777

} = options || {};

callback = makeCallback(callback);

path = getValidatedPath(path);

if (typeof recursive !== 'boolean')

throw new ERR_INVALID_ARG_TYPE('recursive', 'boolean', recursive);

const req = new FSReqCallback();

req.oncomplete = callback;

binding.mkdir(pathModule.toNamespacedPath(path),

parseMode(mode, 'mode', 0o777), recursive, req);

}

function mkdirSync(path, options) {

if (typeof options === 'number' || typeof options === 'string') {

options = { mode: options };

}

const {

recursive = false,

mode = 0o777

} = options || {};

path = getValidatedPath(path);

if (typeof recursive !== 'boolean')

throw new ERR_INVALID_ARG_TYPE('recursive', 'boolean', recursive);

const ctx = { path };

binding.mkdir(pathModule.toNamespacedPath(path),

parseMode(mode, 'mode', 0o777), recursive, undefined,

ctx);

handleErrorFromBinding(ctx);

}

function readdir(path, options, callback) {

callback = makeCallback(typeof options === 'function' ? options : callback);

options = getOptions(options, {});

path = getValidatedPath(path);

const req = new FSReqCallback();

if (!options.withFileTypes) {

req.oncomplete = callback;

} else {

req.oncomplete = (err, result) => {

if (err) {

callback(err);

return;

}

getDirents(path, result, callback);

};

}

binding.readdir(pathModule.toNamespacedPath(path), options.encoding,

!!options.withFileTypes, req);

}

function readdirSync(path, options) {

options = getOptions(options, {});

path = getValidatedPath(path);

const ctx = { path };

const result = binding.readdir(pathModule.toNamespacedPath(path),

options.encoding, !!options.withFileTypes,

undefined, ctx);

handleErrorFromBinding(ctx);

return options.withFileTypes ? getDirents(path, result) : result;

}

function fstat(fd, options = { bigint: false }, callback) {

if (typeof options === 'function') {

callback = options;

options = {};

}

validateInt32(fd, 'fd', 0);

const req = new FSReqCallback(options.bigint);

req.oncomplete = makeStatsCallback(callback);

binding.fstat(fd, options.bigint, req);

}

function lstat(path, options = { bigint: false }, callback) {

if (typeof options === 'function') {

callback = options;

options = {};

}

callback = makeStatsCallback(callback);

path = getValidatedPath(path);

const req = new FSReqCallback(options.bigint);

req.oncomplete = callback;

binding.lstat(pathModule.toNamespacedPath(path), options.bigint, req);

}

function stat(path, options = { bigint: false }, callback) {

if (typeof options === 'function') {

callback = options;

options = {};

}

callback = makeStatsCallback(callback);

path = getValidatedPath(path);

const req = new FSReqCallback(options.bigint);

req.oncomplete = callback;

binding.stat(pathModule.toNamespacedPath(path), options.bigint, req);

}

function fstatSync(fd, options = {}) {

validateInt32(fd, 'fd', 0);

const ctx = { fd };

const stats = binding.fstat(fd, options.bigint, undefined, ctx);

handleErrorFromBinding(ctx);

return getStatsFromBinding(stats);

}

function lstatSync(path, options = {}) {

path = getValidatedPath(path);

const ctx = { path };

const stats = binding.lstat(pathModule.toNamespacedPath(path),

options.bigint, undefined, ctx);

handleErrorFromBinding(ctx);

return getStatsFromBinding(stats);

}

function statSync(path, options = {}) {

path = getValidatedPath(path);

const ctx = { path };

const stats = binding.stat(pathModule.toNamespacedPath(path),

options.bigint, undefined, ctx);

handleErrorFromBinding(ctx);

return getStatsFromBinding(stats);

}

function readlink(path, options, callback) {

callback = makeCallback(typeof options === 'function' ? options : callback);

options = getOptions(options, {});

path = getValidatedPath(path, 'oldPath');

const req = new FSReqCallback();

req.oncomplete = callback;

binding.readlink(pathModule.toNamespacedPath(path), options.encoding, req);

}

function readlinkSync(path, options) {

options = getOptions(options, {});

path = getValidatedPath(path, 'oldPath');

const ctx = { path };

const result = binding.readlink(pathModule.toNamespacedPath(path),

options.encoding, undefined, ctx);

handleErrorFromBinding(ctx);

return result;

}

function symlink(target, path, type_, callback_) {

const type = (typeof type_ === 'string' ? type_ : null);

const callback = makeCallback(arguments[arguments.length - 1]);

target = getValidatedPath(target, 'target');

path = getValidatedPath(path);

const req = new FSReqCallback();

req.oncomplete = callback;

if (isWindows && type === null) {

let absoluteTarget;

try {

// Symlinks targets can be relative to the newly created path.

// Calculate absolute file name of the symlink target, and check

// if it is a directory. Ignore resolve error to keep symlink

// errors consistent between platforms if invalid path is

// provided.

absoluteTarget = pathModule.resolve(path, '..', target);

} catch { }

if (absoluteTarget !== undefined) {

stat(absoluteTarget, (err, stat) => {

const resolvedType = !err && stat.isDirectory() ? 'dir' : 'file';

const resolvedFlags = stringToSymlinkType(resolvedType);

binding.symlink(preprocessSymlinkDestination(target,

resolvedType,

path),

pathModule.toNamespacedPath(path), resolvedFlags, req);

});

return;

}

}

const flags = stringToSymlinkType(type);

binding.symlink(preprocessSymlinkDestination(target, type, path),

pathModule.toNamespacedPath(path), flags, req);

}

function symlinkSync(target, path, type) {

type = (typeof type === 'string' ? type : null);

if (isWindows && type === null) {

try {

const absoluteTarget = pathModule.resolve(path, '..', target);

if (statSync(absoluteTarget).isDirectory()) {

type = 'dir';

}

} catch { }

}

target = getValidatedPath(target, 'target');

path = getValidatedPath(path);

const flags = stringToSymlinkType(type);