callproc.c 48.5 KB
Newer Older
Jim Blandy's avatar
Jim Blandy committed
1
/* Synchronous subprocess invocation for GNU Emacs.
2
   Copyright (C) 1985-1988, 1993-1995, 1999-2011
3
		 Free Software Foundation, Inc.
Jim Blandy's avatar
Jim Blandy committed
4 5 6

This file is part of GNU Emacs.

7
GNU Emacs is free software: you can redistribute it and/or modify
Jim Blandy's avatar
Jim Blandy committed
8
it under the terms of the GNU General Public License as published by
9 10
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Jim Blandy's avatar
Jim Blandy committed
11 12 13 14 15 16 17

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
18
along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
Jim Blandy's avatar
Jim Blandy committed
19 20


21
#include <config.h>
Jim Blandy's avatar
Jim Blandy committed
22
#include <signal.h>
23
#include <errno.h>
24
#include <stdio.h>
25
#include <setjmp.h>
Jim Blandy's avatar
Jim Blandy committed
26
#include <sys/types.h>
27 28
#include <unistd.h>

Jim Blandy's avatar
Jim Blandy committed
29 30 31
#include <sys/file.h>
#include <fcntl.h>

32 33 34
#ifdef WINDOWSNT
#define NOMINMAX
#include <windows.h>
Geoff Voelker's avatar
Geoff Voelker committed
35
#include "w32.h"
36 37 38
#define _P_NOWAIT 1	/* from process.h */
#endif

39 40 41 42 43
#ifdef MSDOS	/* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
#include <sys/stat.h>
#include <sys/param.h>
#endif /* MSDOS */

Jim Blandy's avatar
Jim Blandy committed
44 45 46
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
47
#include "character.h"
Kenichi Handa's avatar
Kenichi Handa committed
48
#include "ccl.h"
Karl Heuer's avatar
Karl Heuer committed
49
#include "coding.h"
Kenichi Handa's avatar
Kenichi Handa committed
50
#include "composite.h"
51
#include <epaths.h>
Jim Blandy's avatar
Jim Blandy committed
52
#include "process.h"
53
#include "syssignal.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
54
#include "systty.h"
Kim F. Storm's avatar
Kim F. Storm committed
55
#include "blockinput.h"
56 57
#include "frame.h"
#include "termhooks.h"
Jim Blandy's avatar
Jim Blandy committed
58

Eli Zaretskii's avatar
Eli Zaretskii committed
59 60 61 62
#ifdef MSDOS
#include "msdos.h"
#endif

63
#ifndef USE_CRT_DLL
Jim Blandy's avatar
Jim Blandy committed
64 65 66
extern char **environ;
#endif

67
#ifdef HAVE_SETPGID
Dan Nicolaescu's avatar
Dan Nicolaescu committed
68
#if !defined (USG)
69
#undef setpgrp
70 71
#define setpgrp setpgid
#endif
72
#endif
73

74 75 76
/* Pattern used by call-process-region to make temp files.  */
static Lisp_Object Vtemp_file_name_pattern;

Glenn Morris's avatar
Glenn Morris committed
77
/* True if we are about to fork off a synchronous process or if we
Jim Blandy's avatar
Jim Blandy committed
78 79 80 81
   are waiting for it.  */
int synch_process_alive;

/* Nonzero => this is a string explaining death of synchronous subprocess.  */
82
const char *synch_process_death;
Jim Blandy's avatar
Jim Blandy committed
83

Kenichi Handa's avatar
Kenichi Handa committed
84 85 86
/* Nonzero => this is the signal number that terminated the subprocess.  */
int synch_process_termsig;

Jim Blandy's avatar
Jim Blandy committed
87 88 89
/* If synch_process_death is zero,
   this is exit code of synchronous subprocess.  */
int synch_process_retcode;
90

Jim Blandy's avatar
Jim Blandy committed
91

92 93 94 95 96 97 98
/* Clean up when exiting Fcall_process.
   On MSDOS, delete the temporary file on any kind of termination.
   On Unix, kill the process and any children on termination by signal.  */

/* Nonzero if this is termination due to exit.  */
static int call_process_exited;

99
static Lisp_Object Fgetenv_internal (Lisp_Object, Lisp_Object);
100

101
static Lisp_Object
102
call_process_kill (Lisp_Object fdpid)
103
{
104
  emacs_close (XFASTINT (Fcar (fdpid)));
105 106 107 108 109
  EMACS_KILLPG (XFASTINT (Fcdr (fdpid)), SIGKILL);
  synch_process_alive = 0;
  return Qnil;
}

110
static Lisp_Object
111
call_process_cleanup (Lisp_Object arg)
Jim Blandy's avatar
Jim Blandy committed
112
{
113 114 115 116 117 118 119 120 121
  Lisp_Object fdpid = Fcdr (arg);
#if defined (MSDOS)
  Lisp_Object file;
#else
  int pid;
#endif

  Fset_buffer (Fcar (arg));

Dan Nicolaescu's avatar
Dan Nicolaescu committed
122
#if defined (MSDOS)
123
  /* for MSDOS fdpid is really (fd . tempfile)  */
124
  file = Fcdr (fdpid);
125
  emacs_close (XFASTINT (Fcar (fdpid)));
126 127
  if (strcmp (SDATA (file), NULL_DEVICE) != 0)
    unlink (SDATA (file));
Dan Nicolaescu's avatar
Dan Nicolaescu committed
128
#else /* not MSDOS */
129
  pid = XFASTINT (Fcdr (fdpid));
130

131
  if (call_process_exited)
132
    {
133
      emacs_close (XFASTINT (Fcar (fdpid)));
134 135
      return Qnil;
    }
136

137 138
  if (EMACS_KILLPG (pid, SIGINT) == 0)
    {
Juanma Barranquero's avatar
Juanma Barranquero committed
139
      int count = SPECPDL_INDEX ();
140 141 142 143 144 145 146 147 148
      record_unwind_protect (call_process_kill, fdpid);
      message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
      immediate_quit = 1;
      QUIT;
      wait_for_termination (pid);
      immediate_quit = 0;
      specpdl_ptr = specpdl + count; /* Discard the unwind protect.  */
      message1 ("Waiting for process to die...done");
    }
Jim Blandy's avatar
Jim Blandy committed
149
  synch_process_alive = 0;
150
  emacs_close (XFASTINT (Fcar (fdpid)));
151
#endif /* not MSDOS */
Jim Blandy's avatar
Jim Blandy committed
152 153 154
  return Qnil;
}

Paul Eggert's avatar
Paul Eggert committed
155
DEFUN ("call-process", Fcall_process, Scall_process, 1, MANY, 0,
156 157 158
       doc: /* Call PROGRAM synchronously in separate process.
The remaining arguments are optional.
The program's input comes from file INFILE (nil means `/dev/null').
159 160 161
Insert output in BUFFER before point; t means current buffer; nil for BUFFER
 means discard it; 0 means discard and don't wait; and `(:file FILE)', where
 FILE is a file name string, means that it should be written to that file.
162 163 164 165 166 167 168 169 170
BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
REAL-BUFFER says what to do with standard output, as above,
while STDERR-FILE says what to do with standard error in the child.
STDERR-FILE may be nil (discard standard error output),
t (mix it with ordinary output), or a file name string.

Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Remaining arguments are strings passed as command arguments to PROGRAM.

171 172 173 174
If executable PROGRAM can't be found as an executable, `call-process'
signals a Lisp error.  `call-process' reports errors in execution of
the program only through its return and output.

175 176 177
If BUFFER is 0, `call-process' returns immediately with value nil.
Otherwise it waits for PROGRAM to terminate
and returns a numeric exit status or a signal description string.
178 179 180
If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.

usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
181
  (size_t nargs, register Lisp_Object *args)
Jim Blandy's avatar
Jim Blandy committed
182
{
183
  Lisp_Object infile, buffer, current_dir, path;
184
  volatile int display_p_volatile;
Jim Blandy's avatar
Jim Blandy committed
185 186 187
  int fd[2];
  int filefd;
  register int pid;
188 189 190 191
#define CALLPROC_BUFFER_SIZE_MIN (16 * 1024)
#define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN)
  char buf[CALLPROC_BUFFER_SIZE_MAX];
  int bufsize = CALLPROC_BUFFER_SIZE_MIN;
Juanma Barranquero's avatar
Juanma Barranquero committed
192
  int count = SPECPDL_INDEX ();
193
  volatile USE_SAFE_ALLOCA;
194

195
  const unsigned char **volatile new_argv_volatile;
196
  register const unsigned char **new_argv;
197 198 199
  /* File to use for stderr in the child.
     t means use same as standard output.  */
  Lisp_Object error_file;
200
  Lisp_Object output_file = Qnil;
201 202 203
#ifdef MSDOS	/* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
  char *outf, *tempfile;
  int outfilefd;
Jim Blandy's avatar
Jim Blandy committed
204
#endif
205
  int fd_output = -1;
Karl Heuer's avatar
Karl Heuer committed
206 207
  struct coding_system process_coding; /* coding-system of process output */
  struct coding_system argument_coding;	/* coding-system of arguments */
208 209
  /* Set to the return value of Ffind_operation_coding_system.  */
  Lisp_Object coding_systems;
210
  int output_to_buffer = 1;
211 212 213

  /* Qt denotes that Ffind_operation_coding_system is not yet called.  */
  coding_systems = Qt;
Karl Heuer's avatar
Karl Heuer committed
214

215
  CHECK_STRING (args[0]);
Jim Blandy's avatar
Jim Blandy committed
216

217 218
  error_file = Qt;

219 220
#ifndef subprocesses
  /* Without asynchronous processes we cannot have BUFFER == 0.  */
221
  if (nargs >= 3
222
      && (INTEGERP (CONSP (args[2]) ? XCAR (args[2]) : args[2])))
223 224 225
    error ("Operating system cannot handle asynchronous subprocesses");
#endif /* subprocesses */

226
  /* Decide the coding-system for giving arguments.  */
Karl Heuer's avatar
Karl Heuer committed
227 228
  {
    Lisp_Object val, *args2;
229
    size_t i;
Karl Heuer's avatar
Karl Heuer committed
230 231 232 233

    /* If arguments are supplied, we may have to encode them.  */
    if (nargs >= 5)
      {
234
	int must_encode = 0;
235
	Lisp_Object coding_attrs;
236

237
	for (i = 4; i < nargs; i++)
238
	  CHECK_STRING (args[i]);
239

240
	for (i = 4; i < nargs; i++)
241 242 243
	  if (STRING_MULTIBYTE (args[i]))
	    must_encode = 1;

244 245
	if (!NILP (Vcoding_system_for_write))
	  val = Vcoding_system_for_write;
246
	else if (! must_encode)
247
	  val = Qraw_text;
248
	else
Karl Heuer's avatar
Karl Heuer committed
249
	  {
250
	    SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
Karl Heuer's avatar
Karl Heuer committed
251 252
	    args2[0] = Qcall_process;
	    for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
253
	    coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
254
	    val = CONSP (coding_systems) ? XCDR (coding_systems) : Qnil;
Karl Heuer's avatar
Karl Heuer committed
255
	  }
256
	val = complement_process_encoding_system (val);
Karl Heuer's avatar
Karl Heuer committed
257
	setup_coding_system (Fcheck_coding_system (val), &argument_coding);
258 259 260 261 262 263 264
	coding_attrs = CODING_ID_ATTRS (argument_coding.id);
	if (NILP (CODING_ATTR_ASCII_COMPAT (coding_attrs)))
	  {
	    /* We should not use an ASCII incompatible coding system.  */
	    val = raw_text_coding_system (val);
	    setup_coding_system (val, &argument_coding);
	  }
Karl Heuer's avatar
Karl Heuer committed
265 266 267
      }
  }

268 269
  if (nargs >= 2 && ! NILP (args[1]))
    {
Tom Tromey's avatar
Tom Tromey committed
270
      infile = Fexpand_file_name (args[1], BVAR (current_buffer, directory));
271
      CHECK_STRING (infile);
272
    }
Jim Blandy's avatar
Jim Blandy committed
273
  else
274
    infile = build_string (NULL_DEVICE);
Jim Blandy's avatar
Jim Blandy committed
275

276 277
  if (nargs >= 3)
    {
278 279
      buffer = args[2];

280 281 282
      /* If BUFFER is a list, its meaning is (BUFFER-FOR-STDOUT
	 FILE-FOR-STDERR), unless the first element is :file, in which case see
	 the next paragraph. */
283 284 285
      if (CONSP (buffer)
	  && (! SYMBOLP (XCAR (buffer))
	      || strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer))), ":file")))
286
	{
287
	  if (CONSP (XCDR (buffer)))
288
	    {
289
	      Lisp_Object stderr_file;
290
	      stderr_file = XCAR (XCDR (buffer));
291 292 293 294 295 296 297

	      if (NILP (stderr_file) || EQ (Qt, stderr_file))
		error_file = stderr_file;
	      else
		error_file = Fexpand_file_name (stderr_file, Qnil);
	    }

298
	  buffer = XCAR (buffer);
299
	}
Richard M. Stallman's avatar
Richard M. Stallman committed
300

301
      /* If the buffer is (still) a list, it might be a (:file "file") spec. */
302 303 304
      if (CONSP (buffer)
	  && SYMBOLP (XCAR (buffer))
	  && ! strcmp (SSDATA (SYMBOL_NAME (XCAR (buffer))), ":file"))
305 306 307 308 309 310 311
	{
	  output_file = Fexpand_file_name (XCAR (XCDR (buffer)),
					   BVAR (current_buffer, directory));
	  CHECK_STRING (output_file);
	  buffer = Qnil;
	}

312 313
      if (!(EQ (buffer, Qnil)
	    || EQ (buffer, Qt)
314
	    || INTEGERP (buffer)))
315
	{
316 317
	  Lisp_Object spec_buffer;
	  spec_buffer = buffer;
318
	  buffer = Fget_buffer_create (buffer);
319 320
	  /* Mention the buffer name for a better error message.  */
	  if (NILP (buffer))
321 322
	    CHECK_BUFFER (spec_buffer);
	  CHECK_BUFFER (buffer);
323 324
	}
    }
325
  else
326
    buffer = Qnil;
Jim Blandy's avatar
Jim Blandy committed
327

328 329 330 331 332 333 334 335 336 337 338
  /* Make sure that the child will be able to chdir to the current
     buffer's current directory, or its unhandled equivalent.  We
     can't just have the child check for an error when it does the
     chdir, since it's in a vfork.

     We have to GCPRO around this because Fexpand_file_name,
     Funhandled_file_name_directory, and Ffile_accessible_directory_p
     might call a file name handling function.  The argument list is
     protected by the caller, so all we really have to worry about is
     buffer.  */
  {
339
    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
340

Tom Tromey's avatar
Tom Tromey committed
341
    current_dir = BVAR (current_buffer, directory);
342

343
    GCPRO5 (infile, buffer, current_dir, error_file, output_file);
344

Stefan Monnier's avatar
Stefan Monnier committed
345 346 347 348 349 350
    current_dir = Funhandled_file_name_directory (current_dir);
    if (NILP (current_dir))
      /* If the file name handler says that current_dir is unreachable, use
	 a sensible default. */
      current_dir = build_string ("~/");
    current_dir = expand_and_dir_to_file (current_dir, Qnil);
351 352
    current_dir = Ffile_name_as_directory (current_dir);

353 354
    if (NILP (Ffile_accessible_directory_p (current_dir)))
      report_file_error ("Setting current directory",
Tom Tromey's avatar
Tom Tromey committed
355
			 Fcons (BVAR (current_buffer, directory), Qnil));
356

357 358 359 360 361 362
    if (STRING_MULTIBYTE (infile))
      infile = ENCODE_FILE (infile);
    if (STRING_MULTIBYTE (current_dir))
      current_dir = ENCODE_FILE (current_dir);
    if (STRINGP (error_file) && STRING_MULTIBYTE (error_file))
      error_file = ENCODE_FILE (error_file);
363 364
    if (STRINGP (output_file) && STRING_MULTIBYTE (output_file))
      output_file = ENCODE_FILE (output_file);
365 366 367
    UNGCPRO;
  }

368
  display_p_volatile = INTERACTIVE && nargs >= 4 && !NILP (args[3]);
Jim Blandy's avatar
Jim Blandy committed
369

370
  filefd = emacs_open (SSDATA (infile), O_RDONLY, 0);
Jim Blandy's avatar
Jim Blandy committed
371 372
  if (filefd < 0)
    {
373
      infile = DECODE_FILE (infile);
374
      report_file_error ("Opening process input file", Fcons (infile, Qnil));
Jim Blandy's avatar
Jim Blandy committed
375
    }
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390

  if (STRINGP (output_file))
    {
#ifdef DOS_NT
      fd_output = emacs_open (SSDATA (output_file),
			      O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
			      S_IREAD | S_IWRITE);
#else  /* not DOS_NT */
      fd_output = creat (SSDATA (output_file), 0666);
#endif /* not DOS_NT */
      if (fd_output < 0)
	{
	  output_file = DECODE_FILE (output_file);
	  report_file_error ("Opening process output file",
			     Fcons (output_file, Qnil));
391
	}
392
      if (STRINGP (error_file) || NILP (error_file))
393
	output_to_buffer = 0;
394 395
    }

Jim Blandy's avatar
Jim Blandy committed
396
  /* Search for program; barf if not found.  */
397
  {
398
    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
399

400
    GCPRO4 (infile, buffer, current_dir, error_file);
401
    openp (Vexec_path, args[0], Vexec_suffixes, &path, make_number (X_OK));
402 403
    UNGCPRO;
  }
404
  if (NILP (path))
Jim Blandy's avatar
Jim Blandy committed
405
    {
406
      emacs_close (filefd);
Jim Blandy's avatar
Jim Blandy committed
407 408
      report_file_error ("Searching for program", Fcons (args[0], Qnil));
    }
409 410 411 412 413 414 415

  /* If program file name starts with /: for quoting a magic name,
     discard that.  */
  if (SBYTES (path) > 2 && SREF (path, 0) == '/'
      && SREF (path, 1) == ':')
    path = Fsubstring (path, make_number (2), Qnil);

416 417 418
  SAFE_ALLOCA (new_argv, const unsigned char **,
	       (nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
  new_argv_volatile = new_argv;
419 420
  if (nargs > 4)
    {
421
      register size_t i;
422
      struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
423

424
      GCPRO5 (infile, buffer, current_dir, path, error_file);
425 426
      argument_coding.dst_multibyte = 0;
      for (i = 4; i < nargs; i++)
427
	{
428 429
	  argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
	  if (CODING_REQUIRE_ENCODING (&argument_coding))
430 431
	    /* We must encode this argument.  */
	    args[i] = encode_coding_string (&argument_coding, args[i], 1);
432
	}
433
      UNGCPRO;
434 435 436
      for (i = 4; i < nargs; i++)
	new_argv[i - 3] = SDATA (args[i]);
      new_argv[i - 3] = 0;
437
    }
438 439
  else
    new_argv[1] = 0;
440
  new_argv[0] = SDATA (path);
Jim Blandy's avatar
Jim Blandy committed
441

442
#ifdef MSDOS /* MW, July 1993 */
443
  if ((outf = egetenv ("TMPDIR")))
444 445 446 447 448 449 450
    strcpy (tempfile = alloca (strlen (outf) + 20), outf);
  else
    {
      tempfile = alloca (20);
      *tempfile = '\0';
    }
  dostounix_filename (tempfile);
451
  if (*tempfile == '\0' || tempfile[strlen (tempfile) - 1] != '/')
452 453 454 455
    strcat (tempfile, "/");
  strcat (tempfile, "detmp.XXX");
  mktemp (tempfile);

456 457
  /* If we're redirecting STDOUT to a file, this is already opened. */
  if (fd_output < 0)
458
    {
459 460 461 462 463 464
      outfilefd = creat (tempfile, S_IREAD | S_IWRITE);
      if (outfilefd < 0) {
	emacs_close (filefd);
	report_file_error ("Opening process output file",
			   Fcons (build_string (tempfile), Qnil));
      }
465
    }
466 467
  else
    outfilefd = fd_output;
Miles Bader's avatar
Miles Bader committed
468
  fd[0] = filefd;
469
  fd[1] = outfilefd;
Miles Bader's avatar
Miles Bader committed
470
#endif /* MSDOS */
471

472
  if (INTEGERP (buffer))
473
    fd[1] = emacs_open (NULL_DEVICE, O_WRONLY, 0), fd[0] = -1;
Jim Blandy's avatar
Jim Blandy committed
474 475
  else
    {
476
#ifndef MSDOS
477 478 479 480 481 482
      errno = 0;
      if (pipe (fd) == -1)
	{
	  emacs_close (filefd);
	  report_file_error ("Creating process pipe", Qnil);
	}
Jim Blandy's avatar
Jim Blandy committed
483 484 485 486 487 488 489 490
#endif
    }

  {
    /* child_setup must clobber environ in systems with true vfork.
       Protect it from permanent change.  */
    register char **save_environ = environ;
    register int fd1 = fd[1];
491
    int fd_error = fd1;
492 493 494 495 496
#ifdef HAVE_WORKING_VFORK
    sigset_t procmask;
    sigset_t blocked;
    struct sigaction sigpipe_action;
#endif
Jim Blandy's avatar
Jim Blandy committed
497

498 499
    if (fd_output >= 0)
      fd1 = fd_output;
Jim Blandy's avatar
Jim Blandy committed
500
#if 0  /* Some systems don't have sigblock.  */
Jim Blandy's avatar
Jim Blandy committed
501
    mask = sigblock (sigmask (SIGCHLD));
Jim Blandy's avatar
Jim Blandy committed
502 503 504 505 506
#endif

    /* Record that we're about to create a synchronous process.  */
    synch_process_alive = 1;

507 508 509 510 511
    /* These vars record information from process termination.
       Clear them now before process can possibly terminate,
       to avoid timing error if process terminates soon.  */
    synch_process_death = 0;
    synch_process_retcode = 0;
Kenichi Handa's avatar
Kenichi Handa committed
512
    synch_process_termsig = 0;
513

514
    if (NILP (error_file))
515
      fd_error = emacs_open (NULL_DEVICE, O_WRONLY, 0);
516 517 518
    else if (STRINGP (error_file))
      {
#ifdef DOS_NT
519
	fd_error = emacs_open (SSDATA (error_file),
520 521
			       O_WRONLY | O_TRUNC | O_CREAT | O_TEXT,
			       S_IREAD | S_IWRITE);
522
#else  /* not DOS_NT */
523
	fd_error = creat (SSDATA (error_file), 0666);
524 525 526 527 528
#endif /* not DOS_NT */
      }

    if (fd_error < 0)
      {
529
	emacs_close (filefd);
Miles Bader's avatar
Miles Bader committed
530
	if (fd[0] != filefd)
531
	  emacs_close (fd[0]);
532
	if (fd1 >= 0)
533
	  emacs_close (fd1);
Miles Bader's avatar
Miles Bader committed
534 535 536
#ifdef MSDOS
	unlink (tempfile);
#endif
537 538 539 540 541
	if (NILP (error_file))
	  error_file = build_string (NULL_DEVICE);
	else if (STRINGP (error_file))
	  error_file = DECODE_FILE (error_file);
	report_file_error ("Cannot redirect stderr", Fcons (error_file, Qnil));
542
      }
543

544
#ifdef MSDOS /* MW, July 1993 */
545
    /* Note that on MSDOS `child_setup' actually returns the child process
546 547
       exit status, not its PID, so we assign it to `synch_process_retcode'
       below.  */
548 549
    pid = child_setup (filefd, outfilefd, fd_error, (char **) new_argv,
		       0, current_dir);
550

551 552 553 554 555
    /* Record that the synchronous process exited and note its
       termination status.  */
    synch_process_alive = 0;
    synch_process_retcode = pid;
    if (synch_process_retcode < 0)  /* means it couldn't be exec'ed */
556
      {
557
	synchronize_system_messages_locale ();
558 559
	synch_process_death = strerror (errno);
      }
560

561
    emacs_close (outfilefd);
562
    if (fd_error != outfilefd)
563
      emacs_close (fd_error);
564
    fd1 = -1; /* No harm in closing that one!  */
Karl Heuer's avatar
Karl Heuer committed
565 566
    /* Since CRLF is converted to LF within `decode_coding', we can
       always open a file with binary mode.  */
567
    fd[0] = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
568 569 570
    if (fd[0] < 0)
      {
	unlink (tempfile);
571
	emacs_close (filefd);
572 573 574
	report_file_error ("Cannot re-open temporary file", Qnil);
      }
#else /* not MSDOS */
575
#ifdef WINDOWSNT
576 577
    pid = child_setup (filefd, fd1, fd_error, (char **) new_argv,
		       0, current_dir);
578
#else  /* not WINDOWSNT */
579 580 581 582 583 584 585 586 587 588 589 590

#ifdef HAVE_WORKING_VFORK
    /* On many hosts (e.g. Solaris 2.4), if a vforked child calls `signal',
       this sets the parent's signal handlers as well as the child's.
       So delay all interrupts whose handlers the child might munge,
       and record the current handlers so they can be restored later.  */
    sigemptyset (&blocked);
    sigaddset (&blocked, SIGPIPE);
    sigaction (SIGPIPE, 0, &sigpipe_action);
    sigprocmask (SIG_BLOCK, &blocked, &procmask);
#endif

Kim F. Storm's avatar
Kim F. Storm committed
591 592
    BLOCK_INPUT;

Jim Blandy's avatar
Jim Blandy committed
593 594
    pid = vfork ();

595 596
    new_argv = new_argv_volatile;

Jim Blandy's avatar
Jim Blandy committed
597 598 599
    if (pid == 0)
      {
	if (fd[0] >= 0)
600
	  emacs_close (fd[0]);
601
#ifdef HAVE_SETSID
602
	setsid ();
603
#endif
Dan Nicolaescu's avatar
Dan Nicolaescu committed
604
#if defined (USG)
605
	setpgrp ();
Jim Blandy's avatar
Jim Blandy committed
606
#else
607
	setpgrp (pid, pid);
Jim Blandy's avatar
Jim Blandy committed
608
#endif /* USG */
609

Jan D's avatar
Jan D committed
610
	/* GConf causes us to ignore SIGPIPE, make sure it is restored
611
	   in the child.  */
Jan D's avatar
Jan D committed
612
	//signal (SIGPIPE, SIG_DFL);
613 614 615 616
#ifdef HAVE_WORKING_VFORK
	sigprocmask (SIG_SETMASK, &procmask, 0);
#endif

617 618
	child_setup (filefd, fd1, fd_error, (char **) new_argv,
		     0, current_dir);
Jim Blandy's avatar
Jim Blandy committed
619
      }
Kim F. Storm's avatar
Kim F. Storm committed
620 621

    UNBLOCK_INPUT;
622 623 624 625 626 627 628

#ifdef HAVE_WORKING_VFORK
    /* Restore the signal state.  */
    sigaction (SIGPIPE, &sigpipe_action, 0);
    sigprocmask (SIG_SETMASK, &procmask, 0);
#endif

629
#endif /* not WINDOWSNT */
630 631 632

    /* The MSDOS case did this already.  */
    if (fd_error >= 0)
633
      emacs_close (fd_error);
634
#endif /* not MSDOS */
Jim Blandy's avatar
Jim Blandy committed
635 636 637

    environ = save_environ;

638 639
    /* Close most of our fd's, but not fd[0]
       since we will use that to read input from.  */
640
    emacs_close (filefd);
641 642
    if (fd_output >= 0)
      emacs_close (fd_output);
643
    if (fd1 >= 0 && fd1 != fd_error)
644
      emacs_close (fd1);
Jim Blandy's avatar
Jim Blandy committed
645 646 647 648
  }

  if (pid < 0)
    {
649
      if (fd[0] >= 0)
650
	emacs_close (fd[0]);
Jim Blandy's avatar
Jim Blandy committed
651 652 653
      report_file_error ("Doing vfork", Qnil);
    }

654
  if (INTEGERP (buffer))
Jim Blandy's avatar
Jim Blandy committed
655
    {
656
      if (fd[0] >= 0)
657
	emacs_close (fd[0]);
Jim Blandy's avatar
Jim Blandy committed
658 659 660
      return Qnil;
    }

661
  /* Enable sending signal if user quits below.  */
662 663
  call_process_exited = 0;

Dan Nicolaescu's avatar
Dan Nicolaescu committed
664
#if defined(MSDOS)
665 666
  /* MSDOS needs different cleanup information.  */
  record_unwind_protect (call_process_cleanup,
667 668 669
			 Fcons (Fcurrent_buffer (),
				Fcons (make_number (fd[0]),
				       build_string (tempfile))));
670
#else
Jim Blandy's avatar
Jim Blandy committed
671
  record_unwind_protect (call_process_cleanup,
672 673
			 Fcons (Fcurrent_buffer (),
				Fcons (make_number (fd[0]), make_number (pid))));
Dan Nicolaescu's avatar
Dan Nicolaescu committed
674
#endif /* not MSDOS */
Jim Blandy's avatar
Jim Blandy committed
675 676


677
  if (BUFFERP (buffer))
Jim Blandy's avatar
Jim Blandy committed
678 679
    Fset_buffer (buffer);

680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
  if (NILP (buffer))
    {
      /* If BUFFER is nil, we must read process output once and then
	 discard it, so setup coding system but with nil.  */
      setup_coding_system (Qnil, &process_coding);
    }
  else
    {
      Lisp_Object val, *args2;

      val = Qnil;
      if (!NILP (Vcoding_system_for_read))
	val = Vcoding_system_for_read;
      else
	{
	  if (EQ (coding_systems, Qt))
	    {
697
	      size_t i;
698

699
	      SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
700 701 702 703 704 705
	      args2[0] = Qcall_process;
	      for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
	      coding_systems
		= Ffind_operation_coding_system (nargs + 1, args2);
	    }
	  if (CONSP (coding_systems))
706
	    val = XCAR (coding_systems);
707
	  else if (CONSP (Vdefault_process_coding_system))
708
	    val = XCAR (Vdefault_process_coding_system);
709 710 711
	  else
	    val = Qnil;
	}
712
      Fcheck_coding_system (val);
713 714 715
      /* In unibyte mode, character code conversion should not take
	 place but EOL conversion should.  So, setup raw-text or one
	 of the subsidiary according to the information just setup.  */
Tom Tromey's avatar
Tom Tromey committed
716
      if (NILP (BVAR (current_buffer, enable_multibyte_characters))
717
	  && !NILP (val))
718 719
	val = raw_text_coding_system (val);
      setup_coding_system (val, &process_coding);
720 721
    }

Jim Blandy's avatar
Jim Blandy committed
722 723 724
  immediate_quit = 1;
  QUIT;

725
  if (output_to_buffer)
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
    {
      register EMACS_INT nread;
      int first = 1;
      EMACS_INT total_read = 0;
      int carryover = 0;
      int display_p = display_p_volatile;
      int display_on_the_fly = display_p;
      struct coding_system saved_coding;

      saved_coding = process_coding;
      while (1)
	{
	  /* Repeatedly read until we've filled as much as possible
	     of the buffer size we have.  But don't read
	     less than 1024--save that for the next bufferful.  */
	  nread = carryover;
	  while (nread < bufsize - 1024)
	    {
	      int this_read = emacs_read (fd[0], buf + nread,
					  bufsize - nread);
746

747 748
	      if (this_read < 0)
		goto give_up;
749

750 751 752 753 754
	      if (this_read == 0)
		{
		  process_coding.mode |= CODING_MODE_LAST_BLOCK;
		  break;
		}
755

756 757
	      nread += this_read;
	      total_read += this_read;
758

759 760 761
	      if (display_on_the_fly)
		break;
	    }
762

763 764
	  /* Now NREAD is the total amount of data in the buffer.  */
	  immediate_quit = 0;
765

766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818
	  if (!NILP (buffer))
	    {
	      if (NILP (BVAR (current_buffer, enable_multibyte_characters))
		  && ! CODING_MAY_REQUIRE_DECODING (&process_coding))
		insert_1_both (buf, nread, nread, 0, 1, 0);
	      else
		{			/* We have to decode the input.  */
		  Lisp_Object curbuf;
		  int count1 = SPECPDL_INDEX ();

		  XSETBUFFER (curbuf, current_buffer);
		  /* We cannot allow after-change-functions be run
		     during decoding, because that might modify the
		     buffer, while we rely on process_coding.produced to
		     faithfully reflect inserted text until we
		     TEMP_SET_PT_BOTH below.  */
		  specbind (Qinhibit_modification_hooks, Qt);
		  decode_coding_c_string (&process_coding,
					  (unsigned char *) buf, nread, curbuf);
		  unbind_to (count1, Qnil);
		  if (display_on_the_fly
		      && CODING_REQUIRE_DETECTION (&saved_coding)
		      && ! CODING_REQUIRE_DETECTION (&process_coding))
		    {
		      /* We have detected some coding system.  But,
			 there's a possibility that the detection was
			 done by insufficient data.  So, we give up
			 displaying on the fly.  */
		      if (process_coding.produced > 0)
			del_range_2 (process_coding.dst_pos,
				     process_coding.dst_pos_byte,
				     process_coding.dst_pos
				     + process_coding.produced_char,
				     process_coding.dst_pos_byte
				     + process_coding.produced, 0);
		      display_on_the_fly = 0;
		      process_coding = saved_coding;
		      carryover = nread;
		      /* This is to make the above condition always
			 fails in the future.  */
		      saved_coding.common_flags
			&= ~CODING_REQUIRE_DETECTION_MASK;
		      continue;
		    }

		  TEMP_SET_PT_BOTH (PT + process_coding.produced_char,
				    PT_BYTE + process_coding.produced);
		  carryover = process_coding.carryover_bytes;
		  if (carryover > 0)
		    memcpy (buf, process_coding.carryover,
			    process_coding.carryover_bytes);
		}
	    }
819

820 821
	  if (process_coding.mode & CODING_MODE_LAST_BLOCK)
	    break;
822

823 824 825 826 827
	  /* Make the buffer bigger as we continue to read more data,
	     but not past CALLPROC_BUFFER_SIZE_MAX.  */
	  if (bufsize < CALLPROC_BUFFER_SIZE_MAX && total_read > 32 * bufsize)
	    if ((bufsize *= 2) > CALLPROC_BUFFER_SIZE_MAX)
	      bufsize = CALLPROC_BUFFER_SIZE_MAX;
828

829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851
	  if (display_p)
	    {
	      if (first)
		prepare_menu_bars ();
	      first = 0;
	      redisplay_preserve_echo_area (1);
	      /* This variable might have been set to 0 for code
		 detection.  In that case, we set it back to 1 because
		 we should have already detected a coding system.  */
	      display_on_the_fly = 1;
	    }
	  immediate_quit = 1;
	  QUIT;
	}
    give_up: ;

      Vlast_coding_system_used = CODING_ID_NAME (process_coding.id);
      /* If the caller required, let the buffer inherit the
	 coding-system used to decode the process output.  */
      if (inherit_process_coding_system)
	call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
	       make_number (total_read));
    }
Eli Zaretskii's avatar
Eli Zaretskii committed
852

853
#ifndef MSDOS
Jim Blandy's avatar
Jim Blandy committed
854
  /* Wait for it to terminate, unless it already has.  */
855 856 857 858
  if (output_to_buffer)
    wait_for_termination (pid);
  else
    interruptible_wait_for_termination (pid);
859
#endif
Jim Blandy's avatar
Jim Blandy committed
860 861 862

  immediate_quit = 0;

863 864 865 866
  /* Don't kill any children that the subprocess may have left behind
     when exiting.  */
  call_process_exited = 1;

867
  SAFE_FREE ();
Jim Blandy's avatar
Jim Blandy committed
868 869
  unbind_to (count, Qnil);

Kenichi Handa's avatar
Kenichi Handa committed