luo980/libuv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fs: rename uv_fs_readdir to uv_fs_scandir

Browse Source 
Closes #1431
This commit is contained in:
Saúl Ibarra Corretgé 2014-09-25 10:09:58 +02:00
parent 2f54947b72
commit 03e53f1cf7
9 changed files with 82 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
docs/src/fs.rst
View File

@ -74,7 +74,7 @@ Data types
UV_FS_MKDIR,
UV_FS_MKDTEMP,
UV_FS_RENAME,
UV_FS_READDIR,
UV_FS_SCANDIR,
UV_FS_LINK,
UV_FS_SYMLINK,
UV_FS_READLINK,
@ -85,7 +85,7 @@ Data types
.. c:type:: uv_dirent_t
Cross platform (reduced) equivalent of ``struct dirent``.
Used in :c:func:`uv_fs_readdir_next`.
Used in :c:func:`uv_fs_scandir_next`.
::
@ -183,11 +183,11 @@ API
Equivalent to ``rmdir(2)``.
.. c:function:: int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, uv_fs_cb cb)
.. c:function:: int uv_fs_readdir_next(uv_fs_t* req, uv_dirent_t* ent)
.. c:function:: int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, uv_fs_cb cb)
.. c:function:: int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent)
Equivalent to ``readdir(2)``, with a slightly different API. Once the callback
for the request is called, the user can use :c:func:`uv_fs_readdir_next` to
Equivalent to ``scandir(3)``, with a slightly different API. Once the callback
for the request is called, the user can use :c:func:`uv_fs_scandir_next` to
get `ent` populated with the next directory entry data. When there are no
more entries ``UV_EOF`` will be returned.

6
include/uv.h
View File

@ -1031,7 +1031,7 @@ typedef enum {
UV_FS_MKDIR,
UV_FS_MKDTEMP,
UV_FS_RENAME,
UV_FS_READDIR,
UV_FS_SCANDIR,
UV_FS_LINK,
UV_FS_SYMLINK,
UV_FS_READLINK,
@ -1094,12 +1094,12 @@ UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
uv_fs_cb cb);
UV_EXTERN int uv_fs_readdir(uv_loop_t* loop,
UV_EXTERN int uv_fs_scandir(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
int flags,
uv_fs_cb cb);
UV_EXTERN int uv_fs_readdir_next(uv_fs_t* req,
UV_EXTERN int uv_fs_scandir_next(uv_fs_t* req,
uv_dirent_t* ent);
UV_EXTERN int uv_fs_stat(uv_loop_t* loop,
uv_fs_t* req,

19
src/unix/fs.c
View File

@ -295,22 +295,21 @@ done:
#if defined(__OpenBSD__) || (defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_8))
static int uv__fs_readdir_filter(uv__dirent_t* dent) {
static int uv__fs_scandir_filter(uv__dirent_t* dent) {
#else
static int uv__fs_readdir_filter(const uv__dirent_t* dent) {
static int uv__fs_scandir_filter(const uv__dirent_t* dent) {
#endif
return strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0;
}
/* This should have been called uv__fs_scandir(). */
static ssize_t uv__fs_readdir(uv_fs_t* req) {
static ssize_t uv__fs_scandir(uv_fs_t* req) {
uv__dirent_t **dents;
int saved_errno;
int n;
dents = NULL;
n = scandir(req->path, &dents, uv__fs_readdir_filter, alphasort);
n = scandir(req->path, &dents, uv__fs_scandir_filter, alphasort);
/* NOTE: We will use nbufs as an index field */
req->nbufs = 0;
@ -779,7 +778,7 @@ static void uv__fs_work(struct uv__work* w) {
X(MKDIR, mkdir(req->path, req->mode));
X(MKDTEMP, uv__fs_mkdtemp(req));
X(READ, uv__fs_read(req));
X(READDIR, uv__fs_readdir(req));
X(SCANDIR, uv__fs_scandir(req));
X(READLINK, uv__fs_readlink(req));
X(RENAME, rename(req->path, req->new_path));
X(RMDIR, rmdir(req->path));
@ -1040,12 +1039,12 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,
}
int uv_fs_readdir(uv_loop_t* loop,
int uv_fs_scandir(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
int flags,
uv_fs_cb cb) {
INIT(READDIR);
INIT(SCANDIR);
PATH;
req->flags = flags;
POST;
@ -1167,8 +1166,8 @@ void uv_fs_req_cleanup(uv_fs_t* req) {
req->path = NULL;
req->new_path = NULL;
if (req->fs_type == UV_FS_READDIR && req->ptr != NULL)
uv__fs_readdir_cleanup(req);
if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
uv__fs_scandir_cleanup(req);
if (req->ptr != &req->statbuf)
free(req->ptr);

4
src/uv-common.c
View File

@ -437,7 +437,7 @@ int uv_fs_event_getpath(uv_fs_event_t* handle, char* buf, size_t* len) {
}
void uv__fs_readdir_cleanup(uv_fs_t* req) {
void uv__fs_scandir_cleanup(uv_fs_t* req) {
uv__dirent_t** dents;
dents = req->ptr;
@ -448,7 +448,7 @@ void uv__fs_readdir_cleanup(uv_fs_t* req) {
}
int uv_fs_readdir_next(uv_fs_t* req, uv_dirent_t* ent) {
int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent) {
uv__dirent_t** dents;
uv__dirent_t* dent;

2
src/uv-common.h
View File

@ -109,7 +109,7 @@ size_t uv__count_bufs(const uv_buf_t bufs[], unsigned int nbufs);
int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value);
void uv__fs_readdir_cleanup(uv_fs_t* req);
void uv__fs_scandir_cleanup(uv_fs_t* req);
#define uv__has_active_reqs(loop) \
(QUEUE_EMPTY(&(loop)->active_reqs) == 0)

10
src/win/fs.c
View File

@ -783,7 +783,7 @@ void fs__mkdtemp(uv_fs_t* req) {
}
void fs__readdir(uv_fs_t* req) {
void fs__scandir(uv_fs_t* req) {
WCHAR* pathw = req->pathw;
size_t len = wcslen(pathw);
int result;
@ -1604,7 +1604,7 @@ static void uv__fs_work(struct uv__work* w) {
XX(MKDIR, mkdir)
XX(MKDTEMP, mkdtemp)
XX(RENAME, rename)
XX(READDIR, readdir)
XX(SCANDIR, scandir)
XX(LINK, link)
XX(SYMLINK, symlink)
XX(READLINK, readlink)
@ -1839,11 +1839,11 @@ int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
}
int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
uv_fs_cb cb) {
int err;
uv_fs_req_init(loop, req, UV_FS_READDIR, cb);
uv_fs_req_init(loop, req, UV_FS_SCANDIR, cb);
err = fs__capture_path(loop, req, path, NULL, cb != NULL);
if (err) {
@ -1856,7 +1856,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
QUEUE_FS_TP_JOB(loop, req);
return 0;
} else {
fs__readdir(req);
fs__scandir(req);
return req->result;
}
}

102
test/test-fs.c
View File

@ -67,7 +67,7 @@ static int unlink_cb_count;
static int mkdir_cb_count;
static int mkdtemp_cb_count;
static int rmdir_cb_count;
static int readdir_cb_count;
static int scandir_cb_count;
static int stat_cb_count;
static int rename_cb_count;
static int fsync_cb_count;
@ -97,7 +97,7 @@ static uv_fs_t mkdir_req;
static uv_fs_t mkdtemp_req1;
static uv_fs_t mkdtemp_req2;
static uv_fs_t rmdir_req;
static uv_fs_t readdir_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;
@ -416,18 +416,18 @@ static void rmdir_cb(uv_fs_t* req) {
}
static void readdir_cb(uv_fs_t* req) {
static void scandir_cb(uv_fs_t* req) {
uv_dirent_t dent;
ASSERT(req == &readdir_req);
ASSERT(req->fs_type == UV_FS_READDIR);
ASSERT(req == &scandir_req);
ASSERT(req->fs_type == UV_FS_SCANDIR);
ASSERT(req->result == 2);
ASSERT(req->ptr);
while (UV_EOF != uv_fs_readdir_next(req, &dent)) {
while (UV_EOF != uv_fs_scandir_next(req, &dent)) {
ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN);
}
readdir_cb_count++;
scandir_cb_count++;
ASSERT(req->path);
ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);
uv_fs_req_cleanup(req);
@ -435,26 +435,26 @@ static void readdir_cb(uv_fs_t* req) {
}
static void empty_readdir_cb(uv_fs_t* req) {
static void empty_scandir_cb(uv_fs_t* req) {
uv_dirent_t dent;
ASSERT(req == &readdir_req);
ASSERT(req->fs_type == UV_FS_READDIR);
ASSERT(req == &scandir_req);
ASSERT(req->fs_type == UV_FS_SCANDIR);
ASSERT(req->result == 0);
ASSERT(req->ptr == NULL);
ASSERT(UV_EOF == uv_fs_readdir_next(req, &dent));
ASSERT(UV_EOF == uv_fs_scandir_next(req, &dent));
uv_fs_req_cleanup(req);
readdir_cb_count++;
scandir_cb_count++;
}
static void file_readdir_cb(uv_fs_t* req) {
ASSERT(req == &readdir_req);
ASSERT(req->fs_type == UV_FS_READDIR);
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(req->ptr == NULL);
uv_fs_req_cleanup(req);
readdir_cb_count++;
scandir_cb_count++;
}
@ -841,23 +841,23 @@ TEST_IMPL(fs_async_dir) {
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);
r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, readdir_cb);
r = uv_fs_scandir(loop, &scandir_req, "test_dir", 0, scandir_cb);
ASSERT(r == 0);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(readdir_cb_count == 1);
ASSERT(scandir_cb_count == 1);
/* sync uv_fs_readdir */
r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, NULL);
/* sync uv_fs_scandir */
r = uv_fs_scandir(loop, &scandir_req, "test_dir", 0, NULL);
ASSERT(r == 2);
ASSERT(readdir_req.result == 2);
ASSERT(readdir_req.ptr);
while (UV_EOF != uv_fs_readdir_next(&readdir_req, &dent)) {
ASSERT(scandir_req.result == 2);
ASSERT(scandir_req.ptr);
while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN);
}
uv_fs_req_cleanup(&readdir_req);
ASSERT(!readdir_req.ptr);
uv_fs_req_cleanup(&scandir_req);
ASSERT(!scandir_req.ptr);
r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb);
ASSERT(r == 0);
@ -1604,36 +1604,36 @@ TEST_IMPL(fs_symlink_dir) {
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);
r = uv_fs_readdir(loop, &readdir_req, "test_dir_symlink", 0, NULL);
r = uv_fs_scandir(loop, &scandir_req, "test_dir_symlink", 0, NULL);
ASSERT(r == 2);
ASSERT(readdir_req.result == 2);
ASSERT(readdir_req.ptr);
while (UV_EOF != uv_fs_readdir_next(&readdir_req, &dent)) {
ASSERT(scandir_req.result == 2);
ASSERT(scandir_req.ptr);
while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN);
}
uv_fs_req_cleanup(&readdir_req);
ASSERT(!readdir_req.ptr);
uv_fs_req_cleanup(&scandir_req);
ASSERT(!scandir_req.ptr);
/* unlink will remove the directory symlink */
r = uv_fs_unlink(loop, &req, "test_dir_symlink", NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&req);
r = uv_fs_readdir(loop, &readdir_req, "test_dir_symlink", 0, NULL);
r = uv_fs_scandir(loop, &scandir_req, "test_dir_symlink", 0, NULL);
ASSERT(r == UV_ENOENT);
uv_fs_req_cleanup(&readdir_req);
uv_fs_req_cleanup(&scandir_req);
r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, NULL);
r = uv_fs_scandir(loop, &scandir_req, "test_dir", 0, NULL);
ASSERT(r == 2);
ASSERT(readdir_req.result == 2);
ASSERT(readdir_req.ptr);
while (UV_EOF != uv_fs_readdir_next(&readdir_req, &dent)) {
ASSERT(scandir_req.result == 2);
ASSERT(scandir_req.ptr);
while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) {
ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0);
ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN);
}
uv_fs_req_cleanup(&readdir_req);
ASSERT(!readdir_req.ptr);
uv_fs_req_cleanup(&scandir_req);
ASSERT(!scandir_req.ptr);
/* clean-up */
unlink("test_dir/file1");
@ -1805,7 +1805,7 @@ TEST_IMPL(fs_stat_missing_path) {
}
TEST_IMPL(fs_readdir_empty_dir) {
TEST_IMPL(fs_scandir_empty_dir) {
const char* path;
uv_fs_t req;
uv_dirent_t dent;
@ -1820,19 +1820,19 @@ TEST_IMPL(fs_readdir_empty_dir) {
/* Fill the req to ensure that required fields are cleaned up */
memset(&req, 0xdb, sizeof(req));
r = uv_fs_readdir(loop, &req, path, 0, NULL);
r = uv_fs_scandir(loop, &req, path, 0, NULL);
ASSERT(r == 0);
ASSERT(req.result == 0);
ASSERT(req.ptr == NULL);
ASSERT(UV_EOF == uv_fs_readdir_next(&req, &dent));
ASSERT(UV_EOF == uv_fs_scandir_next(&req, &dent));
uv_fs_req_cleanup(&req);
r = uv_fs_readdir(loop, &readdir_req, path, 0, empty_readdir_cb);
r = uv_fs_scandir(loop, &scandir_req, path, 0, empty_scandir_cb);
ASSERT(r == 0);
ASSERT(readdir_cb_count == 0);
ASSERT(scandir_cb_count == 0);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(readdir_cb_count == 1);
ASSERT(scandir_cb_count == 1);
uv_fs_rmdir(loop, &req, path, NULL);
uv_fs_req_cleanup(&req);
@ -1842,23 +1842,23 @@ TEST_IMPL(fs_readdir_empty_dir) {
}
TEST_IMPL(fs_readdir_file) {
TEST_IMPL(fs_scandir_file) {
const char* path;
int r;
path = "test/fixtures/empty_file";
loop = uv_default_loop();
r = uv_fs_readdir(loop, &readdir_req, path, 0, NULL);
r = uv_fs_scandir(loop, &scandir_req, path, 0, NULL);
ASSERT(r == UV_ENOTDIR);
uv_fs_req_cleanup(&readdir_req);
uv_fs_req_cleanup(&scandir_req);
r = uv_fs_readdir(loop, &readdir_req, path, 0, file_readdir_cb);
r = uv_fs_scandir(loop, &scandir_req, path, 0, file_scandir_cb);
ASSERT(r == 0);
ASSERT(readdir_cb_count == 0);
ASSERT(scandir_cb_count == 0);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT(readdir_cb_count == 1);
ASSERT(scandir_cb_count == 1);
MAKE_VALGRIND_HAPPY();
return 0;

8
test/test-list.h
View File

@ -241,8 +241,8 @@ TEST_DECLARE (fs_event_close_in_callback)
TEST_DECLARE (fs_event_start_and_close)
TEST_DECLARE (fs_event_error_reporting)
TEST_DECLARE (fs_event_getpath)
TEST_DECLARE (fs_readdir_empty_dir)
TEST_DECLARE (fs_readdir_file)
TEST_DECLARE (fs_scandir_empty_dir)
TEST_DECLARE (fs_scandir_file)
TEST_DECLARE (fs_open_dir)
TEST_DECLARE (fs_rename_to_existing_file)
TEST_DECLARE (threadpool_queue_work_simple)
@ -612,8 +612,8 @@ TASK_LIST_START
TEST_ENTRY (fs_event_start_and_close)
TEST_ENTRY (fs_event_error_reporting)
TEST_ENTRY (fs_event_getpath)
TEST_ENTRY (fs_readdir_empty_dir)
TEST_ENTRY (fs_readdir_file)
TEST_ENTRY (fs_scandir_empty_dir)
TEST_ENTRY (fs_scandir_file)
TEST_ENTRY (fs_open_dir)
TEST_ENTRY (fs_rename_to_existing_file)
TEST_ENTRY (threadpool_queue_work_simple)

2
test/test-threadpool-cancel.c
View File

@ -301,7 +301,7 @@ TEST_IMPL(threadpool_cancel_fs) {
ASSERT(0 == uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb));
ASSERT(0 == uv_fs_open(loop, reqs + n++, "/", 0, 0, fs_cb));
ASSERT(0 == uv_fs_read(loop, reqs + n++, 0, NULL, 0, 0, fs_cb));
ASSERT(0 == uv_fs_readdir(loop, reqs + n++, "/", 0, fs_cb));
ASSERT(0 == uv_fs_scandir(loop, reqs + n++, "/", 0, fs_cb));
ASSERT(0 == uv_fs_readlink(loop, reqs + n++, "/", fs_cb));
ASSERT(0 == uv_fs_rename(loop, reqs + n++, "/", "/", fs_cb));
ASSERT(0 == uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb));