// 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 SlowBuffer = require('buffer').SlowBuffer;

const util = require('util');

const pathModule = require('path');

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

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

const fs = exports;

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

const EventEmitter = require('events').EventEmitter;

const FSReqWrap = binding.FSReqWrap;

const Readable = Stream.Readable;

const Writable = Stream.Writable;

const kMinPoolSpace = 128;

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

const O_APPEND = constants.O_APPEND || 0;

const O_CREAT = constants.O_CREAT || 0;

const O_EXCL = constants.O_EXCL || 0;

const O_RDONLY = constants.O_RDONLY || 0;

const O_RDWR = constants.O_RDWR || 0;

const O_SYNC = constants.O_SYNC || 0;

const O_TRUNC = constants.O_TRUNC || 0;

const O_WRONLY = constants.O_WRONLY || 0;

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

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

const errnoException = util._errnoException;

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

err = backtrace;

throw err;

}

};

}

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 (typeof cb !== 'function') {

return rethrow();

}

return function() {

return cb.apply(null, arguments);

};

}

function assertEncoding(encoding) {

if (encoding && !Buffer.isEncoding(encoding)) {

throw new Error('Unknown encoding: ' + encoding);

}

}

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(function() {

callback(er);

});

return false;

}

return true;

}

// 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 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_) {

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

if (!options || typeof options === 'function')

options = { encoding: null, flag: 'r' };

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

options = { encoding: options, flag: 'r' };

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

throw new TypeError('Bad arguments');

var encoding = options.encoding;

assertEncoding(encoding);

var flag = options.flag || 'r';

if (!nullCheck(path, callback))

return;

var context = new ReadFileContext(callback, encoding);

var req = new FSReqWrap();

req.context = context;

req.oncomplete = readFileAfterOpen;

binding.open(pathModule._makeLong(path),

stringToFlags(flag),

0o666,

req);

};

const kReadFileBufferLength = 8 * 1024;

function ReadFileContext(callback, encoding) {

this.fd = 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 fd = this.fd;

var size = this.size;

var buffer;

var offset;

var length;

if (size === 0) {

buffer = this.buffer = new SlowBuffer(kReadFileBufferLength);

offset = 0;

length = kReadFileBufferLength;

} else {

buffer = this.buffer;

offset = this.pos;

length = size - this.pos;

}

var req = new FSReqWrap();

req.oncomplete = readFileAfterRead;

req.context = this;

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

};

ReadFileContext.prototype.close = function(err) {

var req = new FSReqWrap();

req.oncomplete = readFileAfterClose;

req.context = this;

this.err = err;

binding.close(this.fd, req);

};

function readFileAfterOpen(err, fd) {

var context = this.context;

if (err) {

var callback = context.callback;

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.size;

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 = new SlowBuffer(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)

return callback(context.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)

buffer = buffer.toString(context.encoding);

callback(err, buffer);

}

fs.readFileSync = function(path, options) {

if (!options) {

options = { encoding: null, flag: 'r' };

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

options = { encoding: options, flag: 'r' };

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

throw new TypeError('Bad arguments');

}

var encoding = options.encoding;

assertEncoding(encoding);

var flag = options.flag || 'r';

var fd = fs.openSync(path, flag, 0o666);

var size;

var threw = true;

try {

size = fs.fstatSync(fd).size;

threw = false;

} finally {

if (threw) fs.closeSync(fd);

}

var pos = 0;

var buffer; // single buffer with file data

var buffers; // list for when size is unknown

if (size === 0) {

buffers = [];

} else {

var threw = true;

try {

buffer = new Buffer(size);

threw = false;

} finally {

if (threw) fs.closeSync(fd);

}

}

var done = false;

while (!done) {

var threw = true;

try {

if (size !== 0) {

var bytesRead = fs.readSync(fd, buffer, pos, size - pos);

} else {

// the kernel lies about many files.

// Go ahead and try to read some bytes.

buffer = new Buffer(8192);

var bytesRead = fs.readSync(fd, buffer, 0, 8192);

if (bytesRead) {

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

}

}

threw = false;

} finally {

if (threw) fs.closeSync(fd);

}

pos += bytesRead;

done = (bytesRead === 0) || (size !== 0 && pos >= size);

}

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 (encoding) buffer = buffer.toString(encoding);

return buffer;

};

// Used by binding.open and friends

function stringToFlags(flag) {

// Only mess with strings

if (typeof flag !== 'string') {

return flag;

}

switch (flag) {

case 'r' : return O_RDONLY;

case 'rs' : // fall through

case 'sr' : return O_RDONLY | O_SYNC;

case 'r+' : return O_RDWR;

case 'rs+' : // fall through

case 'sr+' : return O_RDWR | O_SYNC;

case 'w' : return O_TRUNC | O_CREAT | O_WRONLY;

case 'wx' : // fall through

case 'xw' : return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;

case 'w+' : return O_TRUNC | O_CREAT | O_RDWR;

case 'wx+': // fall through

case 'xw+': return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;

case 'a' : return O_APPEND | O_CREAT | O_WRONLY;

case 'ax' : // fall through

case 'xa' : return O_APPEND | O_CREAT | O_WRONLY | O_EXCL;

case 'a+' : return O_APPEND | O_CREAT | O_RDWR;

case 'ax+': // fall through

case 'xa+': return O_APPEND | O_CREAT | O_RDWR | O_EXCL;

}

throw new Error('Unknown file open flag: ' + flag);

}

// exported but hidden, only used by test/simple/test-fs-open-flags.js

Object.defineProperty(exports, '_stringToFlags', {

enumerable: false,

value: stringToFlags

});

// 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) {

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 (!(buffer instanceof Buffer)) {

// legacy string interface (fd, length, position, encoding, callback)

var cb = arguments[4],

encoding = arguments[3];

assertEncoding(encoding);

position = arguments[2];

length = arguments[1];

buffer = new Buffer(length);

offset = 0;

callback = function(err, bytesRead) {

if (!cb) return;

var str = (bytesRead > 0) ? buffer.toString(encoding, 0, bytesRead) : '';

(cb)(err, str, bytesRead);

};

}

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

var legacy = false;

if (!(buffer instanceof Buffer)) {

// legacy string interface (fd, length, position, encoding, callback)

legacy = true;

var encoding = arguments[3];

assertEncoding(encoding);

position = arguments[2];

length = arguments[1];

buffer = new Buffer(length);

offset = 0;

}

var r = binding.read(fd, buffer, offset, length, position);

if (!legacy) {

return r;

}

var str = (r > 0) ? buffer.toString(encoding, 0, r) : '';

return [str, r];

};

// 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 strWrapper(err, written) {

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

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

}

function bufWrapper(err, written) {

// retain reference to string in case it's external

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

}

if (buffer instanceof Buffer) {

// if no position is passed then assume null

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

callback = position;

position = null;

}

callback = maybeCallback(callback);

var req = new FSReqWrap();

req.oncomplete = strWrapper;

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

var req = new FSReqWrap();

req.oncomplete = bufWrapper;

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 (buffer instanceof Buffer) {

if (position === undefined)

position = null;

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') {

var req = new FSReqWrap();

req.oncomplete = callback;

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

}

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 ftruncateCb(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+');

try {

var 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, callback) {

callback = makeCallback(callback);

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

var req = new FSReqWrap();

req.oncomplete = callback;

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

};

fs.readdirSync = function(path) {

nullCheck(path);

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

};

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, callback) {

callback = makeCallback(callback);

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

var req = new FSReqWrap();

req.oncomplete = callback;

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

};

fs.readlinkSync = function(path) {

nullCheck(path);

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

};

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(destination, path, type_, callback) {

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

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

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

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

var req = new FSReqWrap();

req.oncomplete = callback;

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

pathModule._makeLong(path),

type,

req);

};

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

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

nullCheck(destination);

nullCheck(path);

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

pathModule._makeLong(path),

type);

};

fs.link = function(srcpath, dstpath, callback) {

callback = makeCallback(callback);

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

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

var req = new FSReqWrap();

req.oncomplete = callback;

binding.link(pathModule._makeLong(srcpath),

pathModule._makeLong(dstpath),

req);

};

fs.linkSync = function(srcpath, dstpath) {

nullCheck(srcpath);

nullCheck(dstpath);

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

pathModule._makeLong(dstpath));

};

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;

try {

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