(exec_comm_child): Make sure we actually open /dev/null.
[kopensolaris-gnu/glibc.git] / posix / wordexp.c
1 /* POSIX.2 wordexp implementation.
2    Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Tim Waugh <tim@cyberelk.demon.co.uk>.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 #include <wordexp.h>
22 #include <signal.h>
23 #include <stdlib.h>
24 #include <pwd.h>
25 #include <sys/types.h>
26 #include <string.h>
27 #include <glob.h>
28 #include <ctype.h>
29 #include <sys/time.h>
30 #include <sys/types.h>
31 #include <sys/wait.h>
32 #include <unistd.h>
33 #include <fcntl.h>
34 #include <sys/stat.h>
35 #include <paths.h>
36 #include <errno.h>
37 #include <sys/param.h>
38 #include <stdio.h>
39 #include <fnmatch.h>
40
41 #include <stdio-common/_itoa.h>
42
43 /* Undefine the following line for the production version.  */
44 /* #define NDEBUG 1 */
45 #include <assert.h>
46
47 /* Get some device information.  */
48 #include <device-nrs.h>
49
50 /*
51  * This is a recursive-descent-style word expansion routine.
52  */
53
54 /* These variables are defined and initialized in the startup code.  */
55 extern int __libc_argc;
56 extern char **__libc_argv;
57
58 /* Some forward declarations */
59 static int parse_dollars (char **word, size_t *word_length, size_t *max_length,
60                           const char *words, size_t *offset, int flags,
61                           wordexp_t *pwordexp, const char *ifs,
62                           const char *ifs_white, int quoted)
63      internal_function;
64 static int parse_backtick (char **word, size_t *word_length,
65                            size_t *max_length, const char *words,
66                            size_t *offset, int flags, wordexp_t *pwordexp,
67                            const char *ifs, const char *ifs_white)
68      internal_function;
69 static int parse_dquote (char **word, size_t *word_length, size_t *max_length,
70                          const char *words, size_t *offset, int flags,
71                          wordexp_t *pwordexp, const char *ifs,
72                          const char *ifs_white)
73      internal_function;
74 static int eval_expr (char *expr, long int *result) internal_function;
75
76 /* The w_*() functions manipulate word lists. */
77
78 #define W_CHUNK (100)
79
80 /* Result of w_newword will be ignored if it's the last word. */
81 static inline char *
82 w_newword (size_t *actlen, size_t *maxlen)
83 {
84   *actlen = *maxlen = 0;
85   return NULL;
86 }
87
88 static inline char *
89 w_addchar (char *buffer, size_t *actlen, size_t *maxlen, char ch)
90      /* (lengths exclude trailing zero) */
91 {
92   /* Add a character to the buffer, allocating room for it if needed.
93    */
94
95   if (*actlen == *maxlen)
96     {
97       char *old_buffer = buffer;
98       assert (buffer == NULL || *maxlen != 0);
99       *maxlen += W_CHUNK;
100       buffer = realloc (buffer, 1 + *maxlen);
101
102       if (buffer == NULL)
103         free (old_buffer);
104     }
105
106   if (buffer != NULL)
107     {
108       buffer[*actlen] = ch;
109       buffer[++(*actlen)] = '\0';
110     }
111
112   return buffer;
113 }
114
115 static char *
116 internal_function
117 w_addmem (char *buffer, size_t *actlen, size_t *maxlen, const char *str,
118           size_t len)
119 {
120   /* Add a string to the buffer, allocating room for it if needed.
121    */
122   if (*actlen + len > *maxlen)
123     {
124       char *old_buffer = buffer;
125       assert (buffer == NULL || *maxlen != 0);
126       *maxlen += MAX (2 * len, W_CHUNK);
127       buffer = realloc (old_buffer, 1 + *maxlen);
128
129       if (buffer == NULL)
130         free (old_buffer);
131     }
132
133   if (buffer != NULL)
134     {
135       *((char *) __mempcpy (&buffer[*actlen], str, len)) = '\0';
136       *actlen += len;
137     }
138
139   return buffer;
140 }
141
142 static char *
143 internal_function
144 w_addstr (char *buffer, size_t *actlen, size_t *maxlen, const char *str)
145      /* (lengths exclude trailing zero) */
146 {
147   /* Add a string to the buffer, allocating room for it if needed.
148    */
149   size_t len;
150
151   assert (str != NULL); /* w_addstr only called from this file */
152   len = strlen (str);
153
154   return w_addmem (buffer, actlen, maxlen, str, len);
155 }
156
157 static int
158 internal_function
159 w_addword (wordexp_t *pwordexp, char *word)
160 {
161   /* Add a word to the wordlist */
162   size_t num_p;
163   char **new_wordv;
164
165   /* Internally, NULL acts like "".  Convert NULLs to "" before
166    * the caller sees them.
167    */
168   if (word == NULL)
169     {
170       word = __strdup ("");
171       if (word == NULL)
172         goto no_space;
173     }
174
175   num_p = 2 + pwordexp->we_wordc + pwordexp->we_offs;
176   new_wordv = realloc (pwordexp->we_wordv, sizeof (char *) * num_p);
177   if (new_wordv != NULL)
178     {
179       pwordexp->we_wordv = new_wordv;
180       pwordexp->we_wordv[pwordexp->we_offs + pwordexp->we_wordc++] = word;
181       pwordexp->we_wordv[pwordexp->we_offs + pwordexp->we_wordc] = NULL;
182       return 0;
183     }
184
185 no_space:
186   return WRDE_NOSPACE;
187 }
188
189 /* The parse_*() functions should leave *offset being the offset in 'words'
190  * to the last character processed.
191  */
192
193 static int
194 internal_function
195 parse_backslash (char **word, size_t *word_length, size_t *max_length,
196                  const char *words, size_t *offset)
197 {
198   /* We are poised _at_ a backslash, not in quotes */
199
200   switch (words[1 + *offset])
201     {
202     case 0:
203       /* Backslash is last character of input words */
204       return WRDE_SYNTAX;
205
206     case '\n':
207       ++(*offset);
208       break;
209
210     default:
211       *word = w_addchar (*word, word_length, max_length, words[1 + *offset]);
212       if (*word == NULL)
213         return WRDE_NOSPACE;
214
215       ++(*offset);
216       break;
217     }
218
219   return 0;
220 }
221
222 static int
223 internal_function
224 parse_qtd_backslash (char **word, size_t *word_length, size_t *max_length,
225                      const char *words, size_t *offset)
226 {
227   /* We are poised _at_ a backslash, inside quotes */
228
229   switch (words[1 + *offset])
230     {
231     case 0:
232       /* Backslash is last character of input words */
233       return WRDE_SYNTAX;
234
235     case '\n':
236       ++(*offset);
237       break;
238
239     case '$':
240     case '`':
241     case '"':
242     case '\\':
243       *word = w_addchar (*word, word_length, max_length, words[1 + *offset]);
244       if (*word == NULL)
245         return WRDE_NOSPACE;
246
247       ++(*offset);
248       break;
249
250     default:
251       *word = w_addchar (*word, word_length, max_length, words[*offset]);
252       if (*word != NULL)
253         *word = w_addchar (*word, word_length, max_length, words[1 + *offset]);
254
255       if (*word == NULL)
256         return WRDE_NOSPACE;
257
258       ++(*offset);
259       break;
260     }
261
262   return 0;
263 }
264
265 static int
266 internal_function
267 parse_tilde (char **word, size_t *word_length, size_t *max_length,
268              const char *words, size_t *offset, size_t wordc)
269 {
270   /* We are poised _at_ a tilde */
271   size_t i;
272
273   if (*word_length != 0)
274     {
275       if (!((*word)[*word_length - 1] == '=' && wordc == 0))
276         {
277           if (!((*word)[*word_length - 1] == ':'
278                 && strchr (*word, '=') && wordc == 0))
279             {
280               *word = w_addchar (*word, word_length, max_length, '~');
281               return *word ? 0 : WRDE_NOSPACE;
282             }
283         }
284     }
285
286   for (i = 1 + *offset; words[i]; i++)
287     {
288       if (words[i] == ':' || words[i] == '/' || words[i] == ' ' ||
289           words[i] == '\t' || words[i] == 0 )
290         break;
291
292       if (words[i] == '\\')
293         {
294           *word = w_addchar (*word, word_length, max_length, '~');
295           return *word ? 0 : WRDE_NOSPACE;
296         }
297     }
298
299   if (i == 1 + *offset)
300     {
301       /* Tilde appears on its own */
302       uid_t uid;
303       struct passwd pwd, *tpwd;
304       int buflen = 1000;
305       char* home;
306       char* buffer;
307       int result;
308
309       /* POSIX.2 says ~ expands to $HOME and if HOME is unset the
310          results are unspecified.  We do a lookup on the uid if
311          HOME is unset. */
312
313       home = getenv ("HOME");
314       if (home != NULL)
315         {
316           *word = w_addstr (*word, word_length, max_length, home);
317           if (*word == NULL)
318             return WRDE_NOSPACE;
319         }
320       else
321         {
322           uid = __getuid ();
323           buffer = __alloca (buflen);
324
325           while ((result = __getpwuid_r (uid, &pwd, buffer, buflen, &tpwd)) != 0
326                  && errno == ERANGE)
327             {
328               buflen += 1000;
329               buffer = __alloca (buflen);
330             }
331
332           if (result == 0 && tpwd != NULL && pwd.pw_dir != NULL)
333             {
334               *word = w_addstr (*word, word_length, max_length, pwd.pw_dir);
335               if (*word == NULL)
336                 return WRDE_NOSPACE;
337             }
338           else
339             {
340               *word = w_addchar (*word, word_length, max_length, '~');
341               if (*word == NULL)
342                 return WRDE_NOSPACE;
343             }
344         }
345     }
346   else
347     {
348       /* Look up user name in database to get home directory */
349       char *user = __strndup (&words[1 + *offset], i - (1 + *offset));
350       struct passwd pwd, *tpwd;
351       int buflen = 1000;
352       char* buffer = __alloca (buflen);
353       int result;
354
355       while ((result = __getpwnam_r (user, &pwd, buffer, buflen, &tpwd)) != 0
356              && errno == ERANGE)
357         {
358           buflen += 1000;
359           buffer = __alloca (buflen);
360         }
361
362       if (result == 0 && tpwd != NULL && pwd.pw_dir)
363         *word = w_addstr (*word, word_length, max_length, pwd.pw_dir);
364       else
365         {
366           /* (invalid login name) */
367           *word = w_addchar (*word, word_length, max_length, '~');
368           if (*word != NULL)
369             *word = w_addstr (*word, word_length, max_length, user);
370         }
371
372       *offset = i - 1;
373     }
374   return *word ? 0 : WRDE_NOSPACE;
375 }
376
377
378 static int
379 internal_function
380 do_parse_glob (const char *glob_word, char **word, size_t *word_length,
381                size_t *max_length, wordexp_t *pwordexp, const char *ifs,
382                const char *ifs_white)
383 {
384   int error;
385   int match;
386   glob_t globbuf;
387
388   error = glob (glob_word, GLOB_NOCHECK, NULL, &globbuf);
389
390   if (error != 0)
391     {
392       /* We can only run into memory problems.  */
393       assert (error == GLOB_NOSPACE);
394       return WRDE_NOSPACE;
395     }
396
397   if (ifs && !*ifs)
398     {
399       /* No field splitting allowed. */
400       assert (globbuf.gl_pathv[0] != NULL);
401       *word = w_addstr (*word, word_length, max_length, globbuf.gl_pathv[0]);
402       for (match = 1; match < globbuf.gl_pathc && *word != NULL; ++match)
403         {
404           *word = w_addchar (*word, word_length, max_length, ' ');
405           if (*word != NULL)
406             *word = w_addstr (*word, word_length, max_length,
407                               globbuf.gl_pathv[match]);
408         }
409
410       globfree (&globbuf);
411       return *word ? 0 : WRDE_NOSPACE;
412     }
413
414   assert (ifs == NULL || *ifs != '\0');
415   if (*word != NULL)
416     {
417       free (*word);
418       *word = w_newword (word_length, max_length);
419     }
420
421   for (match = 0; match < globbuf.gl_pathc; ++match)
422     {
423       char *matching_word = __strdup (globbuf.gl_pathv[match]);
424       if (matching_word == NULL || w_addword (pwordexp, matching_word))
425         {
426           globfree (&globbuf);
427           return WRDE_NOSPACE;
428         }
429     }
430
431   globfree (&globbuf);
432   return 0;
433 }
434
435 static int
436 internal_function
437 parse_glob (char **word, size_t *word_length, size_t *max_length,
438             const char *words, size_t *offset, int flags,
439             wordexp_t *pwordexp, const char *ifs, const char *ifs_white)
440 {
441   /* We are poised just after a '*', a '[' or a '?'. */
442   int error = WRDE_NOSPACE;
443   int quoted = 0; /* 1 if singly-quoted, 2 if doubly */
444   int i;
445   wordexp_t glob_list; /* List of words to glob */
446
447   glob_list.we_wordc = 0;
448   glob_list.we_wordv = NULL;
449   glob_list.we_offs = 0;
450   for (; words[*offset] != '\0'; ++*offset)
451     {
452       if ((ifs && strchr (ifs, words[*offset])) ||
453           (!ifs && strchr (" \t\n", words[*offset])))
454         /* Reached IFS */
455         break;
456
457       /* Sort out quoting */
458       if (words[*offset] == '\'')
459         {
460           if (quoted == 0)
461             {
462               quoted = 1;
463               continue;
464             }
465           else if (quoted == 1)
466             {
467               quoted = 0;
468               continue;
469             }
470         }
471       else if (words[*offset] == '"')
472         {
473           if (quoted == 0)
474             {
475               quoted = 2;
476               continue;
477             }
478           else if (quoted == 2)
479             {
480               quoted = 0;
481               continue;
482             }
483         }
484
485       /* Sort out other special characters */
486       if (quoted != 1 && words[*offset] == '$')
487         {
488           error = parse_dollars (word, word_length, max_length, words,
489                                  offset, flags, &glob_list, ifs, ifs_white,
490                                  quoted == 2);
491           if (error)
492             goto tidy_up;
493
494           continue;
495         }
496       else if (words[*offset] == '\\')
497         {
498           if (quoted)
499             error = parse_qtd_backslash (word, word_length, max_length,
500                                          words, offset);
501           else
502             error = parse_backslash (word, word_length, max_length,
503                                      words, offset);
504
505           if (error)
506             goto tidy_up;
507
508           continue;
509         }
510
511       *word = w_addchar (*word, word_length, max_length, words[*offset]);
512       if (*word == NULL)
513         goto tidy_up;
514     }
515
516   /* Don't forget to re-parse the character we stopped at. */
517   --*offset;
518
519   /* Glob the words */
520   error = w_addword (&glob_list, *word);
521   *word = w_newword (word_length, max_length);
522   for (i = 0; error == 0 && i < glob_list.we_wordc; i++)
523     error = do_parse_glob (glob_list.we_wordv[i], word, word_length,
524                            max_length, pwordexp, ifs, ifs_white);
525
526   /* Now tidy up */
527 tidy_up:
528   wordfree (&glob_list);
529   return error;
530 }
531
532 static int
533 internal_function
534 parse_squote (char **word, size_t *word_length, size_t *max_length,
535               const char *words, size_t *offset)
536 {
537   /* We are poised just after a single quote */
538   for (; words[*offset]; ++(*offset))
539     {
540       if (words[*offset] != '\'')
541         {
542           *word = w_addchar (*word, word_length, max_length, words[*offset]);
543           if (*word == NULL)
544             return WRDE_NOSPACE;
545         }
546       else return 0;
547     }
548
549   /* Unterminated string */
550   return WRDE_SYNTAX;
551 }
552
553 /* Functions to evaluate an arithmetic expression */
554 static int
555 internal_function
556 eval_expr_val (char **expr, long int *result)
557 {
558   int sgn = +1;
559   char *digit;
560
561   /* Skip white space */
562   for (digit = *expr; digit && *digit && isspace (*digit); ++digit);
563
564   switch (*digit)
565     {
566     case '(':
567
568       /* Scan for closing paren */
569       for (++digit; **expr && **expr != ')'; ++(*expr));
570
571       /* Is there one? */
572       if (!**expr)
573         return WRDE_SYNTAX;
574
575       *(*expr)++ = 0;
576
577       if (eval_expr (digit, result))
578         return WRDE_SYNTAX;
579
580       return 0;
581
582     case '+':   /* Positive value */
583       ++digit;
584       break;
585
586     case '-':   /* Negative value */
587       ++digit;
588       sgn = -1;
589       break;
590
591     default:
592       if (!isdigit (*digit))
593         return WRDE_SYNTAX;
594     }
595
596   *result = 0;
597   for (; *digit && isdigit (*digit); ++digit)
598     *result = (*result * 10) + (*digit - '0');
599
600   *expr = digit;
601   *result *= sgn;
602   return 0;
603 }
604
605 static int
606 internal_function
607 eval_expr_multdiv (char **expr, long int *result)
608 {
609   long int arg;
610
611   /* Read a Value */
612   if (eval_expr_val (expr, result) != 0)
613     return WRDE_SYNTAX;
614
615   while (**expr)
616     {
617       /* Skip white space */
618       for (; *expr && **expr && isspace (**expr); ++(*expr));
619
620       if (**expr == '*')
621         {
622           ++(*expr);
623           if (eval_expr_val (expr, &arg) != 0)
624             return WRDE_SYNTAX;
625
626           *result *= arg;
627         }
628       else if (**expr == '/')
629         {
630           ++(*expr);
631           if (eval_expr_val (expr, &arg) != 0)
632             return WRDE_SYNTAX;
633
634           *result /= arg;
635         }
636       else break;
637     }
638
639   return 0;
640 }
641
642 static int
643 internal_function
644 eval_expr (char *expr, long int *result)
645 {
646   long int arg;
647
648   /* Read a Multdiv */
649   if (eval_expr_multdiv (&expr, result) != 0)
650     return WRDE_SYNTAX;
651
652   while (*expr)
653     {
654       /* Skip white space */
655       for (; expr && *expr && isspace (*expr); ++expr);
656
657       if (*expr == '+')
658         {
659           ++expr;
660           if (eval_expr_multdiv (&expr, &arg) != 0)
661             return WRDE_SYNTAX;
662
663           *result += arg;
664         }
665       else if (*expr == '-')
666         {
667           ++expr;
668           if (eval_expr_multdiv (&expr, &arg) != 0)
669             return WRDE_SYNTAX;
670
671           *result -= arg;
672         }
673       else break;
674     }
675
676   return 0;
677 }
678
679 static int
680 internal_function
681 parse_arith (char **word, size_t *word_length, size_t *max_length,
682              const char *words, size_t *offset, int flags, int bracket)
683 {
684   /* We are poised just after "$((" or "$[" */
685   int error;
686   int paren_depth = 1;
687   size_t expr_length;
688   size_t expr_maxlen;
689   char *expr;
690
691   expr = w_newword (&expr_length, &expr_maxlen);
692   for (; words[*offset]; ++(*offset))
693     {
694       switch (words[*offset])
695         {
696         case '$':
697           error = parse_dollars (&expr, &expr_length, &expr_maxlen,
698                                  words, offset, flags, NULL, NULL, NULL, 1);
699           /* The ``1'' here is to tell parse_dollars not to
700            * split the fields.
701            */
702           if (error)
703             {
704               free (expr);
705               return error;
706             }
707           break;
708
709         case '`':
710           (*offset)++;
711           error = parse_backtick (&expr, &expr_length, &expr_maxlen,
712                                   words, offset, flags, NULL, NULL, NULL);
713           /* The first NULL here is to tell parse_backtick not to
714            * split the fields.
715            */
716           if (error)
717             {
718               free (expr);
719               return error;
720             }
721           break;
722
723         case '\\':
724           error = parse_qtd_backslash (&expr, &expr_length, &expr_maxlen,
725                                        words, offset);
726           if (error)
727             {
728               free (expr);
729               return error;
730             }
731           /* I think that a backslash within an
732            * arithmetic expansion is bound to
733            * cause an error sooner or later anyway though.
734            */
735           break;
736
737         case ')':
738           if (--paren_depth == 0)
739             {
740               char result[21];  /* 21 = ceil(log10(2^64)) + 1 */
741               long int numresult = 0;
742               long long int convertme;
743
744               if (bracket || words[1 + *offset] != ')')
745                 {
746                   free (expr);
747                   return WRDE_SYNTAX;
748                 }
749
750               ++(*offset);
751
752               /* Go - evaluate. */
753               if (*expr && eval_expr (expr, &numresult) != 0)
754                 {
755                   free (expr);
756                   return WRDE_SYNTAX;
757                 }
758
759               if (numresult < 0)
760                 {
761                   convertme = -numresult;
762                   *word = w_addchar (*word, word_length, max_length, '-');
763                   if (!*word)
764                     {
765                       free (expr);
766                       return WRDE_NOSPACE;
767                     }
768                 }
769               else
770                 convertme = numresult;
771
772               result[20] = '\0';
773               *word = w_addstr (*word, word_length, max_length,
774                                 _itoa (convertme, &result[20], 10, 0));
775               free (expr);
776               return *word ? 0 : WRDE_NOSPACE;
777             }
778           expr = w_addchar (expr, &expr_length, &expr_maxlen, words[*offset]);
779           if (expr == NULL)
780             return WRDE_NOSPACE;
781
782           break;
783
784         case ']':
785           if (bracket && paren_depth == 1)
786             {
787               char result[21];  /* 21 = ceil(log10(2^64)) + 1 */
788               long int numresult = 0;
789
790               /* Go - evaluate. */
791               if (*expr && eval_expr (expr, &numresult) != 0)
792                 {
793                   free (expr);
794                   return WRDE_SYNTAX;
795                 }
796
797               result[20] = '\0';
798               *word = w_addstr (*word, word_length, max_length,
799                                 _itoa_word (numresult, &result[20], 10, 0));
800               free (expr);
801               return *word ? 0 : WRDE_NOSPACE;
802             }
803
804           free (expr);
805           return WRDE_SYNTAX;
806
807         case '\n':
808         case ';':
809         case '{':
810         case '}':
811           free (expr);
812           return WRDE_BADCHAR;
813
814         case '(':
815           ++paren_depth;
816         default:
817           expr = w_addchar (expr, &expr_length, &expr_maxlen, words[*offset]);
818           if (expr == NULL)
819             return WRDE_NOSPACE;
820         }
821     }
822
823   /* Premature end */
824   free (expr);
825   return WRDE_SYNTAX;
826 }
827
828 /* Function called by child process in exec_comm() */
829 static void
830 internal_function
831 exec_comm_child (char *comm, int *fildes, int showerr, int noexec)
832 {
833   const char *args[4] = { _PATH_BSHELL, "-c", comm, NULL };
834
835   /* Execute the command, or just check syntax? */
836   if (noexec)
837     args[1] = "-nc";
838
839   /* Redirect output.  */
840   __dup2 (fildes[1], 1);
841   __close (fildes[1]);
842
843   /* Redirect stderr to /dev/null if we have to.  */
844   if (showerr == 0)
845     {
846       struct stat64 st;
847       int fd;
848       __close (2);
849       fd = __open (_PATH_DEVNULL, O_WRONLY);
850       if (fd >= 0 && fd != 2)
851         {
852           __dup2 (fd, 2);
853           __close (fd);
854         }
855       /* Be paranoid.  Check that we actually opened the /dev/null
856          device.  */
857       if (__builtin_expect (__fxstat64 (_STAT_VER, 2, &st), 0) != 0
858           || __builtin_expect (S_ISCHR (st.st_mode), 1) == 0
859 #if defined DEV_NULL_MAJOR && defined DEV_NULL_MINOR
860           || st.st_rdev != makedev (DEV_NULL_MAJOR, DEV_NULL_MINOR)
861 #endif
862           )
863         /* It's not the /dev/null device.  Stop right here.  The
864            problem is: how do we stop?  We use _exit() with an
865            hopefully unusual exit code.  */
866         _exit (90);
867     }
868
869   /* Make sure the subshell doesn't field-split on our behalf. */
870   __unsetenv ("IFS");
871
872   __close (fildes[0]);
873   __execve (_PATH_BSHELL, (char *const *) args, __environ);
874
875   /* Bad.  What now?  */
876   abort ();
877 }
878
879 /* Function to execute a command and retrieve the results */
880 /* pwordexp contains NULL if field-splitting is forbidden */
881 static int
882 internal_function
883 exec_comm (char *comm, char **word, size_t *word_length, size_t *max_length,
884            int flags, wordexp_t *pwordexp, const char *ifs,
885            const char *ifs_white)
886 {
887   int fildes[2];
888   int bufsize = 128;
889   int buflen;
890   int i;
891   int status = 0;
892   size_t maxnewlines = 0;
893   char *buffer;
894   pid_t pid;
895
896   /* Don't fork() unless necessary */
897   if (!comm || !*comm)
898     return 0;
899
900   if (__pipe (fildes))
901     /* Bad */
902     return WRDE_NOSPACE;
903
904   if ((pid = __fork ()) < 0)
905     {
906       /* Bad */
907       __close (fildes[0]);
908       __close (fildes[1]);
909       return WRDE_NOSPACE;
910     }
911
912   if (pid == 0)
913     exec_comm_child(comm, fildes, (flags & WRDE_SHOWERR), 0);
914
915   /* Parent */
916
917   __close (fildes[1]);
918   buffer = __alloca (bufsize);
919
920   if (!pwordexp)
921     /* Quoted - no field splitting */
922     {
923       while (1)
924         {
925           if ((buflen = __read (fildes[0], buffer, bufsize)) < 1)
926             {
927               if (__waitpid (pid, &status, WNOHANG) == 0)
928                 continue;
929               if ((buflen = __read (fildes[0], buffer, bufsize)) < 1)
930                 break;
931             }
932
933           maxnewlines += buflen;
934
935           *word = w_addmem (*word, word_length, max_length, buffer, buflen);
936           if (*word == NULL)
937             goto no_space;
938         }
939     }
940   else
941     /* Not quoted - split fields */
942     {
943       int copying = 0;
944       /* 'copying' is:
945        *  0 when searching for first character in a field not IFS white space
946        *  1 when copying the text of a field
947        *  2 when searching for possible non-whitespace IFS
948        *  3 when searching for non-newline after copying field
949        */
950
951       while (1)
952         {
953           if ((buflen = __read (fildes[0], buffer, bufsize)) < 1)
954             {
955               if (__waitpid (pid, &status, WNOHANG) == 0)
956                 continue;
957               if ((buflen = __read (fildes[0], buffer, bufsize)) < 1)
958                 break;
959             }
960
961           for (i = 0; i < buflen; ++i)
962             {
963               if (strchr (ifs, buffer[i]) != NULL)
964                 {
965                   /* Current character is IFS */
966                   if (strchr (ifs_white, buffer[i]) == NULL)
967                     {
968                       /* Current character is IFS but not whitespace */
969                       if (copying == 2)
970                         {
971                           /*            current character
972                            *                   |
973                            *                   V
974                            * eg: text<space><comma><space>moretext
975                            *
976                            * So, strip whitespace IFS (like at the start)
977                            */
978                           copying = 0;
979                           continue;
980                         }
981
982                       copying = 0;
983                       /* fall through and delimit field.. */
984                     }
985                   else
986                     {
987                       if (buffer[i] == '\n')
988                         {
989                           /* Current character is (IFS) newline */
990
991                           /* If copying a field, this is the end of it,
992                              but maybe all that's left is trailing newlines.
993                              So start searching for a non-newline. */
994                           if (copying == 1)
995                             copying = 3;
996
997                           continue;
998                         }
999                       else
1000                         {
1001                           /* Current character is IFS white space, but
1002                              not a newline */
1003
1004                           /* If not either copying a field or searching
1005                              for non-newline after a field, ignore it */
1006                           if (copying != 1 && copying != 3)
1007                             continue;
1008
1009                           /* End of field (search for non-ws IFS afterwards) */
1010                           copying = 2;
1011                         }
1012                     }
1013
1014                   /* First IFS white space (non-newline), or IFS non-whitespace.
1015                    * Delimit the field.  Nulls are converted by w_addword. */
1016                   if (w_addword (pwordexp, *word) == WRDE_NOSPACE)
1017                     goto no_space;
1018
1019                   *word = w_newword (word_length, max_length);
1020
1021                   maxnewlines = 0;
1022                   /* fall back round the loop.. */
1023                 }
1024               else
1025                 {
1026                   /* Not IFS character */
1027
1028                   if (copying == 3)
1029                     {
1030                       /* Nothing but (IFS) newlines since the last field,
1031                          so delimit it here before starting new word */
1032                       if (w_addword (pwordexp, *word) == WRDE_NOSPACE)
1033                         goto no_space;
1034
1035                       *word = w_newword (word_length, max_length);
1036                     }
1037
1038                   copying = 1;
1039
1040                   if (buffer[i] == '\n') /* happens if newline not in IFS */
1041                     maxnewlines++;
1042                   else
1043                     maxnewlines = 0;
1044
1045                   *word = w_addchar (*word, word_length, max_length,
1046                                      buffer[i]);
1047                   if (*word == NULL)
1048                     goto no_space;
1049                 }
1050             }
1051         }
1052     }
1053
1054   /* Chop off trailing newlines (required by POSIX.2)  */
1055   /* Ensure we don't go back further than the beginning of the
1056      substitution (i.e. remove maxnewlines bytes at most) */
1057   while (maxnewlines-- != 0 &&
1058          *word_length > 0 && (*word)[*word_length - 1] == '\n')
1059     {
1060       (*word)[--*word_length] = '\0';
1061
1062       /* If the last word was entirely newlines, turn it into a new word
1063        * which can be ignored if there's nothing following it. */
1064       if (*word_length == 0)
1065         {
1066           free (*word);
1067           *word = w_newword (word_length, max_length);
1068           break;
1069         }
1070     }
1071
1072   __close (fildes[0]);
1073
1074   /* Check for syntax error (re-execute but with "-n" flag) */
1075   if (buflen < 1 && status != 0)
1076     {
1077       if ((pid = __fork ()) < 0)
1078         {
1079           /* Bad */
1080           return WRDE_NOSPACE;
1081         }
1082
1083       if (pid == 0)
1084         {
1085           fildes[0] = fildes[1] = -1;
1086           exec_comm_child(comm, fildes, 0, 1);
1087         }
1088
1089       if (__waitpid (pid, &status, 0) == pid && status != 0)
1090         return WRDE_SYNTAX;
1091     }
1092
1093   return 0;
1094
1095 no_space:
1096   __kill (pid, SIGKILL);
1097   __waitpid (pid, NULL, 0);
1098   __close (fildes[0]);
1099   return WRDE_NOSPACE;
1100 }
1101
1102 static int
1103 internal_function
1104 parse_comm (char **word, size_t *word_length, size_t *max_length,
1105             const char *words, size_t *offset, int flags, wordexp_t *pwordexp,
1106             const char *ifs, const char *ifs_white)
1107 {
1108   /* We are poised just after "$(" */
1109   int paren_depth = 1;
1110   int error = 0;
1111   int quoted = 0; /* 1 for singly-quoted, 2 for doubly-quoted */
1112   size_t comm_length;
1113   size_t comm_maxlen;
1114   char *comm = w_newword (&comm_length, &comm_maxlen);
1115
1116   for (; words[*offset]; ++(*offset))
1117     {
1118       switch (words[*offset])
1119         {
1120         case '\'':
1121           if (quoted == 0)
1122             quoted = 1;
1123           else if (quoted == 1)
1124             quoted = 0;
1125
1126           break;
1127
1128         case '"':
1129           if (quoted == 0)
1130             quoted = 2;
1131           else if (quoted == 2)
1132             quoted = 0;
1133
1134           break;
1135
1136         case ')':
1137           if (!quoted && --paren_depth == 0)
1138             {
1139               /* Go -- give script to the shell */
1140               if (comm)
1141                 {
1142                   error = exec_comm (comm, word, word_length, max_length,
1143                                      flags, pwordexp, ifs, ifs_white);
1144                   free (comm);
1145                 }
1146
1147               return error;
1148             }
1149
1150           /* This is just part of the script */
1151           break;
1152
1153         case '(':
1154           if (!quoted)
1155             ++paren_depth;
1156         }
1157
1158       comm = w_addchar (comm, &comm_length, &comm_maxlen, words[*offset]);
1159       if (comm == NULL)
1160         return WRDE_NOSPACE;
1161     }
1162
1163   /* Premature end */
1164   if (comm)
1165     free (comm);
1166
1167   return WRDE_SYNTAX;
1168 }
1169
1170 static int
1171 internal_function
1172 parse_param (char **word, size_t *word_length, size_t *max_length,
1173              const char *words, size_t *offset, int flags, wordexp_t *pwordexp,
1174              const char *ifs, const char *ifs_white, int quoted)
1175 {
1176   /* We are poised just after "$" */
1177   enum action
1178   {
1179     ACT_NONE,
1180     ACT_RP_SHORT_LEFT = '#',
1181     ACT_RP_LONG_LEFT = 'L',
1182     ACT_RP_SHORT_RIGHT = '%',
1183     ACT_RP_LONG_RIGHT = 'R',
1184     ACT_NULL_ERROR = '?',
1185     ACT_NULL_SUBST = '-',
1186     ACT_NONNULL_SUBST = '+',
1187     ACT_NULL_ASSIGN = '='
1188   };
1189   size_t env_length;
1190   size_t env_maxlen;
1191   size_t pat_length;
1192   size_t pat_maxlen;
1193   size_t start = *offset;
1194   char *env;
1195   char *pattern;
1196   char *value = NULL;
1197   enum action action = ACT_NONE;
1198   int depth = 0;
1199   int colon_seen = 0;
1200   int seen_hash = 0;
1201   int free_value = 0;
1202   int pattern_is_quoted = 0; /* 1 for singly-quoted, 2 for doubly-quoted */
1203   int error;
1204   int special = 0;
1205   char buffer[21];
1206   int brace = words[*offset] == '{';
1207
1208   env = w_newword (&env_length, &env_maxlen);
1209   pattern = w_newword (&pat_length, &pat_maxlen);
1210
1211   if (brace)
1212     ++*offset;
1213
1214   /* First collect the parameter name. */
1215
1216   if (words[*offset] == '#')
1217     {
1218       seen_hash = 1;
1219       if (!brace)
1220         goto envsubst;
1221       ++*offset;
1222     }
1223
1224   if (isalpha (words[*offset]) || words[*offset] == '_')
1225     {
1226       /* Normal parameter name. */
1227       do
1228         {
1229           env = w_addchar (env, &env_length, &env_maxlen,
1230                            words[*offset]);
1231           if (env == NULL)
1232             goto no_space;
1233         }
1234       while (isalnum (words[++*offset]) || words[*offset] == '_');
1235     }
1236   else if (isdigit (words[*offset]))
1237     {
1238       /* Numeric parameter name. */
1239       special = 1;
1240       do
1241         {
1242           env = w_addchar (env, &env_length, &env_maxlen,
1243                            words[*offset]);
1244           if (env == NULL)
1245             goto no_space;
1246           if (!brace)
1247             goto envsubst;
1248         }
1249       while (isdigit(words[++*offset]));
1250     }
1251   else if (strchr ("*@$", words[*offset]) != NULL)
1252     {
1253       /* Special parameter. */
1254       special = 1;
1255       env = w_addchar (env, &env_length, &env_maxlen,
1256                        words[*offset]);
1257       if (env == NULL)
1258         goto no_space;
1259       ++*offset;
1260     }
1261   else
1262     {
1263       if (brace)
1264         goto syntax;
1265     }
1266
1267   if (brace)
1268     {
1269       /* Check for special action to be applied to the value. */
1270       switch (words[*offset])
1271         {
1272         case '}':
1273           /* Evaluate. */
1274           goto envsubst;
1275
1276         case '#':
1277           action = ACT_RP_SHORT_LEFT;
1278           if (words[1 + *offset] == '#')
1279             {
1280               ++*offset;
1281               action = ACT_RP_LONG_LEFT;
1282             }
1283           break;
1284
1285         case '%':
1286           action = ACT_RP_SHORT_RIGHT;
1287           if (words[1 + *offset] == '%')
1288             {
1289               ++*offset;
1290               action = ACT_RP_LONG_RIGHT;
1291             }
1292           break;
1293
1294         case ':':
1295           if (strchr ("-=?+", words[1 + *offset]) == NULL)
1296             goto syntax;
1297
1298           colon_seen = 1;
1299           action = words[++*offset];
1300           break;
1301
1302         case '-':
1303         case '=':
1304         case '?':
1305         case '+':
1306           action = words[*offset];
1307           break;
1308
1309         default:
1310           goto syntax;
1311         }
1312
1313       /* Now collect the pattern, but don't expand it yet. */
1314       ++*offset;
1315       for (; words[*offset]; ++(*offset))
1316         {
1317           switch (words[*offset])
1318             {
1319             case '{':
1320               if (!pattern_is_quoted)
1321                 ++depth;
1322               break;
1323
1324             case '}':
1325               if (!pattern_is_quoted)
1326                 {
1327                   if (depth == 0)
1328                     goto envsubst;
1329                   --depth;
1330                 }
1331               break;
1332
1333             case '\\':
1334               if (pattern_is_quoted)
1335                 /* Quoted; treat as normal character. */
1336                 break;
1337
1338               /* Otherwise, it's an escape: next character is literal. */
1339               if (words[++*offset] == '\0')
1340                 goto syntax;
1341
1342               pattern = w_addchar (pattern, &pat_length, &pat_maxlen, '\\');
1343               if (pattern == NULL)
1344                 goto no_space;
1345
1346               break;
1347
1348             case '\'':
1349               if (pattern_is_quoted == 0)
1350                 pattern_is_quoted = 1;
1351               else if (pattern_is_quoted == 1)
1352                 pattern_is_quoted = 0;
1353
1354               break;
1355
1356             case '"':
1357               if (pattern_is_quoted == 0)
1358                 pattern_is_quoted = 2;
1359               else if (pattern_is_quoted == 2)
1360                 pattern_is_quoted = 0;
1361
1362               break;
1363             }
1364
1365           pattern = w_addchar (pattern, &pat_length, &pat_maxlen,
1366                                words[*offset]);
1367           if (pattern == NULL)
1368             goto no_space;
1369         }
1370     }
1371
1372   /* End of input string -- remember to reparse the character that we
1373    * stopped at.  */
1374   --(*offset);
1375
1376 envsubst:
1377   if (words[start] == '{' && words[*offset] != '}')
1378     goto syntax;
1379
1380   if (env == NULL)
1381     {
1382       if (seen_hash)
1383         {
1384           /* $# expands to the number of positional parameters */
1385           buffer[20] = '\0';
1386           value = _itoa_word (__libc_argc - 1, &buffer[20], 10, 0);
1387           seen_hash = 0;
1388         }
1389       else
1390         {
1391           /* Just $ on its own */
1392           *offset = start - 1;
1393           *word = w_addchar (*word, word_length, max_length, '$');
1394           return *word ? 0 : WRDE_NOSPACE;
1395         }
1396     }
1397   /* Is it a numeric parameter? */
1398   else if (isdigit (env[0]))
1399     {
1400       int n = atoi (env);
1401
1402       if (n >= __libc_argc)
1403         /* Substitute NULL. */
1404         value = NULL;
1405       else
1406         /* Replace with appropriate positional parameter. */
1407         value = __libc_argv[n];
1408     }
1409   /* Is it a special parameter? */
1410   else if (special)
1411     {
1412       /* Is it `$$'? */
1413       if (*env == '$')
1414         {
1415           buffer[20] = '\0';
1416           value = _itoa_word (__getpid (), &buffer[20], 10, 0);
1417         }
1418       /* Is it `${#*}' or `${#@}'? */
1419       else if ((*env == '*' || *env == '@') && seen_hash)
1420         {
1421           buffer[20] = '\0';
1422           value = _itoa_word (__libc_argc > 0 ? __libc_argc - 1 : 0,
1423                               &buffer[20], 10, 0);
1424           *word = w_addstr (*word, word_length, max_length, value);
1425           free (env);
1426           if (pattern)
1427             free (pattern);
1428           return *word ? 0 : WRDE_NOSPACE;
1429         }
1430       /* Is it `$*' or `$@' (unquoted) ? */
1431       else if (*env == '*' || (*env == '@' && !quoted))
1432         {
1433           size_t plist_len = 0;
1434           int p;
1435           char *end;
1436
1437           /* Build up value parameter by parameter (copy them) */
1438           for (p = 1; __libc_argv[p]; ++p)
1439             plist_len += strlen (__libc_argv[p]) + 1; /* for space */
1440           value = malloc (plist_len);
1441           if (value == NULL)
1442             goto no_space;
1443           end = value;
1444           *end = 0;
1445           for (p = 1; __libc_argv[p]; ++p)
1446             {
1447               if (p > 1)
1448                 *end++ = ' ';
1449               end = __stpcpy (end, __libc_argv[p]);
1450             }
1451
1452           free_value = 1;
1453         }
1454       else
1455         {
1456           /* Must be a quoted `$@' */
1457           assert (*env == '@' && quoted);
1458
1459           /* Each parameter is a separate word ("$@") */
1460           if (__libc_argc == 2)
1461             value = __libc_argv[1];
1462           else if (__libc_argc > 2)
1463             {
1464               int p;
1465
1466               /* Append first parameter to current word. */
1467               value = w_addstr (*word, word_length, max_length,
1468                                 __libc_argv[1]);
1469               if (value == NULL || w_addword (pwordexp, value))
1470                 goto no_space;
1471
1472               for (p = 2; __libc_argv[p + 1]; p++)
1473                 {
1474                   char *newword = __strdup (__libc_argv[p]);
1475                   if (newword == NULL || w_addword (pwordexp, newword))
1476                     goto no_space;
1477                 }
1478
1479               /* Start a new word with the last parameter. */
1480               *word = w_newword (word_length, max_length);
1481               value = __libc_argv[p];
1482             }
1483           else
1484             {
1485               free (env);
1486               free (pattern);
1487               return 0;
1488             }
1489         }
1490     }
1491   else
1492     value = getenv (env);
1493
1494   if (value == NULL && (flags & WRDE_UNDEF))
1495     {
1496       /* Variable not defined. */
1497       error = WRDE_BADVAL;
1498       goto do_error;
1499     }
1500
1501   if (action != ACT_NONE)
1502     {
1503       int expand_pattern = 0;
1504
1505       /* First, find out if we need to expand pattern (i.e. if we will
1506        * use it). */
1507       switch (action)
1508         {
1509         case ACT_RP_SHORT_LEFT:
1510         case ACT_RP_LONG_LEFT:
1511         case ACT_RP_SHORT_RIGHT:
1512         case ACT_RP_LONG_RIGHT:
1513           /* Always expand for these. */
1514           expand_pattern = 1;
1515           break;
1516
1517         case ACT_NULL_ERROR:
1518         case ACT_NULL_SUBST:
1519         case ACT_NULL_ASSIGN:
1520           if (!value || (!*value && colon_seen))
1521             /* If param is unset, or set but null and a colon has been seen,
1522                the expansion of the pattern will be needed. */
1523             expand_pattern = 1;
1524
1525           break;
1526
1527         case ACT_NONNULL_SUBST:
1528           /* Expansion of word will be needed if parameter is set and not null,
1529              or set null but no colon has been seen. */
1530           if (value && (*value || !colon_seen))
1531             expand_pattern = 1;
1532
1533           break;
1534
1535         default:
1536           assert (! "Unrecognised action!");
1537         }
1538
1539       if (expand_pattern)
1540         {
1541           /* We need to perform tilde expansion, parameter expansion,
1542              command substitution, and arithmetic expansion.  We also
1543              have to be a bit careful with wildcard characters, as
1544              pattern might be given to fnmatch soon.  To do this, we
1545              convert quotes to escapes. */
1546
1547           char *expanded;
1548           size_t exp_len;
1549           size_t exp_maxl;
1550           char *p;
1551           int quoted = 0; /* 1: single quotes; 2: double */
1552
1553           expanded = w_newword (&exp_len, &exp_maxl);
1554           for (p = pattern; p && *p; p++)
1555             {
1556               size_t offset;
1557
1558               switch (*p)
1559                 {
1560                 case '"':
1561                   if (quoted == 2)
1562                     quoted = 0;
1563                   else if (quoted == 0)
1564                     quoted = 2;
1565                   else break;
1566
1567                   continue;
1568
1569                 case '\'':
1570                   if (quoted == 1)
1571                     quoted = 0;
1572                   else if (quoted == 0)
1573                     quoted = 1;
1574                   else break;
1575
1576                   continue;
1577
1578                 case '*':
1579                 case '?':
1580                   if (quoted)
1581                     {
1582                       /* Convert quoted wildchar to escaped wildchar. */
1583                       expanded = w_addchar (expanded, &exp_len,
1584                                             &exp_maxl, '\\');
1585
1586                       if (expanded == NULL)
1587                         goto no_space;
1588                     }
1589                   break;
1590
1591                 case '$':
1592                   offset = 0;
1593                   error = parse_dollars (&expanded, &exp_len, &exp_maxl, p,
1594                                          &offset, flags, NULL, NULL, NULL, 1);
1595                   if (error)
1596                     {
1597                       if (free_value)
1598                         free (value);
1599
1600                       if (expanded)
1601                         free (expanded);
1602
1603                       goto do_error;
1604                     }
1605
1606                   p += offset;
1607                   continue;
1608
1609                 case '~':
1610                   if (quoted || exp_len)
1611                     break;
1612
1613                   offset = 0;
1614                   error = parse_tilde (&expanded, &exp_len, &exp_maxl, p,
1615                                        &offset, 0);
1616                   if (error)
1617                     {
1618                       if (free_value)
1619                         free (value);
1620
1621                       if (expanded)
1622                         free (expanded);
1623
1624                       goto do_error;
1625                     }
1626
1627                   p += offset;
1628                   continue;
1629
1630                 case '\\':
1631                   expanded = w_addchar (expanded, &exp_len, &exp_maxl, '\\');
1632                   ++p;
1633                   assert (*p); /* checked when extracted initially */
1634                   if (expanded == NULL)
1635                     goto no_space;
1636                 }
1637
1638               expanded = w_addchar (expanded, &exp_len, &exp_maxl, *p);
1639
1640               if (expanded == NULL)
1641                 goto no_space;
1642             }
1643
1644           if (pattern)
1645                   free (pattern);
1646
1647           pattern = expanded;
1648         }
1649
1650       switch (action)
1651         {
1652         case ACT_RP_SHORT_LEFT:
1653         case ACT_RP_LONG_LEFT:
1654         case ACT_RP_SHORT_RIGHT:
1655         case ACT_RP_LONG_RIGHT:
1656           {
1657             char *p;
1658             char c;
1659             char *end;
1660
1661             if (value == NULL || pattern == NULL || *pattern == '\0')
1662               break;
1663
1664             end = value + strlen (value);
1665
1666             switch (action)
1667               {
1668               case ACT_RP_SHORT_LEFT:
1669                 for (p = value; p <= end; ++p)
1670                   {
1671                     c = *p;
1672                     *p = '\0';
1673                     if (fnmatch (pattern, value, 0) != FNM_NOMATCH)
1674                       {
1675                         *p = c;
1676                         if (free_value)
1677                           {
1678                             char *newval = __strdup (p);
1679                             if (newval == NULL)
1680                               {
1681                                 free (value);
1682                                 goto no_space;
1683                               }
1684                             free (value);
1685                             value = newval;
1686                           }
1687                         else
1688                           value = p;
1689                         break;
1690                       }
1691                     *p = c;
1692                   }
1693
1694                 break;
1695
1696               case ACT_RP_LONG_LEFT:
1697                 for (p = end; p >= value; --p)
1698                   {
1699                     c = *p;
1700                     *p = '\0';
1701                     if (fnmatch (pattern, value, 0) != FNM_NOMATCH)
1702                       {
1703                         *p = c;
1704                         if (free_value)
1705                           {
1706                             char *newval = __strdup (p);
1707                             if (newval == NULL)
1708                               {
1709                                 free (value);
1710                                 goto no_space;
1711                               }
1712                             free (value);
1713                             value = newval;
1714                           }
1715                         else
1716                           value = p;
1717                         break;
1718                       }
1719                     *p = c;
1720                   }
1721
1722                 break;
1723
1724               case ACT_RP_SHORT_RIGHT:
1725                 for (p = end; p >= value; --p)
1726                   {
1727                     if (fnmatch (pattern, p, 0) != FNM_NOMATCH)
1728                       {
1729                         char *newval;
1730                         newval = malloc (p - value + 1);
1731
1732                         if (newval == NULL)
1733                           {
1734                             if (free_value)
1735                               free (value);
1736                             goto no_space;
1737                           }
1738
1739                         *(char *) __mempcpy (newval, value, p - value) = '\0';
1740                         if (free_value)
1741                           free (value);
1742                         value = newval;
1743                         free_value = 1;
1744                         break;
1745                       }
1746                   }
1747
1748                 break;
1749
1750               case ACT_RP_LONG_RIGHT:
1751                 for (p = value; p <= end; ++p)
1752                   {
1753                     if (fnmatch (pattern, p, 0) != FNM_NOMATCH)
1754                       {
1755                         char *newval;
1756                         newval = malloc (p - value + 1);
1757
1758                         if (newval == NULL)
1759                           {
1760                             if (free_value)
1761                               free (value);
1762                             goto no_space;
1763                           }
1764
1765                         *(char *) __mempcpy (newval, value, p - value) = '\0';
1766                         if (free_value)
1767                           free (value);
1768                         value = newval;
1769                         free_value = 1;
1770                         break;
1771                       }
1772                   }
1773
1774                 break;
1775
1776               default:
1777                 break;
1778               }
1779
1780             break;
1781           }
1782
1783         case ACT_NULL_ERROR:
1784           if (value && *value)
1785             /* Substitute parameter */
1786             break;
1787
1788           error = 0;
1789           if (!colon_seen && value)
1790             /* Substitute NULL */
1791             ;
1792           else if (*pattern)
1793             fprintf (stderr, "%s: %s\n", env, pattern);
1794           else
1795             {
1796               fprintf (stderr, "%s: parameter null or not set\n", env);
1797               error = WRDE_BADVAL;
1798             }
1799
1800           if (free_value)
1801             free (value);
1802           goto do_error;
1803
1804         case ACT_NULL_SUBST:
1805           if (value && *value)
1806             /* Substitute parameter */
1807             break;
1808
1809           if (free_value && value)
1810             free (value);
1811
1812           if (!colon_seen && value)
1813             /* Substitute NULL */
1814             goto success;
1815
1816           value = pattern ? __strdup (pattern) : pattern;
1817           free_value = 1;
1818
1819           if (pattern && !value)
1820             goto no_space;
1821
1822           break;
1823
1824         case ACT_NONNULL_SUBST:
1825           if (value && (*value || !colon_seen))
1826             {
1827               if (free_value && value)
1828                 free (value);
1829
1830               value = pattern ? __strdup (pattern) : pattern;
1831               free_value = 1;
1832
1833               if (pattern && !value)
1834                 goto no_space;
1835
1836               break;
1837             }
1838
1839           /* Substitute NULL */
1840           if (free_value)
1841             free (value);
1842           goto success;
1843
1844         case ACT_NULL_ASSIGN:
1845           if (value && *value)
1846             /* Substitute parameter */
1847             break;
1848
1849           if (!colon_seen && value)
1850             {
1851               /* Substitute NULL */
1852               if (free_value)
1853                 free (value);
1854               goto success;
1855             }
1856
1857           if (free_value && value)
1858             free (value);
1859
1860           value = pattern ? __strdup (pattern) : pattern;
1861           free_value = 1;
1862
1863           if (pattern && !value)
1864             goto no_space;
1865
1866           __setenv (env, value, 1);
1867           break;
1868
1869         default:
1870           assert (! "Unrecognised action!");
1871         }
1872     }
1873
1874   free (env); env = NULL;
1875   free (pattern); pattern = NULL;
1876
1877   if (seen_hash)
1878     {
1879       char param_length[21];
1880       param_length[20] = '\0';
1881       *word = w_addstr (*word, word_length, max_length,
1882                         _itoa_word (value ? strlen (value) : 0,
1883                                     &param_length[20], 10, 0));
1884       if (free_value)
1885         {
1886           assert (value != NULL);
1887           free (value);
1888         }
1889
1890       return *word ? 0 : WRDE_NOSPACE;
1891     }
1892
1893   if (value == NULL)
1894     return 0;
1895
1896   if (quoted || !pwordexp)
1897     {
1898       /* Quoted - no field split */
1899       *word = w_addstr (*word, word_length, max_length, value);
1900       if (free_value)
1901         free (value);
1902
1903       return *word ? 0 : WRDE_NOSPACE;
1904     }
1905   else
1906     {
1907       /* Need to field-split */
1908       char *value_copy = __strdup (value); /* Don't modify value */
1909       char *field_begin = value_copy;
1910       int seen_nonws_ifs = 0;
1911
1912       if (free_value)
1913         free (value);
1914
1915       if (value_copy == NULL)
1916         goto no_space;
1917
1918       do
1919         {
1920           char *field_end = field_begin;
1921           char *next_field;
1922
1923           /* If this isn't the first field, start a new word */
1924           if (field_begin != value_copy)
1925             {
1926               if (w_addword (pwordexp, *word) == WRDE_NOSPACE)
1927                 {
1928                   free (value_copy);
1929                   goto no_space;
1930                 }
1931
1932               *word = w_newword (word_length, max_length);
1933             }
1934
1935           /* Skip IFS whitespace before the field */
1936           field_begin += strspn (field_begin, ifs_white);
1937
1938           if (!seen_nonws_ifs && *field_begin == 0)
1939             /* Nothing but whitespace */
1940             break;
1941
1942           /* Search for the end of the field */
1943           field_end = field_begin + strcspn (field_begin, ifs);
1944
1945           /* Set up pointer to the character after end of field and
1946              skip whitespace IFS after it. */
1947           next_field = field_end + strspn (field_end, ifs_white);
1948
1949           /* Skip at most one non-whitespace IFS character after the field */
1950           seen_nonws_ifs = 0;
1951           if (*next_field && strchr (ifs, *next_field))
1952             {
1953               seen_nonws_ifs = 1;
1954               next_field++;
1955             }
1956
1957           /* Null-terminate it */
1958           *field_end = 0;
1959
1960           /* Tag a copy onto the current word */
1961           *word = w_addstr (*word, word_length, max_length, field_begin);
1962
1963           if (*word == NULL && *field_begin != '\0')
1964             {
1965               free (value_copy);
1966               goto no_space;
1967             }
1968
1969           field_begin = next_field;
1970         }
1971       while (seen_nonws_ifs || *field_begin);
1972
1973       free (value_copy);
1974     }
1975
1976   return 0;
1977
1978 success:
1979   error = 0;
1980   goto do_error;
1981
1982 no_space:
1983   error = WRDE_NOSPACE;
1984   goto do_error;
1985
1986 syntax:
1987   error = WRDE_SYNTAX;
1988
1989 do_error:
1990   if (env)
1991     free (env);
1992
1993   if (pattern)
1994     free (pattern);
1995
1996   return error;
1997 }
1998
1999 static int
2000 internal_function
2001 parse_dollars (char **word, size_t *word_length, size_t *max_length,
2002                const char *words, size_t *offset, int flags,
2003                wordexp_t *pwordexp, const char *ifs, const char *ifs_white,
2004                int quoted)
2005 {
2006   /* We are poised _at_ "$" */
2007   switch (words[1 + *offset])
2008     {
2009     case '"':
2010     case '\'':
2011     case 0:
2012       *word = w_addchar (*word, word_length, max_length, '$');
2013       return *word ? 0 : WRDE_NOSPACE;
2014
2015     case '(':
2016       if (words[2 + *offset] == '(')
2017         {
2018           /* Differentiate between $((1+3)) and $((echo);(ls)) */
2019           int i = 3 + *offset;
2020           int depth = 0;
2021           while (words[i] && !(depth == 0 && words[i] == ')'))
2022             {
2023               if (words[i] == '(')
2024                 ++depth;
2025               else if (words[i] == ')')
2026                 --depth;
2027
2028               ++i;
2029             }
2030
2031           if (words[i] == ')' && words[i + 1] == ')')
2032             {
2033               (*offset) += 3;
2034               /* Call parse_arith -- 0 is for "no brackets" */
2035               return parse_arith (word, word_length, max_length, words, offset,
2036                                   flags, 0);
2037             }
2038         }
2039
2040       if (flags & WRDE_NOCMD)
2041         return WRDE_CMDSUB;
2042
2043       (*offset) += 2;
2044       return parse_comm (word, word_length, max_length, words, offset, flags,
2045                          quoted? NULL : pwordexp, ifs, ifs_white);
2046
2047     case '[':
2048       (*offset) += 2;
2049       /* Call parse_arith -- 1 is for "brackets" */
2050       return parse_arith (word, word_length, max_length, words, offset, flags,
2051                           1);
2052
2053     case '{':
2054     default:
2055       ++(*offset);      /* parse_param needs to know if "{" is there */
2056       return parse_param (word, word_length, max_length, words, offset, flags,
2057                            pwordexp, ifs, ifs_white, quoted);
2058     }
2059 }
2060
2061 static int
2062 internal_function
2063 parse_backtick (char **word, size_t *word_length, size_t *max_length,
2064                 const char *words, size_t *offset, int flags,
2065                 wordexp_t *pwordexp, const char *ifs, const char *ifs_white)
2066 {
2067   /* We are poised just after "`" */
2068   int error;
2069   int squoting = 0;
2070   size_t comm_length;
2071   size_t comm_maxlen;
2072   char *comm = w_newword (&comm_length, &comm_maxlen);
2073
2074   for (; words[*offset]; ++(*offset))
2075     {
2076       switch (words[*offset])
2077         {
2078         case '`':
2079           /* Go -- give the script to the shell */
2080           error = exec_comm (comm, word, word_length, max_length, flags,
2081                              pwordexp, ifs, ifs_white);
2082           free (comm);
2083           return error;
2084
2085         case '\\':
2086           if (squoting)
2087             {
2088               error = parse_qtd_backslash (&comm, &comm_length, &comm_maxlen,
2089                                            words, offset);
2090
2091               if (error)
2092                 {
2093                   free (comm);
2094                   return error;
2095                 }
2096
2097               break;
2098             }
2099
2100           ++(*offset);
2101           error = parse_backslash (&comm, &comm_length, &comm_maxlen, words,
2102                                    offset);
2103
2104           if (error)
2105             {
2106               free (comm);
2107               return error;
2108             }
2109
2110           break;
2111
2112         case '\'':
2113           squoting = 1 - squoting;
2114         default:
2115           comm = w_addchar (comm, &comm_length, &comm_maxlen, words[*offset]);
2116           if (comm == NULL)
2117             return WRDE_NOSPACE;
2118         }
2119     }
2120
2121   /* Premature end */
2122   free (comm);
2123   return WRDE_SYNTAX;
2124 }
2125
2126 static int
2127 internal_function
2128 parse_dquote (char **word, size_t *word_length, size_t *max_length,
2129               const char *words, size_t *offset, int flags,
2130               wordexp_t *pwordexp, const char * ifs, const char * ifs_white)
2131 {
2132   /* We are poised just after a double-quote */
2133   int error;
2134
2135   for (; words[*offset]; ++(*offset))
2136     {
2137       switch (words[*offset])
2138         {
2139         case '"':
2140           return 0;
2141
2142         case '$':
2143           error = parse_dollars (word, word_length, max_length, words, offset,
2144                                  flags, pwordexp, ifs, ifs_white, 1);
2145           /* The ``1'' here is to tell parse_dollars not to
2146            * split the fields.  It may need to, however ("$@").
2147            */
2148           if (error)
2149             return error;
2150
2151           break;
2152
2153         case '`':
2154           if (flags & WRDE_NOCMD)
2155             return WRDE_CMDSUB;
2156
2157           ++(*offset);
2158           error = parse_backtick (word, word_length, max_length, words,
2159                                   offset, flags, NULL, NULL, NULL);
2160           /* The first NULL here is to tell parse_backtick not to
2161            * split the fields.
2162            */
2163           if (error)
2164             return error;
2165
2166           break;
2167
2168         case '\\':
2169           error = parse_qtd_backslash (word, word_length, max_length, words,
2170                                        offset);
2171
2172           if (error)
2173             return error;
2174
2175           break;
2176
2177         default:
2178           *word = w_addchar (*word, word_length, max_length, words[*offset]);
2179           if (*word == NULL)
2180             return WRDE_NOSPACE;
2181         }
2182     }
2183
2184   /* Unterminated string */
2185   return WRDE_SYNTAX;
2186 }
2187
2188 /*
2189  * wordfree() is to be called after pwordexp is finished with.
2190  */
2191
2192 void
2193 wordfree (wordexp_t *pwordexp)
2194 {
2195
2196   /* wordexp can set pwordexp to NULL */
2197   if (pwordexp && pwordexp->we_wordv)
2198     {
2199       char **wordv = pwordexp->we_wordv;
2200
2201       for (wordv += pwordexp->we_offs; *wordv; ++wordv)
2202         free (*wordv);
2203
2204       free (pwordexp->we_wordv);
2205       pwordexp->we_wordv = NULL;
2206     }
2207 }
2208
2209 /*
2210  * wordexp()
2211  */
2212
2213 int
2214 wordexp (const char *words, wordexp_t *pwordexp, int flags)
2215 {
2216   size_t words_offset;
2217   size_t word_length;
2218   size_t max_length;
2219   char *word = w_newword (&word_length, &max_length);
2220   int error;
2221   char *ifs;
2222   char ifs_white[4];
2223   wordexp_t old_word = *pwordexp;
2224
2225   if (flags & WRDE_REUSE)
2226     {
2227       /* Minimal implementation of WRDE_REUSE for now */
2228       wordfree (pwordexp);
2229       old_word.we_wordv = NULL;
2230     }
2231
2232   if ((flags & WRDE_APPEND) == 0)
2233     {
2234       pwordexp->we_wordc = 0;
2235
2236       if (flags & WRDE_DOOFFS)
2237         {
2238           pwordexp->we_wordv = calloc (1 + pwordexp->we_offs, sizeof (char *));
2239           if (pwordexp->we_wordv == NULL)
2240             {
2241               error = WRDE_NOSPACE;
2242               goto do_error;
2243             }
2244         }
2245       else
2246         {
2247           pwordexp->we_wordv = calloc (1, sizeof (char *));
2248           if (pwordexp->we_wordv == NULL)
2249             {
2250               error = WRDE_NOSPACE;
2251               goto do_error;
2252             }
2253
2254           pwordexp->we_offs = 0;
2255         }
2256     }
2257
2258   /* Find out what the field separators are.
2259    * There are two types: whitespace and non-whitespace.
2260    */
2261   ifs = getenv ("IFS");
2262
2263   if (!ifs)
2264     /* IFS unset - use <space><tab><newline>. */
2265     ifs = strcpy (ifs_white, " \t\n");
2266   else
2267     {
2268       char *ifsch = ifs;
2269       char *whch = ifs_white;
2270
2271       /* Start off with no whitespace IFS characters */
2272       ifs_white[0] = '\0';
2273
2274       while (*ifsch != '\0')
2275         {
2276           if ((*ifsch == ' ') || (*ifsch == '\t') || (*ifsch == '\n'))
2277             {
2278               /* Whitespace IFS.  See first whether it is already in our
2279                  collection.  */
2280               char *runp = ifs_white;
2281
2282               while (runp < whch && *runp != '\0' && *runp != *ifsch)
2283                 ++runp;
2284
2285               if (runp == whch)
2286                 *whch++ = *ifsch;
2287             }
2288
2289           ++ifsch;
2290         }
2291       *whch = '\0';
2292     }
2293
2294   for (words_offset = 0 ; words[words_offset] ; ++words_offset)
2295     switch (words[words_offset])
2296       {
2297       case '\\':
2298         error = parse_backslash (&word, &word_length, &max_length, words,
2299                                  &words_offset);
2300
2301         if (error)
2302           goto do_error;
2303
2304         break;
2305
2306       case '$':
2307         error = parse_dollars (&word, &word_length, &max_length, words,
2308                                &words_offset, flags, pwordexp, ifs, ifs_white,
2309                                0);
2310
2311         if (error)
2312           goto do_error;
2313
2314         break;
2315
2316       case '`':
2317         if (flags & WRDE_NOCMD)
2318           {
2319             error = WRDE_CMDSUB;
2320             goto do_error;
2321           }
2322
2323         ++words_offset;
2324         error = parse_backtick (&word, &word_length, &max_length, words,
2325                                 &words_offset, flags, pwordexp, ifs,
2326                                 ifs_white);
2327
2328         if (error)
2329           goto do_error;
2330
2331         break;
2332
2333       case '"':
2334         ++words_offset;
2335         error = parse_dquote (&word, &word_length, &max_length, words,
2336                               &words_offset, flags, pwordexp, ifs, ifs_white);
2337
2338         if (error)
2339           goto do_error;
2340
2341         if (!word_length)
2342           {
2343             error = w_addword (pwordexp, NULL);
2344
2345             if (error)
2346               return error;
2347           }
2348
2349         break;
2350
2351       case '\'':
2352         ++words_offset;
2353         error = parse_squote (&word, &word_length, &max_length, words,
2354                               &words_offset);
2355
2356         if (error)
2357           goto do_error;
2358
2359         if (!word_length)
2360           {
2361             error = w_addword (pwordexp, NULL);
2362
2363             if (error)
2364               return error;
2365           }
2366
2367         break;
2368
2369       case '~':
2370         error = parse_tilde (&word, &word_length, &max_length, words,
2371                              &words_offset, pwordexp->we_wordc);
2372
2373         if (error)
2374           goto do_error;
2375
2376         break;
2377
2378       case '*':
2379       case '[':
2380       case '?':
2381         error = parse_glob (&word, &word_length, &max_length, words,
2382                             &words_offset, flags, pwordexp, ifs, ifs_white);
2383
2384         if (error)
2385           goto do_error;
2386
2387         break;
2388
2389       default:
2390         /* Is it a word separator? */
2391         if (strchr (" \t", words[words_offset]) == NULL)
2392           {
2393             char ch = words[words_offset];
2394
2395             /* Not a word separator -- but is it a valid word char? */
2396             if (strchr ("\n|&;<>(){}", ch))
2397               {
2398                 /* Fail */
2399                 error = WRDE_BADCHAR;
2400                 goto do_error;
2401               }
2402
2403             /* "Ordinary" character -- add it to word */
2404             word = w_addchar (word, &word_length, &max_length,
2405                               ch);
2406             if (word == NULL)
2407               {
2408                 error = WRDE_NOSPACE;
2409                 goto do_error;
2410               }
2411
2412             break;
2413           }
2414
2415         /* If a word has been delimited, add it to the list. */
2416         if (word != NULL)
2417           {
2418             error = w_addword (pwordexp, word);
2419             if (error)
2420               goto do_error;
2421           }
2422
2423         word = w_newword (&word_length, &max_length);
2424       }
2425
2426   /* End of string */
2427
2428   /* There was a word separator at the end */
2429   if (word == NULL) /* i.e. w_newword */
2430     return 0;
2431
2432   /* There was no field separator at the end */
2433   return w_addword (pwordexp, word);
2434
2435 do_error:
2436   /* Error:
2437    *    free memory used (unless error is WRDE_NOSPACE), and
2438    *    set pwordexp members back to what they were.
2439    */
2440
2441   if (word != NULL)
2442     free (word);
2443
2444   if (error == WRDE_NOSPACE)
2445     return WRDE_NOSPACE;
2446
2447   if ((flags & WRDE_APPEND) == 0)
2448     wordfree (pwordexp);
2449
2450   *pwordexp = old_word;
2451   return error;
2452 }