blob: 71a1d27e9fe37bd162f59f13a6639a7d52ec5283 [file] [log] [blame]
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
#include <dirent.h>
#if (NJS_SOLARIS)
#define DT_DIR 0
#define DT_REG 1
#define DT_CHR 2
#define DT_LNK 3
#define DT_BLK 4
#define DT_FIFO 5
#define DT_SOCK 6
#define NJS_DT_INVALID 0xffffffff
#define njs_dentry_type(_dentry) \
(NJS_DT_INVALID)
#else
#define NJS_DT_INVALID 0xffffffff
#define njs_dentry_type(_dentry) \
((_dentry)->d_type)
#endif
#define njs_fs_magic(calltype, mode) \
(((mode) << 2) | calltype)
#define njs_fs_magic2(field, type) \
(((type) << 4) | field)
typedef enum {
NJS_FS_DIRECT,
NJS_FS_PROMISE,
NJS_FS_CALLBACK,
} njs_fs_calltype_t;
typedef enum {
NJS_FS_TRUNC,
NJS_FS_APPEND,
} njs_fs_writemode_t;
typedef enum {
NJS_FS_STAT,
NJS_FS_LSTAT,
} njs_fs_statmode_t;
typedef struct {
njs_str_t name;
int value;
} njs_fs_entry_t;
typedef enum {
NJS_FTW_PHYS = 1,
NJS_FTW_MOUNT = 2,
NJS_FTW_DEPTH = 8,
} njs_ftw_flags_t;
typedef enum {
NJS_FTW_F,
NJS_FTW_D,
NJS_FTW_DNR,
NJS_FTW_NS,
NJS_FTW_SL,
NJS_FTW_DP,
NJS_FTW_SLN,
} njs_ftw_type_t;
typedef struct {
long tv_sec;
long tv_nsec;
} njs_timespec_t;
typedef struct {
uint64_t st_dev;
uint64_t st_mode;
uint64_t st_nlink;
uint64_t st_uid;
uint64_t st_gid;
uint64_t st_rdev;
uint64_t st_ino;
uint64_t st_size;
uint64_t st_blksize;
uint64_t st_blocks;
njs_timespec_t st_atim;
njs_timespec_t st_mtim;
njs_timespec_t st_ctim;
njs_timespec_t st_birthtim;
} njs_stat_t;
typedef enum {
NJS_FS_STAT_DEV,
NJS_FS_STAT_INO,
NJS_FS_STAT_MODE,
NJS_FS_STAT_NLINK,
NJS_FS_STAT_UID,
NJS_FS_STAT_GID,
NJS_FS_STAT_RDEV,
NJS_FS_STAT_SIZE,
NJS_FS_STAT_BLKSIZE,
NJS_FS_STAT_BLOCKS,
NJS_FS_STAT_ATIME,
NJS_FS_STAT_BIRTHTIME,
NJS_FS_STAT_CTIME,
NJS_FS_STAT_MTIME,
} njs_stat_prop_t;
typedef njs_int_t (*njs_file_tree_walk_cb_t)(const char *, const struct stat *,
njs_ftw_type_t);
static njs_int_t njs_fs_access(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_mkdir(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_read(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_readdir(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_realpath(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_rename(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_rmdir(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_stat(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_symlink(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_unlink(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_write(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t calltype);
static njs_int_t njs_fs_constants(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *unused, njs_value_t *retval);
static njs_int_t njs_fs_promises(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *unused, njs_value_t *retval);
static njs_int_t njs_fs_dirent_constructor(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused);
static njs_int_t njs_fs_dirent_test(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t testtype);
static njs_int_t njs_fs_stats_test(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t testtype);
static njs_int_t njs_fs_stats_prop(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval);
static njs_int_t njs_fs_stats_create(njs_vm_t *vm, struct stat *st,
njs_value_t *retval);
static njs_int_t njs_fs_fd_read(njs_vm_t *vm, int fd, njs_str_t *data);
static njs_int_t njs_fs_error(njs_vm_t *vm, const char *syscall,
const char *desc, const char *path, int errn, njs_value_t *retval);
static njs_int_t njs_fs_result(njs_vm_t *vm, njs_value_t *result,
njs_index_t calltype, const njs_value_t* callback, njs_uint_t nargs);
static njs_int_t njs_file_tree_walk(const char *path,
njs_file_tree_walk_cb_t cb, int fd_limit, njs_ftw_flags_t flags);
static njs_int_t njs_fs_make_path(njs_vm_t *vm, char *path, mode_t md,
njs_bool_t recursive, njs_value_t *retval);
static njs_int_t njs_fs_rmtree(njs_vm_t *vm, const char *path,
njs_bool_t recursive, njs_value_t *retval);
static const char *njs_fs_path(njs_vm_t *vm, char storage[NJS_MAX_PATH + 1],
const njs_value_t *src, const char *prop_name);
static int njs_fs_flags(njs_vm_t *vm, njs_value_t *value, int default_flags);
static mode_t njs_fs_mode(njs_vm_t *vm, njs_value_t *value,
mode_t default_mode);
static njs_int_t njs_fs_add_event(njs_vm_t *vm, const njs_value_t *callback,
const njs_value_t *args, njs_uint_t nargs);
static njs_int_t njs_fs_dirent_create(njs_vm_t *vm, njs_value_t *name,
njs_value_t *type, njs_value_t *retval);
static njs_int_t njs_fs_init(njs_vm_t *vm);
static const njs_value_t string_flag = njs_string("flag");
static const njs_value_t string_mode = njs_string("mode");
static const njs_value_t string_buffer = njs_string("buffer");
static const njs_value_t string_encoding = njs_string("encoding");
static const njs_value_t string_recursive = njs_string("recursive");
static njs_fs_entry_t njs_flags_table[] = {
{ njs_str("a"), O_APPEND | O_CREAT | O_WRONLY },
{ njs_str("a+"), O_APPEND | O_CREAT | O_RDWR },
{ njs_str("as"), O_APPEND | O_CREAT | O_SYNC | O_WRONLY },
{ njs_str("as+"), O_APPEND | O_CREAT | O_RDWR | O_SYNC },
{ njs_str("ax"), O_APPEND | O_CREAT | O_EXCL | O_WRONLY },
{ njs_str("ax+"), O_APPEND | O_CREAT | O_EXCL | O_RDWR },
{ njs_str("r"), O_RDONLY },
{ njs_str("r+"), O_RDWR },
{ njs_str("rs+"), O_RDWR | O_SYNC },
{ njs_str("w"), O_CREAT | O_TRUNC | O_WRONLY },
{ njs_str("w+"), O_CREAT | O_TRUNC | O_RDWR },
{ njs_str("wx"), O_CREAT | O_TRUNC | O_EXCL | O_WRONLY },
{ njs_str("wx+"), O_CREAT | O_TRUNC | O_EXCL | O_RDWR },
{ njs_null_str, 0 }
};
static njs_external_t njs_ext_fs[] = {
{
.flags = NJS_EXTERN_PROPERTY | NJS_EXTERN_SYMBOL,
.name.symbol = NJS_SYMBOL_TO_STRING_TAG,
.u.property = {
.value = "fs",
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("access"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_access,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("accessSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_access,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("appendFile"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_write,
.magic8 = njs_fs_magic(NJS_FS_CALLBACK, NJS_FS_APPEND),
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("appendFileSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_write,
.magic8 = njs_fs_magic(NJS_FS_DIRECT, NJS_FS_APPEND),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("constants"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_constants,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("Dirent"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_constructor,
.ctor = 1,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("lstat"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stat,
.magic8 = njs_fs_magic(NJS_FS_CALLBACK, NJS_FS_LSTAT),
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("lstatSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stat,
.magic8 = njs_fs_magic(NJS_FS_DIRECT, NJS_FS_LSTAT),
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("mkdir"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_mkdir,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("mkdirSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_mkdir,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("promises"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_promises,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("readdir"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_readdir,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("readdirSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_readdir,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("readFile"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_read,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("readFileSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_read,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("realpath"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_realpath,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("realpathSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_realpath,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("rename"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_rename,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("renameSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_rename,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("rmdir"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_rmdir,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("rmdirSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_rmdir,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("stat"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stat,
.magic8 = njs_fs_magic(NJS_FS_CALLBACK, NJS_FS_STAT),
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("statSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stat,
.magic8 = njs_fs_magic(NJS_FS_DIRECT, NJS_FS_STAT),
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("symlink"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_symlink,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("symlinkSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_symlink,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("unlink"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_unlink,
.magic8 = NJS_FS_CALLBACK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("unlinkSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_unlink,
.magic8 = NJS_FS_DIRECT,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("writeFile"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_write,
.magic8 = njs_fs_magic(NJS_FS_CALLBACK, NJS_FS_TRUNC),
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("writeFileSync"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_write,
.magic8 = njs_fs_magic(NJS_FS_DIRECT, NJS_FS_TRUNC),
}
},
};
static njs_external_t njs_ext_dirent[] = {
{
.flags = NJS_EXTERN_PROPERTY | NJS_EXTERN_SYMBOL,
.name.symbol = NJS_SYMBOL_TO_STRING_TAG,
.u.property = {
.value = "Dirent",
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("constructor"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_constructor,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isBlockDevice"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_test,
.magic8 = DT_BLK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isCharacterDevice"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_test,
.magic8 = DT_CHR,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isDirectory"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_test,
.magic8 = DT_DIR,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isFIFO"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_test,
.magic8 = DT_FIFO,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isFile"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_test,
.magic8 = DT_REG,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isSocket"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_test,
.magic8 = DT_SOCK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isSymbolicLink"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_dirent_test,
.magic8 = DT_LNK,
}
},
};
static njs_external_t njs_ext_stats[] = {
{
.flags = NJS_EXTERN_PROPERTY | NJS_EXTERN_SYMBOL,
.name.symbol = NJS_SYMBOL_TO_STRING_TAG,
.u.property = {
.value = "Stats",
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("atime"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_ATIME, NJS_DATE),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("atimeMs"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_ATIME, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("birthtime"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_BIRTHTIME, NJS_DATE),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("birthtimeMs"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_BIRTHTIME, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("ctime"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_CTIME, NJS_DATE),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("ctimeMs"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_CTIME, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("blksize"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_BLKSIZE, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("blocks"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_BLOCKS, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("dev"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_DEV, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("gid"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_GID, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("ino"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_INO, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("mode"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_MODE, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("mtime"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_MTIME, NJS_DATE),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("mtimeMs"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_MTIME, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("nlink"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_NLINK, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("rdev"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_RDEV, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("size"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_SIZE, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("uid"),
.enumerable = 1,
.u.property = {
.handler = njs_fs_stats_prop,
.magic32 = njs_fs_magic2(NJS_FS_STAT_UID, NJS_NUMBER),
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isBlockDevice"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stats_test,
.magic8 = DT_BLK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isCharacterDevice"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stats_test,
.magic8 = DT_CHR,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isDirectory"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stats_test,
.magic8 = DT_DIR,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isFIFO"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stats_test,
.magic8 = DT_FIFO,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isFile"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stats_test,
.magic8 = DT_REG,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isSocket"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stats_test,
.magic8 = DT_SOCK,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("isSymbolicLink"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_fs_stats_test,
.magic8 = DT_LNK,
}
},
};
static njs_int_t njs_fs_stats_proto_id;
static njs_int_t njs_fs_dirent_proto_id;
njs_module_t njs_fs_module = {
.name = njs_str("fs"),
.init = njs_fs_init,
};
static njs_int_t
njs_fs_access(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
int md;
njs_int_t ret;
const char *path;
njs_value_t retval, *callback, *mode;
char path_buf[NJS_MAX_PATH + 1];
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
mode = njs_arg(args, nargs, 2);
if (calltype == NJS_FS_CALLBACK) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 3));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (mode == callback) {
mode = njs_value_arg(&njs_value_undefined);
}
}
switch (mode->type) {
case NJS_UNDEFINED:
md = F_OK;
break;
case NJS_NUMBER:
md = njs_number(mode);
break;
default:
njs_type_error(vm, "\"mode\" must be a number");
return NJS_ERROR;
}
njs_set_undefined(&retval);
ret = access(path, md);
if (njs_slow_path(ret != 0)) {
ret = njs_fs_error(vm, "access", strerror(errno), path, errno, &retval);
}
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 1);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_mkdir(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
char *path;
mode_t md;
njs_int_t ret;
njs_value_t mode, recursive, retval, *callback, *options;
char path_buf[NJS_MAX_PATH + 1];
path = (char *) njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
options = njs_arg(args, nargs, 2);
if (njs_slow_path(calltype == NJS_FS_CALLBACK)) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 3));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (options == callback) {
options = njs_value_arg(&njs_value_undefined);
}
}
njs_set_undefined(&mode);
njs_set_false(&recursive);
switch (options->type) {
case NJS_NUMBER:
mode = *options;
break;
case NJS_UNDEFINED:
break;
default:
if (!njs_is_object(options)) {
njs_type_error(vm, "Unknown options type: \"%s\" "
"(a number or object required)",
njs_type_string(options->type));
return NJS_ERROR;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_mode),
&mode);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_recursive),
&recursive);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
}
md = njs_fs_mode(vm, &mode, 0777);
if (njs_slow_path(md == (mode_t) -1)) {
return NJS_ERROR;
}
ret = njs_fs_make_path(vm, path, md, njs_is_true(&recursive), &retval);
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 1);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_read(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
int fd, flags;
njs_str_t data;
njs_int_t ret;
const char *path;
njs_value_t flag, encode, retval, *callback, *options;
struct stat sb;
const njs_buffer_encoding_t *encoding;
char path_buf[NJS_MAX_PATH + 1];
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
options = njs_arg(args, nargs, 2);
if (calltype == NJS_FS_CALLBACK) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 3));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (options == callback) {
options = njs_value_arg(&njs_value_undefined);
}
}
njs_set_undefined(&flag);
njs_set_undefined(&encode);
switch (options->type) {
case NJS_STRING:
encode = *options;
break;
case NJS_UNDEFINED:
break;
default:
if (!njs_is_object(options)) {
njs_type_error(vm, "Unknown options type: \"%s\" "
"(a string or object required)",
njs_type_string(options->type));
return NJS_ERROR;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_flag),
&flag);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_encoding),
&encode);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
}
flags = njs_fs_flags(vm, &flag, O_RDONLY);
if (njs_slow_path(flags == -1)) {
return NJS_ERROR;
}
encoding = NULL;
if (njs_is_defined(&encode)) {
encoding = njs_buffer_encoding(vm, &encode);
if (njs_slow_path(encoding == NULL)) {
return NJS_ERROR;
}
}
fd = open(path, flags);
if (njs_slow_path(fd < 0)) {
ret = njs_fs_error(vm, "open", strerror(errno), path, errno, &retval);
goto done;
}
ret = fstat(fd, &sb);
if (njs_slow_path(ret == -1)) {
ret = njs_fs_error(vm, "stat", strerror(errno), path, errno, &retval);
goto done;
}
if (njs_slow_path(!S_ISREG(sb.st_mode))) {
ret = njs_fs_error(vm, "stat", "File is not regular", path, 0, &retval);
goto done;
}
data.start = NULL;
data.length = sb.st_size;
ret = njs_fs_fd_read(vm, fd, &data);
if (njs_slow_path(ret != NJS_OK)) {
if (ret == NJS_DECLINED) {
ret = njs_fs_error(vm, "read", strerror(errno), path, errno,
&retval);
}
goto done;
}
if (encoding == NULL) {
ret = njs_buffer_set(vm, &retval, data.start, data.length);
} else {
ret = encoding->encode(vm, &retval, &data);
njs_mp_free(vm->mem_pool, data.start);
}
done:
if (fd != -1) {
(void) close(fd);
}
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 2);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_readdir(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
DIR *dir;
njs_str_t s;
njs_int_t ret;
const char *path;
njs_value_t encode, types, ename, etype, retval,
*callback, *options, *value;
njs_array_t *results;
struct dirent *entry;
const njs_buffer_encoding_t *encoding;
char path_buf[NJS_MAX_PATH + 1];
static const njs_value_t string_types = njs_string("withFileTypes");
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
options = njs_arg(args, nargs, 2);
if (njs_slow_path(calltype == NJS_FS_CALLBACK)) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 3));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (options == callback) {
options = njs_value_arg(&njs_value_undefined);
}
}
njs_set_false(&types);
njs_set_undefined(&encode);
switch (options->type) {
case NJS_STRING:
encode = *options;
break;
case NJS_UNDEFINED:
break;
default:
if (!njs_is_object(options)) {
njs_type_error(vm, "Unknown options type: \"%s\" "
"(a string or object required)",
njs_type_string(options->type));
return NJS_ERROR;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_encoding),
&encode);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_types),
&types);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
}
encoding = NULL;
if (!njs_is_string(&encode) || !njs_string_eq(&encode, &string_buffer)) {
encoding = njs_buffer_encoding(vm, &encode);
if (njs_slow_path(encoding == NULL)) {
return NJS_ERROR;
}
}
results = njs_array_alloc(vm, 1, 0, NJS_ARRAY_SPARE);
if (njs_slow_path(results == NULL)) {
return NJS_ERROR;
}
njs_set_array(&retval, results);
dir = opendir(path);
if (njs_slow_path(dir == NULL)) {
ret = njs_fs_error(vm, "opendir", strerror(errno), path, errno,
&retval);
goto done;
}
ret = NJS_OK;
for ( ;; ) {
errno = 0;
entry = readdir(dir);
if (njs_slow_path(entry == NULL)) {
if (errno != 0) {
ret = njs_fs_error(vm, "readdir", strerror(errno), path, errno,
&retval);
}
goto done;
}
s.start = (u_char *) entry->d_name;
s.length = njs_strlen(s.start);
if ((s.length == 1 && s.start[0] == '.')
|| (s.length == 2 && (s.start[0] == '.' && s.start[1] == '.')))
{
continue;
}
value = njs_array_push(vm, results);
if (njs_slow_path(value == NULL)) {
goto done;
}
if (encoding == NULL) {
ret = njs_buffer_set(vm, &ename, s.start, s.length);
} else {
ret = encoding->encode(vm, &ename, &s);
}
if (njs_slow_path(ret != NJS_OK)) {
goto done;
}
if (njs_fast_path(!njs_is_true(&types))) {
*value = ename;
continue;
}
njs_set_number(&etype, njs_dentry_type(entry));
ret = njs_fs_dirent_create(vm, &ename, &etype, value);
if (njs_slow_path(ret != NJS_OK)) {
goto done;
}
}
done:
if (dir != NULL) {
(void) closedir(dir);
}
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 2);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_realpath(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
njs_int_t ret;
njs_str_t s;
const char *path;
njs_value_t encode, retval, *callback, *options;
const njs_buffer_encoding_t *encoding;
char path_buf[NJS_MAX_PATH + 1],
dst_buf[NJS_MAX_PATH + 1];
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
options = njs_arg(args, nargs, 2);
if (calltype == NJS_FS_CALLBACK) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 3));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (options == callback) {
options = njs_value_arg(&njs_value_undefined);
}
}
njs_set_undefined(&encode);
switch (options->type) {
case NJS_STRING:
encode = *options;
break;
case NJS_UNDEFINED:
break;
default:
if (!njs_is_object(options)) {
njs_type_error(vm, "Unknown options type: \"%s\" "
"(a string or object required)",
njs_type_string(options->type));
return NJS_ERROR;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_encoding),
&encode);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
}
encoding = NULL;
if (!njs_is_string(&encode) || !njs_string_eq(&encode, &string_buffer)) {
encoding = njs_buffer_encoding(vm, &encode);
if (njs_slow_path(encoding == NULL)) {
return NJS_ERROR;
}
}
s.start = (u_char *) realpath(path, dst_buf);
if (njs_slow_path(s.start == NULL)) {
ret = njs_fs_error(vm, "realpath", strerror(errno), path, errno,
&retval);
goto done;
}
s.length = njs_strlen(s.start);
if (encoding == NULL) {
ret = njs_buffer_new(vm, &retval, s.start, s.length);
} else {
ret = encoding->encode(vm, &retval, &s);
}
done:
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 2);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_rename(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
njs_int_t ret;
const char *path, *newpath;
njs_value_t retval, *callback;
char path_buf[NJS_MAX_PATH + 1], newpath_buf[NJS_MAX_PATH + 1];
callback = NULL;
if (calltype == NJS_FS_CALLBACK) {
callback = njs_arg(args, nargs, 3);
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
}
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "oldPath");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
newpath = njs_fs_path(vm, newpath_buf, njs_arg(args, nargs, 2), "newPath");
if (njs_slow_path(newpath == NULL)) {
return NJS_ERROR;
}
njs_set_undefined(&retval);
ret = rename(path, newpath);
if (njs_slow_path(ret != 0)) {
ret = njs_fs_error(vm, "rename", strerror(errno), NULL, errno, &retval);
}
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 1);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_rmdir(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
njs_int_t ret;
const char *path;
njs_value_t recursive, retval, *callback, *options;
char path_buf[NJS_MAX_PATH + 1];
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
options = njs_arg(args, nargs, 2);
if (njs_slow_path(calltype == NJS_FS_CALLBACK)) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 3));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (options == callback) {
options = njs_value_arg(&njs_value_undefined);
}
}
njs_set_false(&recursive);
switch (options->type) {
case NJS_UNDEFINED:
break;
default:
if (!njs_is_object(options)) {
njs_type_error(vm, "Unknown options type: \"%s\" "
"(an object required)",
njs_type_string(options->type));
return NJS_ERROR;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_recursive),
&recursive);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
}
ret = njs_fs_rmtree(vm, path, njs_is_true(&recursive), &retval);
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 1);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_stat(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t magic)
{
njs_int_t ret;
njs_bool_t throw;
struct stat sb;
const char *path;
njs_value_t retval, *callback, *options;
njs_fs_calltype_t calltype;
char path_buf[NJS_MAX_PATH + 1];
static const njs_value_t string_bigint = njs_string("bigint");
static const njs_value_t string_throw = njs_string("throwIfNoEntry");
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
calltype = magic & 3;
options = njs_arg(args, nargs, 2);
if (njs_slow_path(calltype == NJS_FS_CALLBACK)) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 3));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (options == callback) {
options = njs_value_arg(&njs_value_undefined);
}
}
throw = 1;
switch (options->type) {
case NJS_UNDEFINED:
break;
default:
if (!njs_is_object(options)) {
njs_type_error(vm, "Unknown options type: \"%s\" "
"(an object required)",
njs_type_string(options->type));
return NJS_ERROR;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_bigint),
&retval);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
if (njs_bool(&retval)) {
njs_type_error(vm, "\"bigint\" is not supported");
return NJS_ERROR;
}
if (calltype == NJS_FS_DIRECT) {
ret = njs_value_property(vm, options, njs_value_arg(&string_throw),
&retval);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
throw = njs_bool(&retval);
}
}
ret = ((magic >> 2) == NJS_FS_STAT) ? stat(path, &sb) : lstat(path, &sb);
if (njs_slow_path(ret != 0)) {
if (errno != ENOENT || throw) {
ret = njs_fs_error(vm,
((magic >> 2) == NJS_FS_STAT) ? "stat" : "lstat",
strerror(errno), path, errno, &retval);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
} else {
njs_set_undefined(&retval);
}
return njs_fs_result(vm, &retval, calltype, callback, 2);
}
ret = njs_fs_stats_create(vm, &sb, &retval);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
return njs_fs_result(vm, &retval, calltype, callback, 2);
}
static njs_int_t
njs_fs_symlink(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
njs_int_t ret;
const char *target, *path;
njs_value_t retval, *callback, *type;
char target_buf[NJS_MAX_PATH + 1], path_buf[NJS_MAX_PATH + 1];
target = njs_fs_path(vm, target_buf, njs_arg(args, nargs, 1), "target");
if (njs_slow_path(target == NULL)) {
return NJS_ERROR;
}
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 2), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
type = njs_arg(args, nargs, 3);
if (calltype == NJS_FS_CALLBACK) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 4));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (type == callback) {
type = njs_value_arg(&njs_value_undefined);
}
}
if (njs_slow_path(!njs_is_undefined(type) && !njs_is_string(type))) {
njs_type_error(vm, "\"type\" must be a string");
return NJS_ERROR;
}
njs_set_undefined(&retval);
ret = symlink(target, path);
if (njs_slow_path(ret != 0)) {
ret = njs_fs_error(vm, "symlink", strerror(errno), path, errno,
&retval);
}
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 1);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_unlink(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t calltype)
{
njs_int_t ret;
const char *path;
njs_value_t retval, *callback;
char path_buf[NJS_MAX_PATH + 1];
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
if (calltype == NJS_FS_CALLBACK) {
callback = njs_arg(args, nargs, 2);
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
}
njs_set_undefined(&retval);
ret = unlink(path);
if (njs_slow_path(ret != 0)) {
ret = njs_fs_error(vm, "unlink", strerror(errno), path, errno, &retval);
}
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 1);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_write(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t magic)
{
int fd, flags;
u_char *p, *end;
mode_t md;
ssize_t n;
njs_str_t content;
njs_int_t ret;
const char *path;
njs_value_t flag, mode, encode, retval, *data, *callback,
*options;
njs_typed_array_t *array;
njs_fs_calltype_t calltype;
njs_array_buffer_t *buffer;
const njs_buffer_encoding_t *encoding;
char path_buf[NJS_MAX_PATH + 1];
path = njs_fs_path(vm, path_buf, njs_arg(args, nargs, 1), "path");
if (njs_slow_path(path == NULL)) {
return NJS_ERROR;
}
callback = NULL;
calltype = magic & 3;
options = njs_arg(args, nargs, 3);
if (calltype == NJS_FS_CALLBACK) {
callback = njs_arg(args, nargs, njs_min(nargs - 1, 4));
if (!njs_is_function(callback)) {
njs_type_error(vm, "\"callback\" must be a function");
return NJS_ERROR;
}
if (options == callback) {
options = njs_value_arg(&njs_value_undefined);
}
}
njs_set_undefined(&flag);
njs_set_undefined(&mode);
njs_set_undefined(&encode);
switch (options->type) {
case NJS_STRING:
encode = *options;
break;
case NJS_UNDEFINED:
break;
default:
if (!njs_is_object(options)) {
njs_type_error(vm, "Unknown options type: \"%s\" "
"(a string or object required)",
njs_type_string(options->type));
return NJS_ERROR;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_flag),
&flag);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_mode),
&mode);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
ret = njs_value_property(vm, options, njs_value_arg(&string_encoding),
&encode);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
}
data = njs_arg(args, nargs, 2);
switch (data->type) {
case NJS_TYPED_ARRAY:
case NJS_DATA_VIEW:
array = njs_typed_array(data);
buffer = array->buffer;
if (njs_slow_path(njs_is_detached_buffer(buffer))) {
njs_type_error(vm, "detached buffer");
return NJS_ERROR;
}
content.start = &buffer->u.u8[array->offset];
content.length = array->byte_length;
break;
case NJS_STRING:
default:
encoding = njs_buffer_encoding(vm, &encode);
if (njs_slow_path(encoding == NULL)) {
return NJS_ERROR;
}
ret = njs_value_to_string(vm, &retval, data);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
ret = njs_buffer_decode_string(vm, &retval, &retval, encoding);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
njs_string_get(&retval, &content);
break;
}
flags = njs_fs_flags(vm, &flag, O_CREAT | O_WRONLY);
if (njs_slow_path(flags == -1)) {
return NJS_ERROR;
}
flags |= ((magic >> 2) == NJS_FS_APPEND) ? O_APPEND : O_TRUNC;
md = njs_fs_mode(vm, &mode, 0666);
if (njs_slow_path(md == (mode_t) -1)) {
return NJS_ERROR;
}
fd = open(path, flags, md);
if (njs_slow_path(fd < 0)) {
ret = njs_fs_error(vm, "open", strerror(errno), path, errno, &retval);
goto done;
}
p = content.start;
end = p + content.length;
while (p < end) {
n = write(fd, p, end - p);
if (njs_slow_path(n == -1)) {
if (errno == EINTR) {
continue;
}
ret = njs_fs_error(vm, "write", strerror(errno), path, errno,
&retval);
goto done;
}
p += n;
}
ret = NJS_OK;
njs_set_undefined(&retval);
done:
if (fd != -1) {
(void) close(fd);
}
if (ret == NJS_OK) {
return njs_fs_result(vm, &retval, calltype, callback, 1);
}
return NJS_ERROR;
}
static njs_int_t
njs_fs_fd_read(njs_vm_t *vm, int fd, njs_str_t *data)
{
u_char *p, *end, *start;
size_t size;
ssize_t n;
size = data->length;
if (size == 0) {
size = 4096;
}
data->start = njs_mp_alloc(vm->mem_pool, size);
if (data->start == NULL) {
njs_memory_error(vm);
return NJS_ERROR;
}
p = data->start;
end = p + size;
for ( ;; ) {
n = read(fd, p, end - p);
if (njs_slow_path(n < 0)) {
return NJS_DECLINED;
}
p += n;
if (n == 0) {
break;
}
if (end - p < 2048) {
size *= 2;
start = njs_mp_alloc(vm->mem_pool, size);
if (start == NULL) {
njs_memory_error(vm);
return NJS_ERROR;
}
memcpy(start, data->start, p - data->start);
njs_mp_free(vm->mem_pool, data->start);
p = start + (p - data->start);
end = start + size;
data->start = start;
}
}
data->length = p - data->start;
return NJS_OK;
}
static njs_int_t
njs_fs_make_path(njs_vm_t *vm, char *path, mode_t md, njs_bool_t recursive,
njs_value_t *retval)
{
int err;
njs_int_t ret;
const char *p, *prev, *end;
struct stat sb;
njs_set_undefined(retval);
end = path + njs_strlen(path);
if (!recursive) {
ret = mkdir(path, md);
if (ret != 0) {
err = errno;
goto failed;
}
return NJS_OK;
}
p = path;
prev = p;
for ( ;; ) {
p = strchr(prev + 1, '/');
if (p == NULL) {
p = end;
}
if (njs_slow_path((p - path) > NJS_MAX_PATH)) {
njs_internal_error(vm, "too large path");
return NJS_ERROR;
}
path[p - path] = '\0';
ret = mkdir(path, md);
err = errno;
switch (ret) {
case 0:
break;
case EACCES:
case ENOTDIR:
case EPERM:
goto failed;
case EEXIST:
default:
ret = stat(path, &sb);
if (ret == 0) {
if (!S_ISDIR(sb.st_mode)) {
err = ENOTDIR;
goto failed;
}
break;
}
goto failed;
}
if (p == end) {
break;
}
path[p - path] = '/';
prev = p;
}
return NJS_OK;
failed:
return njs_fs_error(vm, "mkdir", strerror(err), path, err, retval);
}
typedef struct njs_ftw_trace_s njs_ftw_trace_t;
struct njs_ftw_trace_s {
struct njs_ftw_trace_s *chain;
dev_t dev;
ino_t ino;
};
static int
njs_ftw(char *path, njs_file_tree_walk_cb_t cb, int fd_limit,
njs_ftw_flags_t flags, njs_ftw_trace_t *parent)
{
int type, ret, dfd;
DIR *d;
size_t base, len, length;
const char *d_name;
struct stat st;
struct dirent *entry;
njs_ftw_trace_t trace, *h;
ret = (flags & NJS_FTW_PHYS) ? lstat(path, &st) : stat(path, &st);
if (ret < 0) {
if (!(flags & NJS_FTW_PHYS) && errno == ENOENT && !lstat(path, &st)) {
type = NJS_FTW_SLN;
} else if (errno != EACCES) {
return NJS_ERROR;
} else {
type = NJS_FTW_NS;
}
} else if (S_ISDIR(st.st_mode)) {
type = (flags & NJS_FTW_DEPTH) ? NJS_FTW_DP : NJS_FTW_D;
} else if (S_ISLNK(st.st_mode)) {
type = (flags & NJS_FTW_PHYS) ? NJS_FTW_SL : NJS_FTW_SLN;
} else {
type = NJS_FTW_F;
}
if ((flags & NJS_FTW_MOUNT) && parent != NULL && st.st_dev != parent->dev) {
return NJS_OK;
}
for (h = parent; h != NULL; h = h->chain) {
if (h->dev == st.st_dev && h->ino == st.st_ino) {
return NJS_OK;
}
}
len = njs_strlen(path);
base = len && (path[len - 1] == '/') ? len - 1 : len;
trace.chain = parent;
trace.dev = st.st_dev;
trace.ino = st.st_ino;
d = NULL;
dfd = -1;
if (type == NJS_FTW_D || type == NJS_FTW_DP) {
dfd = open(path, O_RDONLY);
if (dfd < 0) {
if (errno != EACCES) {
return NJS_ERROR;
}
type = NJS_FTW_DNR;
}
}
if (!(flags & NJS_FTW_DEPTH)) {
ret = cb(path, &st, type);
if (njs_slow_path(ret != 0)) {
goto done;
}
}
if (type == NJS_FTW_D || type == NJS_FTW_DP) {
d = fdopendir(dfd);
if (njs_slow_path(d == NULL)) {
ret = NJS_ERROR;
goto done;
}
for ( ;; ) {
entry = readdir(d);
if (entry == NULL) {
break;
}
d_name = entry->d_name;
length = njs_strlen(d_name);
if ((length == 1 && d_name[0] == '.')
|| (length == 2 && (d_name[0] == '.' && d_name[1] == '.')))
{
continue;
}
if (njs_slow_path(length >= (NJS_MAX_PATH - len))) {
errno = ENAMETOOLONG;
ret = NJS_ERROR;
goto done;
}
path[base] = '/';
memcpy(&path[base + 1], d_name, length + njs_length("\0"));
if (fd_limit != 0) {
ret = njs_ftw(path, cb, fd_limit - 1, flags, &trace);
if (njs_slow_path(ret != 0)) {
goto done;
}
}
}
(void) closedir(d);
d = NULL;
dfd = -1;
}
path[len] = '\0';
if (flags & NJS_FTW_DEPTH) {
ret = cb(path, &st, type);
if (njs_slow_path(ret != 0)) {
return ret;
}
}
ret = NJS_OK;
done:
if (d != NULL) {
/* closedir() also closes underlying dfd. */
(void) closedir(d);
} else if (dfd >= 0) {
(void) close(dfd);
}
return ret;
}
static njs_int_t
njs_file_tree_walk(const char *path, njs_file_tree_walk_cb_t cb, int fd_limit,
njs_ftw_flags_t flags)
{
size_t len;
char pathbuf[NJS_MAX_PATH + 1];
len = njs_strlen(path);
if (njs_slow_path(len > NJS_MAX_PATH)) {
errno = ENAMETOOLONG;
return -1;
}
memcpy(pathbuf, path, len + 1);
return njs_ftw(pathbuf, cb, fd_limit, flags, NULL);
}
static njs_int_t
njs_fs_rmtree_cb(const char *path, const struct stat *sb, njs_ftw_type_t type)
{
njs_int_t ret;
ret = remove(path);
if (ret != 0) {
return NJS_ERROR;
}
return NJS_OK;
}
static njs_int_t
njs_fs_rmtree(njs_vm_t *vm, const char *path, njs_bool_t recursive,
njs_value_t *retval)
{
njs_int_t ret;
const char *description;
njs_set_undefined(retval);
ret = rmdir(path);
if (ret == 0) {
return NJS_OK;
}
description = strerror(errno);
if (recursive && (errno == ENOTEMPTY || errno == EEXIST)) {
ret = njs_file_tree_walk(path, njs_fs_rmtree_cb, 16,
NJS_FTW_PHYS | NJS_FTW_MOUNT | NJS_FTW_DEPTH);
if (ret == NJS_OK) {
return NJS_OK;
}
description = strerror(errno);
}
return njs_fs_error(vm, "rmdir", description, path, errno, retval);
}
static const char *
njs_fs_path(njs_vm_t *vm, char storage[NJS_MAX_PATH + 1],
const njs_value_t *src, const char *prop_name)
{
u_char *p;
njs_str_t str;
njs_typed_array_t *array;
njs_array_buffer_t *buffer;
switch (src->type) {
case NJS_STRING:
njs_string_get(src, &str);
break;
case NJS_TYPED_ARRAY:
case NJS_DATA_VIEW:
array = njs_typed_array(src);
buffer = array->buffer;
if (njs_slow_path(njs_is_detached_buffer(buffer))) {
njs_type_error(vm, "detached buffer");
return NULL;
}
str.start = &buffer->u.u8[array->offset];
str.length = array->byte_length;
break;
default:
njs_type_error(vm, "\"%s\" must be a string or Buffer", prop_name);
return NULL;
}
if (njs_slow_path(str.length > NJS_MAX_PATH - 1)) {
njs_type_error(vm, "\"%s\" is too long >= %d", prop_name, NJS_MAX_PATH);
return NULL;
}
if (njs_slow_path(memchr(str.start, '\0', str.length) != 0)) {
njs_type_error(vm, "\"%s\" must be a Buffer without null bytes",
prop_name);
return NULL;
}
p = njs_cpymem(storage, str.start, str.length);
*p++ = '\0';
return storage;
}
static int
njs_fs_flags(njs_vm_t *vm, njs_value_t *value, int default_flags)
{
njs_str_t flags;
njs_int_t ret;
njs_fs_entry_t *fl;
if (njs_is_undefined(value)) {
return default_flags;
}
ret = njs_value_to_string(vm, value, value);
if (njs_slow_path(ret != NJS_OK)) {
return -1;
}
njs_string_get(value, &flags);
for (fl = &njs_flags_table[0]; fl->name.length != 0; fl++) {
if (njs_strstr_eq(&flags, &fl->name)) {
return fl->value;
}
}
njs_type_error(vm, "Unknown file open flags: \"%V\"", &flags);
return -1;
}
static mode_t
njs_fs_mode(njs_vm_t *vm, njs_value_t *value, mode_t default_mode)
{
uint32_t u32;
njs_int_t ret;
/* GCC complains about uninitialized u32. */
u32 = 0;
if (njs_is_undefined(value)) {
return default_mode;
}
ret = njs_value_to_uint32(vm, value, &u32);
if (njs_slow_path(ret != NJS_OK)) {
return (mode_t) -1;
}
return (mode_t) u32;
}
static njs_int_t
njs_fs_error(njs_vm_t *vm, const char *syscall, const char *description,
const char *path, int errn, njs_value_t *retval)
{
size_t size;
njs_int_t ret;
njs_value_t value;
const char *code;
njs_object_t *error;
static const njs_value_t string_errno = njs_string("errno");
static const njs_value_t string_code = njs_string("code");
static const njs_value_t string_path = njs_string("path");
static const njs_value_t string_syscall = njs_string("syscall");
size = description != NULL ? njs_strlen(description) : 0;
ret = njs_string_create(vm, &value, description, size);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
error = njs_error_alloc(vm, NJS_OBJ_TYPE_ERROR, NULL, &value, NULL);
if (njs_slow_path(error == NULL)) {
return NJS_ERROR;
}
njs_set_object(retval, error);
if (errn != 0) {
njs_set_number(&value, errn);
ret = njs_value_property_set(vm, retval, njs_value_arg(&string_errno),
&value);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
code = njs_errno_string(errn);
ret = njs_string_create(vm, &value, code, njs_strlen(code));
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
ret = njs_value_property_set(vm, retval, njs_value_arg(&string_code),
&value);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
}
if (path != NULL) {
ret = njs_string_create(vm, &value, path, njs_strlen(path));
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
ret = njs_value_property_set(vm, retval, njs_value_arg(&string_path),
&value);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
}
if (syscall != NULL) {
ret = njs_string_create(vm, &value, syscall, njs_strlen(syscall));
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
ret = njs_value_property_set(vm, retval, njs_value_arg(&string_syscall),
&value);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
}
return NJS_OK;
}
static njs_int_t
ngx_fs_promise_trampoline(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
njs_value_t value;
return njs_function_call(vm, njs_function(&args[1]), &njs_value_undefined,
&args[2], 1, &value);
}
static const njs_value_t promise_trampoline =
njs_native_function(ngx_fs_promise_trampoline, 2);
static njs_int_t
njs_fs_result(njs_vm_t *vm, njs_value_t *result, njs_index_t calltype,
const njs_value_t *callback, njs_uint_t nargs)
{
njs_int_t ret;
njs_value_t promise, callbacks[2], arguments[2];
switch (calltype) {
case NJS_FS_DIRECT:
vm->retval = *result;
return njs_is_error(result) ? NJS_ERROR : NJS_OK;
case NJS_FS_PROMISE:
ret = njs_vm_promise_create(vm, &promise, &callbacks[0]);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
arguments[0] = njs_is_error(result) ? callbacks[1] : callbacks[0];
arguments[1] = *result;
ret = njs_fs_add_event(vm, njs_value_arg(&promise_trampoline),
njs_value_arg(&arguments), 2);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
vm->retval = promise;
return NJS_OK;
case NJS_FS_CALLBACK:
if (njs_is_error(result)) {
arguments[0] = *result;
njs_set_undefined(&arguments[1]);
} else {
njs_set_undefined(&arguments[0]);
arguments[1] = *result;
}
ret = njs_fs_add_event(vm, callback, njs_value_arg(&arguments),
nargs);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
njs_set_undefined(&vm->retval);
return NJS_OK;
default:
njs_internal_error(vm, "invalid calltype");
return NJS_ERROR;
}
}
static njs_int_t
njs_fs_add_event(njs_vm_t *vm, const njs_value_t *callback,
const njs_value_t *args, njs_uint_t nargs)
{
njs_event_t *event;
njs_vm_ops_t *ops;
ops = vm->options.ops;
if (njs_slow_path(ops == NULL)) {
njs_internal_error(vm, "not supported by host environment");
return NJS_ERROR;
}
event = njs_mp_alloc(vm->mem_pool, sizeof(njs_event_t));
if (njs_slow_path(event == NULL)) {
goto memory_error;
}
event->destructor = ops->clear_timer;
event->function = njs_function(callback);
event->nargs = nargs;
event->once = 1;
event->posted = 0;
event->args = njs_mp_alloc(vm->mem_pool, sizeof(njs_value_t) * nargs);
if (njs_slow_path(event->args == NULL)) {
goto memory_error;
}
memcpy(event->args, args, sizeof(njs_value_t) * nargs);
event->host_event = ops->set_timer(vm->external, 0, event);
if (njs_slow_path(event->host_event == NULL)) {
njs_internal_error(vm, "set_timer() failed");
return NJS_ERROR;
}
return njs_add_event(vm, event);
memory_error:
njs_memory_error(vm);
return NJS_ERROR;
}
static njs_int_t
njs_fs_dirent_create(njs_vm_t *vm, njs_value_t *name, njs_value_t *type,
njs_value_t *retval)
{
njs_int_t ret;
static const njs_value_t string_name = njs_string("name");
static const njs_value_t string_type = njs_string("type");
ret = njs_vm_external_create(vm, retval, njs_fs_dirent_proto_id, NULL, 0);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
ret = njs_value_property_set(vm, retval, njs_value_arg(&string_name),
name);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
/* TODO: use a private symbol as a key. */
return njs_value_property_set(vm, retval, njs_value_arg(&string_type),
type);
}
static njs_int_t
njs_fs_dirent_constructor(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused)
{
if (njs_slow_path(!vm->top_frame->ctor)) {
njs_type_error(vm, "the Dirent constructor must be called with new");
return NJS_ERROR;
}
return njs_fs_dirent_create(vm, njs_arg(args, nargs, 1),
njs_arg(args, nargs, 2), &vm->retval);
}
static const njs_object_prop_t njs_dirent_constructor_properties[] =
{
{
.type = NJS_PROPERTY,
.name = njs_string("name"),
.value = njs_string("Dirent"),
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("length"),
.value = njs_value(NJS_NUMBER, 1, 2.0),
.configurable = 1,
},
{
.type = NJS_PROPERTY_HANDLER,
.name = njs_string("prototype"),
.value = njs_prop_handler(njs_object_prototype_create),
},
};
const njs_object_init_t njs_dirent_constructor_init = {
njs_dirent_constructor_properties,
njs_nitems(njs_dirent_constructor_properties),
};
static njs_int_t
njs_fs_dirent_test(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t testtype)
{
njs_int_t ret;
njs_value_t type, *this;
static const njs_value_t string_type = njs_string("type");
this = njs_argument(args, 0);
ret = njs_value_property(vm, this, njs_value_arg(&string_type), &type);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
if (njs_slow_path(njs_is_number(&type)
&& (njs_number(&type) == NJS_DT_INVALID)))
{
njs_internal_error(vm, "dentry type is not supported on this platform");
return NJS_ERROR;
}
njs_set_boolean(&vm->retval,
njs_is_number(&type) && testtype == njs_number(&type));
return NJS_OK;
}
static void
njs_fs_to_stat(njs_stat_t *dst, struct stat *st)
{
dst->st_dev = st->st_dev;
dst->st_mode = st->st_mode;
dst->st_nlink = st->st_nlink;
dst->st_uid = st->st_uid;
dst->st_gid = st->st_gid;
dst->st_rdev = st->st_rdev;
dst->st_ino = st->st_ino;
dst->st_size = st->st_size;
dst->st_blksize = st->st_blksize;
dst->st_blocks = st->st_blocks;
#if (NJS_HAVE_STAT_ATIMESPEC)
dst->st_atim.tv_sec = st->st_atimespec.tv_sec;
dst->st_atim.tv_nsec = st->st_atimespec.tv_nsec;
dst->st_mtim.tv_sec = st->st_mtimespec.tv_sec;
dst->st_mtim.tv_nsec = st->st_mtimespec.tv_nsec;
dst->st_ctim.tv_sec = st->st_ctimespec.tv_sec;
dst->st_ctim.tv_nsec = st->st_ctimespec.tv_nsec;
dst->st_birthtim.tv_sec = st->st_birthtimespec.tv_sec;
dst->st_birthtim.tv_nsec = st->st_birthtimespec.tv_nsec;
#elif (NJS_HAVE_STAT_ATIM)
dst->st_atim.tv_sec = st->st_atim.tv_sec;
dst->st_atim.tv_nsec = st->st_atim.tv_nsec;
dst->st_mtim.tv_sec = st->st_mtim.tv_sec;
dst->st_mtim.tv_nsec = st->st_mtim.tv_nsec;
dst->st_ctim.tv_sec = st->st_ctim.tv_sec;
dst->st_ctim.tv_nsec = st->st_ctim.tv_nsec;
#if (NJS_HAVE_STAT_BIRTHTIM)
dst->st_birthtim.tv_sec = st->st_birthtim.tv_sec;
dst->st_birthtim.tv_nsec = st->st_birthtim.tv_nsec;
#else
dst->st_birthtim.tv_sec = st->st_ctim.tv_sec;
dst->st_birthtim.tv_nsec = st->st_ctim.tv_nsec;
#endif
#else
dst->st_atim.tv_sec = st->st_atime;
dst->st_atim.tv_nsec = 0;
dst->st_mtim.tv_sec = st->st_mtime;
dst->st_mtim.tv_nsec = 0;
dst->st_ctim.tv_sec = st->st_ctime;
dst->st_ctim.tv_nsec = 0;
dst->st_birthtim.tv_sec = st->st_ctime;
dst->st_birthtim.tv_nsec = 0;
#endif
}
static njs_int_t
njs_fs_stats_create(njs_vm_t *vm, struct stat *st, njs_value_t *retval)
{
njs_stat_t *stat;
stat = njs_mp_alloc(vm->mem_pool, sizeof(njs_stat_t));
if (njs_slow_path(stat == NULL)) {
njs_memory_error(vm);
return NJS_ERROR;
}
njs_fs_to_stat(stat, st);
return njs_vm_external_create(vm, retval, njs_fs_stats_proto_id,
stat, 0);
}
static njs_int_t
njs_fs_stats_test(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t testtype)
{
unsigned mask;
njs_stat_t *st;
st = njs_vm_external(vm, njs_fs_stats_proto_id, njs_argument(args, 0));
if (njs_slow_path(st == NULL)) {
return NJS_DECLINED;
}
switch (testtype) {
case DT_DIR:
mask = S_IFDIR;
break;
case DT_REG:
mask = S_IFREG;
break;
case DT_CHR:
mask = S_IFCHR;
break;
case DT_LNK:
mask = S_IFLNK;
break;
case DT_BLK:
mask = S_IFBLK;
break;
case DT_FIFO:
mask = S_IFIFO;
break;
case DT_SOCK:
default:
mask = S_IFSOCK;
}
njs_set_boolean(&vm->retval, (st->st_mode & S_IFMT) == mask);
return NJS_OK;
}
static njs_int_t
njs_fs_stats_prop(njs_vm_t *vm, njs_object_prop_t *prop, njs_value_t *value,
njs_value_t *setval, njs_value_t *retval)
{
double v;
njs_date_t *date;
njs_stat_t *st;
#define njs_fs_time_ms(ts) ((ts)->tv_sec * 1000.0 + (ts)->tv_nsec / 1000000.0)
st = njs_vm_external(vm, njs_fs_stats_proto_id, value);
if (njs_slow_path(st == NULL)) {
return NJS_DECLINED;
}
switch (prop->value.data.magic32 & 0xf) {
case NJS_FS_STAT_DEV:
v = st->st_dev;
break;
case NJS_FS_STAT_INO:
v = st->st_ino;
break;
case NJS_FS_STAT_MODE:
v = st->st_mode;
break;
case NJS_FS_STAT_NLINK:
v = st->st_nlink;
break;
case NJS_FS_STAT_UID:
v = st->st_uid;
break;
case NJS_FS_STAT_GID:
v = st->st_gid;
break;
case NJS_FS_STAT_RDEV:
v = st->st_rdev;
break;
case NJS_FS_STAT_SIZE:
v = st->st_size;
break;
case NJS_FS_STAT_BLKSIZE:
v = st->st_blksize;
break;
case NJS_FS_STAT_BLOCKS:
v = st->st_blocks;
break;
case NJS_FS_STAT_ATIME:
v = njs_fs_time_ms(&st->st_atim);
break;
case NJS_FS_STAT_BIRTHTIME:
v = njs_fs_time_ms(&st->st_birthtim);
break;
case NJS_FS_STAT_CTIME:
v = njs_fs_time_ms(&st->st_ctim);
break;
case NJS_FS_STAT_MTIME:
default:
v = njs_fs_time_ms(&st->st_mtim);
break;
}
switch (prop->value.data.magic32 >> 4) {
case NJS_NUMBER:
njs_set_number(retval, v);
break;
case NJS_DATE:
default:
date = njs_date_alloc(vm, v);
if (njs_slow_path(date == NULL)) {
return NJS_ERROR;
}
njs_set_date(retval, date);
break;
}
return NJS_OK;
}
static const njs_object_prop_t njs_fs_promises_properties[] =
{
{
.type = NJS_PROPERTY,
.name = njs_string("readFile"),
.value = njs_native_function2(njs_fs_read, 0, NJS_FS_PROMISE),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("appendFile"),
.value = njs_native_function2(njs_fs_write, 0,
njs_fs_magic(NJS_FS_PROMISE, NJS_FS_APPEND)),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("writeFile"),
.value = njs_native_function2(njs_fs_write, 0,
njs_fs_magic(NJS_FS_PROMISE, NJS_FS_TRUNC)),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("access"),
.value = njs_native_function2(njs_fs_access, 0, NJS_FS_PROMISE),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("mkdir"),
.value = njs_native_function2(njs_fs_mkdir, 0, NJS_FS_PROMISE),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("rename"),
.value = njs_native_function2(njs_fs_rename, 0, NJS_FS_PROMISE),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("rmdir"),
.value = njs_native_function2(njs_fs_rmdir, 0, NJS_FS_PROMISE),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("readdir"),
.value = njs_native_function2(njs_fs_readdir, 0, NJS_FS_PROMISE),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("lstat"),
.value = njs_native_function2(njs_fs_stat, 0,
njs_fs_magic(NJS_FS_PROMISE, NJS_FS_LSTAT)),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("stat"),
.value = njs_native_function2(njs_fs_stat, 0,
njs_fs_magic(NJS_FS_PROMISE, NJS_FS_STAT)),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("symlink"),
.value = njs_native_function2(njs_fs_symlink, 0, NJS_FS_PROMISE),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("unlink"),
.value = njs_native_function2(njs_fs_unlink, 0, NJS_FS_PROMISE),
.writable = 1,
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("realpath"),
.value = njs_native_function2(njs_fs_realpath, 0, NJS_FS_PROMISE