561 lines
13 KiB
C++
561 lines
13 KiB
C++
#include <stdafx.h>
|
|
#include "ScriptAPI.h"
|
|
#include <sys/stat.h>
|
|
|
|
#pragma warning(disable: 4702) // disable unreachable code warning
|
|
|
|
enum fsop { FS_READ, FS_WRITE };
|
|
static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op); // (fd, buffer, offset, length, position)
|
|
static duk_ret_t js__FileFinalizer(duk_context *ctx);
|
|
|
|
void ScriptAPI::Define_fs(duk_context *ctx)
|
|
{
|
|
// todo DukPutProps DukClass
|
|
|
|
const duk_function_list_entry funcs[] = {
|
|
{ "open", js_fs_open, DUK_VARARGS },
|
|
{ "close", js_fs_close, DUK_VARARGS },
|
|
{ "write", js_fs_write, DUK_VARARGS },
|
|
{ "writefile", js_fs_writefile, DUK_VARARGS },
|
|
{ "read", js_fs_read, DUK_VARARGS },
|
|
{ "readfile", js_fs_readfile, DUK_VARARGS },
|
|
{ "fstat", js_fs_fstat, DUK_VARARGS },
|
|
{ "stat", js_fs_stat, DUK_VARARGS },
|
|
{ "unlink", js_fs_unlink, DUK_VARARGS },
|
|
{ "mkdir", js_fs_mkdir, DUK_VARARGS },
|
|
{ "rmdir", js_fs_rmdir, DUK_VARARGS },
|
|
{ "readdir", js_fs_readdir, DUK_VARARGS },
|
|
{ "Stats", js_fs_Stats__constructor, DUK_VARARGS },
|
|
{ nullptr, nullptr, 0 }
|
|
};
|
|
|
|
const duk_function_list_entry Stats_funcs[] = {
|
|
{ "isFile", js_fs_Stats_isFile, DUK_VARARGS },
|
|
{ "isDirectory", js_fs_Stats_isDirectory, DUK_VARARGS },
|
|
{ nullptr, nullptr, 0 }
|
|
};
|
|
|
|
duk_push_global_object(ctx);
|
|
duk_push_string(ctx, "fs");
|
|
duk_push_object(ctx);
|
|
duk_put_function_list(ctx, -1, funcs);
|
|
|
|
duk_get_prop_string(ctx, -1, "Stats");
|
|
duk_push_object(ctx);
|
|
duk_put_function_list(ctx, -1, Stats_funcs);
|
|
duk_put_prop_string(ctx, -2, "prototype");
|
|
duk_pop(ctx);
|
|
|
|
duk_freeze(ctx, -1);
|
|
duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_ENUMERABLE);
|
|
duk_pop(ctx);
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_open(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_String, Arg_String });
|
|
|
|
const char* path = duk_get_string(ctx, 0);
|
|
const char* mode = duk_get_string(ctx, 1);
|
|
|
|
bool bModeValid = false;
|
|
|
|
const char* validModes[] = {
|
|
"r", "rb",
|
|
"w", "wb",
|
|
"a", "ab",
|
|
"r+", "rb+", "r+b",
|
|
"w+", "wb+", "w+b",
|
|
"a+", "ab+", "a+b",
|
|
nullptr
|
|
};
|
|
|
|
for (int i = 0; validModes[i] != nullptr; i++)
|
|
{
|
|
if (strcmp(mode, validModes[i]) == 0)
|
|
{
|
|
bModeValid = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bModeValid)
|
|
{
|
|
duk_push_error_object(ctx, DUK_ERR_TYPE_ERROR, "mode '%s' is not valid", mode);
|
|
return duk_throw(ctx);
|
|
}
|
|
|
|
FILE *fp = fopen(path, mode);
|
|
|
|
if(fp == nullptr)
|
|
{
|
|
duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: '%s')", path, mode);
|
|
return duk_throw(ctx);
|
|
}
|
|
|
|
int fd = _fileno(fp);
|
|
|
|
// FILES[fd] = {fp: fp}
|
|
duk_get_global_string(ctx, HS_gOpenFileDescriptors);
|
|
|
|
duk_push_object(ctx);
|
|
duk_push_pointer(ctx, fp);
|
|
duk_put_prop_string(ctx, -2, "fp");
|
|
duk_push_c_function(ctx, js__FileFinalizer, 1);
|
|
duk_set_finalizer(ctx, -2);
|
|
|
|
duk_put_prop_index(ctx, -2, fd);
|
|
duk_pop_n(ctx, 2);
|
|
|
|
duk_push_number(ctx, fd);
|
|
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_close(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_Number });
|
|
|
|
int fd = duk_get_int(ctx, 0);
|
|
int rc = -1;
|
|
|
|
duk_get_global_string(ctx, HS_gOpenFileDescriptors);
|
|
|
|
if(duk_has_prop_index(ctx, -1, fd))
|
|
{
|
|
duk_get_prop_index(ctx, -1, fd);
|
|
duk_get_prop_string(ctx, -1, "fp");
|
|
|
|
FILE* fp = (FILE*)duk_get_pointer(ctx, -1);
|
|
rc = fclose(fp);
|
|
|
|
// unset finalizer before deleting
|
|
duk_push_undefined(ctx);
|
|
duk_set_finalizer(ctx, -3);
|
|
duk_del_prop_index(ctx, -3, fd);
|
|
|
|
duk_pop_n(ctx, 2);
|
|
}
|
|
else
|
|
{
|
|
duk_push_error_object(ctx, DUK_ERR_ERROR, "invalid file descriptor");
|
|
return duk_throw(ctx);
|
|
}
|
|
|
|
duk_pop(ctx);
|
|
duk_push_number(ctx, rc);
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_write(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_Number, Arg_Any, Arg_OptNumber, Arg_OptNumber, Arg_OptNumber });
|
|
return ReadWriteImpl(ctx, FS_WRITE);
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_writefile(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_String, Arg_Any });
|
|
|
|
const char* path = duk_get_string(ctx, 0);
|
|
|
|
void* buffer;
|
|
duk_size_t bufferSize;
|
|
|
|
if(duk_is_string(ctx, 1))
|
|
{
|
|
buffer = (void*)duk_get_lstring(ctx, 1, &bufferSize);
|
|
}
|
|
else if(duk_is_buffer_data(ctx, 1))
|
|
{
|
|
buffer = duk_get_buffer_data(ctx, 1, &bufferSize);
|
|
}
|
|
else
|
|
{
|
|
return ThrowInvalidArgsError(ctx);
|
|
}
|
|
|
|
FILE* fp = fopen(path, "wb");
|
|
|
|
if(fp == nullptr)
|
|
{
|
|
duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: 'wb')", path);
|
|
return duk_throw(ctx);
|
|
}
|
|
|
|
if(fwrite(buffer, 1, bufferSize, fp) != bufferSize)
|
|
{
|
|
fclose(fp);
|
|
return DUK_RET_ERROR;
|
|
}
|
|
|
|
fclose(fp);
|
|
return 0;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_read(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_Number, Arg_Any, Arg_Number, Arg_Number, Arg_Number });
|
|
return ReadWriteImpl(ctx, FS_READ);
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_readfile(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_String });
|
|
|
|
const char* path = duk_get_string(ctx, 0);
|
|
|
|
FILE* fp = fopen(path, "rb");
|
|
|
|
if(fp == nullptr)
|
|
{
|
|
duk_push_error_object(ctx, DUK_ERR_ERROR, "could not open '%s' (mode: 'rb')", path);
|
|
return duk_throw(ctx);
|
|
}
|
|
|
|
struct stat stats;
|
|
if(fstat(_fileno(fp), &stats) != 0)
|
|
{
|
|
fclose(fp);
|
|
return DUK_RET_ERROR;
|
|
}
|
|
|
|
void *data = duk_push_fixed_buffer(ctx, stats.st_size);
|
|
duk_push_buffer_object(ctx, -1, 0, stats.st_size, DUK_BUFOBJ_NODEJS_BUFFER);
|
|
|
|
if(fread(data, 1, stats.st_size, fp) != (size_t)stats.st_size)
|
|
{
|
|
duk_pop(ctx);
|
|
fclose(fp);
|
|
return DUK_RET_ERROR;
|
|
}
|
|
|
|
fclose(fp);
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_fstat(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_Number });
|
|
|
|
int fd = duk_get_int(ctx, 0);
|
|
|
|
duk_push_global_object(ctx);
|
|
duk_get_prop_string(ctx, -1, "fs");
|
|
duk_get_prop_string(ctx, -1, "Stats");
|
|
duk_push_number(ctx, fd);
|
|
duk_new(ctx, 1);
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_stat(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_String });
|
|
|
|
const char *path = duk_get_string(ctx, 0);
|
|
|
|
duk_push_global_object(ctx);
|
|
duk_get_prop_string(ctx, -1, "fs");
|
|
duk_get_prop_string(ctx, -1, "Stats");
|
|
duk_push_string(ctx, path);
|
|
duk_new(ctx, 1);
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_unlink(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_String });
|
|
|
|
const char *path = duk_get_string(ctx, 0);
|
|
duk_push_boolean(ctx, DeleteFileA(path) != 0);
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_mkdir(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_String });
|
|
|
|
const char *path = duk_get_string(ctx, 0);
|
|
duk_push_boolean(ctx, CreateDirectoryA(path, nullptr) != 0);
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_rmdir(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_String });
|
|
|
|
const char *path = duk_get_string(ctx, 0);
|
|
duk_push_boolean(ctx, RemoveDirectoryA(path) != 0);
|
|
return 1;
|
|
}
|
|
|
|
// todo make sure failure behavior is similar to nodejs's fs.readdirSync
|
|
duk_ret_t ScriptAPI::js_fs_readdir(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, { Arg_String });
|
|
|
|
const char* path = duk_get_string(ctx, 0);
|
|
|
|
char findFileName[MAX_PATH];
|
|
snprintf(findFileName, sizeof(findFileName), "%s%s", path, "\\*");
|
|
|
|
WIN32_FIND_DATAA ffd;
|
|
HANDLE hFind = FindFirstFileA(findFileName, &ffd);
|
|
|
|
if(hFind == INVALID_HANDLE_VALUE)
|
|
{
|
|
return DUK_RET_ERROR;
|
|
}
|
|
|
|
duk_uarridx_t idx = 0;
|
|
duk_push_array(ctx);
|
|
|
|
do
|
|
{
|
|
if(strcmp(ffd.cFileName, ".") == 0 ||
|
|
strcmp(ffd.cFileName, "..") == 0)
|
|
{
|
|
continue;
|
|
}
|
|
duk_push_string(ctx, ffd.cFileName);
|
|
duk_put_prop_index(ctx, -2, idx++);
|
|
} while(FindNextFileA(hFind, &ffd));
|
|
|
|
FindClose(hFind);
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_Stats__constructor(duk_context *ctx)
|
|
{
|
|
if(!duk_is_constructor_call(ctx))
|
|
{
|
|
return DUK_RET_TYPE_ERROR;
|
|
}
|
|
|
|
if(duk_get_top(ctx) != 1)
|
|
{
|
|
return ThrowInvalidArgsError(ctx);
|
|
}
|
|
|
|
struct stat stats;
|
|
|
|
if(duk_is_number(ctx, 0))
|
|
{
|
|
int fd = duk_get_int(ctx, 0);
|
|
if(fstat(fd, &stats) != 0)
|
|
{
|
|
return DUK_RET_ERROR;
|
|
}
|
|
}
|
|
else if(duk_is_string(ctx, 0))
|
|
{
|
|
const char *path = duk_get_string(ctx, 0);
|
|
if(stat(path, &stats) != 0)
|
|
{
|
|
return DUK_RET_ERROR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ThrowInvalidArgsError(ctx);
|
|
}
|
|
|
|
const duk_number_list_entry numbers[] = {
|
|
{ "dev", (double)stats.st_dev },
|
|
{ "ino", (double)stats.st_ino },
|
|
{ "mode", (double)stats.st_mode },
|
|
{ "nlink", (double)stats.st_nlink },
|
|
{ "uid", (double)stats.st_uid },
|
|
{ "gid", (double)stats.st_gid },
|
|
{ "rdev", (double)stats.st_rdev },
|
|
{ "size", (double)stats.st_size },
|
|
{ "atimeMs", (double)stats.st_atime * 1000 },
|
|
{ "mtimeMs", (double)stats.st_mtime * 1000 },
|
|
{ "ctimeMs", (double)stats.st_ctime * 1000 },
|
|
{ nullptr, 0 }
|
|
};
|
|
|
|
struct { const char *key; time_t time; } dates[3] = {
|
|
{ "atime", stats.st_atime * 1000 },
|
|
{ "mtime", stats.st_mtime * 1000 },
|
|
{ "ctime", stats.st_ctime * 1000 },
|
|
};
|
|
|
|
duk_push_global_object(ctx);
|
|
duk_get_prop_string(ctx, -1, "Date");
|
|
duk_remove(ctx, -2);
|
|
|
|
duk_push_this(ctx);
|
|
duk_put_number_list(ctx, -1, numbers);
|
|
|
|
for(int i = 0; i < 3; i++)
|
|
{
|
|
duk_dup(ctx, -2);
|
|
duk_push_number(ctx, (duk_double_t)dates[i].time);
|
|
duk_new(ctx, 1);
|
|
duk_put_prop_string(ctx, -2, dates[i].key);
|
|
}
|
|
|
|
duk_remove(ctx, -2);
|
|
duk_freeze(ctx, -1);
|
|
return 0;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_Stats_isDirectory(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, {});
|
|
|
|
duk_push_this(ctx);
|
|
duk_get_prop_string(ctx, -1, "mode");
|
|
duk_uint_t mode = duk_get_uint(ctx, -1);
|
|
duk_push_boolean(ctx, (mode & S_IFDIR) != 0);
|
|
return 1;
|
|
}
|
|
|
|
duk_ret_t ScriptAPI::js_fs_Stats_isFile(duk_context *ctx)
|
|
{
|
|
CheckArgs(ctx, {});
|
|
|
|
duk_push_this(ctx);
|
|
duk_get_prop_string(ctx, -1, "mode");
|
|
duk_uint_t mode = duk_get_uint(ctx, -1);
|
|
duk_push_boolean(ctx, (mode & S_IFREG) != 0);
|
|
return 1;
|
|
}
|
|
|
|
static duk_ret_t ReadWriteImpl(duk_context *ctx, fsop op)
|
|
{
|
|
int fd;
|
|
const char* buffer;
|
|
size_t offset = 0;
|
|
size_t length = 0;
|
|
size_t position = 0;
|
|
|
|
bool bHavePos = false;
|
|
duk_size_t bufferSize;
|
|
FILE* fp;
|
|
size_t rc;
|
|
|
|
duk_idx_t nargs = duk_get_top(ctx);
|
|
|
|
if(nargs < 2 || !duk_is_number(ctx, 0))
|
|
{
|
|
goto err_invalid_args;
|
|
}
|
|
|
|
fd = duk_get_int(ctx, 0);
|
|
|
|
if(duk_is_buffer_data(ctx, 1))
|
|
{
|
|
buffer = (const char*)duk_get_buffer_data(ctx, 1, &bufferSize);
|
|
}
|
|
else if(duk_is_string(ctx, 1) && op == FS_WRITE)
|
|
{
|
|
buffer = duk_get_lstring(ctx, 1, &bufferSize);
|
|
}
|
|
else
|
|
{
|
|
goto err_invalid_args;
|
|
}
|
|
|
|
if(nargs >= 3)
|
|
{
|
|
if(!duk_is_number(ctx, 2))
|
|
{
|
|
goto err_invalid_args;
|
|
}
|
|
|
|
offset = duk_get_uint(ctx, 2);
|
|
|
|
if(offset >= bufferSize)
|
|
{
|
|
goto err_invalid_range;
|
|
}
|
|
}
|
|
|
|
length = bufferSize - offset;
|
|
|
|
if(nargs >= 4)
|
|
{
|
|
if(!duk_is_number(ctx, 3))
|
|
{
|
|
goto err_invalid_args;
|
|
}
|
|
length = duk_get_uint(ctx, 3);
|
|
}
|
|
|
|
if(nargs >= 5)
|
|
{
|
|
if(!duk_is_number(ctx, 4))
|
|
{
|
|
goto err_invalid_args;
|
|
}
|
|
position = duk_get_uint(ctx, 4);
|
|
bHavePos = true;
|
|
}
|
|
|
|
if(offset + length > bufferSize)
|
|
{
|
|
goto err_invalid_range;
|
|
}
|
|
|
|
duk_get_global_string(ctx, HS_gOpenFileDescriptors);
|
|
|
|
if(!duk_has_prop_index(ctx, -1, fd))
|
|
{
|
|
goto err_invalid_fd;
|
|
}
|
|
|
|
duk_get_prop_index(ctx, -1, fd);
|
|
duk_get_prop_string(ctx, -1, "fp");
|
|
fp = (FILE*)duk_get_pointer(ctx, -1);
|
|
|
|
duk_pop_n(ctx, 3);
|
|
|
|
if(bHavePos)
|
|
{
|
|
fseek(fp, position, SEEK_SET);
|
|
}
|
|
|
|
switch(op)
|
|
{
|
|
case FS_READ:
|
|
rc = fread((void*)&buffer[offset], 1, length, fp);
|
|
break;
|
|
case FS_WRITE:
|
|
rc = fwrite((void*)&buffer[offset], 1, length, fp);
|
|
break;
|
|
default:
|
|
return DUK_RET_ERROR;
|
|
}
|
|
|
|
duk_push_number(ctx, rc);
|
|
return 1;
|
|
|
|
err_invalid_args:
|
|
return ScriptAPI::ThrowInvalidArgsError(ctx);
|
|
|
|
err_invalid_range:
|
|
duk_push_error_object(ctx, DUK_ERR_RANGE_ERROR, "invalid range");
|
|
return duk_throw(ctx);
|
|
|
|
err_invalid_fd:
|
|
duk_push_error_object(ctx, DUK_ERR_ERROR, "invalid file descriptor");
|
|
return duk_throw(ctx);
|
|
}
|
|
|
|
static duk_ret_t js__FileFinalizer(duk_context *ctx)
|
|
{
|
|
CScriptInstance* inst = ScriptAPI::GetInstance(ctx);
|
|
|
|
duk_get_prop_string(ctx, 0, "fp");
|
|
FILE *fp = (FILE *)duk_get_pointer(ctx, -1);
|
|
duk_pop(ctx);
|
|
fclose(fp);
|
|
|
|
inst->System()->ConsoleLog("[SCRIPTSYS]: warning ('%s'): gc closed leftover file descriptor",
|
|
inst->Name().c_str());
|
|
|
|
return 0;
|
|
}
|