/**

* @license

* Copyright 2013 The Emscripten Authors

* SPDX-License-Identifier: MIT

*/

addToLibrary({

$FS__deps: ['$randomFill', '$PATH', '$PATH_FS', '$TTY', '$MEMFS',

'$FS_createPreloadedFile',

'$FS_modeStringToFlags',

'$FS_getMode',

'$intArrayFromString',

'$stringToUTF8Array',

'$lengthBytesUTF8',

#if LibraryManager.has('library_idbfs.js')

'$IDBFS',

#endif

#if LibraryManager.has('library_nodefs.js')

'$NODEFS',

#endif

#if LibraryManager.has('library_workerfs.js')

'$WORKERFS',

#endif

#if LibraryManager.has('library_noderawfs.js')

'$NODERAWFS',

#endif

#if LibraryManager.has('library_proxyfs.js')

'$PROXYFS',

#endif

#if ASSERTIONS

'$ERRNO_MESSAGES', '$ERRNO_CODES',

#endif

#if ASSERTIONS && !MINIMAL_RUNTIME

'$demangleAll',

#endif

],

$FS__postset: function() {

// TODO: do we need noFSInit?

addAtInit(`

if (!Module["noFSInit"] && !FS.init.initialized)

FS.init();

FS.ignorePermissions = false;

`)

addAtExit('FS.quit();');

// We must statically create FS.FSNode here so that it is created in a manner

// that is visible to Closure compiler. That lets us use type annotations for

// Closure to the "this" pointer in various node creation functions.

return `

var FSNode = /** @constructor */ function(parent, name, mode, rdev) {

if (!parent) {

parent = this; // root node sets parent to itself

}

this.parent = parent;

this.mount = parent.mount;

this.mounted = null;

this.id = FS.nextInode++;

this.name = name;

this.mode = mode;

this.node_ops = {};

this.stream_ops = {};

this.rdev = rdev;

};

var readMode = 292/*{{{ cDefs.S_IRUGO }}}*/ | 73/*{{{ cDefs.S_IXUGO }}}*/;

var writeMode = 146/*{{{ cDefs.S_IWUGO }}}*/;

Object.defineProperties(FSNode.prototype, {

read: {

get: /** @this{FSNode} */function() {

return (this.mode & readMode) === readMode;

},

set: /** @this{FSNode} */function(val) {

val ? this.mode |= readMode : this.mode &= ~readMode;

}

},

write: {

get: /** @this{FSNode} */function() {

return (this.mode & writeMode) === writeMode;

},

set: /** @this{FSNode} */function(val) {

val ? this.mode |= writeMode : this.mode &= ~writeMode;

}

},

isFolder: {

get: /** @this{FSNode} */function() {

return FS.isDir(this.mode);

}

},

isDevice: {

get: /** @this{FSNode} */function() {

return FS.isChrdev(this.mode);

}

}

});

FS.FSNode = FSNode;

FS.createPreloadedFile = FS_createPreloadedFile;

FS.staticInit();` +

// Get module methods from settings

'{{{ EXPORTED_RUNTIME_METHODS.filter(function(func) { return func.substr(0, 3) === 'FS_' }).map(function(func){return 'Module["' + func + '"] = FS.' + func.substr(3) + ";"}).reduce(function(str, func){return str + func;}, '') }}}';

},

$FS: {

root: null,

mounts: [],

devices: {},

streams: [],

nextInode: 1,

nameTable: null,

currentPath: '/',

initialized: false,

// Whether we are currently ignoring permissions. Useful when preparing the

// filesystem and creating files inside read-only folders.

// This is set to false during `preInit`, allowing you to modify the

// filesystem freely up until that point (e.g. during `preRun`).

ignorePermissions: true,

#if FS_DEBUG

trackingDelegate: {},

#endif

ErrnoError: null, // set during init

genericErrors: {},

filesystems: null,

syncFSRequests: 0, // we warn if there are multiple in flight at once

//

// paths

//

lookupPath(path, opts = {}) {

path = PATH_FS.resolve(path);

if (!path) return { path: '', node: null };

var defaults = {

follow_mount: true,

recurse_count: 0

};

opts = Object.assign(defaults, opts)

if (opts.recurse_count > 8) { // max recursive lookup of 8

throw new FS.ErrnoError({{{ cDefs.ELOOP }}});

}

// split the absolute path

var parts = path.split('/').filter((p) => !!p);

// start at the root

var current = FS.root;

var current_path = '/';

for (var i = 0; i < parts.length; i++) {

var islast = (i === parts.length-1);

if (islast && opts.parent) {

// stop resolving

break;

}

current = FS.lookupNode(current, parts[i]);

current_path = PATH.join2(current_path, parts[i]);

// jump to the mount's root node if this is a mountpoint

if (FS.isMountpoint(current)) {

if (!islast || (islast && opts.follow_mount)) {

current = current.mounted.root;

}

}

// by default, lookupPath will not follow a symlink if it is the final path component.

// setting opts.follow = true will override this behavior.

if (!islast || opts.follow) {

var count = 0;

while (FS.isLink(current.mode)) {

var link = FS.readlink(current_path);

current_path = PATH_FS.resolve(PATH.dirname(current_path), link);

var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });

current = lookup.node;

if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX).

throw new FS.ErrnoError({{{ cDefs.ELOOP }}});

}

}

}

}

return { path: current_path, node: current };

},

getPath(node) {

var path;

while (true) {

if (FS.isRoot(node)) {

var mount = node.mount.mountpoint;

if (!path) return mount;

return mount[mount.length-1] !== '/' ? `${mount}/${path}` : mount + path;

}

path = path ? `${node.name}/${path}` : node.name;

node = node.parent;

}

},

//

// nodes

//

hashName(parentid, name) {

var hash = 0;

#if CASE_INSENSITIVE_FS

name = name.toLowerCase();

#endif

for (var i = 0; i < name.length; i++) {

hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;

}

return ((parentid + hash) >>> 0) % FS.nameTable.length;

},

hashAddNode(node) {

var hash = FS.hashName(node.parent.id, node.name);

node.name_next = FS.nameTable[hash];

FS.nameTable[hash] = node;

},

hashRemoveNode(node) {

var hash = FS.hashName(node.parent.id, node.name);

if (FS.nameTable[hash] === node) {

FS.nameTable[hash] = node.name_next;

} else {

var current = FS.nameTable[hash];

while (current) {

if (current.name_next === node) {

current.name_next = node.name_next;

break;

}

current = current.name_next;

}

}

},

lookupNode(parent, name) {

var errCode = FS.mayLookup(parent);

if (errCode) {

throw new FS.ErrnoError(errCode, parent);

}

var hash = FS.hashName(parent.id, name);

#if CASE_INSENSITIVE_FS

name = name.toLowerCase();

#endif

for (var node = FS.nameTable[hash]; node; node = node.name_next) {

var nodeName = node.name;

#if CASE_INSENSITIVE_FS

nodeName = nodeName.toLowerCase();

#endif

if (node.parent.id === parent.id && nodeName === name) {

return node;

}

}

// if we failed to find it in the cache, call into the VFS

return FS.lookup(parent, name);

},

createNode(parent, name, mode, rdev) {

#if ASSERTIONS

assert(typeof parent == 'object')

#endif

var node = new FS.FSNode(parent, name, mode, rdev);

FS.hashAddNode(node);

return node;

},

destroyNode(node) {

FS.hashRemoveNode(node);

},

isRoot(node) {

return node === node.parent;

},

isMountpoint(node) {

return !!node.mounted;

},

isFile(mode) {

return (mode & {{{ cDefs.S_IFMT }}}) === {{{ cDefs.S_IFREG }}};

},

isDir(mode) {

return (mode & {{{ cDefs.S_IFMT }}}) === {{{ cDefs.S_IFDIR }}};

},

isLink(mode) {

return (mode & {{{ cDefs.S_IFMT }}}) === {{{ cDefs.S_IFLNK }}};

},

isChrdev(mode) {

return (mode & {{{ cDefs.S_IFMT }}}) === {{{ cDefs.S_IFCHR }}};

},

isBlkdev(mode) {

return (mode & {{{ cDefs.S_IFMT }}}) === {{{ cDefs.S_IFBLK }}};

},

isFIFO(mode) {

return (mode & {{{ cDefs.S_IFMT }}}) === {{{ cDefs.S_IFIFO }}};

},

isSocket(mode) {

return (mode & {{{ cDefs.S_IFSOCK }}}) === {{{ cDefs.S_IFSOCK }}};

},

//

// permissions

//

// convert O_* bitmask to a string for nodePermissions

flagsToPermissionString(flag) {

var perms = ['r', 'w', 'rw'][flag & 3];

if ((flag & {{{ cDefs.O_TRUNC }}})) {

perms += 'w';

}

return perms;

},

nodePermissions(node, perms) {

if (FS.ignorePermissions) {

return 0;

}

// return 0 if any user, group or owner bits are set.

if (perms.includes('r') && !(node.mode & {{{ cDefs.S_IRUGO }}})) {

return {{{ cDefs.EACCES }}};

} else if (perms.includes('w') && !(node.mode & {{{ cDefs.S_IWUGO }}})) {

return {{{ cDefs.EACCES }}};

} else if (perms.includes('x') && !(node.mode & {{{ cDefs.S_IXUGO }}})) {

return {{{ cDefs.EACCES }}};

}

return 0;

},

mayLookup(dir) {

var errCode = FS.nodePermissions(dir, 'x');

if (errCode) return errCode;

if (!dir.node_ops.lookup) return {{{ cDefs.EACCES }}};

return 0;

},

mayCreate(dir, name) {

try {

var node = FS.lookupNode(dir, name);

return {{{ cDefs.EEXIST }}};

} catch (e) {

}

return FS.nodePermissions(dir, 'wx');

},

mayDelete(dir, name, isdir) {

var node;

try {

node = FS.lookupNode(dir, name);

} catch (e) {

return e.errno;

}

var errCode = FS.nodePermissions(dir, 'wx');

if (errCode) {

return errCode;

}

if (isdir) {

if (!FS.isDir(node.mode)) {

return {{{ cDefs.ENOTDIR }}};

}

if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {

return {{{ cDefs.EBUSY }}};

}

} else {

if (FS.isDir(node.mode)) {

return {{{ cDefs.EISDIR }}};

}

}

return 0;

},

mayOpen(node, flags) {

if (!node) {

return {{{ cDefs.ENOENT }}};

}

if (FS.isLink(node.mode)) {

return {{{ cDefs.ELOOP }}};

} else if (FS.isDir(node.mode)) {

if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write

(flags & {{{ cDefs.O_TRUNC }}})) { // TODO: check for O_SEARCH? (== search for dir only)

return {{{ cDefs.EISDIR }}};

}

}

return FS.nodePermissions(node, FS.flagsToPermissionString(flags));

},

//

// streams

//

MAX_OPEN_FDS: 4096,

nextfd() {

for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {

if (!FS.streams[fd]) {

return fd;

}

}

throw new FS.ErrnoError({{{ cDefs.EMFILE }}});

},

getStreamChecked(fd) {

var stream = FS.getStream(fd);

if (!stream) {

throw new FS.ErrnoError({{{ cDefs.EBADF }}});

}

return stream;

},

getStream: (fd) => FS.streams[fd],

// TODO parameterize this function such that a stream

// object isn't directly passed in. not possible until

// SOCKFS is completed.

createStream(stream, fd = -1) {

if (!FS.FSStream) {

FS.FSStream = /** @constructor */ function() {

this.shared = { };

};

FS.FSStream.prototype = {};

Object.defineProperties(FS.FSStream.prototype, {

object: {

/** @this {FS.FSStream} */

get() { return this.node; },

/** @this {FS.FSStream} */

set(val) { this.node = val; }

},

isRead: {

/** @this {FS.FSStream} */

get() { return (this.flags & {{{ cDefs.O_ACCMODE }}}) !== {{{ cDefs.O_WRONLY }}}; }

},

isWrite: {

/** @this {FS.FSStream} */

get() { return (this.flags & {{{ cDefs.O_ACCMODE }}}) !== {{{ cDefs.O_RDONLY }}}; }

},

isAppend: {

/** @this {FS.FSStream} */

get() { return (this.flags & {{{ cDefs.O_APPEND }}}); }

},

flags: {

/** @this {FS.FSStream} */

get() { return this.shared.flags; },

/** @this {FS.FSStream} */

set(val) { this.shared.flags = val; },

},

position : {

/** @this {FS.FSStream} */

get() { return this.shared.position; },

/** @this {FS.FSStream} */

set(val) { this.shared.position = val; },

},

});

}

// clone it, so we can return an instance of FSStream

stream = Object.assign(new FS.FSStream(), stream);

if (fd == -1) {

fd = FS.nextfd();

}

stream.fd = fd;

FS.streams[fd] = stream;

return stream;

},

closeStream(fd) {

FS.streams[fd] = null;

},

//

// devices

//

// each character device consists of a device id + stream operations.

// when a character device node is created (e.g. /dev/stdin) it is

// assigned a device id that lets us map back to the actual device.

// by default, each character device stream (e.g. _stdin) uses chrdev_stream_ops.

// however, once opened, the stream's operations are overridden with

// the operations of the device its underlying node maps back to.

chrdev_stream_ops: {

open(stream) {

var device = FS.getDevice(stream.node.rdev);

// override node's stream ops with the device's

stream.stream_ops = device.stream_ops;

// forward the open call

if (stream.stream_ops.open) {

stream.stream_ops.open(stream);

}

},

llseek() {

throw new FS.ErrnoError({{{ cDefs.ESPIPE }}});

}

},

major: (dev) => ((dev) >> 8),

minor: (dev) => ((dev) & 0xff),

makedev: (ma, mi) => ((ma) << 8 | (mi)),

registerDevice(dev, ops) {

FS.devices[dev] = { stream_ops: ops };

},

getDevice: (dev) => FS.devices[dev],

//

// core

//

getMounts(mount) {

var mounts = [];

var check = [mount];

while (check.length) {

var m = check.pop();

mounts.push(m);

check.push.apply(check, m.mounts);

}

return mounts;

},

syncfs(populate, callback) {

if (typeof populate == 'function') {

callback = populate;

populate = false;

}

FS.syncFSRequests++;

if (FS.syncFSRequests > 1) {

err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);

}

var mounts = FS.getMounts(FS.root.mount);

var completed = 0;

function doCallback(errCode) {

#if ASSERTIONS

assert(FS.syncFSRequests > 0);

#endif

FS.syncFSRequests--;

return callback(errCode);

}

function done(errCode) {

if (errCode) {

if (!done.errored) {

done.errored = true;

return doCallback(errCode);

}

return;

}

if (++completed >= mounts.length) {

doCallback(null);

}

};

// sync all mounts

mounts.forEach((mount) => {

if (!mount.type.syncfs) {

return done(null);

}

mount.type.syncfs(mount, populate, done);

});

},

mount(type, opts, mountpoint) {

#if ASSERTIONS

if (typeof type == 'string') {

// The filesystem was not included, and instead we have an error

// message stored in the variable.

throw type;

}

#endif

var root = mountpoint === '/';

var pseudo = !mountpoint;

var node;

if (root && FS.root) {

throw new FS.ErrnoError({{{ cDefs.EBUSY }}});

} else if (!root && !pseudo) {

var lookup = FS.lookupPath(mountpoint, { follow_mount: false });

mountpoint = lookup.path; // use the absolute path

node = lookup.node;

if (FS.isMountpoint(node)) {

throw new FS.ErrnoError({{{ cDefs.EBUSY }}});

}

if (!FS.isDir(node.mode)) {

throw new FS.ErrnoError({{{ cDefs.ENOTDIR }}});

}

}

var mount = {

type,

opts,

mountpoint,

mounts: []

};

// create a root node for the fs

var mountRoot = type.mount(mount);

mountRoot.mount = mount;

mount.root = mountRoot;

if (root) {

FS.root = mountRoot;

} else if (node) {

// set as a mountpoint

node.mounted = mount;

// add the new mount to the current mount's children

if (node.mount) {

node.mount.mounts.push(mount);

}

}

return mountRoot;

},

unmount(mountpoint) {

var lookup = FS.lookupPath(mountpoint, { follow_mount: false });

if (!FS.isMountpoint(lookup.node)) {

throw new FS.ErrnoError({{{ cDefs.EINVAL }}});

}

// destroy the nodes for this mount, and all its child mounts

var node = lookup.node;

var mount = node.mounted;

var mounts = FS.getMounts(mount);

Object.keys(FS.nameTable).forEach((hash) => {

var current = FS.nameTable[hash];

while (current) {

var next = current.name_next;

if (mounts.includes(current.mount)) {

FS.destroyNode(current);

}

current = next;

}

});

// no longer a mountpoint

node.mounted = null;

// remove this mount from the child mounts

var idx = node.mount.mounts.indexOf(mount);

#if ASSERTIONS

assert(idx !== -1);

#endif

node.mount.mounts.splice(idx, 1);

},

lookup(parent, name) {

return parent.node_ops.lookup(parent, name);

},

// generic function for all node creation

mknod(path, mode, dev) {

var lookup = FS.lookupPath(path, { parent: true });

var parent = lookup.node;

var name = PATH.basename(path);

if (!name || name === '.' || name === '..') {

throw new FS.ErrnoError({{{ cDefs.EINVAL }}});

}

var errCode = FS.mayCreate(parent, name);

if (errCode) {

throw new FS.ErrnoError(errCode);

}

if (!parent.node_ops.mknod) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

return parent.node_ops.mknod(parent, name, mode, dev);

},

// helpers to create specific types of nodes

create(path, mode) {

mode = mode !== undefined ? mode : 438 /* 0666 */;

mode &= {{{ cDefs.S_IALLUGO }}};

mode |= {{{ cDefs.S_IFREG }}};

return FS.mknod(path, mode, 0);

},

mkdir(path, mode) {

mode = mode !== undefined ? mode : 511 /* 0777 */;

mode &= {{{ cDefs.S_IRWXUGO }}} | {{{ cDefs.S_ISVTX }}};

mode |= {{{ cDefs.S_IFDIR }}};

#if FS_DEBUG

if (FS.trackingDelegate['onMakeDirectory']) {

FS.trackingDelegate['onMakeDirectory'](path, mode);

}

#endif

return FS.mknod(path, mode, 0);

},

// Creates a whole directory tree chain if it doesn't yet exist

mkdirTree(path, mode) {

var dirs = path.split('/');

var d = '';

for (var i = 0; i < dirs.length; ++i) {

if (!dirs[i]) continue;

d += '/' + dirs[i];

try {

FS.mkdir(d, mode);

} catch(e) {

if (e.errno != {{{ cDefs.EEXIST }}}) throw e;

}

}

},

mkdev(path, mode, dev) {

if (typeof dev == 'undefined') {

dev = mode;

mode = 438 /* 0666 */;

}

mode |= {{{ cDefs.S_IFCHR }}};

return FS.mknod(path, mode, dev);

},

symlink(oldpath, newpath) {

if (!PATH_FS.resolve(oldpath)) {

throw new FS.ErrnoError({{{ cDefs.ENOENT }}});

}

var lookup = FS.lookupPath(newpath, { parent: true });

var parent = lookup.node;

if (!parent) {

throw new FS.ErrnoError({{{ cDefs.ENOENT }}});

}

var newname = PATH.basename(newpath);

var errCode = FS.mayCreate(parent, newname);

if (errCode) {

throw new FS.ErrnoError(errCode);

}

if (!parent.node_ops.symlink) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

#if FS_DEBUG

if (FS.trackingDelegate['onMakeSymlink']) {

FS.trackingDelegate['onMakeSymlink'](oldpath, newpath);

}

#endif

return parent.node_ops.symlink(parent, newname, oldpath);

},

rename(old_path, new_path) {

var old_dirname = PATH.dirname(old_path);

var new_dirname = PATH.dirname(new_path);

var old_name = PATH.basename(old_path);

var new_name = PATH.basename(new_path);

// parents must exist

var lookup, old_dir, new_dir;

// let the errors from non existant directories percolate up

lookup = FS.lookupPath(old_path, { parent: true });

old_dir = lookup.node;

lookup = FS.lookupPath(new_path, { parent: true });

new_dir = lookup.node;

if (!old_dir || !new_dir) throw new FS.ErrnoError({{{ cDefs.ENOENT }}});

// need to be part of the same mount

if (old_dir.mount !== new_dir.mount) {

throw new FS.ErrnoError({{{ cDefs.EXDEV }}});

}

// source must exist

var old_node = FS.lookupNode(old_dir, old_name);

// old path should not be an ancestor of the new path

var relative = PATH_FS.relative(old_path, new_dirname);

if (relative.charAt(0) !== '.') {

throw new FS.ErrnoError({{{ cDefs.EINVAL }}});

}

// new path should not be an ancestor of the old path

relative = PATH_FS.relative(new_path, old_dirname);

if (relative.charAt(0) !== '.') {

throw new FS.ErrnoError({{{ cDefs.ENOTEMPTY }}});

}

// see if the new path already exists

var new_node;

try {

new_node = FS.lookupNode(new_dir, new_name);

} catch (e) {

// not fatal

}

// early out if nothing needs to change

if (old_node === new_node) {

return;

}

// we'll need to delete the old entry

var isdir = FS.isDir(old_node.mode);

var errCode = FS.mayDelete(old_dir, old_name, isdir);

if (errCode) {

throw new FS.ErrnoError(errCode);

}

// need delete permissions if we'll be overwriting.

// need create permissions if new doesn't already exist.

errCode = new_node ?

FS.mayDelete(new_dir, new_name, isdir) :

FS.mayCreate(new_dir, new_name);

if (errCode) {

throw new FS.ErrnoError(errCode);

}

if (!old_dir.node_ops.rename) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) {

throw new FS.ErrnoError({{{ cDefs.EBUSY }}});

}

// if we are going to change the parent, check write permissions

if (new_dir !== old_dir) {

errCode = FS.nodePermissions(old_dir, 'w');

if (errCode) {

throw new FS.ErrnoError(errCode);

}

}

#if FS_DEBUG

if (FS.trackingDelegate['willMovePath']) {

FS.trackingDelegate['willMovePath'](old_path, new_path);

}

#endif

// remove the node from the lookup hash

FS.hashRemoveNode(old_node);

// do the underlying fs rename

try {

old_dir.node_ops.rename(old_node, new_dir, new_name);

} catch (e) {

throw e;

} finally {

// add the node back to the hash (in case node_ops.rename

// changed its name)

FS.hashAddNode(old_node);

}

#if FS_DEBUG

if (FS.trackingDelegate['onMovePath']) {

FS.trackingDelegate['onMovePath'](old_path, new_path);

}

#endif

},

rmdir(path) {

var lookup = FS.lookupPath(path, { parent: true });

var parent = lookup.node;

var name = PATH.basename(path);

var node = FS.lookupNode(parent, name);

var errCode = FS.mayDelete(parent, name, true);

if (errCode) {

throw new FS.ErrnoError(errCode);

}

if (!parent.node_ops.rmdir) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

if (FS.isMountpoint(node)) {

throw new FS.ErrnoError({{{ cDefs.EBUSY }}});

}

#if FS_DEBUG

if (FS.trackingDelegate['willDeletePath']) {

FS.trackingDelegate['willDeletePath'](path);

}

#endif

parent.node_ops.rmdir(parent, name);

FS.destroyNode(node);

#if FS_DEBUG

if (FS.trackingDelegate['onDeletePath']) {

FS.trackingDelegate['onDeletePath'](path);

}

#endif

},

readdir(path) {

var lookup = FS.lookupPath(path, { follow: true });

var node = lookup.node;

if (!node.node_ops.readdir) {

throw new FS.ErrnoError({{{ cDefs.ENOTDIR }}});

}

return node.node_ops.readdir(node);

},

unlink(path) {

var lookup = FS.lookupPath(path, { parent: true });

var parent = lookup.node;

if (!parent) {

throw new FS.ErrnoError({{{ cDefs.ENOENT }}});

}

var name = PATH.basename(path);

var node = FS.lookupNode(parent, name);

var errCode = FS.mayDelete(parent, name, false);

if (errCode) {

// According to POSIX, we should map EISDIR to EPERM, but

// we instead do what Linux does (and we must, as we use

// the musl linux libc).

throw new FS.ErrnoError(errCode);

}

if (!parent.node_ops.unlink) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

if (FS.isMountpoint(node)) {

throw new FS.ErrnoError({{{ cDefs.EBUSY }}});

}

#if FS_DEBUG

if (FS.trackingDelegate['willDeletePath']) {

FS.trackingDelegate['willDeletePath'](path);

}

#endif

parent.node_ops.unlink(parent, name);

FS.destroyNode(node);

#if FS_DEBUG

if (FS.trackingDelegate['onDeletePath']) {

FS.trackingDelegate['onDeletePath'](path);

}

#endif

},

readlink(path) {

var lookup = FS.lookupPath(path);

var link = lookup.node;

if (!link) {

throw new FS.ErrnoError({{{ cDefs.ENOENT }}});

}

if (!link.node_ops.readlink) {

throw new FS.ErrnoError({{{ cDefs.EINVAL }}});

}

return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));

},

stat(path, dontFollow) {

var lookup = FS.lookupPath(path, { follow: !dontFollow });

var node = lookup.node;

if (!node) {

throw new FS.ErrnoError({{{ cDefs.ENOENT }}});

}

if (!node.node_ops.getattr) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

return node.node_ops.getattr(node);

},

lstat(path) {

return FS.stat(path, true);

},

chmod(path, mode, dontFollow) {

var node;

if (typeof path == 'string') {

var lookup = FS.lookupPath(path, { follow: !dontFollow });

node = lookup.node;

} else {

node = path;

}

if (!node.node_ops.setattr) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

node.node_ops.setattr(node, {

mode: (mode & {{{ cDefs.S_IALLUGO }}}) | (node.mode & ~{{{ cDefs.S_IALLUGO }}}),

timestamp: Date.now()

});

},

lchmod(path, mode) {

FS.chmod(path, mode, true);

},

fchmod(fd, mode) {

var stream = FS.getStreamChecked(fd);

FS.chmod(stream.node, mode);

},

chown(path, uid, gid, dontFollow) {

var node;

if (typeof path == 'string') {

var lookup = FS.lookupPath(path, { follow: !dontFollow });

node = lookup.node;

} else {

node = path;

}

if (!node.node_ops.setattr) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

node.node_ops.setattr(node, {

timestamp: Date.now()

// we ignore the uid / gid for now

});

},

lchown(path, uid, gid) {

FS.chown(path, uid, gid, true);

},

fchown(fd, uid, gid) {

var stream = FS.getStreamChecked(fd);

FS.chown(stream.node, uid, gid);

},

truncate(path, len) {

if (len < 0) {

throw new FS.ErrnoError({{{ cDefs.EINVAL }}});

}

var node;

if (typeof path == 'string') {

var lookup = FS.lookupPath(path, { follow: true });

node = lookup.node;

} else {

node = path;

}

if (!node.node_ops.setattr) {

throw new FS.ErrnoError({{{ cDefs.EPERM }}});

}

if (FS.isDir(node.mode)) {

throw new FS.ErrnoError({{{ cDefs.EISDIR }}});

}

if (!FS.isFile(node.mode)) {

throw new FS.ErrnoError({{{ cDefs.EINVAL }}});

}

var errCode = FS.nodePermissions(node, 'w');

if (errCode) {

throw new FS.ErrnoError(errCode);

}

node.node_ops.setattr(node, {

size: len,

timestamp: Date.now()

});

},

ftruncate(fd, len) {

var stream = FS.getStreamChecked(fd);

if ((stream.flags & {{{ cDefs.O_ACCMODE }}}) === {{{ cDefs.O_RDONLY}}}) {

throw new FS.ErrnoError({{{ cDefs.EINVAL }}});

}

FS.truncate(stream.node, len);

},

utime(path, atime, mtime) {

var lookup = FS.lookupPath(path, { follow: true });

var node = lookup.node;

node.node_ops.setattr(node, {

timestamp: Math.max(atime, mtime)

});

},

open(path, flags, mode) {

if (path === "") {

throw new FS.ErrnoError({{{ cDefs.ENOENT }}});

}

flags = typeof flags == 'string' ? FS_modeStringToFlags(flags) : flags;

mode = typeof mode == 'undefined' ? 438 /* 0666 */ : mode;

if ((flags & {{{ cDefs.O_CREAT }}})) {

mode = (mode & {{{ cDefs.S_IALLUGO }}}) | {{{ cDefs.S_IFREG }}};

} else {

mode = 0;

}