/*- * Copyright (c) 2002 Tim J. Robbins. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #if TARGET_OS_IPHONE /* */ #include int wordexp(const char *restrict words __unused, wordexp_t *restrict pwordexp __unused, int flags __unused) { return WRDE_NOSPACE; } void wordfree(wordexp_t *pwordexp __unused) { } #else #include "namespace.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "un-namespace.h" #ifdef __APPLE__ // For _NSGetEnviron() -- which gives us a pointer to environ #include #include #endif /* __APPLE__ */ __FBSDID("$FreeBSD$"); #ifdef __APPLE__ /* * To maintain backwards compatibility with wordexp_t, we can't put * we_strings and we_nbytes in wordexp_t. So we create a new structure, * we_int_t, that has wi_strings and wi_nbytes, as well as the we_wordv * storage. */ typedef struct { char *wi_strings; size_t wi_nbytes; char *wi_wordv[0]; } we_int_t; /* * Normally, we_wordv will point to wi_wordv, so we need macros to convert * back and forth between wi_wordv and the we_int_t structure. */ #define WE_INT_T(x) ((we_int_t *)((char *)(x) - sizeof(we_int_t))) #define WE_STRINGS(we) (WE_INT_T((we)->we_wordv)->wi_strings) #define WE_WORDV(x) ((x)->wi_wordv) /* * bash will return success, yet print a command substitution/syntax error * to stderr. So we need to capture stderr, and see if it contains this error. */ static const char command_substitution_str[] = "command substitution"; static const char syntax_error_str[] = "syntax error"; static const char unbound_variable_str[] = " unbound variable"; #endif /* __APPLE__ */ static int we_askshell(const char *, wordexp_t *, int); static int we_check(const char *, int); /* * wordexp -- * Perform shell word expansion on `words' and place the resulting list * of words in `we'. See wordexp(3). * * Specified by IEEE Std. 1003.1-2001. */ int #ifdef __APPLE__ wordexp(const char * __restrict words, wordexp_t * __restrict we0, int flags) #else /* !__APPLE__ */ wordexp(const char * __restrict words, wordexp_t * __restrict we, int flags) #endif /* !__APPLE__ */ { int error; #ifdef __APPLE__ wordexp_t temp; wordexp_t *we = &temp; if ((error = we_check(words, flags)) != 0) return (error); we->we_offs = we0->we_offs; if (flags & WRDE_APPEND) { size_t i; size_t vofs = we0->we_wordc + (flags & WRDE_DOOFFS ? we0->we_offs : 0); we_int_t *wi0 = WE_INT_T(we0->we_wordv); we_int_t *wi = malloc((vofs + 1) * sizeof(char *) + sizeof(we_int_t)); if (!wi) return (WRDE_NOSPACE); memcpy(wi, wi0, (vofs + 1) * sizeof(char *) + sizeof(we_int_t)); wi->wi_strings = malloc(wi->wi_nbytes); if (!wi->wi_strings) { free(wi); return (WRDE_NOSPACE); } memcpy(wi->wi_strings, wi0->wi_strings, wi->wi_nbytes); for (i = 0; i < vofs; i++) if (wi->wi_wordv[i] != NULL) wi->wi_wordv[i] += wi->wi_strings - wi0->wi_strings; we->we_wordc = we0->we_wordc; we->we_wordv = WE_WORDV(wi); } else { we->we_wordc = 0; we->we_wordv = NULL; } #else /* !__APPLE__ */ if (flags & WRDE_REUSE) wordfree(we); if ((flags & WRDE_APPEND) == 0) { we->we_wordc = 0; we->we_wordv = NULL; we->we_strings = NULL; we->we_nbytes = 0; } if ((error = we_check(words, flags)) != 0) { wordfree(we); return (error); } #endif /* !__APPLE__ */ if ((error = we_askshell(words, we, flags)) != 0) { #ifdef __APPLE__ if (error == WRDE_NOSPACE) { if (flags & WRDE_REUSE) wordfree(we0); *we0 = *we; } else { wordfree(we); } #else /* !__APPLE__ */ wordfree(we); #endif /* !__APPLE__ */ return (error); } #ifdef __APPLE__ if (flags & WRDE_REUSE) wordfree(we0); *we0 = *we; #endif /* __APPLE__ */ return (0); } static size_t we_read_fully(int fd, char *buffer, size_t len) { size_t done; ssize_t nread; done = 0; do { nread = _read(fd, buffer + done, len - done); if (nread == -1 && errno == EINTR) continue; if (nread <= 0) break; done += nread; } while (done != len); return done; } /* * we_askshell -- * Use the `wordexp' /bin/sh builtin function to do most of the work * in expanding the word string. This function is complicated by * memory management. */ static int we_askshell(const char *words, wordexp_t *we, int flags) { int pdes[2]; /* Pipe to child */ char bbuf[9]; /* Buffer for byte count */ char wbuf[9]; /* Buffer for word count */ long nwords, nbytes; /* Number of words, bytes from child */ long i; /* Handy integer */ size_t sofs; /* Offset into we->we_strings */ size_t vofs; /* Offset into we->we_wordv */ pid_t pid; /* Process ID of child */ pid_t wpid; /* waitpid return value */ int status; /* Child exit status */ int error; /* Our return value */ int serrno; /* errno to return */ char *np, *p; /* Handy pointers */ char *nstrings; /* Temporary for realloc() */ #ifdef __APPLE__ int perr[2]; /* Pipe to child error */ we_int_t *nwv; /* Temporary for realloc() */ int spawnerr = 0; posix_spawn_file_actions_t file_actions; posix_spawnattr_t attr; #else /* !__APPLE__ */ char **nwv; /* Temporary for realloc() */ #endif /* !__APPLE__ */ sigset_t newsigblock, oldsigblock; serrno = errno; #ifdef __APPLE__ if (pipe(pdes) < 0) #else /* !__APPLE__ */ if (pipe2(pdes, O_CLOEXEC) < 0) #endif /* !__APPLE__ */ return (WRDE_NOSPACE); /* XXX */ #ifdef __APPLE__ if (pipe(perr) < 0) { close(pdes[0]); close(pdes[1]); return (WRDE_NOSPACE); /* XXX */ } #endif /* __APPLE__ */ (void)sigemptyset(&newsigblock); (void)sigaddset(&newsigblock, SIGCHLD); (void)_sigprocmask(SIG_BLOCK, &newsigblock, &oldsigblock); #ifdef __APPLE__ if ((spawnerr = posix_spawnattr_init(&attr)) != 0) goto spawnerrexit; do { sigset_t spawnsig; if ((spawnerr = posix_spawnattr_setflags(&attr, POSIX_SPAWN_CLOEXEC_DEFAULT)) != 0) break; (void)sigfillset(&spawnsig); if ((spawnerr = posix_spawnattr_setsigdefault(&attr, &spawnsig)) != 0) break; (void)sigemptyset(&spawnsig); if ((spawnerr = posix_spawnattr_setsigmask(&attr, &spawnsig)) != 0) break; if ((spawnerr = posix_spawn_file_actions_init(&file_actions)) != 0) break; do { char *argv[7] = {"sh"}; const char cmd[] = "[ $# -gt 0 ] && export IFS=\"$1\";/usr/lib/system/wordexp-helper "; int a = 1; char *buf; int buflen; char *IFS; if (pdes[1] == STDOUT_FILENO) { if ((spawnerr = posix_spawn_file_actions_addinherit_np(&file_actions, STDOUT_FILENO)) != 0) break; } else { if ((spawnerr = posix_spawn_file_actions_adddup2(&file_actions, pdes[1], STDOUT_FILENO)) != 0) break; } if (perr[1] == STDERR_FILENO) { if ((spawnerr = posix_spawn_file_actions_addinherit_np(&file_actions, STDERR_FILENO)) != 0) break; } else { if ((spawnerr = posix_spawn_file_actions_adddup2(&file_actions, perr[1], STDERR_FILENO)) != 0) break; } if (flags & WRDE_UNDEF) argv[a++] = "-u"; argv[a++] = "-c"; buflen = (sizeof(cmd) - 1) + strlen(words) + 1; if ((buf = malloc(buflen)) == NULL) { spawnerr = errno; break; } strcpy(buf, cmd); strcat(buf, words); argv[a++] = buf; if ((IFS = getenv("IFS")) != NULL) { argv[a++] = "--"; argv[a++] = IFS; } argv[a] = NULL; spawnerr = posix_spawn(&pid, _PATH_BSHELL, &file_actions, &attr, argv, *_NSGetEnviron()); free(buf); } while(0); posix_spawn_file_actions_destroy(&file_actions); } while(0); posix_spawnattr_destroy(&attr); if (spawnerr) { spawnerrexit: close(pdes[0]); close(pdes[1]); close(perr[0]); close(perr[1]); errno = spawnerr; return (WRDE_NOSPACE); /* XXX */ } #else /* !__APPLE__ */ if ((pid = fork()) < 0) { serrno = errno; _close(pdes[0]); _close(pdes[1]); (void)_sigprocmask(SIG_SETMASK, &oldsigblock, NULL); errno = serrno; return (WRDE_NOSPACE); /* XXX */ } else if (pid == 0) { /* * We are the child; just get /bin/sh to run the wordexp * builtin on `words'. */ (void)_sigprocmask(SIG_SETMASK, &oldsigblock, NULL); if ((pdes[1] != STDOUT_FILENO ? _dup2(pdes[1], STDOUT_FILENO) : _fcntl(pdes[1], F_SETFD, 0)) < 0) _exit(1); execl(_PATH_BSHELL, "sh", flags & WRDE_UNDEF ? "-u" : "+u", "-c", "eval \"$1\";eval \"wordexp $2\"", "", flags & WRDE_SHOWERR ? "" : "exec 2>/dev/null", words, (char *)NULL); _exit(1); } #endif /* !__APPLE__ */ /* * We are the parent; read the output of the shell wordexp function, * which is a 32-bit hexadecimal word count, a 32-bit hexadecimal * byte count (not including terminating null bytes), followed by * the expanded words separated by nulls. */ _close(pdes[1]); #ifdef __APPLE__ close(perr[1]); #endif /* __APPLE__ */ if (we_read_fully(pdes[0], wbuf, 8) != 8 || we_read_fully(pdes[0], bbuf, 8) != 8) { error = flags & WRDE_UNDEF ? WRDE_BADVAL : WRDE_SYNTAX; serrno = errno; goto cleanup; } wbuf[8] = bbuf[8] = '\0'; nwords = strtol(wbuf, NULL, 16); nbytes = strtol(bbuf, NULL, 16) + nwords; /* * Allocate or reallocate (when flags & WRDE_APPEND) the word vector * and string storage buffers for the expanded words we're about to * read from the child. */ #ifndef __APPLE__ sofs = we->we_nbytes; #endif /* !__APPLE__ */ vofs = we->we_wordc; if ((flags & (WRDE_DOOFFS|WRDE_APPEND)) == (WRDE_DOOFFS|WRDE_APPEND)) vofs += we->we_offs; we->we_wordc += nwords; #ifndef __APPLE__ we->we_nbytes += nbytes; #endif /* !__APPLE__ */ #ifdef __APPLE__ if ((nwv = realloc(we->we_wordv ? WE_INT_T(we->we_wordv) : NULL, (we->we_wordc + 1 + (flags & WRDE_DOOFFS ? we->we_offs : 0)) * sizeof(char *) + sizeof(we_int_t))) == NULL) #else /* !__APPLE__ */ if ((nwv = realloc(we->we_wordv, (we->we_wordc + 1 + (flags & WRDE_DOOFFS ? we->we_offs : 0)) * sizeof(char *))) == NULL) #endif /* !__APPLE__ */ { error = WRDE_NOSPACE; goto cleanup; } #ifdef __APPLE__ if (!we->we_wordv) { nwv->wi_strings = NULL; nwv->wi_nbytes = 0; } sofs = nwv->wi_nbytes; nwv->wi_nbytes += nbytes; we->we_wordv = WE_WORDV(nwv); #else /* !__APPLE__ */ we->we_wordv = nwv; #endif /* !__APPLE__ */ #ifdef __APPLE__ if ((nstrings = realloc(nwv->wi_strings, nwv->wi_nbytes)) == NULL) #else /* !__APPLE__ */ if ((nstrings = realloc(we->we_strings, we->we_nbytes)) == NULL) #endif /* !__APPLE__ */ { error = WRDE_NOSPACE; goto cleanup; } for (i = 0; i < vofs; i++) if (we->we_wordv[i] != NULL) #ifdef __APPLE__ we->we_wordv[i] += nstrings - nwv->wi_strings; #else /* !__APPLE__ */ we->we_wordv[i] += nstrings - we->we_strings; #endif /* !__APPLE__ */ #ifdef __APPLE__ nwv->wi_strings = nstrings; #else /* !__APPLE__ */ we->we_strings = nstrings; #endif /* !__APPLE__ */ #ifdef __APPLE__ if (we_read_fully(pdes[0], nwv->wi_strings + sofs, nbytes) != nbytes) #else /* !__APPLE__ */ if (we_read_fully(pdes[0], we->we_strings + sofs, nbytes) != nbytes) #endif /* !__APPLE__ */ { error = flags & WRDE_UNDEF ? WRDE_BADVAL : WRDE_SYNTAX; serrno = errno; goto cleanup; } #ifdef __APPLE__ char err_buf[1024]; ssize_t err_sz = read(perr[0], err_buf, sizeof(err_buf) - 1); if (err_sz > 0) { err_buf[err_sz] = '\0'; if (flags & WRDE_SHOWERR) { fputs(err_buf, stderr); } } else if (err_sz < 0) { serrno = errno; error = WRDE_NOSPACE; goto cleanup; } #endif /* __APPLE__ */ error = 0; cleanup: _close(pdes[0]); #ifdef __APPLE__ close(perr[0]); #endif /* __APPLE__ */ do wpid = _waitpid(pid, &status, 0); while (wpid < 0 && errno == EINTR); (void)_sigprocmask(SIG_SETMASK, &oldsigblock, NULL); if (error != 0) { errno = serrno; return (error); } if (wpid < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) return (flags & WRDE_UNDEF ? WRDE_BADVAL : WRDE_SYNTAX); #ifdef __APPLE__ const char *cs = strstr(err_buf, command_substitution_str); if (cs && strstr(cs + (sizeof(command_substitution_str) - 1), syntax_error_str)) { return (strstr(err_buf, unbound_variable_str) ? WRDE_BADVAL : WRDE_SYNTAX); } #endif /* __APPLE__ */ /* * Break the null-terminated expanded word strings out into * the vector. */ if (vofs == 0 && flags & WRDE_DOOFFS) while (vofs < we->we_offs) we->we_wordv[vofs++] = NULL; #ifdef __APPLE__ p = nwv->wi_strings + sofs; #else /* !__APPLE__ */ p = we->we_strings + sofs; #endif /* !__APPLE__ */ while (nwords-- != 0) { we->we_wordv[vofs++] = p; if ((np = memchr(p, '\0', nbytes)) == NULL) return (WRDE_NOSPACE); /* XXX */ nbytes -= np - p + 1; p = np + 1; } we->we_wordv[vofs] = NULL; return (0); } /* * we_check -- * Check that the string contains none of the following unquoted * special characters: |&;<>(){} * or command substitutions when WRDE_NOCMD is set in flags. */ static int we_check(const char *words, int flags) { char c; int dquote, level, quote, squote; quote = squote = dquote = 0; while ((c = *words++) != '\0') { switch (c) { case '\\': if (squote == 0) quote ^= 1; continue; case '\'': if (quote + dquote == 0) squote ^= 1; break; case '"': if (quote + squote == 0) dquote ^= 1; break; case '`': if (quote + squote == 0 && flags & WRDE_NOCMD) return (WRDE_CMDSUB); while ((c = *words++) != '\0' && c != '`') if (c == '\\' && (c = *words++) == '\0') break; if (c == '\0') return (WRDE_SYNTAX); break; case '|': case '&': case ';': case '<': case '>': case '{': case '}': case '(': case ')': case '\n': if (quote + squote + dquote == 0) return (WRDE_BADCHAR); break; case '$': if ((c = *words++) == '\0') break; else if (quote + squote == 0 && c == '(') { if (flags & WRDE_NOCMD && *words != '(') return (WRDE_CMDSUB); level = 1; while ((c = *words++) != '\0') { if (c == '\\') { if ((c = *words++) == '\0') break; } else if (c == '(') level++; else if (c == ')' && --level == 0) break; } if (c == '\0' || level != 0) return (WRDE_SYNTAX); } else if (quote + squote == 0 && c == '{') { level = 1; while ((c = *words++) != '\0') { if (c == '\\') { if ((c = *words++) == '\0') break; } else if (c == '{') level++; else if (c == '}' && --level == 0) break; } if (c == '\0' || level != 0) return (WRDE_SYNTAX); } else --words; break; default: break; } quote = 0; } if (quote + squote + dquote != 0) return (WRDE_SYNTAX); return (0); } /* * wordfree -- * Free the result of wordexp(). See wordexp(3). * * Specified by IEEE Std. 1003.1-2001. */ void wordfree(wordexp_t *we) { if (we == NULL) return; #ifdef __APPLE__ if (we->we_wordv) { free(WE_STRINGS(we)); free(WE_INT_T(we->we_wordv)); } #else /* !__APPLE__ */ free(we->we_wordv); #endif /* !__APPLE__ */ #ifndef __APPLE__ free(we->we_strings); #endif /* !__APPLE__ */ we->we_wordv = NULL; #ifndef __APPLE__ we->we_strings = NULL; we->we_nbytes = 0; #endif /* !__APPLE__ */ we->we_wordc = 0; } #endif /* TARGET_OS_IPHONE */