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