Add basic emulation of getcwd/chdir

This commit adds basic emulation of a current working directory to
wasi-libc. The `getcwd` and `chdir` symbols are now implemented and
available for use. The `getcwd` implementation is pretty simple in that
it just copies out of a new global, `__wasilibc_cwd`, which defaults to
`"/"`. The `chdir` implementation is much more involved and has more
ramification, however.

A new function, `make_absolute`, was added to the preopens object. Paths
stored in the preopen table are now always stored as absolute paths
instead of relative paths, and initial relative paths are interpreted as
being relative to `/`. Looking up a path to preopen now always turns it
into an absolute path, relative to the current working directory, and an
appropriate path is then returned.

The signature of `__wasilibc_find_relpath` has changed as well. It now
returns two path components, one for the absolute part and one for the
relative part. Additionally the relative part is always dynamically
allocated since it may no longer be a substring of the original input
path.

This has been tested lightly against the Rust standard library so far,
but I'm not a regular C developer so there's likely a few things to
improve!

Author: alexcrichton

expected/wasm32-wasi/defined-symbols.txt

@@ -250,6 +250,7 @@ __uflow
 __unlist_locked_file
 __uselocale
 __utc
+__wasilibc_cwd
 __wasilibc_ensure_environ
 __wasilibc_environ
 __wasilibc_environ
@@ -367,6 +368,7 @@ ceill
 cexp
 cexpf
 cexpl
+chdir
 cimag
 cimagf
 cimagl
@@ -578,6 +580,7 @@ getc
 getc_unlocked
 getchar
 getchar_unlocked
+getcwd
 getdate
 getdate_err
 getdelim

libc-bottom-half/headers/public/wasi/libc-find-relpath.h

@@ -6,14 +6,22 @@ extern "C" {
 #endif
 
 /**
- * Look up the given path in the preopened directory map. If a suitable
- * entry is found, return its directory file descriptor, and store the
- * computed relative path in *relative_path.
+ * Look up the given `path`, relative to the cwd, in the preopened directory
+ * map. If a suitable entry is found, then the file descriptor for that entry
+ * is returned. Additionally the absolute path of the directory's file
+ * descriptor is returned in `abs_prefix` and the relative portion that needs
+ * to be opened is stored in `relative_path`.
  *
- * Returns -1 if no directories were suitable.
+ * Returns -1 if no directories were suitable or if an allocation error
+ * happens.
+ *
+ * On success the `relative_path` points to a malloc'd string, so you'll
+ * need to call `free` on it. The `abs_prefix` return does not need to be
+ * free'd.
  */
 int __wasilibc_find_relpath(const char *path,
-                            const char **__restrict__ relative_path);
+                            const char **__restrict__ abs_prefix,
+                            char **__restrict__ relative_path);
 
 #ifdef __cplusplus
 }

libc-bottom-half/sources/chdir.c

@@ -0,0 +1,61 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <wasi/libc-find-relpath.h>
+#include <wasi/libc.h>
+
+char *__wasilibc_cwd = "/";
+static int __wasilibc_cwd_mallocd = 0;
+
+int chdir(const char *path)
+{
+  // Find a preopen'd directory as well as a relative path we're anchored
+  // from which we're changing directories to.
+  char *relative;
+  const char *abs;
+  int parent_fd = __wasilibc_find_relpath(path, &abs, &relative);
+  if (parent_fd == -1) {
+    errno = ENOENT;
+    return -1;
+  }
+
+  // Make sure that this directory we're accessing is indeed a directory.
+  struct stat dirinfo;
+  int ret = fstatat(parent_fd, relative, &dirinfo, 0);
+  if (ret == -1) {
+    free(relative);
+    return -1;
+  }
+  if (!S_ISDIR(dirinfo.st_mode)) {
+    free(relative);
+    errno = ENOTDIR;
+    return -1;
+  }
+
+  // Copy over our new absolute path into `__wasilibc_cwd`. Only copy over
+  // the relative portion of the path if it's not equal to `.`
+  size_t len = strlen(abs);
+  int copy_relative = strcmp(relative, ".") != 0;
+  char *new_cwd = malloc(len + (copy_relative ? strlen(relative) : 0));
+  if (new_cwd == NULL) {
+    errno = ENOMEM;
+    return -1;
+  }
+  strcpy(new_cwd, abs);
+  if (copy_relative)
+    strcpy(new_cwd + strlen(abs), relative);
+  free(relative);
+
+  // And set our new malloc'd buffer into the global cwd, freeing the
+  // previous one if necessary.
+  char *prev_cwd = __wasilibc_cwd;
+  __wasilibc_cwd = new_cwd;
+  if (__wasilibc_cwd_mallocd)
+    free(prev_cwd);
+  __wasilibc_cwd_mallocd = 1;
+  return 0;
+}

libc-bottom-half/sources/getcwd.c

@@ -0,0 +1,25 @@
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+
+extern char *__wasilibc_cwd;
+
+char *getcwd(char *buf, size_t size)
+{
+  if (!buf) {
+    buf = strdup(__wasilibc_cwd);
+    if (!buf) {
+      errno = ENOMEM;
+      return -1;
+    }
+  } else {
+    size_t len = strlen(__wasilibc_cwd);
+    if (size < strlen(__wasilibc_cwd) + 1) {
+      errno = ERANGE;
+      return 0;
+    }
+    strcpy(buf, __wasilibc_cwd);
+  }
+  return buf;
+}
+