When opening broken symlink with O_CREAT, create file at target

src/library_fs.js

@@ -199,8 +199,14 @@ FS.staticInit();
           break;
         }
 
-        current = FS.lookupNode(current, parts[i]);
         current_path = PATH.join2(current_path, parts[i]);
+        try {
+          current = FS.lookupNode(current, parts[i]);
+        } catch (e) {
+          if ((e?.errno === {{{ cDefs.ENOENT }}}) && islast && opts.handleBrokenLink) {
+            return { path: current_path };
+          }
+        }
 
         // jump to the mount's root node if this is a mountpoint
         if (FS.isMountpoint(current)) {
@@ -213,11 +219,17 @@ FS.staticInit();
         // setting opts.follow = true will override this behavior.
         if (!islast || opts.follow) {
           var count = 0;
-          while (FS.isLink(current.mode)) {
-            var link = FS.readlink(current_path);
+          while (current && FS.isLink(current.mode)) {
+            if (!current.node_ops.readlink) {
+              throw new FS.ErrnoError({{{ cDefs.ENOSYS }}});
+            }
+            var link = current.node_ops.readlink(current);
             current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
 
-            var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });
+            var lookup = FS.lookupPath(current_path, {
+              recurse_count: opts.recurse_count + 1,
+              handleBrokenLink: islast && opts.handleBrokenLink
+            });
             current = lookup.node;
 
             if (count++ > 40) {  // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
@@ -1027,9 +1039,11 @@ FS.staticInit();
         path = PATH.normalize(path);
         try {
           var lookup = FS.lookupPath(path, {
-            follow: !(flags & {{{ cDefs.O_NOFOLLOW }}})
+            follow: !(flags & {{{ cDefs.O_NOFOLLOW }}}),
+            handleBrokenLink: true
           });
           node = lookup.node;
+          path = lookup.path;
         } catch (e) {
           // ignore
         }

test/test_core.py

@@ -6059,6 +6059,9 @@ def test_unistd_links(self, args, nodefs):
 
     self.do_run_in_out_file_test('unistd/links.c', emcc_args=args)
 
+  def test_unistd_write_broken_link(self):
+    self.do_run_in_out_file_test('unistd/write_broken_link.c')
+
   @no_windows('Skipping NODEFS test, since it would require administrative privileges.')
   @requires_node
   def test_unistd_symlink_on_nodefs(self):

test/unistd/write_broken_link.c

@@ -0,0 +1,49 @@
+#include <stdlib.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+
+char* join_path(const char* path1, const char* path2) {
+    int len1 = strlen(path1);
+    int len2 = strlen(path2);
+    char* result = malloc(len1 + len2 + 2);
+    memcpy(result, path1, len1);
+    result[len1] = '/';
+    memcpy(result + len1 + 1, path2, len2);
+    return result;
+}
+
+int main() {
+    char template[] = "/tmp/tmpdir.XXXXXX";
+    char *tmpdir = mkdtemp(template);
+    char* p1 = join_path(tmpdir, "test");
+    char* p2 = join_path(tmpdir, "test2");
+
+    int res = symlink(p2, p1);
+    printf("link result: %d\n", res);
+    int src_fd = open(p1, O_CREAT | O_WRONLY, 0777);
+    printf("source_fd: %d, errno: %d %s\n", src_fd, errno, strerror(errno));
+    write(src_fd, "abc", 3);
+    close(src_fd);
+    {
+        int target_fd = open(p2, O_RDONLY);
+        printf("target_fd: %d, errno: %d %s\n", target_fd, errno, strerror(errno));
+        char buf[10];
+        read(target_fd, buf, 10);
+        printf("buf: '%s'\n", buf);
+        close(target_fd);
+    }
+    {
+        int target_fd = open(p1, O_RDONLY);
+        printf("target_fd: %d, errno: %d %s\n", target_fd, errno, strerror(errno));
+        char buf[10];
+        read(target_fd, buf, 10);
+        printf("buf: '%s'\n", buf);
+        close(target_fd);
+    }
+    free(p1);
+    free(p2);
+}

test/unistd/write_broken_link.out

@@ -0,0 +1,6 @@
+link result: 0
+source_fd: 3, errno: 0 No error information
+target_fd: 3, errno: 0 No error information
+buf: 'abc'
+target_fd: 3, errno: 0 No error information
+buf: 'abc'