diff --git a/components/fatfs/src/vfs_fat.c b/components/fatfs/src/vfs_fat.c index 1e059e134..70b780d52 100644 --- a/components/fatfs/src/vfs_fat.c +++ b/components/fatfs/src/vfs_fat.c @@ -84,6 +84,7 @@ static void vfs_fat_seekdir(void* ctx, DIR* pdir, long offset); static int vfs_fat_closedir(void* ctx, DIR* pdir); static int vfs_fat_mkdir(void* ctx, const char* name, mode_t mode); static int vfs_fat_rmdir(void* ctx, const char* name); +static int vfs_fat_access(void* ctx, const char *path, int amode); static vfs_fat_ctx_t* s_fat_ctxs[FF_VOLUMES] = { NULL, NULL }; //backwards-compatibility with esp_vfs_fat_unregister() @@ -141,7 +142,8 @@ esp_err_t esp_vfs_fat_register(const char* base_path, const char* fat_drive, siz .seekdir_p = &vfs_fat_seekdir, .telldir_p = &vfs_fat_telldir, .mkdir_p = &vfs_fat_mkdir, - .rmdir_p = &vfs_fat_rmdir + .rmdir_p = &vfs_fat_rmdir, + .access_p = &vfs_fat_access, }; size_t ctx_size = sizeof(vfs_fat_ctx_t) + max_files * sizeof(FIL); vfs_fat_ctx_t* fat_ctx = (vfs_fat_ctx_t*) calloc(1, ctx_size); @@ -720,3 +722,31 @@ static int vfs_fat_rmdir(void* ctx, const char* name) } return 0; } + +static int vfs_fat_access(void* ctx, const char *path, int amode) +{ + FILINFO info; + int ret = 0; + FRESULT res; + + vfs_fat_ctx_t* fat_ctx = (vfs_fat_ctx_t*) ctx; + + _lock_acquire(&fat_ctx->lock); + prepend_drive_to_path(fat_ctx, &path, NULL); + res = f_stat(path, &info); + _lock_release(&fat_ctx->lock); + + if (res == FR_OK) { + if (((amode & W_OK) == W_OK) && ((info.fattrib & AM_RDO) == AM_RDO)) { + ret = -1; + errno = EACCES; + } + // There is no flag to test readable or executable: we assume that if + // it exists then it is readable and executable + } else { + ret = -1; + errno = ENOENT; + } + + return ret; +} diff --git a/components/vfs/include/esp_vfs.h b/components/vfs/include/esp_vfs.h index 54aaaba26..202be2485 100644 --- a/components/vfs/include/esp_vfs.h +++ b/components/vfs/include/esp_vfs.h @@ -18,6 +18,9 @@ #include #include #include +#include +#include "freertos/FreeRTOS.h" +#include "freertos/semphr.h" #include "esp_err.h" #include #include @@ -160,6 +163,10 @@ typedef struct int (*fsync_p)(void* ctx, int fd); int (*fsync)(int fd); }; + union { + int (*access_p)(void* ctx, const char *path, int amode); + int (*access)(const char *path, int amode); + }; } esp_vfs_t; diff --git a/components/vfs/test/test_vfs_access.c b/components/vfs/test/test_vfs_access.c new file mode 100644 index 000000000..02e7d56f8 --- /dev/null +++ b/components/vfs/test/test_vfs_access.c @@ -0,0 +1,127 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include +#include +#include "unity.h" +#include "driver/uart.h" +#include "esp_vfs.h" +#include "esp_vfs_dev.h" +#include "esp_vfs_fat.h" +#include "wear_levelling.h" + +static wl_handle_t test_wl_handle; + +TEST_CASE("Can use access() for UART", "[vfs]") +{ + const char *uarts[] = {"/dev/uart/0", "/dev/uart/1", "/dev/uart/2"}; + + uart_driver_install(UART_NUM_0, 256, 0, 0, NULL, 0); + uart_driver_install(UART_NUM_1, 256, 0, 0, NULL, 0); + uart_driver_install(UART_NUM_2, 256, 0, 0, NULL, 0); + + for (int i = 0; i < sizeof(uarts)/sizeof(uarts[0]); ++i) { + TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], F_OK), 0, uarts[i]); + + TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], R_OK), 0, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], W_OK), 0, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], X_OK), -1, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(errno, EACCES, uarts[i]); + + TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], R_OK | W_OK), 0, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], R_OK | X_OK), -1, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(errno, EACCES, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], W_OK | X_OK), -1, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(errno, EACCES, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(access(uarts[i], R_OK | W_OK | X_OK), -1, uarts[i]); + TEST_ASSERT_EQUAL_MESSAGE(errno, EACCES, uarts[i]); + } + + TEST_ASSERT_EQUAL(access("/dev/uart/3", F_OK), -1); + TEST_ASSERT_EQUAL(errno, ENOENT); + + uart_driver_delete(UART_NUM_0); + uart_driver_delete(UART_NUM_1); + uart_driver_delete(UART_NUM_2); +} + +static inline void test_spi_flash_setup() +{ + esp_vfs_fat_sdmmc_mount_config_t mount_config = { + .format_if_mount_failed = true, + .max_files = 5 + }; + + TEST_ESP_OK(esp_vfs_fat_spiflash_mount("/spiflash", NULL, &mount_config, &test_wl_handle)); +} + +static inline void test_spi_flash_teardown() +{ + TEST_ESP_OK(esp_vfs_fat_spiflash_unmount("/spiflash", test_wl_handle)); +} + +static inline void test_fatfs_create_file(const char *name) +{ + int fd = open(name, O_WRONLY | O_CREAT | O_TRUNC); + TEST_ASSERT_NOT_EQUAL(fd, -1); + TEST_ASSERT_EQUAL(0, close(fd)); +} + +static inline void test_fatfs_delete_file(const char *name) +{ + int ret = unlink(name); + TEST_ASSERT_EQUAL(ret, 0); +} + +TEST_CASE("Can use access() for FATFS", "[vfs][fatfs][wear_levelling]") +{ + const char *path = "/spiflash/access.txt"; + + test_spi_flash_setup(); + + { + int ret = access(path, F_OK); + + if (ret != -1) { + // it wasn't deleted before so we delete it now to pass the test + // case the next time + test_fatfs_delete_file(path); + } + + TEST_ASSERT_EQUAL(ret, -1); + TEST_ASSERT_EQUAL(errno, ENOENT); + } + + test_fatfs_create_file(path); + TEST_ASSERT_EQUAL(access(path, F_OK), 0); + + TEST_ASSERT_EQUAL(access(path, R_OK), 0); + TEST_ASSERT_EQUAL(access(path, W_OK), 0); + TEST_ASSERT_EQUAL(access(path, X_OK), 0); + TEST_ASSERT_EQUAL(access(path, R_OK | W_OK), 0); + TEST_ASSERT_EQUAL(access(path, R_OK | X_OK), 0); + TEST_ASSERT_EQUAL(access(path, W_OK | X_OK), 0); + TEST_ASSERT_EQUAL(access(path, R_OK | W_OK | X_OK), 0); + + //TODO f_chmod the file and re-test the access rights (this requires + // f_chmod support to be implemented in VFS) + + test_fatfs_delete_file(path); + TEST_ASSERT_EQUAL(access(path, F_OK), -1); + TEST_ASSERT_EQUAL(errno, ENOENT); + + test_spi_flash_teardown(); +} diff --git a/components/vfs/vfs.c b/components/vfs/vfs.c index 2e84571b3..d7ca283ec 100644 --- a/components/vfs/vfs.c +++ b/components/vfs/vfs.c @@ -623,3 +623,17 @@ int fsync(int fd) CHECK_AND_CALL(ret, r, vfs, fsync, local_fd); return ret; } + +int access(const char *path, int amode) +{ + int ret; + const vfs_entry_t* vfs = get_vfs_for_path(path); + struct _reent* r = __getreent(); + if (vfs == NULL) { + __errno_r(r) = ENOENT; + return -1; + } + const char* path_within_vfs = translate_path(vfs, path); + CHECK_AND_CALL(ret, r, vfs, access, path_within_vfs, amode); + return ret; +} diff --git a/components/vfs/vfs_uart.c b/components/vfs/vfs_uart.c index 13b227aad..83e89acc3 100644 --- a/components/vfs/vfs_uart.c +++ b/components/vfs/vfs_uart.c @@ -267,6 +267,27 @@ static int uart_fcntl(int fd, int cmd, va_list args) return result; } +static int uart_access(const char *path, int amode) +{ + int ret = -1; + + if (strcmp(path, "/0") == 0 || strcmp(path, "/1") == 0 || strcmp(path, "/2") == 0) { + if (F_OK == amode) { + ret = 0; //path exists + } else { + if ((((amode & R_OK) == R_OK) || ((amode & W_OK) == W_OK)) && ((amode & X_OK) != X_OK)) { + ret = 0; //path is readable and/or writable but not executable + } else { + errno = EACCES; + } + } + } else { + errno = ENOENT; + } + + return ret; +} + void esp_vfs_dev_uart_register() { esp_vfs_t vfs = { @@ -276,7 +297,8 @@ void esp_vfs_dev_uart_register() .fstat = &uart_fstat, .close = &uart_close, .read = &uart_read, - .fcntl = &uart_fcntl + .fcntl = &uart_fcntl, + .access = &uart_access, }; ESP_ERROR_CHECK(esp_vfs_register("/dev/uart", &vfs, NULL)); }