// 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 constants = process.binding('constants').fs;

const util = require('util');

const pathModule = require('path');

const { isUint8Array } = process.binding('util');

const binding = process.binding('fs');

const fs = exports;

const Buffer = require('buffer').Buffer;

const Stream = require('stream').Stream;

const EventEmitter = require('events');

const FSReqWrap = binding.FSReqWrap;

const FSEvent = process.binding('fs_event_wrap').FSEvent;

const internalFS = require('internal/fs');

const assertEncoding = internalFS.assertEncoding;

const stringToFlags = internalFS.stringToFlags;

const SyncWriteStream = internalFS.SyncWriteStream;

Object.defineProperty(exports, 'constants', {

configurable: false,

enumerable: true,

value: constants

});

const Readable = Stream.Readable;

const Writable = Stream.Writable;

const kMinPoolSpace = 128;

const kMaxLength = require('buffer').kMaxLength;

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

const DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);

const errnoException = util._errnoException;

function getOptions(options, defaultOptions) {

if (options === null || options === undefined ||

typeof options === 'function') {

return defaultOptions;

}

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

defaultOptions = util._extend({}, defaultOptions);

defaultOptions.encoding = options;

options = defaultOptions;

} else if (typeof options !== 'object') {

throw new TypeError('"options" must be a string or an object, got ' +

typeof options + ' instead.');

}

if (options.encoding !== 'buffer')

assertEncoding(options.encoding);

return options;

}

function copyObject(source) {

const target = {};

for (const key in source)

target[key] = source[key];

return target;

}

function rethrow() {

// TODO(thefourtheye) Throw error instead of warning in major version > 7

process.emitWarning(

'Calling an asynchronous function without callback is deprecated.',

'DeprecationWarning',

rethrow

);

// Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and

// is fairly slow to generate.

if (DEBUG) {

var backtrace = new Error();

return function(err) {

if (err) {

backtrace.stack = err.name + ': ' + err.message +

backtrace.stack.substr(backtrace.name.length);

throw backtrace;

}

};

}

return function(err) {

if (err) {

throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs

}

};

}

function maybeCallback(cb) {

return typeof cb === 'function' ? cb : rethrow();

}

// 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 (cb === undefined) {

return rethrow();

}

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

throw new TypeError('"callback" argument must be a function');

}

return function() {

return cb.apply(null, arguments);

};

}

function nullCheck(path, callback) {

if (('' + path).indexOf('\u0000') !== -1) {

var er = new Error('Path must be a string without null bytes');

er.code = 'ENOENT';

if (typeof callback !== 'function')

throw er;

process.nextTick(callback, er);

return false;

}

return true;

}

function isFd(path) {

return (path >>> 0) === path;

}

// Static method to set the stats properties on a Stats object.

fs.Stats = function(

dev,

mode,

nlink,

uid,

gid,

rdev,

blksize,

ino,

size,

blocks,

atim_msec,

mtim_msec,

ctim_msec,

birthtim_msec) {

this.dev = dev;

this.mode = mode;

this.nlink = nlink;

this.uid = uid;

this.gid = gid;

this.rdev = rdev;

this.blksize = blksize;

this.ino = ino;

this.size = size;

this.blocks = blocks;

this.atime = new Date(atim_msec);

this.mtime = new Date(mtim_msec);

this.ctime = new Date(ctim_msec);

this.birthtime = new Date(birthtim_msec);

};

// Create a C++ binding to the function which creates a Stats object.

binding.FSInitialize(fs.Stats);

fs.Stats.prototype._checkModeProperty = function(property) {

return ((this.mode & constants.S_IFMT) === property);

};

fs.Stats.prototype.isDirectory = function() {

return this._checkModeProperty(constants.S_IFDIR);

};

fs.Stats.prototype.isFile = function() {

return this._checkModeProperty(constants.S_IFREG);

};

fs.Stats.prototype.isBlockDevice = function() {

return this._checkModeProperty(constants.S_IFBLK);

};

fs.Stats.prototype.isCharacterDevice = function() {

return this._checkModeProperty(constants.S_IFCHR);

};

fs.Stats.prototype.isSymbolicLink = function() {

return this._checkModeProperty(constants.S_IFLNK);

};

fs.Stats.prototype.isFIFO = function() {

return this._checkModeProperty(constants.S_IFIFO);

};

fs.Stats.prototype.isSocket = function() {

return this._checkModeProperty(constants.S_IFSOCK);

};

// Don't allow mode to accidentally be overwritten.

['F_OK', 'R_OK', 'W_OK', 'X_OK'].forEach(function(key) {

Object.defineProperty(fs, key, {

enumerable: true, value: constants[key] || 0, writable: false

});

});

fs.access = function(path, mode, callback) {

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

callback = mode;

mode = fs.F_OK;

} else if (typeof callback !== 'function') {

throw new TypeError('"callback" argument must be a function');

}

if (!nullCheck(path, callback))

return;

mode = mode | 0;

var req = new FSReqWrap();

req.oncomplete = makeCallback(callback);

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

};

fs.accessSync = function(path, mode) {

nullCheck(path);

if (mode === undefined)

mode = fs.F_OK;

else

mode = mode | 0;

binding.access(pathModule._makeLong(path), mode);

};

fs.exists = function(path, callback) {

if (!nullCheck(path, cb)) return;

var req = new FSReqWrap();

req.oncomplete = cb;

binding.stat(pathModule._makeLong(path), req);

function cb(err, stats) {

if (callback) callback(err ? false : true);

}

};

fs.existsSync = function(path) {

try {

nullCheck(path);

binding.stat(pathModule._makeLong(path));

return true;

} catch (e) {

return false;

}

};

fs.readFile = function(path, options, callback) {

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

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

if (!nullCheck(path, callback))

return;

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

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

var req = new FSReqWrap();

req.context = context;

req.oncomplete = readFileAfterOpen;

if (context.isUserFd) {

process.nextTick(function() {

req.oncomplete(null, path);

});

return;

}

binding.open(pathModule._makeLong(path),

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

0o666,

req);

};

const kReadFileBufferLength = 8 * 1024;

function ReadFileContext(callback, encoding) {

this.fd = undefined;

this.isUserFd = undefined;

this.size = undefined;

this.callback = callback;

this.buffers = null;

this.buffer = null;

this.pos = 0;

this.encoding = encoding;

this.err = null;

}

ReadFileContext.prototype.read = function() {

var buffer;

var offset;

var length;

if (this.size === 0) {

buffer = this.buffer = Buffer.allocUnsafeSlow(kReadFileBufferLength);

offset = 0;

length = kReadFileBufferLength;

} else {

buffer = this.buffer;

offset = this.pos;

length = this.size - this.pos;

}

var req = new FSReqWrap();

req.oncomplete = readFileAfterRead;

req.context = this;

binding.read(this.fd, buffer, offset, length, -1, req);

};

ReadFileContext.prototype.close = function(err) {

var req = new FSReqWrap();

req.oncomplete = readFileAfterClose;

req.context = this;

this.err = err;

if (this.isUserFd) {

process.nextTick(function() {

req.oncomplete(null);

});

return;

}

binding.close(this.fd, req);

};

function readFileAfterOpen(err, fd) {

var context = this.context;

if (err) {

context.callback(err);

return;

}

context.fd = fd;

var req = new FSReqWrap();

req.oncomplete = readFileAfterStat;

req.context = context;

binding.fstat(fd, req);

}

function readFileAfterStat(err, st) {

var context = this.context;

if (err)

return context.close(err);

var size = context.size = st.isFile() ? st.size : 0;

if (size === 0) {

context.buffers = [];

context.read();

return;

}

if (size > kMaxLength) {

err = new RangeError('File size is greater than possible Buffer: ' +

`0x${kMaxLength.toString(16)} bytes`);

return context.close(err);

}

context.buffer = Buffer.allocUnsafeSlow(size);

context.read();

}

function readFileAfterRead(err, bytesRead) {

var context = this.context;

if (err)

return context.close(err);

if (bytesRead === 0)

return context.close();

context.pos += bytesRead;

if (context.size !== 0) {

if (context.pos === context.size)

context.close();

else

context.read();

} else {

// unknown size, just read until we don't get bytes.

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

context.read();

}

}

function readFileAfterClose(err) {

var context = this.context;

var buffer = null;

var callback = context.callback;

if (context.err || err)

return callback(context.err || err);

if (context.size === 0)

buffer = Buffer.concat(context.buffers, context.pos);

else if (context.pos < context.size)

buffer = context.buffer.slice(0, context.pos);

else

buffer = context.buffer;

if (context.encoding) {

return tryToString(buffer, context.encoding, callback);

}

callback(null, buffer);

}

function tryToString(buf, encoding, callback) {

try {

buf = buf.toString(encoding);

} catch (err) {

return callback(err);

}

callback(null, buf);

}

function tryStatSync(fd, isUserFd) {

var threw = true;

var st;

try {

st = fs.fstatSync(fd);

threw = false;

} finally {

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

}

return st;

}

function tryCreateBuffer(size, fd, isUserFd) {

var threw = true;

var buffer;

try {

buffer = Buffer.allocUnsafe(size);

threw = false;

} finally {

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

}

return buffer;

}

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

var threw = true;

var bytesRead;

try {

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

threw = false;

} finally {

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

}

return bytesRead;

}

fs.readFileSync = function(path, options) {

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

var isUserFd = isFd(path); // file descriptor ownership

var fd = isUserFd ? path : fs.openSync(path, options.flag || 'r', 0o666);

var st = tryStatSync(fd, isUserFd);

var size = st.isFile() ? st.size : 0;

var pos = 0;

var buffer; // single buffer with file data

var buffers; // list for when size is unknown

if (size === 0) {

buffers = [];

} else {

buffer = tryCreateBuffer(size, fd, isUserFd);

}

var 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;

};

// Yes, the follow could be easily DRYed up but I provide the explicit

// list to make the arguments clear.

fs.close = function(fd, callback) {

var req = new FSReqWrap();

req.oncomplete = makeCallback(callback);

binding.close(fd, req);

};

fs.closeSync = function(fd) {

return binding.close(fd);

};

function modeNum(m, def) {

if (typeof m === 'number')

return m;

if (typeof m === 'string')

return parseInt(m, 8);

if (def)

return modeNum(def);

return undefined;

}

fs.open = function(path, flags, mode, callback_) {

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

mode = modeNum(mode, 0o666);

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.open(pathModule._makeLong(path),

stringToFlags(flags),

mode,

req);

};

fs.openSync = function(path, flags, mode) {

mode = modeNum(mode, 0o666);

nullCheck(path);

return binding.open(pathModule._makeLong(path), stringToFlags(flags), mode);

};

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

if (length === 0) {

return process.nextTick(function() {

callback && callback(null, 0, buffer);

});

}

function wrapper(err, bytesRead) {

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

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

}

var req = new FSReqWrap();

req.oncomplete = wrapper;

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

};

fs.readSync = function(fd, buffer, offset, length, position) {

if (length === 0) {

return 0;

}

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

};

// usage:

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

// OR

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

fs.write = function(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);

}

var req = new FSReqWrap();

req.oncomplete = wrapper;

if (isUint8Array(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;

}

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);

};

// usage:

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

// OR

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

fs.writeSync = function(fd, buffer, offset, length, position) {

if (isUint8Array(buffer)) {

if (position === undefined)

position = null;

if (typeof offset !== 'number')

offset = 0;

if (typeof length !== 'number')

length = buffer.length - offset;

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

}

if (typeof buffer !== 'string')

buffer += '';

if (offset === undefined)

offset = null;

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

};

fs.rename = function(oldPath, newPath, callback) {

callback = makeCallback(callback);

if (!nullCheck(oldPath, callback)) return;

if (!nullCheck(newPath, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.rename(pathModule._makeLong(oldPath),

pathModule._makeLong(newPath),

req);

};

fs.renameSync = function(oldPath, newPath) {

nullCheck(oldPath);

nullCheck(newPath);

return binding.rename(pathModule._makeLong(oldPath),

pathModule._makeLong(newPath));

};

fs.truncate = function(path, len, callback) {

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

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

}

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

callback = len;

len = 0;

} else if (len === undefined) {

len = 0;

}

callback = maybeCallback(callback);

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

if (er) return callback(er);

var req = new FSReqWrap();

req.oncomplete = function oncomplete(er) {

fs.close(fd, function(er2) {

callback(er || er2);

});

};

binding.ftruncate(fd, len, req);

});

};

fs.truncateSync = function(path, len) {

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

// legacy

return fs.ftruncateSync(path, len);

}

if (len === undefined) {

len = 0;

}

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

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

var ret;

try {

ret = fs.ftruncateSync(fd, len);

} finally {

fs.closeSync(fd);

}

return ret;

};

fs.ftruncate = function(fd, len, callback) {

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

callback = len;

len = 0;

} else if (len === undefined) {

len = 0;

}

var req = new FSReqWrap();

req.oncomplete = makeCallback(callback);

binding.ftruncate(fd, len, req);

};

fs.ftruncateSync = function(fd, len) {

if (len === undefined) {

len = 0;

}

return binding.ftruncate(fd, len);

};

fs.rmdir = function(path, callback) {

callback = maybeCallback(callback);

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.rmdir(pathModule._makeLong(path), req);

};

fs.rmdirSync = function(path) {

nullCheck(path);

return binding.rmdir(pathModule._makeLong(path));

};

fs.fdatasync = function(fd, callback) {

var req = new FSReqWrap();

req.oncomplete = makeCallback(callback);

binding.fdatasync(fd, req);

};

fs.fdatasyncSync = function(fd) {

return binding.fdatasync(fd);

};

fs.fsync = function(fd, callback) {

var req = new FSReqWrap();

req.oncomplete = makeCallback(callback);

binding.fsync(fd, req);

};

fs.fsyncSync = function(fd) {

return binding.fsync(fd);

};

fs.mkdir = function(path, mode, callback) {

if (typeof mode === 'function') callback = mode;

callback = makeCallback(callback);

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.mkdir(pathModule._makeLong(path),

modeNum(mode, 0o777),

req);

};

fs.mkdirSync = function(path, mode) {

nullCheck(path);

return binding.mkdir(pathModule._makeLong(path),

modeNum(mode, 0o777));

};

fs.readdir = function(path, options, callback) {

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

options = getOptions(options, {});

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.readdir(pathModule._makeLong(path), options.encoding, req);

};

fs.readdirSync = function(path, options) {

options = getOptions(options, {});

nullCheck(path);

return binding.readdir(pathModule._makeLong(path), options.encoding);

};

fs.fstat = function(fd, callback) {

var req = new FSReqWrap();

req.oncomplete = makeCallback(callback);

binding.fstat(fd, req);

};

fs.lstat = function(path, callback) {

callback = makeCallback(callback);

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.lstat(pathModule._makeLong(path), req);

};

fs.stat = function(path, callback) {

callback = makeCallback(callback);

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.stat(pathModule._makeLong(path), req);

};

fs.fstatSync = function(fd) {

return binding.fstat(fd);

};

fs.lstatSync = function(path) {

nullCheck(path);

return binding.lstat(pathModule._makeLong(path));

};

fs.statSync = function(path) {

nullCheck(path);

return binding.stat(pathModule._makeLong(path));

};

fs.readlink = function(path, options, callback) {

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

options = getOptions(options, {});

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

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

};

fs.readlinkSync = function(path, options) {

options = getOptions(options, {});

nullCheck(path);

return binding.readlink(pathModule._makeLong(path), options.encoding);

};

function preprocessSymlinkDestination(path, type, linkPath) {

if (!isWindows) {

// No preprocessing is needed on Unix.

return path;

} else if (type === 'junction') {

// Junctions paths need to be absolute and \\?\-prefixed.

// A relative target is relative to the link's parent directory.

path = pathModule.resolve(linkPath, '..', path);

return pathModule._makeLong(path);

} else {

// Windows symlinks don't tolerate forward slashes.

return ('' + path).replace(/\//g, '\\');

}

}

fs.symlink = function(target, path, type_, callback_) {

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

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

if (!nullCheck(target, callback)) return;

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

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

pathModule._makeLong(path),

type,

req);

};

fs.symlinkSync = function(target, path, type) {

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

nullCheck(target);

nullCheck(path);

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

pathModule._makeLong(path),

type);

};

fs.link = function(existingPath, newPath, callback) {

callback = makeCallback(callback);

if (!nullCheck(existingPath, callback)) return;

if (!nullCheck(newPath, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.link(pathModule._makeLong(existingPath),

pathModule._makeLong(newPath),

req);

};

fs.linkSync = function(existingPath, newPath) {

nullCheck(existingPath);

nullCheck(newPath);

return binding.link(pathModule._makeLong(existingPath),

pathModule._makeLong(newPath));

};

fs.unlink = function(path, callback) {

callback = makeCallback(callback);

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.unlink(pathModule._makeLong(path), req);

};

fs.unlinkSync = function(path) {

nullCheck(path);

return binding.unlink(pathModule._makeLong(path));

};

fs.fchmod = function(fd, mode, callback) {

var req = new FSReqWrap();

req.oncomplete = makeCallback(callback);

binding.fchmod(fd, modeNum(mode), req);

};

fs.fchmodSync = function(fd, mode) {

return binding.fchmod(fd, modeNum(mode));

};

if (constants.hasOwnProperty('O_SYMLINK')) {

fs.lchmod = function(path, mode, callback) {

callback = maybeCallback(callback);

fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, function(err, fd) {

if (err) {

callback(err);

return;

}

// prefer to return the chmod error, if one occurs,

// but still try to close, and report closing errors if they occur.

fs.fchmod(fd, mode, function(err) {

fs.close(fd, function(err2) {

callback(err || err2);

});

});

});

};

fs.lchmodSync = function(path, mode) {

var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK);

// prefer to return the chmod error, if one occurs,

// but still try to close, and report closing errors if they occur.

var err, err2, ret;

try {

ret = fs.fchmodSync(fd, mode);

} catch (er) {

err = er;

}

try {

fs.closeSync(fd);

} catch (er) {

err2 = er;

}

if (err || err2) throw (err || err2);

return ret;

};

}

fs.chmod = function(path, mode, callback) {

callback = makeCallback(callback);

if (!nullCheck(path, callback)) return;

var req = new FSReqWrap();

req.oncomplete = callback;

binding.chmod(pathModule._makeLong(path),

modeNum(mode),

req);

};

fs.chmodSync = function(path, mode) {

nullCheck(path);

return binding.chmod(pathModule._makeLong(path), modeNum(mode));

};

if (constants.hasOwnProperty('O_SYMLINK')) {

fs.lchown = function(path, uid, gid, callback) {

callback = maybeCallback(callback);

fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, function(err, fd) {

if (err) {

callback(err);

return;

}

fs.fchown(fd, uid, gid, callback);

});

};

fs.lchownSync = function(path, uid, gid) {

var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK);

return fs.fchownSync(fd, uid, gid);

};

}