Fix VFS path normalization and *at syscall path handling

Author: pradosh-arduino

source/includes/filesystems/vfs.h

@@ -11,6 +11,7 @@
 #ifndef VFS_H
 #define VFS_H
 
+#include <stddef.h>
 #include <filesystems/fat16.h>
 #include <filesystems/fat32.h>
 #include <filesystems/iso9660.h>
@@ -134,5 +135,6 @@ int vfs_unlink(const char* path);
 const char* vfs_getcwd();
 
 const char* vfs_basename(const char* path);
+int vfs_normalize_path(const char* in, char* out, size_t out_sz);
 
 #endif // VFS_H

source/includes/stream.h

@@ -52,6 +52,7 @@ int fd_close(int fd);
 int fd_dup(int oldfd);
 int fd_dup2(int oldfd, int newfd);
 int fd_flags(int fd);
+const char* fd_get_path(int fd);
 uint32_t fd_file_size(int fd);
 uint32_t* fd_pos_ptr(int fd);
 

source/kernel/C/filesystems/fat16.c

@@ -516,8 +516,6 @@ int fat16_read(fat16_file_t* f, uint8_t* out, uint32_t size) {
         f->fs->bs.sectors_per_cluster * 512;
     uint16_t cluster = f->entry.first_cluster;
 
-    printf("READ CALLED: pos=%u size=%u\n", f->pos, size);
-
     if (cluster_size == 0 || cluster < 2)
         return 0;
 

source/kernel/C/filesystems/vfs.c

@@ -71,8 +71,11 @@ int vfs_resolve_mount(const char* path, vfs_mount_res_t* out) {
     return 0;
 }
 
-static void vfs_normalize_path(const char* in, char* out) {
-    memset(out, 0, 256);
+int vfs_normalize_path(const char* in, char* out, size_t out_sz) {
+    if (!in || !out || out_sz < 2)
+        return -1;
+
+    memset(out, 0, out_sz);
     char tmp[256];
 
     // Start with absolute or relative
@@ -113,16 +116,17 @@ static void vfs_normalize_path(const char* in, char* out) {
 
         // Copy next component
         while (*p && *p != '/') {
-            if (oi >= 255) {
-                out[255] = '\0';
-                return;
+            if ((size_t)oi >= out_sz - 1) {
+                out[out_sz - 1] = '\0';
+                return -2;
             }
             out[oi++] = *p++;
         }
     }
 
     if (oi == 0) out[oi++] = '/';
     out[oi] = '\0';
+    return 0;
 }
 
 int vfs_read(vfs_file_t* file, uint8_t* buf, uint32_t size)
@@ -215,7 +219,8 @@ int vfs_ls(const char* path)
     }
 
     char norm[256];
-    vfs_normalize_path(path, norm);
+    if (vfs_normalize_path(path, norm, sizeof(norm)) != 0)
+        return -1;
 
     vfs_mount_res_t res;
     if (vfs_resolve_mount(norm, &res) != 0)
@@ -322,14 +327,13 @@ int vfs_open(const char* path, int flags, vfs_file_t* out)
     }
 
     char norm[256];
-    vfs_normalize_path(path, norm);
+    if (vfs_normalize_path(path, norm, sizeof(norm)) != 0)
+        return -1;
 
     vfs_mount_res_t res;
     if (vfs_resolve_mount(norm, &res) != 0)
         return -2;
 
-    printf("[OPEN] %s", norm);
-    
     if (res.mnt->type == FS_PROC) {
         strncpy(out->rel_path, res.rel_path, sizeof(out->rel_path));
         out->mnt = res.mnt;
@@ -454,7 +458,8 @@ int vfs_mkdir(const char* path) {
     }
 
     char norm[256];
-    vfs_normalize_path(path, norm);
+    if (vfs_normalize_path(path, norm, sizeof(norm)) != 0)
+        return -1;
 
     vfs_mount_res_t res;
     if (vfs_resolve_mount(norm, &res) != 0) return -1;
@@ -477,7 +482,8 @@ int vfs_mkdir(const char* path) {
 int vfs_rm_recursive(const char* path)
 {
     char norm[256];
-    vfs_normalize_path(path, norm);
+    if (vfs_normalize_path(path, norm, sizeof(norm)) != 0)
+        return -1;
 
     vfs_mount_res_t res;
     if (vfs_resolve_mount(norm, &res) != 0)
@@ -545,7 +551,8 @@ int vfs_cd(const char* path)
     }
 
     char norm[256];
-    vfs_normalize_path(path, norm);
+    if (vfs_normalize_path(path, norm, sizeof(norm)) != 0)
+        return -1;
 
     vfs_mount_res_t res;
     if (vfs_resolve_mount(norm, &res) != 0)
@@ -633,7 +640,8 @@ int vfs_create_path(const char* path, uint8_t attr) {
     }
 
     char norm[256];
-    vfs_normalize_path(path, norm);
+    if (vfs_normalize_path(path, norm, sizeof(norm)) != 0)
+        return -1;
 
     vfs_mount_res_t res;
     if (vfs_resolve_mount(norm, &res) != 0) return -1;
@@ -659,7 +667,8 @@ int vfs_unlink(const char* path)
     }
     /* Normalize */
     char norm[256];
-    vfs_normalize_path(path, norm);
+    if (vfs_normalize_path(path, norm, sizeof(norm)) != 0)
+        return -1;
 
     /* Resolve mount */
     vfs_mount_res_t res;
@@ -717,8 +726,10 @@ int vfs_unlink(const char* path)
 int vfs_mv(const char* src, const char* dst)
 {
     char src_norm[256], dst_norm[256];
-    vfs_normalize_path(src, src_norm);
-    vfs_normalize_path(dst, dst_norm);
+    if (vfs_normalize_path(src, src_norm, sizeof(src_norm)) != 0)
+        return -1;
+    if (vfs_normalize_path(dst, dst_norm, sizeof(dst_norm)) != 0)
+        return -1;
 
     vfs_mount_res_t src_res, dst_res;
     if (vfs_resolve_mount(src_norm, &src_res) != 0) return -1;
@@ -825,4 +836,4 @@ const char* vfs_basename(const char* path) {
         path++;
     }
     return last;
-}
+}

source/kernel/C/stream.c

@@ -30,6 +30,7 @@ typedef struct {
     int flags;
     vfs_file_t* file;
     vfs_file_t storage;
+    char path[256];
 } fd_object_t;
 
 typedef struct {
@@ -51,6 +52,7 @@ static fd_object_t* fd_object_alloc(vfs_file_t* file, bool owns_file, int flags)
             fd_objects[i].owns_file = owns_file;
             fd_objects[i].flags = flags;
             fd_objects[i].file = file;
+            memset(fd_objects[i].path, 0, sizeof(fd_objects[i].path));
 
             if (!owns_file)
                 memset(&fd_objects[i].storage, 0, sizeof(vfs_file_t));
@@ -206,6 +208,8 @@ int fd_open(const char* path, int flags)
 
     object->file = &object->storage;
     memset(object->file, 0, sizeof(vfs_file_t));
+    if (path)
+        vfs_normalize_path(path, object->path, sizeof(object->path));
 
     if (vfs_open(path, flags, object->file) != 0) {
         fd_object_release(object);
@@ -265,6 +269,17 @@ int fd_flags(int fd)
     return fd_table[fd].object->flags;
 }
 
+const char* fd_get_path(int fd)
+{
+    if (!fd_valid(fd) || !fd_table[fd].object)
+        return NULL;
+
+    if (fd_table[fd].object->path[0] == '\0')
+        return NULL;
+
+    return fd_table[fd].object->path;
+}
+
 uint32_t fd_file_size(int fd)
 {
     vfs_file_t* file = fd_get_file(fd);

source/kernel/C/syscalls.c

@@ -328,17 +328,37 @@ static void fill_stat_from_info(linux_stat_t* st, const vfs_stat_info_t* info) {
     st->st_blocks = (info->size + 511) / 512;
 }
 
-static bool fill_vfs_stat_for_path(const char* path, vfs_stat_info_t* info) {
+static bool resolve_path_at(int dirfd, const char* path, char* out, size_t out_sz) {
+    if (!path || !out)
+        return false;
+
+    if (path[0] == '/')
+        return vfs_normalize_path(path, out, out_sz) == 0;
+
+    if (dirfd == LINUX_AT_FDCWD || dirfd == 0)
+        return vfs_normalize_path(path, out, out_sz) == 0;
+
+    if (!fd_valid(dirfd))
+        return false;
+
+    const char* base = fd_get_path(dirfd);
+    if (!base)
+        base = vfs_getcwd();
+
+    char joined[512];
+    snprintf(joined, sizeof(joined), "%s/%s", base, path);
+    return vfs_normalize_path(joined, out, out_sz) == 0;
+}
+
+static bool fill_vfs_stat_for_path_at(int dirfd, const char* path, vfs_stat_info_t* info) {
     if (!path || !info)
         return false;
 
     memset(info, 0, sizeof(*info));
 
     char norm[256];
-    if (path[0] == '/')
-        snprintf(norm, sizeof(norm), "%s", path);
-    else
-        snprintf(norm, sizeof(norm), "%s/%s", vfs_getcwd(), path);
+    if (!resolve_path_at(dirfd, path, norm, sizeof(norm)))
+        return false;
 
     if (strcmp(norm, "/") == 0) {
         info->exists = true;
@@ -678,10 +698,11 @@ static int64 sys_open_common(int dirfd, const char* path, int flags, int mode) {
     if (path == NULL)
         return -LINUX_EINVAL;
 
-    if (dirfd != LINUX_AT_FDCWD && dirfd != 0)
+    char resolved_path[256];
+    if (!resolve_path_at(dirfd, path, resolved_path, sizeof(resolved_path)))
         return -LINUX_EINVAL;
 
-    int fd = fd_open(path, linux_flags_to_vfs(flags));
+    int fd = fd_open(resolved_path, linux_flags_to_vfs(flags));
     if (fd == -1)
         return -LINUX_ENFILE;
 
@@ -714,7 +735,7 @@ static int64 sys_stat(const char* path, linux_stat_t* st) {
         return -LINUX_EINVAL;
 
     vfs_stat_info_t info;
-    if (!fill_vfs_stat_for_path(path, &info))
+    if (!fill_vfs_stat_for_path_at(LINUX_AT_FDCWD, path, &info))
         return -LINUX_ENOENT;
 
     fill_stat_from_info(st, &info);
@@ -733,11 +754,8 @@ static int64 sys_newfstatat(int dirfd, const char* path, linux_stat_t* st, int f
 
     if (!path)
         return -LINUX_EINVAL;
-    if (dirfd != LINUX_AT_FDCWD && dirfd != 0)
-        return -LINUX_EINVAL;
-
     vfs_stat_info_t info;
-    if (!fill_vfs_stat_for_path(path, &info))
+    if (!fill_vfs_stat_for_path_at(dirfd, path, &info))
         return -LINUX_ENOENT;
     fill_stat_from_info(st, &info);
     return 0;
@@ -894,11 +912,8 @@ static int64 sys_access_common(int dirfd, const char* path, int mode) {
     (void)mode;
     if (!path)
         return -LINUX_EINVAL;
-    if (dirfd != LINUX_AT_FDCWD && dirfd != 0)
-        return -LINUX_EINVAL;
-
     vfs_stat_info_t info;
-    return fill_vfs_stat_for_path(path, &info) ? 0 : -LINUX_ENOENT;
+    return fill_vfs_stat_for_path_at(dirfd, path, &info) ? 0 : -LINUX_ENOENT;
 }
 
 static int64 sys_lseek(uint64_t fd, int64_t offset, uint64_t whence) {
@@ -976,12 +991,14 @@ static int64 sys_chdir(const char* path) {
 }
 
 static int64 sys_readlinkat(int dirfd, const char* path, char* buf, uint64_t bufsiz) {
-    if (dirfd != LINUX_AT_FDCWD && dirfd != 0)
-        return -LINUX_EINVAL;
     if (!path)
         return -LINUX_EINVAL;
 
-    if (strcmp(path, "/proc/self/exe") == 0 || strcmp(path, "self/exe") == 0)
+    char resolved_path[256];
+    if (!resolve_path_at(dirfd, path, resolved_path, sizeof(resolved_path)))
+        return -LINUX_EINVAL;
+
+    if (strcmp(resolved_path, "/proc/self/exe") == 0 || strcmp(resolved_path, "self/exe") == 0)
         return copy_readlink_result(current_exec_path, buf, bufsiz);
 
     return -LINUX_ENOENT;