1 /* env - run a program in a modified environment
2 Copyright (C) 1986-2023 Free Software Foundation, Inc.
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 /* Richard Mlynarik and David MacKenzie */
18
19 #include <config.h>
20 #include <stdio.h>
21 #include <sys/types.h>
22 #include <getopt.h>
23 #include <c-ctype.h>
24 #include <signal.h>
25
26 #include "system.h"
27 #include "operand2sig.h"
28 #include "quote.h"
29 #include "sig2str.h"
30
31 /* The official name of this program (e.g., no 'g' prefix). */
32 #define PROGRAM_NAME "env"
33
34 #define AUTHORS \
35 proper_name ("Richard Mlynarik"), \
36 proper_name ("David MacKenzie"), \
37 proper_name ("Assaf Gordon")
38
39 /* Array of envvars to unset. */
40 static char const **usvars;
41 static size_t usvars_alloc;
42 static idx_t usvars_used;
43
44 /* Annotate the output with extra info to aid the user. */
45 static bool dev_debug;
46
47 /* Buffer and length of extracted envvars in -S strings. */
48 static char *varname;
49 static idx_t vnlen;
50
51 /* Possible actions on each signal. */
52 enum SIGNAL_MODE {
53 UNCHANGED = 0,
54 DEFAULT, /* Set to default handler (SIG_DFL). */
55 DEFAULT_NOERR, /* Ditto, but ignore sigaction(2) errors. */
56 IGNORE, /* Set to ignore (SIG_IGN). */
57 IGNORE_NOERR /* Ditto, but ignore sigaction(2) errors. */
58 };
59 static enum SIGNAL_MODE *signals;
60
61 /* Set of signals to block. */
62 static sigset_t block_signals;
63
64 /* Set of signals to unblock. */
65 static sigset_t unblock_signals;
66
67 /* Whether signal mask adjustment requested. */
68 static bool sig_mask_changed;
69
70 /* Whether to list non default handling. */
71 static bool report_signal_handling;
72
73 /* The isspace characters in the C locale. */
74 #define C_ISSPACE_CHARS " \t\n\v\f\r"
75
76 static char const shortopts[] = "+C:iS:u:v0" C_ISSPACE_CHARS;
77
78 /* For long options that have no equivalent short option, use a
79 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
80 enum
81 {
82 DEFAULT_SIGNAL_OPTION = CHAR_MAX + 1,
83 IGNORE_SIGNAL_OPTION,
84 BLOCK_SIGNAL_OPTION,
85 LIST_SIGNAL_HANDLING_OPTION,
86 };
87
88 static struct option const longopts[] =
89 {
90 {"ignore-environment", no_argument, nullptr, 'i'},
91 {"null", no_argument, nullptr, '0'},
92 {"unset", required_argument, nullptr, 'u'},
93 {"chdir", required_argument, nullptr, 'C'},
94 {"default-signal", optional_argument, nullptr, DEFAULT_SIGNAL_OPTION},
95 {"ignore-signal", optional_argument, nullptr, IGNORE_SIGNAL_OPTION},
96 {"block-signal", optional_argument, nullptr, BLOCK_SIGNAL_OPTION},
97 {"list-signal-handling", no_argument, nullptr, LIST_SIGNAL_HANDLING_OPTION},
98 {"debug", no_argument, nullptr, 'v'},
99 {"split-string", required_argument, nullptr, 'S'},
100 {GETOPT_HELP_OPTION_DECL},
101 {GETOPT_VERSION_OPTION_DECL},
102 {nullptr, 0, nullptr, 0}
103 };
104
105 void
106 usage (int status)
107 {
108 if (status != EXIT_SUCCESS)
109 emit_try_help ();
110 else
111 {
112 printf (_("\
113 Usage: %s [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]\n"),
114 program_name);
115 fputs (_("\
116 Set each NAME to VALUE in the environment and run COMMAND.\n\
117 "), stdout);
118
119 emit_mandatory_arg_note ();
120
121 fputs (_("\
122 -i, --ignore-environment start with an empty environment\n\
123 -0, --null end each output line with NUL, not newline\n\
124 -u, --unset=NAME remove variable from the environment\n\
125 "), stdout);
126 fputs (_("\
127 -C, --chdir=DIR change working directory to DIR\n\
128 "), stdout);
129 fputs (_("\
130 -S, --split-string=S process and split S into separate arguments;\n\
131 used to pass multiple arguments on shebang lines\n\
132 "), stdout);
133 fputs (_("\
134 --block-signal[=SIG] block delivery of SIG signal(s) to COMMAND\n\
135 "), stdout);
136 fputs (_("\
137 --default-signal[=SIG] reset handling of SIG signal(s) to the default\n\
138 "), stdout);
139 fputs (_("\
140 --ignore-signal[=SIG] set handling of SIG signal(s) to do nothing\n\
141 "), stdout);
142 fputs (_("\
143 --list-signal-handling list non default signal handling to stderr\n\
144 "), stdout);
145 fputs (_("\
146 -v, --debug print verbose information for each processing step\n\
147 "), stdout);
148 fputs (HELP_OPTION_DESCRIPTION, stdout);
149 fputs (VERSION_OPTION_DESCRIPTION, stdout);
150 fputs (_("\
151 \n\
152 A mere - implies -i. If no COMMAND, print the resulting environment.\n\
153 "), stdout);
154 fputs (_("\
155 \n\
156 SIG may be a signal name like 'PIPE', or a signal number like '13'.\n\
157 Without SIG, all known signals are included. Multiple signals can be\n\
158 comma-separated. An empty SIG argument is a no-op.\n\
159 "), stdout);
160 emit_exec_status (PROGRAM_NAME);
161 emit_ancillary_info (PROGRAM_NAME);
162 }
163 exit (status);
164 }
165
166 static void
167 append_unset_var (char const *var)
168 {
169 if (usvars_used == usvars_alloc)
170 usvars = x2nrealloc (usvars, &usvars_alloc, sizeof *usvars);
171 usvars[usvars_used++] = var;
172 }
173
174 static void
175 unset_envvars (void)
176 {
177 for (idx_t i = 0; i < usvars_used; ++i)
178 {
179 devmsg ("unset: %s\n", usvars[i]);
180
181 if (unsetenv (usvars[i]))
182 error (EXIT_CANCELED, errno, _("cannot unset %s"),
183 quote (usvars[i]));
184 }
185 }
186
187 /* Return a pointer to the end of a valid ${VARNAME} string, or nullptr.
188 'str' should point to the '$' character.
189 First letter in VARNAME must be alpha or underscore,
190 rest of letters are alnum or underscore.
191 Any other character is an error. */
192 ATTRIBUTE_PURE
193 static char const *
194 scan_varname (char const *str)
195 {
196 if (str[1] == '{' && (c_isalpha (str[2]) || str[2] == '_'))
197 {
198 char const *end = str + 3;
199 while (c_isalnum (*end) || *end == '_')
200 ++end;
201 if (*end == '}')
202 return end;
203 }
204
205 return nullptr;
206 }
207
208 /* Return a pointer to a static buffer containing the VARNAME as
209 extracted from a '${VARNAME}' string.
210 The returned string will be NUL terminated.
211 The returned pointer should not be freed.
212 Return nullptr if not a valid ${VARNAME} syntax. */
213 static char *
214 extract_varname (char const *str)
215 {
216 idx_t i;
217 char const *p;
218
219 p = scan_varname (str);
220 if (!p)
221 return nullptr;
222
223 /* -2 and +2 (below) account for the '${' prefix. */
224 i = p - str - 2;
225
226 if (i >= vnlen)
227 {
228 vnlen = i + 1;
229 varname = xrealloc (varname, vnlen);
230 }
231
232 memcpy (varname, str + 2, i);
233 varname[i] = 0;
234
235 return varname;
236 }
237
238 /* Temporary buffer used by --split-string processing. */
239 struct splitbuf
240 {
241 /* Buffer address, arg count, and half the number of elements in the buffer.
242 ARGC and ARGV are as in 'main', and ARGC + 1 <= HALF_ALLOC so
243 that the upper half of ARGV can be used for string contents.
244 This may waste up to half the space but keeps the code simple,
245 which is better for this rarely-used but security-sensitive code.
246
247 ARGV[0] is not initialized; that is the caller's responsibility
248 after finalization.
249
250 During assembly, ARGV[I] (where 0 < I < ARGC) contains the offset
251 of the Ith string (relative to ARGV + HALF_ALLOC), so that
252 reallocating ARGV does not change the validity of its contents.
253 The integer offset is cast to char * during assembly, and is
254 converted to a true char * pointer on finalization.
255
256 During assembly, ARGV[ARGC] contains the offset of the first
257 unused string byte (relative to ARGV + HALF_ALLOC). */
258 char **argv;
259 int argc;
260 idx_t half_alloc;
261
262 /* The number of extra argv slots to keep room for. */
263 int extra_argc;
264
265 /* Whether processing should act as if the most recent character
266 seen was a separator. */
267 bool sep;
268 };
269
270 /* Expand SS so that it has at least one more argv slot and at least
271 one more string byte. */
272 static void
273 splitbuf_grow (struct splitbuf *ss)
274 {
275 idx_t old_half_alloc = ss->half_alloc;
276 idx_t string_bytes = (intptr_t) ss->argv[ss->argc];
277 ss->argv = xpalloc (ss->argv, &ss->half_alloc, 1,
278 MIN (INT_MAX, IDX_MAX), 2 * sizeof *ss->argv);
279 memmove (ss->argv + ss->half_alloc, ss->argv + old_half_alloc, string_bytes);
280 }
281
282 /* In SS, append C to the last string. */
283 static void
284 splitbuf_append_byte (struct splitbuf *ss, char c)
285 {
286 idx_t string_bytes = (intptr_t) ss->argv[ss->argc];
287 if (ss->half_alloc * sizeof *ss->argv <= string_bytes)
288 splitbuf_grow (ss);
289 ((char *) (ss->argv + ss->half_alloc))[string_bytes] = c;
290 ss->argv[ss->argc] = (char *) (intptr_t) (string_bytes + 1);
291 }
292
293 /* If SS's most recent character was a separator, finish off its
294 previous argument and start a new one. */
295 static void
296 check_start_new_arg (struct splitbuf *ss)
297 {
298 if (ss->sep)
299 {
300 splitbuf_append_byte (ss, '\0');
301 int argc = ss->argc;
302 if (ss->half_alloc <= argc + ss->extra_argc + 1)
303 splitbuf_grow (ss);
304 ss->argv[argc + 1] = ss->argv[argc];
305 ss->argc = argc + 1;
306 ss->sep = false;
307 }
308 }
309
310 /* All additions to SS have been made. Convert its offsets to pointers,
311 and return the resulting argument vector. */
312 static char **
313 splitbuf_finishup (struct splitbuf *ss)
314 {
315 int argc = ss->argc;
316 char **argv = ss->argv;
317 char *stringbase = (char *) (ss->argv + ss->half_alloc);
318 for (int i = 1; i < argc; i++)
319 argv[i] = stringbase + (intptr_t) argv[i];
320 return argv;
321 }
322
323 /* Return a newly-allocated argv-like array,
324 by parsing and splitting the input 'str'.
325
326 'extra_argc' is the number of additional elements to allocate
327 in the array (on top of the number of args required to split 'str').
328
329 Store into *argc the number of arguments found (plus 1 for
330 the program name).
331
332 Example:
333 int argc;
334 char **argv = build_argv ("A=B uname -k', 3, &argc);
335 Results in:
336 argc = 4
337 argv[0] = [not initialized]
338 argv[1] = "A=B"
339 argv[2] = "uname"
340 argv[3] = "-k"
341 argv[4,5,6,7] = [allocated due to extra_argc + 1, but not initialized]
342
343 To free allocated memory:
344 free (argv);
345 However, 'env' does not free since it's about to exec or exit anyway
346 and the complexity of keeping track of the storage that may have been
347 allocated via multiple calls to build_argv is not worth the hassle. */
348 static char **
349 build_argv (char const *str, int extra_argc, int *argc)
350 {
351 bool dq = false, sq = false;
352 struct splitbuf ss;
353 ss.argv = xnmalloc (extra_argc + 2, 2 * sizeof *ss.argv);
354 ss.argc = 1;
355 ss.half_alloc = extra_argc + 2;
356 ss.extra_argc = extra_argc;
357 ss.sep = true;
358 ss.argv[ss.argc] = 0;
359
360 /* In the following loop,
361 'break' causes the character 'newc' to be added to *dest,
362 'continue' skips the character. */
363 while (*str)
364 {
365 char newc = *str; /* Default: add the next character. */
366
367 switch (*str)
368 {
369 case '\'':
370 if (dq)
371 break;
372 sq = !sq;
373 check_start_new_arg (&ss);
374 ++str;
375 continue;
376
377 case '"':
378 if (sq)
379 break;
380 dq = !dq;
381 check_start_new_arg (&ss);
382 ++str;
383 continue;
384
385 case ' ': case '\t': case '\n': case '\v': case '\f': case '\r':
386 /* Start a new argument if outside quotes. */
387 if (sq || dq)
388 break;
389 ss.sep = true;
390 str += strspn (str, C_ISSPACE_CHARS);
391 continue;
392
393 case '#':
394 if (!ss.sep)
395 break;
396 goto eos; /* '#' as first char terminates the string. */
397
398 case '\\':
399 /* Backslash inside single-quotes is not special, except \\
400 and \'. */
401 if (sq && str[1] != '\\' && str[1] != '\'')
402 break;
403
404 /* Skip the backslash and examine the next character. */
405 newc = *++str;
406 switch (newc)
407 {
408 case '"': case '#': case '$': case '\'': case '\\':
409 /* Pass escaped character as-is. */
410 break;
411
412 case '_':
413 if (!dq)
414 {
415 ++str; /* '\_' outside double-quotes is arg separator. */
416 ss.sep = true;
417 continue;
418 }
419 newc = ' '; /* '\_' inside double-quotes is space. */
420 break;
421
422 case 'c':
423 if (dq)
424 error (EXIT_CANCELED, 0,
425 _("'\\c' must not appear in double-quoted -S string"));
426 goto eos; /* '\c' terminates the string. */
427
428 case 'f': newc = '\f'; break;
429 case 'n': newc = '\n'; break;
430 case 'r': newc = '\r'; break;
431 case 't': newc = '\t'; break;
432 case 'v': newc = '\v'; break;
433
434 case '\0':
435 error (EXIT_CANCELED, 0,
436 _("invalid backslash at end of string in -S"));
437
438 default:
439 error (EXIT_CANCELED, 0,
440 _("invalid sequence '\\%c' in -S"), newc);
441 }
442 break;
443
444 case '$':
445 /* ${VARNAME} are not expanded inside single-quotes. */
446 if (sq)
447 break;
448
449 /* Store the ${VARNAME} value. */
450 {
451 char *n = extract_varname (str);
452 if (!n)
453 error (EXIT_CANCELED, 0,
454 _("only ${VARNAME} expansion is supported, error at: %s"),
455 str);
456
457 char *v = getenv (n);
458 if (v)
459 {
460 check_start_new_arg (&ss);
461 devmsg ("expanding ${%s} into %s\n", n, quote (v));
462 for (; *v; v++)
463 splitbuf_append_byte (&ss, *v);
464 }
465 else
466 devmsg ("replacing ${%s} with null string\n", n);
467
468 str = strchr (str, '}') + 1;
469 continue;
470 }
471 }
472
473 check_start_new_arg (&ss);
474 splitbuf_append_byte (&ss, newc);
475 ++str;
476 }
477
478 if (dq || sq)
479 error (EXIT_CANCELED, 0, _("no terminating quote in -S string"));
480
481 eos:
482 splitbuf_append_byte (&ss, '\0');
483 *argc = ss.argc;
484 return splitbuf_finishup (&ss);
485 }
486
487 /* Process an "-S" string and create the corresponding argv array.
488 Update the given argc/argv parameters with the new argv.
489
490 Example: if executed as:
491 $ env -S"-i -C/tmp A=B" foo bar
492 The input argv is:
493 argv[0] = "env"
494 argv[1] = "-S-i -C/tmp A=B"
495 argv[2] = "foo"
496 argv[3] = "bar"
497 argv[4] = nullptr
498 This function will modify argv to be:
499 argv[0] = "env"
500 argv[1] = "-i"
501 argv[2] = "-C/tmp"
502 argv[3] = "A=B"
503 argv[4] = "foo"
504 argv[5] = "bar"
505 argv[6] = nullptr
506 argc will be updated from 4 to 6.
507 optind will be reset to 0 to force getopt_long to rescan all arguments. */
508 static void
509 parse_split_string (char const *str, int *orig_optind,
510 int *orig_argc, char ***orig_argv)
511 {
512 int extra_argc = *orig_argc - *orig_optind, newargc;
513 char **newargv = build_argv (str, extra_argc, &newargc);
514
515 /* Restore argv[0] - the 'env' executable name. */
516 *newargv = (*orig_argv)[0];
517
518 /* Print parsed arguments. */
519 if (dev_debug && 1 < newargc)
520 {
521 devmsg ("split -S: %s\n", quote (str));
522 devmsg (" into: %s\n", quote (newargv[1]));
523 for (int i = 2; i < newargc; i++)
524 devmsg (" & %s\n", quote (newargv[i]));
525 }
526
527 /* Add remaining arguments and terminating null from the original
528 command line. */
529 memcpy (newargv + newargc, *orig_argv + *orig_optind,
530 (extra_argc + 1) * sizeof *newargv);
531
532 /* Set new values for original getopt variables. */
533 *orig_argc = newargc + extra_argc;
534 *orig_argv = newargv;
535 *orig_optind = 0; /* Tell getopt to restart from first argument. */
536 }
537
538 static void
539 parse_signal_action_params (char const *optarg, bool set_default)
540 {
541 char signame[SIG2STR_MAX];
542 char *opt_sig;
543 char *optarg_writable;
544
545 if (! optarg)
546 {
547 /* Without an argument, reset all signals.
548 Some signals cannot be set to ignore or default (e.g., SIGKILL,
549 SIGSTOP on most OSes, and SIGCONT on AIX.) - so ignore errors. */
550 for (int i = 1 ; i <= SIGNUM_BOUND; i++)
551 if (sig2str (i, signame) == 0)
552 signals[i] = set_default ? DEFAULT_NOERR : IGNORE_NOERR;
553 return;
554 }
555
556 optarg_writable = xstrdup (optarg);
557
558 opt_sig = strtok (optarg_writable, ",");
559 while (opt_sig)
560 {
561 int signum = operand2sig (opt_sig, signame);
562 /* operand2sig accepts signal 0 (EXIT) - but we reject it. */
563 if (signum == 0)
564 error (0, 0, _("%s: invalid signal"), quote (opt_sig));
565 if (signum <= 0)
566 usage (exit_failure);
567
568 signals[signum] = set_default ? DEFAULT : IGNORE;
569
570 opt_sig = strtok (nullptr, ",");
571 }
572
573 free (optarg_writable);
574 }
575
576 static void
577 reset_signal_handlers (void)
578 {
579 for (int i = 1; i <= SIGNUM_BOUND; i++)
580 {
581 struct sigaction act;
582
583 if (signals[i] == UNCHANGED)
584 continue;
585
586 bool ignore_errors = (signals[i] == DEFAULT_NOERR
587 || signals[i] == IGNORE_NOERR);
588
589 bool set_to_default = (signals[i] == DEFAULT
590 || signals[i] == DEFAULT_NOERR);
591
592 int sig_err = sigaction (i, nullptr, &act);
593
594 if (sig_err && !ignore_errors)
595 error (EXIT_CANCELED, errno,
596 _("failed to get signal action for signal %d"), i);
597
598 if (! sig_err)
599 {
600 act.sa_handler = set_to_default ? SIG_DFL : SIG_IGN;
601 sig_err = sigaction (i, &act, nullptr);
602 if (sig_err && !ignore_errors)
603 error (EXIT_CANCELED, errno,
604 _("failed to set signal action for signal %d"), i);
605 }
606
607 if (dev_debug)
608 {
609 char signame[SIG2STR_MAX];
610 sig2str (i, signame);
611 devmsg ("Reset signal %s (%d) to %s%s\n",
612 signame, i,
613 set_to_default ? "DEFAULT" : "IGNORE",
614 sig_err ? " (failure ignored)" : "");
615 }
616 }
617 }
618
619
620 static void
621 parse_block_signal_params (char const *optarg, bool block)
622 {
623 char signame[SIG2STR_MAX];
624 char *opt_sig;
625 char *optarg_writable;
626
627 if (! optarg)
628 {
629 /* Without an argument, reset all signals. */
630 sigfillset (block ? &block_signals : &unblock_signals);
631 sigemptyset (block ? &unblock_signals : &block_signals);
632 }
633 else if (! sig_mask_changed)
634 {
635 /* Initialize the sets. */
636 sigemptyset (&block_signals);
637 sigemptyset (&unblock_signals);
638 }
639
640 sig_mask_changed = true;
641
642 if (! optarg)
643 return;
644
645 optarg_writable = xstrdup (optarg);
646
647 opt_sig = strtok (optarg_writable, ",");
648 while (opt_sig)
649 {
650 int signum = operand2sig (opt_sig, signame);
651 /* operand2sig accepts signal 0 (EXIT) - but we reject it. */
652 if (signum == 0)
653 error (0, 0, _("%s: invalid signal"), quote (opt_sig));
654 if (signum <= 0)
655 usage (exit_failure);
656
657 sigaddset (block ? &block_signals : &unblock_signals, signum);
658 sigdelset (block ? &unblock_signals : &block_signals, signum);
659
660 opt_sig = strtok (nullptr, ",");
661 }
662
663 free (optarg_writable);
664 }
665
666 static void
667 set_signal_proc_mask (void)
668 {
669 /* Get the existing signal mask */
670 sigset_t set;
671 char const *debug_act;
672
673 sigemptyset (&set);
674
675 if (sigprocmask (0, nullptr, &set))
676 error (EXIT_CANCELED, errno, _("failed to get signal process mask"));
677
678 for (int i = 1; i <= SIGNUM_BOUND; i++)
679 {
680 if (sigismember (&block_signals, i))
681 {
682 sigaddset (&set, i);
683 debug_act = "BLOCK";
684 }
685 else if (sigismember (&unblock_signals, i))
686 {
687 sigdelset (&set, i);
688 debug_act = "UNBLOCK";
689 }
690 else
691 {
692 debug_act = nullptr;
693 }
694
695 if (dev_debug && debug_act)
696 {
697 char signame[SIG2STR_MAX];
698 sig2str (i, signame);
699 devmsg ("signal %s (%d) mask set to %s\n",
700 signame, i, debug_act);
701 }
702 }
703
704 if (sigprocmask (SIG_SETMASK, &set, nullptr))
705 error (EXIT_CANCELED, errno, _("failed to set signal process mask"));
706 }
707
708 static void
709 list_signal_handling (void)
710 {
711 sigset_t set;
712 char signame[SIG2STR_MAX];
713
714 sigemptyset (&set);
715 if (sigprocmask (0, nullptr, &set))
716 error (EXIT_CANCELED, errno, _("failed to get signal process mask"));
717
718 for (int i = 1; i <= SIGNUM_BOUND; i++)
719 {
720 struct sigaction act;
721 if (sigaction (i, nullptr, &act))
722 continue;
723
724 char const *ignored = act.sa_handler == SIG_IGN ? "IGNORE" : "";
725 char const *blocked = sigismember (&set, i) ? "BLOCK" : "";
726 char const *connect = *ignored && *blocked ? "," : "";
727
728 if (! *ignored && ! *blocked)
729 continue;
730
731 sig2str (i, signame);
732 fprintf (stderr, "%-10s (%2d): %s%s%s\n", signame, i,
733 blocked, connect, ignored);
734 }
735 }
736
737 static void
738 initialize_signals (void)
739 {
740 signals = xmalloc ((sizeof *signals) * (SIGNUM_BOUND + 1));
741
742 for (int i = 0 ; i <= SIGNUM_BOUND; i++)
743 signals[i] = UNCHANGED;
744
745 return;
746 }
747
748 int
749 main (int argc, char **argv)
750 {
751 int optc;
752 bool ignore_environment = false;
753 bool opt_nul_terminate_output = false;
754 char const *newdir = nullptr;
755
756 initialize_main (&argc, &argv);
757 set_program_name (argv[0]);
758 setlocale (LC_ALL, "");
759 bindtextdomain (PACKAGE, LOCALEDIR);
760 textdomain (PACKAGE);
761
762 initialize_exit_failure (EXIT_CANCELED);
763 atexit (close_stdout);
764
765 initialize_signals ();
766
767 while ((optc = getopt_long (argc, argv, shortopts, longopts, nullptr)) != -1)
768 {
769 switch (optc)
770 {
771 case 'i':
772 ignore_environment = true;
773 break;
774 case 'u':
775 append_unset_var (optarg);
776 break;
777 case 'v':
778 dev_debug = true;
779 break;
780 case '0':
781 opt_nul_terminate_output = true;
782 break;
783 case DEFAULT_SIGNAL_OPTION:
784 parse_signal_action_params (optarg, true);
785 parse_block_signal_params (optarg, false);
786 break;
787 case IGNORE_SIGNAL_OPTION:
788 parse_signal_action_params (optarg, false);
789 break;
790 case BLOCK_SIGNAL_OPTION:
791 parse_block_signal_params (optarg, true);
792 break;
793 case LIST_SIGNAL_HANDLING_OPTION:
794 report_signal_handling = true;
795 break;
796 case 'C':
797 newdir = optarg;
798 break;
799 case 'S':
800 parse_split_string (optarg, &optind, &argc, &argv);
801 break;
802 case ' ': case '\t': case '\n': case '\v': case '\f': case '\r':
803 /* These are undocumented options. Attempt to detect
804 incorrect shebang usage with extraneous space, e.g.:
805 #!/usr/bin/env -i command
806 In which case argv[1] == "-i command". */
807 error (0, 0, _("invalid option -- '%c'"), optc);
808 error (0, 0, _("use -[v]S to pass options in shebang lines"));
809 usage (EXIT_CANCELED);
810
811 case_GETOPT_HELP_CHAR;
812 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
813 default:
814 usage (EXIT_CANCELED);
815 }
816 }
817
818 if (optind < argc && STREQ (argv[optind], "-"))
819 {
820 ignore_environment = true;
821 ++optind;
822 }
823
824 if (ignore_environment)
825 {
826 devmsg ("cleaning environ\n");
827 static char *dummy_environ[] = { nullptr };
828 environ = dummy_environ;
829 }
830 else
831 unset_envvars ();
832
833 char *eq;
834 while (optind < argc && (eq = strchr (argv[optind], '=')))
835 {
836 devmsg ("setenv: %s\n", argv[optind]);
837
838 if (putenv (argv[optind]))
839 {
840 *eq = '\0';
841 error (EXIT_CANCELED, errno, _("cannot set %s"),
842 quote (argv[optind]));
843 }
844 optind++;
845 }
846
847 bool program_specified = optind < argc;
848
849 if (opt_nul_terminate_output && program_specified)
850 {
851 error (0, 0, _("cannot specify --null (-0) with command"));
852 usage (EXIT_CANCELED);
853 }
854
855 if (newdir && ! program_specified)
856 {
857 error (0, 0, _("must specify command with --chdir (-C)"));
858 usage (EXIT_CANCELED);
859 }
860
861 if (! program_specified)
862 {
863 /* Print the environment and exit. */
864 char *const *e = environ;
865 while (*e)
866 printf ("%s%c", *e++, opt_nul_terminate_output ? '\0' : '\n');
867 return EXIT_SUCCESS;
868 }
869
870 reset_signal_handlers ();
871 if (sig_mask_changed)
872 set_signal_proc_mask ();
873
874 if (report_signal_handling)
875 list_signal_handling ();
876
877 if (newdir)
878 {
879 devmsg ("chdir: %s\n", quoteaf (newdir));
880
881 if (chdir (newdir) != 0)
882 error (EXIT_CANCELED, errno, _("cannot change directory to %s"),
883 quoteaf (newdir));
884 }
885
886 if (dev_debug)
887 {
888 devmsg ("executing: %s\n", argv[optind]);
889 for (int i=optind; i<argc; ++i)
890 devmsg (" arg[%d]= %s\n", i-optind, quote (argv[i]));
891 }
892
893 execvp (argv[optind], &argv[optind]);
894
895 int exit_status = errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE;
896 error (0, errno, "%s", quote (argv[optind]));
897
898 if (exit_status == EXIT_ENOENT && strpbrk (argv[optind], C_ISSPACE_CHARS))
899 error (0, 0, _("use -[v]S to pass options in shebang lines"));
900
901 main_exit (exit_status);
902 }