1 /* Job execution and handling for GNU Make.
2 Copyright (C) 1988, 89, 90, 91, 92, 93, 94, 1995 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. */
26 /* Default shell to use. */
27 char default_shell
[] = "/bin/sh";
31 static int dos_pid
= 123;
32 static int dos_status
;
33 static char *dos_bname
;
34 static char *dos_bename
;
35 static int dos_batch_file
;
39 /* If NGROUPS_MAX == 0 then try other methods for finding a real value. */
40 #if defined (NGROUPS_MAX) && NGROUPS_MAX == 0
42 #endif /* NGROUPS_MAX == 0 */
46 #define GET_NGROUPS_MAX sysconf (_SC_NGROUPS_MAX)
47 #else /* Not POSIX. */
48 #define NGROUPS_MAX NGROUPS
52 #ifdef HAVE_SYS_WAIT_H
57 #define WAIT_NOHANG(status) waitpid (-1, (status), WNOHANG)
58 #else /* Don't have waitpid. */
63 #define WAIT_NOHANG(status) wait3 ((status), WNOHANG, (struct rusage *) 0)
64 #endif /* Have wait3. */
65 #endif /* Have waitpid. */
67 #if !defined (wait) && !defined (POSIX)
71 #ifndef HAVE_UNION_WAIT
76 #define WTERMSIG(x) ((x) & 0x7f)
79 #define WCOREDUMP(x) ((x) & 0x80)
82 #define WEXITSTATUS(x) (((x) >> 8) & 0xff)
85 #define WIFSIGNALED(x) (WTERMSIG (x) != 0)
88 #define WIFEXITED(x) (WTERMSIG (x) == 0)
91 #else /* Have `union wait'. */
93 #define WAIT_T union wait
95 #define WTERMSIG(x) ((x).w_termsig)
98 #define WCOREDUMP(x) ((x).w_coredump)
101 #define WEXITSTATUS(x) ((x).w_retcode)
104 #define WIFSIGNALED(x) (WTERMSIG(x) != 0)
107 #define WIFEXITED(x) (WTERMSIG(x) == 0)
110 #endif /* Don't have `union wait'. */
113 #ifndef HAVE_UNISTD_H
115 extern int execve ();
116 extern void _exit ();
117 extern int geteuid (), getegid ();
118 extern int setgid (), getgid ();
121 #ifndef getdtablesize
122 #ifdef HAVE_GETDTABLESIZE
123 extern int getdtablesize ();
125 #ifdef HAVE_SYSCONF_OPEN_MAX
126 #define getdtablesize() ((int) sysconf (_SC_OPEN_MAX))
128 #include <sys/param.h>
129 #define getdtablesize() NOFILE
130 #if !defined (NOFILE) && defined (NOFILES_MAX)
131 /* SCO 3.2 "devsys 4.2" defines NOFILES_{MIN,MAX} in lieu of NOFILE. */
132 #define NOFILE NOFILES_MAX
138 extern int getloadavg ();
139 extern int start_remote_job_p ();
140 extern int start_remote_job (), remote_status ();
142 RETSIGTYPE
child_handler ();
143 static void free_child (), start_job_command ();
144 static int load_too_high (), job_next_command ();
146 /* Chain of all live (or recently deceased) children. */
148 struct child
*children
= 0;
150 /* Number of children currently running. */
152 unsigned int job_slots_used
= 0;
154 /* Nonzero if the `good' standard input is in use. */
156 static int good_stdin_used
= 0;
158 /* Chain of children waiting to run until the load average goes down. */
160 static struct child
*waiting_jobs
= 0;
162 /* Write an error message describing the exit status given in
163 EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
164 Append "(ignored)" if IGNORED is nonzero. */
167 child_error (target_name
, exit_code
, exit_sig
, coredump
, ignored
)
169 int exit_code
, exit_sig
, coredump
;
173 error (ignored
? "[%s] Error %d (ignored)" :
175 target_name
, exit_code
);
178 char *coredump_string
= coredump
? " (core dumped)" : "";
179 if (exit_sig
> 0 && exit_sig
< NSIG
)
180 error ("*** [%s] %s%s",
181 target_name
, sys_siglist
[exit_sig
], coredump_string
);
183 error ("*** [%s] Signal %d%s", target_name
, exit_sig
, coredump_string
);
187 static unsigned int dead_children
= 0;
189 /* Notice that a child died.
190 reap_children should be called when convenient. */
198 printf ("Got a SIGCHLD; %d unreaped children.\n", dead_children
);
201 extern int shell_function_pid
, shell_function_completed
;
203 /* Reap dead children, storing the returned status and the new command
204 state (`cs_finished') in the `file' member of the `struct child' for the
205 dead child, and removing the child from the chain. If BLOCK nonzero,
206 reap at least one child, waiting for it to die if necessary. If ERR is
207 nonzero, print an error message first. */
210 reap_children (block
, err
)
215 while ((children
!= 0 || shell_function_pid
!= 0) &&
216 (block
|| dead_children
> 0))
220 int exit_code
, exit_sig
, coredump
;
221 register struct child
*lastc
, *c
;
223 int any_remote
, any_local
;
225 if (err
&& dead_children
== 0)
227 /* We might block for a while, so let the user know why. */
229 error ("*** Waiting for unfinished jobs....");
232 /* We have one less dead child to reap.
233 The test and decrement are not atomic; if it is compiled into:
234 register = dead_children - 1;
235 dead_children = register;
236 a SIGCHLD could come between the two instructions.
237 child_handler increments dead_children.
238 The second instruction here would lose that increment. But the
239 only effect of dead_children being wrong is that we might wait
240 longer than necessary to reap a child, and lose some parallelism;
241 and we might print the "Waiting for unfinished jobs" message above
242 when not necessary. */
244 if (dead_children
!= 0)
248 any_local
= shell_function_pid
!= -1;
249 for (c
= children
; c
!= 0; c
= c
->next
)
251 any_remote
|= c
->remote
;
252 any_local
|= ! c
->remote
;
254 printf ("Live child 0x%08lx PID %d%s\n",
255 (unsigned long int) c
,
256 c
->pid
, c
->remote
? " (remote)" : "");
259 /* First, check for remote children. */
261 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 0);
271 pfatal_with_name ("remote_status");
276 /* No remote children. Check for local children. */
282 pid
= WAIT_NOHANG (&status
);
285 pid
= wait (&status
);
296 pfatal_with_name ("wait");
300 /* No local children. */
301 if (block
&& any_remote
)
303 /* Now try a blocking wait for a remote child. */
304 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 1);
306 goto remote_status_lose
;
308 /* No remote children either. Finally give up. */
311 /* We got a remote child. */
319 /* Chop the status word up. */
320 exit_code
= WEXITSTATUS (status
);
321 exit_sig
= WIFSIGNALED (status
) ? WTERMSIG (status
) : 0;
322 coredump
= WCOREDUMP (status
);
325 /* Life is very different on MSDOS. */
328 exit_code
= dos_status
;
331 #endif /* Not MSDOS. */
334 /* We got a remote child. */
337 /* Check if this is the child of the `shell' function. */
338 if (!remote
&& pid
== shell_function_pid
)
340 /* It is. Leave an indicator for the `shell' function. */
341 if (exit_sig
== 0 && exit_code
== 127)
342 shell_function_completed
= -1;
344 shell_function_completed
= 1;
348 child_failed
= exit_sig
!= 0 || exit_code
!= 0;
350 /* Search for a child matching the deceased one. */
352 for (c
= children
; c
!= 0; lastc
= c
, c
= c
->next
)
353 if (c
->remote
== remote
&& c
->pid
== pid
)
358 /* An unknown child died. */
360 sprintf (buf
, "Unknown%s job %d", remote
? " remote" : "", pid
);
362 child_error (buf
, exit_code
, exit_sig
, coredump
,
365 error ("%s finished.", buf
);
370 printf ("Reaping %s child 0x%08lx PID %d%s\n",
371 child_failed
? "losing" : "winning",
372 (unsigned long int) c
,
373 c
->pid
, c
->remote
? " (remote)" : "");
375 /* If this child had the good stdin, say it is now free. */
379 if (child_failed
&& !c
->noerror
&& !ignore_errors_flag
)
381 /* The commands failed. Write an error message,
382 delete non-precious targets, and abort. */
383 static int delete_on_error
= -1;
384 child_error (c
->file
->name
, exit_code
, exit_sig
, coredump
, 0);
385 c
->file
->update_status
= 1;
386 if (delete_on_error
== -1)
388 struct file
*f
= lookup_file (".DELETE_ON_ERROR");
389 delete_on_error
= f
!= 0 && f
->is_target
;
391 if (exit_sig
!= 0 || delete_on_error
)
392 delete_child_targets (c
);
398 /* The commands failed, but we don't care. */
399 child_error (c
->file
->name
,
400 exit_code
, exit_sig
, coredump
, 1);
404 /* If there are more commands to run, try to start them. */
405 if (job_next_command (c
))
407 if (handling_fatal_signal
)
409 /* Never start new commands while we are dying.
410 Since there are more commands that wanted to be run,
411 the target was not completely remade. So we treat
412 this as if a command had failed. */
413 c
->file
->update_status
= 1;
417 /* Check again whether to start remotely.
418 Whether or not we want to changes over time.
419 Also, start_remote_job may need state set up
420 by start_remote_job_p. */
421 c
->remote
= start_remote_job_p ();
422 start_job_command (c
);
423 if (c
->file
->command_state
== cs_running
)
424 /* We successfully started the new command.
425 Loop to reap more children. */
429 if (c
->file
->update_status
!= 0)
430 /* We failed to start the commands. */
431 delete_child_targets (c
);
434 /* There are no more commands. We got through them all
435 without an unignored error. Now the target has been
436 successfully updated. */
437 c
->file
->update_status
= 0;
440 /* When we get here, all the commands for C->file are finished
441 (or aborted) and C->file->update_status contains 0 or 1. But
442 C->file->command_state is still cs_running if all the commands
443 ran; notice_finish_file looks for cs_running to tell it that
444 it's interesting to check the file's modtime again now. */
446 if (! handling_fatal_signal
)
447 /* Notice if the target of the commands has been changed.
448 This also propagates its values for command_state and
449 update_status to its also_make files. */
450 notice_finished_file (c
->file
);
453 printf ("Removing child 0x%08lx PID %d%s from chain.\n",
454 (unsigned long int) c
,
455 c
->pid
, c
->remote
? " (remote)" : "");
457 /* Remove the child from the chain and free it. */
461 lastc
->next
= c
->next
;
462 if (! handling_fatal_signal
) /* Avoid nonreentrancy. */
465 /* There is now another slot open. */
468 /* If the job failed, and the -k flag was not given, die,
469 unless we are already in the process of dying. */
470 if (!err
&& child_failed
&& !keep_going_flag
)
474 /* Only block for one child. */
479 /* Free the storage allocated for CHILD. */
483 register struct child
*child
;
485 if (child
->command_lines
!= 0)
487 register unsigned int i
;
488 for (i
= 0; i
< child
->file
->cmds
->ncommand_lines
; ++i
)
489 free (child
->command_lines
[i
]);
490 free ((char *) child
->command_lines
);
493 if (child
->environment
!= 0)
495 register char **ep
= child
->environment
;
498 free ((char *) child
->environment
);
501 free ((char *) child
);
512 extern sigset_t fatal_signal_set
;
518 sigemptyset (&empty
);
519 sigprocmask (SIG_SETMASK
, &empty
, (sigset_t
*) 0);
524 /* Start a job to run the commands specified in CHILD.
525 CHILD is updated to reflect the commands and ID of the child process. */
528 start_job_command (child
)
529 register struct child
*child
;
531 static int bad_stdin
= -1;
536 /* Combine the flags parsed for the line itself with
537 the flags specified globally for this target. */
538 flags
= (child
->file
->command_flags
539 | child
->file
->cmds
->lines_flags
[child
->command_line
- 1]);
541 p
= child
->command_ptr
;
542 child
->noerror
= flags
& COMMANDS_NOERROR
;
546 flags
|= COMMANDS_SILENT
;
548 flags
|= COMMANDS_RECURSE
;
551 else if (!isblank (*p
) && *p
!= '+')
556 /* If -q was given, just say that updating `failed'. The exit status of
557 1 tells the user that -q is saying `something to do'; the exit status
558 for a random error is 2. */
559 if (question_flag
&& !(flags
& COMMANDS_RECURSE
))
561 child
->file
->update_status
= 1;
562 notice_finished_file (child
->file
);
566 /* There may be some preceding whitespace left if there
567 was nothing but a backslash on the first line. */
570 /* Figure out an argument list from this command line. */
574 argv
= construct_command_argv (p
, &end
, child
->file
);
576 child
->command_ptr
= NULL
;
580 child
->command_ptr
= end
;
584 if (touch_flag
&& !(flags
& COMMANDS_RECURSE
))
586 /* Go on to the next command. It might be the recursive one.
587 We construct ARGV only to find the end of the command line. */
589 free ((char *) argv
);
595 /* This line has no commands. Go to the next. */
596 if (job_next_command (child
))
597 start_job_command (child
);
600 /* No more commands. All done. */
601 child
->file
->update_status
= 0;
602 notice_finished_file (child
->file
);
607 /* Print out the command. */
609 if (just_print_flag
|| (!(flags
& COMMANDS_SILENT
) && !silent_flag
))
612 /* Tell update_goal_chain that a command has been started on behalf of
613 this target. It is important that this happens here and not in
614 reap_children (where we used to do it), because reap_children might be
615 reaping children from a different target. We want this increment to
616 guaranteedly indicate that a command was started for the dependency
617 chain (i.e., update_file recursion chain) we are processing. */
621 /* If -n was given, recurse to get the next line in the sequence. */
623 if (just_print_flag
&& !(flags
& COMMANDS_RECURSE
))
626 free ((char *) argv
);
627 if (job_next_command (child
))
628 start_job_command (child
);
629 child
->file
->update_status
= 0;
633 /* Flush the output streams so they won't have things written twice. */
638 /* Set up a bad standard input that reads from a broken pipe. */
642 /* Make a file descriptor that is the read end of a broken pipe.
643 This will be used for some children's standard inputs. */
647 /* Close the write side. */
648 (void) close (pd
[1]);
649 /* Save the read side. */
654 /* Decide whether to give this child the `good' standard input
655 (one that points to the terminal or whatever), or the `bad' one
656 that points to the read side of a broken pipe. */
658 child
->good_stdin
= !good_stdin_used
;
659 if (child
->good_stdin
)
664 /* Set up the environment for the child. */
665 if (child
->environment
== 0)
666 child
->environment
= target_environment (child
->file
);
670 /* start_waiting_job has set CHILD->remote if we can start a remote job. */
673 int is_remote
, id
, used_stdin
;
674 if (start_remote_job (argv
, child
->environment
,
675 child
->good_stdin
? 0 : bad_stdin
,
676 &is_remote
, &id
, &used_stdin
))
680 if (child
->good_stdin
&& !used_stdin
)
682 child
->good_stdin
= 0;
685 child
->remote
= is_remote
;
691 /* Fork the child process. */
693 char **parent_environ
;
696 (void) sigprocmask (SIG_BLOCK
, &fatal_signal_set
, (sigset_t
*) 0);
698 #ifdef HAVE_SIGSETMASK
699 (void) sigblock (fatal_signal_mask
);
704 parent_environ
= environ
;
705 child
->pid
= vfork ();
706 environ
= parent_environ
; /* Restore value child may have clobbered. */
709 /* We are the child side. */
711 child_execute_job (child
->good_stdin
? 0 : bad_stdin
, 1,
712 argv
, child
->environment
);
714 else if (child
->pid
< 0)
718 perror_with_name ("vfork", "");
724 dos_status
= spawnvpe (P_WAIT
, argv
[0], argv
, child
->environment
);
726 child
->pid
= dos_pid
++;
730 remove (dos_bname
); /* Ignore errors. */
731 if (access (dos_bename
, 0))
737 #endif /* Not MSDOS. */
739 /* We are the parent side. Set the state to
740 say the commands are running and return. */
742 set_command_state (child
->file
, cs_running
);
744 /* Free the storage used by the child's argument list. */
747 free ((char *) argv
);
752 child
->file
->update_status
= 2;
753 notice_finished_file (child
->file
);
756 /* Try to start a child running.
757 Returns nonzero if the child was started (and maybe finished), or zero if
758 the load was too high and the child was put on the `waiting_jobs' chain. */
761 start_waiting_job (c
)
764 /* If we can start a job remotely, we always want to, and don't care about
765 the local load average. We record that the job should be started
766 remotely in C->remote for start_job_command to test. */
768 c
->remote
= start_remote_job_p ();
770 /* If this job is to be started locally, and we are already running
771 some jobs, make this one wait if the load average is too high. */
772 if (!c
->remote
&& job_slots_used
> 0 && load_too_high ())
774 /* Put this child on the chain of children waiting
775 for the load average to go down. */
776 set_command_state (c
->file
, cs_running
);
777 c
->next
= waiting_jobs
;
782 /* Start the first command; reap_children will run later command lines. */
783 start_job_command (c
);
785 switch (c
->file
->command_state
)
790 printf ("Putting child 0x%08lx PID %05d%s on the chain.\n",
791 (unsigned long int) c
,
792 c
->pid
, c
->remote
? " (remote)" : "");
794 /* One more job slot is in use. */
800 /* All the command lines turned out to be empty. */
801 c
->file
->update_status
= 0;
805 notice_finished_file (c
->file
);
810 assert (c
->file
->command_state
== cs_finished
);
817 /* Create a `struct child' for FILE and start its commands running. */
821 register struct file
*file
;
823 register struct commands
*cmds
= file
->cmds
;
824 register struct child
*c
;
826 register unsigned int i
;
828 /* Let any previously decided-upon jobs that are waiting
829 for the load to go down start before this new one. */
830 start_waiting_jobs ();
832 /* Reap any children that might have finished recently. */
833 reap_children (0, 0);
835 /* Chop the commands up into lines if they aren't already. */
836 chop_commands (cmds
);
839 /* Wait for a job slot to be freed up. */
840 while (job_slots_used
== job_slots
)
841 reap_children (1, 0);
843 /* Expand the command lines and store the results in LINES. */
844 lines
= (char **) xmalloc (cmds
->ncommand_lines
* sizeof (char *));
845 for (i
= 0; i
< cmds
->ncommand_lines
; ++i
)
847 /* Collapse backslash-newline combinations that are inside variable
848 or function references. These are left alone by the parser so
849 that they will appear in the echoing of commands (where they look
850 nice); and collapsed by construct_command_argv when it tokenizes.
851 But letting them survive inside function invocations loses because
852 we don't want the functions to see them as part of the text. */
854 char *in
, *out
, *ref
;
856 /* IN points to where in the line we are scanning.
857 OUT points to where in the line we are writing.
858 When we collapse a backslash-newline combination,
859 IN gets ahead out OUT. */
861 in
= out
= cmds
->command_lines
[i
];
862 while ((ref
= index (in
, '$')) != 0)
864 ++ref
; /* Move past the $. */
867 /* Copy the text between the end of the last chunk
868 we processed (where IN points) and the new chunk
869 we are about to process (where REF points). */
870 bcopy (in
, out
, ref
- in
);
872 /* Move both pointers past the boring stuff. */
876 if (*ref
== '(' || *ref
== '{')
878 char openparen
= *ref
;
879 char closeparen
= openparen
== '(' ? ')' : '}';
883 *out
++ = *in
++; /* Copy OPENPAREN. */
884 /* IN now points past the opening paren or brace.
885 Count parens or braces until it is matched. */
889 if (*in
== closeparen
&& --count
< 0)
891 else if (*in
== '\\' && in
[1] == '\n')
893 /* We have found a backslash-newline inside a
894 variable or function reference. Eat it and
895 any following whitespace. */
898 for (p
= in
- 1; p
> ref
&& *p
== '\\'; --p
)
902 /* There were two or more backslashes, so this is
903 not really a continuation line. We don't collapse
904 the quoting backslashes here as is done in
905 collapse_continuations, because the line will
906 be collapsed again after expansion. */
910 /* Skip the backslash, newline and
911 any following whitespace. */
912 in
= next_token (in
+ 2);
914 /* Discard any preceding whitespace that has
915 already been written to the output. */
916 while (out
> ref
&& isblank (out
[-1]))
919 /* Replace it all with a single space. */
925 if (*in
== openparen
)
934 /* There are no more references in this line to worry about.
935 Copy the remaining uninteresting text to the output. */
939 /* Finally, expand the line. */
940 lines
[i
] = allocated_variable_expand_for_file (cmds
->command_lines
[i
],
944 /* Start the command sequence, record it in a new
945 `struct child', and add that to the chain. */
947 c
= (struct child
*) xmalloc (sizeof (struct child
));
949 c
->command_lines
= lines
;
954 /* Fetch the first command line to be run. */
955 if (! job_next_command (c
))
957 /* There were no commands! */
959 c
->file
->update_status
= 0;
963 /* The job is now primed. Start it running. */
964 start_waiting_job (c
);
967 /* Since there is only one job slot, make things run linearly.
968 Wait for the child to die, setting the state to `cs_finished'. */
969 while (file
->command_state
== cs_running
)
970 reap_children (1, 0);
974 /* Move CHILD's pointers to the next command for it to execute.
975 Returns nonzero if there is another command. */
978 job_next_command (child
)
981 if (child
->command_ptr
== 0 || *child
->command_ptr
== '\0')
983 /* There are no more lines in the expansion of this line. */
984 if (child
->command_line
== child
->file
->cmds
->ncommand_lines
)
986 /* There are no more lines to be expanded. */
987 child
->command_ptr
= 0;
991 /* Get the next line to run. */
992 child
->command_ptr
= child
->command_lines
[child
->command_line
++];
1003 extern int getloadavg ();
1006 if (max_load_average
< 0)
1010 if (getloadavg (&load
, 1) != 1)
1012 static int lossage
= -1;
1013 /* Complain only once for the same error. */
1014 if (lossage
== -1 || errno
!= lossage
)
1017 /* An errno value of zero means getloadavg is just unsupported. */
1018 error ("cannot enforce load limits on this operating system");
1020 perror_with_name ("cannot enforce load limit: ", "getloadavg");
1027 return load
>= max_load_average
;
1031 /* Start jobs that are waiting for the load to be lower. */
1034 start_waiting_jobs ()
1038 if (waiting_jobs
== 0)
1043 /* Check for recently deceased descendants. */
1044 reap_children (0, 0);
1046 /* Take a job off the waiting list. */
1048 waiting_jobs
= job
->next
;
1050 /* Try to start that job. We break out of the loop as soon
1051 as start_waiting_job puts one back on the waiting list. */
1052 } while (start_waiting_job (job
) && waiting_jobs
!= 0);
1055 /* Replace the current process with one executing the command in ARGV.
1056 STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
1057 the environment of the new program. This function does not return. */
1060 child_execute_job (stdin_fd
, stdout_fd
, argv
, envp
)
1061 int stdin_fd
, stdout_fd
;
1062 char **argv
, **envp
;
1065 (void) dup2 (stdin_fd
, 0);
1067 (void) dup2 (stdout_fd
, 1);
1069 /* Free up file descriptors. */
1072 int max
= getdtablesize ();
1073 for (d
= 3; d
< max
; ++d
)
1077 /* Run the command. */
1078 exec_command (argv
, envp
);
1083 /* Default path to search for executables. */
1084 static char default_path
[] = ":/bin:/usr/bin";
1086 /* Search PATH for FILE.
1087 If successful, store the full pathname in PROGRAM and return 1.
1088 If not sucessful, return zero. */
1091 search_path (file
, path
, program
)
1092 char *file
, *path
, *program
;
1094 if (path
== 0 || path
[0] == '\0')
1095 path
= default_path
;
1099 strpbrk (file
, "/\\:")
1105 strcpy (program
, file
);
1112 #ifdef HAVE_GETGROUPS
1113 #ifndef HAVE_UNISTD_H
1114 extern int getgroups ();
1116 static int ngroups
= -1;
1118 static GETGROUPS_T groups
[NGROUPS_MAX
];
1119 #define ngroups_max NGROUPS_MAX
1121 static GETGROUPS_T
*groups
= 0;
1122 static int ngroups_max
;
1125 ngroups_max
= GET_NGROUPS_MAX
;
1126 groups
= (GETGROUPS_T
*) malloc (ngroups_max
* sizeof (GETGROUPS_T
));
1129 if (groups
!= 0 && ngroups
== -1)
1130 ngroups
= getgroups (ngroups_max
, groups
);
1131 #endif /* Have getgroups. */
1133 len
= strlen (file
) + 1;
1140 p
= index (path
, PATH_SEPARATOR_CHAR
);
1142 p
= path
+ strlen (path
);
1145 bcopy (file
, program
, len
);
1148 bcopy (path
, program
, p
- path
);
1149 program
[p
- path
] = '/';
1150 bcopy (file
, program
+ (p
- path
) + 1, len
);
1153 if (safe_stat (program
, &st
) == 0
1154 && S_ISREG (st
.st_mode
))
1156 if (st
.st_uid
== geteuid ())
1157 perm
= (st
.st_mode
& 0100);
1158 else if (st
.st_gid
== getegid ())
1159 perm
= (st
.st_mode
& 0010);
1162 #ifdef HAVE_GETGROUPS
1164 for (i
= 0; i
< ngroups
; ++i
)
1165 if (groups
[i
] == st
.st_gid
)
1168 perm
= (st
.st_mode
& 0010);
1170 #endif /* Have getgroups. */
1171 perm
= (st
.st_mode
& 0001);
1179 } while (*path
!= '\0');
1184 #endif /* search_path commented out */
1186 /* Replace the current process with one running the command in ARGV,
1187 with environment ENVP. This function does not return. */
1190 exec_command (argv
, envp
)
1191 char **argv
, **envp
;
1193 /* Be the user, permanently. */
1196 /* Run the program. */
1198 execvp (argv
[0], argv
);
1203 error ("%s: Command not found", argv
[0]);
1207 /* The file is not executable. Try it as a shell script. */
1208 extern char *getenv ();
1213 shell
= getenv ("SHELL");
1215 shell
= default_shell
;
1218 while (argv
[argc
] != 0)
1221 new_argv
= (char **) alloca ((1 + argc
+ 1) * sizeof (char *));
1222 new_argv
[0] = shell
;
1223 new_argv
[1] = program
;
1226 new_argv
[1 + argc
] = argv
[argc
];
1230 execvp (shell
, new_argv
);
1231 if (errno
== ENOENT
)
1232 error ("%s: Shell program not found", shell
);
1234 perror_with_name ("execvp: ", shell
);
1239 perror_with_name ("execvp: ", argv
[0]);
1246 /* Figure out the argument list necessary to run LINE as a command. Try to
1247 avoid using a shell. This routine handles only ' quoting, and " quoting
1248 when no backslash, $ or ` characters are seen in the quotes. Starting
1249 quotes may be escaped with a backslash. If any of the characters in
1250 sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
1251 is the first word of a line, the shell is used.
1253 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
1254 If *RESTP is NULL, newlines will be ignored.
1256 SHELL is the shell to use, or nil to use the default shell.
1257 IFS is the value of $IFS, or nil (meaning the default). */
1260 construct_command_argv_internal (line
, restp
, shell
, ifs
)
1261 char *line
, **restp
;
1265 static char sh_chars
[] = "\"|<>";
1266 static char *sh_cmds
[] = { "break", "call", "cd", "chcp", "chdir", "cls",
1267 "copy", "ctty", "date", "del", "dir", "echo",
1268 "erase", "exit", "for", "goto", "if", "if", "md",
1269 "mkdir", "path", "pause", "prompt", "rem", "ren",
1270 "rename", "set", "shift", "time", "type",
1271 "ver", "verify", "vol", ":", 0 };
1273 static char sh_chars
[] = "#;\"*?[]&|<>(){}$`^";
1274 static char *sh_cmds
[] = { "cd", "eval", "exec", "exit", "login",
1275 "logout", "set", "umask", "wait", "while", "for",
1276 "case", "if", ":", ".", "break", "continue",
1277 "export", "read", "readonly", "shift", "times",
1278 "trap", "switch", 0 };
1284 int instring
, word_has_equals
, seen_nonequals
;
1285 char **new_argv
= 0;
1290 /* Make sure not to bother processing an empty line. */
1291 while (isblank (*line
))
1296 /* See if it is safe to parse commands internally. */
1298 shell
= default_shell
;
1299 else if (strcmp (shell
, default_shell
))
1303 for (ap
= ifs
; *ap
!= '\0'; ++ap
)
1304 if (*ap
!= ' ' && *ap
!= '\t' && *ap
!= '\n')
1307 i
= strlen (line
) + 1;
1309 /* More than 1 arg per character is impossible. */
1310 new_argv
= (char **) xmalloc (i
* sizeof (char *));
1312 /* All the args can fit in a buffer as big as LINE is. */
1313 ap
= new_argv
[0] = (char *) xmalloc (i
);
1316 /* I is how many complete arguments have been found. */
1318 instring
= word_has_equals
= seen_nonequals
= 0;
1319 for (p
= line
; *p
!= '\0'; ++p
)
1327 /* Inside a string, just copy any char except a closing quote
1328 or a backslash-newline combination. */
1331 else if (*p
== '\\' && p
[1] == '\n')
1332 goto swallow_escaped_newline
;
1333 else if (*p
== '\n' && restp
!= NULL
)
1335 /* End of the command line. */
1339 /* Backslash, $, and ` are special inside double quotes.
1340 If we see any of those, punt. */
1341 else if (instring
== '"' && index ("\\$`", *p
) != 0)
1346 else if (index (sh_chars
, *p
) != 0)
1347 /* Not inside a string, but it's a special char. */
1350 /* Not a special char. */
1354 /* Equals is a special character in leading words before the
1355 first word with no equals sign in it. This is not the case
1356 with sh -k, but we never get here when using nonstandard
1358 if (! seen_nonequals
)
1360 word_has_equals
= 1;
1365 /* Backslash-newline combinations are eaten. */
1368 swallow_escaped_newline
:
1370 /* Eat the backslash, the newline, and following whitespace,
1371 replacing it all with a single space. */
1374 /* If there is a tab after a backslash-newline,
1375 remove it from the source line which will be echoed,
1376 since it was most likely used to line
1377 up the continued line with the previous one. */
1385 if (ap
!= new_argv
[i
])
1386 /* Treat this as a space, ending the arg.
1387 But if it's at the beginning of the arg, it should
1388 just get eaten, rather than becoming an empty arg. */
1391 p
= next_token (p
) - 1;
1394 else if (p
[1] != '\0')
1395 /* Copy and skip the following char. */
1407 /* End of the command line. */
1412 /* Newlines are not special. */
1419 /* We have the end of an argument.
1420 Terminate the text of the argument. */
1424 /* Update SEEN_NONEQUALS, which tells us if every word
1425 heretofore has contained an `='. */
1426 seen_nonequals
|= ! word_has_equals
;
1427 if (word_has_equals
&& ! seen_nonequals
)
1428 /* An `=' in a word before the first
1429 word without one is magical. */
1431 word_has_equals
= 0; /* Prepare for the next word. */
1433 /* If this argument is the command name,
1434 see if it is a built-in shell command.
1435 If so, have the shell handle it. */
1439 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
1440 if (streq (sh_cmds
[j
], new_argv
[0]))
1444 /* Ignore multiple whitespace chars. */
1446 /* Next iteration should examine the first nonwhite char. */
1458 /* Let the shell deal with an unterminated quote. */
1461 /* Terminate the last argument and the argument list. */
1464 if (new_argv
[i
][0] != '\0')
1471 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
1472 if (streq (sh_cmds
[j
], new_argv
[0]))
1476 if (new_argv
[0] == 0)
1477 /* Line was empty. */
1483 /* We must use the shell. */
1487 /* Free the old argument list we were working on. */
1498 dos_bname
= tempnam (".", "mk");
1499 for (i
= 0; dos_bname
[i
] != '\0'; ++i
)
1500 if (dos_bname
[i
] == '/')
1501 dos_bname
[i
] = '\\';
1502 dos_bename
= (char *) xmalloc (strlen (dos_bname
) + 5);
1503 strcpy (dos_bename
, dos_bname
);
1504 strcat (dos_bname
, ".bat");
1505 strcat (dos_bename
, ".err");
1507 batch
= fopen(bename
, "w"); /* Create a file. */
1510 batch
= fopen (dos_bname
, "w");
1511 fputs ("@echo off\n", batch
);
1512 fputs (line
, batch
);
1513 fprintf (batch
, "\nif errorlevel 1 del %s\n", dos_bename
);
1515 new_argv
= (char **) xmalloc(2 * sizeof(char *));
1516 new_argv
[0] = strdup (bname
);
1519 #else /* Not MSDOS. */
1521 /* SHELL may be a multi-word command. Construct a command line
1522 "SHELL -c LINE", with all special chars in LINE escaped.
1523 Then recurse, expanding this command line to get the final
1526 unsigned int shell_len
= strlen (shell
);
1527 static char minus_c
[] = " -c ";
1528 unsigned int line_len
= strlen (line
);
1530 char *new_line
= (char *) alloca (shell_len
+ (sizeof (minus_c
) - 1)
1531 + (line_len
* 2) + 1);
1534 bcopy (shell
, ap
, shell_len
);
1536 bcopy (minus_c
, ap
, sizeof (minus_c
) - 1);
1537 ap
+= sizeof (minus_c
) - 1;
1538 for (p
= line
; *p
!= '\0'; ++p
)
1540 if (restp
!= NULL
&& *p
== '\n')
1545 else if (*p
== '\\' && p
[1] == '\n')
1547 /* Eat the backslash, the newline, and following whitespace,
1548 replacing it all with a single space (which is escaped
1552 /* If there is a tab after a backslash-newline,
1553 remove it from the source line which will be echoed,
1554 since it was most likely used to line
1555 up the continued line with the previous one. */
1566 if (*p
== '\\' || *p
== '\'' || *p
== '"'
1568 || index (sh_chars
, *p
) != 0)
1574 new_argv
= construct_command_argv_internal (new_line
, (char **) NULL
,
1575 (char *) 0, (char *) 0);
1582 /* Figure out the argument list necessary to run LINE as a command. Try to
1583 avoid using a shell. This routine handles only ' quoting, and " quoting
1584 when no backslash, $ or ` characters are seen in the quotes. Starting
1585 quotes may be escaped with a backslash. If any of the characters in
1586 sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
1587 is the first word of a line, the shell is used.
1589 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
1590 If *RESTP is NULL, newlines will be ignored.
1592 FILE is the target whose commands these are. It is used for
1593 variable expansion for $(SHELL) and $(IFS). */
1596 construct_command_argv (line
, restp
, file
)
1597 char *line
, **restp
;
1604 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
1605 int save
= warn_undefined_variables_flag
;
1606 warn_undefined_variables_flag
= 0;
1608 shell
= allocated_variable_expand_for_file ("$(SHELL)", file
);
1609 ifs
= allocated_variable_expand_for_file ("$(IFS)", file
);
1611 warn_undefined_variables_flag
= save
;
1614 argv
= construct_command_argv_internal (line
, restp
, shell
, ifs
);