Add a "fork" of musl as //fusl.

fusl/src/misc/wordexp.c

+#include <wordexp.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <signal.h>
+#include <errno.h>
+#include <fcntl.h>
+#include "pthread_impl.h"
+
+static void reap(pid_t pid)
+{
+        int status;
+        for (;;) {
+                if (waitpid(pid, &status, 0) < 0) {
+                        if (errno != EINTR) return;
+                } else {
+                        if (WIFEXITED(status)) return;
+                }
+        }
+}
+
+static char *getword(FILE *f)
+{
+        char *s = 0;
+        return getdelim(&s, (size_t [1]){0}, 0, f) < 0 ? 0 : s;
+}
+
+static int do_wordexp(const char *s, wordexp_t *we, int flags)
+{
+        size_t i, l;
+        int sq=0, dq=0;
+        size_t np=0;
+        char *w, **tmp;
+        char *redir = (flags & WRDE_SHOWERR) ? "" : "2>/dev/null";
+        int err = 0;
+        FILE *f;
+        size_t wc = 0;
+        char **wv = 0;
+        int p[2];
+        pid_t pid;
+        sigset_t set;
+
+        if (flags & WRDE_REUSE) wordfree(we);
+
+        if (flags & WRDE_NOCMD) for (i=0; s[i]; i++) switch (s[i]) {
+        case '\\':
+                if (!sq) i++;
+                break;
+        case '\'':
+                if (!dq) sq^=1;
+                break;
+        case '"':
+                if (!sq) dq^=1;
+                break;
+        case '(':
+                if (np) {
+                        np++;
+                        break;
+                }
+        case ')':
+                if (np) {
+                        np--;
+                        break;
+                }
+        case '\n':
+        case '|':
+        case '&':
+        case ';':
+        case '<':
+        case '>':
+        case '{':
+        case '}':
+                if (!(sq|dq|np)) return WRDE_BADCHAR;
+                break;
+        case '$':
+                if (sq) break;
+                if (s[i+1]=='(' && s[i+2]=='(') {
+                        i += 2;
+                        np += 2;
+                        break;
+                } else if (s[i+1] != '(') break;
+        case '`':
+                if (sq) break;
+                return WRDE_CMDSUB;
+        }
+
+        if (flags & WRDE_APPEND) {
+                wc = we->we_wordc;
+                wv = we->we_wordv;
+        }
+
+        i = wc;
+        if (flags & WRDE_DOOFFS) {
+                if (we->we_offs > SIZE_MAX/sizeof(void *)/4)
+                        goto nospace;
+                i += we->we_offs;
+        } else {
+                we->we_offs = 0;
+        }
+
+        if (pipe2(p, O_CLOEXEC) < 0) goto nospace;
+        __block_all_sigs(&set);
+        pid = fork();
+        __restore_sigs(&set);
+        if (pid < 0) {
+                close(p[0]);
+                close(p[1]);
+                goto nospace;
+        }
+        if (!pid) {
+                if (p[1] == 1) fcntl(1, F_SETFD, 0);
+                else dup2(p[1], 1);
+                execl("/bin/sh", "sh", "-c",
+                        "eval \"printf %s\\\\\\\\0 x $1 $2\"",
+                        "sh", s, redir, (char *)0);
+                _exit(1);
+        }
+        close(p[1]);
+        
+        f = fdopen(p[0], "r");
+        if (!f) {
+                close(p[0]);
+                kill(pid, SIGKILL);
+                reap(pid);
+                goto nospace;
+        }
+
+        l = wv ? i+1 : 0;
+
+        free(getword(f));
+        if (feof(f)) {
+                fclose(f);
+                reap(pid);
+                return WRDE_SYNTAX;
+        }
+
+        while ((w = getword(f))) {
+                if (i+1 >= l) {
+                        l += l/2+10;
+                        tmp = realloc(wv, l*sizeof(char *));
+                        if (!tmp) break;
+                        wv = tmp;
+                }
+                wv[i++] = w;
+                wv[i] = 0;
+        }
+        if (!feof(f)) err = WRDE_NOSPACE;
+
+        fclose(f);
+        reap(pid);
+
+        if (!wv) wv = calloc(i+1, sizeof *wv);
+
+        we->we_wordv = wv;
+        we->we_wordc = i;
+
+        if (flags & WRDE_DOOFFS) {
+                if (wv) for (i=we->we_offs; i; i--)
+                        we->we_wordv[i-1] = 0;
+                we->we_wordc -= we->we_offs;
+        }
+        return err;
+
+nospace:
+        if (!(flags & WRDE_APPEND)) {
+                we->we_wordc = 0;
+                we->we_wordv = 0;
+        }
+        return WRDE_NOSPACE;
+}
+
+int wordexp(const char *restrict s, wordexp_t *restrict we, int flags)
+{
+        int r, cs;
+        pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+        r = do_wordexp(s, we, flags);
+        pthread_setcancelstate(cs, 0);
+        return r;
+}
+
+void wordfree(wordexp_t *we)
+{
+        size_t i;
+        if (!we->we_wordv) return;
+        for (i=0; i<we->we_wordc; i++) free(we->we_wordv[we->we_offs+i]);
+        free(we->we_wordv);
+        we->we_wordv = 0;
+        we->we_wordc = 0;
+}