/*
* fs.unlink
*/
static int fs_unlink(lua_State* L) {
FSR__SETUP
const char *path = luaL_checkstring(L, 1);
FSR__SET_OPT_CB(2, on_fs_callback)
uv_fs_unlink(loop, req, path, cb);
FSR__TEARDOWN
}
static int pipe_echo_start(char* pipeName) {
int r;
#ifndef _WIN32
{
uv_fs_t req;
uv_fs_unlink(uv_default_loop(), &req, pipeName, NULL);
uv_fs_req_cleanup(&req);
}
#endif
server = (uv_handle_t*)&pipeServer;
serverType = PIPE;
r = uv_pipe_init(loop, &pipeServer, 0);
if (r) {
fprintf(stderr, "uv_pipe_init: %s\n", uv_strerror(r));
return 1;
}
r = uv_pipe_bind(&pipeServer, pipeName);
if (r) {
fprintf(stderr, "uv_pipe_bind: %s\n", uv_strerror(r));
return 1;
}
r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
if (r) {
fprintf(stderr, "uv_pipe_listen: %s\n", uv_strerror(r));
return 1;
}
return 0;
}
DLLEXPORT int jl_fs_unlink(char *path)
{
uv_fs_t req;
int ret = uv_fs_unlink(jl_io_loop, &req, path, NULL);
uv_fs_req_cleanup(&req);
return ret;
}
Status
api_init (Server *server)
{
Api *api = &server->api;
int rc = 0;
api->reusable_base = NULL;
api->base_alloc = false;
debug ("pipe unlink: %s", server->host_pipe);
uv_fs_t req;
uv_fs_unlink (server->loop, &req, server->host_pipe, NULL);
// ignore error if pipe doesn't already exist
debug ("pipe init");
rc = uv_pipe_init (server->loop, (uv_pipe_t *) api, 0);
if (rc < 0)
goto error;
debug ("pipe bind: %s", server->host_pipe);
rc = uv_pipe_bind ((uv_pipe_t *) api, server->host_pipe);
if (rc < 0)
goto error;
return G_OK;
error:
if (rc)
debug ("error: %s", uv_strerror (rc));
return G_ERR;
}
/// Remove a file.
///
/// @return `0` for success, non-zero for failure.
int os_remove(const char *path)
{
uv_fs_t request;
int result = uv_fs_unlink(uv_default_loop(), &request, path, NULL);
uv_fs_req_cleanup(&request);
return result;
}
void remove_realm_files_from_directory(const std::string &dir_path)
{
FileSystemRequest scandir_req;
if (uv_fs_scandir(uv_default_loop(), &scandir_req, dir_path.c_str(), 0, nullptr) < 0) {
throw UVException(static_cast<uv_errno_t>(scandir_req.result));
}
uv_dirent_t entry;
while (uv_fs_scandir_next(&scandir_req, &entry) != UV_EOF) {
std::string path(dir_path + '/' + entry.name);
if (entry.type == UV_DIRENT_DIR) {
static std::string realm_management_extension(".realm.management");
if (ends_with(path, realm_management_extension)) {
uv_dirent_t management_entry;
FileSystemRequest management_scandir_req;
if (uv_fs_scandir(uv_default_loop(), &management_scandir_req, path.c_str(), 0, nullptr) < 0) {
throw UVException(static_cast<uv_errno_t>(scandir_req.result));
}
while (uv_fs_scandir_next(&management_scandir_req, &management_entry) != UV_EOF) {
std::string management_entry_path = path + '/' + management_entry.name;
FileSystemRequest delete_req;
if (uv_fs_unlink(uv_default_loop(), &delete_req, management_entry_path.c_str(), nullptr) != 0) {
throw UVException(static_cast<uv_errno_t>(delete_req.result));
}
}
FileSystemRequest management_rmdir_req;
if (uv_fs_rmdir(uv_default_loop(), &management_rmdir_req, path.c_str(), nullptr)) {
throw UVException(static_cast<uv_errno_t>(management_rmdir_req.result));
}
}
} else {
static std::string realm_extension(".realm");
static std::string realm_note_extension(".realm.note");
static std::string realm_lock_extension(".realm.lock");
if (ends_with(path, realm_extension) || ends_with(path, realm_note_extension) || ends_with(path, realm_lock_extension)) {
FileSystemRequest delete_req;
if (uv_fs_unlink(uv_default_loop(), &delete_req, path.c_str(), nullptr) != 0) {
throw UVException(static_cast<uv_errno_t>(delete_req.result));
}
}
}
}
}
JL_DLLEXPORT int jl_fs_unlink(char *path)
{
uv_fs_t req;
JL_SIGATOMIC_BEGIN();
int ret = uv_fs_unlink(jl_io_loop, &req, path, NULL);
uv_fs_req_cleanup(&req);
JL_SIGATOMIC_END();
return ret;
}
static void close_cb(uv_fs_t* req) {
int r;
ASSERT(req == &close_req);
ASSERT(req->fs_type == UV_FS_CLOSE);
ASSERT(req->result != -1);
close_cb_count++;
uv_fs_req_cleanup(req);
if (close_cb_count == 3) {
r = uv_fs_unlink(loop, &unlink_req, "test_file2", unlink_cb);
}
}
static void close_cb(uv_fs_t* req) {
int r;
TUV_ASSERT(req == &close_req);
TUV_ASSERT(req->fs_type == UV_FS_CLOSE);
TUV_ASSERT(req->result == 0);
close_cb_count++;
uv_fs_req_cleanup(req);
if (close_cb_count == 3) {
r = uv_fs_unlink(loop, &unlink_req, filename2, unlink_cb);
TUV_ASSERT(r == 0);
}
}
void durotanInit() {
int err;
durotan = malloc(sizeof(uv_pipe_t));
uv_pipe_init(loop, durotan, 0);
uv_fs_t req;
uv_fs_unlink(loop, &req, SOCKET, NULL);
err = uv_pipe_bind(durotan, SOCKET);
if(err) ERROR("durotan bind", err);
err = uv_listen((uv_stream_t*) durotan, 128, durotanOnConnection);
if(err) ERROR("durotan listen", err);
printf("durotan: listening\n");
}
void MVM_file_delete(MVMThreadContext *tc, MVMString *f) {
uv_fs_t req;
char * const a = MVM_string_utf8_encode_C_string(tc, f);
#ifdef _WIN32
const int r = MVM_platform_unlink(a);
if( r < 0 && r != ENOENT) {
MVM_free(a);
MVM_exception_throw_adhoc(tc, "Failed to delete file: %d", errno);
}
#else
const int r = uv_fs_unlink(tc->loop, &req, a, NULL);
if( r < 0 && r != UV_ENOENT) {
MVM_free(a);
MVM_exception_throw_adhoc(tc, "Failed to delete file: %s", uv_strerror(req.result));
}
#endif
MVM_free(a);
}
void remove_sock(int sig) {
uv_fs_t req;
uv_fs_unlink(loop, &req, "echo.sock", NULL);
exit(0);
}
static ssize_t uv__fs_copyfile(uv_fs_t* req) {
#if defined(__APPLE__) && !TARGET_OS_IPHONE
/* On macOS, use the native copyfile(3). */
copyfile_flags_t flags;
flags = COPYFILE_ALL;
if (req->flags & UV_FS_COPYFILE_EXCL)
flags |= COPYFILE_EXCL;
return copyfile(req->path, req->new_path, NULL, flags);
#else
uv_fs_t fs_req;
uv_file srcfd;
uv_file dstfd;
struct stat statsbuf;
int dst_flags;
int result;
int err;
size_t bytes_to_send;
int64_t in_offset;
dstfd = -1;
err = 0;
/* Open the source file. */
srcfd = uv_fs_open(NULL, &fs_req, req->path, O_RDONLY, 0, NULL);
uv_fs_req_cleanup(&fs_req);
if (srcfd < 0)
return srcfd;
/* Get the source file's mode. */
if (fstat(srcfd, &statsbuf)) {
err = -errno;
goto out;
}
dst_flags = O_WRONLY | O_CREAT | O_TRUNC;
if (req->flags & UV_FS_COPYFILE_EXCL)
dst_flags |= O_EXCL;
/* Open the destination file. */
dstfd = uv_fs_open(NULL,
&fs_req,
req->new_path,
dst_flags,
statsbuf.st_mode,
NULL);
uv_fs_req_cleanup(&fs_req);
if (dstfd < 0) {
err = dstfd;
goto out;
}
if (fchmod(dstfd, statsbuf.st_mode) == -1) {
err = -errno;
goto out;
}
bytes_to_send = statsbuf.st_size;
in_offset = 0;
while (bytes_to_send != 0) {
err = uv_fs_sendfile(NULL,
&fs_req,
dstfd,
srcfd,
in_offset,
bytes_to_send,
NULL);
uv_fs_req_cleanup(&fs_req);
if (err < 0)
break;
bytes_to_send -= fs_req.result;
in_offset += fs_req.result;
}
out:
if (err < 0)
result = err;
else
result = 0;
/* Close the source file. */
err = uv__close_nocheckstdio(srcfd);
/* Don't overwrite any existing errors. */
if (err != 0 && result == 0)
result = err;
/* Close the destination file if it is open. */
if (dstfd >= 0) {
err = uv__close_nocheckstdio(dstfd);
/* Don't overwrite any existing errors. */
if (err != 0 && result == 0)
result = err;
/* Remove the destination file if something went wrong. */
if (result != 0) {
uv_fs_unlink(NULL, &fs_req, req->new_path, NULL);
/* Ignore the unlink return value, as an error already happened. */
uv_fs_req_cleanup(&fs_req);
}
}
return result;
#endif
}
static ssize_t uv__fs_copyfile(uv_fs_t* req) {
#if defined(__APPLE__) && !TARGET_OS_IPHONE
/* On macOS, use the native copyfile(3). */
copyfile_flags_t flags;
flags = COPYFILE_ALL;
if (req->flags & UV_FS_COPYFILE_EXCL)
flags |= COPYFILE_EXCL;
#ifdef COPYFILE_CLONE
if (req->flags & UV_FS_COPYFILE_FICLONE)
flags |= COPYFILE_CLONE;
#endif
if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
#ifdef COPYFILE_CLONE_FORCE
flags |= COPYFILE_CLONE_FORCE;
#else
return UV_ENOSYS;
#endif
}
return copyfile(req->path, req->new_path, NULL, flags);
#else
uv_fs_t fs_req;
uv_file srcfd;
uv_file dstfd;
struct stat statsbuf;
int dst_flags;
int result;
int err;
size_t bytes_to_send;
int64_t in_offset;
dstfd = -1;
err = 0;
/* Open the source file. */
srcfd = uv_fs_open(NULL, &fs_req, req->path, O_RDONLY, 0, NULL);
uv_fs_req_cleanup(&fs_req);
if (srcfd < 0)
return srcfd;
/* Get the source file's mode. */
if (fstat(srcfd, &statsbuf)) {
err = UV__ERR(errno);
goto out;
}
dst_flags = O_WRONLY | O_CREAT | O_TRUNC;
if (req->flags & UV_FS_COPYFILE_EXCL)
dst_flags |= O_EXCL;
/* Open the destination file. */
dstfd = uv_fs_open(NULL,
&fs_req,
req->new_path,
dst_flags,
statsbuf.st_mode,
NULL);
uv_fs_req_cleanup(&fs_req);
if (dstfd < 0) {
err = dstfd;
goto out;
}
if (fchmod(dstfd, statsbuf.st_mode) == -1) {
err = UV__ERR(errno);
goto out;
}
#ifdef FICLONE
if (req->flags & UV_FS_COPYFILE_FICLONE ||
req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
if (ioctl(dstfd, FICLONE, srcfd) == -1) {
/* If an error occurred that the sendfile fallback also won't handle, or
this is a force clone then exit. Otherwise, fall through to try using
sendfile(). */
if (errno != ENOTTY && errno != EOPNOTSUPP && errno != EXDEV) {
err = UV__ERR(errno);
goto out;
} else if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
err = UV_ENOTSUP;
goto out;
}
} else {
goto out;
}
}
#else
if (req->flags & UV_FS_COPYFILE_FICLONE_FORCE) {
err = UV_ENOSYS;
goto out;
}
#endif
bytes_to_send = statsbuf.st_size;
in_offset = 0;
while (bytes_to_send != 0) {
err = uv_fs_sendfile(NULL,
&fs_req,
dstfd,
srcfd,
in_offset,
bytes_to_send,
NULL);
uv_fs_req_cleanup(&fs_req);
if (err < 0)
break;
bytes_to_send -= fs_req.result;
in_offset += fs_req.result;
}
out:
if (err < 0)
result = err;
else
result = 0;
/* Close the source file. */
err = uv__close_nocheckstdio(srcfd);
/* Don't overwrite any existing errors. */
if (err != 0 && result == 0)
result = err;
/* Close the destination file if it is open. */
if (dstfd >= 0) {
err = uv__close_nocheckstdio(dstfd);
/* Don't overwrite any existing errors. */
if (err != 0 && result == 0)
result = err;
/* Remove the destination file if something went wrong. */
if (result != 0) {
uv_fs_unlink(NULL, &fs_req, req->new_path, NULL);
/* Ignore the unlink return value, as an error already happened. */
uv_fs_req_cleanup(&fs_req);
}
}
if (result == 0)
return 0;
errno = UV__ERR(result);
return -1;
#endif
}
extern "C" int
rust_uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
return uv_fs_unlink(loop, req, path, cb);
}
