home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Spezial / SPEZIAL2_97.zip / SPEZIAL2_97.iso / ANWEND / EDITOR / NVI179B / NVI179B.ZIP / ex / ex_argv.c < prev    next >
C/C++ Source or Header  |  1996-09-20  |  17KB  |  757 lines
  1. /*-
  2.  * Copyright (c) 1993, 1994
  3.  *    The Regents of the University of California.  All rights reserved.
  4.  * Copyright (c) 1993, 1994, 1995, 1996
  5.  *    Keith Bostic.  All rights reserved.
  6.  *
  7.  * See the LICENSE file for redistribution information.
  8.  */
  9.  
  10. #include "config.h"
  11.  
  12. #ifndef lint
  13. static const char sccsid[] = "@(#)ex_argv.c    10.26 (Berkeley) 9/20/96";
  14. #endif /* not lint */
  15.  
  16. #include <sys/types.h>
  17. #include <sys/queue.h>
  18.  
  19. #include <bitstring.h>
  20. #include <ctype.h>
  21. #include <dirent.h>
  22. #include <errno.h>
  23. #include <limits.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <string.h>
  27. #include <unistd.h>
  28.  
  29. #include "../common/common.h"
  30.  
  31. static int argv_alloc __P((SCR *, size_t));
  32. static int argv_comp __P((const void *, const void *));
  33. static int argv_fexp __P((SCR *, EXCMD *,
  34.     char *, size_t, char *, size_t *, char **, size_t *, int));
  35. static int argv_lexp __P((SCR *, EXCMD *, char *));
  36. static int argv_sexp __P((SCR *, char **, size_t *, size_t *));
  37.  
  38. /*
  39.  * argv_init --
  40.  *    Build  a prototype arguments list.
  41.  *
  42.  * PUBLIC: int argv_init __P((SCR *, EXCMD *));
  43.  */
  44. int
  45. argv_init(sp, excp)
  46.     SCR *sp;
  47.     EXCMD *excp;
  48. {
  49.     EX_PRIVATE *exp;
  50.  
  51.     exp = EXP(sp);
  52.     exp->argsoff = 0;
  53.     argv_alloc(sp, 1);
  54.  
  55.     excp->argv = exp->args;
  56.     excp->argc = exp->argsoff;
  57.     return (0);
  58. }
  59.  
  60. /*
  61.  * argv_exp0 --
  62.  *    Append a string to the argument list.
  63.  *
  64.  * PUBLIC: int argv_exp0 __P((SCR *, EXCMD *, char *, size_t));
  65.  */
  66. int
  67. argv_exp0(sp, excp, cmd, cmdlen)
  68.     SCR *sp;
  69.     EXCMD *excp;
  70.     char *cmd;
  71.     size_t cmdlen;
  72. {
  73.     EX_PRIVATE *exp;
  74.  
  75.     exp = EXP(sp);
  76.     argv_alloc(sp, cmdlen);
  77.     memcpy(exp->args[exp->argsoff]->bp, cmd, cmdlen);
  78.     exp->args[exp->argsoff]->bp[cmdlen] = '\0';
  79.     exp->args[exp->argsoff]->len = cmdlen;
  80.     ++exp->argsoff;
  81.     excp->argv = exp->args;
  82.     excp->argc = exp->argsoff;
  83.     return (0);
  84. }
  85.  
  86. /*
  87.  * argv_exp1 --
  88.  *    Do file name expansion on a string, and append it to the
  89.  *    argument list.
  90.  *
  91.  * PUBLIC: int argv_exp1 __P((SCR *, EXCMD *, char *, size_t, int));
  92.  */
  93. int
  94. argv_exp1(sp, excp, cmd, cmdlen, is_bang)
  95.     SCR *sp;
  96.     EXCMD *excp;
  97.     char *cmd;
  98.     size_t cmdlen;
  99.     int is_bang;
  100. {
  101.     EX_PRIVATE *exp;
  102.     size_t blen, len;
  103.     char *bp, *p, *t;
  104.  
  105.     GET_SPACE_RET(sp, bp, blen, 512);
  106.  
  107.     len = 0;
  108.     exp = EXP(sp);
  109.     if (argv_fexp(sp, excp, cmd, cmdlen, bp, &len, &bp, &blen, is_bang)) {
  110.         FREE_SPACE(sp, bp, blen);
  111.         return (1);
  112.     }
  113.  
  114.     /* If it's empty, we're done. */
  115.     if (len != 0) {
  116.         for (p = bp, t = bp + len; p < t; ++p)
  117.             if (!isblank(*p))
  118.                 break;
  119.         if (p == t)
  120.             goto ret;
  121.     } else
  122.         goto ret;
  123.  
  124.     (void)argv_exp0(sp, excp, bp, len);
  125.  
  126. ret:    FREE_SPACE(sp, bp, blen);
  127.     return (0);
  128. }
  129.  
  130. /*
  131.  * argv_exp2 --
  132.  *    Do file name and shell expansion on a string, and append it to
  133.  *    the argument list.
  134.  *
  135.  * PUBLIC: int argv_exp2 __P((SCR *, EXCMD *, char *, size_t));
  136.  */
  137. int
  138. argv_exp2(sp, excp, cmd, cmdlen)
  139.     SCR *sp;
  140.     EXCMD *excp;
  141.     char *cmd;
  142.     size_t cmdlen;
  143. {
  144.     size_t blen, len, n;
  145.     int rval;
  146.     char *bp, *mp, *p;
  147.  
  148.     GET_SPACE_RET(sp, bp, blen, 512);
  149.  
  150. #define    SHELLECHO    "echo "
  151. #define    SHELLOFFSET    (sizeof(SHELLECHO) - 1)
  152.     memcpy(bp, SHELLECHO, SHELLOFFSET);
  153.     p = bp + SHELLOFFSET;
  154.     len = SHELLOFFSET;
  155.  
  156. #if defined(DEBUG) && 0
  157.     TRACE(sp, "file_argv: {%.*s}\n", (int)cmdlen, cmd);
  158. #endif
  159.  
  160.     if (argv_fexp(sp, excp, cmd, cmdlen, p, &len, &bp, &blen, 0)) {
  161.         rval = 1;
  162.         goto err;
  163.     }
  164.  
  165. #if defined(DEBUG) && 0
  166.     TRACE(sp, "before shell: %d: {%s}\n", len, bp);
  167. #endif
  168.  
  169.     /*
  170.      * Do shell word expansion -- it's very, very hard to figure out what
  171.      * magic characters the user's shell expects.  Historically, it was a
  172.      * union of v7 shell and csh meta characters.  We match that practice
  173.      * by default, so ":read \%" tries to read a file named '%'.  It would
  174.      * make more sense to pass any special characters through the shell,
  175.      * but then, if your shell was csh, the above example will behave
  176.      * differently in nvi than in vi.  If you want to get other characters
  177.      * passed through to your shell, change the "meta" option.
  178.      *
  179.      * To avoid a function call per character, we do a first pass through
  180.      * the meta characters looking for characters that aren't expected
  181.      * to be there, and then we can ignore them in the user's argument.
  182.      */
  183.     if (opts_empty(sp, O_SHELL, 1) || opts_empty(sp, O_SHELLMETA, 1))
  184.         n = 0;
  185.     else {
  186.         for (p = mp = O_STR(sp, O_SHELLMETA); *p != '\0'; ++p)
  187.             if (isblank(*p) || isalnum(*p))
  188.                 break;
  189.         p = bp + SHELLOFFSET;
  190.         n = len - SHELLOFFSET;
  191.         if (*p != '\0') {
  192.             for (; n > 0; --n, ++p)
  193.                 if (strchr(mp, *p) != NULL)
  194.                     break;
  195.         } else
  196.             for (; n > 0; --n, ++p)
  197.                 if (!isblank(*p) &&
  198.                     !isalnum(*p) && strchr(mp, *p) != NULL)
  199.                     break;
  200.     }
  201.  
  202.     /*
  203.      * If we found a meta character in the string, fork a shell to expand
  204.      * it.  Unfortunately, this is comparatively slow.  Historically, it
  205.      * didn't matter much, since users don't enter meta characters as part
  206.      * of pathnames that frequently.  The addition of filename completion
  207.      * broke that assumption because it's easy to use.  As a result, lots
  208.      * folks have complained that the expansion code is too slow.  So, we
  209.      * detect filename completion as a special case, and do it internally.
  210.      * Note that this code assumes that the <asterisk> character is the
  211.      * match-anything meta character.  That feels safe -- if anyone writes
  212.      * a shell that doesn't follow that convention, I'd suggest giving them
  213.      * a festive hot-lead enema.
  214.      */
  215.     switch (n) {
  216.     case 0:
  217.         p = bp + SHELLOFFSET;
  218.         len -= SHELLOFFSET;
  219.         rval = argv_exp3(sp, excp, p, len);
  220.         break;
  221.     case 1:
  222.         if (*p == '*') {
  223.             *p = '\0';
  224.             rval = argv_lexp(sp, excp, bp + SHELLOFFSET);
  225.             break;
  226.         }
  227.         /* FALLTHROUGH */
  228.     default:
  229.         if (argv_sexp(sp, &bp, &blen, &len)) {
  230.             rval = 1;
  231.             goto err;
  232.         }
  233.         p = bp;
  234.         rval = argv_exp3(sp, excp, p, len);
  235.         break;
  236.     }
  237.  
  238. err:    FREE_SPACE(sp, bp, blen);
  239.     return (rval);
  240. }
  241.  
  242. /*
  243.  * argv_exp3 --
  244.  *    Take a string and break it up into an argv, which is appended
  245.  *    to the argument list.
  246.  *
  247.  * PUBLIC: int argv_exp3 __P((SCR *, EXCMD *, char *, size_t));
  248.  */
  249. int
  250. argv_exp3(sp, excp, cmd, cmdlen)
  251.     SCR *sp;
  252.     EXCMD *excp;
  253.     char *cmd;
  254.     size_t cmdlen;
  255. {
  256.     EX_PRIVATE *exp;
  257.     size_t len;
  258.     int ch, off;
  259.     char *ap, *p;
  260.  
  261.     for (exp = EXP(sp); cmdlen > 0; ++exp->argsoff) {
  262.         /* Skip any leading whitespace. */
  263.         for (; cmdlen > 0; --cmdlen, ++cmd) {
  264.             ch = *cmd;
  265.             if (!isblank(ch))
  266.                 break;
  267.         }
  268.         if (cmdlen == 0)
  269.             break;
  270.  
  271.         /*
  272.          * Determine the length of this whitespace delimited
  273.          * argument.
  274.          *
  275.          * QUOTING NOTE:
  276.          *
  277.          * Skip any character preceded by the user's quoting
  278.          * character.
  279.          */
  280.         for (ap = cmd, len = 0; cmdlen > 0; ++cmd, --cmdlen, ++len) {
  281.             ch = *cmd;
  282.             if (IS_ESCAPE(sp, excp, ch) && cmdlen > 1) {
  283.                 ++cmd;
  284.                 --cmdlen;
  285.             } else if (isblank(ch))
  286.                 break;
  287.         }
  288.  
  289.         /*
  290.          * Copy the argument into place.
  291.          *
  292.          * QUOTING NOTE:
  293.          *
  294.          * Lose quote chars.
  295.          */
  296.         argv_alloc(sp, len);
  297.         off = exp->argsoff;
  298.         exp->args[off]->len = len;
  299.         for (p = exp->args[off]->bp; len > 0; --len, *p++ = *ap++)
  300.             if (IS_ESCAPE(sp, excp, *ap))
  301.                 ++ap;
  302.         *p = '\0';
  303.     }
  304.     excp->argv = exp->args;
  305.     excp->argc = exp->argsoff;
  306.  
  307. #if defined(DEBUG) && 0
  308.     for (cnt = 0; cnt < exp->argsoff; ++cnt)
  309.         TRACE(sp, "arg %d: {%s}\n", cnt, exp->argv[cnt]);
  310. #endif
  311.     return (0);
  312. }
  313.  
  314. /*
  315.  * argv_fexp --
  316.  *    Do file name and bang command expansion.
  317.  */
  318. static int
  319. argv_fexp(sp, excp, cmd, cmdlen, p, lenp, bpp, blenp, is_bang)
  320.     SCR *sp;
  321.     EXCMD *excp;
  322.     char *cmd, *p, **bpp;
  323.     size_t cmdlen, *lenp, *blenp;
  324.     int is_bang;
  325. {
  326.     EX_PRIVATE *exp;
  327.     char *bp, *t;
  328.     size_t blen, len, off, tlen;
  329.  
  330.     /* Replace file name characters. */
  331.     for (bp = *bpp, blen = *blenp, len = *lenp; cmdlen > 0; --cmdlen, ++cmd)
  332.         switch (*cmd) {
  333.         case '!':
  334.             if (!is_bang)
  335.                 goto ins_ch;
  336.             exp = EXP(sp);
  337.             if (exp->lastbcomm == NULL) {
  338.                 msgq(sp, M_ERR,
  339.                     "115|No previous command to replace \"!\"");
  340.                 return (1);
  341.             }
  342.             len += tlen = strlen(exp->lastbcomm);
  343.             off = p - bp;
  344.             ADD_SPACE_RET(sp, bp, blen, len);
  345.             p = bp + off;
  346.             memcpy(p, exp->lastbcomm, tlen);
  347.             p += tlen;
  348.             F_SET(excp, E_MODIFY);
  349.             break;
  350.         case '%':
  351.             if ((t = sp->frp->name) == NULL) {
  352.                 msgq(sp, M_ERR,
  353.                     "116|No filename to substitute for %%");
  354.                 return (1);
  355.             }
  356.             tlen = strlen(t);
  357.             len += tlen;
  358.             off = p - bp;
  359.             ADD_SPACE_RET(sp, bp, blen, len);
  360.             p = bp + off;
  361.             memcpy(p, t, tlen);
  362.             p += tlen;
  363.             F_SET(excp, E_MODIFY);
  364.             break;
  365.         case '#':
  366.             if ((t = sp->alt_name) == NULL) {
  367.                 msgq(sp, M_ERR,
  368.                     "117|No filename to substitute for #");
  369.                 return (1);
  370.             }
  371.             len += tlen = strlen(t);
  372.             off = p - bp;
  373.             ADD_SPACE_RET(sp, bp, blen, len);
  374.             p = bp + off;
  375.             memcpy(p, t, tlen);
  376.             p += tlen;
  377.             F_SET(excp, E_MODIFY);
  378.             break;
  379.         case '\\':
  380.             /*
  381.              * QUOTING NOTE:
  382.              *
  383.              * Strip any backslashes that protected the file
  384.              * expansion characters.
  385.              */
  386.             if (cmdlen > 1 &&
  387.                 (cmd[1] == '%' || cmd[1] == '#' || cmd[1] == '!')) {
  388.                 ++cmd;
  389.                 --cmdlen;
  390.             }
  391.             /* FALLTHROUGH */
  392.         default:
  393. ins_ch:            ++len;
  394.             off = p - bp;
  395.             ADD_SPACE_RET(sp, bp, blen, len);
  396.             p = bp + off;
  397.             *p++ = *cmd;
  398.         }
  399.  
  400.     /* Nul termination. */
  401.     ++len;
  402.     off = p - bp;
  403.     ADD_SPACE_RET(sp, bp, blen, len);
  404.     p = bp + off;
  405.     *p = '\0';
  406.  
  407.     /* Return the new string length, buffer, buffer length. */
  408.     *lenp = len - 1;
  409.     *bpp = bp;
  410.     *blenp = blen;
  411.     return (0);
  412. }
  413.  
  414. /*
  415.  * argv_alloc --
  416.  *    Make more space for arguments.
  417.  */
  418. static int
  419. argv_alloc(sp, len)
  420.     SCR *sp;
  421.     size_t len;
  422. {
  423.     ARGS *ap;
  424.     EX_PRIVATE *exp;
  425.     int cnt, off;
  426.  
  427.     /*
  428.      * Allocate room for another argument, always leaving
  429.      * enough room for an ARGS structure with a length of 0.
  430.      */
  431. #define    INCREMENT    20
  432.     exp = EXP(sp);
  433.     off = exp->argsoff;
  434.     if (exp->argscnt == 0 || off + 2 >= exp->argscnt - 1) {
  435.         cnt = exp->argscnt + INCREMENT;
  436.         REALLOC(sp, exp->args, ARGS **, cnt * sizeof(ARGS *));
  437.         if (exp->args == NULL) {
  438.             (void)argv_free(sp);
  439.             goto mem;
  440.         }
  441.         memset(&exp->args[exp->argscnt], 0, INCREMENT * sizeof(ARGS *));
  442.         exp->argscnt = cnt;
  443.     }
  444.  
  445.     /* First argument. */
  446.     if (exp->args[off] == NULL) {
  447.         CALLOC(sp, exp->args[off], ARGS *, 1, sizeof(ARGS));
  448.         if (exp->args[off] == NULL)
  449.             goto mem;
  450.     }
  451.  
  452.     /* First argument buffer. */
  453.     ap = exp->args[off];
  454.     ap->len = 0;
  455.     if (ap->blen < len + 1) {
  456.         ap->blen = len + 1;
  457.         REALLOC(sp, ap->bp, CHAR_T *, ap->blen * sizeof(CHAR_T));
  458.         if (ap->bp == NULL) {
  459.             ap->bp = NULL;
  460.             ap->blen = 0;
  461.             F_CLR(ap, A_ALLOCATED);
  462. mem:            msgq(sp, M_SYSERR, NULL);
  463.             return (1);
  464.         }
  465.         F_SET(ap, A_ALLOCATED);
  466.     }
  467.  
  468.     /* Second argument. */
  469.     if (exp->args[++off] == NULL) {
  470.         CALLOC(sp, exp->args[off], ARGS *, 1, sizeof(ARGS));
  471.         if (exp->args[off] == NULL)
  472.             goto mem;
  473.     }
  474.     /* 0 length serves as end-of-argument marker. */
  475.     exp->args[off]->len = 0;
  476.     return (0);
  477. }
  478.  
  479. /*
  480.  * argv_free --
  481.  *    Free up argument structures.
  482.  *
  483.  * PUBLIC: int argv_free __P((SCR *));
  484.  */
  485. int
  486. argv_free(sp)
  487.     SCR *sp;
  488. {
  489.     EX_PRIVATE *exp;
  490.     int off;
  491.  
  492.     exp = EXP(sp);
  493.     if (exp->args != NULL) {
  494.         for (off = 0; off < exp->argscnt; ++off) {
  495.             if (exp->args[off] == NULL)
  496.                 continue;
  497.             if (F_ISSET(exp->args[off], A_ALLOCATED))
  498.                 free(exp->args[off]->bp);
  499.             free(exp->args[off]);
  500.         }
  501.         free(exp->args);
  502.     }
  503.     exp->args = NULL;
  504.     exp->argscnt = 0;
  505.     exp->argsoff = 0;
  506.     return (0);
  507. }
  508.  
  509. /*
  510.  * argv_lexp --
  511.  *    Find all file names matching the prefix and append them to the
  512.  *    buffer.
  513.  */
  514. static int
  515. argv_lexp(sp, excp, path)
  516.     SCR *sp;
  517.     EXCMD *excp;
  518.     char *path;
  519. {
  520.     struct dirent *dp;
  521.     DIR *dirp;
  522.     EX_PRIVATE *exp;
  523.     int off;
  524.     size_t dlen, len, nlen;
  525.     char *dname, *name, *p;
  526.  
  527.     exp = EXP(sp);
  528.  
  529.     /* Set up the name and length for comparison. */
  530.     if ((p = strrchr(path, '/')) == NULL) {
  531.         dname = ".";
  532.         dlen = 0;
  533.         name = path;
  534.     } else { 
  535.         if (p == path) {
  536.             dname = "/";
  537.             dlen = 1;
  538.         } else {
  539.             *p = '\0';
  540.             dname = path;
  541.             dlen = strlen(path);
  542.         }
  543.         name = p + 1;
  544.     }
  545.     nlen = strlen(name);
  546.  
  547.     /*
  548.      * XXX
  549.      * We don't use the d_namlen field, it's not portable enough; we
  550.      * assume that d_name is nul terminated, instead.
  551.      */
  552.     if ((dirp = opendir(dname)) == NULL) {
  553.         msgq_str(sp, M_SYSERR, dname, "%s");
  554.         return (1);
  555.     }
  556.     for (off = exp->argsoff; (dp = readdir(dirp)) != NULL;) {
  557.         if (nlen == 0) {
  558.             if (dp->d_name[0] == '.')
  559.                 continue;
  560.             len = strlen(dp->d_name);
  561.         } else {
  562.             len = strlen(dp->d_name);
  563.             if (len < nlen || memcmp(dp->d_name, name, nlen))
  564.                 continue;
  565.         }
  566.  
  567.         /* Directory + name + slash + null. */
  568.         argv_alloc(sp, dlen + len + 2);
  569.         p = exp->args[exp->argsoff]->bp;
  570.         if (dlen != 0) {
  571.             memcpy(p, dname, dlen);
  572.             p += dlen;
  573.             if (dlen > 1 || dname[0] != '/')
  574.                 *p++ = '/';
  575.         }
  576.         memcpy(p, dp->d_name, len + 1);
  577.         exp->args[exp->argsoff]->len = dlen + len + 1;
  578.         ++exp->argsoff;
  579.         excp->argv = exp->args;
  580.         excp->argc = exp->argsoff;
  581.     }
  582.     closedir(dirp);
  583.  
  584.     if (off == exp->argsoff) {
  585.         /*
  586.          * If we didn't find a match, complain that the expansion
  587.          * failed.  We can't know for certain that's the error, but
  588.          * it's a good guess, and it matches historic practice. 
  589.          */
  590.         msgq(sp, M_ERR, "304|Shell expansion failed");
  591.         return (1);
  592.     }
  593.     qsort(exp->args + off, exp->argsoff - off, sizeof(ARGS *), argv_comp);
  594.     return (0);
  595. }
  596.  
  597. /*
  598.  * argv_comp --
  599.  *    Alphabetic comparison.
  600.  */
  601. static int
  602. argv_comp(a, b)
  603.     const void *a, *b;
  604. {
  605.     return (strcmp((char *)(*(ARGS **)a)->bp, (char *)(*(ARGS **)b)->bp));
  606. }
  607.  
  608. /*
  609.  * argv_sexp --
  610.  *    Fork a shell, pipe a command through it, and read the output into
  611.  *    a buffer.
  612.  */
  613. static int
  614. argv_sexp(sp, bpp, blenp, lenp)
  615.     SCR *sp;
  616.     char **bpp;
  617.     size_t *blenp, *lenp;
  618. {
  619.     enum { SEXP_ERR, SEXP_EXPANSION_ERR, SEXP_OK } rval;
  620.     FILE *ifp;
  621.     pid_t pid;
  622.     size_t blen, len;
  623.     int ch, std_output[2];
  624.     char *bp, *p, *sh, *sh_path;
  625.  
  626.     /* Secure means no shell access. */
  627.     if (O_ISSET(sp, O_SECURE)) {
  628.         msgq(sp, M_ERR,
  629. "289|Shell expansions not supported when the secure edit option is set");
  630.         return (1);
  631.     }
  632.  
  633.     sh_path = O_STR(sp, O_SHELL);
  634.     if ((sh = strrchr(sh_path, '/')) == NULL)
  635.         sh = sh_path;
  636.     else
  637.         ++sh;
  638.  
  639.     /* Local copies of the buffer variables. */
  640.     bp = *bpp;
  641.     blen = *blenp;
  642.  
  643.     /*
  644.      * There are two different processes running through this code, named
  645.      * the utility (the shell) and the parent. The utility reads standard
  646.      * input and writes standard output and standard error output.  The
  647.      * parent writes to the utility, reads its standard output and ignores
  648.      * its standard error output.  Historically, the standard error output
  649.      * was discarded by vi, as it produces a lot of noise when file patterns
  650.      * don't match.
  651.      *
  652.      * The parent reads std_output[0], and the utility writes std_output[1].
  653.      */
  654.     ifp = NULL;
  655.     std_output[0] = std_output[1] = -1;
  656.     if (pipe(std_output) < 0) {
  657.         msgq(sp, M_SYSERR, "pipe");
  658.         return (1);
  659.     }
  660.     if ((ifp = fdopen(std_output[0], "r")) == NULL) {
  661.         msgq(sp, M_SYSERR, "fdopen");
  662.         goto err;
  663.     }
  664.  
  665.     /*
  666.      * Do the minimal amount of work possible, the shell is going to run
  667.      * briefly and then exit.  We sincerely hope.
  668.      */
  669.     switch (pid = vfork()) {
  670.     case -1:            /* Error. */
  671.         msgq(sp, M_SYSERR, "vfork");
  672. err:        if (ifp != NULL)
  673.             (void)fclose(ifp);
  674.         else if (std_output[0] != -1)
  675.             close(std_output[0]);
  676.         if (std_output[1] != -1)
  677.             close(std_output[0]);
  678.         return (1);
  679.     case 0:                /* Utility. */
  680.         /* Redirect stdout to the write end of the pipe. */
  681.         (void)dup2(std_output[1], STDOUT_FILENO);
  682.  
  683.         /* Close the utility's file descriptors. */
  684.         (void)close(std_output[0]);
  685.         (void)close(std_output[1]);
  686.         (void)close(STDERR_FILENO);
  687.  
  688.         /*
  689.          * XXX
  690.          * Assume that all shells have -c.
  691.          */
  692.         execl(sh_path, sh, "-c", bp, NULL);
  693.         msgq_str(sp, M_SYSERR, sh_path, "118|Error: execl: %s");
  694.         _exit(127);
  695.     default:            /* Parent. */
  696.         /* Close the pipe ends the parent won't use. */
  697.         (void)close(std_output[1]);
  698.         break;
  699.     }
  700.  
  701.     /*
  702.      * Copy process standard output into a buffer.
  703.      *
  704.      * !!!
  705.      * Historic vi apparently discarded leading \n and \r's from
  706.      * the shell output stream.  We don't on the grounds that any
  707.      * shell that does that is broken.
  708.      */
  709.     for (p = bp, len = 0, ch = EOF;
  710.         (ch = getc(ifp)) != EOF; *p++ = ch, --blen, ++len)
  711.         if (blen < 5) {
  712.             ADD_SPACE_GOTO(sp, bp, *blenp, *blenp * 2);
  713.             p = bp + len;
  714.             blen = *blenp - len;
  715.         }
  716.  
  717.     /* Delete the final newline, nul terminate the string. */
  718.     if (p > bp && (p[-1] == '\n' || p[-1] == '\r')) {
  719.         --p;
  720.         --len;
  721.     }
  722.     *p = '\0';
  723.     *lenp = len;
  724.     *bpp = bp;        /* *blenp is already updated. */
  725.  
  726.     if (ferror(ifp))
  727.         goto ioerr;
  728.     if (fclose(ifp)) {
  729. ioerr:        msgq_str(sp, M_ERR, sh, "119|I/O error: %s");
  730. alloc_err:    rval = SEXP_ERR;
  731.     } else
  732.         rval = SEXP_OK;
  733.  
  734.     /*
  735.      * Wait for the process.  If the shell process fails (e.g., "echo $q"
  736.      * where q wasn't a defined variable) or if the returned string has
  737.      * no characters or only blank characters, (e.g., "echo $5"), complain
  738.      * that the shell expansion failed.  We can't know for certain that's
  739.      * the error, but it's a good guess, and it matches historic practice.
  740.      * This won't catch "echo foo_$5", but that's not a common error and
  741.      * historic vi didn't catch it either.
  742.      */
  743.     if (proc_wait(sp, (long)pid, sh, 1, 0))
  744.         rval = SEXP_EXPANSION_ERR;
  745.  
  746.     for (p = bp; len; ++p, --len)
  747.         if (!isblank(*p))
  748.             break;
  749.     if (len == 0)
  750.         rval = SEXP_EXPANSION_ERR;
  751.  
  752.     if (rval == SEXP_EXPANSION_ERR)
  753.         msgq(sp, M_ERR, "304|Shell expansion failed");
  754.  
  755.     return (rval == SEXP_OK ? 0 : 1);
  756. }
  757.