Keep our own cwd and resolve paths in os

Author: tannewt

shared-bindings/os/__init__.h

@@ -10,6 +10,7 @@
 #include <stdbool.h>
 
 #include "py/objtuple.h"
+#include "shared-module/os/__init__.h"
 
 void common_hal_os_chdir(const char *path);
 mp_obj_t common_hal_os_getcwd(void);

shared-module/os/__init__.c

@@ -6,6 +6,7 @@
 //
 // SPDX-License-Identifier: MIT
 
+#include <stddef.h>
 #include <string.h>
 
 #include "extmod/vfs.h"
@@ -63,9 +64,73 @@ static mp_obj_t mp_vfs_proxy_call(mp_vfs_mount_t *vfs, qstr meth_name, size_t n_
     return mp_call_method_n_kw(n_args, 0, meth);
 }
 
+const char *common_hal_os_path_abspath(const char *path) {
+    const char *cwd;
+    if (path[0] == '/') {
+        cwd = "";
+    } else {
+        cwd = MP_STATE_VM(cwd_path);
+        if (cwd == NULL) {
+            char *new_cwd = m_malloc(2);
+            strcpy(new_cwd, "/");
+            MP_STATE_VM(cwd_path) = new_cwd;
+            cwd = new_cwd;
+        }
+    }
+    // Scan to see if the path has any `..` in it and return the same string if it doesn't
+    bool found_dot_dot = false;
+    size_t slash_count = 0;
+    for (size_t i = 0; i < strlen(path); i++) {
+        if (path[i] == '/') {
+            slash_count++;
+        }
+        if (i + 2 < strlen(path) && path[i] == '/' && path[i + 1] == '.' && path[i + 2] == '.' && (i + 3 == strlen(path) || path[i + 3] == '/')) {
+            found_dot_dot = true;
+        }
+    }
+    if (!found_dot_dot) {
+        return path;
+    }
+
+    // Store the current output length for previous components so we can rewind to before them.
+    size_t slashes[slash_count];
+    char *full_path = m_malloc(strlen(cwd) + strlen(path) + 1);
+    memcpy(full_path, cwd, strlen(cwd));
+    memcpy(full_path + strlen(cwd), path, strlen(path) + 1);
+    size_t output_len = 0;
+    size_t component_len = 0;
+    slash_count = 0;
+
+    // Remove `..` and `.`
+    size_t original_len = strlen(full_path);
+    for (size_t i = 0; i <= original_len; i++) {
+        full_path[output_len++] = full_path[i];
+        // Treat the final nul character as a slash.
+        if (full_path[i] == '/' || full_path[i] == '\0') {
+            if (component_len == 1 && full_path[i - 1] == '.') {
+                // Remove the dot
+                output_len = slashes[slash_count - 1];
+            } else if (component_len == 2 && full_path[i - 1] == '.' && full_path[i - 2] == '.') {
+                // Remove the double dot and the previous component if it exists
+                slash_count--;
+                output_len = slashes[slash_count - 1];
+            } else {
+                slashes[slash_count] = output_len;
+                slash_count++;
+            }
+            component_len = 0;
+        } else {
+            component_len++;
+        }
+    }
+    full_path[output_len] = '\0';
+    return full_path;
+}
+
 void common_hal_os_chdir(const char *path) {
+    MP_STATE_VM(cwd_path) = common_hal_os_path_abspath(path);
     mp_obj_t path_out;
-    mp_vfs_mount_t *vfs = lookup_dir_path(path, &path_out);
+    mp_vfs_mount_t *vfs = lookup_dir_path(MP_STATE_VM(cwd_path), &path_out);
     MP_STATE_VM(vfs_cur) = vfs;
     if (vfs == MP_VFS_ROOT) {
         // If we change to the root dir and a VFS is mounted at the root then
@@ -84,12 +149,17 @@ void common_hal_os_chdir(const char *path) {
 }
 
 mp_obj_t common_hal_os_getcwd(void) {
-    return mp_vfs_getcwd();
+    const char *cwd = MP_STATE_VM(cwd_path);
+    if (cwd == NULL) {
+        return MP_OBJ_NEW_QSTR(MP_QSTR__slash_);
+    }
+    return mp_obj_new_str_of_type(&mp_type_str, (const byte *)cwd, strlen(cwd));
 }
 
 mp_obj_t common_hal_os_listdir(const char *path) {
+    const char *abspath = common_hal_os_path_abspath(path);
     mp_obj_t path_out;
-    mp_vfs_mount_t *vfs = lookup_dir_path(path, &path_out);
+    mp_vfs_mount_t *vfs = lookup_dir_path(abspath, &path_out);
     if (vfs == MP_VFS_ROOT) {
         vfs = MP_STATE_VM(vfs_mount_table);
         while (vfs != NULL) {
@@ -114,17 +184,19 @@ mp_obj_t common_hal_os_listdir(const char *path) {
 }
 
 void common_hal_os_mkdir(const char *path) {
+    const char *abspath = common_hal_os_path_abspath(path);
     mp_obj_t path_out;
-    mp_vfs_mount_t *vfs = lookup_dir_path(path, &path_out);
+    mp_vfs_mount_t *vfs = lookup_dir_path(abspath, &path_out);
     if (vfs == MP_VFS_ROOT || (vfs != MP_VFS_NONE && !strcmp(mp_obj_str_get_str(path_out), "/"))) {
         mp_raise_OSError(MP_EEXIST);
     }
     mp_vfs_proxy_call(vfs, MP_QSTR_mkdir, 1, &path_out);
 }
 
 void common_hal_os_remove(const char *path) {
+    const char *abspath = common_hal_os_path_abspath(path);
     mp_obj_t path_out;
-    mp_vfs_mount_t *vfs = lookup_path(path, &path_out);
+    mp_vfs_mount_t *vfs = lookup_path(abspath, &path_out);
     mp_vfs_proxy_call(vfs, MP_QSTR_remove, 1, &path_out);
 }
 
@@ -140,14 +212,16 @@ void common_hal_os_rename(const char *old_path, const char *new_path) {
 }
 
 void common_hal_os_rmdir(const char *path) {
+    const char *abspath = common_hal_os_path_abspath(path);
     mp_obj_t path_out;
-    mp_vfs_mount_t *vfs = lookup_dir_path(path, &path_out);
+    mp_vfs_mount_t *vfs = lookup_dir_path(abspath, &path_out);
     mp_vfs_proxy_call(vfs, MP_QSTR_rmdir, 1, &path_out);
 }
 
 mp_obj_t common_hal_os_stat(const char *path) {
+    const char *abspath = common_hal_os_path_abspath(path);
     mp_obj_t path_out;
-    mp_vfs_mount_t *vfs = lookup_path(path, &path_out);
+    mp_vfs_mount_t *vfs = lookup_path(abspath, &path_out);
     if (vfs == MP_VFS_ROOT) {
         mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(10, NULL));
         t->items[0] = MP_OBJ_NEW_SMALL_INT(MP_S_IFDIR); // st_mode
@@ -160,8 +234,9 @@ mp_obj_t common_hal_os_stat(const char *path) {
 }
 
 mp_obj_t common_hal_os_statvfs(const char *path) {
+    const char *abspath = common_hal_os_path_abspath(path);
     mp_obj_t path_out;
-    mp_vfs_mount_t *vfs = lookup_path(path, &path_out);
+    mp_vfs_mount_t *vfs = lookup_path(abspath, &path_out);
     if (vfs == MP_VFS_ROOT) {
         // statvfs called on the root directory, see if there's anything mounted there
         for (vfs = MP_STATE_VM(vfs_mount_table); vfs != NULL; vfs = vfs->next) {
@@ -192,8 +267,11 @@ mp_obj_t common_hal_os_statvfs(const char *path) {
 }
 
 void common_hal_os_utime(const char *path, mp_obj_t times) {
+    const char *abspath = common_hal_os_path_abspath(path);
     mp_obj_t args[2];
-    mp_vfs_mount_t *vfs = lookup_path(path, &args[0]);
+    mp_vfs_mount_t *vfs = lookup_path(abspath, &args[0]);
     args[1] = times;
     mp_vfs_proxy_call(vfs, MP_QSTR_utime, 2, args);
 }
+
+MP_REGISTER_ROOT_POINTER(const char *cwd_path);

shared-module/os/__init__.h

@@ -26,3 +26,5 @@ os_getenv_err_t common_hal_os_getenv_str(const char *key, char *value, size_t va
 // If any error code is returned, value is guaranteed not modified
 // An error that is not 'open' or 'not found' is printed on the repl.
 os_getenv_err_t common_hal_os_getenv_int(const char *key, mp_int_t *value);
+
+const char *common_hal_os_path_abspath(const char *path);

shared-module/pathlib/PosixPath.c

@@ -26,8 +26,7 @@ typedef struct _mp_obj_path_dir_iter_t {
 } mp_obj_path_dir_iter_t;
 
 mp_obj_t pathlib_posixpath_from_str(mp_obj_t path_str) {
-    pathlib_posixpath_obj_t *self = m_new_obj(pathlib_posixpath_obj_t);
-    self->base.type = &pathlib_posixpath_type;
+    pathlib_posixpath_obj_t *self = mp_obj_malloc(pathlib_posixpath_obj_t, &pathlib_posixpath_type);
     self->path_str = path_str;
     return MP_OBJ_FROM_PTR(self);
 }
@@ -290,8 +289,10 @@ mp_obj_t common_hal_pathlib_posixpath_absolute(pathlib_posixpath_obj_t *self) {
 }
 
 mp_obj_t common_hal_pathlib_posixpath_resolve(pathlib_posixpath_obj_t *self) {
-    // For now, just call absolute() since CircuitPython doesn't support symlinks
-    return common_hal_pathlib_posixpath_absolute(self);
+    const char *path = mp_obj_str_get_str(self->path_str);
+    const char *abspath = common_hal_os_path_abspath(path);
+    mp_obj_t abspath_obj = mp_obj_new_str(abspath, strlen(abspath));
+    return pathlib_posixpath_from_str(abspath_obj);
 }
 
 // Iterator iternext function - called for each iteration
@@ -310,8 +311,7 @@ static mp_obj_t path_dir_iter_iternext(mp_obj_t self_in) {
 
 // Create a new path directory iterator
 mp_obj_t mp_obj_new_path_dir_iter(mp_obj_t path, mp_obj_t iter) {
-    mp_obj_path_dir_iter_t *o = m_new_obj(mp_obj_path_dir_iter_t);
-    o->base.type = &mp_type_polymorph_iter;
+    mp_obj_path_dir_iter_t *o = mp_obj_malloc(mp_obj_path_dir_iter_t, &mp_type_polymorph_iter);
     o->iternext = path_dir_iter_iternext;
     o->path = path;
     o->iter = iter;