| 1 | /* Job execution and handling for GNU Make.
|
|---|
| 2 | Copyright (C) 1988,89,90,91,92,93,94,95,96,97,99 Free Software Foundation, Inc.
|
|---|
| 3 | This file is part of GNU Make.
|
|---|
| 4 |
|
|---|
| 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)
|
|---|
| 8 | any later version.
|
|---|
| 9 |
|
|---|
| 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.
|
|---|
| 14 |
|
|---|
| 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, Inc., 59 Temple Place - Suite 330,
|
|---|
| 18 | Boston, MA 02111-1307, USA. */
|
|---|
| 19 |
|
|---|
| 20 | #include "make.h"
|
|---|
| 21 |
|
|---|
| 22 | #include <assert.h>
|
|---|
| 23 |
|
|---|
| 24 | #include "job.h"
|
|---|
| 25 | #include "debug.h"
|
|---|
| 26 | #include "filedef.h"
|
|---|
| 27 | #include "commands.h"
|
|---|
| 28 | #include "variable.h"
|
|---|
| 29 | #include "debug.h"
|
|---|
| 30 |
|
|---|
| 31 | #include <string.h>
|
|---|
| 32 |
|
|---|
| 33 | /* Default shell to use. */
|
|---|
| 34 | #ifdef WINDOWS32
|
|---|
| 35 |
|
|---|
| 36 | char *default_shell = "sh.exe";
|
|---|
| 37 | int no_default_sh_exe = 1;
|
|---|
| 38 | int batch_mode_shell = 1;
|
|---|
| 39 |
|
|---|
| 40 | #elif defined (_AMIGA)
|
|---|
| 41 |
|
|---|
| 42 | char default_shell[] = "";
|
|---|
| 43 | extern int MyExecute (char **);
|
|---|
| 44 | int batch_mode_shell = 0;
|
|---|
| 45 |
|
|---|
| 46 | #elif defined (__MSDOS__)
|
|---|
| 47 |
|
|---|
| 48 | /* The default shell is a pointer so we can change it if Makefile
|
|---|
| 49 | says so. It is without an explicit path so we get a chance
|
|---|
| 50 | to search the $PATH for it (since MSDOS doesn't have standard
|
|---|
| 51 | directories we could trust). */
|
|---|
| 52 | char *default_shell = "command.com";
|
|---|
| 53 | int batch_mode_shell = 0;
|
|---|
| 54 |
|
|---|
| 55 | #elif defined (__EMX__)
|
|---|
| 56 |
|
|---|
| 57 | const char *default_shell = "/bin/sh";
|
|---|
| 58 | int batch_mode_shell = 0;
|
|---|
| 59 |
|
|---|
| 60 | #elif defined (VMS)
|
|---|
| 61 |
|
|---|
| 62 | # include <descrip.h>
|
|---|
| 63 | char default_shell[] = "";
|
|---|
| 64 | int batch_mode_shell = 0;
|
|---|
| 65 |
|
|---|
| 66 | #else
|
|---|
| 67 |
|
|---|
| 68 | char default_shell[] = "/bin/sh";
|
|---|
| 69 | int batch_mode_shell = 0;
|
|---|
| 70 |
|
|---|
| 71 | #endif
|
|---|
| 72 |
|
|---|
| 73 | #ifdef __MSDOS__
|
|---|
| 74 | # include <process.h>
|
|---|
| 75 | static int execute_by_shell;
|
|---|
| 76 | static int dos_pid = 123;
|
|---|
| 77 | int dos_status;
|
|---|
| 78 | int dos_command_running;
|
|---|
| 79 | #endif /* __MSDOS__ */
|
|---|
| 80 |
|
|---|
| 81 | #ifdef _AMIGA
|
|---|
| 82 | # include <proto/dos.h>
|
|---|
| 83 | static int amiga_pid = 123;
|
|---|
| 84 | static int amiga_status;
|
|---|
| 85 | static char amiga_bname[32];
|
|---|
| 86 | static int amiga_batch_file;
|
|---|
| 87 | #endif /* Amiga. */
|
|---|
| 88 |
|
|---|
| 89 | #ifdef VMS
|
|---|
| 90 | # ifndef __GNUC__
|
|---|
| 91 | # include <processes.h>
|
|---|
| 92 | # endif
|
|---|
| 93 | # include <starlet.h>
|
|---|
| 94 | # include <lib$routines.h>
|
|---|
| 95 | #endif
|
|---|
| 96 |
|
|---|
| 97 | #ifdef WINDOWS32
|
|---|
| 98 | # include <windows.h>
|
|---|
| 99 | # include <io.h>
|
|---|
| 100 | # include <process.h>
|
|---|
| 101 | # include "sub_proc.h"
|
|---|
| 102 | # include "w32err.h"
|
|---|
| 103 | # include "pathstuff.h"
|
|---|
| 104 | #endif /* WINDOWS32 */
|
|---|
| 105 |
|
|---|
| 106 | #ifdef __EMX__
|
|---|
| 107 | # include <process.h>
|
|---|
| 108 | #endif
|
|---|
| 109 |
|
|---|
| 110 | #if defined (HAVE_SYS_WAIT_H) || defined (HAVE_UNION_WAIT)
|
|---|
| 111 | # include <sys/wait.h>
|
|---|
| 112 | #endif
|
|---|
| 113 |
|
|---|
| 114 | #ifdef HAVE_WAITPID
|
|---|
| 115 | # define WAIT_NOHANG(status) waitpid (-1, (status), WNOHANG)
|
|---|
| 116 | #else /* Don't have waitpid. */
|
|---|
| 117 | # ifdef HAVE_WAIT3
|
|---|
| 118 | # ifndef wait3
|
|---|
| 119 | extern int wait3 ();
|
|---|
| 120 | # endif
|
|---|
| 121 | # define WAIT_NOHANG(status) wait3 ((status), WNOHANG, (struct rusage *) 0)
|
|---|
| 122 | # endif /* Have wait3. */
|
|---|
| 123 | #endif /* Have waitpid. */
|
|---|
| 124 |
|
|---|
| 125 | #if !defined (wait) && !defined (POSIX)
|
|---|
| 126 | extern int wait ();
|
|---|
| 127 | #endif
|
|---|
| 128 |
|
|---|
| 129 | #ifndef HAVE_UNION_WAIT
|
|---|
| 130 |
|
|---|
| 131 | # define WAIT_T int
|
|---|
| 132 |
|
|---|
| 133 | # ifndef WTERMSIG
|
|---|
| 134 | # define WTERMSIG(x) ((x) & 0x7f)
|
|---|
| 135 | # endif
|
|---|
| 136 | # ifndef WCOREDUMP
|
|---|
| 137 | # define WCOREDUMP(x) ((x) & 0x80)
|
|---|
| 138 | # endif
|
|---|
| 139 | # ifndef WEXITSTATUS
|
|---|
| 140 | # define WEXITSTATUS(x) (((x) >> 8) & 0xff)
|
|---|
| 141 | # endif
|
|---|
| 142 | # ifndef WIFSIGNALED
|
|---|
| 143 | # define WIFSIGNALED(x) (WTERMSIG (x) != 0)
|
|---|
| 144 | # endif
|
|---|
| 145 | # ifndef WIFEXITED
|
|---|
| 146 | # define WIFEXITED(x) (WTERMSIG (x) == 0)
|
|---|
| 147 | # endif
|
|---|
| 148 |
|
|---|
| 149 | #else /* Have `union wait'. */
|
|---|
| 150 |
|
|---|
| 151 | # define WAIT_T union wait
|
|---|
| 152 | # ifndef WTERMSIG
|
|---|
| 153 | # define WTERMSIG(x) ((x).w_termsig)
|
|---|
| 154 | # endif
|
|---|
| 155 | # ifndef WCOREDUMP
|
|---|
| 156 | # define WCOREDUMP(x) ((x).w_coredump)
|
|---|
| 157 | # endif
|
|---|
| 158 | # ifndef WEXITSTATUS
|
|---|
| 159 | # define WEXITSTATUS(x) ((x).w_retcode)
|
|---|
| 160 | # endif
|
|---|
| 161 | # ifndef WIFSIGNALED
|
|---|
| 162 | # define WIFSIGNALED(x) (WTERMSIG(x) != 0)
|
|---|
| 163 | # endif
|
|---|
| 164 | # ifndef WIFEXITED
|
|---|
| 165 | # define WIFEXITED(x) (WTERMSIG(x) == 0)
|
|---|
| 166 | # endif
|
|---|
| 167 |
|
|---|
| 168 | #endif /* Don't have `union wait'. */
|
|---|
| 169 |
|
|---|
| 170 | #ifdef VMS
|
|---|
| 171 | static int vms_jobsefnmask = 0;
|
|---|
| 172 | #endif /* !VMS */
|
|---|
| 173 |
|
|---|
| 174 | #ifndef HAVE_UNISTD_H
|
|---|
| 175 | extern int dup2 ();
|
|---|
| 176 | extern int execve ();
|
|---|
| 177 | extern void _exit ();
|
|---|
| 178 | # ifndef VMS
|
|---|
| 179 | extern int geteuid ();
|
|---|
| 180 | extern int getegid ();
|
|---|
| 181 | extern int setgid ();
|
|---|
| 182 | extern int getgid ();
|
|---|
| 183 | # endif
|
|---|
| 184 | #endif
|
|---|
| 185 |
|
|---|
| 186 | extern char *allocated_variable_expand_for_file PARAMS ((char *line, struct file *file));
|
|---|
| 187 |
|
|---|
| 188 | extern int getloadavg PARAMS ((double loadavg[], int nelem));
|
|---|
| 189 | extern int start_remote_job PARAMS ((char **argv, char **envp, int stdin_fd,
|
|---|
| 190 | int *is_remote, int *id_ptr, int *used_stdin));
|
|---|
| 191 | extern int start_remote_job_p PARAMS ((int));
|
|---|
| 192 | extern int remote_status PARAMS ((int *exit_code_ptr, int *signal_ptr,
|
|---|
| 193 | int *coredump_ptr, int block));
|
|---|
| 194 |
|
|---|
| 195 | RETSIGTYPE child_handler PARAMS ((int));
|
|---|
| 196 | static void free_child PARAMS ((struct child *));
|
|---|
| 197 | static void start_job_command PARAMS ((struct child *child));
|
|---|
| 198 | static int load_too_high PARAMS ((void));
|
|---|
| 199 | static int job_next_command PARAMS ((struct child *));
|
|---|
| 200 | static int start_waiting_job PARAMS ((struct child *));
|
|---|
| 201 | #ifdef VMS
|
|---|
| 202 | static void vmsWaitForChildren PARAMS ((int *));
|
|---|
| 203 | #endif
|
|---|
| 204 | |
|---|
| 205 |
|
|---|
| 206 | /* Chain of all live (or recently deceased) children. */
|
|---|
| 207 |
|
|---|
| 208 | struct child *children = 0;
|
|---|
| 209 |
|
|---|
| 210 | /* Number of children currently running. */
|
|---|
| 211 |
|
|---|
| 212 | unsigned int job_slots_used = 0;
|
|---|
| 213 |
|
|---|
| 214 | /* Nonzero if the `good' standard input is in use. */
|
|---|
| 215 |
|
|---|
| 216 | static int good_stdin_used = 0;
|
|---|
| 217 |
|
|---|
| 218 | /* Chain of children waiting to run until the load average goes down. */
|
|---|
| 219 |
|
|---|
| 220 | static struct child *waiting_jobs = 0;
|
|---|
| 221 |
|
|---|
| 222 | /* Non-zero if we use a *real* shell (always so on Unix). */
|
|---|
| 223 |
|
|---|
| 224 | int unixy_shell = 1;
|
|---|
| 225 |
|
|---|
| 226 | |
|---|
| 227 |
|
|---|
| 228 | #ifdef WINDOWS32
|
|---|
| 229 | /*
|
|---|
| 230 | * The macro which references this function is defined in make.h.
|
|---|
| 231 | */
|
|---|
| 232 | int
|
|---|
| 233 | w32_kill(int pid, int sig)
|
|---|
| 234 | {
|
|---|
| 235 | return ((process_kill(pid, sig) == TRUE) ? 0 : -1);
|
|---|
| 236 | }
|
|---|
| 237 | #endif /* WINDOWS32 */
|
|---|
| 238 |
|
|---|
| 239 | #ifdef __EMX__
|
|---|
| 240 | /* returns whether path is assumed to be a unix like shell. */
|
|---|
| 241 | int
|
|---|
| 242 | _is_unixy_shell (const char *path)
|
|---|
| 243 | {
|
|---|
| 244 | /* list of non unix shells */
|
|---|
| 245 | const char *known_os2shells[] = {
|
|---|
| 246 | "cmd.exe",
|
|---|
| 247 | "cmd",
|
|---|
| 248 | "4os2.exe",
|
|---|
| 249 | "4os2",
|
|---|
| 250 | "4dos.exe",
|
|---|
| 251 | "4dos",
|
|---|
| 252 | "command.com",
|
|---|
| 253 | "command",
|
|---|
| 254 | NULL
|
|---|
| 255 | };
|
|---|
| 256 |
|
|---|
| 257 | /* find the rightmost '/' or '\\' */
|
|---|
| 258 | const char *name = strrchr (path, '/');
|
|---|
| 259 | const char *p = strrchr (path, '\\');
|
|---|
| 260 | unsigned i;
|
|---|
| 261 |
|
|---|
| 262 | if (name && p) /* take the max */
|
|---|
| 263 | name = (name > p) ? name : p;
|
|---|
| 264 | else if (p) /* name must be 0 */
|
|---|
| 265 | name = p;
|
|---|
| 266 | else if (!name) /* name and p must be 0 */
|
|---|
| 267 | name = path;
|
|---|
| 268 |
|
|---|
| 269 | if (*name == '/' || *name == '\\') name++;
|
|---|
| 270 |
|
|---|
| 271 | i = 0;
|
|---|
| 272 | while (known_os2shells[i] != NULL) {
|
|---|
| 273 | if (stricmp (name, known_os2shells[i]) == 0) /* strcasecmp() */
|
|---|
| 274 | return 0; /* not a unix shell */
|
|---|
| 275 | i++;
|
|---|
| 276 | }
|
|---|
| 277 |
|
|---|
| 278 | /* in doubt assume a unix like shell */
|
|---|
| 279 | return 1;
|
|---|
| 280 | }
|
|---|
| 281 | #endif /* __EMX__ */
|
|---|
| 282 |
|
|---|
| 283 | |
|---|
| 284 |
|
|---|
| 285 | /* Write an error message describing the exit status given in
|
|---|
| 286 | EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
|
|---|
| 287 | Append "(ignored)" if IGNORED is nonzero. */
|
|---|
| 288 |
|
|---|
| 289 | static void
|
|---|
| 290 | child_error (char *target_name, int exit_code, int exit_sig, int coredump,
|
|---|
| 291 | int ignored)
|
|---|
| 292 | {
|
|---|
| 293 | if (ignored && silent_flag)
|
|---|
| 294 | return;
|
|---|
| 295 |
|
|---|
| 296 | #ifdef VMS
|
|---|
| 297 | if (!(exit_code & 1))
|
|---|
| 298 | error (NILF,
|
|---|
| 299 | (ignored ? _("*** [%s] Error 0x%x (ignored)")
|
|---|
| 300 | : _("*** [%s] Error 0x%x")),
|
|---|
| 301 | target_name, exit_code);
|
|---|
| 302 | #else
|
|---|
| 303 | if (exit_sig == 0)
|
|---|
| 304 | error (NILF, ignored ? _("[%s] Error %d (ignored)") :
|
|---|
| 305 | _("*** [%s] Error %d"),
|
|---|
| 306 | target_name, exit_code);
|
|---|
| 307 | else
|
|---|
| 308 | error (NILF, "*** [%s] %s%s",
|
|---|
| 309 | target_name, strsignal (exit_sig),
|
|---|
| 310 | coredump ? _(" (core dumped)") : "");
|
|---|
| 311 | #endif /* VMS */
|
|---|
| 312 | }
|
|---|
| 313 | |
|---|
| 314 |
|
|---|
| 315 | #ifdef VMS
|
|---|
| 316 | /* Wait for nchildren children to terminate */
|
|---|
| 317 | static void
|
|---|
| 318 | vmsWaitForChildren(int *status)
|
|---|
| 319 | {
|
|---|
| 320 | while (1)
|
|---|
| 321 | {
|
|---|
| 322 | if (!vms_jobsefnmask)
|
|---|
| 323 | {
|
|---|
| 324 | *status = 0;
|
|---|
| 325 | return;
|
|---|
| 326 | }
|
|---|
| 327 |
|
|---|
| 328 | *status = sys$wflor (32, vms_jobsefnmask);
|
|---|
| 329 | }
|
|---|
| 330 | return;
|
|---|
| 331 | }
|
|---|
| 332 |
|
|---|
| 333 | /* Set up IO redirection. */
|
|---|
| 334 |
|
|---|
| 335 | char *
|
|---|
| 336 | vms_redirect (struct dsc$descriptor_s *desc, char *fname, char *ibuf)
|
|---|
| 337 | {
|
|---|
| 338 | char *fptr;
|
|---|
| 339 | extern char *vmsify ();
|
|---|
| 340 |
|
|---|
| 341 | ibuf++;
|
|---|
| 342 | while (isspace ((unsigned char)*ibuf))
|
|---|
| 343 | ibuf++;
|
|---|
| 344 | fptr = ibuf;
|
|---|
| 345 | while (*ibuf && !isspace ((unsigned char)*ibuf))
|
|---|
| 346 | ibuf++;
|
|---|
| 347 | *ibuf = 0;
|
|---|
| 348 | if (strcmp (fptr, "/dev/null") != 0)
|
|---|
| 349 | {
|
|---|
| 350 | strcpy (fname, vmsify (fptr, 0));
|
|---|
| 351 | if (strchr (fname, '.') == 0)
|
|---|
| 352 | strcat (fname, ".");
|
|---|
| 353 | }
|
|---|
| 354 | desc->dsc$w_length = strlen(fname);
|
|---|
| 355 | desc->dsc$a_pointer = fname;
|
|---|
| 356 | desc->dsc$b_dtype = DSC$K_DTYPE_T;
|
|---|
| 357 | desc->dsc$b_class = DSC$K_CLASS_S;
|
|---|
| 358 |
|
|---|
| 359 | if (*fname == 0)
|
|---|
| 360 | printf (_("Warning: Empty redirection\n"));
|
|---|
| 361 | return ibuf;
|
|---|
| 362 | }
|
|---|
| 363 |
|
|---|
| 364 |
|
|---|
| 365 | /*
|
|---|
| 366 | found apostrophe at (p-1)
|
|---|
| 367 |
|
|---|
| 368 | inc p until after closing apostrophe. */
|
|---|
| 369 |
|
|---|
| 370 | static char *
|
|---|
| 371 | handle_apos (char *p)
|
|---|
| 372 | {
|
|---|
| 373 | int alast;
|
|---|
| 374 | int inside;
|
|---|
| 375 |
|
|---|
| 376 | #define SEPCHARS ",/()= "
|
|---|
| 377 |
|
|---|
| 378 | inside = 0;
|
|---|
| 379 |
|
|---|
| 380 | while (*p != 0)
|
|---|
| 381 | {
|
|---|
| 382 | if (*p == '"')
|
|---|
| 383 | {
|
|---|
| 384 | if (inside)
|
|---|
| 385 | {
|
|---|
| 386 | while ((alast > 0)
|
|---|
| 387 | && (*p == '"'))
|
|---|
| 388 | {
|
|---|
| 389 | p++;
|
|---|
| 390 | alast--;
|
|---|
| 391 | }
|
|---|
| 392 | if (alast == 0)
|
|---|
| 393 | inside = 0;
|
|---|
| 394 | else
|
|---|
| 395 | {
|
|---|
| 396 | fprintf (stderr, _("Syntax error, still inside '\"'\n"));
|
|---|
| 397 | exit (3);
|
|---|
| 398 | }
|
|---|
| 399 | }
|
|---|
| 400 | else
|
|---|
| 401 | {
|
|---|
| 402 | p++;
|
|---|
| 403 | if (strchr (SEPCHARS, *p))
|
|---|
| 404 | break;
|
|---|
| 405 | inside = 1;
|
|---|
| 406 | alast = 1;
|
|---|
| 407 | while (*p == '"')
|
|---|
| 408 | {
|
|---|
| 409 | alast++;
|
|---|
| 410 | p++;
|
|---|
| 411 | }
|
|---|
| 412 | }
|
|---|
| 413 | }
|
|---|
| 414 | else
|
|---|
| 415 | p++;
|
|---|
| 416 | }
|
|---|
| 417 |
|
|---|
| 418 | return p;
|
|---|
| 419 | }
|
|---|
| 420 |
|
|---|
| 421 | #endif
|
|---|
| 422 |
|
|---|
| 423 |
|
|---|
| 424 | /* Handle a dead child. This handler may or may not ever be installed.
|
|---|
| 425 |
|
|---|
| 426 | If we're using the jobserver feature, we need it. First, installing it
|
|---|
| 427 | ensures the read will interrupt on SIGCHLD. Second, we close the dup'd
|
|---|
| 428 | read FD to ensure we don't enter another blocking read without reaping all
|
|---|
| 429 | the dead children. In this case we don't need the dead_children count.
|
|---|
| 430 |
|
|---|
| 431 | If we don't have either waitpid or wait3, then make is unreliable, but we
|
|---|
| 432 | use the dead_children count to reap children as best we can. */
|
|---|
| 433 |
|
|---|
| 434 | static unsigned int dead_children = 0;
|
|---|
| 435 |
|
|---|
| 436 | #ifndef __EMX__ /* Don't use SIGCHLD handler on OS/2. */
|
|---|
| 437 | RETSIGTYPE
|
|---|
| 438 | child_handler (int sig)
|
|---|
| 439 | {
|
|---|
| 440 | ++dead_children;
|
|---|
| 441 |
|
|---|
| 442 | if (job_rfd >= 0)
|
|---|
| 443 | {
|
|---|
| 444 | close (job_rfd);
|
|---|
| 445 | job_rfd = -1;
|
|---|
| 446 | }
|
|---|
| 447 |
|
|---|
| 448 | DB (DB_JOBS, (_("Got a SIGCHLD; %u unreaped children.\n"), dead_children));
|
|---|
| 449 | }
|
|---|
| 450 | #endif /* !__EMX__ */
|
|---|
| 451 |
|
|---|
| 452 | extern int shell_function_pid, shell_function_completed;
|
|---|
| 453 |
|
|---|
| 454 | /* Reap all dead children, storing the returned status and the new command
|
|---|
| 455 | state (`cs_finished') in the `file' member of the `struct child' for the
|
|---|
| 456 | dead child, and removing the child from the chain. In addition, if BLOCK
|
|---|
| 457 | nonzero, we block in this function until we've reaped at least one
|
|---|
| 458 | complete child, waiting for it to die if necessary. If ERR is nonzero,
|
|---|
| 459 | print an error message first. */
|
|---|
| 460 |
|
|---|
| 461 | void
|
|---|
| 462 | reap_children (int block, int err)
|
|---|
| 463 | {
|
|---|
| 464 | WAIT_T status;
|
|---|
| 465 | /* Initially, assume we have some. */
|
|---|
| 466 | int reap_more = 1;
|
|---|
| 467 |
|
|---|
| 468 | #ifdef WAIT_NOHANG
|
|---|
| 469 | # define REAP_MORE reap_more
|
|---|
| 470 | #else
|
|---|
| 471 | # define REAP_MORE dead_children
|
|---|
| 472 | #endif
|
|---|
| 473 |
|
|---|
| 474 | /* As long as:
|
|---|
| 475 |
|
|---|
| 476 | We have at least one child outstanding OR a shell function in progress,
|
|---|
| 477 | AND
|
|---|
| 478 | We're blocking for a complete child OR there are more children to reap
|
|---|
| 479 |
|
|---|
| 480 | we'll keep reaping children. */
|
|---|
| 481 |
|
|---|
| 482 | while ((children != 0 || shell_function_pid != 0)
|
|---|
| 483 | && (block || REAP_MORE))
|
|---|
| 484 | {
|
|---|
| 485 | int remote = 0;
|
|---|
| 486 | register int pid;
|
|---|
| 487 | int exit_code, exit_sig, coredump;
|
|---|
| 488 | register struct child *lastc, *c;
|
|---|
| 489 | int child_failed;
|
|---|
| 490 | int any_remote, any_local;
|
|---|
| 491 |
|
|---|
| 492 | if (err && block)
|
|---|
| 493 | {
|
|---|
| 494 | /* We might block for a while, so let the user know why. */
|
|---|
| 495 | fflush (stdout);
|
|---|
| 496 | error (NILF, _("*** Waiting for unfinished jobs...."));
|
|---|
| 497 | }
|
|---|
| 498 |
|
|---|
| 499 | /* We have one less dead child to reap. As noted in
|
|---|
| 500 | child_handler() above, this count is completely unimportant for
|
|---|
| 501 | all modern, POSIX-y systems that support wait3() or waitpid().
|
|---|
| 502 | The rest of this comment below applies only to early, broken
|
|---|
| 503 | pre-POSIX systems. We keep the count only because... it's there...
|
|---|
| 504 |
|
|---|
| 505 | The test and decrement are not atomic; if it is compiled into:
|
|---|
| 506 | register = dead_children - 1;
|
|---|
| 507 | dead_children = register;
|
|---|
| 508 | a SIGCHLD could come between the two instructions.
|
|---|
| 509 | child_handler increments dead_children.
|
|---|
| 510 | The second instruction here would lose that increment. But the
|
|---|
| 511 | only effect of dead_children being wrong is that we might wait
|
|---|
| 512 | longer than necessary to reap a child, and lose some parallelism;
|
|---|
| 513 | and we might print the "Waiting for unfinished jobs" message above
|
|---|
| 514 | when not necessary. */
|
|---|
| 515 |
|
|---|
| 516 | if (dead_children > 0)
|
|---|
| 517 | --dead_children;
|
|---|
| 518 |
|
|---|
| 519 | any_remote = 0;
|
|---|
| 520 | any_local = shell_function_pid != 0;
|
|---|
| 521 | for (c = children; c != 0; c = c->next)
|
|---|
| 522 | {
|
|---|
| 523 | any_remote |= c->remote;
|
|---|
| 524 | any_local |= ! c->remote;
|
|---|
| 525 | DB (DB_JOBS, (_("Live child 0x%08lx (%s) PID %ld %s\n"),
|
|---|
| 526 | (unsigned long int) c, c->file->name,
|
|---|
| 527 | (long) c->pid, c->remote ? _(" (remote)") : ""));
|
|---|
| 528 | #ifdef VMS
|
|---|
| 529 | break;
|
|---|
| 530 | #endif
|
|---|
| 531 | }
|
|---|
| 532 |
|
|---|
| 533 | /* First, check for remote children. */
|
|---|
| 534 | if (any_remote)
|
|---|
| 535 | pid = remote_status (&exit_code, &exit_sig, &coredump, 0);
|
|---|
| 536 | else
|
|---|
| 537 | pid = 0;
|
|---|
| 538 |
|
|---|
| 539 | if (pid > 0)
|
|---|
| 540 | /* We got a remote child. */
|
|---|
| 541 | remote = 1;
|
|---|
| 542 | else if (pid < 0)
|
|---|
| 543 | {
|
|---|
| 544 | /* A remote status command failed miserably. Punt. */
|
|---|
| 545 | remote_status_lose:
|
|---|
| 546 | pfatal_with_name ("remote_status");
|
|---|
| 547 | }
|
|---|
| 548 | else
|
|---|
| 549 | {
|
|---|
| 550 | /* No remote children. Check for local children. */
|
|---|
| 551 | #if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32)
|
|---|
| 552 | if (any_local)
|
|---|
| 553 | {
|
|---|
| 554 | #ifdef VMS
|
|---|
| 555 | vmsWaitForChildren (&status);
|
|---|
| 556 | pid = c->pid;
|
|---|
| 557 | #else
|
|---|
| 558 | #ifdef WAIT_NOHANG
|
|---|
| 559 | if (!block)
|
|---|
| 560 | pid = WAIT_NOHANG (&status);
|
|---|
| 561 | else
|
|---|
| 562 | #endif
|
|---|
| 563 | pid = wait (&status);
|
|---|
| 564 | #endif /* !VMS */
|
|---|
| 565 | }
|
|---|
| 566 | else
|
|---|
| 567 | pid = 0;
|
|---|
| 568 |
|
|---|
| 569 | if (pid < 0)
|
|---|
| 570 | {
|
|---|
| 571 | /* The wait*() failed miserably. Punt. */
|
|---|
| 572 | pfatal_with_name ("wait");
|
|---|
| 573 | }
|
|---|
| 574 | else if (pid > 0)
|
|---|
| 575 | {
|
|---|
| 576 | /* We got a child exit; chop the status word up. */
|
|---|
| 577 | exit_code = WEXITSTATUS (status);
|
|---|
| 578 | exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
|
|---|
| 579 | coredump = WCOREDUMP (status);
|
|---|
| 580 |
|
|---|
| 581 | #ifdef __EMX__
|
|---|
| 582 | /* the SIGCHLD handler must not be used on OS/2 because, unlike
|
|---|
| 583 | on UNIX systems, it had to call wait() itself. Therefore
|
|---|
| 584 | job_rfd has to be closed here. */
|
|---|
| 585 | if (job_rfd >= 0)
|
|---|
| 586 | {
|
|---|
| 587 | close (job_rfd);
|
|---|
| 588 | job_rfd = -1;
|
|---|
| 589 | }
|
|---|
| 590 | #endif
|
|---|
| 591 |
|
|---|
| 592 | }
|
|---|
| 593 | else
|
|---|
| 594 | {
|
|---|
| 595 | /* No local children are dead. */
|
|---|
| 596 | reap_more = 0;
|
|---|
| 597 |
|
|---|
| 598 | if (!block || !any_remote)
|
|---|
| 599 | break;
|
|---|
| 600 |
|
|---|
| 601 | /* Now try a blocking wait for a remote child. */
|
|---|
| 602 | pid = remote_status (&exit_code, &exit_sig, &coredump, 1);
|
|---|
| 603 | if (pid < 0)
|
|---|
| 604 | goto remote_status_lose;
|
|---|
| 605 | else if (pid == 0)
|
|---|
| 606 | /* No remote children either. Finally give up. */
|
|---|
| 607 | break;
|
|---|
| 608 |
|
|---|
| 609 | /* We got a remote child. */
|
|---|
| 610 | remote = 1;
|
|---|
| 611 | }
|
|---|
| 612 | #endif /* !__MSDOS__, !Amiga, !WINDOWS32. */
|
|---|
| 613 |
|
|---|
| 614 | #ifdef __MSDOS__
|
|---|
| 615 | /* Life is very different on MSDOS. */
|
|---|
| 616 | pid = dos_pid - 1;
|
|---|
| 617 | status = dos_status;
|
|---|
| 618 | exit_code = WEXITSTATUS (status);
|
|---|
| 619 | if (exit_code == 0xff)
|
|---|
| 620 | exit_code = -1;
|
|---|
| 621 | exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
|
|---|
| 622 | coredump = 0;
|
|---|
| 623 | #endif /* __MSDOS__ */
|
|---|
| 624 | #ifdef _AMIGA
|
|---|
| 625 | /* Same on Amiga */
|
|---|
| 626 | pid = amiga_pid - 1;
|
|---|
| 627 | status = amiga_status;
|
|---|
| 628 | exit_code = amiga_status;
|
|---|
| 629 | exit_sig = 0;
|
|---|
| 630 | coredump = 0;
|
|---|
| 631 | #endif /* _AMIGA */
|
|---|
| 632 | #ifdef WINDOWS32
|
|---|
| 633 | {
|
|---|
| 634 | HANDLE hPID;
|
|---|
| 635 | int err;
|
|---|
| 636 |
|
|---|
| 637 | /* wait for anything to finish */
|
|---|
| 638 | if (hPID = process_wait_for_any()) {
|
|---|
| 639 |
|
|---|
| 640 | /* was an error found on this process? */
|
|---|
| 641 | err = process_last_err(hPID);
|
|---|
| 642 |
|
|---|
| 643 | /* get exit data */
|
|---|
| 644 | exit_code = process_exit_code(hPID);
|
|---|
| 645 |
|
|---|
| 646 | if (err)
|
|---|
| 647 | fprintf(stderr, "make (e=%d): %s",
|
|---|
| 648 | exit_code, map_windows32_error_to_string(exit_code));
|
|---|
| 649 |
|
|---|
| 650 | /* signal */
|
|---|
| 651 | exit_sig = process_signal(hPID);
|
|---|
| 652 |
|
|---|
| 653 | /* cleanup process */
|
|---|
| 654 | process_cleanup(hPID);
|
|---|
| 655 |
|
|---|
| 656 | coredump = 0;
|
|---|
| 657 | }
|
|---|
| 658 | pid = (int) hPID;
|
|---|
| 659 | }
|
|---|
| 660 | #endif /* WINDOWS32 */
|
|---|
| 661 | }
|
|---|
| 662 |
|
|---|
| 663 | /* Check if this is the child of the `shell' function. */
|
|---|
| 664 | if (!remote && pid == shell_function_pid)
|
|---|
| 665 | {
|
|---|
| 666 | /* It is. Leave an indicator for the `shell' function. */
|
|---|
| 667 | if (exit_sig == 0 && exit_code == 127)
|
|---|
| 668 | shell_function_completed = -1;
|
|---|
| 669 | else
|
|---|
| 670 | shell_function_completed = 1;
|
|---|
| 671 | break;
|
|---|
| 672 | }
|
|---|
| 673 |
|
|---|
| 674 | child_failed = exit_sig != 0 || exit_code != 0;
|
|---|
| 675 |
|
|---|
| 676 | /* Search for a child matching the deceased one. */
|
|---|
| 677 | lastc = 0;
|
|---|
| 678 | for (c = children; c != 0; lastc = c, c = c->next)
|
|---|
| 679 | if (c->remote == remote && c->pid == pid)
|
|---|
| 680 | break;
|
|---|
| 681 |
|
|---|
| 682 | if (c == 0)
|
|---|
| 683 | /* An unknown child died.
|
|---|
| 684 | Ignore it; it was inherited from our invoker. */
|
|---|
| 685 | continue;
|
|---|
| 686 |
|
|---|
| 687 | DB (DB_JOBS, (child_failed
|
|---|
| 688 | ? _("Reaping losing child 0x%08lx PID %ld %s\n")
|
|---|
| 689 | : _("Reaping winning child 0x%08lx PID %ld %s\n"),
|
|---|
| 690 | (unsigned long int) c, (long) c->pid,
|
|---|
| 691 | c->remote ? _(" (remote)") : ""));
|
|---|
| 692 |
|
|---|
| 693 | if (c->sh_batch_file) {
|
|---|
| 694 | DB (DB_JOBS, (_("Cleaning up temp batch file %s\n"),
|
|---|
| 695 | c->sh_batch_file));
|
|---|
| 696 |
|
|---|
| 697 | /* just try and remove, don't care if this fails */
|
|---|
| 698 | remove (c->sh_batch_file);
|
|---|
| 699 |
|
|---|
| 700 | /* all done with memory */
|
|---|
| 701 | free (c->sh_batch_file);
|
|---|
| 702 | c->sh_batch_file = NULL;
|
|---|
| 703 | }
|
|---|
| 704 |
|
|---|
| 705 | /* If this child had the good stdin, say it is now free. */
|
|---|
| 706 | if (c->good_stdin)
|
|---|
| 707 | good_stdin_used = 0;
|
|---|
| 708 |
|
|---|
| 709 | if (child_failed && !c->noerror && !ignore_errors_flag)
|
|---|
| 710 | {
|
|---|
| 711 | /* The commands failed. Write an error message,
|
|---|
| 712 | delete non-precious targets, and abort. */
|
|---|
| 713 | static int delete_on_error = -1;
|
|---|
| 714 | child_error (c->file->name, exit_code, exit_sig, coredump, 0);
|
|---|
| 715 | c->file->update_status = 2;
|
|---|
| 716 | if (delete_on_error == -1)
|
|---|
| 717 | {
|
|---|
| 718 | struct file *f = lookup_file (".DELETE_ON_ERROR");
|
|---|
| 719 | delete_on_error = f != 0 && f->is_target;
|
|---|
| 720 | }
|
|---|
| 721 | if (exit_sig != 0 || delete_on_error)
|
|---|
| 722 | delete_child_targets (c);
|
|---|
| 723 | }
|
|---|
| 724 | else
|
|---|
| 725 | {
|
|---|
| 726 | if (child_failed)
|
|---|
| 727 | {
|
|---|
| 728 | /* The commands failed, but we don't care. */
|
|---|
| 729 | child_error (c->file->name,
|
|---|
| 730 | exit_code, exit_sig, coredump, 1);
|
|---|
| 731 | child_failed = 0;
|
|---|
| 732 | }
|
|---|
| 733 |
|
|---|
| 734 | /* If there are more commands to run, try to start them. */
|
|---|
| 735 | if (job_next_command (c))
|
|---|
| 736 | {
|
|---|
| 737 | if (handling_fatal_signal)
|
|---|
| 738 | {
|
|---|
| 739 | /* Never start new commands while we are dying.
|
|---|
| 740 | Since there are more commands that wanted to be run,
|
|---|
| 741 | the target was not completely remade. So we treat
|
|---|
| 742 | this as if a command had failed. */
|
|---|
| 743 | c->file->update_status = 2;
|
|---|
| 744 | }
|
|---|
| 745 | else
|
|---|
| 746 | {
|
|---|
| 747 | /* Check again whether to start remotely.
|
|---|
| 748 | Whether or not we want to changes over time.
|
|---|
| 749 | Also, start_remote_job may need state set up
|
|---|
| 750 | by start_remote_job_p. */
|
|---|
| 751 | c->remote = start_remote_job_p (0);
|
|---|
| 752 | start_job_command (c);
|
|---|
| 753 | /* Fatal signals are left blocked in case we were
|
|---|
| 754 | about to put that child on the chain. But it is
|
|---|
| 755 | already there, so it is safe for a fatal signal to
|
|---|
| 756 | arrive now; it will clean up this child's targets. */
|
|---|
| 757 | unblock_sigs ();
|
|---|
| 758 | if (c->file->command_state == cs_running)
|
|---|
| 759 | /* We successfully started the new command.
|
|---|
| 760 | Loop to reap more children. */
|
|---|
| 761 | continue;
|
|---|
| 762 | }
|
|---|
| 763 |
|
|---|
| 764 | if (c->file->update_status != 0)
|
|---|
| 765 | /* We failed to start the commands. */
|
|---|
| 766 | delete_child_targets (c);
|
|---|
| 767 | }
|
|---|
| 768 | else
|
|---|
| 769 | /* There are no more commands. We got through them all
|
|---|
| 770 | without an unignored error. Now the target has been
|
|---|
| 771 | successfully updated. */
|
|---|
| 772 | c->file->update_status = 0;
|
|---|
| 773 | }
|
|---|
| 774 |
|
|---|
| 775 | /* When we get here, all the commands for C->file are finished
|
|---|
| 776 | (or aborted) and C->file->update_status contains 0 or 2. But
|
|---|
| 777 | C->file->command_state is still cs_running if all the commands
|
|---|
| 778 | ran; notice_finish_file looks for cs_running to tell it that
|
|---|
| 779 | it's interesting to check the file's modtime again now. */
|
|---|
| 780 |
|
|---|
| 781 | if (! handling_fatal_signal)
|
|---|
| 782 | /* Notice if the target of the commands has been changed.
|
|---|
| 783 | This also propagates its values for command_state and
|
|---|
| 784 | update_status to its also_make files. */
|
|---|
| 785 | notice_finished_file (c->file);
|
|---|
| 786 |
|
|---|
| 787 | DB (DB_JOBS, (_("Removing child 0x%08lx PID %ld%s from chain.\n"),
|
|---|
| 788 | (unsigned long int) c, (long) c->pid,
|
|---|
| 789 | c->remote ? _(" (remote)") : ""));
|
|---|
| 790 |
|
|---|
| 791 | /* Block fatal signals while frobnicating the list, so that
|
|---|
| 792 | children and job_slots_used are always consistent. Otherwise
|
|---|
| 793 | a fatal signal arriving after the child is off the chain and
|
|---|
| 794 | before job_slots_used is decremented would believe a child was
|
|---|
| 795 | live and call reap_children again. */
|
|---|
| 796 | block_sigs ();
|
|---|
| 797 |
|
|---|
| 798 | /* There is now another slot open. */
|
|---|
| 799 | if (job_slots_used > 0)
|
|---|
| 800 | --job_slots_used;
|
|---|
| 801 |
|
|---|
| 802 | /* Remove the child from the chain and free it. */
|
|---|
| 803 | if (lastc == 0)
|
|---|
| 804 | children = c->next;
|
|---|
| 805 | else
|
|---|
| 806 | lastc->next = c->next;
|
|---|
| 807 |
|
|---|
| 808 | free_child (c);
|
|---|
| 809 |
|
|---|
| 810 | unblock_sigs ();
|
|---|
| 811 |
|
|---|
| 812 | /* If the job failed, and the -k flag was not given, die,
|
|---|
| 813 | unless we are already in the process of dying. */
|
|---|
| 814 | if (!err && child_failed && !keep_going_flag &&
|
|---|
| 815 | /* fatal_error_signal will die with the right signal. */
|
|---|
| 816 | !handling_fatal_signal)
|
|---|
| 817 | die (2);
|
|---|
| 818 |
|
|---|
| 819 | /* Only block for one child. */
|
|---|
| 820 | block = 0;
|
|---|
| 821 | }
|
|---|
| 822 |
|
|---|
| 823 | return;
|
|---|
| 824 | }
|
|---|
| 825 | |
|---|
| 826 |
|
|---|
| 827 | /* Free the storage allocated for CHILD. */
|
|---|
| 828 |
|
|---|
| 829 | static void
|
|---|
| 830 | free_child (struct child *child)
|
|---|
| 831 | {
|
|---|
| 832 | /* If this child is the only one it was our "free" job, so don't put a
|
|---|
| 833 | token back for it. This child has already been removed from the list,
|
|---|
| 834 | so if there any left this wasn't the last one. */
|
|---|
| 835 |
|
|---|
| 836 | if (job_fds[1] >= 0 && children)
|
|---|
| 837 | {
|
|---|
| 838 | char token = '+';
|
|---|
| 839 | int r;
|
|---|
| 840 |
|
|---|
| 841 | /* Write a job token back to the pipe. */
|
|---|
| 842 |
|
|---|
| 843 | EINTRLOOP (r, write (job_fds[1], &token, 1));
|
|---|
| 844 | if (r != 1)
|
|---|
| 845 | pfatal_with_name (_("write jobserver"));
|
|---|
| 846 |
|
|---|
| 847 | DB (DB_JOBS, (_("Released token for child 0x%08lx (%s).\n"),
|
|---|
| 848 | (unsigned long int) child, child->file->name));
|
|---|
| 849 | }
|
|---|
| 850 |
|
|---|
| 851 | if (handling_fatal_signal) /* Don't bother free'ing if about to die. */
|
|---|
| 852 | return;
|
|---|
| 853 |
|
|---|
| 854 | if (child->command_lines != 0)
|
|---|
| 855 | {
|
|---|
| 856 | register unsigned int i;
|
|---|
| 857 | for (i = 0; i < child->file->cmds->ncommand_lines; ++i)
|
|---|
| 858 | free (child->command_lines[i]);
|
|---|
| 859 | free ((char *) child->command_lines);
|
|---|
| 860 | }
|
|---|
| 861 |
|
|---|
| 862 | if (child->environment != 0)
|
|---|
| 863 | {
|
|---|
| 864 | register char **ep = child->environment;
|
|---|
| 865 | while (*ep != 0)
|
|---|
| 866 | free (*ep++);
|
|---|
| 867 | free ((char *) child->environment);
|
|---|
| 868 | }
|
|---|
| 869 |
|
|---|
| 870 | free ((char *) child);
|
|---|
| 871 | }
|
|---|
| 872 | |
|---|
| 873 |
|
|---|
| 874 | #ifdef POSIX
|
|---|
| 875 | extern sigset_t fatal_signal_set;
|
|---|
| 876 | #endif
|
|---|
| 877 |
|
|---|
| 878 | void
|
|---|
| 879 | block_sigs (void)
|
|---|
| 880 | {
|
|---|
| 881 | #ifdef POSIX
|
|---|
| 882 | (void) sigprocmask (SIG_BLOCK, &fatal_signal_set, (sigset_t *) 0);
|
|---|
| 883 | #else
|
|---|
| 884 | # ifdef HAVE_SIGSETMASK
|
|---|
| 885 | (void) sigblock (fatal_signal_mask);
|
|---|
| 886 | # endif
|
|---|
| 887 | #endif
|
|---|
| 888 | }
|
|---|
| 889 |
|
|---|
| 890 | #ifdef POSIX
|
|---|
| 891 | void
|
|---|
| 892 | unblock_sigs (void)
|
|---|
| 893 | {
|
|---|
| 894 | sigset_t empty;
|
|---|
| 895 | sigemptyset (&empty);
|
|---|
| 896 | sigprocmask (SIG_SETMASK, &empty, (sigset_t *) 0);
|
|---|
| 897 | }
|
|---|
| 898 | #endif
|
|---|
| 899 |
|
|---|
| 900 | #ifdef MAKE_JOBSERVER
|
|---|
| 901 | # ifdef __EMX__
|
|---|
| 902 | /* Never install the SIGCHLD handler for EMX!!! */
|
|---|
| 903 | # define set_child_handler_action_flags(x)
|
|---|
| 904 | # else
|
|---|
| 905 | /* Set the child handler action flags to FLAGS. */
|
|---|
| 906 | static void
|
|---|
| 907 | set_child_handler_action_flags (int flags)
|
|---|
| 908 | {
|
|---|
| 909 | struct sigaction sa;
|
|---|
| 910 | bzero ((char *) &sa, sizeof sa);
|
|---|
| 911 | sa.sa_handler = child_handler;
|
|---|
| 912 | sa.sa_flags = flags;
|
|---|
| 913 | #if defined SIGCHLD
|
|---|
| 914 | sigaction (SIGCHLD, &sa, NULL);
|
|---|
| 915 | #endif
|
|---|
| 916 | #if defined SIGCLD && SIGCLD != SIGCHLD
|
|---|
| 917 | sigaction (SIGCLD, &sa, NULL);
|
|---|
| 918 | #endif
|
|---|
| 919 | }
|
|---|
| 920 | #endif /* !__EMX__ */
|
|---|
| 921 | #endif
|
|---|
| 922 |
|
|---|
| 923 |
|
|---|
| 924 | /* Start a job to run the commands specified in CHILD.
|
|---|
| 925 | CHILD is updated to reflect the commands and ID of the child process.
|
|---|
| 926 |
|
|---|
| 927 | NOTE: On return fatal signals are blocked! The caller is responsible
|
|---|
| 928 | for calling `unblock_sigs', once the new child is safely on the chain so
|
|---|
| 929 | it can be cleaned up in the event of a fatal signal. */
|
|---|
| 930 |
|
|---|
| 931 | static void
|
|---|
| 932 | start_job_command (struct child *child)
|
|---|
| 933 | {
|
|---|
| 934 | #ifndef _AMIGA
|
|---|
| 935 | static int bad_stdin = -1;
|
|---|
| 936 | #endif
|
|---|
| 937 | register char *p;
|
|---|
| 938 | int flags;
|
|---|
| 939 | #ifdef VMS
|
|---|
| 940 | char *argv;
|
|---|
| 941 | #else
|
|---|
| 942 | char **argv;
|
|---|
| 943 | #endif
|
|---|
| 944 |
|
|---|
| 945 | /* If we have a completely empty commandset, stop now. */
|
|---|
| 946 | if (!child->command_ptr)
|
|---|
| 947 | goto next_command;
|
|---|
| 948 |
|
|---|
| 949 | /* Combine the flags parsed for the line itself with
|
|---|
| 950 | the flags specified globally for this target. */
|
|---|
| 951 | flags = (child->file->command_flags
|
|---|
| 952 | | child->file->cmds->lines_flags[child->command_line - 1]);
|
|---|
| 953 |
|
|---|
| 954 | p = child->command_ptr;
|
|---|
| 955 | child->noerror = flags & COMMANDS_NOERROR;
|
|---|
| 956 |
|
|---|
| 957 | while (*p != '\0')
|
|---|
| 958 | {
|
|---|
| 959 | if (*p == '@')
|
|---|
| 960 | flags |= COMMANDS_SILENT;
|
|---|
| 961 | else if (*p == '+')
|
|---|
| 962 | flags |= COMMANDS_RECURSE;
|
|---|
| 963 | else if (*p == '-')
|
|---|
| 964 | child->noerror = 1;
|
|---|
| 965 | else if (!isblank ((unsigned char)*p))
|
|---|
| 966 | break;
|
|---|
| 967 | ++p;
|
|---|
| 968 | }
|
|---|
| 969 |
|
|---|
| 970 | /* Update the file's command flags with any new ones we found. We only
|
|---|
| 971 | keep the COMMANDS_RECURSE setting. Even this isn't 100% correct; we are
|
|---|
| 972 | now marking more commands recursive than should be in the case of
|
|---|
| 973 | multiline define/endef scripts where only one line is marked "+". In
|
|---|
| 974 | order to really fix this, we'll have to keep a lines_flags for every
|
|---|
| 975 | actual line, after expansion. */
|
|---|
| 976 | child->file->cmds->lines_flags[child->command_line - 1]
|
|---|
| 977 | |= flags & COMMANDS_RECURSE;
|
|---|
| 978 |
|
|---|
| 979 | /* Figure out an argument list from this command line. */
|
|---|
| 980 |
|
|---|
| 981 | {
|
|---|
| 982 | char *end = 0;
|
|---|
| 983 | #ifdef VMS
|
|---|
| 984 | argv = p;
|
|---|
| 985 | #else
|
|---|
| 986 | argv = construct_command_argv (p, &end, child->file, &child->sh_batch_file);
|
|---|
| 987 | #endif
|
|---|
| 988 | if (end == NULL)
|
|---|
| 989 | child->command_ptr = NULL;
|
|---|
| 990 | else
|
|---|
| 991 | {
|
|---|
| 992 | *end++ = '\0';
|
|---|
| 993 | child->command_ptr = end;
|
|---|
| 994 | }
|
|---|
| 995 | }
|
|---|
| 996 |
|
|---|
| 997 | /* If -q was given, say that updating `failed' if there was any text on the
|
|---|
| 998 | command line, or `succeeded' otherwise. The exit status of 1 tells the
|
|---|
| 999 | user that -q is saying `something to do'; the exit status for a random
|
|---|
| 1000 | error is 2. */
|
|---|
| 1001 | if (argv != 0 && question_flag && !(flags & COMMANDS_RECURSE))
|
|---|
| 1002 | {
|
|---|
| 1003 | #ifndef VMS
|
|---|
| 1004 | free (argv[0]);
|
|---|
| 1005 | free ((char *) argv);
|
|---|
| 1006 | #endif
|
|---|
| 1007 | child->file->update_status = 1;
|
|---|
| 1008 | notice_finished_file (child->file);
|
|---|
| 1009 | return;
|
|---|
| 1010 | }
|
|---|
| 1011 |
|
|---|
| 1012 | if (touch_flag && !(flags & COMMANDS_RECURSE))
|
|---|
| 1013 | {
|
|---|
| 1014 | /* Go on to the next command. It might be the recursive one.
|
|---|
| 1015 | We construct ARGV only to find the end of the command line. */
|
|---|
| 1016 | #ifndef VMS
|
|---|
| 1017 | if (argv)
|
|---|
| 1018 | {
|
|---|
| 1019 | free (argv[0]);
|
|---|
| 1020 | free ((char *) argv);
|
|---|
| 1021 | }
|
|---|
| 1022 | #endif
|
|---|
| 1023 | argv = 0;
|
|---|
| 1024 | }
|
|---|
| 1025 |
|
|---|
| 1026 | if (argv == 0)
|
|---|
| 1027 | {
|
|---|
| 1028 | next_command:
|
|---|
| 1029 | #ifdef __MSDOS__
|
|---|
| 1030 | execute_by_shell = 0; /* in case construct_command_argv sets it */
|
|---|
| 1031 | #endif
|
|---|
| 1032 | /* This line has no commands. Go to the next. */
|
|---|
| 1033 | if (job_next_command (child))
|
|---|
| 1034 | start_job_command (child);
|
|---|
| 1035 | else
|
|---|
| 1036 | {
|
|---|
| 1037 | /* No more commands. Make sure we're "running"; we might not be if
|
|---|
| 1038 | (e.g.) all commands were skipped due to -n. */
|
|---|
| 1039 | set_command_state (child->file, cs_running);
|
|---|
| 1040 | child->file->update_status = 0;
|
|---|
| 1041 | notice_finished_file (child->file);
|
|---|
| 1042 | }
|
|---|
| 1043 | return;
|
|---|
| 1044 | }
|
|---|
| 1045 |
|
|---|
| 1046 | /* Print out the command. If silent, we call `message' with null so it
|
|---|
| 1047 | can log the working directory before the command's own error messages
|
|---|
| 1048 | appear. */
|
|---|
| 1049 |
|
|---|
| 1050 | message (0, (just_print_flag || (!(flags & COMMANDS_SILENT) && !silent_flag))
|
|---|
| 1051 | ? "%s" : (char *) 0, p);
|
|---|
| 1052 |
|
|---|
| 1053 | /* Tell update_goal_chain that a command has been started on behalf of
|
|---|
| 1054 | this target. It is important that this happens here and not in
|
|---|
| 1055 | reap_children (where we used to do it), because reap_children might be
|
|---|
| 1056 | reaping children from a different target. We want this increment to
|
|---|
| 1057 | guaranteedly indicate that a command was started for the dependency
|
|---|
| 1058 | chain (i.e., update_file recursion chain) we are processing. */
|
|---|
| 1059 |
|
|---|
| 1060 | ++commands_started;
|
|---|
| 1061 |
|
|---|
| 1062 | /* Optimize an empty command. People use this for timestamp rules,
|
|---|
| 1063 | so avoid forking a useless shell. Do this after we increment
|
|---|
| 1064 | commands_started so make still treats this special case as if it
|
|---|
| 1065 | performed some action (makes a difference as to what messages are
|
|---|
| 1066 | printed, etc. */
|
|---|
| 1067 |
|
|---|
| 1068 | #if !defined(VMS) && !defined(_AMIGA)
|
|---|
| 1069 | if (
|
|---|
| 1070 | #if defined __MSDOS__ || defined (__EMX__)
|
|---|
| 1071 | unixy_shell /* the test is complicated and we already did it */
|
|---|
| 1072 | #else
|
|---|
| 1073 | (argv[0] && !strcmp (argv[0], "/bin/sh"))
|
|---|
| 1074 | #endif
|
|---|
| 1075 | && (argv[1]
|
|---|
| 1076 | && argv[1][0] == '-' && argv[1][1] == 'c' && argv[1][2] == '\0')
|
|---|
| 1077 | && (argv[2] && argv[2][0] == ':' && argv[2][1] == '\0')
|
|---|
| 1078 | && argv[3] == NULL)
|
|---|
| 1079 | {
|
|---|
| 1080 | free (argv[0]);
|
|---|
| 1081 | free ((char *) argv);
|
|---|
| 1082 | goto next_command;
|
|---|
| 1083 | }
|
|---|
| 1084 | #endif /* !VMS && !_AMIGA */
|
|---|
| 1085 |
|
|---|
| 1086 | /* If -n was given, recurse to get the next line in the sequence. */
|
|---|
| 1087 |
|
|---|
| 1088 | if (just_print_flag && !(flags & COMMANDS_RECURSE))
|
|---|
| 1089 | {
|
|---|
| 1090 | #ifndef VMS
|
|---|
| 1091 | free (argv[0]);
|
|---|
| 1092 | free ((char *) argv);
|
|---|
| 1093 | #endif
|
|---|
| 1094 | goto next_command;
|
|---|
| 1095 | }
|
|---|
| 1096 |
|
|---|
| 1097 | /* Flush the output streams so they won't have things written twice. */
|
|---|
| 1098 |
|
|---|
| 1099 | fflush (stdout);
|
|---|
| 1100 | fflush (stderr);
|
|---|
| 1101 |
|
|---|
| 1102 | #ifndef VMS
|
|---|
| 1103 | #if !defined(WINDOWS32) && !defined(_AMIGA) && !defined(__MSDOS__)
|
|---|
| 1104 |
|
|---|
| 1105 | /* Set up a bad standard input that reads from a broken pipe. */
|
|---|
| 1106 |
|
|---|
| 1107 | if (bad_stdin == -1)
|
|---|
| 1108 | {
|
|---|
| 1109 | /* Make a file descriptor that is the read end of a broken pipe.
|
|---|
| 1110 | This will be used for some children's standard inputs. */
|
|---|
| 1111 | int pd[2];
|
|---|
| 1112 | if (pipe (pd) == 0)
|
|---|
| 1113 | {
|
|---|
| 1114 | /* Close the write side. */
|
|---|
| 1115 | (void) close (pd[1]);
|
|---|
| 1116 | /* Save the read side. */
|
|---|
| 1117 | bad_stdin = pd[0];
|
|---|
| 1118 |
|
|---|
| 1119 | /* Set the descriptor to close on exec, so it does not litter any
|
|---|
| 1120 | child's descriptor table. When it is dup2'd onto descriptor 0,
|
|---|
| 1121 | that descriptor will not close on exec. */
|
|---|
| 1122 | CLOSE_ON_EXEC (bad_stdin);
|
|---|
| 1123 | }
|
|---|
| 1124 | }
|
|---|
| 1125 |
|
|---|
| 1126 | #endif /* !WINDOWS32 && !_AMIGA && !__MSDOS__ */
|
|---|
| 1127 |
|
|---|
| 1128 | /* Decide whether to give this child the `good' standard input
|
|---|
| 1129 | (one that points to the terminal or whatever), or the `bad' one
|
|---|
| 1130 | that points to the read side of a broken pipe. */
|
|---|
| 1131 |
|
|---|
| 1132 | child->good_stdin = !good_stdin_used;
|
|---|
| 1133 | if (child->good_stdin)
|
|---|
| 1134 | good_stdin_used = 1;
|
|---|
| 1135 |
|
|---|
| 1136 | #endif /* !VMS */
|
|---|
| 1137 |
|
|---|
| 1138 | child->deleted = 0;
|
|---|
| 1139 |
|
|---|
| 1140 | #ifndef _AMIGA
|
|---|
| 1141 | /* Set up the environment for the child. */
|
|---|
| 1142 | if (child->environment == 0)
|
|---|
| 1143 | child->environment = target_environment (child->file);
|
|---|
| 1144 | #endif
|
|---|
| 1145 |
|
|---|
| 1146 | #if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32)
|
|---|
| 1147 |
|
|---|
| 1148 | #ifndef VMS
|
|---|
| 1149 | /* start_waiting_job has set CHILD->remote if we can start a remote job. */
|
|---|
| 1150 | if (child->remote)
|
|---|
| 1151 | {
|
|---|
| 1152 | int is_remote, id, used_stdin;
|
|---|
| 1153 | if (start_remote_job (argv, child->environment,
|
|---|
| 1154 | child->good_stdin ? 0 : bad_stdin,
|
|---|
| 1155 | &is_remote, &id, &used_stdin))
|
|---|
| 1156 | /* Don't give up; remote execution may fail for various reasons. If
|
|---|
| 1157 | so, simply run the job locally. */
|
|---|
| 1158 | goto run_local;
|
|---|
| 1159 | else
|
|---|
| 1160 | {
|
|---|
| 1161 | if (child->good_stdin && !used_stdin)
|
|---|
| 1162 | {
|
|---|
| 1163 | child->good_stdin = 0;
|
|---|
| 1164 | good_stdin_used = 0;
|
|---|
| 1165 | }
|
|---|
| 1166 | child->remote = is_remote;
|
|---|
| 1167 | child->pid = id;
|
|---|
| 1168 | }
|
|---|
| 1169 | }
|
|---|
| 1170 | else
|
|---|
| 1171 | #endif /* !VMS */
|
|---|
| 1172 | {
|
|---|
| 1173 | /* Fork the child process. */
|
|---|
| 1174 |
|
|---|
| 1175 | char **parent_environ;
|
|---|
| 1176 |
|
|---|
| 1177 | run_local:
|
|---|
| 1178 | block_sigs ();
|
|---|
| 1179 |
|
|---|
| 1180 | child->remote = 0;
|
|---|
| 1181 |
|
|---|
| 1182 | #ifdef VMS
|
|---|
| 1183 |
|
|---|
| 1184 | if (!child_execute_job (argv, child)) {
|
|---|
| 1185 | /* Fork failed! */
|
|---|
| 1186 | perror_with_name ("vfork", "");
|
|---|
| 1187 | goto error;
|
|---|
| 1188 | }
|
|---|
| 1189 |
|
|---|
| 1190 | #else
|
|---|
| 1191 |
|
|---|
| 1192 | parent_environ = environ;
|
|---|
| 1193 |
|
|---|
| 1194 | # ifdef __EMX__
|
|---|
| 1195 | /* If we aren't running a recursive command and we have a jobserver
|
|---|
| 1196 | pipe, close it before exec'ing. */
|
|---|
| 1197 | if (!(flags & COMMANDS_RECURSE) && job_fds[0] >= 0)
|
|---|
| 1198 | {
|
|---|
| 1199 | CLOSE_ON_EXEC (job_fds[0]);
|
|---|
| 1200 | CLOSE_ON_EXEC (job_fds[1]);
|
|---|
| 1201 | }
|
|---|
| 1202 | if (job_rfd >= 0)
|
|---|
| 1203 | CLOSE_ON_EXEC (job_rfd);
|
|---|
| 1204 |
|
|---|
| 1205 | /* Never use fork()/exec() here! Use spawn() instead in exec_command() */
|
|---|
| 1206 | child->pid = child_execute_job (child->good_stdin ? 0 : bad_stdin, 1,
|
|---|
| 1207 | argv, child->environment);
|
|---|
| 1208 | if (child->pid < 0)
|
|---|
| 1209 | {
|
|---|
| 1210 | /* spawn failed! */
|
|---|
| 1211 | unblock_sigs ();
|
|---|
| 1212 | perror_with_name ("spawn", "");
|
|---|
| 1213 | goto error;
|
|---|
| 1214 | }
|
|---|
| 1215 |
|
|---|
| 1216 | /* undo CLOSE_ON_EXEC() after the child process has been started */
|
|---|
| 1217 | if (!(flags & COMMANDS_RECURSE) && job_fds[0] >= 0)
|
|---|
| 1218 | {
|
|---|
| 1219 | fcntl (job_fds[0], F_SETFD, 0);
|
|---|
| 1220 | fcntl (job_fds[1], F_SETFD, 0);
|
|---|
| 1221 | }
|
|---|
| 1222 | if (job_rfd >= 0)
|
|---|
| 1223 | fcntl (job_rfd, F_SETFD, 0);
|
|---|
| 1224 |
|
|---|
| 1225 | #else /* !__EMX__ */
|
|---|
| 1226 |
|
|---|
| 1227 | child->pid = vfork ();
|
|---|
| 1228 | environ = parent_environ; /* Restore value child may have clobbered. */
|
|---|
| 1229 | if (child->pid == 0)
|
|---|
| 1230 | {
|
|---|
| 1231 | /* We are the child side. */
|
|---|
| 1232 | unblock_sigs ();
|
|---|
| 1233 |
|
|---|
| 1234 | /* If we aren't running a recursive command and we have a jobserver
|
|---|
| 1235 | pipe, close it before exec'ing. */
|
|---|
| 1236 | if (!(flags & COMMANDS_RECURSE) && job_fds[0] >= 0)
|
|---|
| 1237 | {
|
|---|
| 1238 | close (job_fds[0]);
|
|---|
| 1239 | close (job_fds[1]);
|
|---|
| 1240 | }
|
|---|
| 1241 | if (job_rfd >= 0)
|
|---|
| 1242 | close (job_rfd);
|
|---|
| 1243 |
|
|---|
| 1244 | child_execute_job (child->good_stdin ? 0 : bad_stdin, 1,
|
|---|
| 1245 | argv, child->environment);
|
|---|
| 1246 | }
|
|---|
| 1247 | else if (child->pid < 0)
|
|---|
| 1248 | {
|
|---|
| 1249 | /* Fork failed! */
|
|---|
| 1250 | unblock_sigs ();
|
|---|
| 1251 | perror_with_name ("vfork", "");
|
|---|
| 1252 | goto error;
|
|---|
| 1253 | }
|
|---|
| 1254 | # endif /* !__EMX__ */
|
|---|
| 1255 | #endif /* !VMS */
|
|---|
| 1256 | }
|
|---|
| 1257 |
|
|---|
| 1258 | #else /* __MSDOS__ or Amiga or WINDOWS32 */
|
|---|
| 1259 | #ifdef __MSDOS__
|
|---|
| 1260 | {
|
|---|
| 1261 | int proc_return;
|
|---|
| 1262 |
|
|---|
| 1263 | block_sigs ();
|
|---|
| 1264 | dos_status = 0;
|
|---|
| 1265 |
|
|---|
| 1266 | /* We call `system' to do the job of the SHELL, since stock DOS
|
|---|
| 1267 | shell is too dumb. Our `system' knows how to handle long
|
|---|
| 1268 | command lines even if pipes/redirection is needed; it will only
|
|---|
| 1269 | call COMMAND.COM when its internal commands are used. */
|
|---|
| 1270 | if (execute_by_shell)
|
|---|
| 1271 | {
|
|---|
| 1272 | char *cmdline = argv[0];
|
|---|
| 1273 | /* We don't have a way to pass environment to `system',
|
|---|
| 1274 | so we need to save and restore ours, sigh... */
|
|---|
| 1275 | char **parent_environ = environ;
|
|---|
| 1276 |
|
|---|
| 1277 | environ = child->environment;
|
|---|
| 1278 |
|
|---|
| 1279 | /* If we have a *real* shell, tell `system' to call
|
|---|
| 1280 | it to do everything for us. */
|
|---|
| 1281 | if (unixy_shell)
|
|---|
| 1282 | {
|
|---|
| 1283 | /* A *real* shell on MSDOS may not support long
|
|---|
| 1284 | command lines the DJGPP way, so we must use `system'. */
|
|---|
| 1285 | cmdline = argv[2]; /* get past "shell -c" */
|
|---|
| 1286 | }
|
|---|
| 1287 |
|
|---|
| 1288 | dos_command_running = 1;
|
|---|
| 1289 | proc_return = system (cmdline);
|
|---|
| 1290 | environ = parent_environ;
|
|---|
| 1291 | execute_by_shell = 0; /* for the next time */
|
|---|
| 1292 | }
|
|---|
| 1293 | else
|
|---|
| 1294 | {
|
|---|
| 1295 | dos_command_running = 1;
|
|---|
| 1296 | proc_return = spawnvpe (P_WAIT, argv[0], argv, child->environment);
|
|---|
| 1297 | }
|
|---|
| 1298 |
|
|---|
| 1299 | /* Need to unblock signals before turning off
|
|---|
| 1300 | dos_command_running, so that child's signals
|
|---|
| 1301 | will be treated as such (see fatal_error_signal). */
|
|---|
| 1302 | unblock_sigs ();
|
|---|
| 1303 | dos_command_running = 0;
|
|---|
| 1304 |
|
|---|
| 1305 | /* If the child got a signal, dos_status has its
|
|---|
| 1306 | high 8 bits set, so be careful not to alter them. */
|
|---|
| 1307 | if (proc_return == -1)
|
|---|
| 1308 | dos_status |= 0xff;
|
|---|
| 1309 | else
|
|---|
| 1310 | dos_status |= (proc_return & 0xff);
|
|---|
| 1311 | ++dead_children;
|
|---|
| 1312 | child->pid = dos_pid++;
|
|---|
| 1313 | }
|
|---|
| 1314 | #endif /* __MSDOS__ */
|
|---|
| 1315 | #ifdef _AMIGA
|
|---|
| 1316 | amiga_status = MyExecute (argv);
|
|---|
| 1317 |
|
|---|
| 1318 | ++dead_children;
|
|---|
| 1319 | child->pid = amiga_pid++;
|
|---|
| 1320 | if (amiga_batch_file)
|
|---|
| 1321 | {
|
|---|
| 1322 | amiga_batch_file = 0;
|
|---|
| 1323 | DeleteFile (amiga_bname); /* Ignore errors. */
|
|---|
| 1324 | }
|
|---|
| 1325 | #endif /* Amiga */
|
|---|
| 1326 | #ifdef WINDOWS32
|
|---|
| 1327 | {
|
|---|
| 1328 | HANDLE hPID;
|
|---|
| 1329 | char* arg0;
|
|---|
| 1330 |
|
|---|
| 1331 | /* make UNC paths safe for CreateProcess -- backslash format */
|
|---|
| 1332 | arg0 = argv[0];
|
|---|
| 1333 | if (arg0 && arg0[0] == '/' && arg0[1] == '/')
|
|---|
| 1334 | for ( ; arg0 && *arg0; arg0++)
|
|---|
| 1335 | if (*arg0 == '/')
|
|---|
| 1336 | *arg0 = '\\';
|
|---|
| 1337 |
|
|---|
| 1338 | /* make sure CreateProcess() has Path it needs */
|
|---|
| 1339 | sync_Path_environment();
|
|---|
| 1340 |
|
|---|
| 1341 | hPID = process_easy(argv, child->environment);
|
|---|
| 1342 |
|
|---|
| 1343 | if (hPID != INVALID_HANDLE_VALUE)
|
|---|
| 1344 | child->pid = (int) hPID;
|
|---|
| 1345 | else {
|
|---|
| 1346 | int i;
|
|---|
| 1347 | unblock_sigs();
|
|---|
| 1348 | fprintf(stderr,
|
|---|
| 1349 | _("process_easy() failed failed to launch process (e=%d)\n"),
|
|---|
| 1350 | process_last_err(hPID));
|
|---|
| 1351 | for (i = 0; argv[i]; i++)
|
|---|
| 1352 | fprintf(stderr, "%s ", argv[i]);
|
|---|
| 1353 | fprintf(stderr, _("\nCounted %d args in failed launch\n"), i);
|
|---|
| 1354 | }
|
|---|
| 1355 | }
|
|---|
| 1356 | #endif /* WINDOWS32 */
|
|---|
| 1357 | #endif /* __MSDOS__ or Amiga or WINDOWS32 */
|
|---|
| 1358 |
|
|---|
| 1359 | /* We are the parent side. Set the state to
|
|---|
| 1360 | say the commands are running and return. */
|
|---|
| 1361 |
|
|---|
| 1362 | set_command_state (child->file, cs_running);
|
|---|
| 1363 |
|
|---|
| 1364 | /* Free the storage used by the child's argument list. */
|
|---|
| 1365 | #ifndef VMS
|
|---|
| 1366 | free (argv[0]);
|
|---|
| 1367 | free ((char *) argv);
|
|---|
| 1368 | #endif
|
|---|
| 1369 |
|
|---|
| 1370 | return;
|
|---|
| 1371 |
|
|---|
| 1372 | error:
|
|---|
| 1373 | child->file->update_status = 2;
|
|---|
| 1374 | notice_finished_file (child->file);
|
|---|
| 1375 | return;
|
|---|
| 1376 | }
|
|---|
| 1377 |
|
|---|
| 1378 | /* Try to start a child running.
|
|---|
| 1379 | Returns nonzero if the child was started (and maybe finished), or zero if
|
|---|
| 1380 | the load was too high and the child was put on the `waiting_jobs' chain. */
|
|---|
| 1381 |
|
|---|
| 1382 | static int
|
|---|
| 1383 | start_waiting_job (struct child *c)
|
|---|
| 1384 | {
|
|---|
| 1385 | struct file *f = c->file;
|
|---|
| 1386 |
|
|---|
| 1387 | /* If we can start a job remotely, we always want to, and don't care about
|
|---|
| 1388 | the local load average. We record that the job should be started
|
|---|
| 1389 | remotely in C->remote for start_job_command to test. */
|
|---|
| 1390 |
|
|---|
| 1391 | c->remote = start_remote_job_p (1);
|
|---|
| 1392 |
|
|---|
| 1393 | /* If we are running at least one job already and the load average
|
|---|
| 1394 | is too high, make this one wait. */
|
|---|
| 1395 | if (!c->remote && job_slots_used > 0 && load_too_high ())
|
|---|
| 1396 | {
|
|---|
| 1397 | /* Put this child on the chain of children waiting for the load average
|
|---|
| 1398 | to go down. */
|
|---|
| 1399 | set_command_state (f, cs_running);
|
|---|
| 1400 | c->next = waiting_jobs;
|
|---|
| 1401 | waiting_jobs = c;
|
|---|
| 1402 | return 0;
|
|---|
| 1403 | }
|
|---|
| 1404 |
|
|---|
| 1405 | /* Start the first command; reap_children will run later command lines. */
|
|---|
| 1406 | start_job_command (c);
|
|---|
| 1407 |
|
|---|
| 1408 | switch (f->command_state)
|
|---|
| 1409 | {
|
|---|
| 1410 | case cs_running:
|
|---|
| 1411 | c->next = children;
|
|---|
| 1412 | DB (DB_JOBS, (_("Putting child 0x%08lx (%s) PID %ld%s on the chain.\n"),
|
|---|
| 1413 | (unsigned long int) c, c->file->name,
|
|---|
| 1414 | (long) c->pid, c->remote ? _(" (remote)") : ""));
|
|---|
| 1415 | children = c;
|
|---|
| 1416 | /* One more job slot is in use. */
|
|---|
| 1417 | ++job_slots_used;
|
|---|
| 1418 | unblock_sigs ();
|
|---|
| 1419 | break;
|
|---|
| 1420 |
|
|---|
| 1421 | case cs_not_started:
|
|---|
| 1422 | /* All the command lines turned out to be empty. */
|
|---|
| 1423 | f->update_status = 0;
|
|---|
| 1424 | /* FALLTHROUGH */
|
|---|
| 1425 |
|
|---|
| 1426 | case cs_finished:
|
|---|
| 1427 | notice_finished_file (f);
|
|---|
| 1428 | free_child (c);
|
|---|
| 1429 | break;
|
|---|
| 1430 |
|
|---|
| 1431 | default:
|
|---|
| 1432 | assert (f->command_state == cs_finished);
|
|---|
| 1433 | break;
|
|---|
| 1434 | }
|
|---|
| 1435 |
|
|---|
| 1436 | return 1;
|
|---|
| 1437 | }
|
|---|
| 1438 |
|
|---|
| 1439 | /* Create a `struct child' for FILE and start its commands running. */
|
|---|
| 1440 |
|
|---|
| 1441 | void
|
|---|
| 1442 | new_job (struct file *file)
|
|---|
| 1443 | {
|
|---|
| 1444 | register struct commands *cmds = file->cmds;
|
|---|
| 1445 | register struct child *c;
|
|---|
| 1446 | char **lines;
|
|---|
| 1447 | register unsigned int i;
|
|---|
| 1448 |
|
|---|
| 1449 | /* Let any previously decided-upon jobs that are waiting
|
|---|
| 1450 | for the load to go down start before this new one. */
|
|---|
| 1451 | start_waiting_jobs ();
|
|---|
| 1452 |
|
|---|
| 1453 | /* Reap any children that might have finished recently. */
|
|---|
| 1454 | reap_children (0, 0);
|
|---|
| 1455 |
|
|---|
| 1456 | /* Chop the commands up into lines if they aren't already. */
|
|---|
| 1457 | chop_commands (cmds);
|
|---|
| 1458 |
|
|---|
| 1459 | /* Expand the command lines and store the results in LINES. */
|
|---|
| 1460 | lines = (char **) xmalloc (cmds->ncommand_lines * sizeof (char *));
|
|---|
| 1461 | for (i = 0; i < cmds->ncommand_lines; ++i)
|
|---|
| 1462 | {
|
|---|
| 1463 | /* Collapse backslash-newline combinations that are inside variable
|
|---|
| 1464 | or function references. These are left alone by the parser so
|
|---|
| 1465 | that they will appear in the echoing of commands (where they look
|
|---|
| 1466 | nice); and collapsed by construct_command_argv when it tokenizes.
|
|---|
| 1467 | But letting them survive inside function invocations loses because
|
|---|
| 1468 | we don't want the functions to see them as part of the text. */
|
|---|
| 1469 |
|
|---|
| 1470 | char *in, *out, *ref;
|
|---|
| 1471 |
|
|---|
| 1472 | /* IN points to where in the line we are scanning.
|
|---|
| 1473 | OUT points to where in the line we are writing.
|
|---|
| 1474 | When we collapse a backslash-newline combination,
|
|---|
| 1475 | IN gets ahead of OUT. */
|
|---|
| 1476 |
|
|---|
| 1477 | in = out = cmds->command_lines[i];
|
|---|
| 1478 | while ((ref = strchr (in, '$')) != 0)
|
|---|
| 1479 | {
|
|---|
| 1480 | ++ref; /* Move past the $. */
|
|---|
| 1481 |
|
|---|
| 1482 | if (out != in)
|
|---|
| 1483 | /* Copy the text between the end of the last chunk
|
|---|
| 1484 | we processed (where IN points) and the new chunk
|
|---|
| 1485 | we are about to process (where REF points). */
|
|---|
| 1486 | bcopy (in, out, ref - in);
|
|---|
| 1487 |
|
|---|
| 1488 | /* Move both pointers past the boring stuff. */
|
|---|
| 1489 | out += ref - in;
|
|---|
| 1490 | in = ref;
|
|---|
| 1491 |
|
|---|
| 1492 | if (*ref == '(' || *ref == '{')
|
|---|
| 1493 | {
|
|---|
| 1494 | char openparen = *ref;
|
|---|
| 1495 | char closeparen = openparen == '(' ? ')' : '}';
|
|---|
| 1496 | int count;
|
|---|
| 1497 | char *p;
|
|---|
| 1498 |
|
|---|
| 1499 | *out++ = *in++; /* Copy OPENPAREN. */
|
|---|
| 1500 | /* IN now points past the opening paren or brace.
|
|---|
| 1501 | Count parens or braces until it is matched. */
|
|---|
| 1502 | count = 0;
|
|---|
| 1503 | while (*in != '\0')
|
|---|
| 1504 | {
|
|---|
| 1505 | if (*in == closeparen && --count < 0)
|
|---|
| 1506 | break;
|
|---|
| 1507 | else if (*in == '\\' && in[1] == '\n')
|
|---|
| 1508 | {
|
|---|
| 1509 | /* We have found a backslash-newline inside a
|
|---|
| 1510 | variable or function reference. Eat it and
|
|---|
| 1511 | any following whitespace. */
|
|---|
| 1512 |
|
|---|
| 1513 | int quoted = 0;
|
|---|
| 1514 | for (p = in - 1; p > ref && *p == '\\'; --p)
|
|---|
| 1515 | quoted = !quoted;
|
|---|
| 1516 |
|
|---|
| 1517 | if (quoted)
|
|---|
| 1518 | /* There were two or more backslashes, so this is
|
|---|
| 1519 | not really a continuation line. We don't collapse
|
|---|
| 1520 | the quoting backslashes here as is done in
|
|---|
| 1521 | collapse_continuations, because the line will
|
|---|
| 1522 | be collapsed again after expansion. */
|
|---|
| 1523 | *out++ = *in++;
|
|---|
| 1524 | else
|
|---|
| 1525 | {
|
|---|
| 1526 | /* Skip the backslash, newline and
|
|---|
| 1527 | any following whitespace. */
|
|---|
| 1528 | in = next_token (in + 2);
|
|---|
| 1529 |
|
|---|
| 1530 | /* Discard any preceding whitespace that has
|
|---|
| 1531 | already been written to the output. */
|
|---|
| 1532 | while (out > ref
|
|---|
| 1533 | && isblank ((unsigned char)out[-1]))
|
|---|
| 1534 | --out;
|
|---|
| 1535 |
|
|---|
| 1536 | /* Replace it all with a single space. */
|
|---|
| 1537 | *out++ = ' ';
|
|---|
| 1538 | }
|
|---|
| 1539 | }
|
|---|
| 1540 | else
|
|---|
| 1541 | {
|
|---|
| 1542 | if (*in == openparen)
|
|---|
| 1543 | ++count;
|
|---|
| 1544 |
|
|---|
| 1545 | *out++ = *in++;
|
|---|
| 1546 | }
|
|---|
| 1547 | }
|
|---|
| 1548 | }
|
|---|
| 1549 | }
|
|---|
| 1550 |
|
|---|
| 1551 | /* There are no more references in this line to worry about.
|
|---|
| 1552 | Copy the remaining uninteresting text to the output. */
|
|---|
| 1553 | if (out != in)
|
|---|
| 1554 | strcpy (out, in);
|
|---|
| 1555 |
|
|---|
| 1556 | /* Finally, expand the line. */
|
|---|
| 1557 | lines[i] = allocated_variable_expand_for_file (cmds->command_lines[i],
|
|---|
| 1558 | file);
|
|---|
| 1559 | }
|
|---|
| 1560 |
|
|---|
| 1561 | /* Start the command sequence, record it in a new
|
|---|
| 1562 | `struct child', and add that to the chain. */
|
|---|
| 1563 |
|
|---|
| 1564 | c = (struct child *) xmalloc (sizeof (struct child));
|
|---|
| 1565 | bzero ((char *)c, sizeof (struct child));
|
|---|
| 1566 | c->file = file;
|
|---|
| 1567 | c->command_lines = lines;
|
|---|
| 1568 | c->sh_batch_file = NULL;
|
|---|
| 1569 |
|
|---|
| 1570 | /* Fetch the first command line to be run. */
|
|---|
| 1571 | job_next_command (c);
|
|---|
| 1572 |
|
|---|
| 1573 | /* Wait for a job slot to be freed up. If we allow an infinite number
|
|---|
| 1574 | don't bother; also job_slots will == 0 if we're using the jobserver. */
|
|---|
| 1575 |
|
|---|
| 1576 | if (job_slots != 0)
|
|---|
| 1577 | while (job_slots_used == job_slots)
|
|---|
| 1578 | reap_children (1, 0);
|
|---|
| 1579 |
|
|---|
| 1580 | #ifdef MAKE_JOBSERVER
|
|---|
| 1581 | /* If we are controlling multiple jobs make sure we have a token before
|
|---|
| 1582 | starting the child. */
|
|---|
| 1583 |
|
|---|
| 1584 | /* This can be inefficient. There's a decent chance that this job won't
|
|---|
| 1585 | actually have to run any subprocesses: the command script may be empty
|
|---|
| 1586 | or otherwise optimized away. It would be nice if we could defer
|
|---|
| 1587 | obtaining a token until just before we need it, in start_job_command.
|
|---|
| 1588 | To do that we'd need to keep track of whether we'd already obtained a
|
|---|
| 1589 | token (since start_job_command is called for each line of the job, not
|
|---|
| 1590 | just once). Also more thought needs to go into the entire algorithm;
|
|---|
| 1591 | this is where the old parallel job code waits, so... */
|
|---|
| 1592 |
|
|---|
| 1593 | else if (job_fds[0] >= 0)
|
|---|
| 1594 | while (1)
|
|---|
| 1595 | {
|
|---|
| 1596 | char token;
|
|---|
| 1597 | int got_token;
|
|---|
| 1598 | int saved_errno;
|
|---|
| 1599 |
|
|---|
| 1600 | DB (DB_JOBS, ("Need a job token; we %shave children\n",
|
|---|
| 1601 | children ? "" : "don't "));
|
|---|
| 1602 |
|
|---|
| 1603 | /* If we don't already have a job started, use our "free" token. */
|
|---|
| 1604 | if (!children)
|
|---|
| 1605 | break;
|
|---|
| 1606 |
|
|---|
| 1607 | /* Read a token. As long as there's no token available we'll block.
|
|---|
| 1608 | We enable interruptible system calls before the read(2) so that if
|
|---|
| 1609 | we get a SIGCHLD while we're waiting, we'll return with EINTR and
|
|---|
| 1610 | we can process the death(s) and return tokens to the free pool.
|
|---|
| 1611 |
|
|---|
| 1612 | Once we return from the read, we immediately reinstate restartable
|
|---|
| 1613 | system calls. This allows us to not worry about checking for
|
|---|
| 1614 | EINTR on all the other system calls in the program.
|
|---|
| 1615 |
|
|---|
| 1616 | There is one other twist: there is a span between the time
|
|---|
| 1617 | reap_children() does its last check for dead children and the time
|
|---|
| 1618 | the read(2) call is entered, below, where if a child dies we won't
|
|---|
| 1619 | notice. This is extremely serious as it could cause us to
|
|---|
| 1620 | deadlock, given the right set of events.
|
|---|
| 1621 |
|
|---|
| 1622 | To avoid this, we do the following: before we reap_children(), we
|
|---|
| 1623 | dup(2) the read FD on the jobserver pipe. The read(2) call below
|
|---|
| 1624 | uses that new FD. In the signal handler, we close that FD. That
|
|---|
| 1625 | way, if a child dies during the section mentioned above, the
|
|---|
| 1626 | read(2) will be invoked with an invalid FD and will return
|
|---|
| 1627 | immediately with EBADF. */
|
|---|
| 1628 |
|
|---|
| 1629 | /* Make sure we have a dup'd FD. */
|
|---|
| 1630 | if (job_rfd < 0)
|
|---|
| 1631 | {
|
|---|
| 1632 | DB (DB_JOBS, ("Duplicate the job FD\n"));
|
|---|
| 1633 | job_rfd = dup (job_fds[0]);
|
|---|
| 1634 | }
|
|---|
| 1635 |
|
|---|
| 1636 | /* Reap anything that's currently waiting. */
|
|---|
| 1637 | reap_children (0, 0);
|
|---|
| 1638 |
|
|---|
| 1639 | /* If our "free" token has become available, use it. */
|
|---|
| 1640 | if (!children)
|
|---|
| 1641 | break;
|
|---|
| 1642 |
|
|---|
| 1643 | /* Set interruptible system calls, and read() for a job token. */
|
|---|
| 1644 | set_child_handler_action_flags (0);
|
|---|
| 1645 | got_token = read (job_rfd, &token, 1);
|
|---|
| 1646 | saved_errno = errno;
|
|---|
| 1647 | set_child_handler_action_flags (SA_RESTART);
|
|---|
| 1648 |
|
|---|
| 1649 | /* If we got one, we're done here. */
|
|---|
| 1650 | if (got_token == 1)
|
|---|
| 1651 | {
|
|---|
| 1652 | DB (DB_JOBS, (_("Obtained token for child 0x%08lx (%s).\n"),
|
|---|
| 1653 | (unsigned long int) c, c->file->name));
|
|---|
| 1654 | break;
|
|---|
| 1655 | }
|
|---|
| 1656 |
|
|---|
| 1657 | /* If the error _wasn't_ expected (EINTR or EBADF), punt. Otherwise,
|
|---|
| 1658 | go back and reap_children(), and try again. */
|
|---|
| 1659 | errno = saved_errno;
|
|---|
| 1660 | if (errno != EINTR && errno != EBADF)
|
|---|
| 1661 | pfatal_with_name (_("read jobs pipe"));
|
|---|
| 1662 | if (errno == EBADF)
|
|---|
| 1663 | DB (DB_JOBS, ("Read returned EBADF.\n"));
|
|---|
| 1664 | }
|
|---|
| 1665 | #endif
|
|---|
| 1666 |
|
|---|
| 1667 | /* The job is now primed. Start it running.
|
|---|
| 1668 | (This will notice if there are in fact no commands.) */
|
|---|
| 1669 | (void) start_waiting_job (c);
|
|---|
| 1670 |
|
|---|
| 1671 | if (job_slots == 1 || not_parallel)
|
|---|
| 1672 | /* Since there is only one job slot, make things run linearly.
|
|---|
| 1673 | Wait for the child to die, setting the state to `cs_finished'. */
|
|---|
| 1674 | while (file->command_state == cs_running)
|
|---|
| 1675 | reap_children (1, 0);
|
|---|
| 1676 |
|
|---|
| 1677 | return;
|
|---|
| 1678 | }
|
|---|
| 1679 | |
|---|
| 1680 |
|
|---|
| 1681 | /* Move CHILD's pointers to the next command for it to execute.
|
|---|
| 1682 | Returns nonzero if there is another command. */
|
|---|
| 1683 |
|
|---|
| 1684 | static int
|
|---|
| 1685 | job_next_command (struct child *child)
|
|---|
| 1686 | {
|
|---|
| 1687 | while (child->command_ptr == 0 || *child->command_ptr == '\0')
|
|---|
| 1688 | {
|
|---|
| 1689 | /* There are no more lines in the expansion of this line. */
|
|---|
| 1690 | if (child->command_line == child->file->cmds->ncommand_lines)
|
|---|
| 1691 | {
|
|---|
| 1692 | /* There are no more lines to be expanded. */
|
|---|
| 1693 | child->command_ptr = 0;
|
|---|
| 1694 | return 0;
|
|---|
| 1695 | }
|
|---|
| 1696 | else
|
|---|
| 1697 | /* Get the next line to run. */
|
|---|
| 1698 | child->command_ptr = child->command_lines[child->command_line++];
|
|---|
| 1699 | }
|
|---|
| 1700 | return 1;
|
|---|
| 1701 | }
|
|---|
| 1702 |
|
|---|
| 1703 | static int
|
|---|
| 1704 | load_too_high (void)
|
|---|
| 1705 | {
|
|---|
| 1706 | #if defined(__MSDOS__) || defined(VMS) || defined(_AMIGA)
|
|---|
| 1707 | return 1;
|
|---|
| 1708 | #else
|
|---|
| 1709 | double load;
|
|---|
| 1710 |
|
|---|
| 1711 | if (max_load_average < 0)
|
|---|
| 1712 | return 0;
|
|---|
| 1713 |
|
|---|
| 1714 | make_access ();
|
|---|
| 1715 | if (getloadavg (&load, 1) != 1)
|
|---|
| 1716 | {
|
|---|
| 1717 | static int lossage = -1;
|
|---|
| 1718 | /* Complain only once for the same error. */
|
|---|
| 1719 | if (lossage == -1 || errno != lossage)
|
|---|
| 1720 | {
|
|---|
| 1721 | if (errno == 0)
|
|---|
| 1722 | /* An errno value of zero means getloadavg is just unsupported. */
|
|---|
| 1723 | error (NILF,
|
|---|
| 1724 | _("cannot enforce load limits on this operating system"));
|
|---|
| 1725 | else
|
|---|
| 1726 | perror_with_name (_("cannot enforce load limit: "), "getloadavg");
|
|---|
| 1727 | }
|
|---|
| 1728 | lossage = errno;
|
|---|
| 1729 | load = 0;
|
|---|
| 1730 | }
|
|---|
| 1731 | user_access ();
|
|---|
| 1732 |
|
|---|
| 1733 | DB (DB_JOBS, ("Current system load = %f (max requested = %f)\n",
|
|---|
| 1734 | load, max_load_average));
|
|---|
| 1735 | return load >= max_load_average;
|
|---|
| 1736 | #endif
|
|---|
| 1737 | }
|
|---|
| 1738 |
|
|---|
| 1739 | /* Start jobs that are waiting for the load to be lower. */
|
|---|
| 1740 |
|
|---|
| 1741 | void
|
|---|
| 1742 | start_waiting_jobs (void)
|
|---|
| 1743 | {
|
|---|
| 1744 | struct child *job;
|
|---|
| 1745 |
|
|---|
| 1746 | if (waiting_jobs == 0)
|
|---|
| 1747 | return;
|
|---|
| 1748 |
|
|---|
| 1749 | do
|
|---|
| 1750 | {
|
|---|
| 1751 | /* Check for recently deceased descendants. */
|
|---|
| 1752 | reap_children (0, 0);
|
|---|
| 1753 |
|
|---|
| 1754 | /* Take a job off the waiting list. */
|
|---|
| 1755 | job = waiting_jobs;
|
|---|
| 1756 | waiting_jobs = job->next;
|
|---|
| 1757 |
|
|---|
| 1758 | /* Try to start that job. We break out of the loop as soon
|
|---|
| 1759 | as start_waiting_job puts one back on the waiting list. */
|
|---|
| 1760 | }
|
|---|
| 1761 | while (start_waiting_job (job) && waiting_jobs != 0);
|
|---|
| 1762 |
|
|---|
| 1763 | return;
|
|---|
| 1764 | }
|
|---|
| 1765 | |
|---|
| 1766 |
|
|---|
| 1767 | #ifndef WINDOWS32
|
|---|
| 1768 | #ifdef VMS
|
|---|
| 1769 | #include <descrip.h>
|
|---|
| 1770 | #include <clidef.h>
|
|---|
| 1771 |
|
|---|
| 1772 | /* This is called as an AST when a child process dies (it won't get
|
|---|
| 1773 | interrupted by anything except a higher level AST).
|
|---|
| 1774 | */
|
|---|
| 1775 | int vmsHandleChildTerm(struct child *child)
|
|---|
| 1776 | {
|
|---|
| 1777 | int status;
|
|---|
| 1778 | register struct child *lastc, *c;
|
|---|
| 1779 | int child_failed;
|
|---|
| 1780 |
|
|---|
| 1781 | vms_jobsefnmask &= ~(1 << (child->efn - 32));
|
|---|
| 1782 |
|
|---|
| 1783 | lib$free_ef(&child->efn);
|
|---|
| 1784 |
|
|---|
| 1785 | (void) sigblock (fatal_signal_mask);
|
|---|
| 1786 |
|
|---|
| 1787 | child_failed = !(child->cstatus & 1 || ((child->cstatus & 7) == 0));
|
|---|
| 1788 |
|
|---|
| 1789 | /* Search for a child matching the deceased one. */
|
|---|
| 1790 | lastc = 0;
|
|---|
| 1791 | #if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
|
|---|
| 1792 | for (c = children; c != 0 && c != child; lastc = c, c = c->next);
|
|---|
| 1793 | #else
|
|---|
| 1794 | c = child;
|
|---|
| 1795 | #endif
|
|---|
| 1796 |
|
|---|
| 1797 | if (child_failed && !c->noerror && !ignore_errors_flag)
|
|---|
| 1798 | {
|
|---|
| 1799 | /* The commands failed. Write an error message,
|
|---|
| 1800 | delete non-precious targets, and abort. */
|
|---|
| 1801 | child_error (c->file->name, c->cstatus, 0, 0, 0);
|
|---|
| 1802 | c->file->update_status = 1;
|
|---|
| 1803 | delete_child_targets (c);
|
|---|
| 1804 | }
|
|---|
| 1805 | else
|
|---|
| 1806 | {
|
|---|
| 1807 | if (child_failed)
|
|---|
| 1808 | {
|
|---|
| 1809 | /* The commands failed, but we don't care. */
|
|---|
| 1810 | child_error (c->file->name, c->cstatus, 0, 0, 1);
|
|---|
| 1811 | child_failed = 0;
|
|---|
| 1812 | }
|
|---|
| 1813 |
|
|---|
| 1814 | #if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
|
|---|
| 1815 | /* If there are more commands to run, try to start them. */
|
|---|
| 1816 | start_job (c);
|
|---|
| 1817 |
|
|---|
| 1818 | switch (c->file->command_state)
|
|---|
| 1819 | {
|
|---|
| 1820 | case cs_running:
|
|---|
| 1821 | /* Successfully started. */
|
|---|
| 1822 | break;
|
|---|
| 1823 |
|
|---|
| 1824 | case cs_finished:
|
|---|
| 1825 | if (c->file->update_status != 0) {
|
|---|
| 1826 | /* We failed to start the commands. */
|
|---|
| 1827 | delete_child_targets (c);
|
|---|
| 1828 | }
|
|---|
| 1829 | break;
|
|---|
| 1830 |
|
|---|
| 1831 | default:
|
|---|
| 1832 | error (NILF, _("internal error: `%s' command_state"),
|
|---|
| 1833 | c->file->name);
|
|---|
| 1834 | abort ();
|
|---|
| 1835 | break;
|
|---|
| 1836 | }
|
|---|
| 1837 | #endif /* RECURSIVEJOBS */
|
|---|
| 1838 | }
|
|---|
| 1839 |
|
|---|
| 1840 | /* Set the state flag to say the commands have finished. */
|
|---|
| 1841 | c->file->command_state = cs_finished;
|
|---|
| 1842 | notice_finished_file (c->file);
|
|---|
| 1843 |
|
|---|
| 1844 | #if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
|
|---|
| 1845 | /* Remove the child from the chain and free it. */
|
|---|
| 1846 | if (lastc == 0)
|
|---|
| 1847 | children = c->next;
|
|---|
| 1848 | else
|
|---|
| 1849 | lastc->next = c->next;
|
|---|
| 1850 | free_child (c);
|
|---|
| 1851 | #endif /* RECURSIVEJOBS */
|
|---|
| 1852 |
|
|---|
| 1853 | /* There is now another slot open. */
|
|---|
| 1854 | if (job_slots_used > 0)
|
|---|
| 1855 | --job_slots_used;
|
|---|
| 1856 |
|
|---|
| 1857 | /* If the job failed, and the -k flag was not given, die. */
|
|---|
| 1858 | if (child_failed && !keep_going_flag)
|
|---|
| 1859 | die (EXIT_FAILURE);
|
|---|
| 1860 |
|
|---|
| 1861 | (void) sigsetmask (sigblock (0) & ~(fatal_signal_mask));
|
|---|
| 1862 |
|
|---|
| 1863 | return 1;
|
|---|
| 1864 | }
|
|---|
| 1865 |
|
|---|
| 1866 | /* VMS:
|
|---|
| 1867 | Spawn a process executing the command in ARGV and return its pid. */
|
|---|
| 1868 |
|
|---|
| 1869 | #define MAXCMDLEN 200
|
|---|
| 1870 |
|
|---|
| 1871 | /* local helpers to make ctrl+c and ctrl+y working, see below */
|
|---|
| 1872 | #include <iodef.h>
|
|---|
| 1873 | #include <libclidef.h>
|
|---|
| 1874 | #include <ssdef.h>
|
|---|
| 1875 |
|
|---|
| 1876 | static int ctrlMask= LIB$M_CLI_CTRLY;
|
|---|
| 1877 | static int oldCtrlMask;
|
|---|
| 1878 | static int setupYAstTried= 0;
|
|---|
| 1879 | static int pidToAbort= 0;
|
|---|
| 1880 | static int chan= 0;
|
|---|
| 1881 |
|
|---|
| 1882 | static void reEnableAst(void) {
|
|---|
| 1883 | lib$enable_ctrl (&oldCtrlMask,0);
|
|---|
| 1884 | }
|
|---|
| 1885 |
|
|---|
| 1886 | static astHandler (void) {
|
|---|
| 1887 | if (pidToAbort) {
|
|---|
| 1888 | sys$forcex (&pidToAbort, 0, SS$_ABORT);
|
|---|
| 1889 | pidToAbort= 0;
|
|---|
| 1890 | }
|
|---|
| 1891 | kill (getpid(),SIGQUIT);
|
|---|
| 1892 | }
|
|---|
| 1893 |
|
|---|
| 1894 | static void tryToSetupYAst(void) {
|
|---|
| 1895 | $DESCRIPTOR(inputDsc,"SYS$COMMAND");
|
|---|
| 1896 | int status;
|
|---|
| 1897 | struct {
|
|---|
| 1898 | short int status, count;
|
|---|
| 1899 | int dvi;
|
|---|
| 1900 | } iosb;
|
|---|
| 1901 |
|
|---|
| 1902 | setupYAstTried++;
|
|---|
| 1903 |
|
|---|
| 1904 | if (!chan) {
|
|---|
| 1905 | status= sys$assign(&inputDsc,&chan,0,0);
|
|---|
| 1906 | if (!(status&SS$_NORMAL)) {
|
|---|
| 1907 | lib$signal(status);
|
|---|
| 1908 | return;
|
|---|
| 1909 | }
|
|---|
| 1910 | }
|
|---|
| 1911 | status= sys$qiow (0, chan, IO$_SETMODE|IO$M_CTRLYAST,&iosb,0,0,
|
|---|
| 1912 | astHandler,0,0,0,0,0);
|
|---|
| 1913 | if (status==SS$_ILLIOFUNC) {
|
|---|
| 1914 | sys$dassgn(chan);
|
|---|
| 1915 | #ifdef CTRLY_ENABLED_ANYWAY
|
|---|
| 1916 | fprintf (stderr,
|
|---|
| 1917 | _("-warning, CTRL-Y will leave sub-process(es) around.\n"));
|
|---|
| 1918 | #else
|
|---|
| 1919 | return;
|
|---|
| 1920 | #endif
|
|---|
| 1921 | }
|
|---|
| 1922 | if (status==SS$_NORMAL)
|
|---|
| 1923 | status= iosb.status;
|
|---|
| 1924 | if (!(status&SS$_NORMAL)) {
|
|---|
| 1925 | lib$signal(status);
|
|---|
| 1926 | return;
|
|---|
| 1927 | }
|
|---|
| 1928 |
|
|---|
| 1929 | /* called from AST handler ? */
|
|---|
| 1930 | if (setupYAstTried>1)
|
|---|
| 1931 | return;
|
|---|
| 1932 | if (atexit(reEnableAst))
|
|---|
| 1933 | fprintf (stderr,
|
|---|
| 1934 | _("-warning, you may have to re-enable CTRL-Y handling from DCL.\n"));
|
|---|
| 1935 | status= lib$disable_ctrl (&ctrlMask, &oldCtrlMask);
|
|---|
| 1936 | if (!(status&SS$_NORMAL)) {
|
|---|
| 1937 | lib$signal(status);
|
|---|
| 1938 | return;
|
|---|
| 1939 | }
|
|---|
| 1940 | }
|
|---|
| 1941 | int
|
|---|
| 1942 | child_execute_job (char *argv, struct child *child)
|
|---|
| 1943 | {
|
|---|
| 1944 | int i;
|
|---|
| 1945 | static struct dsc$descriptor_s cmddsc;
|
|---|
| 1946 | static struct dsc$descriptor_s pnamedsc;
|
|---|
| 1947 | static struct dsc$descriptor_s ifiledsc;
|
|---|
| 1948 | static struct dsc$descriptor_s ofiledsc;
|
|---|
| 1949 | static struct dsc$descriptor_s efiledsc;
|
|---|
| 1950 | int have_redirection = 0;
|
|---|
| 1951 | int have_newline = 0;
|
|---|
| 1952 |
|
|---|
| 1953 | int spflags = CLI$M_NOWAIT;
|
|---|
| 1954 | int status;
|
|---|
| 1955 | char *cmd = alloca (strlen (argv) + 512), *p, *q;
|
|---|
| 1956 | char ifile[256], ofile[256], efile[256];
|
|---|
| 1957 | char *comname = 0;
|
|---|
| 1958 | char procname[100];
|
|---|
| 1959 |
|
|---|
| 1960 | /* Parse IO redirection. */
|
|---|
| 1961 |
|
|---|
| 1962 | ifile[0] = 0;
|
|---|
| 1963 | ofile[0] = 0;
|
|---|
| 1964 | efile[0] = 0;
|
|---|
| 1965 |
|
|---|
| 1966 | DB (DB_JOBS, ("child_execute_job (%s)\n", argv));
|
|---|
| 1967 |
|
|---|
| 1968 | while (isspace ((unsigned char)*argv))
|
|---|
| 1969 | argv++;
|
|---|
| 1970 |
|
|---|
| 1971 | if (*argv == 0)
|
|---|
| 1972 | return 0;
|
|---|
| 1973 |
|
|---|
| 1974 | sprintf (procname, "GMAKE_%05x", getpid () & 0xfffff);
|
|---|
| 1975 | pnamedsc.dsc$w_length = strlen(procname);
|
|---|
| 1976 | pnamedsc.dsc$a_pointer = procname;
|
|---|
| 1977 | pnamedsc.dsc$b_dtype = DSC$K_DTYPE_T;
|
|---|
| 1978 | pnamedsc.dsc$b_class = DSC$K_CLASS_S;
|
|---|
| 1979 |
|
|---|
| 1980 | /* Handle comments and redirection. */
|
|---|
| 1981 | for (p = argv, q = cmd; *p; p++, q++)
|
|---|
| 1982 | {
|
|---|
| 1983 | switch (*p)
|
|---|
| 1984 | {
|
|---|
| 1985 | case '#':
|
|---|
| 1986 | *p-- = 0;
|
|---|
| 1987 | *q-- = 0;
|
|---|
| 1988 | break;
|
|---|
| 1989 | case '\\':
|
|---|
| 1990 | p++;
|
|---|
| 1991 | if (*p == '\n')
|
|---|
| 1992 | p++;
|
|---|
| 1993 | if (isspace ((unsigned char)*p))
|
|---|
| 1994 | {
|
|---|
| 1995 | do { p++; } while (isspace ((unsigned char)*p));
|
|---|
| 1996 | p--;
|
|---|
| 1997 | }
|
|---|
| 1998 | *q = *p;
|
|---|
| 1999 | break;
|
|---|
| 2000 | case '<':
|
|---|
| 2001 | p = vms_redirect (&ifiledsc, ifile, p);
|
|---|
| 2002 | *q = ' ';
|
|---|
| 2003 | have_redirection = 1;
|
|---|
| 2004 | break;
|
|---|
| 2005 | case '>':
|
|---|
| 2006 | have_redirection = 1;
|
|---|
| 2007 | if (*(p-1) == '2')
|
|---|
| 2008 | {
|
|---|
| 2009 | q--;
|
|---|
| 2010 | if (strncmp (p, ">&1", 3) == 0)
|
|---|
| 2011 | {
|
|---|
| 2012 | p += 3;
|
|---|
| 2013 | strcpy (efile, "sys$output");
|
|---|
| 2014 | efiledsc.dsc$w_length = strlen(efile);
|
|---|
| 2015 | efiledsc.dsc$a_pointer = efile;
|
|---|
| 2016 | efiledsc.dsc$b_dtype = DSC$K_DTYPE_T;
|
|---|
| 2017 | efiledsc.dsc$b_class = DSC$K_CLASS_S;
|
|---|
| 2018 | }
|
|---|
| 2019 | else
|
|---|
| 2020 | {
|
|---|
| 2021 | p = vms_redirect (&efiledsc, efile, p);
|
|---|
| 2022 | }
|
|---|
| 2023 | }
|
|---|
| 2024 | else
|
|---|
| 2025 | {
|
|---|
| 2026 | p = vms_redirect (&ofiledsc, ofile, p);
|
|---|
| 2027 | }
|
|---|
| 2028 | *q = ' ';
|
|---|
| 2029 | break;
|
|---|
| 2030 | case '\n':
|
|---|
| 2031 | have_newline = 1;
|
|---|
| 2032 | default:
|
|---|
| 2033 | *q = *p;
|
|---|
| 2034 | break;
|
|---|
| 2035 | }
|
|---|
| 2036 | }
|
|---|
| 2037 | *q = *p;
|
|---|
| 2038 |
|
|---|
| 2039 | if (strncmp (cmd, "builtin_", 8) == 0)
|
|---|
| 2040 | {
|
|---|
| 2041 | child->pid = 270163;
|
|---|
| 2042 | child->efn = 0;
|
|---|
| 2043 | child->cstatus = 1;
|
|---|
| 2044 |
|
|---|
| 2045 | DB (DB_JOBS, (_("BUILTIN [%s][%s]\n"), cmd, cmd+8));
|
|---|
| 2046 |
|
|---|
| 2047 | p = cmd + 8;
|
|---|
| 2048 |
|
|---|
| 2049 | if ((*(p) == 'c')
|
|---|
| 2050 | && (*(p+1) == 'd')
|
|---|
| 2051 | && ((*(p+2) == ' ') || (*(p+2) == '\t')))
|
|---|
| 2052 | {
|
|---|
| 2053 | p += 3;
|
|---|
| 2054 | while ((*p == ' ') || (*p == '\t'))
|
|---|
| 2055 | p++;
|
|---|
| 2056 | DB (DB_JOBS, (_("BUILTIN CD %s\n"), p));
|
|---|
| 2057 | if (chdir (p))
|
|---|
| 2058 | return 0;
|
|---|
| 2059 | else
|
|---|
| 2060 | return 1;
|
|---|
| 2061 | }
|
|---|
| 2062 | else if ((*(p) == 'r')
|
|---|
| 2063 | && (*(p+1) == 'm')
|
|---|
| 2064 | && ((*(p+2) == ' ') || (*(p+2) == '\t')))
|
|---|
| 2065 | {
|
|---|
| 2066 | int in_arg;
|
|---|
| 2067 |
|
|---|
| 2068 | /* rm */
|
|---|
| 2069 | p += 3;
|
|---|
| 2070 | while ((*p == ' ') || (*p == '\t'))
|
|---|
| 2071 | p++;
|
|---|
| 2072 | in_arg = 1;
|
|---|
| 2073 |
|
|---|
| 2074 | DB (DB_JOBS, (_("BUILTIN RM %s\n"), p));
|
|---|
| 2075 | while (*p)
|
|---|
| 2076 | {
|
|---|
| 2077 | switch (*p)
|
|---|
| 2078 | {
|
|---|
| 2079 | case ' ':
|
|---|
| 2080 | case '\t':
|
|---|
| 2081 | if (in_arg)
|
|---|
| 2082 | {
|
|---|
| 2083 | *p++ = ';';
|
|---|
| 2084 | in_arg = 0;
|
|---|
| 2085 | }
|
|---|
| 2086 | break;
|
|---|
| 2087 | default:
|
|---|
| 2088 | break;
|
|---|
| 2089 | }
|
|---|
| 2090 | p++;
|
|---|
| 2091 | }
|
|---|
| 2092 | }
|
|---|
| 2093 | else
|
|---|
| 2094 | {
|
|---|
| 2095 | printf(_("Unknown builtin command '%s'\n"), cmd);
|
|---|
| 2096 | fflush(stdout);
|
|---|
| 2097 | return 0;
|
|---|
| 2098 | }
|
|---|
| 2099 | }
|
|---|
| 2100 |
|
|---|
| 2101 | /* Create a *.com file if either the command is too long for
|
|---|
| 2102 | lib$spawn, or the command contains a newline, or if redirection
|
|---|
| 2103 | is desired. Forcing commands with newlines into DCLs allows to
|
|---|
| 2104 | store search lists on user mode logicals. */
|
|---|
| 2105 |
|
|---|
| 2106 | if (strlen (cmd) > MAXCMDLEN
|
|---|
| 2107 | || (have_redirection != 0)
|
|---|
| 2108 | || (have_newline != 0))
|
|---|
| 2109 | {
|
|---|
| 2110 | FILE *outfile;
|
|---|
| 2111 | char c;
|
|---|
| 2112 | char *sep;
|
|---|
| 2113 | int alevel = 0; /* apostrophe level */
|
|---|
| 2114 |
|
|---|
| 2115 | if (strlen (cmd) == 0)
|
|---|
| 2116 | {
|
|---|
| 2117 | printf (_("Error, empty command\n"));
|
|---|
| 2118 | fflush (stdout);
|
|---|
| 2119 | return 0;
|
|---|
| 2120 | }
|
|---|
| 2121 |
|
|---|
| 2122 | outfile = open_tmpfile (&comname, "sys$scratch:CMDXXXXXX.COM");
|
|---|
| 2123 | if (outfile == 0)
|
|---|
| 2124 | pfatal_with_name (_("fopen (temporary file)"));
|
|---|
| 2125 |
|
|---|
| 2126 | if (ifile[0])
|
|---|
| 2127 | {
|
|---|
| 2128 | fprintf (outfile, "$ assign/user %s sys$input\n", ifile);
|
|---|
| 2129 | DB (DB_JOBS, (_("Redirected input from %s\n"), ifile));
|
|---|
| 2130 | ifiledsc.dsc$w_length = 0;
|
|---|
| 2131 | }
|
|---|
| 2132 |
|
|---|
| 2133 | if (efile[0])
|
|---|
| 2134 | {
|
|---|
| 2135 | fprintf (outfile, "$ define sys$error %s\n", efile);
|
|---|
| 2136 | DB (DB_JOBS, (_("Redirected error to %s\n"), efile));
|
|---|
| 2137 | efiledsc.dsc$w_length = 0;
|
|---|
| 2138 | }
|
|---|
| 2139 |
|
|---|
| 2140 | if (ofile[0])
|
|---|
| 2141 | {
|
|---|
| 2142 | fprintf (outfile, "$ define sys$output %s\n", ofile);
|
|---|
| 2143 | DB (DB_JOBS, (_("Redirected output to %s\n"), ofile));
|
|---|
| 2144 | ofiledsc.dsc$w_length = 0;
|
|---|
| 2145 | }
|
|---|
| 2146 |
|
|---|
| 2147 | p = sep = q = cmd;
|
|---|
| 2148 | for (c = '\n'; c; c = *q++)
|
|---|
| 2149 | {
|
|---|
| 2150 | switch (c)
|
|---|
| 2151 | {
|
|---|
| 2152 | case '\n':
|
|---|
| 2153 | /* At a newline, skip any whitespace around a leading $
|
|---|
| 2154 | from the command and issue exactly one $ into the DCL. */
|
|---|
| 2155 | while (isspace ((unsigned char)*p))
|
|---|
| 2156 | p++;
|
|---|
| 2157 | if (*p == '$')
|
|---|
| 2158 | p++;
|
|---|
| 2159 | while (isspace ((unsigned char)*p))
|
|---|
| 2160 | p++;
|
|---|
| 2161 | fwrite (p, 1, q - p, outfile);
|
|---|
| 2162 | fputc ('$', outfile);
|
|---|
| 2163 | fputc (' ', outfile);
|
|---|
| 2164 | /* Reset variables. */
|
|---|
| 2165 | p = sep = q;
|
|---|
| 2166 | break;
|
|---|
| 2167 |
|
|---|
| 2168 | /* Nice places for line breaks are after strings, after
|
|---|
| 2169 | comma or space and before slash. */
|
|---|
| 2170 | case '"':
|
|---|
| 2171 | q = handle_apos (q + 1);
|
|---|
| 2172 | sep = q;
|
|---|
| 2173 | break;
|
|---|
| 2174 | case ',':
|
|---|
| 2175 | case ' ':
|
|---|
| 2176 | sep = q;
|
|---|
| 2177 | break;
|
|---|
| 2178 | case '/':
|
|---|
| 2179 | case '\0':
|
|---|
| 2180 | sep = q - 1;
|
|---|
| 2181 | break;
|
|---|
| 2182 | default:
|
|---|
| 2183 | break;
|
|---|
| 2184 | }
|
|---|
| 2185 | if (sep - p > 78)
|
|---|
| 2186 | {
|
|---|
| 2187 | /* Enough stuff for a line. */
|
|---|
| 2188 | fwrite (p, 1, sep - p, outfile);
|
|---|
| 2189 | p = sep;
|
|---|
| 2190 | if (*sep)
|
|---|
| 2191 | {
|
|---|
| 2192 | /* The command continues. */
|
|---|
| 2193 | fputc ('-', outfile);
|
|---|
| 2194 | }
|
|---|
| 2195 | fputc ('\n', outfile);
|
|---|
| 2196 | }
|
|---|
| 2197 | }
|
|---|
| 2198 |
|
|---|
| 2199 | fwrite (p, 1, q - p, outfile);
|
|---|
| 2200 | fputc ('\n', outfile);
|
|---|
| 2201 |
|
|---|
| 2202 | fclose (outfile);
|
|---|
| 2203 |
|
|---|
| 2204 | sprintf (cmd, "$ @%s", comname);
|
|---|
| 2205 |
|
|---|
| 2206 | DB (DB_JOBS, (_("Executing %s instead\n"), cmd));
|
|---|
| 2207 | }
|
|---|
| 2208 |
|
|---|
| 2209 | cmddsc.dsc$w_length = strlen(cmd);
|
|---|
| 2210 | cmddsc.dsc$a_pointer = cmd;
|
|---|
| 2211 | cmddsc.dsc$b_dtype = DSC$K_DTYPE_T;
|
|---|
| 2212 | cmddsc.dsc$b_class = DSC$K_CLASS_S;
|
|---|
| 2213 |
|
|---|
| 2214 | child->efn = 0;
|
|---|
| 2215 | while (child->efn < 32 || child->efn > 63)
|
|---|
| 2216 | {
|
|---|
| 2217 | status = lib$get_ef ((unsigned long *)&child->efn);
|
|---|
| 2218 | if (!(status & 1))
|
|---|
| 2219 | return 0;
|
|---|
| 2220 | }
|
|---|
| 2221 |
|
|---|
| 2222 | sys$clref (child->efn);
|
|---|
| 2223 |
|
|---|
| 2224 | vms_jobsefnmask |= (1 << (child->efn - 32));
|
|---|
| 2225 |
|
|---|
| 2226 | /*
|
|---|
| 2227 | LIB$SPAWN [command-string]
|
|---|
| 2228 | [,input-file]
|
|---|
| 2229 | [,output-file]
|
|---|
| 2230 | [,flags]
|
|---|
| 2231 | [,process-name]
|
|---|
| 2232 | [,process-id] [,completion-status-address] [,byte-integer-event-flag-num]
|
|---|
| 2233 | [,AST-address] [,varying-AST-argument]
|
|---|
| 2234 | [,prompt-string] [,cli] [,table]
|
|---|
| 2235 | */
|
|---|
| 2236 |
|
|---|
| 2237 | #ifndef DONTWAITFORCHILD
|
|---|
| 2238 | /*
|
|---|
| 2239 | * Code to make ctrl+c and ctrl+y working.
|
|---|
| 2240 | * The problem starts with the synchronous case where after lib$spawn is
|
|---|
| 2241 | * called any input will go to the child. But with input re-directed,
|
|---|
| 2242 | * both control characters won't make it to any of the programs, neither
|
|---|
| 2243 | * the spawning nor to the spawned one. Hence the caller needs to spawn
|
|---|
| 2244 | * with CLI$M_NOWAIT to NOT give up the input focus. A sys$waitfr
|
|---|
| 2245 | * has to follow to simulate the wanted synchronous behaviour.
|
|---|
| 2246 | * The next problem is ctrl+y which isn't caught by the crtl and
|
|---|
| 2247 | * therefore isn't converted to SIGQUIT (for a signal handler which is
|
|---|
| 2248 | * already established). The only way to catch ctrl+y, is an AST
|
|---|
| 2249 | * assigned to the input channel. But ctrl+y handling of DCL needs to be
|
|---|
| 2250 | * disabled, otherwise it will handle it. Not to mention the previous
|
|---|
| 2251 | * ctrl+y handling of DCL needs to be re-established before make exits.
|
|---|
| 2252 | * One more: At the time of LIB$SPAWN signals are blocked. SIGQUIT will
|
|---|
| 2253 | * make it to the signal handler after the child "normally" terminates.
|
|---|
| 2254 | * This isn't enough. It seems reasonable for simple command lines like
|
|---|
| 2255 | * a 'cc foobar.c' spawned in a subprocess but it is unacceptable for
|
|---|
| 2256 | * spawning make. Therefore we need to abort the process in the AST.
|
|---|
| 2257 | *
|
|---|
| 2258 | * Prior to the spawn it is checked if an AST is already set up for
|
|---|
| 2259 | * ctrl+y, if not one is set up for a channel to SYS$COMMAND. In general
|
|---|
| 2260 | * this will work except if make is run in a batch environment, but there
|
|---|
| 2261 | * nobody can press ctrl+y. During the setup the DCL handling of ctrl+y
|
|---|
| 2262 | * is disabled and an exit handler is established to re-enable it.
|
|---|
| 2263 | * If the user interrupts with ctrl+y, the assigned AST will fire, force
|
|---|
| 2264 | * an abort to the subprocess and signal SIGQUIT, which will be caught by
|
|---|
| 2265 | * the already established handler and will bring us back to common code.
|
|---|
| 2266 | * After the spawn (now /nowait) a sys$waitfr simulates the /wait and
|
|---|
| 2267 | * enables the ctrl+y be delivered to this code. And the ctrl+c too,
|
|---|
| 2268 | * which the crtl converts to SIGINT and which is caught by the common
|
|---|
| 2269 | * signal handler. Because signals were blocked before entering this code
|
|---|
| 2270 | * sys$waitfr will always complete and the SIGQUIT will be processed after
|
|---|
| 2271 | * it (after termination of the current block, somewhere in common code).
|
|---|
| 2272 | * And SIGINT too will be delayed. That is ctrl+c can only abort when the
|
|---|
| 2273 | * current command completes. Anyway it's better than nothing :-)
|
|---|
| 2274 | */
|
|---|
| 2275 |
|
|---|
| 2276 | if (!setupYAstTried)
|
|---|
| 2277 | tryToSetupYAst();
|
|---|
| 2278 | status = lib$spawn (&cmddsc, /* cmd-string */
|
|---|
| 2279 | (ifiledsc.dsc$w_length == 0)?0:&ifiledsc, /* input-file */
|
|---|
| 2280 | (ofiledsc.dsc$w_length == 0)?0:&ofiledsc, /* output-file */
|
|---|
| 2281 | &spflags, /* flags */
|
|---|
| 2282 | &pnamedsc, /* proc name */
|
|---|
| 2283 | &child->pid, &child->cstatus, &child->efn,
|
|---|
| 2284 | 0, 0,
|
|---|
| 2285 | 0, 0, 0);
|
|---|
| 2286 | if (status & 1)
|
|---|
| 2287 | {
|
|---|
| 2288 | pidToAbort= child->pid;
|
|---|
| 2289 | status= sys$waitfr (child->efn);
|
|---|
| 2290 | pidToAbort= 0;
|
|---|
| 2291 | vmsHandleChildTerm(child);
|
|---|
| 2292 | }
|
|---|
| 2293 | #else
|
|---|
| 2294 | status = lib$spawn (&cmddsc,
|
|---|
| 2295 | (ifiledsc.dsc$w_length == 0)?0:&ifiledsc,
|
|---|
| 2296 | (ofiledsc.dsc$w_length == 0)?0:&ofiledsc,
|
|---|
| 2297 | &spflags,
|
|---|
| 2298 | &pnamedsc,
|
|---|
| 2299 | &child->pid, &child->cstatus, &child->efn,
|
|---|
| 2300 | vmsHandleChildTerm, child,
|
|---|
| 2301 | 0, 0, 0);
|
|---|
| 2302 | #endif
|
|---|
| 2303 |
|
|---|
| 2304 | if (!(status & 1))
|
|---|
| 2305 | {
|
|---|
| 2306 | printf (_("Error spawning, %d\n") ,status);
|
|---|
| 2307 | fflush (stdout);
|
|---|
| 2308 | switch (status)
|
|---|
| 2309 | {
|
|---|
| 2310 | case 0x1c:
|
|---|
| 2311 | errno = EPROCLIM;
|
|---|
| 2312 | break;
|
|---|
| 2313 | default:
|
|---|
| 2314 | errno = EFAIL;
|
|---|
| 2315 | }
|
|---|
| 2316 | }
|
|---|
| 2317 |
|
|---|
| 2318 | if (comname && !ISDB (DB_JOBS))
|
|---|
| 2319 | unlink (comname);
|
|---|
| 2320 |
|
|---|
| 2321 | return (status & 1);
|
|---|
| 2322 | }
|
|---|
| 2323 |
|
|---|
| 2324 | #else /* !VMS */
|
|---|
| 2325 |
|
|---|
| 2326 | /* EMX: Start a child process. This function returns the new pid. */
|
|---|
| 2327 | # if defined __MSDOS__ || defined __EMX__
|
|---|
| 2328 | int
|
|---|
| 2329 | child_execute_job (int stdin_fd, int stdout_fd, char **argv, char **envp)
|
|---|
| 2330 | {
|
|---|
| 2331 | int pid;
|
|---|
| 2332 | /* stdin_fd == 0 means: nothing to do for stdin;
|
|---|
| 2333 | stdout_fd == 1 means: nothing to do for stdout */
|
|---|
| 2334 | int save_stdin = (stdin_fd != 0) ? dup (0) : 0;
|
|---|
| 2335 | int save_stdout = (stdout_fd != 1) ? dup (1): 1;
|
|---|
| 2336 |
|
|---|
| 2337 | /* < 0 only if dup() failed */
|
|---|
| 2338 | if (save_stdin < 0)
|
|---|
| 2339 | fatal (NILF, _("no more file handles: could not duplicate stdin\n"));
|
|---|
| 2340 | if (save_stdout < 0)
|
|---|
| 2341 | fatal (NILF, _("no more file handles: could not duplicate stdout\n"));
|
|---|
| 2342 |
|
|---|
| 2343 | /* Close unnecessary file handles for the child. */
|
|---|
| 2344 | if (save_stdin != 0)
|
|---|
| 2345 | CLOSE_ON_EXEC (save_stdin);
|
|---|
| 2346 | if (save_stdout != 1)
|
|---|
| 2347 | CLOSE_ON_EXEC (save_stdout);
|
|---|
| 2348 |
|
|---|
| 2349 | /* Connect the pipes to the child process. */
|
|---|
| 2350 | if (stdin_fd != 0)
|
|---|
| 2351 | (void) dup2 (stdin_fd, 0);
|
|---|
| 2352 | if (stdout_fd != 1)
|
|---|
| 2353 | (void) dup2 (stdout_fd, 1);
|
|---|
| 2354 |
|
|---|
| 2355 | /* stdin_fd and stdout_fd must be closed on exit because we are
|
|---|
| 2356 | still in the parent process */
|
|---|
| 2357 | if (stdin_fd != 0)
|
|---|
| 2358 | CLOSE_ON_EXEC (stdin_fd);
|
|---|
| 2359 | if (stdout_fd != 1)
|
|---|
| 2360 | CLOSE_ON_EXEC (stdout_fd);
|
|---|
| 2361 |
|
|---|
| 2362 | /* Run the command. */
|
|---|
| 2363 | pid = exec_command (argv, envp);
|
|---|
| 2364 |
|
|---|
| 2365 | /* Restore stdout/stdin of the parent process. */
|
|---|
| 2366 | if (stdin_fd != 0 && dup2 (save_stdin, 0) != 0)
|
|---|
| 2367 | fatal (NILF, _("restoring of stdin failed\n"));
|
|---|
| 2368 | if (stdout_fd != 1 && dup2 (save_stdout, 1) != 1)
|
|---|
| 2369 | fatal (NILF, _("restoring of stdout failed\n"));
|
|---|
| 2370 |
|
|---|
| 2371 | return pid;
|
|---|
| 2372 | }
|
|---|
| 2373 |
|
|---|
| 2374 | #elif !defined (_AMIGA) && !defined (__MSDOS__)
|
|---|
| 2375 |
|
|---|
| 2376 | /* UNIX:
|
|---|
| 2377 | Replace the current process with one executing the command in ARGV.
|
|---|
| 2378 | STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
|
|---|
| 2379 | the environment of the new program. This function does not return. */
|
|---|
| 2380 | void
|
|---|
| 2381 | child_execute_job (int stdin_fd, int stdout_fd, char **argv, char **envp)
|
|---|
| 2382 | {
|
|---|
| 2383 | if (stdin_fd != 0)
|
|---|
| 2384 | (void) dup2 (stdin_fd, 0);
|
|---|
| 2385 | if (stdout_fd != 1)
|
|---|
| 2386 | (void) dup2 (stdout_fd, 1);
|
|---|
| 2387 | if (stdin_fd != 0)
|
|---|
| 2388 | (void) close (stdin_fd);
|
|---|
| 2389 | if (stdout_fd != 1)
|
|---|
| 2390 | (void) close (stdout_fd);
|
|---|
| 2391 |
|
|---|
| 2392 | /* Run the command. */
|
|---|
| 2393 | exec_command (argv, envp);
|
|---|
| 2394 | }
|
|---|
| 2395 | #endif /* !AMIGA && !__MSDOS__ */
|
|---|
| 2396 | #endif /* !VMS */
|
|---|
| 2397 | #endif /* !WINDOWS32 */
|
|---|
| 2398 | |
|---|
| 2399 |
|
|---|
| 2400 | #ifndef _AMIGA
|
|---|
| 2401 | /* Replace the current process with one running the command in ARGV,
|
|---|
| 2402 | with environment ENVP. This function does not return. */
|
|---|
| 2403 |
|
|---|
| 2404 | /* EMX: This function returns the pid of the child process. */
|
|---|
| 2405 | # ifdef __EMX__
|
|---|
| 2406 | int
|
|---|
| 2407 | # else
|
|---|
| 2408 | void
|
|---|
| 2409 | # endif
|
|---|
| 2410 | exec_command (char **argv, char **envp)
|
|---|
| 2411 | {
|
|---|
| 2412 | #ifdef VMS
|
|---|
| 2413 | /* to work around a problem with signals and execve: ignore them */
|
|---|
| 2414 | #ifdef SIGCHLD
|
|---|
| 2415 | signal (SIGCHLD,SIG_IGN);
|
|---|
| 2416 | #endif
|
|---|
| 2417 | /* Run the program. */
|
|---|
| 2418 | execve (argv[0], argv, envp);
|
|---|
| 2419 | perror_with_name ("execve: ", argv[0]);
|
|---|
| 2420 | _exit (EXIT_FAILURE);
|
|---|
| 2421 | #else
|
|---|
| 2422 | #ifdef WINDOWS32
|
|---|
| 2423 | HANDLE hPID;
|
|---|
| 2424 | HANDLE hWaitPID;
|
|---|
| 2425 | int err = 0;
|
|---|
| 2426 | int exit_code = EXIT_FAILURE;
|
|---|
| 2427 |
|
|---|
| 2428 | /* make sure CreateProcess() has Path it needs */
|
|---|
| 2429 | sync_Path_environment();
|
|---|
| 2430 |
|
|---|
| 2431 | /* launch command */
|
|---|
| 2432 | hPID = process_easy(argv, envp);
|
|---|
| 2433 |
|
|---|
| 2434 | /* make sure launch ok */
|
|---|
| 2435 | if (hPID == INVALID_HANDLE_VALUE)
|
|---|
| 2436 | {
|
|---|
| 2437 | int i;
|
|---|
| 2438 | fprintf(stderr,
|
|---|
| 2439 | _("process_easy() failed failed to launch process (e=%d)\n"),
|
|---|
| 2440 | process_last_err(hPID));
|
|---|
| 2441 | for (i = 0; argv[i]; i++)
|
|---|
| 2442 | fprintf(stderr, "%s ", argv[i]);
|
|---|
| 2443 | fprintf(stderr, _("\nCounted %d args in failed launch\n"), i);
|
|---|
| 2444 | exit(EXIT_FAILURE);
|
|---|
| 2445 | }
|
|---|
| 2446 |
|
|---|
| 2447 | /* wait and reap last child */
|
|---|
| 2448 | while (hWaitPID = process_wait_for_any())
|
|---|
| 2449 | {
|
|---|
| 2450 | /* was an error found on this process? */
|
|---|
| 2451 | err = process_last_err(hWaitPID);
|
|---|
| 2452 |
|
|---|
| 2453 | /* get exit data */
|
|---|
| 2454 | exit_code = process_exit_code(hWaitPID);
|
|---|
| 2455 |
|
|---|
| 2456 | if (err)
|
|---|
| 2457 | fprintf(stderr, "make (e=%d, rc=%d): %s",
|
|---|
| 2458 | err, exit_code, map_windows32_error_to_string(err));
|
|---|
| 2459 |
|
|---|
| 2460 | /* cleanup process */
|
|---|
| 2461 | process_cleanup(hWaitPID);
|
|---|
| 2462 |
|
|---|
| 2463 | /* expect to find only last pid, warn about other pids reaped */
|
|---|
| 2464 | if (hWaitPID == hPID)
|
|---|
| 2465 | break;
|
|---|
| 2466 | else
|
|---|
| 2467 | fprintf(stderr,
|
|---|
| 2468 | _("make reaped child pid %d, still waiting for pid %d\n"),
|
|---|
| 2469 | hWaitPID, hPID);
|
|---|
| 2470 | }
|
|---|
| 2471 |
|
|---|
| 2472 | /* return child's exit code as our exit code */
|
|---|
| 2473 | exit(exit_code);
|
|---|
| 2474 |
|
|---|
| 2475 | #else /* !WINDOWS32 */
|
|---|
| 2476 |
|
|---|
| 2477 | # ifdef __EMX__
|
|---|
| 2478 | int pid;
|
|---|
| 2479 | # endif
|
|---|
| 2480 |
|
|---|
| 2481 | /* Be the user, permanently. */
|
|---|
| 2482 | child_access ();
|
|---|
| 2483 |
|
|---|
| 2484 | # ifdef __EMX__
|
|---|
| 2485 |
|
|---|
| 2486 | /* Run the program. */
|
|---|
| 2487 | pid = spawnvpe (P_NOWAIT, argv[0], argv, envp);
|
|---|
| 2488 |
|
|---|
| 2489 | if (pid >= 0)
|
|---|
| 2490 | return pid;
|
|---|
| 2491 |
|
|---|
| 2492 | /* the file might have a strange shell extension */
|
|---|
| 2493 | if (errno == ENOENT)
|
|---|
| 2494 | errno = ENOEXEC;
|
|---|
| 2495 |
|
|---|
| 2496 | # else
|
|---|
| 2497 |
|
|---|
| 2498 | /* Run the program. */
|
|---|
| 2499 | environ = envp;
|
|---|
| 2500 | execvp (argv[0], argv);
|
|---|
| 2501 |
|
|---|
| 2502 | # endif /* !__EMX__ */
|
|---|
| 2503 |
|
|---|
| 2504 | switch (errno)
|
|---|
| 2505 | {
|
|---|
| 2506 | case ENOENT:
|
|---|
| 2507 | error (NILF, _("%s: Command not found"), argv[0]);
|
|---|
| 2508 | break;
|
|---|
| 2509 | case ENOEXEC:
|
|---|
| 2510 | {
|
|---|
| 2511 | /* The file is not executable. Try it as a shell script. */
|
|---|
| 2512 | extern char *getenv ();
|
|---|
| 2513 | char *shell;
|
|---|
| 2514 | char **new_argv;
|
|---|
| 2515 | int argc;
|
|---|
| 2516 |
|
|---|
| 2517 | # ifdef __EMX__
|
|---|
| 2518 | /* Do not use $SHELL from the environment */
|
|---|
| 2519 | struct variable *p = lookup_variable ("SHELL", 5);
|
|---|
| 2520 | if (p)
|
|---|
| 2521 | shell = p->value;
|
|---|
| 2522 | else
|
|---|
| 2523 | shell = 0;
|
|---|
| 2524 | # else
|
|---|
| 2525 | shell = getenv ("SHELL");
|
|---|
| 2526 | # endif
|
|---|
| 2527 | if (shell == 0)
|
|---|
| 2528 | shell = default_shell;
|
|---|
| 2529 |
|
|---|
| 2530 | argc = 1;
|
|---|
| 2531 | while (argv[argc] != 0)
|
|---|
| 2532 | ++argc;
|
|---|
| 2533 |
|
|---|
| 2534 | new_argv = (char **) alloca ((1 + argc + 1) * sizeof (char *));
|
|---|
| 2535 | new_argv[0] = shell;
|
|---|
| 2536 | new_argv[1] = argv[0];
|
|---|
| 2537 | while (argc > 0)
|
|---|
| 2538 | {
|
|---|
| 2539 | new_argv[1 + argc] = argv[argc];
|
|---|
| 2540 | --argc;
|
|---|
| 2541 | }
|
|---|
| 2542 |
|
|---|
| 2543 | # ifdef __EMX__
|
|---|
| 2544 | pid = spawnvpe (P_NOWAIT, shell, new_argv, envp);
|
|---|
| 2545 | if (pid >= 0)
|
|---|
| 2546 | break;
|
|---|
| 2547 | # else
|
|---|
| 2548 | execvp (shell, new_argv);
|
|---|
| 2549 | # endif
|
|---|
| 2550 | if (errno == ENOENT)
|
|---|
| 2551 | error (NILF, _("%s: Shell program not found"), shell);
|
|---|
| 2552 | else
|
|---|
| 2553 | perror_with_name ("execvp: ", shell);
|
|---|
| 2554 | break;
|
|---|
| 2555 | }
|
|---|
| 2556 |
|
|---|
| 2557 | # ifdef __EMX__
|
|---|
| 2558 | case EINVAL:
|
|---|
| 2559 | /* this nasty error was driving me nuts :-( */
|
|---|
| 2560 | error (NILF, _("spawnvpe: environment space might be exhausted"));
|
|---|
| 2561 | /* FALLTHROUGH */
|
|---|
| 2562 | # endif
|
|---|
| 2563 |
|
|---|
| 2564 | default:
|
|---|
| 2565 | perror_with_name ("execvp: ", argv[0]);
|
|---|
| 2566 | break;
|
|---|
| 2567 | }
|
|---|
| 2568 |
|
|---|
| 2569 | # ifdef __EMX__
|
|---|
| 2570 | return pid;
|
|---|
| 2571 | # else
|
|---|
| 2572 | _exit (127);
|
|---|
| 2573 | # endif
|
|---|
| 2574 | #endif /* !WINDOWS32 */
|
|---|
| 2575 | #endif /* !VMS */
|
|---|
| 2576 | }
|
|---|
| 2577 | #else /* On Amiga */
|
|---|
| 2578 | void exec_command (char **argv)
|
|---|
| 2579 | {
|
|---|
| 2580 | MyExecute (argv);
|
|---|
| 2581 | }
|
|---|
| 2582 |
|
|---|
| 2583 | void clean_tmp (void)
|
|---|
| 2584 | {
|
|---|
| 2585 | DeleteFile (amiga_bname);
|
|---|
| 2586 | }
|
|---|
| 2587 |
|
|---|
| 2588 | #endif /* On Amiga */
|
|---|
| 2589 | |
|---|
| 2590 |
|
|---|
| 2591 | #ifndef VMS
|
|---|
| 2592 | /* Figure out the argument list necessary to run LINE as a command. Try to
|
|---|
| 2593 | avoid using a shell. This routine handles only ' quoting, and " quoting
|
|---|
| 2594 | when no backslash, $ or ` characters are seen in the quotes. Starting
|
|---|
| 2595 | quotes may be escaped with a backslash. If any of the characters in
|
|---|
| 2596 | sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
|
|---|
| 2597 | is the first word of a line, the shell is used.
|
|---|
| 2598 |
|
|---|
| 2599 | If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
|
|---|
| 2600 | If *RESTP is NULL, newlines will be ignored.
|
|---|
| 2601 |
|
|---|
| 2602 | SHELL is the shell to use, or nil to use the default shell.
|
|---|
| 2603 | IFS is the value of $IFS, or nil (meaning the default). */
|
|---|
| 2604 |
|
|---|
| 2605 | static char **
|
|---|
| 2606 | construct_command_argv_internal (char *line, char **restp, char *shell,
|
|---|
| 2607 | char *ifs, char **batch_filename_ptr)
|
|---|
| 2608 | {
|
|---|
| 2609 | #ifdef __MSDOS__
|
|---|
| 2610 | /* MSDOS supports both the stock DOS shell and ports of Unixy shells.
|
|---|
| 2611 | We call `system' for anything that requires ``slow'' processing,
|
|---|
| 2612 | because DOS shells are too dumb. When $SHELL points to a real
|
|---|
| 2613 | (unix-style) shell, `system' just calls it to do everything. When
|
|---|
| 2614 | $SHELL points to a DOS shell, `system' does most of the work
|
|---|
| 2615 | internally, calling the shell only for its internal commands.
|
|---|
| 2616 | However, it looks on the $PATH first, so you can e.g. have an
|
|---|
| 2617 | external command named `mkdir'.
|
|---|
| 2618 |
|
|---|
| 2619 | Since we call `system', certain characters and commands below are
|
|---|
| 2620 | actually not specific to COMMAND.COM, but to the DJGPP implementation
|
|---|
| 2621 | of `system'. In particular:
|
|---|
| 2622 |
|
|---|
| 2623 | The shell wildcard characters are in DOS_CHARS because they will
|
|---|
| 2624 | not be expanded if we call the child via `spawnXX'.
|
|---|
| 2625 |
|
|---|
| 2626 | The `;' is in DOS_CHARS, because our `system' knows how to run
|
|---|
| 2627 | multiple commands on a single line.
|
|---|
| 2628 |
|
|---|
| 2629 | DOS_CHARS also include characters special to 4DOS/NDOS, so we
|
|---|
| 2630 | won't have to tell one from another and have one more set of
|
|---|
| 2631 | commands and special characters. */
|
|---|
| 2632 | static char sh_chars_dos[] = "*?[];|<>%^&()";
|
|---|
| 2633 | static char *sh_cmds_dos[] = { "break", "call", "cd", "chcp", "chdir", "cls",
|
|---|
| 2634 | "copy", "ctty", "date", "del", "dir", "echo",
|
|---|
| 2635 | "erase", "exit", "for", "goto", "if", "md",
|
|---|
| 2636 | "mkdir", "path", "pause", "prompt", "rd",
|
|---|
| 2637 | "rmdir", "rem", "ren", "rename", "set",
|
|---|
| 2638 | "shift", "time", "type", "ver", "verify",
|
|---|
| 2639 | "vol", ":", 0 };
|
|---|
| 2640 |
|
|---|
| 2641 | static char sh_chars_sh[] = "#;\"*?[]&|<>(){}$`^";
|
|---|
| 2642 | static char *sh_cmds_sh[] = { "cd", "echo", "eval", "exec", "exit", "login",
|
|---|
| 2643 | "logout", "set", "umask", "wait", "while",
|
|---|
| 2644 | "for", "case", "if", ":", ".", "break",
|
|---|
| 2645 | "continue", "export", "read", "readonly",
|
|---|
| 2646 | "shift", "times", "trap", "switch", "unset",
|
|---|
| 2647 | 0 };
|
|---|
| 2648 |
|
|---|
| 2649 | char *sh_chars;
|
|---|
| 2650 | char **sh_cmds;
|
|---|
| 2651 | #elif defined (__EMX__)
|
|---|
| 2652 | static char sh_chars_dos[] = "*?[];|<>%^&()";
|
|---|
| 2653 | static char *sh_cmds_dos[] = { "break", "call", "cd", "chcp", "chdir", "cls",
|
|---|
| 2654 | "copy", "ctty", "date", "del", "dir", "echo",
|
|---|
| 2655 | "erase", "exit", "for", "goto", "if", "md",
|
|---|
| 2656 | "mkdir", "path", "pause", "prompt", "rd",
|
|---|
| 2657 | "rmdir", "rem", "ren", "rename", "set",
|
|---|
| 2658 | "shift", "time", "type", "ver", "verify",
|
|---|
| 2659 | "vol", ":", 0 };
|
|---|
| 2660 |
|
|---|
| 2661 | static char sh_chars_os2[] = "*?[];|<>%^()\"'&";
|
|---|
| 2662 | static char *sh_cmds_os2[] = { "call", "cd", "chcp", "chdir", "cls", "copy",
|
|---|
| 2663 | "date", "del", "detach", "dir", "echo",
|
|---|
| 2664 | "endlocal", "erase", "exit", "for", "goto", "if",
|
|---|
| 2665 | "keys", "md", "mkdir", "move", "path", "pause",
|
|---|
| 2666 | "prompt", "rd", "rem", "ren", "rename", "rmdir",
|
|---|
| 2667 | "set", "setlocal", "shift", "start", "time",
|
|---|
| 2668 | "type", "ver", "verify", "vol", ":", 0 };
|
|---|
| 2669 |
|
|---|
| 2670 | static char sh_chars_sh[] = "#;\"*?[]&|<>(){}$`^~'";
|
|---|
| 2671 | static char *sh_cmds_sh[] = { "echo", "cd", "eval", "exec", "exit", "login",
|
|---|
| 2672 | "logout", "set", "umask", "wait", "while",
|
|---|
| 2673 | "for", "case", "if", ":", ".", "break",
|
|---|
| 2674 | "continue", "export", "read", "readonly",
|
|---|
| 2675 | "shift", "times", "trap", "switch", "unset",
|
|---|
| 2676 | 0 };
|
|---|
| 2677 | char *sh_chars;
|
|---|
| 2678 | char **sh_cmds;
|
|---|
| 2679 |
|
|---|
| 2680 | #elif defined (_AMIGA)
|
|---|
| 2681 | static char sh_chars[] = "#;\"|<>()?*$`";
|
|---|
| 2682 | static char *sh_cmds[] = { "cd", "eval", "if", "delete", "echo", "copy",
|
|---|
| 2683 | "rename", "set", "setenv", "date", "makedir",
|
|---|
| 2684 | "skip", "else", "endif", "path", "prompt",
|
|---|
| 2685 | "unset", "unsetenv", "version",
|
|---|
| 2686 | 0 };
|
|---|
| 2687 | #elif defined (WINDOWS32)
|
|---|
| 2688 | static char sh_chars_dos[] = "\"|&<>";
|
|---|
| 2689 | static char *sh_cmds_dos[] = { "break", "call", "cd", "chcp", "chdir", "cls",
|
|---|
| 2690 | "copy", "ctty", "date", "del", "dir", "echo",
|
|---|
| 2691 | "erase", "exit", "for", "goto", "if", "if", "md",
|
|---|
| 2692 | "mkdir", "path", "pause", "prompt", "rd", "rem",
|
|---|
| 2693 | "ren", "rename", "rmdir", "set", "shift", "time",
|
|---|
| 2694 | "type", "ver", "verify", "vol", ":", 0 };
|
|---|
| 2695 | static char sh_chars_sh[] = "#;\"*?[]&|<>(){}$`^";
|
|---|
| 2696 | static char *sh_cmds_sh[] = { "cd", "eval", "exec", "exit", "login",
|
|---|
| 2697 | "logout", "set", "umask", "wait", "while", "for",
|
|---|
| 2698 | "case", "if", ":", ".", "break", "continue",
|
|---|
| 2699 | "export", "read", "readonly", "shift", "times",
|
|---|
| 2700 | "trap", "switch", "test",
|
|---|
| 2701 | #ifdef BATCH_MODE_ONLY_SHELL
|
|---|
| 2702 | "echo",
|
|---|
| 2703 | #endif
|
|---|
| 2704 | 0 };
|
|---|
| 2705 | char* sh_chars;
|
|---|
| 2706 | char** sh_cmds;
|
|---|
| 2707 | #else /* must be UNIX-ish */
|
|---|
| 2708 | static char sh_chars[] = "#;\"*?[]&|<>(){}$`^~";
|
|---|
| 2709 | static char *sh_cmds[] = { "cd", "eval", "exec", "exit", "login",
|
|---|
| 2710 | "logout", "set", "umask", "wait", "while", "for",
|
|---|
| 2711 | "case", "if", ":", ".", "break", "continue",
|
|---|
| 2712 | "export", "read", "readonly", "shift", "times",
|
|---|
| 2713 | "trap", "switch", 0 };
|
|---|
| 2714 | #endif /* __MSDOS__ */
|
|---|
| 2715 | register int i;
|
|---|
| 2716 | register char *p;
|
|---|
| 2717 | register char *ap;
|
|---|
| 2718 | char *end;
|
|---|
| 2719 | int instring, word_has_equals, seen_nonequals, last_argument_was_empty;
|
|---|
| 2720 | char **new_argv = 0;
|
|---|
| 2721 | #ifdef WINDOWS32
|
|---|
| 2722 | int slow_flag = 0;
|
|---|
| 2723 |
|
|---|
| 2724 | if (no_default_sh_exe) {
|
|---|
| 2725 | sh_cmds = sh_cmds_dos;
|
|---|
| 2726 | sh_chars = sh_chars_dos;
|
|---|
| 2727 | } else {
|
|---|
| 2728 | sh_cmds = sh_cmds_sh;
|
|---|
| 2729 | sh_chars = sh_chars_sh;
|
|---|
| 2730 | }
|
|---|
| 2731 | #endif /* WINDOWS32 */
|
|---|
| 2732 |
|
|---|
| 2733 | if (restp != NULL)
|
|---|
| 2734 | *restp = NULL;
|
|---|
| 2735 |
|
|---|
| 2736 | /* Make sure not to bother processing an empty line. */
|
|---|
| 2737 | while (isblank ((unsigned char)*line))
|
|---|
| 2738 | ++line;
|
|---|
| 2739 | if (*line == '\0')
|
|---|
| 2740 | return 0;
|
|---|
| 2741 |
|
|---|
| 2742 | /* See if it is safe to parse commands internally. */
|
|---|
| 2743 | if (shell == 0)
|
|---|
| 2744 | shell = default_shell;
|
|---|
| 2745 | #ifdef WINDOWS32
|
|---|
| 2746 | else if (strcmp (shell, default_shell))
|
|---|
| 2747 | {
|
|---|
| 2748 | char *s1 = _fullpath(NULL, shell, 0);
|
|---|
| 2749 | char *s2 = _fullpath(NULL, default_shell, 0);
|
|---|
| 2750 |
|
|---|
| 2751 | slow_flag = strcmp((s1 ? s1 : ""), (s2 ? s2 : ""));
|
|---|
| 2752 |
|
|---|
| 2753 | if (s1)
|
|---|
| 2754 | free (s1);
|
|---|
| 2755 | if (s2)
|
|---|
| 2756 | free (s2);
|
|---|
| 2757 | }
|
|---|
| 2758 | if (slow_flag)
|
|---|
| 2759 | goto slow;
|
|---|
| 2760 | #else /* not WINDOWS32 */
|
|---|
| 2761 | #if defined (__MSDOS__) || defined (__EMX__)
|
|---|
| 2762 | else if (stricmp (shell, default_shell))
|
|---|
| 2763 | {
|
|---|
| 2764 | extern int _is_unixy_shell (const char *_path);
|
|---|
| 2765 |
|
|---|
| 2766 | DB (DB_BASIC, (_("$SHELL changed (was `%s', now `%s')\n"),
|
|---|
| 2767 | default_shell, shell));
|
|---|
| 2768 | unixy_shell = _is_unixy_shell (shell);
|
|---|
| 2769 | /* we must allocate a copy of shell: construct_command_argv() will free
|
|---|
| 2770 | * shell after this function returns. */
|
|---|
| 2771 | default_shell = xstrdup (shell);
|
|---|
| 2772 | }
|
|---|
| 2773 | if (unixy_shell)
|
|---|
| 2774 | {
|
|---|
| 2775 | sh_chars = sh_chars_sh;
|
|---|
| 2776 | sh_cmds = sh_cmds_sh;
|
|---|
| 2777 | }
|
|---|
| 2778 | else
|
|---|
| 2779 | {
|
|---|
| 2780 | sh_chars = sh_chars_dos;
|
|---|
| 2781 | sh_cmds = sh_cmds_dos;
|
|---|
| 2782 | # ifdef __EMX__
|
|---|
| 2783 | if (_osmode == OS2_MODE)
|
|---|
| 2784 | {
|
|---|
| 2785 | sh_chars = sh_chars_os2;
|
|---|
| 2786 | sh_cmds = sh_cmds_os2;
|
|---|
| 2787 | }
|
|---|
| 2788 | # endif
|
|---|
| 2789 | }
|
|---|
| 2790 | #else /* !__MSDOS__ */
|
|---|
| 2791 | else if (strcmp (shell, default_shell))
|
|---|
| 2792 | goto slow;
|
|---|
| 2793 | #endif /* !__MSDOS__ && !__EMX__ */
|
|---|
| 2794 | #endif /* not WINDOWS32 */
|
|---|
| 2795 |
|
|---|
| 2796 | if (ifs != 0)
|
|---|
| 2797 | for (ap = ifs; *ap != '\0'; ++ap)
|
|---|
| 2798 | if (*ap != ' ' && *ap != '\t' && *ap != '\n')
|
|---|
| 2799 | goto slow;
|
|---|
| 2800 |
|
|---|
| 2801 | i = strlen (line) + 1;
|
|---|
| 2802 |
|
|---|
| 2803 | /* More than 1 arg per character is impossible. */
|
|---|
| 2804 | new_argv = (char **) xmalloc (i * sizeof (char *));
|
|---|
| 2805 |
|
|---|
| 2806 | /* All the args can fit in a buffer as big as LINE is. */
|
|---|
| 2807 | ap = new_argv[0] = (char *) xmalloc (i);
|
|---|
| 2808 | end = ap + i;
|
|---|
| 2809 |
|
|---|
| 2810 | /* I is how many complete arguments have been found. */
|
|---|
| 2811 | i = 0;
|
|---|
| 2812 | instring = word_has_equals = seen_nonequals = last_argument_was_empty = 0;
|
|---|
| 2813 | for (p = line; *p != '\0'; ++p)
|
|---|
| 2814 | {
|
|---|
| 2815 | if (ap > end)
|
|---|
| 2816 | abort ();
|
|---|
| 2817 |
|
|---|
| 2818 | if (instring)
|
|---|
| 2819 | {
|
|---|
| 2820 | string_char:
|
|---|
| 2821 | /* Inside a string, just copy any char except a closing quote
|
|---|
| 2822 | or a backslash-newline combination. */
|
|---|
| 2823 | if (*p == instring)
|
|---|
| 2824 | {
|
|---|
| 2825 | instring = 0;
|
|---|
| 2826 | if (ap == new_argv[0] || *(ap-1) == '\0')
|
|---|
| 2827 | last_argument_was_empty = 1;
|
|---|
| 2828 | }
|
|---|
| 2829 | else if (*p == '\\' && p[1] == '\n')
|
|---|
| 2830 | goto swallow_escaped_newline;
|
|---|
| 2831 | else if (*p == '\n' && restp != NULL)
|
|---|
| 2832 | {
|
|---|
| 2833 | /* End of the command line. */
|
|---|
| 2834 | *restp = p;
|
|---|
| 2835 | goto end_of_line;
|
|---|
| 2836 | }
|
|---|
| 2837 | /* Backslash, $, and ` are special inside double quotes.
|
|---|
| 2838 | If we see any of those, punt.
|
|---|
| 2839 | But on MSDOS, if we use COMMAND.COM, double and single
|
|---|
| 2840 | quotes have the same effect. */
|
|---|
| 2841 | else if (instring == '"' && strchr ("\\$`", *p) != 0 && unixy_shell)
|
|---|
| 2842 | goto slow;
|
|---|
| 2843 | else
|
|---|
| 2844 | *ap++ = *p;
|
|---|
| 2845 | }
|
|---|
| 2846 | else if (strchr (sh_chars, *p) != 0)
|
|---|
| 2847 | /* Not inside a string, but it's a special char. */
|
|---|
| 2848 | goto slow;
|
|---|
| 2849 | #ifdef __MSDOS__
|
|---|
| 2850 | else if (*p == '.' && p[1] == '.' && p[2] == '.' && p[3] != '.')
|
|---|
| 2851 | /* `...' is a wildcard in DJGPP. */
|
|---|
| 2852 | goto slow;
|
|---|
| 2853 | #endif
|
|---|
| 2854 | else
|
|---|
| 2855 | /* Not a special char. */
|
|---|
| 2856 | switch (*p)
|
|---|
| 2857 | {
|
|---|
| 2858 | case '=':
|
|---|
| 2859 | /* Equals is a special character in leading words before the
|
|---|
| 2860 | first word with no equals sign in it. This is not the case
|
|---|
| 2861 | with sh -k, but we never get here when using nonstandard
|
|---|
| 2862 | shell flags. */
|
|---|
| 2863 | if (! seen_nonequals && unixy_shell)
|
|---|
| 2864 | goto slow;
|
|---|
| 2865 | word_has_equals = 1;
|
|---|
| 2866 | *ap++ = '=';
|
|---|
| 2867 | break;
|
|---|
| 2868 |
|
|---|
| 2869 | case '\\':
|
|---|
| 2870 | /* Backslash-newline combinations are eaten. */
|
|---|
| 2871 | if (p[1] == '\n')
|
|---|
| 2872 | {
|
|---|
| 2873 | swallow_escaped_newline:
|
|---|
| 2874 |
|
|---|
| 2875 | /* Eat the backslash, the newline, and following whitespace,
|
|---|
| 2876 | replacing it all with a single space. */
|
|---|
| 2877 | p += 2;
|
|---|
| 2878 |
|
|---|
| 2879 | /* If there is a tab after a backslash-newline,
|
|---|
| 2880 | remove it from the source line which will be echoed,
|
|---|
| 2881 | since it was most likely used to line
|
|---|
| 2882 | up the continued line with the previous one. */
|
|---|
| 2883 | if (*p == '\t')
|
|---|
| 2884 | /* Note these overlap and strcpy() is undefined for
|
|---|
| 2885 | overlapping objects in ANSI C. The strlen() _IS_ right,
|
|---|
| 2886 | since we need to copy the nul byte too. */
|
|---|
| 2887 | bcopy (p + 1, p, strlen (p));
|
|---|
| 2888 |
|
|---|
| 2889 | if (instring)
|
|---|
| 2890 | goto string_char;
|
|---|
| 2891 | else
|
|---|
| 2892 | {
|
|---|
| 2893 | if (ap != new_argv[i])
|
|---|
| 2894 | /* Treat this as a space, ending the arg.
|
|---|
| 2895 | But if it's at the beginning of the arg, it should
|
|---|
| 2896 | just get eaten, rather than becoming an empty arg. */
|
|---|
| 2897 | goto end_of_arg;
|
|---|
| 2898 | else
|
|---|
| 2899 | p = next_token (p) - 1;
|
|---|
| 2900 | }
|
|---|
| 2901 | }
|
|---|
| 2902 | else if (p[1] != '\0')
|
|---|
| 2903 | {
|
|---|
| 2904 | #ifdef HAVE_DOS_PATHS
|
|---|
| 2905 | /* Only remove backslashes before characters special
|
|---|
| 2906 | to Unixy shells. All other backslashes are copied
|
|---|
| 2907 | verbatim, since they are probably DOS-style
|
|---|
| 2908 | directory separators. This still leaves a small
|
|---|
| 2909 | window for problems, but at least it should work
|
|---|
| 2910 | for the vast majority of naive users. */
|
|---|
| 2911 |
|
|---|
| 2912 | #ifdef __MSDOS__
|
|---|
| 2913 | /* A dot is only special as part of the "..."
|
|---|
| 2914 | wildcard. */
|
|---|
| 2915 | if (strneq (p + 1, ".\\.\\.", 5))
|
|---|
| 2916 | {
|
|---|
| 2917 | *ap++ = '.';
|
|---|
| 2918 | *ap++ = '.';
|
|---|
| 2919 | p += 4;
|
|---|
| 2920 | }
|
|---|
| 2921 | else
|
|---|
| 2922 | #endif
|
|---|
| 2923 | if (p[1] != '\\' && p[1] != '\''
|
|---|
| 2924 | && !isspace ((unsigned char)p[1])
|
|---|
| 2925 | && (strchr (sh_chars_sh, p[1]) == 0))
|
|---|
| 2926 | /* back up one notch, to copy the backslash */
|
|---|
| 2927 | --p;
|
|---|
| 2928 | #endif /* HAVE_DOS_PATHS */
|
|---|
| 2929 |
|
|---|
| 2930 | /* Copy and skip the following char. */
|
|---|
| 2931 | *ap++ = *++p;
|
|---|
| 2932 | }
|
|---|
| 2933 | break;
|
|---|
| 2934 |
|
|---|
| 2935 | case '\'':
|
|---|
| 2936 | case '"':
|
|---|
| 2937 | instring = *p;
|
|---|
| 2938 | break;
|
|---|
| 2939 |
|
|---|
| 2940 | case '\n':
|
|---|
| 2941 | if (restp != NULL)
|
|---|
| 2942 | {
|
|---|
| 2943 | /* End of the command line. */
|
|---|
| 2944 | *restp = p;
|
|---|
| 2945 | goto end_of_line;
|
|---|
| 2946 | }
|
|---|
| 2947 | else
|
|---|
| 2948 | /* Newlines are not special. */
|
|---|
| 2949 | *ap++ = '\n';
|
|---|
| 2950 | break;
|
|---|
| 2951 |
|
|---|
| 2952 | case ' ':
|
|---|
| 2953 | case '\t':
|
|---|
| 2954 | end_of_arg:
|
|---|
| 2955 | /* We have the end of an argument.
|
|---|
| 2956 | Terminate the text of the argument. */
|
|---|
| 2957 | *ap++ = '\0';
|
|---|
| 2958 | new_argv[++i] = ap;
|
|---|
| 2959 | last_argument_was_empty = 0;
|
|---|
| 2960 |
|
|---|
| 2961 | /* Update SEEN_NONEQUALS, which tells us if every word
|
|---|
| 2962 | heretofore has contained an `='. */
|
|---|
| 2963 | seen_nonequals |= ! word_has_equals;
|
|---|
| 2964 | if (word_has_equals && ! seen_nonequals)
|
|---|
| 2965 | /* An `=' in a word before the first
|
|---|
| 2966 | word without one is magical. */
|
|---|
| 2967 | goto slow;
|
|---|
| 2968 | word_has_equals = 0; /* Prepare for the next word. */
|
|---|
| 2969 |
|
|---|
| 2970 | /* If this argument is the command name,
|
|---|
| 2971 | see if it is a built-in shell command.
|
|---|
| 2972 | If so, have the shell handle it. */
|
|---|
| 2973 | if (i == 1)
|
|---|
| 2974 | {
|
|---|
| 2975 | register int j;
|
|---|
| 2976 | for (j = 0; sh_cmds[j] != 0; ++j)
|
|---|
| 2977 | if (streq (sh_cmds[j], new_argv[0]))
|
|---|
| 2978 | goto slow;
|
|---|
| 2979 | }
|
|---|
| 2980 |
|
|---|
| 2981 | /* Ignore multiple whitespace chars. */
|
|---|
| 2982 | p = next_token (p);
|
|---|
| 2983 | /* Next iteration should examine the first nonwhite char. */
|
|---|
| 2984 | --p;
|
|---|
| 2985 | break;
|
|---|
| 2986 |
|
|---|
| 2987 | default:
|
|---|
| 2988 | *ap++ = *p;
|
|---|
| 2989 | break;
|
|---|
| 2990 | }
|
|---|
| 2991 | }
|
|---|
| 2992 | end_of_line:
|
|---|
| 2993 |
|
|---|
| 2994 | if (instring)
|
|---|
| 2995 | /* Let the shell deal with an unterminated quote. */
|
|---|
| 2996 | goto slow;
|
|---|
| 2997 |
|
|---|
| 2998 | /* Terminate the last argument and the argument list. */
|
|---|
| 2999 |
|
|---|
| 3000 | *ap = '\0';
|
|---|
| 3001 | if (new_argv[i][0] != '\0' || last_argument_was_empty)
|
|---|
| 3002 | ++i;
|
|---|
| 3003 | new_argv[i] = 0;
|
|---|
| 3004 |
|
|---|
| 3005 | if (i == 1)
|
|---|
| 3006 | {
|
|---|
| 3007 | register int j;
|
|---|
| 3008 | for (j = 0; sh_cmds[j] != 0; ++j)
|
|---|
| 3009 | if (streq (sh_cmds[j], new_argv[0]))
|
|---|
| 3010 | goto slow;
|
|---|
| 3011 | }
|
|---|
| 3012 |
|
|---|
| 3013 | if (new_argv[0] == 0)
|
|---|
| 3014 | /* Line was empty. */
|
|---|
| 3015 | return 0;
|
|---|
| 3016 | else
|
|---|
| 3017 | return new_argv;
|
|---|
| 3018 |
|
|---|
| 3019 | slow:;
|
|---|
| 3020 | /* We must use the shell. */
|
|---|
| 3021 |
|
|---|
| 3022 | if (new_argv != 0)
|
|---|
| 3023 | {
|
|---|
| 3024 | /* Free the old argument list we were working on. */
|
|---|
| 3025 | free (new_argv[0]);
|
|---|
| 3026 | free ((void *)new_argv);
|
|---|
| 3027 | }
|
|---|
| 3028 |
|
|---|
| 3029 | #ifdef __MSDOS__
|
|---|
| 3030 | execute_by_shell = 1; /* actually, call `system' if shell isn't unixy */
|
|---|
| 3031 | #endif
|
|---|
| 3032 |
|
|---|
| 3033 | #ifdef _AMIGA
|
|---|
| 3034 | {
|
|---|
| 3035 | char *ptr;
|
|---|
| 3036 | char *buffer;
|
|---|
| 3037 | char *dptr;
|
|---|
| 3038 |
|
|---|
| 3039 | buffer = (char *)xmalloc (strlen (line)+1);
|
|---|
| 3040 |
|
|---|
| 3041 | ptr = line;
|
|---|
| 3042 | for (dptr=buffer; *ptr; )
|
|---|
| 3043 | {
|
|---|
| 3044 | if (*ptr == '\\' && ptr[1] == '\n')
|
|---|
| 3045 | ptr += 2;
|
|---|
| 3046 | else if (*ptr == '@') /* Kludge: multiline commands */
|
|---|
| 3047 | {
|
|---|
| 3048 | ptr += 2;
|
|---|
| 3049 | *dptr++ = '\n';
|
|---|
| 3050 | }
|
|---|
| 3051 | else
|
|---|
| 3052 | *dptr++ = *ptr++;
|
|---|
| 3053 | }
|
|---|
| 3054 | *dptr = 0;
|
|---|
| 3055 |
|
|---|
| 3056 | new_argv = (char **) xmalloc (2 * sizeof (char *));
|
|---|
| 3057 | new_argv[0] = buffer;
|
|---|
| 3058 | new_argv[1] = 0;
|
|---|
| 3059 | }
|
|---|
| 3060 | #else /* Not Amiga */
|
|---|
| 3061 | #ifdef WINDOWS32
|
|---|
| 3062 | /*
|
|---|
| 3063 | * Not eating this whitespace caused things like
|
|---|
| 3064 | *
|
|---|
| 3065 | * sh -c "\n"
|
|---|
| 3066 | *
|
|---|
| 3067 | * which gave the shell fits. I think we have to eat
|
|---|
| 3068 | * whitespace here, but this code should be considered
|
|---|
| 3069 | * suspicious if things start failing....
|
|---|
| 3070 | */
|
|---|
| 3071 |
|
|---|
| 3072 | /* Make sure not to bother processing an empty line. */
|
|---|
| 3073 | while (isspace ((unsigned char)*line))
|
|---|
| 3074 | ++line;
|
|---|
| 3075 | if (*line == '\0')
|
|---|
| 3076 | return 0;
|
|---|
| 3077 | #endif /* WINDOWS32 */
|
|---|
| 3078 | {
|
|---|
| 3079 | /* SHELL may be a multi-word command. Construct a command line
|
|---|
| 3080 | "SHELL -c LINE", with all special chars in LINE escaped.
|
|---|
| 3081 | Then recurse, expanding this command line to get the final
|
|---|
| 3082 | argument list. */
|
|---|
| 3083 |
|
|---|
| 3084 | unsigned int shell_len = strlen (shell);
|
|---|
| 3085 | #ifndef VMS
|
|---|
| 3086 | static char minus_c[] = " -c ";
|
|---|
| 3087 | #else
|
|---|
| 3088 | static char minus_c[] = "";
|
|---|
| 3089 | #endif
|
|---|
| 3090 | unsigned int line_len = strlen (line);
|
|---|
| 3091 |
|
|---|
| 3092 | char *new_line = (char *) alloca (shell_len + (sizeof (minus_c) - 1)
|
|---|
| 3093 | + (line_len * 2) + 1);
|
|---|
| 3094 | char *command_ptr = NULL; /* used for batch_mode_shell mode */
|
|---|
| 3095 |
|
|---|
| 3096 | # ifdef __EMX__ /* is this necessary? */
|
|---|
| 3097 | if (!unixy_shell)
|
|---|
| 3098 | minus_c[1] = '/'; /* " /c " */
|
|---|
| 3099 | # endif
|
|---|
| 3100 |
|
|---|
| 3101 | ap = new_line;
|
|---|
| 3102 | bcopy (shell, ap, shell_len);
|
|---|
| 3103 | ap += shell_len;
|
|---|
| 3104 | bcopy (minus_c, ap, sizeof (minus_c) - 1);
|
|---|
| 3105 | ap += sizeof (minus_c) - 1;
|
|---|
| 3106 | command_ptr = ap;
|
|---|
| 3107 | for (p = line; *p != '\0'; ++p)
|
|---|
| 3108 | {
|
|---|
| 3109 | if (restp != NULL && *p == '\n')
|
|---|
| 3110 | {
|
|---|
| 3111 | *restp = p;
|
|---|
| 3112 | break;
|
|---|
| 3113 | }
|
|---|
| 3114 | else if (*p == '\\' && p[1] == '\n')
|
|---|
| 3115 | {
|
|---|
| 3116 | /* Eat the backslash, the newline, and following whitespace,
|
|---|
| 3117 | replacing it all with a single space (which is escaped
|
|---|
| 3118 | from the shell). */
|
|---|
| 3119 | p += 2;
|
|---|
| 3120 |
|
|---|
| 3121 | /* If there is a tab after a backslash-newline,
|
|---|
| 3122 | remove it from the source line which will be echoed,
|
|---|
| 3123 | since it was most likely used to line
|
|---|
| 3124 | up the continued line with the previous one. */
|
|---|
| 3125 | if (*p == '\t')
|
|---|
| 3126 | bcopy (p + 1, p, strlen (p));
|
|---|
| 3127 |
|
|---|
| 3128 | p = next_token (p);
|
|---|
| 3129 | --p;
|
|---|
| 3130 | if (unixy_shell && !batch_mode_shell)
|
|---|
| 3131 | *ap++ = '\\';
|
|---|
| 3132 | *ap++ = ' ';
|
|---|
| 3133 | continue;
|
|---|
| 3134 | }
|
|---|
| 3135 |
|
|---|
| 3136 | /* DOS shells don't know about backslash-escaping. */
|
|---|
| 3137 | if (unixy_shell && !batch_mode_shell &&
|
|---|
| 3138 | (*p == '\\' || *p == '\'' || *p == '"'
|
|---|
| 3139 | || isspace ((unsigned char)*p)
|
|---|
| 3140 | || strchr (sh_chars, *p) != 0))
|
|---|
| 3141 | *ap++ = '\\';
|
|---|
| 3142 | #ifdef __MSDOS__
|
|---|
| 3143 | else if (unixy_shell && strneq (p, "...", 3))
|
|---|
| 3144 | {
|
|---|
| 3145 | /* The case of `...' wildcard again. */
|
|---|
| 3146 | strcpy (ap, "\\.\\.\\");
|
|---|
| 3147 | ap += 5;
|
|---|
| 3148 | p += 2;
|
|---|
| 3149 | }
|
|---|
| 3150 | #endif
|
|---|
| 3151 | *ap++ = *p;
|
|---|
| 3152 | }
|
|---|
| 3153 | if (ap == new_line + shell_len + sizeof (minus_c) - 1)
|
|---|
| 3154 | /* Line was empty. */
|
|---|
| 3155 | return 0;
|
|---|
| 3156 | *ap = '\0';
|
|---|
| 3157 |
|
|---|
| 3158 | #ifdef WINDOWS32
|
|---|
| 3159 | /* Some shells do not work well when invoked as 'sh -c xxx' to run a
|
|---|
| 3160 | command line (e.g. Cygnus GNUWIN32 sh.exe on WIN32 systems). In these
|
|---|
| 3161 | cases, run commands via a script file. */
|
|---|
| 3162 | if ((no_default_sh_exe || batch_mode_shell) && batch_filename_ptr) {
|
|---|
| 3163 | FILE* batch = NULL;
|
|---|
| 3164 | int id = GetCurrentProcessId();
|
|---|
| 3165 | PATH_VAR(fbuf);
|
|---|
| 3166 | char* fname = NULL;
|
|---|
| 3167 |
|
|---|
| 3168 | /* create a file name */
|
|---|
| 3169 | sprintf(fbuf, "make%d", id);
|
|---|
| 3170 | fname = tempnam(".", fbuf);
|
|---|
| 3171 |
|
|---|
| 3172 | /* create batch file name */
|
|---|
| 3173 | *batch_filename_ptr = xmalloc(strlen(fname) + 5);
|
|---|
| 3174 | strcpy(*batch_filename_ptr, fname);
|
|---|
| 3175 |
|
|---|
| 3176 | /* make sure path name is in DOS backslash format */
|
|---|
| 3177 | if (!unixy_shell) {
|
|---|
| 3178 | fname = *batch_filename_ptr;
|
|---|
| 3179 | for (i = 0; fname[i] != '\0'; ++i)
|
|---|
| 3180 | if (fname[i] == '/')
|
|---|
| 3181 | fname[i] = '\\';
|
|---|
| 3182 | strcat(*batch_filename_ptr, ".bat");
|
|---|
| 3183 | } else {
|
|---|
| 3184 | strcat(*batch_filename_ptr, ".sh");
|
|---|
| 3185 | }
|
|---|
| 3186 |
|
|---|
| 3187 | DB (DB_JOBS, (_("Creating temporary batch file %s\n"),
|
|---|
| 3188 | *batch_filename_ptr));
|
|---|
| 3189 |
|
|---|
| 3190 | /* create batch file to execute command */
|
|---|
| 3191 | batch = fopen (*batch_filename_ptr, "w");
|
|---|
| 3192 | if (!unixy_shell)
|
|---|
| 3193 | fputs ("@echo off\n", batch);
|
|---|
| 3194 | fputs (command_ptr, batch);
|
|---|
| 3195 | fputc ('\n', batch);
|
|---|
| 3196 | fclose (batch);
|
|---|
| 3197 |
|
|---|
| 3198 | /* create argv */
|
|---|
| 3199 | new_argv = (char **) xmalloc(3 * sizeof (char *));
|
|---|
| 3200 | if (unixy_shell) {
|
|---|
| 3201 | new_argv[0] = xstrdup (shell);
|
|---|
| 3202 | new_argv[1] = *batch_filename_ptr; /* only argv[0] gets freed later */
|
|---|
| 3203 | } else {
|
|---|
| 3204 | new_argv[0] = xstrdup (*batch_filename_ptr);
|
|---|
| 3205 | new_argv[1] = NULL;
|
|---|
| 3206 | }
|
|---|
| 3207 | new_argv[2] = NULL;
|
|---|
| 3208 | } else
|
|---|
| 3209 | #endif /* WINDOWS32 */
|
|---|
| 3210 | if (unixy_shell)
|
|---|
| 3211 | new_argv = construct_command_argv_internal (new_line, (char **) NULL,
|
|---|
| 3212 | (char *) 0, (char *) 0,
|
|---|
| 3213 | (char **) 0);
|
|---|
| 3214 | # ifdef __EMX__
|
|---|
| 3215 | else if (!unixy_shell)
|
|---|
| 3216 | {
|
|---|
| 3217 | /* new_line is local, must not be freed therefore */
|
|---|
| 3218 | char *p, *q;
|
|---|
| 3219 | int quote;
|
|---|
| 3220 | size_t index;
|
|---|
| 3221 | size_t len;
|
|---|
| 3222 |
|
|---|
| 3223 | /* handle quotes
|
|---|
| 3224 | We have to remove all double quotes and to split the line
|
|---|
| 3225 | into distinct arguments because of the strange handling
|
|---|
| 3226 | of builtin commands by cmd: 'echo "bla"' prints "bla"
|
|---|
| 3227 | (with quotes) while 'c:\bin\echo.exe "bla"' prints bla
|
|---|
| 3228 | (without quotes). Some programs like autoconf rely
|
|---|
| 3229 | on the second behaviour. */
|
|---|
| 3230 |
|
|---|
| 3231 | len = strlen (new_line) + 1;
|
|---|
| 3232 |
|
|---|
| 3233 | /* More than 1 arg per character is impossible. */
|
|---|
| 3234 | new_argv = (char **) xmalloc (len * sizeof (char *));
|
|---|
| 3235 |
|
|---|
| 3236 | /* All the args can fit in a buffer as big as new_line is. */
|
|---|
| 3237 | new_argv[0] = (char *) xmalloc (len);
|
|---|
| 3238 |
|
|---|
| 3239 | index = 0;
|
|---|
| 3240 | quote = 0;
|
|---|
| 3241 | q = new_line;
|
|---|
| 3242 | p = new_argv[index];
|
|---|
| 3243 | while(*q != '\0')
|
|---|
| 3244 | {
|
|---|
| 3245 | /* searching for closing quote */
|
|---|
| 3246 | if (quote)
|
|---|
| 3247 | {
|
|---|
| 3248 | if (*q == quote)
|
|---|
| 3249 | {
|
|---|
| 3250 | /* remove the quote */
|
|---|
| 3251 | q++;
|
|---|
| 3252 | quote = 0;
|
|---|
| 3253 | }
|
|---|
| 3254 | else /* normal character: copy it */
|
|---|
| 3255 | *p++ = *q++;
|
|---|
| 3256 | }
|
|---|
| 3257 |
|
|---|
| 3258 | /* searching for opening quote */
|
|---|
| 3259 | else if (*q == '\"'
|
|---|
| 3260 | # ifndef NO_CMD_DEFAULT
|
|---|
| 3261 | || *q == '\''
|
|---|
| 3262 | # endif
|
|---|
| 3263 | )
|
|---|
| 3264 | {
|
|---|
| 3265 | /* remove opening quote */
|
|---|
| 3266 | quote = *q;
|
|---|
| 3267 | q++;
|
|---|
| 3268 | }
|
|---|
| 3269 |
|
|---|
| 3270 | /* spaces outside of a quoted string: remove them
|
|---|
| 3271 | and start a new argument */
|
|---|
| 3272 | else if (*q == ' ' || *q == '\t')
|
|---|
| 3273 | {
|
|---|
| 3274 | *p++ = '\0'; /* trailing '\0' for last argument */
|
|---|
| 3275 |
|
|---|
| 3276 | /* remove all successive spaces */
|
|---|
| 3277 | do
|
|---|
| 3278 | {
|
|---|
| 3279 | q++;
|
|---|
| 3280 | }
|
|---|
| 3281 | while(*q == ' ' || *q == '\t');
|
|---|
| 3282 |
|
|---|
| 3283 | /* start new argument */
|
|---|
| 3284 | index++;
|
|---|
| 3285 | new_argv[index] = p;
|
|---|
| 3286 | }
|
|---|
| 3287 |
|
|---|
| 3288 | /* normal character (no space) outside a quoted string*/
|
|---|
| 3289 | else
|
|---|
| 3290 | *p++ = *q++;
|
|---|
| 3291 | } /* end while() */
|
|---|
| 3292 |
|
|---|
| 3293 | *p = '\0'; /* trailing '\0' for the last argument */
|
|---|
| 3294 | new_argv[index + 1] = NULL;
|
|---|
| 3295 |
|
|---|
| 3296 | # ifndef NO_CMD_DEFAULT
|
|---|
| 3297 | /* special case: echo x="y"
|
|---|
| 3298 | (e.g. autoconf uses this to determine whether make works)
|
|---|
| 3299 | this is pure idioty but cmd works this way:
|
|---|
| 3300 | if 'echo' and 'x="y"' are two different arguments cmd
|
|---|
| 3301 | will print '"x="y""' but if they are only one argument
|
|---|
| 3302 | cmd will print 'bla="blurb"' as it should be
|
|---|
| 3303 | note: if we do not allow cmd to be the default shell
|
|---|
| 3304 | we do not need this kind of voodoo */
|
|---|
| 3305 | if (index == 3 && strcasecmp(new_argv[2], "echo") == 0)
|
|---|
| 3306 | {
|
|---|
| 3307 | new_argv[2][4] = ' ';
|
|---|
| 3308 | new_argv[3] = NULL;
|
|---|
| 3309 | }
|
|---|
| 3310 | # endif
|
|---|
| 3311 | }
|
|---|
| 3312 | #elif defined(__MSDOS__)
|
|---|
| 3313 | else
|
|---|
| 3314 | {
|
|---|
| 3315 | /* With MSDOS shells, we must construct the command line here
|
|---|
| 3316 | instead of recursively calling ourselves, because we
|
|---|
| 3317 | cannot backslash-escape the special characters (see above). */
|
|---|
| 3318 | new_argv = (char **) xmalloc (sizeof (char *));
|
|---|
| 3319 | line_len = strlen (new_line) - shell_len - sizeof (minus_c) + 1;
|
|---|
| 3320 | new_argv[0] = xmalloc (line_len + 1);
|
|---|
| 3321 | strncpy (new_argv[0],
|
|---|
| 3322 | new_line + shell_len + sizeof (minus_c) - 1, line_len);
|
|---|
| 3323 | new_argv[0][line_len] = '\0';
|
|---|
| 3324 | }
|
|---|
| 3325 | #else
|
|---|
| 3326 | else
|
|---|
| 3327 | fatal (NILF, _("%s (line %d) Bad shell context (!unixy && !batch_mode_shell)\n"),
|
|---|
| 3328 | __FILE__, __LINE__);
|
|---|
| 3329 | #endif
|
|---|
| 3330 | }
|
|---|
| 3331 | #endif /* ! AMIGA */
|
|---|
| 3332 |
|
|---|
| 3333 | return new_argv;
|
|---|
| 3334 | }
|
|---|
| 3335 | #endif /* !VMS */
|
|---|
| 3336 |
|
|---|
| 3337 | /* Figure out the argument list necessary to run LINE as a command. Try to
|
|---|
| 3338 | avoid using a shell. This routine handles only ' quoting, and " quoting
|
|---|
| 3339 | when no backslash, $ or ` characters are seen in the quotes. Starting
|
|---|
| 3340 | quotes may be escaped with a backslash. If any of the characters in
|
|---|
| 3341 | sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
|
|---|
| 3342 | is the first word of a line, the shell is used.
|
|---|
| 3343 |
|
|---|
| 3344 | If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
|
|---|
| 3345 | If *RESTP is NULL, newlines will be ignored.
|
|---|
| 3346 |
|
|---|
| 3347 | FILE is the target whose commands these are. It is used for
|
|---|
| 3348 | variable expansion for $(SHELL) and $(IFS). */
|
|---|
| 3349 |
|
|---|
| 3350 | char **
|
|---|
| 3351 | construct_command_argv (char *line, char **restp, struct file *file,
|
|---|
| 3352 | char **batch_filename_ptr)
|
|---|
| 3353 | {
|
|---|
| 3354 | char *shell, *ifs;
|
|---|
| 3355 | char **argv;
|
|---|
| 3356 |
|
|---|
| 3357 | #ifdef VMS
|
|---|
| 3358 | char *cptr;
|
|---|
| 3359 | int argc;
|
|---|
| 3360 |
|
|---|
| 3361 | argc = 0;
|
|---|
| 3362 | cptr = line;
|
|---|
| 3363 | for (;;)
|
|---|
| 3364 | {
|
|---|
| 3365 | while ((*cptr != 0)
|
|---|
| 3366 | && (isspace ((unsigned char)*cptr)))
|
|---|
| 3367 | cptr++;
|
|---|
| 3368 | if (*cptr == 0)
|
|---|
| 3369 | break;
|
|---|
| 3370 | while ((*cptr != 0)
|
|---|
| 3371 | && (!isspace((unsigned char)*cptr)))
|
|---|
| 3372 | cptr++;
|
|---|
| 3373 | argc++;
|
|---|
| 3374 | }
|
|---|
| 3375 |
|
|---|
| 3376 | argv = (char **)malloc (argc * sizeof (char *));
|
|---|
| 3377 | if (argv == 0)
|
|---|
| 3378 | abort ();
|
|---|
| 3379 |
|
|---|
| 3380 | cptr = line;
|
|---|
| 3381 | argc = 0;
|
|---|
| 3382 | for (;;)
|
|---|
| 3383 | {
|
|---|
| 3384 | while ((*cptr != 0)
|
|---|
| 3385 | && (isspace ((unsigned char)*cptr)))
|
|---|
| 3386 | cptr++;
|
|---|
| 3387 | if (*cptr == 0)
|
|---|
| 3388 | break;
|
|---|
| 3389 | DB (DB_JOBS, ("argv[%d] = [%s]\n", argc, cptr));
|
|---|
| 3390 | argv[argc++] = cptr;
|
|---|
| 3391 | while ((*cptr != 0)
|
|---|
| 3392 | && (!isspace((unsigned char)*cptr)))
|
|---|
| 3393 | cptr++;
|
|---|
| 3394 | if (*cptr != 0)
|
|---|
| 3395 | *cptr++ = 0;
|
|---|
| 3396 | }
|
|---|
| 3397 | #else
|
|---|
| 3398 | {
|
|---|
| 3399 | /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
|
|---|
| 3400 | int save = warn_undefined_variables_flag;
|
|---|
| 3401 | warn_undefined_variables_flag = 0;
|
|---|
| 3402 |
|
|---|
| 3403 | shell = allocated_variable_expand_for_file ("$(SHELL)", file);
|
|---|
| 3404 | #ifdef WINDOWS32
|
|---|
| 3405 | /*
|
|---|
| 3406 | * Convert to forward slashes so that construct_command_argv_internal()
|
|---|
| 3407 | * is not confused.
|
|---|
| 3408 | */
|
|---|
| 3409 | if (shell) {
|
|---|
| 3410 | char *p = w32ify (shell, 0);
|
|---|
| 3411 | strcpy (shell, p);
|
|---|
| 3412 | }
|
|---|
| 3413 | #endif
|
|---|
| 3414 | #ifdef __EMX__
|
|---|
| 3415 | {
|
|---|
| 3416 | static const char *unixroot = NULL;
|
|---|
| 3417 | static const char *last_shell = "";
|
|---|
| 3418 | static int init = 0;
|
|---|
| 3419 | if (init == 0)
|
|---|
| 3420 | {
|
|---|
| 3421 | unixroot = getenv ("UNIXROOT");
|
|---|
| 3422 | /* unixroot must be NULL or not empty */
|
|---|
| 3423 | if (unixroot && unixroot[0] == '\0') unixroot = NULL;
|
|---|
| 3424 | init = 1;
|
|---|
| 3425 | }
|
|---|
| 3426 |
|
|---|
| 3427 | /* if we have an unixroot drive and if shell is not default_shell
|
|---|
| 3428 | (which means it's either cmd.exe or the test has already been
|
|---|
| 3429 | performed) and if shell is an absolute path without drive letter,
|
|---|
| 3430 | try whether it exists e.g.: if "/bin/sh" does not exist use
|
|---|
| 3431 | "$UNIXROOT/bin/sh" instead. */
|
|---|
| 3432 | if (unixroot && shell && strcmp (shell, last_shell) != 0
|
|---|
| 3433 | && (shell[0] == '/' || shell[0] == '\\'))
|
|---|
| 3434 | {
|
|---|
| 3435 | /* trying a new shell, check whether it exists */
|
|---|
| 3436 | size_t size = strlen (shell);
|
|---|
| 3437 | char *buf = xmalloc (size + 7);
|
|---|
| 3438 | memcpy (buf, shell, size);
|
|---|
| 3439 | memcpy (buf + size, ".exe", 5); /* including the trailing '\0' */
|
|---|
| 3440 | if (access (shell, F_OK) != 0 && access (buf, F_OK) != 0)
|
|---|
| 3441 | {
|
|---|
| 3442 | /* try the same for the unixroot drive */
|
|---|
| 3443 | memmove (buf + 2, buf, size + 5);
|
|---|
| 3444 | buf[0] = unixroot[0];
|
|---|
| 3445 | buf[1] = unixroot[1];
|
|---|
| 3446 | if (access (buf, F_OK) == 0)
|
|---|
| 3447 | /* we have found a shell! */
|
|---|
| 3448 | /* free(shell); */
|
|---|
| 3449 | shell = buf;
|
|---|
| 3450 | else
|
|---|
| 3451 | free (buf);
|
|---|
| 3452 | }
|
|---|
| 3453 | else
|
|---|
| 3454 | free (buf);
|
|---|
| 3455 | }
|
|---|
| 3456 | }
|
|---|
| 3457 | #endif /* __EMX__ */
|
|---|
| 3458 |
|
|---|
| 3459 | ifs = allocated_variable_expand_for_file ("$(IFS)", file);
|
|---|
| 3460 |
|
|---|
| 3461 | warn_undefined_variables_flag = save;
|
|---|
| 3462 | }
|
|---|
| 3463 |
|
|---|
| 3464 | argv = construct_command_argv_internal (line, restp, shell, ifs, batch_filename_ptr);
|
|---|
| 3465 |
|
|---|
| 3466 | free (shell);
|
|---|
| 3467 | free (ifs);
|
|---|
| 3468 | #endif /* !VMS */
|
|---|
| 3469 | return argv;
|
|---|
| 3470 | }
|
|---|
| 3471 | |
|---|
| 3472 |
|
|---|
| 3473 | #if !defined(HAVE_DUP2) && !defined(_AMIGA)
|
|---|
| 3474 | int
|
|---|
| 3475 | dup2 (int old, int new)
|
|---|
| 3476 | {
|
|---|
| 3477 | int fd;
|
|---|
| 3478 |
|
|---|
| 3479 | (void) close (new);
|
|---|
| 3480 | fd = dup (old);
|
|---|
| 3481 | if (fd != new)
|
|---|
| 3482 | {
|
|---|
| 3483 | (void) close (fd);
|
|---|
| 3484 | errno = EMFILE;
|
|---|
| 3485 | return -1;
|
|---|
| 3486 | }
|
|---|
| 3487 |
|
|---|
| 3488 | return fd;
|
|---|
| 3489 | }
|
|---|
| 3490 | #endif /* !HAPE_DUP2 && !_AMIGA */
|
|---|