1 /* Job execution and handling for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
25 /* Default path to search for executables. */
26 static char default_path
[] = ":/bin:/usr/bin";
28 /* Default shell to use. */
29 char default_shell
[] = "/bin/sh";
31 /* If NGROUPS_MAX == 0 then try other methods for finding a real value. */
32 #if defined (NGROUPS_MAX) && NGROUPS_MAX == 0
34 #endif /* NGROUPS_MAX == 0 */
38 #define GET_NGROUPS_MAX sysconf (_SC_NGROUPS_MAX)
39 #else /* Not POSIX. */
40 #define NGROUPS_MAX NGROUPS
44 #ifdef HAVE_SYS_WAIT_H
49 #define WAIT_NOHANG(status) waitpid (-1, (status), WNOHANG)
50 #else /* Don't have waitpid. */
55 #define WAIT_NOHANG(status) wait3 ((status), WNOHANG, (struct rusage *) 0)
56 #endif /* Have wait3. */
57 #endif /* Have waitpid. */
59 #if !defined (wait) && !defined (POSIX)
63 #ifndef HAVE_UNION_WAIT
68 #define WTERMSIG(x) ((x) & 0x7f)
71 #define WCOREDUMP(x) ((x) & 0x80)
74 #define WEXITSTATUS(x) (((x) >> 8) & 0xff)
77 #define WIFSIGNALED(x) (WTERMSIG (x) != 0)
80 #define WIFEXITED(x) (WTERMSIG (x) == 0)
83 #else /* Have `union wait'. */
85 #define WAIT_T union wait
87 #define WTERMSIG(x) ((x).w_termsig)
90 #define WCOREDUMP(x) ((x).w_coredump)
93 #define WEXITSTATUS(x) ((x).w_retcode)
96 #define WIFSIGNALED(x) (WTERMSIG(x) != 0)
99 #define WIFEXITED(x) (WTERMSIG(x) == 0)
102 #endif /* Don't have `union wait'. */
105 #ifndef HAVE_UNISTD_H
107 extern int execve ();
108 extern void _exit ();
109 extern int geteuid (), getegid ();
110 extern int setgid (), getgid ();
113 #ifndef getdtablesize
114 #ifdef HAVE_GETDTABLESIZE
115 extern int getdtablesize ();
117 #include <sys/param.h>
118 #define getdtablesize() NOFILE
122 extern int getloadavg ();
123 extern int start_remote_job_p ();
124 extern int start_remote_job (), remote_status ();
126 RETSIGTYPE
child_handler ();
127 static void free_child (), start_job_command ();
128 static int load_too_high (), job_next_command ();
130 /* Chain of all live (or recently deceased) children. */
132 struct child
*children
= 0;
134 /* Number of children currently running. */
136 unsigned int job_slots_used
= 0;
138 /* Nonzero if the `good' standard input is in use. */
140 static int good_stdin_used
= 0;
142 /* Chain of children waiting to run until the load average goes down. */
144 static struct child
*waiting_jobs
= 0;
146 /* Write an error message describing the exit status given in
147 EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
148 Append "(ignored)" if IGNORED is nonzero. */
151 child_error (target_name
, exit_code
, exit_sig
, coredump
, ignored
)
153 int exit_code
, exit_sig
, coredump
;
157 error (ignored
? "[%s] Error %d (ignored)" :
159 target_name
, exit_code
);
162 char *coredump_string
= coredump
? " (core dumped)" : "";
163 if (exit_sig
> 0 && exit_sig
< NSIG
)
164 error ("*** [%s] %s%s",
165 target_name
, sys_siglist
[exit_sig
], coredump_string
);
167 error ("*** [%s] Signal %d%s", target_name
, exit_sig
, coredump_string
);
171 static unsigned int dead_children
= 0;
173 /* Notice that a child died.
174 reap_children should be called when convenient. */
182 printf ("Got a SIGCHLD; %d unreaped children.\n", dead_children
);
185 extern int shell_function_pid
, shell_function_completed
;
187 /* Reap dead children, storing the returned status and the new command
188 state (`cs_finished') in the `file' member of the `struct child' for the
189 dead child, and removing the child from the chain. If BLOCK nonzero,
190 reap at least one child, waiting for it to die if necessary. If ERR is
191 nonzero, print an error message first. */
194 reap_children (block
, err
)
199 while ((children
!= 0 || shell_function_pid
!= 0) &&
200 (block
|| dead_children
> 0))
204 int exit_code
, exit_sig
, coredump
;
205 register struct child
*lastc
, *c
;
208 if (err
&& dead_children
== 0)
210 /* We might block for a while, so let the user know why. */
212 error ("*** Waiting for unfinished jobs....");
215 /* We have one less dead child to reap.
216 The test and decrement are not atomic; if it is compiled into:
217 register = dead_children - 1;
218 dead_children = register;
219 a SIGCHLD could come between the two instructions.
220 child_handler increments dead_children.
221 The second instruction here would lose that increment. But the
222 only effect of dead_children being wrong is that we might wait
223 longer than necessary to reap a child, and lose some parallelism;
224 and we might print the "Waiting for unfinished jobs" message above
225 when not necessary. */
227 if (dead_children
!= 0)
231 for (c
= children
; c
!= 0; c
= c
->next
)
232 printf ("Live child 0x%08lx PID %d%s\n",
233 (unsigned long int) c
,
234 c
->pid
, c
->remote
? " (remote)" : "");
236 /* First, check for remote children. */
237 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 0);
240 /* No remote children. Check for local children. */
244 pid
= WAIT_NOHANG (&status
);
247 pid
= wait (&status
);
255 pfatal_with_name ("wait");
258 /* No local children. */
262 /* Chop the status word up. */
263 exit_code
= WEXITSTATUS (status
);
264 exit_sig
= WIFSIGNALED (status
) ? WTERMSIG (status
) : 0;
265 coredump
= WCOREDUMP (status
);
269 /* We got a remote child. */
272 /* Check if this is the child of the `shell' function. */
273 if (!remote
&& pid
== shell_function_pid
)
275 /* It is. Leave an indicator for the `shell' function. */
276 if (exit_sig
== 0 && exit_code
== 127)
277 shell_function_completed
= -1;
279 shell_function_completed
= 1;
283 child_failed
= exit_sig
!= 0 || exit_code
!= 0;
285 /* Search for a child matching the deceased one. */
287 for (c
= children
; c
!= 0; lastc
= c
, c
= c
->next
)
288 if (c
->remote
== remote
&& c
->pid
== pid
)
293 /* An unknown child died. */
295 sprintf (buf
, "Unknown%s job %d", remote
? " remote" : "", pid
);
297 child_error (buf
, exit_code
, exit_sig
, coredump
,
300 error ("%s finished.", buf
);
305 printf ("Reaping %s child 0x%08lx PID %d%s\n",
306 child_failed
? "losing" : "winning",
307 (unsigned long int) c
,
308 c
->pid
, c
->remote
? " (remote)" : "");
310 /* If this child had the good stdin, say it is now free. */
314 if (child_failed
&& !c
->noerror
&& !ignore_errors_flag
)
316 /* The commands failed. Write an error message,
317 delete non-precious targets, and abort. */
318 child_error (c
->file
->name
, exit_code
, exit_sig
, coredump
, 0);
319 c
->file
->update_status
= 1;
321 delete_child_targets (c
);
327 /* The commands failed, but we don't care. */
328 child_error (c
->file
->name
,
329 exit_code
, exit_sig
, coredump
, 1);
333 /* If there are more commands to run, try to start them. */
334 if (job_next_command (c
))
336 if (handling_fatal_signal
)
338 /* Never start new commands while we are dying.
339 Since there are more commands that wanted to be run,
340 the target was not completely remade. So we treat
341 this as if a command had failed. */
342 c
->file
->command_state
= cs_finished
;
343 c
->file
->update_status
= 1;
347 /* Check again whether to start remotely.
348 Whether or not we want to changes over time.
349 Also, start_remote_job may need state set up
350 by start_remote_job_p. */
351 c
->remote
= start_remote_job_p ();
352 start_job_command (c
);
356 switch (c
->file
->command_state
)
359 /* Successfully started. Loop to reap more children. */
363 if (c
->file
->update_status
!= 0)
364 /* We failed to start the commands. */
365 delete_child_targets (c
);
369 error ("internal error: `%s' has bogus command_state \
370 %d in reap_children",
371 c
->file
->name
, (int) c
->file
->command_state
);
377 if (! handling_fatal_signal
)
378 /* Notice if the target of the commands has been changed. */
379 notice_finished_file (c
->file
);
382 printf ("Removing child 0x%08lx PID %d%s from chain.\n",
383 (unsigned long int) c
,
384 c
->pid
, c
->remote
? " (remote)" : "");
386 /* Remove the child from the chain and free it. */
390 lastc
->next
= c
->next
;
391 if (! handling_fatal_signal
) /* Avoid nonreentrancy. */
394 /* There is now another slot open. */
397 /* If the job failed, and the -k flag was not given, die,
398 unless we are already in the process of dying. */
399 if (!err
&& child_failed
&& !keep_going_flag
)
403 /* Only block for one child. */
408 /* Free the storage allocated for CHILD. */
412 register struct child
*child
;
414 if (child
->command_lines
!= 0)
416 register unsigned int i
;
417 for (i
= 0; i
< child
->file
->cmds
->ncommand_lines
; ++i
)
418 free (child
->command_lines
[i
]);
419 free ((char *) child
->command_lines
);
422 if (child
->environment
!= 0)
424 register char **ep
= child
->environment
;
427 free ((char *) child
->environment
);
430 free ((char *) child
);
434 extern sigset_t fatal_signal_set
;
440 sigemptyset (&empty
);
441 sigprocmask (SIG_SETMASK
, &empty
, (sigset_t
*) 0);
445 /* Start a job to run the commands specified in CHILD.
446 CHILD is updated to reflect the commands and ID of the child process. */
449 start_job_command (child
)
450 register struct child
*child
;
452 static int bad_stdin
= -1;
454 int flags
= child
->file
->cmds
->lines_flags
[child
->command_line
- 1];
457 p
= child
->command_ptr
;
458 child
->noerror
= flags
& COMMANDS_NOERROR
;
462 flags
|= COMMANDS_SILENT
;
465 else if (!isblank (*p
) && *p
!= '+')
470 /* If -q was given, just say that updating `failed'. */
471 if (question_flag
&& !(flags
& COMMANDS_RECURSE
))
474 /* There may be some preceding whitespace left if there
475 was nothing but a backslash on the first line. */
478 /* Figure out an argument list from this command line. */
482 argv
= construct_command_argv (p
, &end
, child
->file
);
484 child
->command_ptr
= NULL
;
488 child
->command_ptr
= end
;
492 if (touch_flag
&& !(flags
& COMMANDS_RECURSE
))
494 /* Go on to the next command. It might be the recursive one.
495 We construct ARGV only to find the end of the command line. */
497 free ((char *) argv
);
503 /* This line has no commands. Go to the next. */
504 if (job_next_command (child
))
505 start_job_command (child
);
509 /* Print out the command. */
511 if (just_print_flag
|| (!(flags
& COMMANDS_SILENT
) && !silent_flag
))
514 /* Tell update_goal_chain that a command has been started on behalf of
515 this target. It is important that this happens here and not in
516 reap_children (where we used to do it), because reap_children might be
517 reaping children from a different target. We want this increment to
518 guaranteedly indicate that a command was started for the dependency
519 chain (i.e., update_file recursion chain) we are processing. */
523 /* If -n was given, recurse to get the next line in the sequence. */
525 if (just_print_flag
&& !(flags
& COMMANDS_RECURSE
))
528 free ((char *) argv
);
529 if (job_next_command (child
))
530 start_job_command (child
);
534 /* Flush the output streams so they won't have things written twice. */
539 /* Set up a bad standard input that reads from a broken pipe. */
543 /* Make a file descriptor that is the read end of a broken pipe.
544 This will be used for some children's standard inputs. */
548 /* Close the write side. */
549 (void) close (pd
[1]);
550 /* Save the read side. */
555 /* Decide whether to give this child the `good' standard input
556 (one that points to the terminal or whatever), or the `bad' one
557 that points to the read side of a broken pipe. */
559 child
->good_stdin
= !good_stdin_used
;
560 if (child
->good_stdin
)
565 /* Set up the environment for the child. */
566 if (child
->environment
== 0)
567 child
->environment
= target_environment (child
->file
);
569 /* start_waiting_job has set CHILD->remote if we can start a remote job. */
572 int is_remote
, id
, used_stdin
;
573 if (start_remote_job (argv
, child
->environment
,
574 child
->good_stdin
? 0 : bad_stdin
,
575 &is_remote
, &id
, &used_stdin
))
579 if (child
->good_stdin
&& !used_stdin
)
581 child
->good_stdin
= 0;
584 child
->remote
= is_remote
;
590 /* Fork the child process. */
593 (void) sigprocmask (SIG_BLOCK
, &fatal_signal_set
, (sigset_t
*) 0);
595 #ifdef HAVE_SIGSETMASK
596 (void) sigblock (fatal_signal_mask
);
601 child
->pid
= vfork ();
604 /* We are the child side. */
606 child_execute_job (child
->good_stdin
? 0 : bad_stdin
, 1,
607 argv
, child
->environment
);
609 else if (child
->pid
< 0)
613 perror_with_name ("vfork", "");
618 /* We are the parent side. Set the state to
619 say the commands are running and return. */
621 child
->file
->command_state
= cs_running
;
623 /* Free the storage used by the child's argument list. */
626 free ((char *) argv
);
631 child
->file
->update_status
= 1;
632 child
->file
->command_state
= cs_finished
;
635 /* Try to start a child running.
636 Returns nonzero if the child was started (and maybe finished), or zero if
637 the load was too high and the child was put on the `waiting_jobs' chain. */
640 start_waiting_job (c
)
643 /* If we can start a job remotely, we always want to, and don't care about
644 the local load average. We record that the job should be started
645 remotely in C->remote for start_job_command to test. */
647 c
->remote
= start_remote_job_p ();
649 /* If this job is to be started locally, and we are already running
650 some jobs, make this one wait if the load average is too high. */
651 if (!c
->remote
&& job_slots_used
> 0 && load_too_high ())
653 /* Put this child on the chain of children waiting
654 for the load average to go down. */
655 c
->file
->command_state
= cs_running
;
656 c
->next
= waiting_jobs
;
661 /* Start the first command; reap_children will run later command lines. */
662 start_job_command (c
);
664 switch (c
->file
->command_state
)
669 printf ("Putting child 0x%08lx PID %05d%s on the chain.\n",
670 (unsigned long int) c
,
671 c
->pid
, c
->remote
? " (remote)" : "");
673 /* One more job slot is in use. */
679 notice_finished_file (c
->file
);
684 error ("internal error: `%s' command_state == %d in new_job",
685 c
->file
->name
, (int) c
->file
->command_state
);
693 /* Create a `struct child' for FILE and start its commands running. */
697 register struct file
*file
;
699 register struct commands
*cmds
= file
->cmds
;
700 register struct child
*c
;
702 register unsigned int i
;
704 /* Let any previously decided-upon jobs that are waiting
705 for the load to go down start before this new one. */
706 start_waiting_jobs ();
708 /* Reap any children that might have finished recently. */
709 reap_children (0, 0);
711 /* Chop the commands up into lines if they aren't already. */
712 chop_commands (cmds
);
715 /* Wait for a job slot to be freed up. */
716 while (job_slots_used
== job_slots
)
717 reap_children (1, 0);
719 /* Expand the command lines and store the results in LINES. */
720 lines
= (char **) xmalloc (cmds
->ncommand_lines
* sizeof (char *));
721 for (i
= 0; i
< cmds
->ncommand_lines
; ++i
)
723 /* Collapse backslash-newline combinations that are inside variable
724 or function references. These are left alone by the parser so
725 that they will appear in the echoing of commands (where they look
726 nice); and collapsed by construct_command_argv when it tokenizes.
727 But letting them survive inside function invocations loses because
728 we don't want the functions to see them as part of the text. */
730 char *in
, *out
, *ref
;
732 /* IN points to where in the line we are scanning.
733 OUT points to where in the line we are writing.
734 When we collapse a backslash-newline combination,
735 IN gets ahead out OUT. */
737 in
= out
= cmds
->command_lines
[i
];
738 while ((ref
= index (in
, '$')) != 0)
740 ++ref
; /* Move past the $. */
743 /* Copy the text between the end of the last chunk
744 we processed (where IN points) and the new chunk
745 we are about to process (where REF points). */
746 bcopy (in
, out
, ref
- in
);
748 /* Move both pointers past the boring stuff. */
752 if (*ref
== '(' || *ref
== '{')
754 char openparen
= *ref
;
755 char closeparen
= openparen
== '(' ? ')' : '}';
759 *out
++ = *in
++; /* Copy OPENPAREN. */
760 /* IN now points past the opening paren or brace.
761 Count parens or braces until it is matched. */
765 if (*in
== closeparen
&& --count
< 0)
767 else if (*in
== '\\' && in
[1] == '\n')
769 /* We have found a backslash-newline inside a
770 variable or function reference. Eat it and
771 any following whitespace. */
774 for (p
= in
- 1; p
> ref
&& *p
== '\\'; --p
)
778 /* There were two or more backslashes, so this is
779 not really a continuation line. We don't collapse
780 the quoting backslashes here as is done in
781 collapse_continuations, because the line will
782 be collapsed again after expansion. */
786 /* Skip the backslash, newline and
787 any following whitespace. */
788 in
= next_token (in
+ 2);
790 /* Discard any preceding whitespace that has
791 already been written to the output. */
792 while (out
> ref
&& isblank (out
[-1]))
795 /* Replace it all with a single space. */
801 if (*in
== openparen
)
810 /* There are no more references in this line to worry about.
811 Copy the remaining uninteresting text to the output. */
815 /* Finally, expand the line. */
816 lines
[i
] = allocated_variable_expand_for_file (cmds
->command_lines
[i
],
820 /* Start the command sequence, record it in a new
821 `struct child', and add that to the chain. */
823 c
= (struct child
*) xmalloc (sizeof (struct child
));
825 c
->command_lines
= lines
;
830 /* Fetch the first command line to be run. */
831 if (! job_next_command (c
))
832 /* There were no commands! */
836 /* The job is now primed. Start it running. */
837 start_waiting_job (c
);
840 /* Since there is only one job slot, make things run linearly.
841 Wait for the child to die, setting the state to `cs_finished'. */
842 while (file
->command_state
== cs_running
)
843 reap_children (1, 0);
847 /* Move CHILD's pointers to the next command for it to execute.
848 Returns nonzero if there is another command. */
851 job_next_command (child
)
854 if (child
->command_ptr
== 0 || *child
->command_ptr
== '\0')
856 /* There are no more lines in the expansion of this line. */
857 if (child
->command_line
== child
->file
->cmds
->ncommand_lines
)
859 /* There are no more lines to be expanded. */
860 child
->command_ptr
= 0;
861 child
->file
->command_state
= cs_finished
;
862 child
->file
->update_status
= 0;
866 /* Get the next line to run. */
867 child
->command_ptr
= child
->command_lines
[child
->command_line
++];
875 extern int getloadavg ();
878 if (max_load_average
< 0)
882 if (getloadavg (&load
, 1) != 1)
884 static int lossage
= -1;
885 /* Complain only once for the same error. */
886 if (lossage
== -1 || errno
!= lossage
)
889 /* An errno value of zero means getloadavg is just unsupported. */
890 error ("cannot enforce load limits on this operating system");
892 perror_with_name ("cannot enforce load limit: ", "getloadavg");
899 return load
>= max_load_average
;
902 /* Start jobs that are waiting for the load to be lower. */
905 start_waiting_jobs ()
909 if (waiting_jobs
== 0)
914 /* Check for recently deceased descendants. */
915 reap_children (0, 0);
917 /* Take a job off the waiting list. */
919 waiting_jobs
= job
->next
;
921 /* Try to start that job. We break out of the loop as soon
922 as start_waiting_job puts one back on the waiting list. */
923 } while (start_waiting_job (job
) && waiting_jobs
!= 0);
926 /* Replace the current process with one executing the command in ARGV.
927 STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
928 the environment of the new program. This function does not return. */
931 child_execute_job (stdin_fd
, stdout_fd
, argv
, envp
)
932 int stdin_fd
, stdout_fd
;
936 (void) dup2 (stdin_fd
, 0);
938 (void) dup2 (stdout_fd
, 1);
940 /* Free up file descriptors. */
943 int max
= getdtablesize ();
944 for (d
= 3; d
< max
; ++d
)
948 /* Run the command. */
949 exec_command (argv
, envp
);
952 /* Search PATH for FILE.
953 If successful, store the full pathname in PROGRAM and return 1.
954 If not sucessful, return zero. */
957 search_path (file
, path
, program
)
958 char *file
, *path
, *program
;
960 if (path
== 0 || path
[0] == '\0')
963 if (index (file
, '/') != 0)
965 strcpy (program
, file
);
972 #ifdef HAVE_GETGROUPS
973 #ifndef HAVE_UNISTD_H
974 extern int getgroups ();
976 static int ngroups
= -1;
978 static GETGROUPS_T groups
[NGROUPS_MAX
];
979 #define ngroups_max NGROUPS_MAX
981 static GETGROUPS_T
*groups
= 0;
982 static int ngroups_max
;
985 ngroups_max
= GET_NGROUPS_MAX
;
986 groups
= (GETGROUPS_T
*) malloc (ngroups_max
* sizeof (GETGROUPS_T
));
989 if (groups
!= 0 && ngroups
== -1)
990 ngroups
= getgroups (ngroups_max
, groups
);
991 #endif /* Have getgroups. */
993 len
= strlen (file
) + 1;
1000 p
= index (path
, ':');
1002 p
= path
+ strlen (path
);
1005 bcopy (file
, program
, len
);
1008 bcopy (path
, program
, p
- path
);
1009 program
[p
- path
] = '/';
1010 bcopy (file
, program
+ (p
- path
) + 1, len
);
1013 if (stat (program
, &st
) == 0
1014 && S_ISREG (st
.st_mode
))
1016 if (st
.st_uid
== geteuid ())
1017 perm
= (st
.st_mode
& 0100);
1018 else if (st
.st_gid
== getegid ())
1019 perm
= (st
.st_mode
& 0010);
1022 #ifdef HAVE_GETGROUPS
1024 for (i
= 0; i
< ngroups
; ++i
)
1025 if (groups
[i
] == st
.st_gid
)
1028 perm
= (st
.st_mode
& 0010);
1030 #endif /* Have getgroups. */
1031 perm
= (st
.st_mode
& 0001);
1039 } while (*path
!= '\0');
1045 /* Replace the current process with one running the command in ARGV,
1046 with environment ENVP. This function does not return. */
1049 exec_command (argv
, envp
)
1050 char **argv
, **envp
;
1057 for (ep
= envp
; *ep
!= 0; ++ep
)
1059 if (shell
== 0 && !strncmp(*ep
, "SHELL=", 6))
1061 else if (path
== 0 && !strncmp(*ep
, "PATH=", 5))
1063 else if (path
!= 0 && shell
!= 0)
1067 /* Be the user, permanently. */
1070 if (!search_path (argv
[0], path
, program
))
1071 error ("%s: Command not found", argv
[0]);
1074 /* Run the program. */
1075 execve (program
, argv
, envp
);
1077 if (errno
== ENOEXEC
)
1079 PATH_VAR (shell_program
);
1082 shell_path
= default_shell
;
1085 if (search_path (shell
, path
, shell_program
))
1086 shell_path
= shell_program
;
1090 error ("%s: Shell program not found", shell
);
1094 if (shell_path
!= 0)
1100 while (argv
[argc
] != 0)
1103 new_argv
= (char **) alloca ((1 + argc
+ 1) * sizeof (char *));
1104 new_argv
[0] = shell_path
;
1105 new_argv
[1] = program
;
1108 new_argv
[1 + argc
] = argv
[argc
];
1112 execve (shell_path
, new_argv
, envp
);
1113 perror_with_name ("execve: ", shell_path
);
1117 perror_with_name ("execve: ", program
);
1123 /* Figure out the argument list necessary to run LINE as a command.
1124 Try to avoid using a shell. This routine handles only ' quoting.
1125 Starting quotes may be escaped with a backslash. If any of the
1126 characters in sh_chars[] is seen, or any of the builtin commands
1127 listed in sh_cmds[] is the first word of a line, the shell is used.
1129 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
1130 If *RESTP is NULL, newlines will be ignored.
1132 SHELL is the shell to use, or nil to use the default shell.
1133 IFS is the value of $IFS, or nil (meaning the default). */
1136 construct_command_argv_internal (line
, restp
, shell
, ifs
)
1137 char *line
, **restp
;
1140 static char sh_chars
[] = "#;\"*?[]&|<>(){}=$`";
1141 static char *sh_cmds
[] = { "cd", "eval", "exec", "exit", "login",
1142 "logout", "set", "umask", "wait", "while", "for",
1143 "case", "if", ":", ".", "break", "continue",
1144 "export", "read", "readonly", "shift", "times",
1145 "trap", "switch", 0 };
1151 char **new_argv
= 0;
1156 /* Make sure not to bother processing an empty line. */
1157 while (isblank (*line
))
1162 /* See if it is safe to parse commands internally. */
1164 shell
= default_shell
;
1165 else if (strcmp (shell
, default_shell
))
1169 for (ap
= ifs
; *ap
!= '\0'; ++ap
)
1170 if (*ap
!= ' ' && *ap
!= '\t' && *ap
!= '\n')
1173 i
= strlen (line
) + 1;
1175 /* More than 1 arg per character is impossible. */
1176 new_argv
= (char **) xmalloc (i
* sizeof (char *));
1178 /* All the args can fit in a buffer as big as LINE is. */
1179 ap
= new_argv
[0] = (char *) xmalloc (i
);
1182 /* I is how many complete arguments have been found. */
1185 for (p
= line
; *p
!= '\0'; ++p
)
1192 /* Inside a string, just copy any char except a closing quote. */
1198 else if (index (sh_chars
, *p
) != 0)
1199 /* Not inside a string, but it's a special char. */
1202 /* Not a special char. */
1206 /* Backslash-newline combinations are eaten. */
1209 /* Eat the backslash, the newline, and following whitespace,
1210 replacing it all with a single space. */
1213 /* If there is a tab after a backslash-newline,
1214 remove it from the source line which will be echoed,
1215 since it was most likely used to line
1216 up the continued line with the previous one. */
1220 if (ap
!= new_argv
[i
])
1221 /* Treat this as a space, ending the arg.
1222 But if it's at the beginning of the arg, it should
1223 just get eaten, rather than becoming an empty arg. */
1226 p
= next_token (p
) - 1;
1228 else if (p
[1] != '\0')
1229 /* Copy and skip the following char. */
1240 /* End of the command line. */
1245 /* Newlines are not special. */
1252 /* We have the end of an argument.
1253 Terminate the text of the argument. */
1256 /* If this argument is the command name,
1257 see if it is a built-in shell command.
1258 If so, have the shell handle it. */
1262 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
1263 if (streq (sh_cmds
[j
], new_argv
[0]))
1267 /* Ignore multiple whitespace chars. */
1269 /* Next iteration should examine the first nonwhite char. */
1281 /* Let the shell deal with an unterminated quote. */
1284 /* Terminate the last argument and the argument list. */
1287 if (new_argv
[i
][0] != '\0')
1294 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
1295 if (streq (sh_cmds
[j
], new_argv
[0]))
1299 if (new_argv
[0] == 0)
1300 /* Line was empty. */
1306 /* We must use the shell. */
1310 /* Free the old argument list we were working on. */
1316 /* SHELL may be a multi-word command. Construct a command line
1317 "SHELL -c LINE", with all special chars in LINE escaped.
1318 Then recurse, expanding this command line to get the final
1321 unsigned int shell_len
= strlen (shell
);
1322 static char minus_c
[] = " -c ";
1323 unsigned int line_len
= strlen (line
);
1325 char *new_line
= (char *) alloca (shell_len
+ (sizeof (minus_c
) - 1)
1326 + (line_len
* 2) + 1);
1329 bcopy (shell
, ap
, shell_len
);
1331 bcopy (minus_c
, ap
, sizeof (minus_c
) - 1);
1332 ap
+= sizeof (minus_c
) - 1;
1333 for (p
= line
; *p
!= '\0'; ++p
)
1335 if (restp
!= NULL
&& *p
== '\n')
1340 else if (*p
== '\\' && p
[1] == '\n')
1342 /* Eat the backslash, the newline, and following whitespace,
1343 replacing it all with a single space (which is escaped
1347 /* If there is a tab after a backslash-newline,
1348 remove it from the source line which will be echoed,
1349 since it was most likely used to line
1350 up the continued line with the previous one. */
1361 if (*p
== '\\' || *p
== '\''
1363 || index (sh_chars
, *p
) != 0)
1369 new_argv
= construct_command_argv_internal (new_line
, (char **) NULL
,
1370 (char *) 0, (char *) 0);
1376 /* Figure out the argument list necessary to run LINE as a command.
1377 Try to avoid using a shell. This routine handles only ' quoting.
1378 Starting quotes may be escaped with a backslash. If any of the
1379 characters in sh_chars[] is seen, or any of the builtin commands
1380 listed in sh_cmds[] is the first word of a line, the shell is used.
1382 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
1383 If *RESTP is NULL, newlines will be ignored.
1385 FILE is the target whose commands these are. It is used for
1386 variable expansion for $(SHELL) and $(IFS). */
1389 construct_command_argv (line
, restp
, file
)
1390 char *line
, **restp
;
1393 char *shell
= allocated_variable_expand_for_file ("$(SHELL)", file
);
1394 char *ifs
= allocated_variable_expand_for_file ("$(IFS)", file
);
1397 argv
= construct_command_argv_internal (line
, restp
, shell
, ifs
);