Merge from trunk after a lot of time.

1 files changed, 1476 insertions, 1687 deletions

diff --git a/src/process.c b/src/process.c
index 4d59ff0d452..20f84990d6f 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1,7 +1,7 @@
 /* Asynchronous subprocess control for GNU Emacs.
 
-Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -20,15 +20,14 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 #include <config.h>
-#include <signal.h>
+
+#define PROCESS_INLINE EXTERN_INLINE
+
 #include <stdio.h>
 #include <errno.h>
-#include <setjmp.h>
 #include <sys/types.h>          /* Some typedefs are used in sys/file.h.  */
 #include <sys/file.h>
 #include <sys/stat.h>
-#include <setjmp.h>
-
 #include <unistd.h>
 #include <fcntl.h>
 
@@ -73,8 +72,12 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <bsdtty.h>
 #endif
 
+#ifdef USG5_4
+# include <sys/stream.h>
+# include <sys/stropts.h>
+#endif
+
 #ifdef HAVE_RES_INIT
-#include <netinet/in.h>
 #include <arpa/nameser.h>
 #include <resolv.h>
 #endif
@@ -87,14 +90,18 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <pty.h>
 #endif
 
+#include <c-ctype.h>
+#include <sig2str.h>
+#include <verify.h>
+
 #endif  /* subprocesses */
 
 #include "systime.h"
 #include "systty.h"
 
 #include "window.h"
-#include "buffer.h"
 #include "character.h"
+#include "buffer.h"
 #include "coding.h"
 #include "process.h"
 #include "frame.h"
@@ -113,17 +120,57 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "gnutls.h"
 #endif
 
-#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
+#ifdef HAVE_WINDOW_SYSTEM
+#include TERM_HEADER
+#endif /* HAVE_WINDOW_SYSTEM */
+
+#ifdef HAVE_GLIB
 #include "xgselect.h"
+#ifndef WINDOWSNT
+#include <glib.h>
+#endif
 #endif
-#ifdef HAVE_NS
-#include "nsterm.h"
+
+#ifdef WINDOWSNT
+extern int sys_select (int, fd_set *, fd_set *, fd_set *,
+                       struct timespec *, void *);
+#endif
+
+#ifndef SOCK_CLOEXEC
+# define SOCK_CLOEXEC 0
+#endif
+
+#ifndef HAVE_ACCEPT4
+
+/* Emulate GNU/Linux accept4 and socket well enough for this module.  */
+
+static int
+close_on_exec (int fd)
+{
+  if (0 <= fd)
+    fcntl (fd, F_SETFD, FD_CLOEXEC);
+  return fd;
+}
+
+static int
+accept4 (int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)
+{
+  return close_on_exec (accept (sockfd, addr, addrlen));
+}
+
+static int
+process_socket (int domain, int type, int protocol)
+{
+  return close_on_exec (socket (domain, type, protocol));
+}
+# undef socket
+# define socket(domain, type, protocol) process_socket (domain, type, protocol)
 #endif
 
 /* Work around GCC 4.7.0 bug with strict overflow checking; see
    <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52904>.
    These lines can be removed once the GCC bug is fixed.  */
-#if (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) || 4 < __GNUC__
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 # pragma GCC diagnostic ignored "-Wstrict-overflow"
 #endif
 
@@ -133,13 +180,13 @@ Lisp_Object Qcutime, Qpri, Qnice, Qthcount, Qstart, Qvsize, Qrss, Qargs;
 Lisp_Object Quser, Qgroup, Qetime, Qpcpu, Qpmem, Qtime, Qctime;
 Lisp_Object QCname, QCtype;
 
-/* Non-zero if keyboard input is on hold, zero otherwise.  */
+/* True if keyboard input is on hold, zero otherwise.  */
 
-static int kbd_is_on_hold;
+static bool kbd_is_on_hold;
 
 /* Nonzero means don't run process sentinels.  This is used
    when exiting.  */
-int inhibit_sentinels;
+bool inhibit_sentinels;
 
 #ifdef subprocesses
 
@@ -161,25 +208,13 @@ static Lisp_Object QClocal, QCremote, QCcoding;
 static Lisp_Object QCserver, QCnowait, QCnoquery, QCstop;
 static Lisp_Object QCsentinel, QClog, QCoptions, QCplist;
 static Lisp_Object Qlast_nonmenu_event;
-/* QCfamily is declared and initialized in xfaces.c,
-   QCfilter in keyboard.c.  */
-extern Lisp_Object QCfamily, QCfilter;
-
-/* Qexit is declared and initialized in eval.c.  */
-
-/* QCfamily is defined in xfaces.c.  */
-extern Lisp_Object QCfamily;
-/* QCfilter is defined in keyboard.c.  */
-extern Lisp_Object QCfilter;
+static Lisp_Object Qinternal_default_process_sentinel;
+static Lisp_Object Qinternal_default_process_filter;
 
 #define NETCONN_P(p) (EQ (XPROCESS (p)->type, Qnetwork))
-#define NETCONN1_P(p) (EQ ((p)->type, Qnetwork))
+#define NETCONN1_P(p) (EQ (p->type, Qnetwork))
 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
-#define SERIALCONN1_P(p) (EQ ((p)->type, Qserial))
-
-#ifndef HAVE_H_ERRNO
-extern int h_errno;
-#endif
+#define SERIALCONN1_P(p) (EQ (p->type, Qserial))
 
 /* Number of events of change of status of a process.  */
 static EMACS_INT process_tick;
@@ -196,11 +231,9 @@ static EMACS_INT update_tick;
 #ifndef NON_BLOCKING_CONNECT
 #ifdef HAVE_SELECT
 #if defined (HAVE_GETPEERNAME) || defined (GNU_LINUX)
-#if defined (O_NONBLOCK) || defined (O_NDELAY)
 #if defined (EWOULDBLOCK) || defined (EINPROGRESS)
 #define NON_BLOCKING_CONNECT
 #endif /* EWOULDBLOCK || EINPROGRESS */
-#endif /* O_NONBLOCK || O_NDELAY */
 #endif /* HAVE_GETPEERNAME || GNU_LINUX */
 #endif /* HAVE_SELECT */
 #endif /* NON_BLOCKING_CONNECT */
@@ -211,30 +244,24 @@ static EMACS_INT update_tick;
    "non-destructive" select.  So we require either native select,
    or emulation of select using FIONREAD.  */
 
-#ifdef BROKEN_DATAGRAM_SOCKETS
-#undef DATAGRAM_SOCKETS
-#else
-#ifndef DATAGRAM_SOCKETS
-#if defined (HAVE_SELECT) || defined (FIONREAD)
-#if defined (HAVE_SENDTO) && defined (HAVE_RECVFROM) && defined (EMSGSIZE)
-#define DATAGRAM_SOCKETS
-#endif /* HAVE_SENDTO && HAVE_RECVFROM && EMSGSIZE */
-#endif /* HAVE_SELECT || FIONREAD */
-#endif /* DATAGRAM_SOCKETS */
-#endif /* BROKEN_DATAGRAM_SOCKETS */
+#ifndef BROKEN_DATAGRAM_SOCKETS
+# if defined HAVE_SELECT || defined USABLE_FIONREAD
+#  if defined HAVE_SENDTO && defined HAVE_RECVFROM && defined EMSGSIZE
+#   define DATAGRAM_SOCKETS
+#  endif
+# endif
+#endif
 
 #if defined HAVE_LOCAL_SOCKETS && defined DATAGRAM_SOCKETS
 # define HAVE_SEQPACKET
 #endif
 
 #if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING)
-#ifdef EMACS_HAS_USECS
 #define ADAPTIVE_READ_BUFFERING
 #endif
-#endif
 
 #ifdef ADAPTIVE_READ_BUFFERING
-#define READ_OUTPUT_DELAY_INCREMENT 10000
+#define READ_OUTPUT_DELAY_INCREMENT (TIMESPEC_RESOLUTION / 100)
 #define READ_OUTPUT_DELAY_MAX       (READ_OUTPUT_DELAY_INCREMENT * 5)
 #define READ_OUTPUT_DELAY_MAX_MAX   (READ_OUTPUT_DELAY_INCREMENT * 7)
 
@@ -243,27 +270,27 @@ static EMACS_INT update_tick;
 
 static int process_output_delay_count;
 
-/* Non-zero if any process has non-nil read_output_skip.  */
+/* True if any process has non-nil read_output_skip.  */
 
-static int process_output_skip;
+static bool process_output_skip;
 
 #else
 #define process_output_delay_count 0
 #endif
 
-static Lisp_Object Fget_process (Lisp_Object);
 static void create_process (Lisp_Object, char **, Lisp_Object);
-#ifdef SIGIO
-static int keyboard_bit_set (SELECT_TYPE *);
+#ifdef USABLE_SIGIO
+static bool keyboard_bit_set (fd_set *);
 #endif
 static void deactivate_process (Lisp_Object);
 static void status_notify (struct Lisp_Process *);
 static int read_process_output (Lisp_Object, int);
+static void handle_child_signal (int);
 static void create_pty (Lisp_Object);
 
 /* If we support a window system, turn on the code to poll periodically
    to detect C-g.  It isn't actually used when doing interrupt input.  */
-#if defined (HAVE_WINDOW_SYSTEM) && !defined (USE_ASYNC_EVENTS)
+#ifdef HAVE_WINDOW_SYSTEM
 #define POLL_FOR_INPUT
 #endif
 
@@ -272,39 +299,39 @@ static void exec_sentinel (Lisp_Object proc, Lisp_Object reason);
 
 /* Mask of bits indicating the descriptors that we wait for input on.  */
 
-static SELECT_TYPE input_wait_mask;
+static fd_set input_wait_mask;
 
 /* Mask that excludes keyboard input descriptor(s).  */
 
-static SELECT_TYPE non_keyboard_wait_mask;
+static fd_set non_keyboard_wait_mask;
 
 /* Mask that excludes process input descriptor(s).  */
 
-static SELECT_TYPE non_process_wait_mask;
+static fd_set non_process_wait_mask;
 
 /* Mask for selecting for write.  */
 
-static SELECT_TYPE write_mask;
+static fd_set write_mask;
 
 #ifdef NON_BLOCKING_CONNECT
 /* Mask of bits indicating the descriptors that we wait for connect to
    complete on.  Once they complete, they are removed from this mask
    and added to the input_wait_mask and non_keyboard_wait_mask.  */
 
-static SELECT_TYPE connect_wait_mask;
+static fd_set connect_wait_mask;
 
 /* Number of bits set in connect_wait_mask.  */
 static int num_pending_connects;
 #endif  /* NON_BLOCKING_CONNECT */
 
-/* The largest descriptor currently in use for a process object.  */
+/* The largest descriptor currently in use for a process object; -1 if none.  */
 static int max_process_desc;
 
-/* The largest descriptor currently in use for input.  */
+/* The largest descriptor currently in use for input; -1 if none.  */
 static int max_input_desc;
 
 /* Indexed by descriptor, gives the process (if any) for that descriptor */
-static Lisp_Object chan_process[MAXDESC];
+static Lisp_Object chan_process[FD_SETSIZE];
 
 /* Alist of elements (NAME . PROCESS) */
 static Lisp_Object Vprocess_alist;
@@ -315,18 +342,18 @@ static Lisp_Object Vprocess_alist;
    output from the process is to read at least one char.
    Always -1 on systems that support FIONREAD.  */
 
-static int proc_buffered_char[MAXDESC];
+static int proc_buffered_char[FD_SETSIZE];
 
 /* Table of `struct coding-system' for each process.  */
-static struct coding_system *proc_decode_coding_system[MAXDESC];
-static struct coding_system *proc_encode_coding_system[MAXDESC];
+static struct coding_system *proc_decode_coding_system[FD_SETSIZE];
+static struct coding_system *proc_encode_coding_system[FD_SETSIZE];
 
 #ifdef DATAGRAM_SOCKETS
 /* Table of `partner address' for datagram sockets.  */
 static struct sockaddr_and_len {
   struct sockaddr *sa;
   int len;
-} datagram_address[MAXDESC];
+} datagram_address[FD_SETSIZE];
 #define DATAGRAM_CHAN_P(chan)   (datagram_address[chan].sa != 0)
 #define DATAGRAM_CONN_P(proc)   (PROCESSP (proc) && datagram_address[XPROCESS (proc)->infd].sa != 0)
 #else
@@ -334,8 +361,93 @@ static struct sockaddr_and_len {
 #define DATAGRAM_CONN_P(proc)   (0)
 #endif
 
-/* Maximum number of bytes to send to a pty without an eof.  */
-static int pty_max_bytes;
+/* FOR_EACH_PROCESS (LIST_VAR, PROC_VAR) followed by a statement is
+   a `for' loop which iterates over processes from Vprocess_alist.  */
+
+#define FOR_EACH_PROCESS(list_var, proc_var)                    \
+  FOR_EACH_ALIST_VALUE (Vprocess_alist, list_var, proc_var)
+
+/* These setters are used only in this file, so they can be private.  */
+static void
+pset_buffer (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->buffer = val;
+}
+static void
+pset_command (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->command = val;
+}
+static void
+pset_decode_coding_system (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->decode_coding_system = val;
+}
+static void
+pset_decoding_buf (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->decoding_buf = val;
+}
+static void
+pset_encode_coding_system (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->encode_coding_system = val;
+}
+static void
+pset_encoding_buf (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->encoding_buf = val;
+}
+static void
+pset_filter (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->filter = NILP (val) ? Qinternal_default_process_filter : val;
+}
+static void
+pset_log (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->log = val;
+}
+static void
+pset_mark (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->mark = val;
+}
+static void
+pset_name (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->name = val;
+}
+static void
+pset_plist (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->plist = val;
+}
+static void
+pset_sentinel (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->sentinel = NILP (val) ? Qinternal_default_process_sentinel : val;
+}
+static void
+pset_status (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->status = val;
+}
+static void
+pset_tty_name (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->tty_name = val;
+}
+static void
+pset_type (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->type = val;
+}
+static void
+pset_write_queue (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->write_queue = val;
+}
 
 
 
@@ -346,7 +458,7 @@ static struct fd_callback_data
 #define FOR_READ  1
 #define FOR_WRITE 2
   int condition; /* mask of the defines above.  */
-} fd_callback_info[MAXDESC];
+} fd_callback_info[FD_SETSIZE];
 
 
 /* Add a file descriptor FD to be monitored for when read is possible.
@@ -355,7 +467,7 @@ static struct fd_callback_data
 void
 add_read_fd (int fd, fd_callback func, void *data)
 {
-  xassert (fd < MAXDESC);
+  eassert (fd < FD_SETSIZE);
   add_keyboard_wait_descriptor (fd);
 
   fd_callback_info[fd].func = func;
@@ -368,7 +480,7 @@ add_read_fd (int fd, fd_callback func, void *data)
 void
 delete_read_fd (int fd)
 {
-  xassert (fd < MAXDESC);
+  eassert (fd < FD_SETSIZE);
   delete_keyboard_wait_descriptor (fd);
 
   fd_callback_info[fd].condition &= ~FOR_READ;
@@ -385,7 +497,7 @@ delete_read_fd (int fd)
 void
 add_write_fd (int fd, fd_callback func, void *data)
 {
-  xassert (fd < MAXDESC);
+  eassert (fd < FD_SETSIZE);
   FD_SET (fd, &write_mask);
   if (fd > max_input_desc)
     max_input_desc = fd;
@@ -395,29 +507,35 @@ add_write_fd (int fd, fd_callback func, void *data)
   fd_callback_info[fd].condition |= FOR_WRITE;
 }
 
+/* FD is no longer an input descriptor; update max_input_desc accordingly.  */
+
+static void
+delete_input_desc (int fd)
+{
+  if (fd == max_input_desc)
+    {
+      do
+        fd--;
+      while (0 <= fd && ! (FD_ISSET (fd, &input_wait_mask)
+                           || FD_ISSET (fd, &write_mask)));
+
+      max_input_desc = fd;
+    }
+}
+
 /* Stop monitoring file descriptor FD for when write is possible.  */
 
 void
 delete_write_fd (int fd)
 {
-  int lim = max_input_desc;
-
-  xassert (fd < MAXDESC);
+  eassert (fd < FD_SETSIZE);
   FD_CLR (fd, &write_mask);
   fd_callback_info[fd].condition &= ~FOR_WRITE;
   if (fd_callback_info[fd].condition == 0)
     {
       fd_callback_info[fd].func = 0;
       fd_callback_info[fd].data = 0;
-
-      if (fd == max_input_desc)
-        for (fd = lim; fd >= 0; fd--)
-          if (FD_ISSET (fd, &input_wait_mask) || FD_ISSET (fd, &write_mask))
-            {
-              max_input_desc = fd;
-              break;
-            }
-
+      delete_input_desc (fd);
     }
 }
 
@@ -431,7 +549,7 @@ static void
 update_status (struct Lisp_Process *p)
 {
   eassert (p->raw_status_new);
-  p->status = status_convert (p->raw_status);
+  pset_status (p, status_convert (p->raw_status));
   p->raw_status_new = 0;
 }
 
@@ -444,7 +562,7 @@ status_convert (int w)
   if (WIFSTOPPED (w))
     return Fcons (Qstop, Fcons (make_number (WSTOPSIG (w)), Qnil));
   else if (WIFEXITED (w))
-    return Fcons (Qexit, Fcons (make_number (WRETCODE (w)),
+    return Fcons (Qexit, Fcons (make_number (WEXITSTATUS (w)),
                                 WCOREDUMP (w) ? Qt : Qnil));
   else if (WIFSIGNALED (w))
     return Fcons (Qsignal, Fcons (make_number (WTERMSIG (w)),
@@ -457,7 +575,7 @@ status_convert (int w)
    and store them individually through the three pointers.  */
 
 static void
-decode_status (Lisp_Object l, Lisp_Object *symbol, int *code, int *coredump)
+decode_status (Lisp_Object l, Lisp_Object *symbol, int *code, bool *coredump)
 {
   Lisp_Object tem;
 
@@ -484,14 +602,15 @@ status_message (struct Lisp_Process *p)
 {
   Lisp_Object status = p->status;
   Lisp_Object symbol;
-  int code, coredump;
+  int code;
+  bool coredump;
   Lisp_Object string, string2;
 
   decode_status (status, &symbol, &code, &coredump);
 
   if (EQ (symbol, Qsignal) || EQ (symbol, Qstop))
     {
-      char *signame;
+      char const *signame;
       synchronize_system_messages_locale ();
       signame = strsignal (code);
       if (signame == 0)
@@ -500,7 +619,7 @@ status_message (struct Lisp_Process *p)
         {
           int c1, c2;
 
-          string = make_unibyte_string (signame, strlen (signame));
+          string = build_unibyte_string (signame);
           if (! NILP (Vlocale_coding_system))
             string = (code_convert_string_norecord
                       (string, Vlocale_coding_system, 0));
@@ -534,19 +653,16 @@ status_message (struct Lisp_Process *p)
     return Fcopy_sequence (Fsymbol_name (symbol));
 }
 
-#ifdef HAVE_PTYS
-
-/* The file name of the pty opened by allocate_pty.  */
-static char pty_name[24];
+enum { PTY_NAME_SIZE = 24 };
 
 /* Open an available pty, returning a file descriptor.
-   Return -1 on failure.
-   The file name of the terminal corresponding to the pty
-   is left in the variable pty_name.  */
+   Store into PTY_NAME the file name of the terminal corresponding to the pty.
+   Return -1 on failure.  */
 
 static int
-allocate_pty (void)
+allocate_pty (char pty_name[PTY_NAME_SIZE])
 {
+#ifdef HAVE_PTYS
   int fd;
 
 #ifdef PTY_ITERATION
@@ -566,34 +682,20 @@ allocate_pty (void)
 #ifdef PTY_OPEN
         PTY_OPEN;
 #else /* no PTY_OPEN */
-        {
-          { /* Some systems name their pseudoterminals so that there are gaps in
-               the usual sequence - for example, on HP9000/S700 systems, there
-               are no pseudoterminals with names ending in 'f'.  So we wait for
-               three failures in a row before deciding that we've reached the
-               end of the ptys.  */
-            int failed_count = 0;
-            struct stat stb;
-
-            if (stat (pty_name, &stb) < 0)
-              {
-                failed_count++;
-                if (failed_count >= 3)
-                  return -1;
-              }
-            else
-              failed_count = 0;
-          }
-#  ifdef O_NONBLOCK
-          fd = emacs_open (pty_name, O_RDWR | O_NONBLOCK, 0);
-#  else
-          fd = emacs_open (pty_name, O_RDWR | O_NDELAY, 0);
-#  endif
-        }
+        fd = emacs_open (pty_name, O_RDWR | O_NONBLOCK, 0);
 #endif /* no PTY_OPEN */
 
         if (fd >= 0)
           {
+#ifdef PTY_OPEN
+            /* Set FD's close-on-exec flag.  This is needed even if
+               PT_OPEN calls posix_openpt with O_CLOEXEC, since POSIX
+               doesn't require support for that combination.
+               Multithreaded platforms where posix_openpt ignores
+               O_CLOEXEC (or where PTY_OPEN doesn't call posix_openpt)
+               have a race condition between the PTY_OPEN and here.  */
+            fcntl (fd, F_SETFD, FD_CLOEXEC);
+#endif
             /* check to make certain that both sides are available
                this avoids a nasty yet stupid bug in rlogins */
 #ifdef PTY_TTY_NAME_SPRINTF
@@ -601,7 +703,7 @@ allocate_pty (void)
 #else
             sprintf (pty_name, "/dev/tty%c%x", c, i);
 #endif /* no PTY_TTY_NAME_SPRINTF */
-            if (access (pty_name, 6) != 0)
+            if (faccessat (AT_FDCWD, pty_name, R_OK | W_OK, AT_EACCESS) != 0)
               {
                 emacs_close (fd);
 # ifndef __sgi
@@ -614,9 +716,9 @@ allocate_pty (void)
             return fd;
           }
       }
+#endif /* HAVE_PTYS */
   return -1;
 }
-#endif /* HAVE_PTYS */
 
 static Lisp_Object
 make_process (Lisp_Object name)
@@ -627,34 +729,20 @@ make_process (Lisp_Object name)
   printmax_t i;
 
   p = allocate_process ();
+  /* Initialize Lisp data.  Note that allocate_process initializes all
+     Lisp data to nil, so do it only for slots which should not be nil.  */
+  pset_status (p, Qrun);
+  pset_mark (p, Fmake_marker ());
 
+  /* Initialize non-Lisp data.  Note that allocate_process zeroes out all
+     non-Lisp data, so do it only for slots which should not be zero.  */
   p->infd = -1;
   p->outfd = -1;
-  p->tick = 0;
-  p->update_tick = 0;
-  p->pid = 0;
-  p->pty_flag = 0;
-  p->raw_status_new = 0;
-  p->status = Qrun;
-  p->mark = Fmake_marker ();
-  p->kill_without_query = 0;
-
-#ifdef ADAPTIVE_READ_BUFFERING
-  p->adaptive_read_buffering = 0;
-  p->read_output_delay = 0;
-  p->read_output_skip = 0;
-#endif
+  for (i = 0; i < PROCESS_OPEN_FDS; i++)
+    p->open_fd[i] = -1;
 
 #ifdef HAVE_GNUTLS
   p->gnutls_initstage = GNUTLS_STAGE_EMPTY;
-  /* Default log level.  */
-  p->gnutls_log_level = 0;
-  /* GnuTLS handshakes attempted for this connection.  */
-  p->gnutls_handshakes_tried = 0;
-  p->gnutls_p = 0;
-  p->gnutls_state = NULL;
-  p->gnutls_x509_cred = NULL;
-  p->gnutls_anon_cred = NULL;
 #endif
 
   /* If name is already in use, modify it until it is unused.  */
@@ -664,11 +752,12 @@ make_process (Lisp_Object name)
     {
       tem = Fget_process (name1);
       if (NILP (tem)) break;
-      sprintf (suffix, "<%"pMd">", i);
-      name1 = concat2 (name, build_string (suffix));
+      name1 = concat2 (name, make_formatted_string (suffix, "<%"pMd">", i));
     }
   name = name1;
-  p->name = name;
+  pset_name (p, name);
+  pset_sentinel (p, Qinternal_default_process_sentinel);
+  pset_filter (p, Qinternal_default_process_filter);
   XSETPROCESS (val, p);
   Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist);
   return val;
@@ -742,14 +831,26 @@ get_process (register Lisp_Object name)
 }
 
 
-#ifdef SIGCHLD
 /* Fdelete_process promises to immediately forget about the process, but in
    reality, Emacs needs to remember those processes until they have been
-   treated by sigchld_handler; otherwise this handler would consider the
-   process as being synchronous and say that the synchronous process is
-   dead.  */
+   treated by the SIGCHLD handler and waitpid has been invoked on them;
+   otherwise they might fill up the kernel's process table.
+
+   Some processes created by call-process are also put onto this list.
+
+   Members of this list are (process-ID . filename) pairs.  The
+   process-ID is a number; the filename, if a string, is a file that
+   needs to be removed after the process exits.  */
 static Lisp_Object deleted_pid_list;
-#endif
+
+void
+record_deleted_pid (pid_t pid, Lisp_Object filename)
+{
+  deleted_pid_list = Fcons (Fcons (make_fixnum_or_float (pid), filename),
+                            /* GC treated elements set to nil.  */
+                            Fdelq (Qnil, deleted_pid_list));
+
+}
 
 DEFUN ("delete-process", Fdelete_process, Sdelete_process, 1, 1, 0,
        doc: /* Delete PROCESS: kill it and forget about it immediately.
@@ -765,37 +866,27 @@ nil, indicating the current buffer's process.  */)
   p->raw_status_new = 0;
   if (NETCONN1_P (p) || SERIALCONN1_P (p))
     {
-      p->status = Fcons (Qexit, Fcons (make_number (0), Qnil));
+      pset_status (p, list2 (Qexit, make_number (0)));
       p->tick = ++process_tick;
       status_notify (p);
       redisplay_preserve_echo_area (13);
     }
-  else if (p->infd >= 0)
+  else
     {
-#ifdef SIGCHLD
-      Lisp_Object symbol;
-      pid_t pid = p->pid;
-
-      /* No problem storing the pid here, as it is still in Vprocess_alist.  */
-      deleted_pid_list = Fcons (make_fixnum_or_float (pid),
-                                /* GC treated elements set to nil.  */
-                                Fdelq (Qnil, deleted_pid_list));
-      /* If the process has already signaled, remove it from the list.  */
-      if (p->raw_status_new)
-        update_status (p);
-      symbol = p->status;
-      if (CONSP (p->status))
-        symbol = XCAR (p->status);
-      if (EQ (symbol, Qsignal) || EQ (symbol, Qexit))
-        deleted_pid_list
-          = Fdelete (make_fixnum_or_float (pid), deleted_pid_list);
-      else
-#endif
+      if (p->alive)
+        record_kill_process (p, Qnil);
+
+      if (p->infd >= 0)
         {
-          Fkill_process (process, Qnil);
-          /* Do this now, since remove_process will make sigchld_handler do nothing.  */
-          p->status
-            = Fcons (Qsignal, Fcons (make_number (SIGKILL), Qnil));
+          /* Update P's status, since record_kill_process will make the
+             SIGCHLD handler update deleted_pid_list, not *P.  */
+          Lisp_Object symbol;
+          if (p->raw_status_new)
+            update_status (p);
+          symbol = CONSP (p->status) ? XCAR (p->status) : p->status;
+          if (! (EQ (symbol, Qsignal) || EQ (symbol, Qexit)))
+            pset_status (p, list2 (Qsignal, make_number (SIGKILL)));
+
           p->tick = ++process_tick;
           status_notify (p);
           redisplay_preserve_echo_area (13);
@@ -922,9 +1013,9 @@ Return BUFFER.  */)
   if (!NILP (buffer))
     CHECK_BUFFER (buffer);
   p = XPROCESS (process);
-  p->buffer = buffer;
+  pset_buffer (p, buffer);
   if (NETCONN1_P (p) || SERIALCONN1_P (p))
-    p->childp = Fplist_put (p->childp, QCbuffer, buffer);
+    pset_childp (p, Fplist_put (p->childp, QCbuffer, buffer));
   setup_process_coding_systems (process);
   return buffer;
 }
@@ -950,10 +1041,10 @@ DEFUN ("process-mark", Fprocess_mark, Sprocess_mark,
 
 DEFUN ("set-process-filter", Fset_process_filter, Sset_process_filter,
        2, 2, 0,
-       doc: /* Give PROCESS the filter function FILTER; nil means no filter.
+       doc: /* Give PROCESS the filter function FILTER; nil means default.
 A value of t means stop accepting output from the process.
 
-When a process has a filter, its buffer is not used for output.
+When a process has a non-default filter, its buffer is not used for output.
 Instead, each time it does output, the entire string of output is
 passed to the filter.
 
@@ -979,6 +1070,9 @@ The string argument is normally a multibyte string, except:
      (debug)
      (set-process-filter process ...)  */
 
+  if (NILP (filter))
+    filter = Qinternal_default_process_filter;
+
   if (p->infd >= 0)
     {
       if (EQ (filter, Qt) && !EQ (p->status, Qlisten))
@@ -995,16 +1089,16 @@ The string argument is normally a multibyte string, except:
         }
     }
 
-  p->filter = filter;
+  pset_filter (p, filter);
   if (NETCONN1_P (p) || SERIALCONN1_P (p))
-    p->childp = Fplist_put (p->childp, QCfilter, filter);
+    pset_childp (p, Fplist_put (p->childp, QCfilter, filter));
   setup_process_coding_systems (process);
   return filter;
 }
 
 DEFUN ("process-filter", Fprocess_filter, Sprocess_filter,
        1, 1, 0,
-       doc: /* Returns the filter function of PROCESS; nil if none.
+       doc: /* Return the filter function of PROCESS.
 See `set-process-filter' for more info on filter functions.  */)
   (register Lisp_Object process)
 {
@@ -1014,7 +1108,7 @@ See `set-process-filter' for more info on filter functions.  */)
 
 DEFUN ("set-process-sentinel", Fset_process_sentinel, Sset_process_sentinel,
        2, 2, 0,
-       doc: /* Give PROCESS the sentinel SENTINEL; nil for none.
+       doc: /* Give PROCESS the sentinel SENTINEL; nil for default.
 The sentinel is called as a function when the process changes state.
 It gets two arguments: the process, and a string describing the change.  */)
   (register Lisp_Object process, Lisp_Object sentinel)
@@ -1024,15 +1118,18 @@ It gets two arguments: the process, and a string describing the change.  */)
   CHECK_PROCESS (process);
   p = XPROCESS (process);
 
-  p->sentinel = sentinel;
+  if (NILP (sentinel))
+    sentinel = Qinternal_default_process_sentinel;
+
+  pset_sentinel (p, sentinel);
   if (NETCONN1_P (p) || SERIALCONN1_P (p))
-    p->childp = Fplist_put (p->childp, QCsentinel, sentinel);
+    pset_childp (p, Fplist_put (p->childp, QCsentinel, sentinel));
   return sentinel;
 }
 
 DEFUN ("process-sentinel", Fprocess_sentinel, Sprocess_sentinel,
        1, 1, 0,
-       doc: /* Return the sentinel of PROCESS; nil if none.
+       doc: /* Return the sentinel of PROCESS.
 See `set-process-sentinel' for more info on sentinels.  */)
   (register Lisp_Object process)
 {
@@ -1043,15 +1140,18 @@ See `set-process-sentinel' for more info on sentinels.  */)
 DEFUN ("set-process-window-size", Fset_process_window_size,
        Sset_process_window_size, 3, 3, 0,
        doc: /* Tell PROCESS that it has logical window size HEIGHT and WIDTH.  */)
-  (register Lisp_Object process, Lisp_Object height, Lisp_Object width)
+  (Lisp_Object process, Lisp_Object height, Lisp_Object width)
 {
   CHECK_PROCESS (process);
-  CHECK_RANGED_INTEGER (0, height, INT_MAX);
-  CHECK_RANGED_INTEGER (0, width, INT_MAX);
+
+  /* All known platforms store window sizes as 'unsigned short'.  */
+  CHECK_RANGED_INTEGER (height, 0, USHRT_MAX);
+  CHECK_RANGED_INTEGER (width, 0, USHRT_MAX);
 
   if (XPROCESS (process)->infd < 0
-      || set_window_size (XPROCESS (process)->infd,
-                          XINT (height), XINT (width)) <= 0)
+      || (set_window_size (XPROCESS (process)->infd,
+                           XINT (height), XINT (width))
+          < 0))
     return Qnil;
   else
     return Qt;
@@ -1107,10 +1207,6 @@ DEFUN ("process-query-on-exit-flag",
   return (XPROCESS (process)->kill_without_query ? Qnil : Qt);
 }
 
-#ifdef DATAGRAM_SOCKETS
-static Lisp_Object Fprocess_datagram_address (Lisp_Object);
-#endif
-
 DEFUN ("process-contact", Fprocess_contact, Sprocess_contact,
        1, 2, 0,
        doc: /* Return the contact info of PROCESS; t for a real child.
@@ -1138,11 +1234,11 @@ list of keywords.  */)
   if ((!NETCONN_P (process) && !SERIALCONN_P (process)) || EQ (key, Qt))
     return contact;
   if (NILP (key) && NETCONN_P (process))
-    return Fcons (Fplist_get (contact, QChost),
-                  Fcons (Fplist_get (contact, QCservice), Qnil));
+    return list2 (Fplist_get (contact, QChost),
+                  Fplist_get (contact, QCservice));
   if (NILP (key) && SERIALCONN_P (process))
-    return Fcons (Fplist_get (contact, QCport),
-                  Fcons (Fplist_get (contact, QCspeed), Qnil));
+    return list2 (Fplist_get (contact, QCport),
+                  Fplist_get (contact, QCspeed));
   return Fplist_get (contact, key);
 }
 
@@ -1163,7 +1259,7 @@ DEFUN ("set-process-plist", Fset_process_plist, Sset_process_plist,
   CHECK_PROCESS (process);
   CHECK_LIST (plist);
 
-  XPROCESS (process)->plist = plist;
+  pset_plist (XPROCESS (process), plist);
   return plist;
 }
 
@@ -1265,7 +1361,7 @@ Returns nil if format of ADDRESS is invalid.  */)
 }
 
 DEFUN ("process-list", Fprocess_list, Sprocess_list, 0, 0, 0,
-       doc: /* Return a list of all processes.  */)
+       doc: /* Return a list of all processes that are Emacs sub-processes.  */)
   (void)
 {
   return Fmapcar (Qcdr, Vprocess_alist);
@@ -1273,7 +1369,7 @@ DEFUN ("process-list", Fprocess_list, Sprocess_list, 0, 0, 0,
 
 /* Starting asynchronous inferior processes.  */
 
-static Lisp_Object start_process_unwind (Lisp_Object proc);
+static void start_process_unwind (Lisp_Object proc);
 
 DEFUN ("start-process", Fstart_process, Sstart_process, 3, MANY, 0,
        doc: /* Start a program in a subprocess.  Return the process object for it.
@@ -1315,22 +1411,9 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
      function.  The argument list is protected by the caller, so all
      we really have to worry about is buffer.  */
   {
-    struct gcpro gcpro1, gcpro2;
-
-    current_dir = BVAR (current_buffer, directory);
-
-    GCPRO2 (buffer, current_dir);
-
-    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);
-    if (NILP (Ffile_accessible_directory_p (current_dir)))
-      report_file_error ("Setting current directory",
-                         Fcons (BVAR (current_buffer, directory), Qnil));
-
+    struct gcpro gcpro1;
+    GCPRO1 (buffer);
+    current_dir = encode_current_directory ();
     UNGCPRO;
   }
 
@@ -1349,18 +1432,18 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
      itself; it's all taken care of here.  */
   record_unwind_protect (start_process_unwind, proc);
 
-  XPROCESS (proc)->childp = Qt;
-  XPROCESS (proc)->plist = Qnil;
-  XPROCESS (proc)->type = Qreal;
-  XPROCESS (proc)->buffer = buffer;
-  XPROCESS (proc)->sentinel = Qnil;
-  XPROCESS (proc)->filter = Qnil;
-  XPROCESS (proc)->command = Flist (nargs - 2, args + 2);
+  pset_childp (XPROCESS (proc), Qt);
+  pset_plist (XPROCESS (proc), Qnil);
+  pset_type (XPROCESS (proc), Qreal);
+  pset_buffer (XPROCESS (proc), buffer);
+  pset_sentinel (XPROCESS (proc), Qinternal_default_process_sentinel);
+  pset_filter (XPROCESS (proc), Qinternal_default_process_filter);
+  pset_command (XPROCESS (proc), Flist (nargs - 2, args + 2));
 
 #ifdef HAVE_GNUTLS
   /* AKA GNUTLS_INITSTAGE(proc).  */
   XPROCESS (proc)->gnutls_initstage = GNUTLS_STAGE_EMPTY;
-  XPROCESS (proc)->gnutls_cred_type = Qnil;
+  pset_gnutls_cred_type (XPROCESS (proc), Qnil);
 #endif
 
 #ifdef ADAPTIVE_READ_BUFFERING
@@ -1388,7 +1471,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
     val = Vcoding_system_for_read;
     if (NILP (val))
       {
-        args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+        args2 = alloca ((nargs + 1) * sizeof *args2);
         args2[0] = Qstart_process;
         for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
         GCPRO2 (proc, current_dir);
@@ -1400,14 +1483,14 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
         else if (CONSP (Vdefault_process_coding_system))
           val = XCAR (Vdefault_process_coding_system);
       }
-    XPROCESS (proc)->decode_coding_system = val;
+    pset_decode_coding_system (XPROCESS (proc), val);
 
     val = Vcoding_system_for_write;
     if (NILP (val))
       {
         if (EQ (coding_systems, Qt))
           {
-            args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+            args2 = alloca ((nargs + 1) * sizeof *args2);
             args2[0] = Qstart_process;
             for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
             GCPRO2 (proc, current_dir);
@@ -1420,7 +1503,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
         else if (CONSP (Vdefault_process_coding_system))
           val = XCDR (Vdefault_process_coding_system);
       }
-    XPROCESS (proc)->encode_coding_system = val;
+    pset_encode_coding_system (XPROCESS (proc), val);
     /* Note: At this moment, the above coding system may leave
        text-conversion or eol-conversion unspecified.  They will be
        decided after we read output from the process and decode it by
@@ -1429,9 +1512,9 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
   }
 
 
-  XPROCESS (proc)->decoding_buf = empty_unibyte_string;
+  pset_decoding_buf (XPROCESS (proc), empty_unibyte_string);
   XPROCESS (proc)->decoding_carryover = 0;
-  XPROCESS (proc)->encoding_buf = empty_unibyte_string;
+  pset_encoding_buf (XPROCESS (proc), empty_unibyte_string);
 
   XPROCESS (proc)->inherit_coding_system_flag
     = !(NILP (buffer) || !inherit_process_coding_system);
@@ -1451,7 +1534,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
           openp (Vexec_path, program, Vexec_suffixes, &tem, make_number (X_OK));
           UNGCPRO;
           if (NILP (tem))
-            report_file_error ("Searching for program", Fcons (program, Qnil));
+            report_file_error ("Searching for program", program);
           tem = Fexpand_file_name (tem, Qnil);
         }
       else
@@ -1474,7 +1557,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
 
         /* Encode the file name and put it in NEW_ARGV.
            That's where the child will use it to execute the program.  */
-        tem = Fcons (ENCODE_FILE (tem), Qnil);
+        tem = list1 (ENCODE_FILE (tem));
 
         /* Here we encode arguments by the coding system used for sending
            data to the process.  We don't support using different coding
@@ -1501,7 +1584,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
 
       /* Now that everything is encoded we can collect the strings into
          NEW_ARGV.  */
-      new_argv = (unsigned char **) alloca ((nargs - 1) * sizeof (char *));
+      new_argv = alloca ((nargs - 1) * sizeof *new_argv);
       new_argv[nargs - 2] = 0;
 
       for (i = nargs - 2; i-- != 0; )
@@ -1522,442 +1605,321 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
    PROC doesn't have its pid set, then we know someone has signaled
    an error and the process wasn't started successfully, so we should
    remove it from the process list.  */
-static Lisp_Object
+static void
 start_process_unwind (Lisp_Object proc)
 {
   if (!PROCESSP (proc))
-    abort ();
+    emacs_abort ();
 
   /* Was PROC started successfully?
      -2 is used for a pty with no process, eg for gdb.  */
   if (XPROCESS (proc)->pid <= 0 && XPROCESS (proc)->pid != -2)
     remove_process (proc);
-
-  return Qnil;
 }
 
+/* If *FD_ADDR is nonnegative, close it, and mark it as closed.  */
+
 static void
-create_process_1 (struct atimer *timer)
+close_process_fd (int *fd_addr)
 {
-  /* Nothing to do.  */
+  int fd = *fd_addr;
+  if (0 <= fd)
+    {
+      *fd_addr = -1;
+      emacs_close (fd);
+    }
 }
 
+/* Indexes of file descriptors in open_fds.  */
+enum
+  {
+    /* The pipe from Emacs to its subprocess.  */
+    SUBPROCESS_STDIN,
+    WRITE_TO_SUBPROCESS,
+
+    /* The main pipe from the subprocess to Emacs.  */
+    READ_FROM_SUBPROCESS,
+    SUBPROCESS_STDOUT,
+
+    /* The pipe from the subprocess to Emacs that is closed when the
+       subprocess execs.  */
+    READ_FROM_EXEC_MONITOR,
+    EXEC_MONITOR_OUTPUT
+  };
+
+verify (PROCESS_OPEN_FDS == EXEC_MONITOR_OUTPUT + 1);
 
 static void
 create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 {
+  struct Lisp_Process *p = XPROCESS (process);
   int inchannel, outchannel;
   pid_t pid;
-  int sv[2];
-#if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
-  int wait_child_setup[2];
-#endif
-  sigset_t procmask;
-  sigset_t blocked;
-  struct sigaction sigint_action;
-  struct sigaction sigquit_action;
-  struct sigaction sigpipe_action;
-#ifdef AIX
-  struct sigaction sighup_action;
-#endif
-  /* Use volatile to protect variables from being clobbered by longjmp.  */
-  volatile int forkin, forkout;
-  volatile int pty_flag = 0;
-#ifndef USE_CRT_DLL
-  extern char **environ;
-#endif
+  int vfork_errno;
+  int forkin, forkout;
+  bool pty_flag = 0;
+  char pty_name[PTY_NAME_SIZE];
+  Lisp_Object lisp_pty_name = Qnil;
 
   inchannel = outchannel = -1;
 
-#ifdef HAVE_PTYS
   if (!NILP (Vprocess_connection_type))
-    outchannel = inchannel = allocate_pty ();
+    outchannel = inchannel = allocate_pty (pty_name);
 
   if (inchannel >= 0)
     {
+      p->open_fd[READ_FROM_SUBPROCESS] = inchannel;
 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
       /* On most USG systems it does not work to open the pty's tty here,
          then close it and reopen it in the child.  */
-#ifdef O_NOCTTY
       /* Don't let this terminal become our controlling terminal
          (in case we don't have one).  */
       forkout = forkin = emacs_open (pty_name, O_RDWR | O_NOCTTY, 0);
-#else
-      forkout = forkin = emacs_open (pty_name, O_RDWR, 0);
-#endif
       if (forkin < 0)
         report_file_error ("Opening pty", Qnil);
+      p->open_fd[SUBPROCESS_STDIN] = forkin;
 #else
       forkin = forkout = -1;
 #endif /* not USG, or USG_SUBTTY_WORKS */
       pty_flag = 1;
+      lisp_pty_name = build_string (pty_name);
     }
   else
-#endif /* HAVE_PTYS */
     {
-      int tem;
-      tem = pipe (sv);
-      if (tem < 0)
+      if (emacs_pipe (p->open_fd + SUBPROCESS_STDIN) != 0
+          || emacs_pipe (p->open_fd + READ_FROM_SUBPROCESS) != 0)
         report_file_error ("Creating pipe", Qnil);
-      inchannel = sv[0];
-      forkout = sv[1];
-      tem = pipe (sv);
-      if (tem < 0)
-        {
-          emacs_close (inchannel);
-          emacs_close (forkout);
-          report_file_error ("Creating pipe", Qnil);
-        }
-      outchannel = sv[1];
-      forkin = sv[0];
+      forkin = p->open_fd[SUBPROCESS_STDIN];
+      outchannel = p->open_fd[WRITE_TO_SUBPROCESS];
+      inchannel = p->open_fd[READ_FROM_SUBPROCESS];
+      forkout = p->open_fd[SUBPROCESS_STDOUT];
     }
 
-#if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
-    {
-      int tem;
-
-      tem = pipe (wait_child_setup);
-      if (tem < 0)
-        report_file_error ("Creating pipe", Qnil);
-      tem = fcntl (wait_child_setup[1], F_GETFD, 0);
-      if (tem >= 0)
-        tem = fcntl (wait_child_setup[1], F_SETFD, tem | FD_CLOEXEC);
-      if (tem < 0)
-        {
-          emacs_close (wait_child_setup[0]);
-          emacs_close (wait_child_setup[1]);
-          report_file_error ("Setting file descriptor flags", Qnil);
-        }
-    }
+#ifndef WINDOWSNT
+  if (emacs_pipe (p->open_fd + READ_FROM_EXEC_MONITOR) != 0)
+    report_file_error ("Creating pipe", Qnil);
 #endif
 
-#ifdef O_NONBLOCK
   fcntl (inchannel, F_SETFL, O_NONBLOCK);
   fcntl (outchannel, F_SETFL, O_NONBLOCK);
-#else
-#ifdef O_NDELAY
-  fcntl (inchannel, F_SETFL, O_NDELAY);
-  fcntl (outchannel, F_SETFL, O_NDELAY);
-#endif
-#endif
 
-  /* Record this as an active process, with its channels.
-     As a result, child_setup will close Emacs's side of the pipes.  */
+  /* Record this as an active process, with its channels.  */
   chan_process[inchannel] = process;
-  XPROCESS (process)->infd = inchannel;
-  XPROCESS (process)->outfd = outchannel;
+  p->infd = inchannel;
+  p->outfd = outchannel;
 
   /* Previously we recorded the tty descriptor used in the subprocess.
      It was only used for getting the foreground tty process, so now
      we just reopen the device (see emacs_get_tty_pgrp) as this is
      more portable (see USG_SUBTTY_WORKS above).  */
 
-  XPROCESS (process)->pty_flag = pty_flag;
-  XPROCESS (process)->status = Qrun;
-
-  /* Delay interrupts until we have a chance to store
-     the new fork's pid in its process structure */
-  sigemptyset (&blocked);
-#ifdef SIGCHLD
-  sigaddset (&blocked, SIGCHLD);
-#endif
-#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.  */
-  sigaddset (&blocked, SIGINT );  sigaction (SIGINT , 0, &sigint_action );
-  sigaddset (&blocked, SIGQUIT);  sigaction (SIGQUIT, 0, &sigquit_action);
-  sigaddset (&blocked, SIGPIPE);  sigaction (SIGPIPE, 0, &sigpipe_action);
-#ifdef AIX
-  sigaddset (&blocked, SIGHUP );  sigaction (SIGHUP , 0, &sighup_action );
-#endif
-#endif /* HAVE_WORKING_VFORK */
-  pthread_sigmask (SIG_BLOCK, &blocked, &procmask);
+  p->pty_flag = pty_flag;
+  pset_status (p, Qrun);
 
   FD_SET (inchannel, &input_wait_mask);
   FD_SET (inchannel, &non_keyboard_wait_mask);
   if (inchannel > max_process_desc)
     max_process_desc = inchannel;
 
-  /* Until we store the proper pid, enable sigchld_handler
-     to recognize an unknown pid as standing for this process.
-     It is very important not to let this `marker' value stay
-     in the table after this function has returned; if it does
-     it might cause call-process to hang and subsequent asynchronous
-     processes to get their return values scrambled.  */
-  XPROCESS (process)->pid = -1;
-
-  /* This must be called after the above line because it may signal an
-     error. */
+  /* This may signal an error. */
   setup_process_coding_systems (process);
 
-  BLOCK_INPUT;
+  block_input ();
+  block_child_signal ();
 
+#ifndef WINDOWSNT
+  /* vfork, and prevent local vars from being clobbered by the vfork.  */
   {
-    /* child_setup must clobber environ on systems with true vfork.
-       Protect it from permanent change.  */
-    char **save_environ = environ;
-    volatile Lisp_Object encoded_current_dir = ENCODE_FILE (current_dir);
+    Lisp_Object volatile current_dir_volatile = current_dir;
+    Lisp_Object volatile lisp_pty_name_volatile = lisp_pty_name;
+    char **volatile new_argv_volatile = new_argv;
+    int volatile forkin_volatile = forkin;
+    int volatile forkout_volatile = forkout;
+    struct Lisp_Process *p_volatile = p;
 
-#ifndef WINDOWSNT
     pid = vfork ();
-    if (pid == 0)
-#endif /* not WINDOWSNT */
-      {
-        int xforkin = forkin;
-        int xforkout = forkout;
 
-#if 0 /* This was probably a mistake--it duplicates code later on,
-         but fails to handle all the cases.  */
-        /* Make sure SIGCHLD is not blocked in the child.  */
-        sigsetmask (SIGEMPTYMASK);
-#endif
+    current_dir = current_dir_volatile;
+    lisp_pty_name = lisp_pty_name_volatile;
+    new_argv = new_argv_volatile;
+    forkin = forkin_volatile;
+    forkout = forkout_volatile;
+    p = p_volatile;
+
+    pty_flag = p->pty_flag;
+  }
 
-        /* Make the pty be the controlling terminal of the process.  */
+  if (pid == 0)
+#endif /* not WINDOWSNT */
+    {
+      int xforkin = forkin;
+      int xforkout = forkout;
+
+      /* Make the pty be the controlling terminal of the process.  */
 #ifdef HAVE_PTYS
-        /* First, disconnect its current controlling terminal.  */
-#ifdef HAVE_SETSID
-        /* We tried doing setsid only if pty_flag, but it caused
-           process_set_signal to fail on SGI when using a pipe.  */
-        setsid ();
-        /* Make the pty's terminal the controlling terminal.  */
-        if (pty_flag && xforkin >= 0)
-          {
+      /* First, disconnect its current controlling terminal.  */
+      /* We tried doing setsid only if pty_flag, but it caused
+         process_set_signal to fail on SGI when using a pipe.  */
+      setsid ();
+      /* Make the pty's terminal the controlling terminal.  */
+      if (pty_flag && xforkin >= 0)
+        {
 #ifdef TIOCSCTTY
-            /* We ignore the return value
-               because faith@cs.unc.edu says that is necessary on Linux.  */
-            ioctl (xforkin, TIOCSCTTY, 0);
+          /* We ignore the return value
+             because faith@cs.unc.edu says that is necessary on Linux.  */
+          ioctl (xforkin, TIOCSCTTY, 0);
 #endif
-          }
-#else /* not HAVE_SETSID */
-#ifdef USG
-        /* It's very important to call setpgrp here and no time
-           afterwards.  Otherwise, we lose our controlling tty which
-           is set when we open the pty. */
-        setpgrp ();
-#endif /* USG */
-#endif /* not HAVE_SETSID */
+        }
 #if defined (LDISC1)
-        if (pty_flag && xforkin >= 0)
-          {
-            struct termios t;
-            tcgetattr (xforkin, &t);
-            t.c_lflag = LDISC1;
-            if (tcsetattr (xforkin, TCSANOW, &t) < 0)
-              emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
-          }
+      if (pty_flag && xforkin >= 0)
+        {
+          struct termios t;
+          tcgetattr (xforkin, &t);
+          t.c_lflag = LDISC1;
+          if (tcsetattr (xforkin, TCSANOW, &t) < 0)
+            emacs_perror ("create_process/tcsetattr LDISC1");
+        }
 #else
 #if defined (NTTYDISC) && defined (TIOCSETD)
-        if (pty_flag && xforkin >= 0)
-          {
-            /* Use new line discipline.  */
-            int ldisc = NTTYDISC;
-            ioctl (xforkin, TIOCSETD, &ldisc);
-          }
+      if (pty_flag && xforkin >= 0)
+        {
+          /* Use new line discipline.  */
+          int ldisc = NTTYDISC;
+          ioctl (xforkin, TIOCSETD, &ldisc);
+        }
 #endif
 #endif
 #ifdef TIOCNOTTY
-        /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
-           can do TIOCSPGRP only to the process's controlling tty.  */
-        if (pty_flag)
-          {
-            /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
-               I can't test it since I don't have 4.3.  */
-            int j = emacs_open ("/dev/tty", O_RDWR, 0);
-            if (j >= 0)
-              {
-                ioctl (j, TIOCNOTTY, 0);
-                emacs_close (j);
-              }
-#ifndef USG
-            /* In order to get a controlling terminal on some versions
-               of BSD, it is necessary to put the process in pgrp 0
-               before it opens the terminal.  */
-#ifdef HAVE_SETPGID
-            setpgid (0, 0);
-#else
-            setpgrp (0, 0);
-#endif
-#endif
-          }
+      /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
+         can do TIOCSPGRP only to the process's controlling tty.  */
+      if (pty_flag)
+        {
+          /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
+             I can't test it since I don't have 4.3.  */
+          int j = emacs_open ("/dev/tty", O_RDWR, 0);
+          if (j >= 0)
+            {
+              ioctl (j, TIOCNOTTY, 0);
+              emacs_close (j);
+            }
+        }
 #endif /* TIOCNOTTY */
 
 #if !defined (DONT_REOPEN_PTY)
 /*** There is a suggestion that this ought to be a
-     conditional on TIOCSPGRP,
-     or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
+     conditional on TIOCSPGRP, or !defined TIOCSCTTY.
      Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
      that system does seem to need this code, even though
-     both HAVE_SETSID and TIOCSCTTY are defined.  */
+     both TIOCSCTTY is defined.  */
         /* Now close the pty (if we had it open) and reopen it.
            This makes the pty the controlling terminal of the subprocess.  */
-        if (pty_flag)
-          {
+      if (pty_flag)
+        {
 
-            /* I wonder if emacs_close (emacs_open (pty_name, ...))
-               would work?  */
-            if (xforkin >= 0)
-              emacs_close (xforkin);
-            xforkout = xforkin = emacs_open (pty_name, O_RDWR, 0);
+          /* I wonder if emacs_close (emacs_open (SSDATA (lisp_pty_name), ...))
+             would work?  */
+          if (xforkin >= 0)
+            emacs_close (xforkin);
+          xforkout = xforkin = emacs_open (SSDATA (lisp_pty_name), O_RDWR, 0);
 
-            if (xforkin < 0)
-              {
-                emacs_write (1, "Couldn't open the pty terminal ", 31);
-                emacs_write (1, pty_name, strlen (pty_name));
-                emacs_write (1, "\n", 1);
-                _exit (1);
-              }
+          if (xforkin < 0)
+            {
+              emacs_perror (SSDATA (lisp_pty_name));
+              _exit (EXIT_CANCELED);
+            }
 
-          }
+        }
 #endif /* not DONT_REOPEN_PTY */
 
 #ifdef SETUP_SLAVE_PTY
-        if (pty_flag)
-          {
-            SETUP_SLAVE_PTY;
-          }
+      if (pty_flag)
+        {
+          SETUP_SLAVE_PTY;
+        }
 #endif /* SETUP_SLAVE_PTY */
-#ifdef AIX
-        /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
-           Now reenable it in the child, so it will die when we want it to.  */
-        if (pty_flag)
-          signal (SIGHUP, SIG_DFL);
-#endif
 #endif /* HAVE_PTYS */
 
-        signal (SIGINT, SIG_DFL);
-        signal (SIGQUIT, SIG_DFL);
-        /* GConf causes us to ignore SIGPIPE, make sure it is restored
-           in the child.  */
-        signal (SIGPIPE, SIG_DFL);
+      signal (SIGINT, SIG_DFL);
+      signal (SIGQUIT, SIG_DFL);
 
-        /* Stop blocking signals in the child.  */
-        pthread_sigmask (SIG_SETMASK, &procmask, 0);
+      /* Emacs ignores SIGPIPE, but the child should not.  */
+      signal (SIGPIPE, SIG_DFL);
 
-        if (pty_flag)
-          child_setup_tty (xforkout);
+      /* Stop blocking SIGCHLD in the child.  */
+      unblock_child_signal ();
+
+      if (pty_flag)
+        child_setup_tty (xforkout);
 #ifdef WINDOWSNT
-        pid = child_setup (xforkin, xforkout, xforkout,
-                           new_argv, 1, encoded_current_dir);
+      pid = child_setup (xforkin, xforkout, xforkout, new_argv, 1, current_dir);
 #else  /* not WINDOWSNT */
-#ifdef FD_CLOEXEC
-        emacs_close (wait_child_setup[0]);
-#endif
-        child_setup (xforkin, xforkout, xforkout,
-                     new_argv, 1, encoded_current_dir);
+      child_setup (xforkin, xforkout, xforkout, new_argv, 1, current_dir);
 #endif /* not WINDOWSNT */
-      }
-    environ = save_environ;
-  }
+    }
 
-  UNBLOCK_INPUT;
+  /* Back in the parent process.  */
+
+  vfork_errno = errno;
+  p->pid = pid;
+  if (pid >= 0)
+    p->alive = 1;
+
+  /* Stop blocking in the parent.  */
+  unblock_child_signal ();
+  unblock_input ();
 
-  /* This runs in the Emacs process.  */
   if (pid < 0)
-    {
-      if (forkin >= 0)
-        emacs_close (forkin);
-      if (forkin != forkout && forkout >= 0)
-        emacs_close (forkout);
-    }
+    report_file_errno ("Doing vfork", Qnil, vfork_errno);
   else
     {
       /* vfork succeeded.  */
-      XPROCESS (process)->pid = pid;
+
+      /* Close the pipe ends that the child uses, or the child's pty.  */
+      close_process_fd (&p->open_fd[SUBPROCESS_STDIN]);
+      close_process_fd (&p->open_fd[SUBPROCESS_STDOUT]);
 
 #ifdef WINDOWSNT
       register_child (pid, inchannel);
 #endif /* WINDOWSNT */
 
-      /* If the subfork execv fails, and it exits,
-         this close hangs.  I don't know why.
-         So have an interrupt jar it loose.  */
-      {
-        struct atimer *timer;
-        EMACS_TIME offset;
-
-        stop_polling ();
-        EMACS_SET_SECS_USECS (offset, 1, 0);
-        timer = start_atimer (ATIMER_RELATIVE, offset, create_process_1, 0);
-
-        if (forkin >= 0)
-          emacs_close (forkin);
-
-        cancel_atimer (timer);
-        start_polling ();
-      }
-
-      if (forkin != forkout && forkout >= 0)
-        emacs_close (forkout);
-
-#ifdef HAVE_PTYS
-      if (pty_flag)
-        XPROCESS (process)->tty_name = build_string (pty_name);
-      else
-#endif
-        XPROCESS (process)->tty_name = Qnil;
+      pset_tty_name (p, lisp_pty_name);
 
-#if !defined (WINDOWSNT) && defined (FD_CLOEXEC)
+#ifndef WINDOWSNT
       /* Wait for child_setup to complete in case that vfork is
-         actually defined as fork.  The descriptor wait_child_setup[1]
+         actually defined as fork.  The descriptor
+         XPROCESS (proc)->open_fd[EXEC_MONITOR_OUTPUT]
          of a pipe is closed at the child side either by close-on-exec
-         on successful execvp or the _exit call in child_setup.  */
+         on successful execve or the _exit call in child_setup.  */
       {
         char dummy;
 
-        emacs_close (wait_child_setup[1]);
-        emacs_read (wait_child_setup[0], &dummy, 1);
-        emacs_close (wait_child_setup[0]);
+        close_process_fd (&p->open_fd[EXEC_MONITOR_OUTPUT]);
+        emacs_read (p->open_fd[READ_FROM_EXEC_MONITOR], &dummy, 1);
+        close_process_fd (&p->open_fd[READ_FROM_EXEC_MONITOR]);
       }
 #endif
     }
-
-  /* Restore the signal state whether vfork succeeded or not.
-     (We will signal an error, below, if it failed.)  */
-#ifdef HAVE_WORKING_VFORK
-  /* Restore the parent's signal handlers.  */
-  sigaction (SIGINT, &sigint_action, 0);
-  sigaction (SIGQUIT, &sigquit_action, 0);
-  sigaction (SIGPIPE, &sigpipe_action, 0);
-#ifdef AIX
-  sigaction (SIGHUP, &sighup_action, 0);
-#endif
-#endif /* HAVE_WORKING_VFORK */
-  /* Stop blocking signals in the parent.  */
-  pthread_sigmask (SIG_SETMASK, &procmask, 0);
-
-  /* Now generate the error if vfork failed.  */
-  if (pid < 0)
-    report_file_error ("Doing vfork", Qnil);
 }
 
-void
+static void
 create_pty (Lisp_Object process)
 {
-  int inchannel, outchannel;
-  int pty_flag = 0;
-
-  inchannel = outchannel = -1;
-
-#ifdef HAVE_PTYS
-  if (!NILP (Vprocess_connection_type))
-    outchannel = inchannel = allocate_pty ();
+  struct Lisp_Process *p = XPROCESS (process);
+  char pty_name[PTY_NAME_SIZE];
+  int pty_fd = NILP (Vprocess_connection_type) ? -1 : allocate_pty (pty_name);
 
-  if (inchannel >= 0)
+  if (pty_fd >= 0)
     {
+      p->open_fd[SUBPROCESS_STDIN] = pty_fd;
 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
       /* On most USG systems it does not work to open the pty's tty here,
          then close it and reopen it in the child.  */
-#ifdef O_NOCTTY
       /* Don't let this terminal become our controlling terminal
          (in case we don't have one).  */
       int forkout = emacs_open (pty_name, O_RDWR | O_NOCTTY, 0);
-#else
-      int forkout = emacs_open (pty_name, O_RDWR, 0);
-#endif
       if (forkout < 0)
         report_file_error ("Opening pty", Qnil);
+      p->open_fd[WRITE_TO_SUBPROCESS] = forkout;
 #if defined (DONT_REOPEN_PTY)
       /* In the case that vfork is defined as fork, the parent process
          (Emacs) may send some data before the child process completes
@@ -1965,47 +1927,33 @@ create_pty (Lisp_Object process)
       child_setup_tty (forkout);
 #endif /* DONT_REOPEN_PTY */
 #endif /* not USG, or USG_SUBTTY_WORKS */
-      pty_flag = 1;
-    }
-#endif /* HAVE_PTYS */
 
-#ifdef O_NONBLOCK
-  fcntl (inchannel, F_SETFL, O_NONBLOCK);
-  fcntl (outchannel, F_SETFL, O_NONBLOCK);
-#else
-#ifdef O_NDELAY
-  fcntl (inchannel, F_SETFL, O_NDELAY);
-  fcntl (outchannel, F_SETFL, O_NDELAY);
-#endif
-#endif
+      fcntl (pty_fd, F_SETFL, O_NONBLOCK);
 
-  /* Record this as an active process, with its channels.
-     As a result, child_setup will close Emacs's side of the pipes.  */
-  chan_process[inchannel] = process;
-  XPROCESS (process)->infd = inchannel;
-  XPROCESS (process)->outfd = outchannel;
+      /* Record this as an active process, with its channels.
+         As a result, child_setup will close Emacs's side of the pipes.  */
+      chan_process[pty_fd] = process;
+      p->infd = pty_fd;
+      p->outfd = pty_fd;
 
-  /* Previously we recorded the tty descriptor used in the subprocess.
-     It was only used for getting the foreground tty process, so now
-     we just reopen the device (see emacs_get_tty_pgrp) as this is
-     more portable (see USG_SUBTTY_WORKS above).  */
+      /* Previously we recorded the tty descriptor used in the subprocess.
+         It was only used for getting the foreground tty process, so now
+         we just reopen the device (see emacs_get_tty_pgrp) as this is
+         more portable (see USG_SUBTTY_WORKS above).  */
 
-  XPROCESS (process)->pty_flag = pty_flag;
-  XPROCESS (process)->status = Qrun;
-  setup_process_coding_systems (process);
+      p->pty_flag = 1;
+      pset_status (p, Qrun);
+      setup_process_coding_systems (process);
 
-  FD_SET (inchannel, &input_wait_mask);
-  FD_SET (inchannel, &non_keyboard_wait_mask);
-  if (inchannel > max_process_desc)
-    max_process_desc = inchannel;
+      FD_SET (pty_fd, &input_wait_mask);
+      FD_SET (pty_fd, &non_keyboard_wait_mask);
+      if (pty_fd > max_process_desc)
+        max_process_desc = pty_fd;
 
-  XPROCESS (process)->pid = -2;
-#ifdef HAVE_PTYS
-  if (pty_flag)
-    XPROCESS (process)->tty_name = build_string (pty_name);
-  else
-#endif
-    XPROCESS (process)->tty_name = Qnil;
+      pset_tty_name (p, build_string (pty_name));
+    }
+
+  p->pid = -2;
 }
 
 
@@ -2230,7 +2178,7 @@ Returns nil upon error setting address, ADDRESS otherwise.  */)
   channel = XPROCESS (process)->infd;
 
   len = get_lisp_to_sockaddr_size (address, &family);
-  if (datagram_address[channel].len != len)
+  if (len == 0 || datagram_address[channel].len != len)
     return Qnil;
   conv_lisp_to_sockaddr (family, address, datagram_address[channel].sa, len);
   return address;
@@ -2365,8 +2313,12 @@ set_socket_option (int s, Lisp_Object opt, Lisp_Object val)
     }
 
   if (ret < 0)
-    report_file_error ("Cannot set network option",
-                       Fcons (opt, Fcons (val, Qnil)));
+    {
+      int setsockopt_errno = errno;
+      report_file_errno ("Cannot set network option", list2 (opt, val),
+                         setsockopt_errno);
+    }
+
   return (1 << sopt->optbit);
 }
 
@@ -2394,7 +2346,7 @@ OPTION is not a supported option, return nil instead; otherwise return t.  */)
 
   if (set_socket_option (s, option, value))
     {
-      p->childp = Fplist_put (p->childp, option, value);
+      pset_childp (p, Fplist_put (p->childp, option, value));
       return Qt;
     }
 
@@ -2498,16 +2450,6 @@ usage: (serial-process-configure &rest ARGS)  */)
   return Qnil;
 }
 
-/* Used by make-serial-process to recover from errors.  */
-static Lisp_Object
-make_serial_process_unwind (Lisp_Object proc)
-{
-  if (!PROCESSP (proc))
-    abort ();
-  remove_process (proc);
-  return Qnil;
-}
-
 DEFUN ("make-serial-process", Fmake_serial_process, Smake_serial_process,
        0, MANY, 0,
        doc: /* Create and return a serial port process.
@@ -2589,7 +2531,7 @@ usage:  (make-serial-process &rest ARGS)  */)
   struct gcpro gcpro1;
   Lisp_Object name, buffer;
   Lisp_Object tem, val;
-  ptrdiff_t specpdl_count = -1;
+  ptrdiff_t specpdl_count;
 
   if (nargs == 0)
     return Qnil;
@@ -2613,10 +2555,11 @@ usage:  (make-serial-process &rest ARGS)  */)
   CHECK_STRING (name);
   proc = make_process (name);
   specpdl_count = SPECPDL_INDEX ();
-  record_unwind_protect (make_serial_process_unwind, proc);
+  record_unwind_protect (remove_process, proc);
   p = XPROCESS (proc);
 
-  fd = serial_open (SSDATA (port));
+  fd = serial_open (port);
+  p->open_fd[SUBPROCESS_STDIN] = fd;
   p->infd = fd;
   p->outfd = fd;
   if (fd > max_process_desc)
@@ -2627,19 +2570,19 @@ usage:  (make-serial-process &rest ARGS)  */)
   if (NILP (buffer))
     buffer = name;
   buffer = Fget_buffer_create (buffer);
-  p->buffer = buffer;
-
-  p->childp = contact;
-  p->plist = Fcopy_sequence (Fplist_get (contact, QCplist));
-  p->type = Qserial;
-  p->sentinel = Fplist_get (contact, QCsentinel);
-  p->filter = Fplist_get (contact, QCfilter);
-  p->log = Qnil;
+  pset_buffer (p, buffer);
+
+  pset_childp (p, contact);
+  pset_plist (p, Fcopy_sequence (Fplist_get (contact, QCplist)));
+  pset_type (p, Qserial);
+  pset_sentinel (p, Fplist_get (contact, QCsentinel));
+  pset_filter (p, Fplist_get (contact, QCfilter));
+  pset_log (p, Qnil);
   if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
     p->kill_without_query = 1;
   if (tem = Fplist_get (contact, QCstop), !NILP (tem))
-    p->command = Qt;
-  p->pty_flag = 0;
+    pset_command (p, Qt);
+  eassert (! p->pty_flag);
 
   if (!EQ (p->command, Qt))
     {
@@ -2670,7 +2613,7 @@ usage:  (make-serial-process &rest ARGS)  */)
   else if ((!NILP (buffer) && NILP (BVAR (XBUFFER (buffer), enable_multibyte_characters)))
            || (NILP (buffer) && NILP (BVAR (&buffer_defaults, enable_multibyte_characters))))
     val = Qnil;
-  p->decode_coding_system = val;
+  pset_decode_coding_system (p, val);
 
   val = Qnil;
   if (!NILP (tem))
@@ -2684,12 +2627,12 @@ usage:  (make-serial-process &rest ARGS)  */)
   else if ((!NILP (buffer) && NILP (BVAR (XBUFFER (buffer), enable_multibyte_characters)))
            || (NILP (buffer) && NILP (BVAR (&buffer_defaults, enable_multibyte_characters))))
     val = Qnil;
-  p->encode_coding_system = val;
+  pset_encode_coding_system (p, val);
 
   setup_process_coding_systems (proc);
-  p->decoding_buf = empty_unibyte_string;
+  pset_decoding_buf (p, empty_unibyte_string);
   p->decoding_carryover = 0;
-  p->encoding_buf = empty_unibyte_string;
+  pset_encoding_buf (p, empty_unibyte_string);
   p->inherit_coding_system_flag
     = !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
 
@@ -2895,8 +2838,9 @@ usage: (make-network-process &rest ARGS)  */)
   Lisp_Object tem;
   Lisp_Object name, buffer, host, service, address;
   Lisp_Object filter, sentinel;
-  int is_non_blocking_client = 0;
-  int is_server = 0, backlog = 5;
+  bool is_non_blocking_client = 0;
+  bool is_server = 0;
+  int backlog = 5;
   int socktype;
   int family = -1;
 
@@ -2933,13 +2877,9 @@ usage: (make-network-process &rest ARGS)  */)
     {
       /* Don't support network sockets when non-blocking mode is
          not available, since a blocked Emacs is not useful.  */
-#if !defined (O_NONBLOCK) && !defined (O_NDELAY)
-      error ("Network servers not supported");
-#else
       is_server = 1;
       if (TYPE_RANGED_INTEGERP (int, tem))
         backlog = XINT (tem);
-#endif
     }
 
   /* Make QCaddress an alias for :local (server) or :remote (client).  */
@@ -3037,7 +2977,9 @@ usage: (make-network-process &rest ARGS)  */)
       CHECK_STRING (service);
       memset (&address_un, 0, sizeof address_un);
       address_un.sun_family = AF_LOCAL;
-      strncpy (address_un.sun_path, SSDATA (service), sizeof address_un.sun_path);
+      if (sizeof address_un.sun_path <= SBYTES (service))
+        error ("Service name too long");
+      strcpy (address_un.sun_path, SSDATA (service));
       ai.ai_addr = (struct sockaddr *) &address_un;
       ai.ai_addrlen = sizeof address_un;
       goto open_socket;
@@ -3050,7 +2992,7 @@ usage: (make-network-process &rest ARGS)  */)
 #ifdef POLL_FOR_INPUT
   if (socktype != SOCK_DGRAM)
     {
-      record_unwind_protect (unwind_stop_other_atimers, Qnil);
+      record_unwind_protect_void (run_all_atimers);
       bind_polling_period (10);
     }
 #endif
@@ -3182,7 +3124,8 @@ usage: (make-network-process &rest ARGS)  */)
     retry_connect:
 #endif
 
-      s = socket (lres->ai_family, lres->ai_socktype, lres->ai_protocol);
+      s = socket (lres->ai_family, lres->ai_socktype | SOCK_CLOEXEC,
+                  lres->ai_protocol);
       if (s < 0)
         {
           xerrno = errno;
@@ -3197,11 +3140,7 @@ usage: (make-network-process &rest ARGS)  */)
 #ifdef NON_BLOCKING_CONNECT
       if (is_non_blocking_client)
         {
-#ifdef O_NONBLOCK
           ret = fcntl (s, F_SETFL, O_NONBLOCK);
-#else
-          ret = fcntl (s, F_SETFL, O_NDELAY);
-#endif
           if (ret < 0)
             {
               xerrno = errno;
@@ -3213,7 +3152,7 @@ usage: (make-network-process &rest ARGS)  */)
 #endif
 
       /* Make us close S if quit.  */
-      record_unwind_protect (close_file_unwind, make_number (s));
+      record_unwind_protect_int (close_file_unwind, s);
 
       /* Parse network options in the arg list.
          We simply ignore anything which isn't a known option (including other keywords).
@@ -3290,33 +3229,31 @@ usage: (make-network-process &rest ARGS)  */)
         {
           /* Unlike most other syscalls connect() cannot be called
              again.  (That would return EALREADY.)  The proper way to
-             wait for completion is select(). */
+             wait for completion is pselect(). */
           int sc;
           socklen_t len;
-          SELECT_TYPE fdset;
+          fd_set fdset;
         retry_select:
           FD_ZERO (&fdset);
           FD_SET (s, &fdset);
           QUIT;
-          sc = select (s + 1, (SELECT_TYPE *)0, &fdset, (SELECT_TYPE *)0,
-                       (EMACS_TIME *)0);
+          sc = pselect (s + 1, NULL, &fdset, NULL, NULL, NULL);
           if (sc == -1)
             {
               if (errno == EINTR)
                 goto retry_select;
               else
-                report_file_error ("select failed", Qnil);
+                report_file_error ("Failed select", Qnil);
             }
           eassert (sc > 0);
 
           len = sizeof xerrno;
           eassert (FD_ISSET (s, &fdset));
-          if (getsockopt (s, SOL_SOCKET, SO_ERROR, &xerrno, &len) == -1)
-            report_file_error ("getsockopt failed", Qnil);
+          if (getsockopt (s, SOL_SOCKET, SO_ERROR, &xerrno, &len) < 0)
+            report_file_error ("Failed getsockopt", Qnil);
           if (xerrno)
-            errno = xerrno, report_file_error ("error during connect", Qnil);
-          else
-            break;
+            report_file_errno ("Failed connect", Qnil, xerrno);
+          break;
         }
 #endif /* !WINDOWSNT */
 
@@ -3339,8 +3276,8 @@ usage: (make-network-process &rest ARGS)  */)
       if (socktype == SOCK_DGRAM)
         {
           if (datagram_address[s].sa)
-            abort ();
-          datagram_address[s].sa = (struct sockaddr *) xmalloc (lres->ai_addrlen);
+            emacs_abort ();
+          datagram_address[s].sa = xmalloc (lres->ai_addrlen);
           datagram_address[s].len = lres->ai_addrlen;
           if (is_server)
             {
@@ -3350,7 +3287,8 @@ usage: (make-network-process &rest ARGS)  */)
                 {
                   int rfamily, rlen;
                   rlen = get_lisp_to_sockaddr_size (remote, &rfamily);
-                  if (rfamily == lres->ai_family && rlen == lres->ai_addrlen)
+                  if (rlen != 0 && rfamily == lres->ai_family
+                      && rlen == lres->ai_addrlen)
                     conv_lisp_to_sockaddr (rfamily, remote,
                                            datagram_address[s].sa, rlen);
                 }
@@ -3378,18 +3316,12 @@ usage: (make-network-process &rest ARGS)  */)
 #ifdef HAVE_GETADDRINFO
   if (res != &ai)
     {
-      BLOCK_INPUT;
+      block_input ();
       freeaddrinfo (res);
-      UNBLOCK_INPUT;
+      unblock_input ();
     }
 #endif
 
-  /* Discard the unwind protect for closing S, if any.  */
-  specpdl_ptr = specpdl + count1;
-
-  /* Unwind bind_polling_period and request_sigio.  */
-  unbind_to (count, Qnil);
-
   if (s < 0)
     {
       /* If non-blocking got this far - and failed - assume non-blocking is
@@ -3399,11 +3331,10 @@ usage: (make-network-process &rest ARGS)  */)
       if (is_non_blocking_client)
           return Qnil;
 
-      errno = xerrno;
-      if (is_server)
-        report_file_error ("make server process failed", contact);
-      else
-        report_file_error ("make client process failed", contact);
+      report_file_errno ((is_server
+                          ? "make server process failed"
+                          : "make client process failed"),
+                         contact, xerrno);
     }
 
   inch = s;
@@ -3415,33 +3346,36 @@ usage: (make-network-process &rest ARGS)  */)
 
   chan_process[inch] = proc;
 
-#ifdef O_NONBLOCK
   fcntl (inch, F_SETFL, O_NONBLOCK);
-#else
-#ifdef O_NDELAY
-  fcntl (inch, F_SETFL, O_NDELAY);
-#endif
-#endif
 
   p = XPROCESS (proc);
 
-  p->childp = contact;
-  p->plist = Fcopy_sequence (Fplist_get (contact, QCplist));
-  p->type = Qnetwork;
+  pset_childp (p, contact);
+  pset_plist (p, Fcopy_sequence (Fplist_get (contact, QCplist)));
+  pset_type (p, Qnetwork);
 
-  p->buffer = buffer;
-  p->sentinel = sentinel;
-  p->filter = filter;
-  p->log = Fplist_get (contact, QClog);
+  pset_buffer (p, buffer);
+  pset_sentinel (p, sentinel);
+  pset_filter (p, filter);
+  pset_log (p, Fplist_get (contact, QClog));
   if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
     p->kill_without_query = 1;
   if ((tem = Fplist_get (contact, QCstop), !NILP (tem)))
-    p->command = Qt;
+    pset_command (p, Qt);
   p->pid = 0;
+
+  p->open_fd[SUBPROCESS_STDIN] = inch;
   p->infd  = inch;
   p->outfd = outch;
+
+  /* Discard the unwind protect for closing S, if any.  */
+  specpdl_ptr = specpdl + count1;
+
+  /* Unwind bind_polling_period and request_sigio.  */
+  unbind_to (count, Qnil);
+
   if (is_server && socktype != SOCK_DGRAM)
-    p->status = Qlisten;
+    pset_status (p, Qlisten);
 
   /* Make the process marker point into the process buffer (if any).  */
   if (BUFFERP (buffer))
@@ -3455,7 +3389,7 @@ usage: (make-network-process &rest ARGS)  */)
       /* We may get here if connect did succeed immediately.  However,
          in that case, we still need to signal this like a non-blocking
          connection.  */
-      p->status = Qconnect;
+      pset_status (p, Qconnect);
       if (!FD_ISSET (inch, &connect_wait_mask))
         {
           FD_SET (inch, &connect_wait_mask);
@@ -3522,7 +3456,7 @@ usage: (make-network-process &rest ARGS)  */)
         else
           val = Qnil;
       }
-    p->decode_coding_system = val;
+    pset_decode_coding_system (p, val);
 
     if (!NILP (tem))
       {
@@ -3556,13 +3490,13 @@ usage: (make-network-process &rest ARGS)  */)
         else
           val = Qnil;
       }
-    p->encode_coding_system = val;
+    pset_encode_coding_system (p, val);
   }
   setup_process_coding_systems (proc);
 
-  p->decoding_buf = empty_unibyte_string;
+  pset_decoding_buf (p, empty_unibyte_string);
   p->decoding_carryover = 0;
-  p->encoding_buf = empty_unibyte_string;
+  pset_encoding_buf (p, empty_unibyte_string);
 
   p->inherit_coding_system_flag
     = !(!NILP (tem) || NILP (buffer) || !inherit_process_coding_system);
@@ -3586,12 +3520,15 @@ format; see the description of ADDRESS in `make-network-process'.  */)
   struct ifreq *ifreq;
   void *buf = NULL;
   ptrdiff_t buf_size = 512;
-  int s, i;
+  int s;
   Lisp_Object res;
+  ptrdiff_t count;
 
-  s = socket (AF_INET, SOCK_STREAM, 0);
+  s = socket (AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
   if (s < 0)
     return Qnil;
+  count = SPECPDL_INDEX ();
+  record_unwind_protect_int (close_file_unwind, s);
 
   do
     {
@@ -3600,16 +3537,14 @@ format; see the description of ADDRESS in `make-network-process'.  */)
       ifconf.ifc_len = buf_size;
       if (ioctl (s, SIOCGIFCONF, &ifconf))
         {
-          close (s);
+          emacs_close (s);
           xfree (buf);
           return Qnil;
         }
     }
   while (ifconf.ifc_len == buf_size);
 
-  close (s);
-
-  res = Qnil;
+  res = unbind_to (count, Qnil);
   ifreq = ifconf.ifc_req;
   while ((char *) ifreq < (char *) ifconf.ifc_req + ifconf.ifc_len)
     {
@@ -3624,7 +3559,6 @@ format; see the description of ADDRESS in `make-network-process'.  */)
       int len = sizeof (*ifreq);
 #endif
       char namebuf[sizeof (ifq->ifr_name) + 1];
-      i += len;
       ifreq = (struct ifreq *) ((char *) ifreq + len);
 
       if (ifq->ifr_addr.sa_family != AF_INET)
@@ -3734,7 +3668,8 @@ FLAGS is the current flags of the interface.  */)
   Lisp_Object res = Qnil;
   Lisp_Object elt;
   int s;
-  int any = 0;
+  bool any = 0;
+  ptrdiff_t count;
 #if (! (defined SIOCGIFHWADDR && defined HAVE_STRUCT_IFREQ_IFR_HWADDR)  \
      && defined HAVE_GETIFADDRS && defined LLADDR)
   struct ifaddrs *ifap;
@@ -3742,12 +3677,15 @@ FLAGS is the current flags of the interface.  */)
 
   CHECK_STRING (ifname);
 
-  memset (rq.ifr_name, 0, sizeof rq.ifr_name);
-  strncpy (rq.ifr_name, SSDATA (ifname), sizeof (rq.ifr_name));
+  if (sizeof rq.ifr_name <= SBYTES (ifname))
+    error ("interface name too long");
+  strcpy (rq.ifr_name, SSDATA (ifname));
 
-  s = socket (AF_INET, SOCK_STREAM, 0);
+  s = socket (AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
   if (s < 0)
     return Qnil;
+  count = SPECPDL_INDEX ();
+  record_unwind_protect_int (close_file_unwind, s);
 
   elt = Qnil;
 #if defined (SIOCGIFFLAGS) && defined (HAVE_STRUCT_IFREQ_IFR_FLAGS)
@@ -3864,9 +3802,7 @@ FLAGS is the current flags of the interface.  */)
 #endif
   res = Fcons (elt, res);
 
-  close (s);
-
-  return any ? res : Qnil;
+  return unbind_to (count, any ? res : Qnil);
 }
 #endif
 #endif  /* defined (HAVE_NET_IF_H) */
@@ -3876,17 +3812,15 @@ FLAGS is the current flags of the interface.  */)
 static void
 deactivate_process (Lisp_Object proc)
 {
-  register int inchannel, outchannel;
-  register struct Lisp_Process *p = XPROCESS (proc);
+  int inchannel;
+  struct Lisp_Process *p = XPROCESS (proc);
+  int i;
 
 #ifdef HAVE_GNUTLS
   /* Delete GnuTLS structures in PROC, if any.  */
   emacs_gnutls_deinit (proc);
 #endif /* HAVE_GNUTLS */
 
-  inchannel  = p->infd;
-  outchannel = p->outfd;
-
 #ifdef ADAPTIVE_READ_BUFFERING
   if (p->read_output_delay > 0)
     {
@@ -3897,14 +3831,14 @@ deactivate_process (Lisp_Object proc)
     }
 #endif
 
+  /* Beware SIGCHLD hereabouts. */
+
+  for (i = 0; i < PROCESS_OPEN_FDS; i++)
+    close_process_fd (&p->open_fd[i]);
+
+  inchannel = p->infd;
   if (inchannel >= 0)
     {
-      /* Beware SIGCHLD hereabouts. */
-      flush_pending_output (inchannel);
-      emacs_close (inchannel);
-      if (outchannel >= 0 && outchannel != inchannel)
-        emacs_close (outchannel);
-
       p->infd  = -1;
       p->outfd = -1;
 #ifdef DATAGRAM_SOCKETS
@@ -3924,18 +3858,19 @@ deactivate_process (Lisp_Object proc)
           FD_CLR (inchannel, &connect_wait_mask);
           FD_CLR (inchannel, &write_mask);
           if (--num_pending_connects < 0)
-            abort ();
+            emacs_abort ();
         }
 #endif
       if (inchannel == max_process_desc)
         {
-          int i;
           /* We just closed the highest-numbered process input descriptor,
              so recompute the highest-numbered one now.  */
-          max_process_desc = 0;
-          for (i = 0; i < MAXDESC; i++)
-            if (!NILP (chan_process[i]))
-              max_process_desc = i;
+          int i = inchannel;
+          do
+            i--;
+          while (0 <= i && NILP (chan_process[i]));
+
+          max_process_desc = i;
         }
     }
 }
@@ -3960,7 +3895,8 @@ If JUST-THIS-ONE is an integer, don't run any timers either.
 Return non-nil if we received any output before the timeout expired.  */)
   (register Lisp_Object process, Lisp_Object seconds, Lisp_Object millisec, Lisp_Object just_this_one)
 {
-  int secs = -1, usecs = 0;
+  intmax_t secs;
+  int nsecs;
 
   if (! NILP (process))
     CHECK_PROCESS (process);
@@ -3979,17 +3915,36 @@ Return non-nil if we received any output before the timeout expired.  */)
         }
     }
 
+  secs = 0;
+  nsecs = -1;
+
   if (!NILP (seconds))
     {
-      double duration = extract_float (seconds);
-      if (0 < duration)
-        duration_to_sec_usec (duration, &secs, &usecs);
+      if (INTEGERP (seconds))
+        {
+          if (XINT (seconds) > 0)
+            {
+              secs = XINT (seconds);
+              nsecs = 0;
+            }
+        }
+      else if (FLOATP (seconds))
+        {
+          if (XFLOAT_DATA (seconds) > 0)
+            {
+              struct timespec t = dtotimespec (XFLOAT_DATA (seconds));
+              secs = min (t.tv_sec, WAIT_READING_MAX);
+              nsecs = t.tv_nsec;
+            }
+        }
+      else
+        wrong_type_argument (Qnumberp, seconds);
     }
-  else if (!NILP (process))
-    secs = 0;
+  else if (! NILP (process))
+    nsecs = 0;
 
   return
-    (wait_reading_process_output (secs, usecs, 0, 0,
+    (wait_reading_process_output (secs, nsecs, 0, 0,
                                   Qnil,
                                   !NILP (process) ? XPROCESS (process) : NULL,
                                   NILP (just_this_one) ? 0 :
@@ -3999,7 +3954,7 @@ Return non-nil if we received any output before the timeout expired.  */)
 
 /* Accept a connection for server process SERVER on CHANNEL.  */
 
-static int connect_counter = 0;
+static EMACS_INT connect_counter = 0;
 
 static void
 server_accept_connection (Lisp_Object server, int channel)
@@ -4020,8 +3975,9 @@ server_accept_connection (Lisp_Object server, int channel)
 #endif
   } saddr;
   socklen_t len = sizeof saddr;
+  ptrdiff_t count;
 
-  s = accept (channel, &saddr.sa, &len);
+  s = accept4 (channel, &saddr.sa, &len, SOCK_CLOEXEC);
 
   if (s < 0)
     {
@@ -4042,6 +3998,9 @@ server_accept_connection (Lisp_Object server, int channel)
       return;
     }
 
+  count = SPECPDL_INDEX ();
+  record_unwind_protect_int (close_file_unwind, s);
+
   connect_counter++;
 
   /* Setup a new process to handle the connection.  */
@@ -4105,7 +4064,8 @@ server_accept_connection (Lisp_Object server, int channel)
      process name of the server process concatenated with the caller
      identification.  */
 
-  if (!NILP (ps->filter) && !EQ (ps->filter, Qt))
+  if (!(EQ (ps->filter, Qinternal_default_process_filter)
+        || EQ (ps->filter, Qt)))
     buffer = Qnil;
   else
     {
@@ -4129,13 +4089,7 @@ server_accept_connection (Lisp_Object server, int channel)
 
   chan_process[s] = proc;
 
-#ifdef O_NONBLOCK
   fcntl (s, F_SETFL, O_NONBLOCK);
-#else
-#ifdef O_NDELAY
-  fcntl (s, F_SETFL, O_NDELAY);
-#endif
-#endif
 
   p = XPROCESS (proc);
 
@@ -4154,18 +4108,23 @@ server_accept_connection (Lisp_Object server, int channel)
                           conv_sockaddr_to_lisp (&saddr.sa, len));
 #endif
 
-  p->childp = contact;
-  p->plist = Fcopy_sequence (ps->plist);
-  p->type = Qnetwork;
+  pset_childp (p, contact);
+  pset_plist (p, Fcopy_sequence (ps->plist));
+  pset_type (p, Qnetwork);
 
-  p->buffer = buffer;
-  p->sentinel = ps->sentinel;
-  p->filter = ps->filter;
-  p->command = Qnil;
+  pset_buffer (p, buffer);
+  pset_sentinel (p, ps->sentinel);
+  pset_filter (p, ps->filter);
+  pset_command (p, Qnil);
   p->pid = 0;
+
+  /* Discard the unwind protect for closing S.  */
+  specpdl_ptr = specpdl + count;
+
+  p->open_fd[SUBPROCESS_STDIN] = s;
   p->infd  = s;
   p->outfd = s;
-  p->status = Qrun;
+  pset_status (p, Qrun);
 
   /* Client processes for accepted connections are not stopped initially.  */
   if (!EQ (p->filter, Qt))
@@ -4180,15 +4139,15 @@ server_accept_connection (Lisp_Object server, int channel)
   /* Setup coding system for new process based on server process.
      This seems to be the proper thing to do, as the coding system
      of the new process should reflect the settings at the time the
-     server socket was opened; not the current settings. */
+     server socket was opened; not the current settings.  */
 
-  p->decode_coding_system = ps->decode_coding_system;
-  p->encode_coding_system = ps->encode_coding_system;
+  pset_decode_coding_system (p, ps->decode_coding_system);
+  pset_encode_coding_system (p, ps->encode_coding_system);
   setup_process_coding_systems (proc);
 
-  p->decoding_buf = empty_unibyte_string;
+  pset_decoding_buf (p, empty_unibyte_string);
   p->decoding_carryover = 0;
-  p->encoding_buf = empty_unibyte_string;
+  pset_encoding_buf (p, empty_unibyte_string);
 
   p->inherit_coding_system_flag
     = (NILP (buffer) ? 0 : ps->inherit_coding_system_flag);
@@ -4199,11 +4158,10 @@ server_accept_connection (Lisp_Object server, int channel)
                       (STRINGP (host) ? host : build_string ("-")),
                       build_string ("\n")));
 
-  if (!NILP (p->sentinel))
-    exec_sentinel (proc,
-                   concat3 (build_string ("open from "),
-                            (STRINGP (host) ? host : build_string ("-")),
-                            build_string ("\n")));
+  exec_sentinel (proc,
+                 concat3 (build_string ("open from "),
+                          (STRINGP (host) ? host : build_string ("-")),
+                          build_string ("\n")));
 }
 
 /* This variable is different from waiting_for_input in keyboard.c.
@@ -4217,11 +4175,10 @@ server_accept_connection (Lisp_Object server, int channel)
    when not inside wait_reading_process_output.  */
 static int waiting_for_user_input_p;
 
-static Lisp_Object
-wait_reading_process_output_unwind (Lisp_Object data)
+static void
+wait_reading_process_output_unwind (int data)
 {
-  waiting_for_user_input_p = XINT (data);
-  return Qnil;
+  waiting_for_user_input_p = data;
 }
 
 /* This is here so breakpoints can be put on it.  */
@@ -4230,42 +4187,27 @@ wait_reading_process_output_1 (void)
 {
 }
 
-/* Use a wrapper around select to work around a bug in gdb 5.3.
-   Normally, the wrapper is optimized away by inlining.
-
-   If emacs is stopped inside select, the gdb backtrace doesn't
-   show the function which called select, so it is practically
-   impossible to step through wait_reading_process_output.  */
-
-#ifndef select
-static inline int
-select_wrapper (int n, fd_set *rfd, fd_set *wfd, fd_set *xfd, struct timeval *tmo)
-{
-  return select (n, rfd, wfd, xfd, tmo);
-}
-#define select select_wrapper
-#endif
-
 /* Read and dispose of subprocess output while waiting for timeout to
    elapse and/or keyboard input to be available.
 
    TIME_LIMIT is:
-     timeout in seconds, or
-     zero for no limit, or
-     -1 means gobble data immediately available but don't wait for any.
+     timeout in seconds
+     If negative, gobble data immediately available but don't wait for any.
 
-   MICROSECS is:
-     an additional duration to wait, measured in microseconds.
-     If this is nonzero and time_limit is 0, then the timeout
-     consists of MICROSECS only.
+   NSECS is:
+     an additional duration to wait, measured in nanoseconds
+     If TIME_LIMIT is zero, then:
+       If NSECS == 0, there is no limit.
+       If NSECS > 0, the timeout consists of NSECS only.
+       If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
 
-   READ_KBD is a lisp value:
+   READ_KBD is:
      0 to ignore keyboard input, or
      1 to return when input is available, or
      -1 meaning caller will actually read the input, so don't throw to
        the quit handler, or
 
-   DO_DISPLAY != 0 means redisplay should be done to show subprocess
+   DO_DISPLAY means redisplay should be done to show subprocess
      output that arrives.
 
    If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
@@ -4275,7 +4217,7 @@ select_wrapper (int n, fd_set *rfd, fd_set *wfd, fd_set *xfd, struct timeval *tm
      process.  The return value is true if we read some input from
      that process.
 
-   If JUST_WAIT_PROC is non-nil, handle only output from WAIT_PROC
+   If JUST_WAIT_PROC is nonzero, handle only output from WAIT_PROC
      (suspending output from other processes).  A negative value
      means don't run any timers either.
 
@@ -4283,86 +4225,93 @@ select_wrapper (int n, fd_set *rfd, fd_set *wfd, fd_set *xfd, struct timeval *tm
      received input from that process before the timeout elapsed.
    Otherwise, return true if we received input from any process.  */
 
-int
-wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
-                             int do_display,
+bool
+wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
+                             bool do_display,
                              Lisp_Object wait_for_cell,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
 {
-  register int channel, nfds;
-  SELECT_TYPE Available;
-  SELECT_TYPE Writeok;
-  int check_write;
-  int check_delay, no_avail;
+  int channel, nfds;
+  fd_set Available;
+  fd_set Writeok;
+  bool check_write;
+  int check_delay;
+  bool no_avail;
   int xerrno;
   Lisp_Object proc;
-  EMACS_TIME timeout, end_time;
+  struct timespec timeout, end_time;
   int wait_channel = -1;
-  int got_some_input = 0;
+  bool got_some_input = 0;
   ptrdiff_t count = SPECPDL_INDEX ();
 
   FD_ZERO (&Available);
   FD_ZERO (&Writeok);
 
-  if (time_limit == 0 && microsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
-      && !(CONSP (wait_proc->status) && EQ (XCAR (wait_proc->status), Qexit)))
-    message ("Blocking call to accept-process-output with quit inhibited!!");
+  if (time_limit == 0 && nsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
+      && !(CONSP (wait_proc->status)
+           && EQ (XCAR (wait_proc->status), Qexit)))
+    message1 ("Blocking call to accept-process-output with quit inhibited!!");
 
   /* If wait_proc is a process to watch, set wait_channel accordingly.  */
   if (wait_proc != NULL)
     wait_channel = wait_proc->infd;
 
-  record_unwind_protect (wait_reading_process_output_unwind,
-                         make_number (waiting_for_user_input_p));
+  record_unwind_protect_int (wait_reading_process_output_unwind,
+                             waiting_for_user_input_p);
   waiting_for_user_input_p = read_kbd;
 
+  if (time_limit < 0)
+    {
+      time_limit = 0;
+      nsecs = -1;
+    }
+  else if (TYPE_MAXIMUM (time_t) < time_limit)
+    time_limit = TYPE_MAXIMUM (time_t);
+
   /* Since we may need to wait several times,
      compute the absolute time to return at.  */
-  if (time_limit || microsecs)
+  if (time_limit || nsecs > 0)
     {
-      EMACS_GET_TIME (end_time);
-      EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
-      EMACS_ADD_TIME (end_time, end_time, timeout);
+      timeout = make_timespec (time_limit, nsecs);
+      end_time = timespec_add (current_timespec (), timeout);
     }
 
   while (1)
     {
-      int timeout_reduced_for_timers = 0;
+      bool timeout_reduced_for_timers = 0;
 
       /* If calling from keyboard input, do not quit
          since we want to return C-g as an input character.
          Otherwise, do pending quit if requested.  */
       if (read_kbd >= 0)
         QUIT;
-#ifdef SYNC_INPUT
-      else
+      else if (pending_signals)
         process_pending_signals ();
-#endif
 
       /* Exit now if the cell we're waiting for became non-nil.  */
       if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
         break;
 
-      /* Compute time from now till when time limit is up */
-      /* Exit if already run out */
-      if (time_limit == -1)
+      /* Compute time from now till when time limit is up.  */
+      /* Exit if already run out.  */
+      if (nsecs < 0)
         {
-          /* -1 specified for timeout means
+          /* A negative timeout means
              gobble output available now
              but don't wait at all. */
 
-          EMACS_SET_SECS_USECS (timeout, 0, 0);
+          timeout = make_timespec (0, 0);
         }
-      else if (time_limit || microsecs)
+      else if (time_limit || nsecs > 0)
         {
-          EMACS_GET_TIME (timeout);
-          EMACS_SUB_TIME (timeout, end_time, timeout);
-          if (EMACS_TIME_NEG_P (timeout))
+          struct timespec now = current_timespec ();
+          if (timespec_cmp (end_time, now) <= 0)
             break;
+          timeout = timespec_sub (end_time, now);
         }
       else
         {
-          EMACS_SET_SECS_USECS (timeout, 100000, 0);
+          timeout = make_timespec (100000, 0);
         }
 
       /* Normally we run timers here.
@@ -4372,11 +4321,11 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       if (NILP (wait_for_cell)
           && just_wait_proc >= 0)
         {
-          EMACS_TIME timer_delay;
+          struct timespec timer_delay;
 
           do
             {
-              int old_timers_run = timers_run;
+              unsigned old_timers_run = timers_run;
               struct buffer *old_buffer = current_buffer;
               Lisp_Object old_window = selected_window;
 
@@ -4404,21 +4353,22 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               && requeued_events_pending_p ())
             break;
 
-          if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
+          /* A negative timeout means do not wait at all.  */
+          if (nsecs >= 0)
             {
-              EMACS_TIME difference;
-              EMACS_SUB_TIME (difference, timer_delay, timeout);
-              if (EMACS_TIME_NEG_P (difference))
+              if (timespec_valid_p (timer_delay))
                 {
-                  timeout = timer_delay;
-                  timeout_reduced_for_timers = 1;
+                  if (timespec_cmp (timer_delay, timeout) < 0)
+                    {
+                      timeout = timer_delay;
+                      timeout_reduced_for_timers = 1;
+                    }
+                }
+              else
+                {
+                  /* This is so a breakpoint can be put here.  */
+                  wait_reading_process_output_1 ();
                 }
-            }
-          /* If time_limit is -1, we are not going to wait at all.  */
-          else if (time_limit != -1)
-            {
-              /* This is so a breakpoint can be put here.  */
-              wait_reading_process_output_1 ();
             }
         }
 
@@ -4437,8 +4387,8 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
          timeout to get our attention.  */
       if (update_tick != process_tick)
         {
-          SELECT_TYPE Atemp;
-          SELECT_TYPE Ctemp;
+          fd_set Atemp;
+          fd_set Ctemp;
 
           if (kbd_on_hold_p ())
             FD_ZERO (&Atemp);
@@ -4446,15 +4396,15 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
             Atemp = input_wait_mask;
           Ctemp = write_mask;
 
-          EMACS_SET_SECS_USECS (timeout, 0, 0);
-          if ((select (max (max_process_desc, max_input_desc) + 1,
-                       &Atemp,
+          timeout = make_timespec (0, 0);
+          if ((pselect (max (max_process_desc, max_input_desc) + 1,
+                        &Atemp,
 #ifdef NON_BLOCKING_CONNECT
-                       (num_pending_connects > 0 ? &Ctemp : (SELECT_TYPE *)0),
+                        (num_pending_connects > 0 ? &Ctemp : NULL),
 #else
-                       (SELECT_TYPE *)0,
+                        NULL,
 #endif
-                       (SELECT_TYPE *)0, &timeout)
+                        NULL, &timeout, NULL)
                <= 0))
             {
               /* It's okay for us to do this and then continue with
@@ -4473,7 +4423,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
           && ! EQ (wait_proc->status, Qrun)
           && ! EQ (wait_proc->status, Qconnect))
         {
-          int nread, total_nread = 0;
+          bool read_some_bytes = 0;
 
           clear_waiting_for_input ();
           XSETPROCESS (proc, wait_proc);
@@ -4481,30 +4431,21 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
           /* Read data from the process, until we exhaust it.  */
           while (wait_proc->infd >= 0)
             {
-              nread = read_process_output (proc, wait_proc->infd);
+              int nread = read_process_output (proc, wait_proc->infd);
 
               if (nread == 0)
                 break;
 
-              if (0 < nread)
-                {
-                  total_nread += nread;
-                  got_some_input = 1;
-                }
-#ifdef EIO
-              else if (nread == -1 && EIO == errno)
-                break;
-#endif
-#ifdef EAGAIN
-              else if (nread == -1 && EAGAIN == errno)
+              if (nread > 0)
+                got_some_input = read_some_bytes = 1;
+              else if (nread == -1 && (errno == EIO || errno == EAGAIN))
                 break;
-#endif
 #ifdef EWOULDBLOCK
               else if (nread == -1 && EWOULDBLOCK == errno)
                 break;
 #endif
             }
-          if (total_nread > 0 && do_display)
+          if (read_some_bytes && do_display)
             redisplay_preserve_echo_area (10);
 
           break;
@@ -4577,9 +4518,9 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
              Vprocess_adaptive_read_buffering is nil.  */
           if (process_output_skip && check_delay > 0)
             {
-              int usecs = EMACS_USECS (timeout);
-              if (EMACS_SECS (timeout) > 0 || usecs > READ_OUTPUT_DELAY_MAX)
-                usecs = READ_OUTPUT_DELAY_MAX;
+              int nsecs = timeout.tv_nsec;
+              if (timeout.tv_sec > 0 || nsecs > READ_OUTPUT_DELAY_MAX)
+                nsecs = READ_OUTPUT_DELAY_MAX;
               for (channel = 0; check_delay > 0 && channel <= max_process_desc; channel++)
                 {
                   proc = chan_process[channel];
@@ -4594,25 +4535,26 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                         continue;
                       FD_CLR (channel, &Available);
                       XPROCESS (proc)->read_output_skip = 0;
-                      if (XPROCESS (proc)->read_output_delay < usecs)
-                        usecs = XPROCESS (proc)->read_output_delay;
+                      if (XPROCESS (proc)->read_output_delay < nsecs)
+                        nsecs = XPROCESS (proc)->read_output_delay;
                     }
                 }
-              EMACS_SET_SECS_USECS (timeout, 0, usecs);
+              timeout = make_timespec (0, nsecs);
               process_output_skip = 0;
             }
 #endif
-#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
-          nfds = xg_select
-#elif defined (HAVE_NS)
-          nfds = ns_select
+
+#if defined (HAVE_NS)
+          nfds = ns_select
+#elif defined (HAVE_GLIB)
+          nfds = xg_select
 #else
-          nfds = select
+          nfds = pselect
 #endif
             (max (max_process_desc, max_input_desc) + 1,
              &Available,
-             (check_write ? &Writeok : (SELECT_TYPE *)0),
-             (SELECT_TYPE *)0, &timeout);
+             (check_write ? &Writeok : 0),
+             NULL, &timeout, NULL);
 
 #ifdef HAVE_GNUTLS
           /* GnuTLS buffers data internally.  In lowat mode it leaves
@@ -4629,7 +4571,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                      the gnutls library -- 2.12.14 has been confirmed
                      to need it.  See
                      http://comments.gmane.org/gmane.emacs.devel/145074 */
-                  for (channel = 0; channel < MAXDESC; ++channel)
+                  for (channel = 0; channel < FD_SETSIZE; ++channel)
                     if (! NILP (chan_process[channel]))
                       {
                         struct Lisp_Process *p =
@@ -4670,30 +4612,17 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       /*  If we woke up due to SIGWINCH, actually change size now.  */
       do_pending_window_change (0);
 
-      if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
-        /* We wanted the full specified time, so return now.  */
+      if ((time_limit || nsecs) && nfds == 0 && ! timeout_reduced_for_timers)
+        /* We waited the full specified time, so return now.  */
         break;
       if (nfds < 0)
         {
           if (xerrno == EINTR)
             no_avail = 1;
           else if (xerrno == EBADF)
-            {
-#ifdef AIX
-              /* AIX doesn't handle PTY closure the same way BSD does.  On AIX,
-                 the child's closure of the pts gives the parent a SIGHUP, and
-                 the ptc file descriptor is automatically closed,
-                 yielding EBADF here or at select() call above.
-                 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
-                 in m/ibmrt-aix.h), and here we just ignore the select error.
-                 Cleanup occurs c/o status_notify after SIGCLD. */
-              no_avail = 1; /* Cannot depend on values returned */
-#else
-              abort ();
-#endif
-            }
+            emacs_abort ();
           else
-            error ("select error: %s", emacs_strerror (xerrno));
+            report_file_errno ("Failed select", Qnil, xerrno);
         }
 
       if (no_avail)
@@ -4702,31 +4631,16 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
           check_write = 0;
         }
 
-#if 0 /* When polling is used, interrupt_input is 0,
-         so get_input_pending should read the input.
-         So this should not be needed.  */
-      /* If we are using polling for input,
-         and we see input available, make it get read now.
-         Otherwise it might not actually get read for a second.
-         And on hpux, since we turn off polling in wait_reading_process_output,
-         it might never get read at all if we don't spend much time
-         outside of wait_reading_process_output.  */
-      if (read_kbd && interrupt_input
-          && keyboard_bit_set (&Available)
-          && input_polling_used ())
-        kill (getpid (), SIGALRM);
-#endif
-
       /* Check for keyboard input */
       /* If there is any, return immediately
          to give it higher priority than subprocesses */
 
       if (read_kbd != 0)
         {
-          int old_timers_run = timers_run;
+          unsigned old_timers_run = timers_run;
           struct buffer *old_buffer = current_buffer;
           Lisp_Object old_window = selected_window;
-          int leave = 0;
+          bool leave = 0;
 
           if (detect_input_pending_run_timers (do_display))
             {
@@ -4772,7 +4686,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
         break;
 
-#ifdef SIGIO
+#ifdef USABLE_SIGIO
       /* If we think we have keyboard input waiting, but didn't get SIGIO,
          go read it.  This can happen with X on BSD after logging out.
          In that case, there really is no input and no SIGIO,
@@ -4780,7 +4694,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 
       if (read_kbd && interrupt_input
           && keyboard_bit_set (&Available) && ! noninteractive)
-        kill (getpid (), SIGIO);
+        handle_input_available_signal (SIGIO);
 #endif
 
       if (! wait_proc)
@@ -4798,15 +4712,13 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       for (channel = 0; channel <= max_input_desc; ++channel)
         {
           struct fd_callback_data *d = &fd_callback_info[channel];
-          if (FD_ISSET (channel, &Available)
-              && d->func != 0
-              && (d->condition & FOR_READ) != 0)
-            d->func (channel, d->data, 1);
-          if (FD_ISSET (channel, &write_mask)
-              && d->func != 0
-              && (d->condition & FOR_WRITE) != 0)
-            d->func (channel, d->data, 0);
-          }
+          if (d->func
+              && ((d->condition & FOR_READ
+                   && FD_ISSET (channel, &Available))
+                  || (d->condition & FOR_WRITE
+                      && FD_ISSET (channel, &write_mask))))
+            d->func (channel, d->data);
+        }
 
       for (channel = 0; channel <= max_process_desc; channel++)
         {
@@ -4822,7 +4734,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               if (wait_channel == channel)
                 {
                   wait_channel = -1;
-                  time_limit = -1;
+                  nsecs = -1;
                   got_some_input = 1;
                 }
               proc = chan_process[channel];
@@ -4855,23 +4767,17 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               else if (nread == -1 && errno == EWOULDBLOCK)
                 ;
 #endif
-              /* ISC 4.1 defines both EWOULDBLOCK and O_NONBLOCK,
-                 and Emacs uses O_NONBLOCK, so what we get is EAGAIN.  */
-#ifdef O_NONBLOCK
-              else if (nread == -1 && errno == EAGAIN)
-                ;
-#else
-#ifdef O_NDELAY
               else if (nread == -1 && errno == EAGAIN)
                 ;
+#ifdef WINDOWSNT
+              /* FIXME: Is this special case still needed?  */
               /* Note that we cannot distinguish between no input
                  available now and a closed pipe.
                  With luck, a closed pipe will be accompanied by
                  subprocess termination and SIGCHLD.  */
               else if (nread == 0 && !NETCONN_P (proc) && !SERIALCONN_P (proc))
                 ;
-#endif /* O_NDELAY */
-#endif /* O_NONBLOCK */
+#endif
 #ifdef HAVE_PTYS
               /* On some OSs with ptys, when the process on one end of
                  a pty exits, the other end gets an error reading with
@@ -4879,11 +4785,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                  Therefore, if we get an error reading and errno =
                  EIO, just continue, because the child process has
                  exited and should clean itself up soon (e.g. when we
-                 get a SIGCHLD).
-
-                 However, it has been known to happen that the SIGCHLD
-                 got lost.  So raise the signal again just in case.
-                 It can't hurt.  */
+                 get a SIGCHLD).  */
               else if (nread == -1 && errno == EIO)
                 {
                   struct Lisp_Process *p = XPROCESS (proc);
@@ -4895,22 +4797,18 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 
                   if (p->pid == -2)
                     {
-                      /* If the EIO occurs on a pty, sigchld_handler's
-                         wait3() will not find the process object to
+                      /* If the EIO occurs on a pty, the SIGCHLD handler's
+                         waitpid call will not find the process object to
                          delete.  Do it here.  */
                       p->tick = ++process_tick;
-                      p->status = Qfailed;
+                      pset_status (p, Qfailed);
                     }
-                  else
-                    kill (getpid (), SIGCHLD);
                 }
 #endif /* HAVE_PTYS */
               /* If we can detect process termination, don't consider the
                  process gone just because its pipe is closed.  */
-#ifdef SIGCHLD
               else if (nread == 0 && !NETCONN_P (proc) && !SERIALCONN_P (proc))
                 ;
-#endif
               else
                 {
                   /* Preserve status of processes already terminated.  */
@@ -4919,8 +4817,8 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                   if (XPROCESS (proc)->raw_status_new)
                     update_status (XPROCESS (proc));
                   if (EQ (XPROCESS (proc)->status, Qrun))
-                    XPROCESS (proc)->status
-                      = Fcons (Qexit, Fcons (make_number (256), Qnil));
+                    pset_status (XPROCESS (proc),
+                                 list2 (Qexit, make_number (256)));
                 }
             }
 #ifdef NON_BLOCKING_CONNECT
@@ -4932,7 +4830,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               FD_CLR (channel, &connect_wait_mask);
               FD_CLR (channel, &write_mask);
               if (--num_pending_connects < 0)
-                abort ();
+                emacs_abort ();
 
               proc = chan_process[channel];
               if (NILP (proc))
@@ -4968,12 +4866,12 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               if (xerrno)
                 {
                   p->tick = ++process_tick;
-                  p->status = Fcons (Qfailed, Fcons (make_number (xerrno), Qnil));
+                  pset_status (p, list2 (Qfailed, make_number (xerrno)));
                   deactivate_process (proc);
                 }
               else
                 {
-                  p->status = Qrun;
+                  pset_status (p, Qrun);
                   /* Execute the sentinel here.  If we had relied on
                      status_notify to do it later, it will read input
                      from the process before calling the sentinel.  */
@@ -4986,8 +4884,8 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
                 }
             }
 #endif /* NON_BLOCKING_CONNECT */
-        }                       /* end for each file descriptor */
-    }                           /* end while exit conditions not met */
+        }                       /* End for each file descriptor.  */
+    }                           /* End while exit conditions not met.  */
 
   unbind_to (count, Qnil);
 
@@ -5022,6 +4920,11 @@ read_process_output_error_handler (Lisp_Object error_val)
   return Qt;
 }
 
+static void
+read_and_dispose_of_process_output (struct Lisp_Process *p, char *chars,
+                                    ssize_t nbytes,
+                                    struct coding_system *coding);
+
 /* Read pending output from the process channel,
    starting with our buffered-ahead character if we have one.
    Yield number of decoded characters read.
@@ -5038,16 +4941,14 @@ read_process_output (Lisp_Object proc, register int channel)
 {
   register ssize_t nbytes;
   char *chars;
-  register Lisp_Object outstream;
   register struct Lisp_Process *p = XPROCESS (proc);
-  register ptrdiff_t opoint;
   struct coding_system *coding = proc_decode_coding_system[channel];
   int carryover = p->decoding_carryover;
   int readmax = 4096;
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object odeactivate;
 
-  chars = (char *) alloca (carryover + readmax);
+  chars = alloca (carryover + readmax);
   if (carryover)
     /* See the comment above.  */
     memcpy (chars, SDATA (p->decoding_buf), carryover);
@@ -5063,7 +4964,7 @@ read_process_output (Lisp_Object proc, register int channel)
   else
 #endif
     {
-      int buffered = 0 <= proc_buffered_char[channel];
+      bool buffered = proc_buffered_char[channel] >= 0;
       if (buffered)
         {
           chars[carryover] = proc_buffered_char[channel];
@@ -5126,124 +5027,144 @@ read_process_output (Lisp_Object proc, register int channel)
   /* There's no good reason to let process filters change the current
      buffer, and many callers of accept-process-output, sit-for, and
      friends don't expect current-buffer to be changed from under them.  */
-  record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
+  record_unwind_current_buffer ();
 
-  /* Read and dispose of the process output.  */
-  outstream = p->filter;
-  if (!NILP (outstream))
-    {
-      Lisp_Object text;
-      int outer_running_asynch_code = running_asynch_code;
-      int waiting = waiting_for_user_input_p;
+  read_and_dispose_of_process_output (p, chars, nbytes, coding);
+
+  /* Handling the process output should not deactivate the mark.  */
+  Vdeactivate_mark = odeactivate;
+
+  unbind_to (count, Qnil);
+  return nbytes;
+}
+
+static void
+read_and_dispose_of_process_output (struct Lisp_Process *p, char *chars,
+                                    ssize_t nbytes,
+                                    struct coding_system *coding)
+{
+  Lisp_Object outstream = p->filter;
+  Lisp_Object text;
+  bool outer_running_asynch_code = running_asynch_code;
+  int waiting = waiting_for_user_input_p;
 
-      /* No need to gcpro these, because all we do with them later
-         is test them for EQness, and none of them should be a string.  */
+  /* No need to gcpro these, because all we do with them later
+     is test them for EQness, and none of them should be a string.  */
 #if 0
-      Lisp_Object obuffer, okeymap;
-      XSETBUFFER (obuffer, current_buffer);
-      okeymap = BVAR (current_buffer, keymap);
+  Lisp_Object obuffer, okeymap;
+  XSETBUFFER (obuffer, current_buffer);
+  okeymap = BVAR (current_buffer, keymap);
 #endif
 
-      /* We inhibit quit here instead of just catching it so that
-         hitting ^G when a filter happens to be running won't screw
-         it up.  */
-      specbind (Qinhibit_quit, Qt);
-      specbind (Qlast_nonmenu_event, Qt);
-
-      /* In case we get recursively called,
-         and we already saved the match data nonrecursively,
-         save the same match data in safely recursive fashion.  */
-      if (outer_running_asynch_code)
-        {
-          Lisp_Object tem;
-          /* Don't clobber the CURRENT match data, either!  */
-          tem = Fmatch_data (Qnil, Qnil, Qnil);
-          restore_search_regs ();
-          record_unwind_save_match_data ();
-          Fset_match_data (tem, Qt);
-        }
+  /* We inhibit quit here instead of just catching it so that
+     hitting ^G when a filter happens to be running won't screw
+     it up.  */
+  specbind (Qinhibit_quit, Qt);
+  specbind (Qlast_nonmenu_event, Qt);
 
-      /* For speed, if a search happens within this code,
-         save the match data in a special nonrecursive fashion.  */
-      running_asynch_code = 1;
+  /* In case we get recursively called,
+     and we already saved the match data nonrecursively,
+     save the same match data in safely recursive fashion.  */
+  if (outer_running_asynch_code)
+    {
+      Lisp_Object tem;
+      /* Don't clobber the CURRENT match data, either!  */
+      tem = Fmatch_data (Qnil, Qnil, Qnil);
+      restore_search_regs ();
+      record_unwind_save_match_data ();
+      Fset_match_data (tem, Qt);
+    }
 
-      decode_coding_c_string (coding, (unsigned char *) chars, nbytes, Qt);
-      text = coding->dst_object;
-      Vlast_coding_system_used = CODING_ID_NAME (coding->id);
-      /* A new coding system might be found.  */
-      if (!EQ (p->decode_coding_system, Vlast_coding_system_used))
-        {
-          p->decode_coding_system = Vlast_coding_system_used;
+  /* For speed, if a search happens within this code,
+     save the match data in a special nonrecursive fashion.  */
+  running_asynch_code = 1;
 
-          /* Don't call setup_coding_system for
-             proc_decode_coding_system[channel] here.  It is done in
-             detect_coding called via decode_coding above.  */
+  decode_coding_c_string (coding, (unsigned char *) chars, nbytes, Qt);
+  text = coding->dst_object;
+  Vlast_coding_system_used = CODING_ID_NAME (coding->id);
+  /* A new coding system might be found.  */
+  if (!EQ (p->decode_coding_system, Vlast_coding_system_used))
+    {
+      pset_decode_coding_system (p, Vlast_coding_system_used);
 
-          /* If a coding system for encoding is not yet decided, we set
-             it as the same as coding-system for decoding.
+      /* Don't call setup_coding_system for
+         proc_decode_coding_system[channel] here.  It is done in
+         detect_coding called via decode_coding above.  */
 
-             But, before doing that we must check if
-             proc_encode_coding_system[p->outfd] surely points to a
-             valid memory because p->outfd will be changed once EOF is
-             sent to the process.  */
-          if (NILP (p->encode_coding_system)
-              && proc_encode_coding_system[p->outfd])
-            {
-              p->encode_coding_system
-                = coding_inherit_eol_type (Vlast_coding_system_used, Qnil);
-              setup_coding_system (p->encode_coding_system,
-                                   proc_encode_coding_system[p->outfd]);
-            }
-        }
+      /* If a coding system for encoding is not yet decided, we set
+         it as the same as coding-system for decoding.
 
-      if (coding->carryover_bytes > 0)
+         But, before doing that we must check if
+         proc_encode_coding_system[p->outfd] surely points to a
+         valid memory because p->outfd will be changed once EOF is
+         sent to the process.  */
+      if (NILP (p->encode_coding_system)
+          && proc_encode_coding_system[p->outfd])
         {
-          if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
-            p->decoding_buf = make_uninit_string (coding->carryover_bytes);
-          memcpy (SDATA (p->decoding_buf), coding->carryover,
-                  coding->carryover_bytes);
-          p->decoding_carryover = coding->carryover_bytes;
+          pset_encode_coding_system
+            (p, coding_inherit_eol_type (Vlast_coding_system_used, Qnil));
+          setup_coding_system (p->encode_coding_system,
+                               proc_encode_coding_system[p->outfd]);
         }
-      if (SBYTES (text) > 0)
-        /* FIXME: It's wrong to wrap or not based on debug-on-error, and
-           sometimes it's simply wrong to wrap (e.g. when called from
-           accept-process-output).  */
-        internal_condition_case_1 (read_process_output_call,
-                                   Fcons (outstream,
-                                          Fcons (proc, Fcons (text, Qnil))),
-                                   !NILP (Vdebug_on_error) ? Qnil : Qerror,
-                                   read_process_output_error_handler);
-
-      /* If we saved the match data nonrecursively, restore it now.  */
-      restore_search_regs ();
-      running_asynch_code = outer_running_asynch_code;
+    }
+
+  if (coding->carryover_bytes > 0)
+    {
+      if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
+        pset_decoding_buf (p, make_uninit_string (coding->carryover_bytes));
+      memcpy (SDATA (p->decoding_buf), coding->carryover,
+              coding->carryover_bytes);
+      p->decoding_carryover = coding->carryover_bytes;
+    }
+  if (SBYTES (text) > 0)
+    /* FIXME: It's wrong to wrap or not based on debug-on-error, and
+       sometimes it's simply wrong to wrap (e.g. when called from
+       accept-process-output).  */
+    internal_condition_case_1 (read_process_output_call,
+                               list3 (outstream, make_lisp_proc (p), text),
+                               !NILP (Vdebug_on_error) ? Qnil : Qerror,
+                               read_process_output_error_handler);
 
-      /* Restore waiting_for_user_input_p as it was
-         when we were called, in case the filter clobbered it.  */
-      waiting_for_user_input_p = waiting;
+  /* If we saved the match data nonrecursively, restore it now.  */
+  restore_search_regs ();
+  running_asynch_code = outer_running_asynch_code;
+
+  /* Restore waiting_for_user_input_p as it was
+     when we were called, in case the filter clobbered it.  */
+  waiting_for_user_input_p = waiting;
 
 #if 0 /* Call record_asynch_buffer_change unconditionally,
          because we might have changed minor modes or other things
          that affect key bindings.  */
-      if (! EQ (Fcurrent_buffer (), obuffer)
-          || ! EQ (current_buffer->keymap, okeymap))
-#endif
-        /* But do it only if the caller is actually going to read events.
-           Otherwise there's no need to make him wake up, and it could
-           cause trouble (for example it would make sit_for return).  */
-        if (waiting_for_user_input_p == -1)
-          record_asynch_buffer_change ();
-    }
+  if (! EQ (Fcurrent_buffer (), obuffer)
+      || ! EQ (current_buffer->keymap, okeymap))
+#endif
+    /* But do it only if the caller is actually going to read events.
+       Otherwise there's no need to make him wake up, and it could
+       cause trouble (for example it would make sit_for return).  */
+    if (waiting_for_user_input_p == -1)
+      record_asynch_buffer_change ();
+}
+
+DEFUN ("internal-default-process-filter", Finternal_default_process_filter,
+       Sinternal_default_process_filter, 2, 2, 0,
+       doc: /* Function used as default process filter.  */)
+  (Lisp_Object proc, Lisp_Object text)
+{
+  struct Lisp_Process *p;
+  ptrdiff_t opoint;
+
+  CHECK_PROCESS (proc);
+  p = XPROCESS (proc);
+  CHECK_STRING (text);
 
-  /* If no filter, write into buffer if it isn't dead.  */
-  else if (!NILP (p->buffer) && !NILP (BVAR (XBUFFER (p->buffer), name)))
+  if (!NILP (p->buffer) && BUFFER_LIVE_P (XBUFFER (p->buffer)))
     {
       Lisp_Object old_read_only;
       ptrdiff_t old_begv, old_zv;
       ptrdiff_t old_begv_byte, old_zv_byte;
       ptrdiff_t before, before_byte;
       ptrdiff_t opoint_byte;
-      Lisp_Object text;
       struct buffer *b;
 
       Fset_buffer (p->buffer);
@@ -5255,15 +5176,12 @@ read_process_output (Lisp_Object proc, register int channel)
       old_begv_byte = BEGV_BYTE;
       old_zv_byte = ZV_BYTE;
 
-      BVAR (current_buffer, read_only) = Qnil;
+      bset_read_only (current_buffer, Qnil);
 
-      /* Insert new output into buffer
-         at the current end-of-output marker,
-         thus preserving logical ordering of input and output.  */
+      /* Insert new output into buffer at the current end-of-output
+         marker, thus preserving logical ordering of input and output.  */
       if (XMARKER (p->mark)->buffer)
-        SET_PT_BOTH (clip_to_bounds (BEGV, marker_position (p->mark), ZV),
-                     clip_to_bounds (BEGV_BYTE, marker_byte_position (p->mark),
-                                     ZV_BYTE));
+        set_point_from_marker (p->mark);
       else
         SET_PT_BOTH (ZV, ZV_BYTE);
       before = PT;
@@ -5274,31 +5192,6 @@ read_process_output (Lisp_Object proc, register int channel)
       if (! (BEGV <= PT && PT <= ZV))
         Fwiden ();
 
-      decode_coding_c_string (coding, (unsigned char *) chars, nbytes, Qt);
-      text = coding->dst_object;
-      Vlast_coding_system_used = CODING_ID_NAME (coding->id);
-      /* A new coding system might be found.  See the comment in the
-         similar code in the previous `if' block.  */
-      if (!EQ (p->decode_coding_system, Vlast_coding_system_used))
-        {
-          p->decode_coding_system = Vlast_coding_system_used;
-          if (NILP (p->encode_coding_system)
-              && proc_encode_coding_system[p->outfd])
-            {
-              p->encode_coding_system
-                = coding_inherit_eol_type (Vlast_coding_system_used, Qnil);
-              setup_coding_system (p->encode_coding_system,
-                                   proc_encode_coding_system[p->outfd]);
-            }
-        }
-      if (coding->carryover_bytes > 0)
-        {
-          if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
-            p->decoding_buf = make_uninit_string (coding->carryover_bytes);
-          memcpy (SDATA (p->decoding_buf), coding->carryover,
-                  coding->carryover_bytes);
-          p->decoding_carryover = coding->carryover_bytes;
-        }
       /* Adjust the multibyteness of TEXT to that of the buffer.  */
       if (NILP (BVAR (current_buffer, enable_multibyte_characters))
           != ! STRING_MULTIBYTE (text))
@@ -5343,32 +5236,84 @@ read_process_output (Lisp_Object proc, register int channel)
       if (old_begv != BEGV || old_zv != ZV)
         Fnarrow_to_region (make_number (old_begv), make_number (old_zv));
 
-
-      BVAR (current_buffer, read_only) = old_read_only;
+      bset_read_only (current_buffer, old_read_only);
       SET_PT_BOTH (opoint, opoint_byte);
     }
-  /* Handling the process output should not deactivate the mark.  */
-  Vdeactivate_mark = odeactivate;
-
-  unbind_to (count, Qnil);
-  return nbytes;
+  return Qnil;
 }
 
-/* Sending data to subprocess */
+/* Sending data to subprocess.  */
 
-static jmp_buf send_process_frame;
-static Lisp_Object process_sent_to;
+/* In send_process, when a write fails temporarily,
+   wait_reading_process_output is called.  It may execute user code,
+   e.g. timers, that attempts to write new data to the same process.
+   We must ensure that data is sent in the right order, and not
+   interspersed half-completed with other writes (Bug#10815).  This is
+   handled by the write_queue element of struct process.  It is a list
+   with each entry having the form
 
-#ifndef FORWARD_SIGNAL_TO_MAIN_THREAD
-static void send_process_trap (int) NO_RETURN;
-#endif
+   (string . (offset . length))
+
+   where STRING is a lisp string, OFFSET is the offset into the
+   string's byte sequence from which we should begin to send, and
+   LENGTH is the number of bytes left to send.  */
+
+/* Create a new entry in write_queue.
+   INPUT_OBJ should be a buffer, string Qt, or Qnil.
+   BUF is a pointer to the string sequence of the input_obj or a C
+   string in case of Qt or Qnil.  */
 
 static void
-send_process_trap (int ignore)
+write_queue_push (struct Lisp_Process *p, Lisp_Object input_obj,
+                  const char *buf, ptrdiff_t len, bool front)
+{
+  ptrdiff_t offset;
+  Lisp_Object entry, obj;
+
+  if (STRINGP (input_obj))
+    {
+      offset = buf - SSDATA (input_obj);
+      obj = input_obj;
+    }
+  else
+    {
+      offset = 0;
+      obj = make_unibyte_string (buf, len);
+    }
+
+  entry = Fcons (obj, Fcons (make_number (offset), make_number (len)));
+
+  if (front)
+    pset_write_queue (p, Fcons (entry, p->write_queue));
+  else
+    pset_write_queue (p, nconc2 (p->write_queue, list1 (entry)));
+}
+
+/* Remove the first element in the write_queue of process P, put its
+   contents in OBJ, BUF and LEN, and return true.  If the
+   write_queue is empty, return false.  */
+
+static bool
+write_queue_pop (struct Lisp_Process *p, Lisp_Object *obj,
+                 const char **buf, ptrdiff_t *len)
 {
-  SIGNAL_THREAD_CHECK (SIGPIPE);
-  sigunblock (sigmask (SIGPIPE));
-  longjmp (send_process_frame, 1);
+  Lisp_Object entry, offset_length;
+  ptrdiff_t offset;
+
+  if (NILP (p->write_queue))
+    return 0;
+
+  entry = XCAR (p->write_queue);
+  pset_write_queue (p, XCDR (p->write_queue));
+
+  *obj = XCAR (entry);
+  offset_length = XCDR (entry);
+
+  *len = XINT (XCDR (offset_length));
+  offset = XINT (XCAR (offset_length));
+  *buf = SSDATA (*obj) + offset;
+
+  return 1;
 }
 
 /* Send some data to process PROC.
@@ -5382,17 +5327,12 @@ send_process_trap (int ignore)
    This function can evaluate Lisp code and can garbage collect.  */
 
 static void
-send_process (volatile Lisp_Object proc, const char *volatile buf,
-              volatile ptrdiff_t len, volatile Lisp_Object object)
+send_process (Lisp_Object proc, const char *buf, ptrdiff_t len,
+              Lisp_Object object)
 {
-  /* Use volatile to protect variables from being clobbered by longjmp.  */
   struct Lisp_Process *p = XPROCESS (proc);
   ssize_t rv;
   struct coding_system *coding;
-  struct gcpro gcpro1;
-  void (*volatile old_sigpipe) (int);
-
-  GCPRO1 (object);
 
   if (p->raw_status_new)
     update_status (p);
@@ -5409,8 +5349,8 @@ send_process (volatile Lisp_Object proc, const char *volatile buf,
           && !NILP (BVAR (XBUFFER (object), enable_multibyte_characters)))
       || EQ (object, Qt))
     {
-      p->encode_coding_system
-        = complement_process_encoding_system (p->encode_coding_system);
+      pset_encode_coding_system
+        (p, complement_process_encoding_system (p->encode_coding_system));
       if (!EQ (Vlast_coding_system_used, p->encode_coding_system))
         {
           /* The coding system for encoding was changed to raw-text
@@ -5486,158 +5426,123 @@ send_process (volatile Lisp_Object proc, const char *volatile buf,
       buf = SSDATA (object);
     }
 
-  if (pty_max_bytes == 0)
-    {
-#if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
-      pty_max_bytes = fpathconf (p->outfd, _PC_MAX_CANON);
-      if (pty_max_bytes < 0)
-        pty_max_bytes = 250;
-#else
-      pty_max_bytes = 250;
-#endif
-      /* Deduct one, to leave space for the eof.  */
-      pty_max_bytes--;
-    }
+  /* If there is already data in the write_queue, put the new data
+     in the back of queue.  Otherwise, ignore it.  */
+  if (!NILP (p->write_queue))
+    write_queue_push (p, object, buf, len, 0);
 
-  /* 2000-09-21: Emacs 20.7, sparc-sun-solaris-2.6, GCC 2.95.2,
-     CFLAGS="-g -O": The value of the parameter `proc' is clobbered
-     when returning with longjmp despite being declared volatile.  */
-  if (!setjmp (send_process_frame))
+  do   /* while !NILP (p->write_queue) */
     {
-      p = XPROCESS (proc);  /* Repair any setjmp clobbering.  */
+      ptrdiff_t cur_len = -1;
+      const char *cur_buf;
+      Lisp_Object cur_object;
 
-      process_sent_to = proc;
-      while (len > 0)
+      /* If write_queue is empty, ignore it.  */
+      if (!write_queue_pop (p, &cur_object, &cur_buf, &cur_len))
         {
-          ptrdiff_t this = len;
+          cur_len = len;
+          cur_buf = buf;
+          cur_object = object;
+        }
 
+      while (cur_len > 0)
+        {
           /* Send this batch, using one or more write calls.  */
-          while (this > 0)
-            {
-              ptrdiff_t written = 0;
-              int outfd = p->outfd;
-              old_sigpipe = (void (*) (int)) signal (SIGPIPE, send_process_trap);
+          ptrdiff_t written = 0;
+          int outfd = p->outfd;
 #ifdef DATAGRAM_SOCKETS
-              if (DATAGRAM_CHAN_P (outfd))
-                {
-                  rv = sendto (outfd, buf, this,
-                               0, datagram_address[outfd].sa,
-                               datagram_address[outfd].len);
-                  if (0 <= rv)
-                    written = rv;
-                  else if (errno == EMSGSIZE)
-                    {
-                      signal (SIGPIPE, old_sigpipe);
-                      report_file_error ("sending datagram",
-                                         Fcons (proc, Qnil));
-                    }
-                }
-              else
+          if (DATAGRAM_CHAN_P (outfd))
+            {
+              rv = sendto (outfd, cur_buf, cur_len,
+                           0, datagram_address[outfd].sa,
+                           datagram_address[outfd].len);
+              if (rv >= 0)
+                written = rv;
+              else if (errno == EMSGSIZE)
+                report_file_error ("Sending datagram", proc);
+            }
+          else
 #endif
-                {
+            {
 #ifdef HAVE_GNUTLS
-                  if (p->gnutls_p)
-                    written = emacs_gnutls_write (p, buf, this);
-                  else
+              if (p->gnutls_p)
+                written = emacs_gnutls_write (p, cur_buf, cur_len);
+              else
 #endif
-                    written = emacs_write (outfd, buf, this);
-                  rv = (written ? 0 : -1);
+                written = emacs_write_sig (outfd, cur_buf, cur_len);
+              rv = (written ? 0 : -1);
 #ifdef ADAPTIVE_READ_BUFFERING
-                  if (p->read_output_delay > 0
-                      && p->adaptive_read_buffering == 1)
-                    {
-                      p->read_output_delay = 0;
-                      process_output_delay_count--;
-                      p->read_output_skip = 0;
-                    }
-#endif
+              if (p->read_output_delay > 0
+                  && p->adaptive_read_buffering == 1)
+                {
+                  p->read_output_delay = 0;
+                  process_output_delay_count--;
+                  p->read_output_skip = 0;
                 }
-              signal (SIGPIPE, old_sigpipe);
+#endif
+            }
 
-              if (rv < 0)
-                {
-                  if (0
+          if (rv < 0)
+            {
+              if (errno == EAGAIN
 #ifdef EWOULDBLOCK
-                      || errno == EWOULDBLOCK
+                  || errno == EWOULDBLOCK
 #endif
-#ifdef EAGAIN
-                      || errno == EAGAIN
-#endif
-                      )
-                    /* Buffer is full.  Wait, accepting input;
-                       that may allow the program
-                       to finish doing output and read more.  */
-                    {
-                      ptrdiff_t offset = 0;
-
+                  )
+                /* Buffer is full.  Wait, accepting input;
+                   that may allow the program
+                   to finish doing output and read more.  */
+                {
 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
-                      /* A gross hack to work around a bug in FreeBSD.
-                         In the following sequence, read(2) returns
-                         bogus data:
-
-                         write(2)        1022 bytes
-                         write(2)   954 bytes, get EAGAIN
-                         read(2)   1024 bytes in process_read_output
-                         read(2)     11 bytes in process_read_output
-
-                         That is, read(2) returns more bytes than have
-                         ever been written successfully.  The 1033 bytes
-                         read are the 1022 bytes written successfully
-                         after processing (for example with CRs added if
-                         the terminal is set up that way which it is
-                         here).  The same bytes will be seen again in a
-                         later read(2), without the CRs.  */
-
-                      if (errno == EAGAIN)
-                        {
-                          int flags = FWRITE;
-                          ioctl (p->outfd, TIOCFLUSH, &flags);
-                        }
+                  /* A gross hack to work around a bug in FreeBSD.
+                     In the following sequence, read(2) returns
+                     bogus data:
+
+                     write(2)    1022 bytes
+                     write(2)   954 bytes, get EAGAIN
+                     read(2)   1024 bytes in process_read_output
+                     read(2)     11 bytes in process_read_output
+
+                     That is, read(2) returns more bytes than have
+                     ever been written successfully.  The 1033 bytes
+                     read are the 1022 bytes written successfully
+                     after processing (for example with CRs added if
+                     the terminal is set up that way which it is
+                     here).  The same bytes will be seen again in a
+                     later read(2), without the CRs.  */
+
+                  if (errno == EAGAIN)
+                    {
+                      int flags = FWRITE;
+                      ioctl (p->outfd, TIOCFLUSH, &flags);
+                    }
 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
 
-                      /* Running filters might relocate buffers or strings.
-                         Arrange to relocate BUF.  */
-                      if (BUFFERP (object))
-                        offset = BUF_PTR_BYTE_POS (XBUFFER (object),
-                                                   (unsigned char *) buf);
-                      else if (STRINGP (object))
-                        offset = buf - SSDATA (object);
-
-#ifdef EMACS_HAS_USECS
-                      wait_reading_process_output (0, 20000, 0, 0, Qnil, NULL, 0);
-#else
-                      wait_reading_process_output (1, 0, 0, 0, Qnil, NULL, 0);
-#endif
-
-                      if (BUFFERP (object))
-                        buf = (char *) BUF_BYTE_ADDRESS (XBUFFER (object),
-                                                         offset);
-                      else if (STRINGP (object))
-                        buf = offset + SSDATA (object);
-                    }
-                  else
-                    /* This is a real error.  */
-                    report_file_error ("writing to process", Fcons (proc, Qnil));
+                  /* Put what we should have written in wait_queue.  */
+                  write_queue_push (p, cur_object, cur_buf, cur_len, 1);
+                  wait_reading_process_output (0, 20 * 1000 * 1000,
+                                               0, 0, Qnil, NULL, 0);
+                  /* Reread queue, to see what is left.  */
+                  break;
+                }
+              else if (errno == EPIPE)
+                {
+                  p->raw_status_new = 0;
+                  pset_status (p, list2 (Qexit, make_number (256)));
+                  p->tick = ++process_tick;
+                  deactivate_process (proc);
+                  error ("process %s no longer connected to pipe; closed it",
+                         SDATA (p->name));
                 }
-              buf += written;
-              len -= written;
-              this -= written;
+              else
+                /* This is a real error.  */
+                report_file_error ("Writing to process", proc);
             }
+          cur_buf += written;
+          cur_len -= written;
         }
     }
-  else
-    {
-      signal (SIGPIPE, old_sigpipe);
-      proc = process_sent_to;
-      p = XPROCESS (proc);
-      p->raw_status_new = 0;
-      p->status = Fcons (Qexit, Fcons (make_number (256), Qnil));
-      p->tick = ++process_tick;
-      deactivate_process (proc);
-      error ("SIGPIPE raised on process %s; closed it", SDATA (p->name));
-    }
-
-  UNGCPRO;
+  while (!NILP (p->write_queue));
 }
 
 DEFUN ("process-send-region", Fprocess_send_region, Sprocess_send_region,
@@ -5651,19 +5556,19 @@ it is sent in several bunches.  This may happen even for shorter regions.
 Output from processes can arrive in between bunches.  */)
   (Lisp_Object process, Lisp_Object start, Lisp_Object end)
 {
-  Lisp_Object proc;
-  ptrdiff_t start1, end1;
+  Lisp_Object proc = get_process (process);
+  ptrdiff_t start_byte, end_byte;
 
-  proc = get_process (process);
   validate_region (&start, &end);
 
+  start_byte = CHAR_TO_BYTE (XINT (start));
+  end_byte = CHAR_TO_BYTE (XINT (end));
+
   if (XINT (start) < GPT && XINT (end) > GPT)
-    move_gap (XINT (start));
+    move_gap_both (XINT (start), start_byte);
 
-  start1 = CHAR_TO_BYTE (XINT (start));
-  end1 = CHAR_TO_BYTE (XINT (end));
-  send_process (proc, (char *) BYTE_POS_ADDR (start1), end1 - start1,
-                Fcurrent_buffer ());
+  send_process (proc, (char *) BYTE_POS_ADDR (start_byte),
+                end_byte - start_byte, Fcurrent_buffer ());
 
   return Qnil;
 }
@@ -5749,21 +5654,21 @@ return t unconditionally.  */)
    If CURRENT_GROUP is lambda, that means send to the process group
    that currently owns the terminal, but only if it is NOT the shell itself.
 
-   If NOMSG is zero, insert signal-announcements into process's buffers
+   If NOMSG is false, insert signal-announcements into process's buffers
    right away.
 
    If we can, we try to signal PROCESS by sending control characters
    down the pty.  This allows us to signal inferiors who have changed
-   their uid, for which killpg would return an EPERM error.  */
+   their uid, for which kill would return an EPERM error.  */
 
 static void
 process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
-                     int nomsg)
+                     bool nomsg)
 {
   Lisp_Object proc;
-  register struct Lisp_Process *p;
+  struct Lisp_Process *p;
   pid_t gid;
-  int no_pgrp = 0;
+  bool no_pgrp = 0;
 
   proc = get_process (process);
   p = XPROCESS (proc);
@@ -5857,26 +5762,19 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
         return;
     }
 
-  switch (signo)
-    {
 #ifdef SIGCONT
-    case SIGCONT:
+  if (signo == SIGCONT)
+    {
       p->raw_status_new = 0;
-      p->status = Qrun;
+      pset_status (p, Qrun);
       p->tick = ++process_tick;
       if (!nomsg)
         {
           status_notify (NULL);
           redisplay_preserve_echo_area (13);
         }
-      break;
-#endif /* ! defined (SIGCONT) */
-    case SIGINT:
-    case SIGQUIT:
-    case SIGKILL:
-      flush_pending_output (p->infd);
-      break;
     }
+#endif
 
   /* If we don't have process groups, send the signal to the immediate
      subprocess.  That isn't really right, but it's better than any
@@ -5892,7 +5790,7 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
   if (!NILP (current_group))
     {
       if (ioctl (p->infd, TIOCSIGSEND, signo) == -1)
-        EMACS_KILLPG (gid, signo);
+        kill (-gid, signo);
     }
   else
     {
@@ -5900,7 +5798,7 @@ process_send_signal (Lisp_Object process, int signo, Lisp_Object current_group,
       kill (gid, signo);
     }
 #else /* ! defined (TIOCSIGSEND) */
-  EMACS_KILLPG (gid, signo);
+  kill (-gid, signo);
 #endif /* ! defined (TIOCSIGSEND) */
 }
 
@@ -5958,7 +5856,7 @@ traffic.  */)
           FD_CLR (p->infd, &input_wait_mask);
           FD_CLR (p->infd, &non_keyboard_wait_mask);
         }
-      p->command = Qt;
+      pset_command (p, Qt);
       return process;
     }
 #ifndef SIGTSTP
@@ -5994,7 +5892,7 @@ traffic.  */)
           tcflush (p->infd, TCIFLUSH);
 #endif /* not WINDOWSNT */
         }
-      p->command = Qnil;
+      pset_command (p, Qnil);
       return process;
     }
 #ifdef SIGCONT
@@ -6005,6 +5903,27 @@ traffic.  */)
   return process;
 }
 
+/* Return the integer value of the signal whose abbreviation is ABBR,
+   or a negative number if there is no such signal.  */
+static int
+abbr_to_signal (char const *name)
+{
+  int i, signo;
+  char sigbuf[20]; /* Large enough for all valid signal abbreviations.  */
+
+  if (!strncmp (name, "SIG", 3) || !strncmp (name, "sig", 3))
+    name += 3;
+
+  for (i = 0; i < sizeof sigbuf; i++)
+    {
+      sigbuf[i] = c_toupper (name[i]);
+      if (! sigbuf[i])
+        return str2sig (sigbuf, &signo) == 0 ? signo : -1;
+    }
+
+  return -1;
+}
+
 DEFUN ("signal-process", Fsignal_process, Ssignal_process,
        2, 2, "sProcess (name or number): \nnSignal code: ",
        doc: /* Send PROCESS the signal with code SIGCODE.
@@ -6015,6 +5934,7 @@ SIGCODE may be an integer, or a symbol whose name is a signal name.  */)
   (Lisp_Object process, Lisp_Object sigcode)
 {
   pid_t pid;
+  int signo;
 
   if (STRINGP (process))
     {
@@ -6044,12 +5964,11 @@ SIGCODE may be an integer, or a symbol whose name is a signal name.  */)
         error ("Cannot signal process %s", SDATA (XPROCESS (process)->name));
     }
 
-#define parse_signal(NAME, VALUE)               \
-  else if (!xstrcasecmp (name, NAME))           \
-    XSETINT (sigcode, VALUE)
-
   if (INTEGERP (sigcode))
-    CHECK_TYPE_RANGED_INTEGER (int, sigcode);
+    {
+      CHECK_TYPE_RANGED_INTEGER (int, sigcode);
+      signo = XINT (sigcode);
+    }
   else
     {
       char *name;
@@ -6057,108 +5976,12 @@ SIGCODE may be an integer, or a symbol whose name is a signal name.  */)
       CHECK_SYMBOL (sigcode);
       name = SSDATA (SYMBOL_NAME (sigcode));
 
-      if (!strncmp (name, "SIG", 3) || !strncmp (name, "sig", 3))
-        name += 3;
-
-      if (0)
-        ;
-#ifdef SIGUSR1
-      parse_signal ("usr1", SIGUSR1);
-#endif
-#ifdef SIGUSR2
-      parse_signal ("usr2", SIGUSR2);
-#endif
-#ifdef SIGTERM
-      parse_signal ("term", SIGTERM);
-#endif
-#ifdef SIGHUP
-      parse_signal ("hup", SIGHUP);
-#endif
-#ifdef SIGINT
-      parse_signal ("int", SIGINT);
-#endif
-#ifdef SIGQUIT
-      parse_signal ("quit", SIGQUIT);
-#endif
-#ifdef SIGILL
-      parse_signal ("ill", SIGILL);
-#endif
-#ifdef SIGABRT
-      parse_signal ("abrt", SIGABRT);
-#endif
-#ifdef SIGEMT
-      parse_signal ("emt", SIGEMT);
-#endif
-#ifdef SIGKILL
-      parse_signal ("kill", SIGKILL);
-#endif
-#ifdef SIGFPE
-      parse_signal ("fpe", SIGFPE);
-#endif
-#ifdef SIGBUS
-      parse_signal ("bus", SIGBUS);
-#endif
-#ifdef SIGSEGV
-      parse_signal ("segv", SIGSEGV);
-#endif
-#ifdef SIGSYS
-      parse_signal ("sys", SIGSYS);
-#endif
-#ifdef SIGPIPE
-      parse_signal ("pipe", SIGPIPE);
-#endif
-#ifdef SIGALRM
-      parse_signal ("alrm", SIGALRM);
-#endif
-#ifdef SIGURG
-      parse_signal ("urg", SIGURG);
-#endif
-#ifdef SIGSTOP
-      parse_signal ("stop", SIGSTOP);
-#endif
-#ifdef SIGTSTP
-      parse_signal ("tstp", SIGTSTP);
-#endif
-#ifdef SIGCONT
-      parse_signal ("cont", SIGCONT);
-#endif
-#ifdef SIGCHLD
-      parse_signal ("chld", SIGCHLD);
-#endif
-#ifdef SIGTTIN
-      parse_signal ("ttin", SIGTTIN);
-#endif
-#ifdef SIGTTOU
-      parse_signal ("ttou", SIGTTOU);
-#endif
-#ifdef SIGIO
-      parse_signal ("io", SIGIO);
-#endif
-#ifdef SIGXCPU
-      parse_signal ("xcpu", SIGXCPU);
-#endif
-#ifdef SIGXFSZ
-      parse_signal ("xfsz", SIGXFSZ);
-#endif
-#ifdef SIGVTALRM
-      parse_signal ("vtalrm", SIGVTALRM);
-#endif
-#ifdef SIGPROF
-      parse_signal ("prof", SIGPROF);
-#endif
-#ifdef SIGWINCH
-      parse_signal ("winch", SIGWINCH);
-#endif
-#ifdef SIGINFO
-      parse_signal ("info", SIGINFO);
-#endif
-      else
+      signo = abbr_to_signal (name);
+      if (signo < 0)
         error ("Undefined signal name %s", name);
     }
 
-#undef parse_signal
-
-  return make_number (kill (pid, XINT (sigcode)));
+  return make_number (kill (pid, signo));
 }
 
 DEFUN ("process-send-eof", Fprocess_send_eof, Sprocess_send_eof, 0, 1, 0,
@@ -6200,13 +6023,14 @@ process has been transmitted to the serial port.  */)
     {
 #ifndef WINDOWSNT
       if (tcdrain (XPROCESS (proc)->outfd) != 0)
-        error ("tcdrain() failed: %s", emacs_strerror (errno));
+        report_file_error ("Failed tcdrain", Qnil);
 #endif /* not WINDOWSNT */
       /* Do nothing on Windows because writes are blocking.  */
     }
   else
     {
-      int old_outfd, new_outfd;
+      int old_outfd = XPROCESS (proc)->outfd;
+      int new_outfd;
 
 #ifdef HAVE_SHUTDOWN
       /* If this is a network connection, or socketpair is used
@@ -6214,36 +6038,63 @@ process has been transmitted to the serial port.  */)
          (In some old system, shutdown to socketpair doesn't work.
          Then we just can't win.)  */
       if (EQ (XPROCESS (proc)->type, Qnetwork)
-          || XPROCESS (proc)->outfd == XPROCESS (proc)->infd)
-        shutdown (XPROCESS (proc)->outfd, 1);
-      /* In case of socketpair, outfd == infd, so don't close it.  */
-      if (XPROCESS (proc)->outfd != XPROCESS (proc)->infd)
-        emacs_close (XPROCESS (proc)->outfd);
-#else /* not HAVE_SHUTDOWN */
-      emacs_close (XPROCESS (proc)->outfd);
-#endif /* not HAVE_SHUTDOWN */
+          || XPROCESS (proc)->infd == old_outfd)
+        shutdown (old_outfd, 1);
+#endif
+      close_process_fd (&XPROCESS (proc)->open_fd[WRITE_TO_SUBPROCESS]);
       new_outfd = emacs_open (NULL_DEVICE, O_WRONLY, 0);
       if (new_outfd < 0)
-        abort ();
-      old_outfd = XPROCESS (proc)->outfd;
+        report_file_error ("Opening null device", Qnil);
+      XPROCESS (proc)->open_fd[WRITE_TO_SUBPROCESS] = new_outfd;
+      XPROCESS (proc)->outfd = new_outfd;
 
       if (!proc_encode_coding_system[new_outfd])
         proc_encode_coding_system[new_outfd]
-          = (struct coding_system *) xmalloc (sizeof (struct coding_system));
-      memcpy (proc_encode_coding_system[new_outfd],
-              proc_encode_coding_system[old_outfd],
-              sizeof (struct coding_system));
+          = xmalloc (sizeof (struct coding_system));
+      *proc_encode_coding_system[new_outfd]
+        = *proc_encode_coding_system[old_outfd];
       memset (proc_encode_coding_system[old_outfd], 0,
               sizeof (struct coding_system));
-
-      XPROCESS (proc)->outfd = new_outfd;
     }
   return process;
 }
 
-/* On receipt of a signal that a child status has changed, loop asking
-   about children with changed statuses until the system says there
-   are no more.
+/* The main Emacs thread records child processes in three places:
+
+   - Vprocess_alist, for asynchronous subprocesses, which are child
+     processes visible to Lisp.
+
+   - deleted_pid_list, for child processes invisible to Lisp,
+     typically because of delete-process.  These are recorded so that
+     the processes can be reaped when they exit, so that the operating
+     system's process table is not cluttered by zombies.
+
+   - the local variable PID in Fcall_process, call_process_cleanup and
+     call_process_kill, for synchronous subprocesses.
+     record_unwind_protect is used to make sure this process is not
+     forgotten: if the user interrupts call-process and the child
+     process refuses to exit immediately even with two C-g's,
+     call_process_kill adds PID's contents to deleted_pid_list before
+     returning.
+
+   The main Emacs thread invokes waitpid only on child processes that
+   it creates and that have not been reaped.  This avoid races on
+   platforms such as GTK, where other threads create their own
+   subprocesses which the main thread should not reap.  For example,
+   if the main thread attempted to reap an already-reaped child, it
+   might inadvertently reap a GTK-created process that happened to
+   have the same process ID.  */
+
+/* LIB_CHILD_HANDLER is a SIGCHLD handler that Emacs calls while doing
+   its own SIGCHLD handling.  On POSIXish systems, glib needs this to
+   keep track of its own children.  GNUstep is similar.  */
+
+static void dummy_handler (int sig) {}
+static signal_handler_t volatile lib_child_handler;
+
+/* Handle a SIGCHLD signal by looking for known child processes of
+   Emacs whose status have changed.  For each one found, record its
+   new status.
 
    All we do is change the status; we do not run sentinels or print
    notifications.  That is saved for the next time keyboard input is
@@ -6266,153 +6117,87 @@ process has been transmitted to the serial port.  */)
    ** Malloc WARNING: This should never call malloc either directly or
    indirectly; if it does, that is a bug  */
 
-#ifdef SIGCHLD
 static void
-sigchld_handler (int signo)
+handle_child_signal (int sig)
 {
-  int old_errno = errno;
-  Lisp_Object proc;
-  struct Lisp_Process *p;
+  Lisp_Object tail, proc;
 
-  SIGNAL_THREAD_CHECK (signo);
+  /* Find the process that signaled us, and record its status.  */
 
-  while (1)
+  /* The process can have been deleted by Fdelete_process, or have
+     been started asynchronously by Fcall_process.  */
+  for (tail = deleted_pid_list; CONSP (tail); tail = XCDR (tail))
     {
-      pid_t pid;
-      int w;
-      Lisp_Object tail;
-
-#ifdef WNOHANG
-#ifndef WUNTRACED
-#define WUNTRACED 0
-#endif /* no WUNTRACED */
-      /* Keep trying to get a status until we get a definitive result.  */
-      do
-        {
-          errno = 0;
-          pid = wait3 (&w, WNOHANG | WUNTRACED, 0);
-        }
-      while (pid < 0 && errno == EINTR);
-
-      if (pid <= 0)
-        {
-          /* PID == 0 means no processes found, PID == -1 means a real
-             failure.  We have done all our job, so return.  */
-
-          errno = old_errno;
-          return;
-        }
-#else
-      pid = wait (&w);
-#endif /* no WNOHANG */
-
-      /* Find the process that signaled us, and record its status.  */
-
-      /* The process can have been deleted by Fdelete_process.  */
-      for (tail = deleted_pid_list; CONSP (tail); tail = XCDR (tail))
+      bool all_pids_are_fixnums
+        = (MOST_NEGATIVE_FIXNUM <= TYPE_MINIMUM (pid_t)
+           && TYPE_MAXIMUM (pid_t) <= MOST_POSITIVE_FIXNUM);
+      Lisp_Object head = XCAR (tail);
+      Lisp_Object xpid;
+      if (! CONSP (head))
+        continue;
+      xpid = XCAR (head);
+      if (all_pids_are_fixnums ? INTEGERP (xpid) : NUMBERP (xpid))
         {
-          Lisp_Object xpid = XCAR (tail);
-          if ((INTEGERP (xpid) && pid == XINT (xpid))
-              || (FLOATP (xpid) && pid == XFLOAT_DATA (xpid)))
+          pid_t deleted_pid;
+          if (INTEGERP (xpid))
+            deleted_pid = XINT (xpid);
+          else
+            deleted_pid = XFLOAT_DATA (xpid);
+          if (child_status_changed (deleted_pid, 0, 0))
             {
+              if (STRINGP (XCDR (head)))
+                unlink (SSDATA (XCDR (head)));
               XSETCAR (tail, Qnil);
-              goto sigchld_end_of_loop;
             }
         }
+    }
 
-      /* Otherwise, if it is asynchronous, it is in Vprocess_alist.  */
-      p = 0;
-      for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
-        {
-          proc = XCDR (XCAR (tail));
-          p = XPROCESS (proc);
-          if (EQ (p->type, Qreal) && p->pid == pid)
-            break;
-          p = 0;
-        }
-
-      /* Look for an asynchronous process whose pid hasn't been filled
-         in yet.  */
-      if (p == 0)
-        for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
-          {
-            proc = XCDR (XCAR (tail));
-            p = XPROCESS (proc);
-            if (p->pid == -1)
-              break;
-            p = 0;
-          }
+  /* Otherwise, if it is asynchronous, it is in Vprocess_alist.  */
+  FOR_EACH_PROCESS (tail, proc)
+    {
+      struct Lisp_Process *p = XPROCESS (proc);
+      int status;
 
-      /* Change the status of the process that was found.  */
-      if (p != 0)
+      if (p->alive
+          && child_status_changed (p->pid, &status, WUNTRACED | WCONTINUED))
         {
-          int clear_desc_flag = 0;
-
+          /* Change the status of the process that was found.  */
           p->tick = ++process_tick;
-          p->raw_status = w;
+          p->raw_status = status;
           p->raw_status_new = 1;
 
           /* If process has terminated, stop waiting for its output.  */
-          if ((WIFSIGNALED (w) || WIFEXITED (w))
-              && p->infd >= 0)
-            clear_desc_flag = 1;
-
-          /* We use clear_desc_flag to avoid a compiler bug in Microsoft C.  */
-          if (clear_desc_flag)
+          if (WIFSIGNALED (status) || WIFEXITED (status))
             {
-              FD_CLR (p->infd, &input_wait_mask);
-              FD_CLR (p->infd, &non_keyboard_wait_mask);
-            }
-
-          /* Tell wait_reading_process_output that it needs to wake up and
-             look around.  */
-          if (input_available_clear_time)
-            EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
-        }
+              bool clear_desc_flag = 0;
+              p->alive = 0;
+              if (p->infd >= 0)
+                clear_desc_flag = 1;
 
-      /* There was no asynchronous process found for that pid: we have
-         a synchronous process.  */
-      else
-        {
-          synch_process_alive = 0;
-
-          /* Report the status of the synchronous process.  */
-          if (WIFEXITED (w))
-            synch_process_retcode = WRETCODE (w);
-          else if (WIFSIGNALED (w))
-            synch_process_termsig = WTERMSIG (w);
-
-          /* Tell wait_reading_process_output that it needs to wake up and
-             look around.  */
-          if (input_available_clear_time)
-            EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
+              /* clear_desc_flag avoids a compiler bug in Microsoft C.  */
+              if (clear_desc_flag)
+                {
+                  FD_CLR (p->infd, &input_wait_mask);
+                  FD_CLR (p->infd, &non_keyboard_wait_mask);
+                }
+            }
         }
-
-    sigchld_end_of_loop:
-      ;
-
-      /* On some systems, we must return right away.
-         If any more processes want to signal us, we will
-         get another signal.
-         Otherwise (on systems that have WNOHANG), loop around
-         to use up all the processes that have something to tell us.  */
-#if (defined WINDOWSNT \
-     || (defined USG && !defined GNU_LINUX \
-         && !(defined HPUX && defined WNOHANG)))
-      errno = old_errno;
-      return;
-#endif /* USG, but not HPUX with WNOHANG */
     }
+
+  lib_child_handler (sig);
+#ifdef NS_IMPL_GNUSTEP
+  /* NSTask in GNUStep sets its child handler each time it is called.
+     So we must re-set ours.  */
+  catch_child_signal();
+#endif
 }
-#endif /* SIGCHLD */
-
 
-static Lisp_Object
-exec_sentinel_unwind (Lisp_Object data)
+static void
+deliver_child_signal (int sig)
 {
-  XPROCESS (XCAR (data))->sentinel = XCDR (data);
-  return Qnil;
+  deliver_process_signal (sig, handle_child_signal);
 }
+
 
 static Lisp_Object
 exec_sentinel_error_handler (Lisp_Object error_val)
@@ -6428,9 +6213,9 @@ static void
 exec_sentinel (Lisp_Object proc, Lisp_Object reason)
 {
   Lisp_Object sentinel, odeactivate;
-  register struct Lisp_Process *p = XPROCESS (proc);
+  struct Lisp_Process *p = XPROCESS (proc);
   ptrdiff_t count = SPECPDL_INDEX ();
-  int outer_running_asynch_code = running_asynch_code;
+  bool outer_running_asynch_code = running_asynch_code;
   int waiting = waiting_for_user_input_p;
 
   if (inhibit_sentinels)
@@ -6448,16 +6233,10 @@ exec_sentinel (Lisp_Object proc, Lisp_Object reason)
   /* There's no good reason to let sentinels change the current
      buffer, and many callers of accept-process-output, sit-for, and
      friends don't expect current-buffer to be changed from under them.  */
-  record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
+  record_unwind_current_buffer ();
 
   sentinel = p->sentinel;
-  if (NILP (sentinel))
-    return;
 
-  /* Zilch the sentinel while it's running, to avoid recursive invocations;
-     assure that it gets restored no matter how the sentinel exits.  */
-  p->sentinel = Qnil;
-  record_unwind_protect (exec_sentinel_unwind, Fcons (proc, sentinel));
   /* Inhibit quit so that random quits don't screw up a running filter.  */
   specbind (Qinhibit_quit, Qt);
   specbind (Qlast_nonmenu_event, Qt); /* Why? --Stef  */
@@ -6479,8 +6258,7 @@ exec_sentinel (Lisp_Object proc, Lisp_Object reason)
   running_asynch_code = 1;
 
   internal_condition_case_1 (read_process_output_call,
-                             Fcons (sentinel,
-                                    Fcons (proc, Fcons (reason, Qnil))),
+                             list3 (sentinel, proc, reason),
                              !NILP (Vdebug_on_error) ? Qnil : Qerror,
                              exec_sentinel_error_handler);
 
@@ -6515,7 +6293,7 @@ exec_sentinel (Lisp_Object proc, Lisp_Object reason)
 static void
 status_notify (struct Lisp_Process *deleting_process)
 {
-  register Lisp_Object proc, buffer;
+  register Lisp_Object proc;
   Lisp_Object tail, msg;
   struct gcpro gcpro1, gcpro2;
 
@@ -6531,13 +6309,10 @@ status_notify (struct Lisp_Process *deleting_process)
      that we run, we get called again to handle their status changes.  */
   update_tick = process_tick;
 
-  for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_PROCESS (tail, proc)
     {
       Lisp_Object symbol;
-      register struct Lisp_Process *p;
-
-      proc = Fcdr (XCAR (tail));
-      p = XPROCESS (proc);
+      register struct Lisp_Process *p = XPROCESS (proc);
 
       if (p->tick != p->update_tick)
         {
@@ -6553,8 +6328,6 @@ status_notify (struct Lisp_Process *deleting_process)
                  && p != deleting_process
                  && read_process_output (proc, p->infd) > 0);
 
-          buffer = p->buffer;
-
           /* Get the text to use for the message.  */
           if (p->raw_status_new)
             update_status (p);
@@ -6575,65 +6348,83 @@ status_notify (struct Lisp_Process *deleting_process)
             }
 
           /* The actions above may have further incremented p->tick.
-             So set p->update_tick again
-             so that an error in the sentinel will not cause
-             this code to be run again.  */
+             So set p->update_tick again so that an error in the sentinel will
+             not cause this code to be run again.  */
           p->update_tick = p->tick;
           /* Now output the message suitably.  */
-          if (!NILP (p->sentinel))
-            exec_sentinel (proc, msg);
-          /* Don't bother with a message in the buffer
-             when a process becomes runnable.  */
-          else if (!EQ (symbol, Qrun) && !NILP (buffer))
-            {
-              Lisp_Object tem;
-              struct buffer *old = current_buffer;
-              ptrdiff_t opoint, opoint_byte;
-              ptrdiff_t before, before_byte;
-
-              /* Avoid error if buffer is deleted
-                 (probably that's why the process is dead, too) */
-              if (NILP (BVAR (XBUFFER (buffer), name)))
-                continue;
-              Fset_buffer (buffer);
-
-              opoint = PT;
-              opoint_byte = PT_BYTE;
-              /* Insert new output into buffer
-                 at the current end-of-output marker,
-                 thus preserving logical ordering of input and output.  */
-              if (XMARKER (p->mark)->buffer)
-                Fgoto_char (p->mark);
-              else
-                SET_PT_BOTH (ZV, ZV_BYTE);
-
-              before = PT;
-              before_byte = PT_BYTE;
-
-              tem = BVAR (current_buffer, read_only);
-              BVAR (current_buffer, read_only) = Qnil;
-              insert_string ("\nProcess ");
-              Finsert (1, &p->name);
-              insert_string (" ");
-              Finsert (1, &msg);
-              BVAR (current_buffer, read_only) = tem;
-              set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
-
-              if (opoint >= before)
-                SET_PT_BOTH (opoint + (PT - before),
-                             opoint_byte + (PT_BYTE - before_byte));
-              else
-                SET_PT_BOTH (opoint, opoint_byte);
-
-              set_buffer_internal (old);
-            }
+          exec_sentinel (proc, msg);
         }
     } /* end for */
 
-  update_mode_lines++;  /* in case buffers use %s in mode-line-format */
+  update_mode_lines++;  /* In case buffers use %s in mode-line-format.  */
   UNGCPRO;
 }
 
+DEFUN ("internal-default-process-sentinel", Finternal_default_process_sentinel,
+       Sinternal_default_process_sentinel, 2, 2, 0,
+       doc: /* Function used as default sentinel for processes.  */)
+     (Lisp_Object proc, Lisp_Object msg)
+{
+  Lisp_Object buffer, symbol;
+  struct Lisp_Process *p;
+  CHECK_PROCESS (proc);
+  p = XPROCESS (proc);
+  buffer = p->buffer;
+  symbol = p->status;
+  if (CONSP (symbol))
+    symbol = XCAR (symbol);
+
+  if (!EQ (symbol, Qrun) && !NILP (buffer))
+    {
+      Lisp_Object tem;
+      struct buffer *old = current_buffer;
+      ptrdiff_t opoint, opoint_byte;
+      ptrdiff_t before, before_byte;
+
+      /* Avoid error if buffer is deleted
+         (probably that's why the process is dead, too).  */
+      if (!BUFFER_LIVE_P (XBUFFER (buffer)))
+        return Qnil;
+      Fset_buffer (buffer);
+
+      if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
+        msg = (code_convert_string_norecord
+               (msg, Vlocale_coding_system, 1));
+
+      opoint = PT;
+      opoint_byte = PT_BYTE;
+      /* Insert new output into buffer
+         at the current end-of-output marker,
+         thus preserving logical ordering of input and output.  */
+      if (XMARKER (p->mark)->buffer)
+        Fgoto_char (p->mark);
+      else
+        SET_PT_BOTH (ZV, ZV_BYTE);
+
+      before = PT;
+      before_byte = PT_BYTE;
+
+      tem = BVAR (current_buffer, read_only);
+      bset_read_only (current_buffer, Qnil);
+      insert_string ("\nProcess ");
+      { /* FIXME: temporary kludge.  */
+        Lisp_Object tem2 = p->name; Finsert (1, &tem2); }
+      insert_string (" ");
+      Finsert (1, &msg);
+      bset_read_only (current_buffer, tem);
+      set_marker_both (p->mark, p->buffer, PT, PT_BYTE);
+
+      if (opoint >= before)
+        SET_PT_BOTH (opoint + (PT - before),
+                     opoint_byte + (PT_BYTE - before_byte));
+      else
+        SET_PT_BOTH (opoint, opoint_byte);
+
+      set_buffer_internal (old);
+    }
+  return Qnil;
+}
+
 
 DEFUN ("set-process-coding-system", Fset_process_coding_system,
        Sset_process_coding_system, 1, 3, 0,
@@ -6653,8 +6444,8 @@ encode subprocess input.  */)
   Fcheck_coding_system (decoding);
   Fcheck_coding_system (encoding);
   encoding = coding_inherit_eol_type (encoding, Qnil);
-  p->decode_coding_system = decoding;
-  p->encode_coding_system = encoding;
+  pset_decode_coding_system (p, decoding);
+  pset_encode_coding_system (p, encoding);
   setup_process_coding_systems (process);
 
   return Qnil;
@@ -6684,7 +6475,8 @@ suppressed.  */)
   CHECK_PROCESS (process);
   p = XPROCESS (process);
   if (NILP (flag))
-    p->decode_coding_system = raw_text_coding_system (p->decode_coding_system);
+    pset_decode_coding_system
+      (p, raw_text_coding_system (p->decode_coding_system));
   setup_process_coding_systems (process);
 
   return Qnil;
@@ -6723,12 +6515,12 @@ delete_gpm_wait_descriptor (int desc)
 
 # endif
 
-# ifdef SIGIO
+# ifdef USABLE_SIGIO
 
-/* Return nonzero if *MASK has a bit set
+/* Return true if *MASK has a bit set
    that corresponds to one of the keyboard input descriptors.  */
 
-static int
+static bool
 keyboard_bit_set (fd_set *mask)
 {
   int fd;
@@ -6745,20 +6537,26 @@ keyboard_bit_set (fd_set *mask)
 #else  /* not subprocesses */
 
 /* Defined on msdos.c.  */
-extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
-                       EMACS_TIME *);
+extern int sys_select (int, fd_set *, fd_set *, fd_set *,
+                       struct timespec *, void *);
 
 /* Implementation of wait_reading_process_output, assuming that there
    are no subprocesses.  Used only by the MS-DOS build.
 
    Wait for timeout to elapse and/or keyboard input to be available.
 
-   time_limit is:
-     timeout in seconds, or
-     zero for no limit, or
-     -1 means gobble data immediately available but don't wait for any.
+   TIME_LIMIT is:
+     timeout in seconds
+     If negative, gobble data immediately available but don't wait for any.
 
-   read_kbd is a Lisp_Object:
+   NSECS is:
+     an additional duration to wait, measured in nanoseconds
+     If TIME_LIMIT is zero, then:
+       If NSECS == 0, there is no limit.
+       If NSECS > 0, the timeout consists of NSECS only.
+       If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
+
+   READ_KBD is:
      0 to ignore keyboard input, or
      1 to return when input is available, or
      -1 means caller will actually read the input, so don't throw to
@@ -6767,28 +6565,33 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
    see full version for other parameters. We know that wait_proc will
      always be NULL, since `subprocesses' isn't defined.
 
-   do_display != 0 means redisplay should be done to show subprocess
+   DO_DISPLAY means redisplay should be done to show subprocess
    output that arrives.
 
    Return true if we received input from any process.  */
 
-int
-wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
-                             int do_display,
+bool
+wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
+                             bool do_display,
                              Lisp_Object wait_for_cell,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
 {
   register int nfds;
-  EMACS_TIME end_time, timeout;
-  SELECT_TYPE waitchannels;
-  int xerrno;
+  struct timespec end_time, timeout;
+
+  if (time_limit < 0)
+    {
+      time_limit = 0;
+      nsecs = -1;
+    }
+  else if (TYPE_MAXIMUM (time_t) < time_limit)
+    time_limit = TYPE_MAXIMUM (time_t);
 
   /* What does time_limit really mean?  */
-  if (time_limit || microsecs)
+  if (time_limit || nsecs > 0)
     {
-      EMACS_GET_TIME (end_time);
-      EMACS_SET_SECS_USECS (timeout, time_limit, microsecs);
-      EMACS_ADD_TIME (end_time, end_time, timeout);
+      timeout = make_timespec (time_limit, nsecs);
+      end_time = timespec_add (current_timespec (), timeout);
     }
 
   /* Turn off periodic alarms (in case they are in use)
@@ -6799,7 +6602,9 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
 
   while (1)
     {
-      int timeout_reduced_for_timers = 0;
+      bool timeout_reduced_for_timers = 0;
+      fd_set waitchannels;
+      int xerrno;
 
       /* If calling from keyboard input, do not quit
          since we want to return C-g as an input character.
@@ -6811,26 +6616,26 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
         break;
 
-      /* Compute time from now till when time limit is up */
-      /* Exit if already run out */
-      if (time_limit == -1)
+      /* Compute time from now till when time limit is up.  */
+      /* Exit if already run out.  */
+      if (nsecs < 0)
         {
-          /* -1 specified for timeout means
+          /* A negative timeout means
              gobble output available now
-             but don't wait at all. */
+             but don't wait at all.  */
 
-          EMACS_SET_SECS_USECS (timeout, 0, 0);
+          timeout = make_timespec (0, 0);
         }
-      else if (time_limit || microsecs)
+      else if (time_limit || nsecs > 0)
         {
-          EMACS_GET_TIME (timeout);
-          EMACS_SUB_TIME (timeout, end_time, timeout);
-          if (EMACS_TIME_NEG_P (timeout))
+          struct timespec now = current_timespec ();
+          if (timespec_cmp (end_time, now) <= 0)
             break;
+          timeout = timespec_sub (end_time, now);
         }
       else
         {
-          EMACS_SET_SECS_USECS (timeout, 100000, 0);
+          timeout = make_timespec (100000, 0);
         }
 
       /* If our caller will not immediately handle keyboard events,
@@ -6839,11 +6644,11 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
          call timer_delay on their own.)  */
       if (NILP (wait_for_cell))
         {
-          EMACS_TIME timer_delay;
+          struct timespec timer_delay;
 
           do
             {
-              int old_timers_run = timers_run;
+              unsigned old_timers_run = timers_run;
               timer_delay = timer_check ();
               if (timers_run != old_timers_run && do_display)
                 /* We must retry, since a timer may have requeued itself
@@ -6859,11 +6664,9 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
               && requeued_events_pending_p ())
             break;
 
-          if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1)
+          if (timespec_valid_p (timer_delay) && nsecs >= 0)
             {
-              EMACS_TIME difference;
-              EMACS_SUB_TIME (difference, timer_delay, timeout);
-              if (EMACS_TIME_NEG_P (difference))
+              if (timespec_cmp (timer_delay, timeout) < 0)
                 {
                   timeout = timer_delay;
                   timeout_reduced_for_timers = 1;
@@ -6876,13 +6679,6 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       if (read_kbd < 0)
         set_waiting_for_input (&timeout);
 
-      /* Wait till there is something to do.  */
-
-      if (! read_kbd && NILP (wait_for_cell))
-        FD_ZERO (&waitchannels);
-      else
-        FD_SET (0, &waitchannels);
-
       /* If a frame has been newly mapped and needs updating,
          reprocess its display stuff.  */
       if (frame_garbaged && do_display)
@@ -6893,14 +6689,16 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
             set_waiting_for_input (&timeout);
         }
 
+      /* Wait till there is something to do.  */
+      FD_ZERO (&waitchannels);
       if (read_kbd && detect_input_pending ())
+        nfds = 0;
+      else
         {
-          nfds = 0;
-          FD_ZERO (&waitchannels);
+          if (read_kbd || !NILP (wait_for_cell))
+            FD_SET (0, &waitchannels);
+          nfds = pselect (1, &waitchannels, NULL, NULL, &timeout, NULL);
         }
-      else
-        nfds = select (1, &waitchannels, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
-                       &timeout);
 
       xerrno = errno;
 
@@ -6910,7 +6708,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
       /*  If we woke up due to SIGWINCH, actually change size now.  */
       do_pending_window_change (0);
 
-      if (time_limit && nfds == 0 && ! timeout_reduced_for_timers)
+      if ((time_limit || nsecs) && nfds == 0 && ! timeout_reduced_for_timers)
         /* We waited the full specified time, so return now.  */
         break;
 
@@ -6921,7 +6719,7 @@ wait_reading_process_output (int time_limit, int microsecs, int read_kbd,
           if (xerrno == EINTR)
             FD_ZERO (&waitchannels);
           else
-            error ("select error: %s", emacs_strerror (xerrno));
+            report_file_errno ("Failed select", Qnil, xerrno);
         }
 
       /* Check for keyboard input */
@@ -6987,16 +6785,9 @@ void
 delete_keyboard_wait_descriptor (int desc)
 {
 #ifdef subprocesses
-  int fd;
-  int lim = max_input_desc;
-
   FD_CLR (desc, &input_wait_mask);
   FD_CLR (desc, &non_process_wait_mask);
-
-  if (desc == max_input_desc)
-    for (fd = 0; fd < lim; fd++)
-      if (FD_ISSET (fd, &input_wait_mask) || FD_ISSET (fd, &write_mask))
-        max_input_desc = fd;
+  delete_input_desc (desc);
 #endif
 }
 
@@ -7015,12 +6806,10 @@ setup_process_coding_systems (Lisp_Object process)
     return;
 
   if (!proc_decode_coding_system[inch])
-    proc_decode_coding_system[inch]
-      = (struct coding_system *) xmalloc (sizeof (struct coding_system));
+    proc_decode_coding_system[inch] = xmalloc (sizeof (struct coding_system));
   coding_system = p->decode_coding_system;
-  if (! NILP (p->filter))
-    ;
-  else if (BUFFERP (p->buffer))
+  if (EQ (p->filter, Qinternal_default_process_filter)
+      && BUFFERP (p->buffer))
     {
       if (NILP (BVAR (XBUFFER (p->buffer), enable_multibyte_characters)))
         coding_system = raw_text_coding_system (coding_system);
@@ -7028,39 +6817,12 @@ setup_process_coding_systems (Lisp_Object process)
   setup_coding_system (coding_system, proc_decode_coding_system[inch]);
 
   if (!proc_encode_coding_system[outch])
-    proc_encode_coding_system[outch]
-      = (struct coding_system *) xmalloc (sizeof (struct coding_system));
+    proc_encode_coding_system[outch] = xmalloc (sizeof (struct coding_system));
   setup_coding_system (p->encode_coding_system,
                        proc_encode_coding_system[outch]);
 #endif
 }
 
-/* Close all descriptors currently in use for communication
-   with subprocess.  This is used in a newly-forked subprocess
-   to get rid of irrelevant descriptors.  */
-
-void
-close_process_descs (void)
-{
-#ifndef DOS_NT
-  int i;
-  for (i = 0; i < MAXDESC; i++)
-    {
-      Lisp_Object process;
-      process = chan_process[i];
-      if (!NILP (process))
-        {
-          int in  = XPROCESS (process)->infd;
-          int out = XPROCESS (process)->outfd;
-          if (in >= 0)
-            emacs_close (in);
-          if (out >= 0 && in != out)
-            emacs_close (out);
-        }
-    }
-#endif
-}
-
 DEFUN ("get-buffer-process", Fget_buffer_process, Sget_buffer_process, 1, 1, 0,
        doc: /* Return the (or a) process associated with BUFFER.
 BUFFER may be a buffer or the name of one.  */)
@@ -7073,12 +6835,9 @@ BUFFER may be a buffer or the name of one.  */)
   buf = Fget_buffer (buffer);
   if (NILP (buf)) return Qnil;
 
-  for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
-    {
-      proc = Fcdr (XCAR (tail));
-      if (PROCESSP (proc) && EQ (XPROCESS (proc)->buffer, buf))
-        return proc;
-    }
+  FOR_EACH_PROCESS (tail, proc)
+    if (EQ (XPROCESS (proc)->buffer, buf))
+      return proc;
 #endif  /* subprocesses */
   return Qnil;
 }
@@ -7111,18 +6870,14 @@ kill_buffer_processes (Lisp_Object buffer)
 #ifdef subprocesses
   Lisp_Object tail, proc;
 
-  for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
-    {
-      proc = XCDR (XCAR (tail));
-      if (PROCESSP (proc)
-          && (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer)))
-        {
-          if (NETCONN_P (proc) || SERIALCONN_P (proc))
-            Fdelete_process (proc);
-          else if (XPROCESS (proc)->infd >= 0)
-            process_send_signal (proc, SIGHUP, Qnil, 1);
-        }
-    }
+  FOR_EACH_PROCESS (tail, proc)
+    if (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer))
+      {
+        if (NETCONN_P (proc) || SERIALCONN_P (proc))
+          Fdelete_process (proc);
+        else if (XPROCESS (proc)->infd >= 0)
+          process_send_signal (proc, SIGHUP, Qnil, 1);
+      }
 #else  /* subprocesses */
   /* Since we have no subprocesses, this does nothing.  */
 #endif /* subprocesses */
@@ -7130,7 +6885,7 @@ kill_buffer_processes (Lisp_Object buffer)
 
 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p,
        Swaiting_for_user_input_p, 0, 0, 0,
-       doc: /* Returns non-nil if Emacs is waiting for input from the user.
+       doc: /* Return non-nil if Emacs is waiting for input from the user.
 This is intended for use by asynchronous process output filters and sentinels.  */)
   (void)
 {
@@ -7157,9 +6912,9 @@ unhold_keyboard_input (void)
   kbd_is_on_hold = 0;
 }
 
-/* Return non-zero if keyboard input is on hold, zero otherwise.  */
+/* Return true if keyboard input is on hold, zero otherwise.  */
 
-int
+bool
 kbd_on_hold_p (void)
 {
   return kbd_is_on_hold;
@@ -7213,19 +6968,20 @@ integer or floating point values.
  majflt  -- number of major page faults (number)
  cminflt -- cumulative number of minor page faults (number)
  cmajflt -- cumulative number of major page faults (number)
- utime   -- user time used by the process, in the (HIGH LOW USEC) format
- stime   -- system time used by the process, in the (HIGH LOW USEC) format
- time    -- sum of utime and stime, in the (HIGH LOW USEC) format
- cutime  -- user time used by the process and its children, (HIGH LOW USEC)
- cstime  -- system time used by the process and its children, (HIGH LOW USEC)
- ctime   -- sum of cutime and cstime, in the (HIGH LOW USEC) format
+ utime   -- user time used by the process, in (current-time) format,
+              which is a list of integers (HIGH LOW USEC PSEC)
+ stime   -- system time used by the process (current-time)
+ time    -- sum of utime and stime (current-time)
+ cutime  -- user time used by the process and its children (current-time)
+ cstime  -- system time used by the process and its children (current-time)
+ ctime   -- sum of cutime and cstime (current-time)
  pri     -- priority of the process (number)
  nice    -- nice value of the process (number)
  thcount -- process thread count (number)
- start   -- time the process started, in the (HIGH LOW USEC) format
+ start   -- time the process started (current-time)
  vsize   -- virtual memory size of the process in KB's (number)
  rss     -- resident set size of the process in KB's (number)
- etime   -- elapsed time the process is running, in (HIGH LOW USEC) format
+ etime   -- elapsed time the process is running, in (HIGH LOW USEC PSEC) format
  pcpu    -- percents of CPU time used by the process (floating-point number)
  pmem    -- percents of total physical memory used by process's resident set
               (floating-point number)
@@ -7235,27 +6991,61 @@ integer or floating point values.
   return system_process_attributes (pid);
 }
 
+/* Arrange to catch SIGCHLD if this hasn't already been arranged.
+   Invoke this after init_process_emacs, and after glib and/or GNUstep
+   futz with the SIGCHLD handler, but before Emacs forks any children.
+   This function's caller should block SIGCHLD.  */
+
+#ifndef NS_IMPL_GNUSTEP
+static
+#endif
+void
+catch_child_signal (void)
+{
+  struct sigaction action, old_action;
+  emacs_sigaction_init (&action, deliver_child_signal);
+  block_child_signal ();
+  sigaction (SIGCHLD, &action, &old_action);
+  eassert (! (old_action.sa_flags & SA_SIGINFO));
+
+  if (old_action.sa_handler != deliver_child_signal)
+    lib_child_handler
+      = (old_action.sa_handler == SIG_DFL || old_action.sa_handler == SIG_IGN
+         ? dummy_handler
+         : old_action.sa_handler);
+  unblock_child_signal ();
+}
+
 
+/* This is not called "init_process" because that is the name of a
+   Mach system call, so it would cause problems on Darwin systems.  */
 void
-init_process (void)
+init_process_emacs (void)
 {
 #ifdef subprocesses
   register int i;
 
   inhibit_sentinels = 0;
 
-#ifdef SIGCHLD
 #ifndef CANNOT_DUMP
   if (! noninteractive || initialized)
 #endif
-    signal (SIGCHLD, sigchld_handler);
-#endif
+    {
+#if defined HAVE_GLIB && !defined WINDOWSNT
+      /* Tickle glib's child-handling code.  Ask glib to wait for Emacs itself;
+         this should always fail, but is enough to initialize glib's
+         private SIGCHLD handler, allowing catch_child_signal to copy
+         it into lib_child_handler.  */
+      g_source_unref (g_child_watch_source_new (getpid ()));
+#endif
+      catch_child_signal ();
+    }
 
   FD_ZERO (&input_wait_mask);
   FD_ZERO (&non_keyboard_wait_mask);
   FD_ZERO (&non_process_wait_mask);
   FD_ZERO (&write_mask);
-  max_process_desc = 0;
+  max_process_desc = max_input_desc = -1;
   memset (fd_callback_info, 0, sizeof (fd_callback_info));
 
 #ifdef NON_BLOCKING_CONNECT
@@ -7276,10 +7066,8 @@ init_process (void)
 #endif
 
   Vprocess_alist = Qnil;
-#ifdef SIGCHLD
   deleted_pid_list = Qnil;
-#endif
-  for (i = 0; i < MAXDESC; i++)
+  for (i = 0; i < FD_SETSIZE; i++)
     {
       chan_process[i] = Qnil;
       proc_buffered_char[i] = -1;
@@ -7316,9 +7104,7 @@ init_process (void)
 #ifdef HAVE_GETSOCKNAME
    ADD_SUBFEATURE (QCservice, Qt);
 #endif
-#if defined (O_NONBLOCK) || defined (O_NDELAY)
    ADD_SUBFEATURE (QCserver, Qt);
-#endif
 
    for (sopt = socket_options; sopt->name; sopt++)
      subfeatures = pure_cons (intern_c_string (sopt->name), subfeatures);
@@ -7334,8 +7120,7 @@ init_process (void)
     char const *release = (STRINGP (Voperating_system_release)
                            ? SSDATA (Voperating_system_release)
                            : 0);
-    if (!release || !release[0] || (release[0] < MIN_PTY_KERNEL_VERSION
-                                    && release[1] == '.')) {
+    if (!release || !release[0] || (release[0] < '7' && release[1] == '.')) {
       Vprocess_connection_type = Qnil;
     }
   }
@@ -7408,9 +7193,7 @@ syms_of_process (void)
   DEFSYM (Qlast_nonmenu_event, "last-nonmenu-event");
 
   staticpro (&Vprocess_alist);
-#ifdef SIGCHLD
   staticpro (&deleted_pid_list);
-#endif
 
 #endif  /* subprocesses */
 
@@ -7438,6 +7221,10 @@ syms_of_process (void)
   DEFSYM (Qcutime, "cutime");
   DEFSYM (Qcstime, "cstime");
   DEFSYM (Qctime, "ctime");
+  DEFSYM (Qinternal_default_process_sentinel,
+          "internal-default-process-sentinel");
+  DEFSYM (Qinternal_default_process_filter,
+          "internal-default-process-filter");
   DEFSYM (Qpri, "pri");
   DEFSYM (Qnice, "nice");
   DEFSYM (Qthcount, "thcount");
@@ -7533,6 +7320,8 @@ The variable takes effect when `start-process' is called.  */);
   defsubr (&Ssignal_process);
   defsubr (&Swaiting_for_user_input_p);
   defsubr (&Sprocess_type);
+  defsubr (&Sinternal_default_process_sentinel);
+  defsubr (&Sinternal_default_process_filter);
   defsubr (&Sset_process_coding_system);
   defsubr (&Sprocess_coding_system);
   defsubr (&Sset_process_filter_multibyte);