/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to

* deal in the Software without restriction, including without limitation the

* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

* sell copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

* IN THE SOFTWARE.

*/

#include "uv.h"

#include "task.h"

#include <errno.h>

#include <string.h> /* memset */

#include <fcntl.h>

#include <sys/stat.h>

#include <limits.h> /* INT_MAX, PATH_MAX, IOV_MAX */

#ifndef _WIN32

# include <unistd.h> /* unlink, rmdir, etc. */

#else

# include <winioctl.h>

# include <direct.h>

# include <io.h>

# ifndef ERROR_SYMLINK_NOT_SUPPORTED

# define ERROR_SYMLINK_NOT_SUPPORTED 1464

# endif

# define unlink _unlink

# define rmdir _rmdir

# define open _open

# define write _write

# define close _close

# ifndef stat

# define stat _stati64

# endif

# ifndef lseek

# define lseek _lseek

# endif

#endif

#define TOO_LONG_NAME_LENGTH 65536

#define PATHMAX 4096

typedef struct {

const char* path;

double atime;

double mtime;

} utime_check_t;

static int dummy_cb_count;

static int close_cb_count;

static int create_cb_count;

static int open_cb_count;

static int read_cb_count;

static int write_cb_count;

static int unlink_cb_count;

static int mkdir_cb_count;

static int mkdtemp_cb_count;

static int mkstemp_cb_count;

static int rmdir_cb_count;

static int scandir_cb_count;

static int stat_cb_count;

static int rename_cb_count;

static int fsync_cb_count;

static int fdatasync_cb_count;

static int ftruncate_cb_count;

static int sendfile_cb_count;

static int fstat_cb_count;

static int access_cb_count;

static int chmod_cb_count;

static int fchmod_cb_count;

static int chown_cb_count;

static int fchown_cb_count;

static int lchown_cb_count;

static int link_cb_count;

static int symlink_cb_count;

static int readlink_cb_count;

static int realpath_cb_count;

static int utime_cb_count;

static int futime_cb_count;

static int lutime_cb_count;

static int statfs_cb_count;

static uv_loop_t* loop;

static uv_fs_t open_req1;

static uv_fs_t open_req2;

static uv_fs_t read_req;

static uv_fs_t write_req;

static uv_fs_t unlink_req;

static uv_fs_t close_req;

static uv_fs_t mkdir_req;

static uv_fs_t mkdtemp_req1;

static uv_fs_t mkdtemp_req2;

static uv_fs_t mkstemp_req1;

static uv_fs_t mkstemp_req2;

static uv_fs_t mkstemp_req3;

static uv_fs_t rmdir_req;

static uv_fs_t scandir_req;

static uv_fs_t stat_req;

static uv_fs_t rename_req;

static uv_fs_t fsync_req;

static uv_fs_t fdatasync_req;

static uv_fs_t ftruncate_req;

static uv_fs_t sendfile_req;

static uv_fs_t utime_req;

static uv_fs_t futime_req;

static char buf[32];

static char buf2[32];

static char test_buf[] = "test-buffer\n";

static char test_buf2[] = "second-buffer\n";

static uv_buf_t iov;

#ifdef _WIN32

int uv_test_getiovmax(void) {

return INT32_MAX; /* Emulated by libuv, so no real limit. */

}

#else

int uv_test_getiovmax(void) {

#if defined(IOV_MAX)

return IOV_MAX;

#elif defined(_SC_IOV_MAX)

static int iovmax = -1;

if (iovmax == -1) {

iovmax = sysconf(_SC_IOV_MAX);

/* On some embedded devices (arm-linux-uclibc based ip camera),

* sysconf(_SC_IOV_MAX) can not get the correct value. The return

* value is -1 and the errno is EINPROGRESS. Degrade the value to 1.

*/

if (iovmax == -1) iovmax = 1;

}

return iovmax;

#else

return 1024;

#endif

}

#endif

#ifdef _WIN32

/*

* This tag and guid have no special meaning, and don't conflict with

* reserved ids.

*/

static unsigned REPARSE_TAG = 0x9913;

static GUID REPARSE_GUID = {

0x1bf6205f, 0x46ae, 0x4527,

{ 0xb1, 0x0c, 0xc5, 0x09, 0xb7, 0x55, 0x22, 0x80 }};

#endif

static void check_permission(const char* filename, unsigned int mode) {

int r;

uv_fs_t req;

uv_stat_t* s;

r = uv_fs_stat(NULL, &req, filename, NULL);

ASSERT(r == 0);

ASSERT(req.result == 0);

s = &req.statbuf;

#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__)

/*

* On Windows, chmod can only modify S_IWUSR (_S_IWRITE) bit,

* so only testing for the specified flags.

*/

ASSERT((s->st_mode & 0777) & mode);

#else

ASSERT((s->st_mode & 0777) == mode);

#endif

uv_fs_req_cleanup(&req);

}

static void dummy_cb(uv_fs_t* req) {

(void) req;

dummy_cb_count++;

}

static void link_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_LINK);

ASSERT(req->result == 0);

link_cb_count++;

uv_fs_req_cleanup(req);

}

static void symlink_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_SYMLINK);

ASSERT(req->result == 0);

symlink_cb_count++;

uv_fs_req_cleanup(req);

}

static void readlink_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_READLINK);

ASSERT(req->result == 0);

ASSERT(strcmp(req->ptr, "test_file_symlink2") == 0);

readlink_cb_count++;

uv_fs_req_cleanup(req);

}

static void realpath_cb(uv_fs_t* req) {

char test_file_abs_buf[PATHMAX];

size_t test_file_abs_size = sizeof(test_file_abs_buf);

ASSERT(req->fs_type == UV_FS_REALPATH);

#ifdef _WIN32

/*

* Windows XP and Server 2003 don't support GetFinalPathNameByHandleW()

*/

if (req->result == UV_ENOSYS) {

realpath_cb_count++;

uv_fs_req_cleanup(req);

return;

}

#endif

ASSERT(req->result == 0);

uv_cwd(test_file_abs_buf, &test_file_abs_size);

#ifdef _WIN32

strcat(test_file_abs_buf, "\\test_file");

ASSERT(stricmp(req->ptr, test_file_abs_buf) == 0);

#else

strcat(test_file_abs_buf, "/test_file");

ASSERT(strcmp(req->ptr, test_file_abs_buf) == 0);

#endif

realpath_cb_count++;

uv_fs_req_cleanup(req);

}

static void access_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_ACCESS);

access_cb_count++;

uv_fs_req_cleanup(req);

}

static void fchmod_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_FCHMOD);

ASSERT(req->result == 0);

fchmod_cb_count++;

uv_fs_req_cleanup(req);

check_permission("test_file", *(int*)req->data);

}

static void chmod_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_CHMOD);

ASSERT(req->result == 0);

chmod_cb_count++;

uv_fs_req_cleanup(req);

check_permission("test_file", *(int*)req->data);

}

static void fchown_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_FCHOWN);

ASSERT(req->result == 0);

fchown_cb_count++;

uv_fs_req_cleanup(req);

}

static void chown_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_CHOWN);

ASSERT(req->result == 0);

chown_cb_count++;

uv_fs_req_cleanup(req);

}

static void lchown_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_LCHOWN);

ASSERT(req->result == 0);

lchown_cb_count++;

uv_fs_req_cleanup(req);

}

static void chown_root_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_CHOWN);

#if defined(_WIN32) || defined(__MSYS__)

/* On windows, chown is a no-op and always succeeds. */

ASSERT(req->result == 0);

#else

/* On unix, chown'ing the root directory is not allowed -

* unless you're root, of course.

*/

if (geteuid() == 0)

ASSERT(req->result == 0);

else

# if defined(__CYGWIN__)

/* On Cygwin, uid 0 is invalid (no root). */

ASSERT(req->result == UV_EINVAL);

# elif defined(__PASE__)

/* On IBMi PASE, there is no root user. uid 0 is user qsecofr.

* User may grant qsecofr's privileges, including changing

* the file's ownership to uid 0.

*/

ASSERT(req->result == 0 || req->result == UV_EPERM);

# else

ASSERT(req->result == UV_EPERM);

# endif

#endif

chown_cb_count++;

uv_fs_req_cleanup(req);

}

static void unlink_cb(uv_fs_t* req) {

ASSERT(req == &unlink_req);

ASSERT(req->fs_type == UV_FS_UNLINK);

ASSERT(req->result == 0);

unlink_cb_count++;

uv_fs_req_cleanup(req);

}

static void fstat_cb(uv_fs_t* req) {

uv_stat_t* s = req->ptr;

ASSERT(req->fs_type == UV_FS_FSTAT);

ASSERT(req->result == 0);

ASSERT(s->st_size == sizeof(test_buf));

uv_fs_req_cleanup(req);

fstat_cb_count++;

}

static void statfs_cb(uv_fs_t* req) {

uv_statfs_t* stats;

ASSERT(req->fs_type == UV_FS_STATFS);

ASSERT(req->result == 0);

ASSERT_NOT_NULL(req->ptr);

stats = req->ptr;

#if defined(_WIN32) || defined(__sun) || defined(_AIX) || defined(__MVS__) || \

defined(__OpenBSD__) || defined(__NetBSD__)

ASSERT(stats->f_type == 0);

#else

ASSERT(stats->f_type > 0);

#endif

ASSERT(stats->f_bsize > 0);

ASSERT(stats->f_blocks > 0);

ASSERT(stats->f_bfree <= stats->f_blocks);

ASSERT(stats->f_bavail <= stats->f_bfree);

#ifdef _WIN32

ASSERT(stats->f_files == 0);

ASSERT(stats->f_ffree == 0);

#else

/* There is no assertion for stats->f_files that makes sense, so ignore it. */

ASSERT(stats->f_ffree <= stats->f_files);

#endif

uv_fs_req_cleanup(req);

ASSERT_NULL(req->ptr);

statfs_cb_count++;

}

static void close_cb(uv_fs_t* req) {

int r;

ASSERT(req == &close_req);

ASSERT(req->fs_type == UV_FS_CLOSE);

ASSERT(req->result == 0);

close_cb_count++;

uv_fs_req_cleanup(req);

if (close_cb_count == 3) {

r = uv_fs_unlink(loop, &unlink_req, "test_file2", unlink_cb);

ASSERT(r == 0);

}

}

static void ftruncate_cb(uv_fs_t* req) {

int r;

ASSERT(req == &ftruncate_req);

ASSERT(req->fs_type == UV_FS_FTRUNCATE);

ASSERT(req->result == 0);

ftruncate_cb_count++;

uv_fs_req_cleanup(req);

r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);

ASSERT(r == 0);

}

static void fail_cb(uv_fs_t* req) {

FATAL("fail_cb should not have been called");

}

static void read_cb(uv_fs_t* req) {

int r;

ASSERT(req == &read_req);

ASSERT(req->fs_type == UV_FS_READ);

ASSERT(req->result >= 0); /* FIXME(bnoordhuis) Check if requested size? */

read_cb_count++;

uv_fs_req_cleanup(req);

if (read_cb_count == 1) {

ASSERT(strcmp(buf, test_buf) == 0);

r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7,

ftruncate_cb);

} else {

ASSERT(strcmp(buf, "test-bu") == 0);

r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);

}

ASSERT(r == 0);

}

static void open_cb(uv_fs_t* req) {

int r;

ASSERT(req == &open_req1);

ASSERT(req->fs_type == UV_FS_OPEN);

if (req->result < 0) {

fprintf(stderr, "async open error: %d\n", (int) req->result);

ASSERT(0);

}

open_cb_count++;

ASSERT(req->path);

ASSERT(memcmp(req->path, "test_file2\0", 11) == 0);

uv_fs_req_cleanup(req);

memset(buf, 0, sizeof(buf));

iov = uv_buf_init(buf, sizeof(buf));

r = uv_fs_read(loop, &read_req, open_req1.result, &iov, 1, -1,

read_cb);

ASSERT(r == 0);

}

static void open_cb_simple(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_OPEN);

if (req->result < 0) {

fprintf(stderr, "async open error: %d\n", (int) req->result);

ASSERT(0);

}

open_cb_count++;

ASSERT(req->path);

uv_fs_req_cleanup(req);

}

static void fsync_cb(uv_fs_t* req) {

int r;

ASSERT(req == &fsync_req);

ASSERT(req->fs_type == UV_FS_FSYNC);

ASSERT(req->result == 0);

fsync_cb_count++;

uv_fs_req_cleanup(req);

r = uv_fs_close(loop, &close_req, open_req1.result, close_cb);

ASSERT(r == 0);

}

static void fdatasync_cb(uv_fs_t* req) {

int r;

ASSERT(req == &fdatasync_req);

ASSERT(req->fs_type == UV_FS_FDATASYNC);

ASSERT(req->result == 0);

fdatasync_cb_count++;

uv_fs_req_cleanup(req);

r = uv_fs_fsync(loop, &fsync_req, open_req1.result, fsync_cb);

ASSERT(r == 0);

}

static void write_cb(uv_fs_t* req) {

int r;

ASSERT(req == &write_req);

ASSERT(req->fs_type == UV_FS_WRITE);

ASSERT(req->result >= 0); /* FIXME(bnoordhuis) Check if requested size? */

write_cb_count++;

uv_fs_req_cleanup(req);

r = uv_fs_fdatasync(loop, &fdatasync_req, open_req1.result, fdatasync_cb);

ASSERT(r == 0);

}

static void create_cb(uv_fs_t* req) {

int r;

ASSERT(req == &open_req1);

ASSERT(req->fs_type == UV_FS_OPEN);

ASSERT(req->result >= 0);

create_cb_count++;

uv_fs_req_cleanup(req);

iov = uv_buf_init(test_buf, sizeof(test_buf));

r = uv_fs_write(loop, &write_req, req->result, &iov, 1, -1, write_cb);

ASSERT(r == 0);

}

static void rename_cb(uv_fs_t* req) {

ASSERT(req == &rename_req);

ASSERT(req->fs_type == UV_FS_RENAME);

ASSERT(req->result == 0);

rename_cb_count++;

uv_fs_req_cleanup(req);

}

static void mkdir_cb(uv_fs_t* req) {

ASSERT(req == &mkdir_req);

ASSERT(req->fs_type == UV_FS_MKDIR);

ASSERT(req->result == 0);

mkdir_cb_count++;

ASSERT(req->path);

ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);

uv_fs_req_cleanup(req);

}

static void check_mkdtemp_result(uv_fs_t* req) {

int r;

ASSERT(req->fs_type == UV_FS_MKDTEMP);

ASSERT(req->result == 0);

ASSERT(req->path);

ASSERT(strlen(req->path) == 15);

ASSERT(memcmp(req->path, "test_dir_", 9) == 0);

ASSERT(memcmp(req->path + 9, "XXXXXX", 6) != 0);

check_permission(req->path, 0700);

/* Check if req->path is actually a directory */

r = uv_fs_stat(NULL, &stat_req, req->path, NULL);

ASSERT(r == 0);

ASSERT(((uv_stat_t*)stat_req.ptr)->st_mode & S_IFDIR);

uv_fs_req_cleanup(&stat_req);

}

static void mkdtemp_cb(uv_fs_t* req) {

ASSERT(req == &mkdtemp_req1);

check_mkdtemp_result(req);

mkdtemp_cb_count++;

}

static void check_mkstemp_result(uv_fs_t* req) {

int r;

ASSERT(req->fs_type == UV_FS_MKSTEMP);

ASSERT(req->result >= 0);

ASSERT(req->path);

ASSERT(strlen(req->path) == 16);

ASSERT(memcmp(req->path, "test_file_", 10) == 0);

ASSERT(memcmp(req->path + 10, "XXXXXX", 6) != 0);

check_permission(req->path, 0600);

/* Check if req->path is actually a file */

r = uv_fs_stat(NULL, &stat_req, req->path, NULL);

ASSERT(r == 0);

ASSERT(stat_req.statbuf.st_mode & S_IFREG);

uv_fs_req_cleanup(&stat_req);

}

static void mkstemp_cb(uv_fs_t* req) {

ASSERT(req == &mkstemp_req1);

check_mkstemp_result(req);

mkstemp_cb_count++;

}

static void rmdir_cb(uv_fs_t* req) {

ASSERT(req == &rmdir_req);

ASSERT(req->fs_type == UV_FS_RMDIR);

ASSERT(req->result == 0);

rmdir_cb_count++;

ASSERT(req->path);

ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);

uv_fs_req_cleanup(req);

}

static void assert_is_file_type(uv_dirent_t dent) {

#ifdef HAVE_DIRENT_TYPES

/*

* For Apple and Windows, we know getdents is expected to work but for other

* environments, the filesystem dictates whether or not getdents supports

* returning the file type.

*

* See:

* http://man7.org/linux/man-pages/man2/getdents.2.html

* https://github.com/libuv/libuv/issues/501

*/

#if defined(__APPLE__) || defined(_WIN32)

ASSERT(dent.type == UV_DIRENT_FILE);

#else

ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN);

#endif

#else

ASSERT(dent.type == UV_DIRENT_UNKNOWN);

#endif

}

static void scandir_cb(uv_fs_t* req) {

uv_dirent_t dent;

ASSERT(req == &scandir_req);

ASSERT(req->fs_type == UV_FS_SCANDIR);

ASSERT(req->result == 2);

ASSERT(req->ptr);

while (UV_EOF != uv_fs_scandir_next(req, &dent)) {

ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);

assert_is_file_type(dent);

}

scandir_cb_count++;

ASSERT(req->path);

ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);

uv_fs_req_cleanup(req);

ASSERT(!req->ptr);

}

static void empty_scandir_cb(uv_fs_t* req) {

uv_dirent_t dent;

ASSERT(req == &scandir_req);

ASSERT(req->fs_type == UV_FS_SCANDIR);

ASSERT(req->result == 0);

ASSERT_NULL(req->ptr);

ASSERT(UV_EOF == uv_fs_scandir_next(req, &dent));

uv_fs_req_cleanup(req);

scandir_cb_count++;

}

static void non_existent_scandir_cb(uv_fs_t* req) {

uv_dirent_t dent;

ASSERT(req == &scandir_req);

ASSERT(req->fs_type == UV_FS_SCANDIR);

ASSERT(req->result == UV_ENOENT);

ASSERT_NULL(req->ptr);

ASSERT(UV_ENOENT == uv_fs_scandir_next(req, &dent));

uv_fs_req_cleanup(req);

scandir_cb_count++;

}

static void file_scandir_cb(uv_fs_t* req) {

ASSERT(req == &scandir_req);

ASSERT(req->fs_type == UV_FS_SCANDIR);

ASSERT(req->result == UV_ENOTDIR);

ASSERT_NULL(req->ptr);

uv_fs_req_cleanup(req);

scandir_cb_count++;

}

static void stat_cb(uv_fs_t* req) {

ASSERT(req == &stat_req);

ASSERT(req->fs_type == UV_FS_STAT || req->fs_type == UV_FS_LSTAT);

ASSERT(req->result == 0);

ASSERT(req->ptr);

stat_cb_count++;

uv_fs_req_cleanup(req);

ASSERT(!req->ptr);

}

static void sendfile_cb(uv_fs_t* req) {

ASSERT(req == &sendfile_req);

ASSERT(req->fs_type == UV_FS_SENDFILE);

ASSERT(req->result == 65545);

sendfile_cb_count++;

uv_fs_req_cleanup(req);

}

static void sendfile_nodata_cb(uv_fs_t* req) {

ASSERT(req == &sendfile_req);

ASSERT(req->fs_type == UV_FS_SENDFILE);

ASSERT(req->result == 0);

sendfile_cb_count++;

uv_fs_req_cleanup(req);

}

static void open_noent_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_OPEN);

ASSERT(req->result == UV_ENOENT);

open_cb_count++;

uv_fs_req_cleanup(req);

}

static void open_nametoolong_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_OPEN);

ASSERT(req->result == UV_ENAMETOOLONG);

open_cb_count++;

uv_fs_req_cleanup(req);

}

static void open_loop_cb(uv_fs_t* req) {

ASSERT(req->fs_type == UV_FS_OPEN);

ASSERT(req->result == UV_ELOOP);

open_cb_count++;

uv_fs_req_cleanup(req);

}

TEST_IMPL(fs_file_noent) {

uv_fs_t req;

int r;

loop = uv_default_loop();

r = uv_fs_open(NULL, &req, "does_not_exist", O_RDONLY, 0, NULL);

ASSERT(r == UV_ENOENT);

ASSERT(req.result == UV_ENOENT);

uv_fs_req_cleanup(&req);

r = uv_fs_open(loop, &req, "does_not_exist", O_RDONLY, 0, open_noent_cb);

ASSERT(r == 0);

ASSERT(open_cb_count == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(open_cb_count == 1);

/* TODO add EACCES test */

MAKE_VALGRIND_HAPPY();

return 0;

}

TEST_IMPL(fs_file_nametoolong) {

uv_fs_t req;

int r;

char name[TOO_LONG_NAME_LENGTH + 1];

loop = uv_default_loop();

memset(name, 'a', TOO_LONG_NAME_LENGTH);

name[TOO_LONG_NAME_LENGTH] = 0;

r = uv_fs_open(NULL, &req, name, O_RDONLY, 0, NULL);

ASSERT(r == UV_ENAMETOOLONG);

ASSERT(req.result == UV_ENAMETOOLONG);

uv_fs_req_cleanup(&req);

r = uv_fs_open(loop, &req, name, O_RDONLY, 0, open_nametoolong_cb);

ASSERT(r == 0);

ASSERT(open_cb_count == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(open_cb_count == 1);

MAKE_VALGRIND_HAPPY();

return 0;

}

TEST_IMPL(fs_file_loop) {

uv_fs_t req;

int r;

loop = uv_default_loop();

unlink("test_symlink");

r = uv_fs_symlink(NULL, &req, "test_symlink", "test_symlink", 0, NULL);

#ifdef _WIN32

/*

* Windows XP and Server 2003 don't support symlinks; we'll get UV_ENOTSUP.

* Starting with vista they are supported, but only when elevated, otherwise

* we'll see UV_EPERM.

*/

if (r == UV_ENOTSUP || r == UV_EPERM)

return 0;

#elif defined(__MSYS__)

/* MSYS2's approximation of symlinks with copies does not work for broken

links. */

if (r == UV_ENOENT)

return 0;

#endif

ASSERT(r == 0);

uv_fs_req_cleanup(&req);

r = uv_fs_open(NULL, &req, "test_symlink", O_RDONLY, 0, NULL);

ASSERT(r == UV_ELOOP);

ASSERT(req.result == UV_ELOOP);

uv_fs_req_cleanup(&req);

r = uv_fs_open(loop, &req, "test_symlink", O_RDONLY, 0, open_loop_cb);

ASSERT(r == 0);

ASSERT(open_cb_count == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(open_cb_count == 1);

unlink("test_symlink");

MAKE_VALGRIND_HAPPY();

return 0;

}

static void check_utime(const char* path,

double atime,

double mtime,

int test_lutime) {

uv_stat_t* s;

uv_fs_t req;

int r;

if (test_lutime)

r = uv_fs_lstat(loop, &req, path, NULL);

else

r = uv_fs_stat(loop, &req, path, NULL);

ASSERT_EQ(r, 0);

ASSERT_EQ(req.result, 0);

s = &req.statbuf;

if (s->st_atim.tv_nsec == 0 && s->st_mtim.tv_nsec == 0) {

/*

* Test sub-second timestamps only when supported (such as Windows with

* NTFS). Some other platforms support sub-second timestamps, but that

* support is filesystem-dependent. Notably OS X (HFS Plus) does NOT

* support sub-second timestamps. But kernels may round or truncate in

* either direction, so we may accept either possible answer.

*/

#ifdef _WIN32

ASSERT_DOUBLE_EQ(atime, (long) atime);

ASSERT_DOUBLE_EQ(mtime, (long) atime);

#endif

if (atime > 0 || (long) atime == atime)

ASSERT_EQ(s->st_atim.tv_sec, (long) atime);

if (mtime > 0 || (long) mtime == mtime)

ASSERT_EQ(s->st_mtim.tv_sec, (long) mtime);

ASSERT_GE(s->st_atim.tv_sec, (long) atime - 1);

ASSERT_GE(s->st_mtim.tv_sec, (long) mtime - 1);

ASSERT_LE(s->st_atim.tv_sec, (long) atime);

ASSERT_LE(s->st_mtim.tv_sec, (long) mtime);

} else {

double st_atim;

double st_mtim;

#if !defined(__APPLE__) && !defined(__SUNPRO_C)

/* TODO(vtjnash): would it be better to normalize this? */

ASSERT_DOUBLE_GE(s->st_atim.tv_nsec, 0);

ASSERT_DOUBLE_GE(s->st_mtim.tv_nsec, 0);

#endif

st_atim = s->st_atim.tv_sec + s->st_atim.tv_nsec / 1e9;

st_mtim = s->st_mtim.tv_sec + s->st_mtim.tv_nsec / 1e9;

ASSERT_DOUBLE_EQ(st_atim, atime);

ASSERT_DOUBLE_EQ(st_mtim, mtime);

}

uv_fs_req_cleanup(&req);

}

static void utime_cb(uv_fs_t* req) {

utime_check_t* c;

ASSERT(req == &utime_req);

ASSERT(req->result == 0);

ASSERT(req->fs_type == UV_FS_UTIME);

c = req->data;

check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 0);

uv_fs_req_cleanup(req);

utime_cb_count++;

}

static void futime_cb(uv_fs_t* req) {

utime_check_t* c;

ASSERT(req == &futime_req);

ASSERT(req->result == 0);

ASSERT(req->fs_type == UV_FS_FUTIME);

c = req->data;

check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 0);

uv_fs_req_cleanup(req);

futime_cb_count++;

}

static void lutime_cb(uv_fs_t* req) {

utime_check_t* c;

ASSERT(req->result == 0);

ASSERT(req->fs_type == UV_FS_LUTIME);

c = req->data;

check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 1);

uv_fs_req_cleanup(req);

lutime_cb_count++;

}

TEST_IMPL(fs_file_async) {

int r;

/* Setup. */

unlink("test_file");

unlink("test_file2");

loop = uv_default_loop();

r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,

S_IRUSR | S_IWUSR, create_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(create_cb_count == 1);

ASSERT(write_cb_count == 1);

ASSERT(fsync_cb_count == 1);

ASSERT(fdatasync_cb_count == 1);

ASSERT(close_cb_count == 1);

r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", rename_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(create_cb_count == 1);

ASSERT(write_cb_count == 1);

ASSERT(close_cb_count == 1);

ASSERT(rename_cb_count == 1);

r = uv_fs_open(loop, &open_req1, "test_file2", O_RDWR, 0, open_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(open_cb_count == 1);

ASSERT(read_cb_count == 1);

ASSERT(close_cb_count == 2);

ASSERT(rename_cb_count == 1);

ASSERT(create_cb_count == 1);

ASSERT(write_cb_count == 1);

ASSERT(ftruncate_cb_count == 1);

r = uv_fs_open(loop, &open_req1, "test_file2", O_RDONLY, 0, open_cb);

ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);

ASSERT(open_cb_count == 2);

ASSERT(read_cb_count == 2);

ASSERT(close_cb_count == 3);

ASSERT(rename_cb_count == 1);

ASSERT(unlink_cb_count == 1);

ASSERT(create_cb_count == 1);

ASSERT(write_cb_count == 1);

ASSERT(ftruncate_cb_count == 1);

/* Cleanup. */

unlink("test_file");

unlink("test_file2");

MAKE_VALGRIND_HAPPY();

return 0;

}

static void fs_file_sync(int add_flags) {

int r;

/* Setup. */

unlink("test_file");

unlink("test_file2");

loop = uv_default_loop();

r = uv_fs_open(loop, &open_req1, "test_file",

O_WRONLY | O_CREAT | add_flags, S_IWUSR | S_IRUSR, NULL);

ASSERT(r >= 0);

ASSERT(open_req1.result >= 0);

uv_fs_req_cleanup(&open_req1);

iov = uv_buf_init(test_buf, sizeof(test_buf));

r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL);

ASSERT(r >= 0);

ASSERT(write_req.result >= 0);

uv_fs_req_cleanup(&write_req);

r = uv_fs_close(NULL, &close_req, open_req1.result, NULL);

ASSERT(r == 0);

ASSERT(close_req.result == 0);

uv_fs_req_cleanup(&close_req);

r = uv_fs_open(NULL, &open_req1, "test_file", O_RDWR | add_flags, 0, NULL);

ASSERT(r >= 0);

ASSERT(open_req1.result >= 0);

uv_fs_req_cleanup(&open_req1);

iov = uv_buf_init(buf, sizeof(buf));