process.c 241 KB
Newer Older
Jim Blandy's avatar
Jim Blandy committed
1
/* Asynchronous subprocess control for GNU Emacs.
2

Paul Eggert's avatar
Paul Eggert committed
3
Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2018 Free Software
Paul Eggert's avatar
Paul Eggert committed
4
Foundation, Inc.
Jim Blandy's avatar
Jim Blandy committed
5 6 7

This file is part of GNU Emacs.

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

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

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


22
#include <config.h>
Paul Eggert's avatar
Paul Eggert committed
23

Jim Blandy's avatar
Jim Blandy committed
24
#include <stdio.h>
Paul Eggert's avatar
Paul Eggert committed
25
#include <stdlib.h>
Jim Blandy's avatar
Jim Blandy committed
26
#include <errno.h>
27
#include <sys/types.h>		/* Some typedefs are used in sys/file.h.  */
Jim Blandy's avatar
Jim Blandy committed
28 29
#include <sys/file.h>
#include <sys/stat.h>
Richard M. Stallman's avatar
Richard M. Stallman committed
30
#include <unistd.h>
31 32
#include <fcntl.h>

33 34
#include "lisp.h"

35 36 37
/* Only MS-DOS does not define `subprocesses'.  */
#ifdef subprocesses

Jim Blandy's avatar
Jim Blandy committed
38 39 40 41
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
42

Eli Zaretskii's avatar
Eli Zaretskii committed
43 44
#endif	/* subprocesses */

Paul Eggert's avatar
Paul Eggert committed
45 46
#ifdef HAVE_SETRLIMIT
# include <sys/resource.h>
47 48 49 50 51

/* If NOFILE_LIMIT.rlim_cur is greater than FD_SETSIZE, then
   NOFILE_LIMIT is the initial limit on the number of open files,
   which should be restored in child processes.  */
static struct rlimit nofile_limit;
Paul Eggert's avatar
Paul Eggert committed
52 53
#endif

Eli Zaretskii's avatar
Eli Zaretskii committed
54 55
#ifdef subprocesses

56
/* Are local (unix) sockets supported?  */
57
#if defined (HAVE_SYS_UN_H)
58 59 60 61 62 63 64 65
#if !defined (AF_LOCAL) && defined (AF_UNIX)
#define AF_LOCAL AF_UNIX
#endif
#ifdef AF_LOCAL
#define HAVE_LOCAL_SOCKETS
#include <sys/un.h>
#endif
#endif
Jim Blandy's avatar
Jim Blandy committed
66 67

#include <sys/ioctl.h>
Juanma Barranquero's avatar
Juanma Barranquero committed
68
#if defined (HAVE_NET_IF_H)
69 70
#include <net/if.h>
#endif /* HAVE_NET_IF_H */
Jim Blandy's avatar
Jim Blandy committed
71

Juanma Barranquero's avatar
Juanma Barranquero committed
72
#if defined (HAVE_IFADDRS_H)
73 74 75 76
/* Must be after net/if.h */
#include <ifaddrs.h>

/* We only use structs from this header when we use getifaddrs.  */
Juanma Barranquero's avatar
Juanma Barranquero committed
77
#if defined (HAVE_NET_IF_DL_H)
78 79 80 81 82
#include <net/if_dl.h>
#endif

#endif

Jim Blandy's avatar
Jim Blandy committed
83 84 85 86
#ifdef NEED_BSDTTY
#include <bsdtty.h>
#endif

Paul Eggert's avatar
Paul Eggert committed
87 88 89 90 91
#ifdef USG5_4
# include <sys/stream.h>
# include <sys/stropts.h>
#endif

92 93 94 95
#ifdef HAVE_UTIL_H
#include <util.h>
#endif

Dan Nicolaescu's avatar
Dan Nicolaescu committed
96 97 98 99
#ifdef HAVE_PTY_H
#include <pty.h>
#endif

100
#include <c-ctype.h>
101
#include <flexmember.h>
102
#include <sig2str.h>
103
#include <verify.h>
104

105 106
#endif	/* subprocesses */

Jim Blandy's avatar
Jim Blandy committed
107
#include "systime.h"
108
#include "systty.h"
Jim Blandy's avatar
Jim Blandy committed
109 110

#include "window.h"
111
#include "character.h"
112
#include "buffer.h"
Karl Heuer's avatar
Karl Heuer committed
113
#include "coding.h"
Jim Blandy's avatar
Jim Blandy committed
114
#include "process.h"
115
#include "frame.h"
Jim Blandy's avatar
Jim Blandy committed
116
#include "termopts.h"
117
#include "keyboard.h"
Richard M. Stallman's avatar
Richard M. Stallman committed
118
#include "blockinput.h"
Gerd Moellmann's avatar
Gerd Moellmann committed
119
#include "atimer.h"
120 121 122
#include "sysselect.h"
#include "syssignal.h"
#include "syswait.h"
Ted Zlatanov's avatar
Ted Zlatanov committed
123 124 125
#ifdef HAVE_GNUTLS
#include "gnutls.h"
#endif
Jim Blandy's avatar
Jim Blandy committed
126

127 128 129 130
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
#endif /* HAVE_WINDOW_SYSTEM */

131
#ifdef HAVE_GLIB
132
#include "xgselect.h"
133 134 135
#ifndef WINDOWSNT
#include <glib.h>
#endif
136
#endif
Dan Nicolaescu's avatar
Dan Nicolaescu committed
137

138 139 140 141 142
#if defined HAVE_GETADDRINFO_A || defined HAVE_GNUTLS
/* This is 0.1s in nanoseconds. */
#define ASYNC_RETRY_NSEC 100000000
#endif

143
#ifdef WINDOWSNT
144
extern int sys_select (int, fd_set *, fd_set *, fd_set *,
145
                       const struct timespec *, const sigset_t *);
146 147
#endif

148
/* Work around GCC 4.3.0 bug with strict overflow checking; see
149
   <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52904>.
150
   This bug appears to be fixed in GCC 5.1, so don't work around it there.  */
151
#if GNUC_PREREQ (4, 3, 0) && ! GNUC_PREREQ (5, 1, 0)
Eli Zaretskii's avatar
Eli Zaretskii committed
152 153 154 155 156 157 158 159 160 161 162
# pragma GCC diagnostic ignored "-Wstrict-overflow"
#endif

/* True if keyboard input is on hold, zero otherwise.  */

static bool kbd_is_on_hold;

/* Nonzero means don't run process sentinels.  This is used
   when exiting.  */
bool inhibit_sentinels;

163 164 165 166 167 168 169 170 171 172 173 174
union u_sockaddr
{
  struct sockaddr sa;
  struct sockaddr_in in;
#ifdef AF_INET6
  struct sockaddr_in6 in6;
#endif
#ifdef HAVE_LOCAL_SOCKETS
  struct sockaddr_un un;
#endif
};

Eli Zaretskii's avatar
Eli Zaretskii committed
175 176
#ifdef subprocesses

177 178
#ifndef SOCK_CLOEXEC
# define SOCK_CLOEXEC 0
Paul Eggert's avatar
Paul Eggert committed
179
#endif
180
#ifndef SOCK_NONBLOCK
181
# define SOCK_NONBLOCK 0
182
#endif
Paul Eggert's avatar
Paul Eggert committed
183

184 185 186 187 188 189 190 191 192 193 194 195
/* True if ERRNUM represents an error where the system call would
   block if a blocking variant were used.  */
static bool
would_block (int errnum)
{
#ifdef EWOULDBLOCK
  if (EWOULDBLOCK != EAGAIN && errnum == EWOULDBLOCK)
    return true;
#endif
  return errnum == EAGAIN;
}

Paul Eggert's avatar
Paul Eggert committed
196
#ifndef HAVE_ACCEPT4
197 198 199 200 201 202 203 204 205 206 207

/* 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;
}

208 209 210
# undef accept4
# define accept4(sockfd, addr, addrlen, flags) \
    process_accept4 (sockfd, addr, addrlen, flags)
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
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

226 227 228 229
#define NETCONN_P(p) (EQ (XPROCESS (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))
230 231
#define PIPECONN_P(p) (EQ (XPROCESS (p)->type, Qpipe))
#define PIPECONN1_P(p) (EQ (p->type, Qpipe))
Jim Blandy's avatar
Jim Blandy committed
232 233

/* Number of events of change of status of a process.  */
234
static EMACS_INT process_tick;
Jim Blandy's avatar
Jim Blandy committed
235
/* Number of events for which the user or sentinel has been notified.  */
236
static EMACS_INT update_tick;
Jim Blandy's avatar
Jim Blandy committed
237

238 239 240 241 242
/* Define DATAGRAM_SOCKETS if datagrams can be used safely on
   this system.  We need to read full packets, so we need a
   "non-destructive" select.  So we require either native select,
   or emulation of select using FIONREAD.  */

Paul Eggert's avatar
Paul Eggert committed
243 244 245 246 247 248 249
#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
250

Stefan Monnier's avatar
Stefan Monnier committed
251 252 253 254
#if defined HAVE_LOCAL_SOCKETS && defined DATAGRAM_SOCKETS
# define HAVE_SEQPACKET
#endif

255
#define READ_OUTPUT_DELAY_INCREMENT (TIMESPEC_RESOLUTION / 100)
Kenichi Handa's avatar
Kenichi Handa committed
256 257 258
#define READ_OUTPUT_DELAY_MAX       (READ_OUTPUT_DELAY_INCREMENT * 5)
#define READ_OUTPUT_DELAY_MAX_MAX   (READ_OUTPUT_DELAY_INCREMENT * 7)

259 260
/* Number of processes which have a non-zero read_output_delay,
   and therefore might be delayed for adaptive read buffering.  */
Kenichi Handa's avatar
Kenichi Handa committed
261 262 263

static int process_output_delay_count;

264
/* True if any process has non-nil read_output_skip.  */
Kenichi Handa's avatar
Kenichi Handa committed
265

266
static bool process_output_skip;
Kenichi Handa's avatar
Kenichi Handa committed
267

268
static void start_process_unwind (Lisp_Object);
269
static void create_process (Lisp_Object, char **, Lisp_Object);
Paul Eggert's avatar
Paul Eggert committed
270
#ifdef USABLE_SIGIO
271
static bool keyboard_bit_set (fd_set *);
272
#endif
273
static void deactivate_process (Lisp_Object);
274
static int status_notify (struct Lisp_Process *, struct Lisp_Process *);
275 276
static int read_process_output (Lisp_Object, int);
static void create_pty (Lisp_Object);
277
static void exec_sentinel (Lisp_Object, Lisp_Object);
278

279 280
/* Number of bits set in connect_wait_mask.  */
static int num_pending_connects;
281

Tom Tromey's avatar
Tom Tromey committed
282
/* The largest descriptor currently in use; -1 if none.  */
Tom Tromey's avatar
Tom Tromey committed
283
static int max_desc;
284

285 286 287 288
/* Set the external socket descriptor for Emacs to use when
   `make-network-process' is called with a non-nil
   `:use-external-socket' option.  The value should be either -1, or
   the file descriptor of a socket that is already bound.  */
289
static int external_sock_fd;
290

291
/* Indexed by descriptor, gives the process (if any) for that descriptor.  */
292
static Lisp_Object chan_process[FD_SETSIZE];
293
static void wait_for_socket_fds (Lisp_Object, char const *);
Jim Blandy's avatar
Jim Blandy committed
294

295
/* Alist of elements (NAME . PROCESS).  */
296
static Lisp_Object Vprocess_alist;
Jim Blandy's avatar
Jim Blandy committed
297 298 299 300 301 302 303

/* Buffered-ahead input char from process, indexed by channel.
   -1 means empty (no char is buffered).
   Used on sys V where the only way to tell if there is any
   output from the process is to read at least one char.
   Always -1 on systems that support FIONREAD.  */

304
static int proc_buffered_char[FD_SETSIZE];
305

Karl Heuer's avatar
Karl Heuer committed
306
/* Table of `struct coding-system' for each process.  */
307 308
static struct coding_system *proc_decode_coding_system[FD_SETSIZE];
static struct coding_system *proc_encode_coding_system[FD_SETSIZE];
Karl Heuer's avatar
Karl Heuer committed
309

310 311
#ifdef DATAGRAM_SOCKETS
/* Table of `partner address' for datagram sockets.  */
312
static struct sockaddr_and_len {
313
  struct sockaddr *sa;
314
  ptrdiff_t len;
315
} datagram_address[FD_SETSIZE];
316
#define DATAGRAM_CHAN_P(chan)	(datagram_address[chan].sa != 0)
317 318 319 320
#define DATAGRAM_CONN_P(proc)                                           \
  (PROCESSP (proc) &&                                                   \
   XPROCESS (proc)->infd >= 0 &&                                        \
   datagram_address[XPROCESS (proc)->infd].sa != 0)
321 322 323 324
#else
#define DATAGRAM_CONN_P(proc)	(0)
#endif

325 326 327 328 329 330
/* 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)

Paul Eggert's avatar
Paul Eggert committed
331
/* These setters are used only in this file, so they can be private.  */
332
static void
Paul Eggert's avatar
Paul Eggert committed
333 334 335 336
pset_buffer (struct Lisp_Process *p, Lisp_Object val)
{
  p->buffer = val;
}
337
static void
Paul Eggert's avatar
Paul Eggert committed
338 339 340 341
pset_command (struct Lisp_Process *p, Lisp_Object val)
{
  p->command = val;
}
342
static void
Paul Eggert's avatar
Paul Eggert committed
343 344 345 346
pset_decode_coding_system (struct Lisp_Process *p, Lisp_Object val)
{
  p->decode_coding_system = val;
}
347
static void
Paul Eggert's avatar
Paul Eggert committed
348 349 350 351
pset_decoding_buf (struct Lisp_Process *p, Lisp_Object val)
{
  p->decoding_buf = val;
}
352
static void
Paul Eggert's avatar
Paul Eggert committed
353 354 355 356
pset_encode_coding_system (struct Lisp_Process *p, Lisp_Object val)
{
  p->encode_coding_system = val;
}
357
static void
Paul Eggert's avatar
Paul Eggert committed
358 359 360 361
pset_encoding_buf (struct Lisp_Process *p, Lisp_Object val)
{
  p->encoding_buf = val;
}
362
static void
Paul Eggert's avatar
Paul Eggert committed
363 364
pset_filter (struct Lisp_Process *p, Lisp_Object val)
{
365
  p->filter = NILP (val) ? Qinternal_default_process_filter : val;
Paul Eggert's avatar
Paul Eggert committed
366
}
367
static void
Paul Eggert's avatar
Paul Eggert committed
368 369 370 371
pset_log (struct Lisp_Process *p, Lisp_Object val)
{
  p->log = val;
}
372
static void
Paul Eggert's avatar
Paul Eggert committed
373 374 375 376
pset_mark (struct Lisp_Process *p, Lisp_Object val)
{
  p->mark = val;
}
377
static void
Tom Tromey's avatar
Tom Tromey committed
378 379 380 381
pset_thread (struct Lisp_Process *p, Lisp_Object val)
{
  p->thread = val;
}
Tom Tromey's avatar
Tom Tromey committed
382
static void
Paul Eggert's avatar
Paul Eggert committed
383 384 385 386
pset_name (struct Lisp_Process *p, Lisp_Object val)
{
  p->name = val;
}
387
static void
Paul Eggert's avatar
Paul Eggert committed
388 389 390 391
pset_plist (struct Lisp_Process *p, Lisp_Object val)
{
  p->plist = val;
}
392
static void
Paul Eggert's avatar
Paul Eggert committed
393 394
pset_sentinel (struct Lisp_Process *p, Lisp_Object val)
{
395
  p->sentinel = NILP (val) ? Qinternal_default_process_sentinel : val;
Paul Eggert's avatar
Paul Eggert committed
396
}
397
static void
Paul Eggert's avatar
Paul Eggert committed
398 399 400 401
pset_tty_name (struct Lisp_Process *p, Lisp_Object val)
{
  p->tty_name = val;
}
402
static void
Paul Eggert's avatar
Paul Eggert committed
403 404 405 406
pset_type (struct Lisp_Process *p, Lisp_Object val)
{
  p->type = val;
}
407
static void
Paul Eggert's avatar
Paul Eggert committed
408 409 410 411
pset_write_queue (struct Lisp_Process *p, Lisp_Object val)
{
  p->write_queue = val;
}
412 413 414 415 416
static void
pset_stderrproc (struct Lisp_Process *p, Lisp_Object val)
{
  p->stderrproc = val;
}
Paul Eggert's avatar
Paul Eggert committed
417

418

Dmitry Antipov's avatar
Dmitry Antipov committed
419 420 421 422 423
static Lisp_Object
make_lisp_proc (struct Lisp_Process *p)
{
  return make_lisp_ptr (p, Lisp_Vectorlike);
}
424

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
enum fd_bits
{
  /* Read from file descriptor.  */
  FOR_READ = 1,
  /* Write to file descriptor.  */
  FOR_WRITE = 2,
  /* This descriptor refers to a keyboard.  Only valid if FOR_READ is
     set.  */
  KEYBOARD_FD = 4,
  /* This descriptor refers to a process.  */
  PROCESS_FD = 8,
  /* A non-blocking connect.  Only valid if FOR_WRITE is set.  */
  NON_BLOCKING_CONNECT_FD = 16
};

440
static struct fd_callback_data
441 442 443
{
  fd_callback func;
  void *data;
444 445
  /* Flags from enum fd_bits.  */
  int flags;
Tom Tromey's avatar
Tom Tromey committed
446 447 448 449 450 451 452
  /* If this fd is locked to a certain thread, this points to it.
     Otherwise, this is NULL.  If an fd is locked to a thread, then
     only that thread is permitted to wait on it.  */
  struct thread_state *thread;
  /* If this fd is currently being selected on by a thread, this
     points to the thread.  Otherwise it is NULL.  */
  struct thread_state *waiting_thread;
453
} fd_callback_info[FD_SETSIZE];
454 455 456 457 458 459 460 461 462 463 464 465


/* Add a file descriptor FD to be monitored for when read is possible.
   When read is possible, call FUNC with argument DATA.  */

void
add_read_fd (int fd, fd_callback func, void *data)
{
  add_keyboard_wait_descriptor (fd);

  fd_callback_info[fd].func = func;
  fd_callback_info[fd].data = data;
466 467
}

Tom Tromey's avatar
Tom Tromey committed
468
static void
469 470
add_non_keyboard_read_fd (int fd)
{
Ken Raeburn's avatar
Ken Raeburn committed
471
  eassert (fd >= 0 && fd < FD_SETSIZE);
472
  eassert (fd_callback_info[fd].func == NULL);
Eli Zaretskii's avatar
Eli Zaretskii committed
473 474

  fd_callback_info[fd].flags &= ~KEYBOARD_FD;
475
  fd_callback_info[fd].flags |= FOR_READ;
Tom Tromey's avatar
Tom Tromey committed
476 477
  if (fd > max_desc)
    max_desc = fd;
478 479
}

Tom Tromey's avatar
Tom Tromey committed
480
static void
481 482 483 484
add_process_read_fd (int fd)
{
  add_non_keyboard_read_fd (fd);
  fd_callback_info[fd].flags |= PROCESS_FD;
485 486 487 488 489 490 491 492 493
}

/* Stop monitoring file descriptor FD for when read is possible.  */

void
delete_read_fd (int fd)
{
  delete_keyboard_wait_descriptor (fd);

494
  if (fd_callback_info[fd].flags == 0)
495 496 497 498 499 500 501 502 503 504 505 506
    {
      fd_callback_info[fd].func = 0;
      fd_callback_info[fd].data = 0;
    }
}

/* Add a file descriptor FD to be monitored for when write is possible.
   When write is possible, call FUNC with argument DATA.  */

void
add_write_fd (int fd, fd_callback func, void *data)
{
Eli Zaretskii's avatar
Eli Zaretskii committed
507
  eassert (fd >= 0 && fd < FD_SETSIZE);
508 509 510

  fd_callback_info[fd].func = func;
  fd_callback_info[fd].data = data;
511
  fd_callback_info[fd].flags |= FOR_WRITE;
Eli Zaretskii's avatar
Eli Zaretskii committed
512 513
  if (fd > max_desc)
    max_desc = fd;
514 515
}

Tom Tromey's avatar
Tom Tromey committed
516
static void
517 518
add_non_blocking_write_fd (int fd)
{
Ken Raeburn's avatar
Ken Raeburn committed
519
  eassert (fd >= 0 && fd < FD_SETSIZE);
520 521 522
  eassert (fd_callback_info[fd].func == NULL);

  fd_callback_info[fd].flags |= FOR_WRITE | NON_BLOCKING_CONNECT_FD;
Tom Tromey's avatar
Tom Tromey committed
523 524
  if (fd > max_desc)
    max_desc = fd;
525
  ++num_pending_connects;
526
}
527 528

static void
Tom Tromey's avatar
Tom Tromey committed
529
recompute_max_desc (void)
530
{
Tom Tromey's avatar
Tom Tromey committed
531
  int fd;
532

Tom Tromey's avatar
Tom Tromey committed
533 534 535 536 537 538 539
  for (fd = max_desc; fd >= 0; --fd)
    {
      if (fd_callback_info[fd].flags != 0)
	{
	  max_desc = fd;
	  break;
	}
540 541 542
    }
}

543 544 545 546 547
/* Stop monitoring file descriptor FD for when write is possible.  */

void
delete_write_fd (int fd)
{
548 549 550
  if ((fd_callback_info[fd].flags & NON_BLOCKING_CONNECT_FD) != 0)
    {
      if (--num_pending_connects < 0)
Eli Zaretskii's avatar
Eli Zaretskii committed
551
	emacs_abort ();
552 553 554
    }
  fd_callback_info[fd].flags &= ~(FOR_WRITE | NON_BLOCKING_CONNECT_FD);
  if (fd_callback_info[fd].flags == 0)
555 556 557 558
    {
      fd_callback_info[fd].func = 0;
      fd_callback_info[fd].data = 0;

Tom Tromey's avatar
Tom Tromey committed
559 560
      if (fd == max_desc)
	recompute_max_desc ();
561 562 563 564
    }
}

static void
Ken Raeburn's avatar
Ken Raeburn committed
565
compute_input_wait_mask (fd_set *mask)
566 567
{
  int fd;
568

569
  FD_ZERO (mask);
Tom Tromey's avatar
Tom Tromey committed
570
  for (fd = 0; fd <= max_desc; ++fd)
571
    {
Tom Tromey's avatar
Tom Tromey committed
572 573 574 575 576 577
      if (fd_callback_info[fd].thread != NULL
	  && fd_callback_info[fd].thread != current_thread)
	continue;
      if (fd_callback_info[fd].waiting_thread != NULL
	  && fd_callback_info[fd].waiting_thread != current_thread)
	continue;
578
      if ((fd_callback_info[fd].flags & FOR_READ) != 0)
Tom Tromey's avatar
Tom Tromey committed
579 580 581 582
	{
	  FD_SET (fd, mask);
	  fd_callback_info[fd].waiting_thread = current_thread;
	}
583 584 585
    }
}

586
static void
Ken Raeburn's avatar
Ken Raeburn committed
587
compute_non_process_wait_mask (fd_set *mask)
588 589 590 591
{
  int fd;

  FD_ZERO (mask);
Tom Tromey's avatar
Tom Tromey committed
592
  for (fd = 0; fd <= max_desc; ++fd)
593
    {
Tom Tromey's avatar
Tom Tromey committed
594 595 596 597 598 599
      if (fd_callback_info[fd].thread != NULL
	  && fd_callback_info[fd].thread != current_thread)
	continue;
      if (fd_callback_info[fd].waiting_thread != NULL
	  && fd_callback_info[fd].waiting_thread != current_thread)
	continue;
600 601
      if ((fd_callback_info[fd].flags & FOR_READ) != 0
	  && (fd_callback_info[fd].flags & PROCESS_FD) == 0)
Tom Tromey's avatar
Tom Tromey committed
602 603 604 605
	{
	  FD_SET (fd, mask);
	  fd_callback_info[fd].waiting_thread = current_thread;
	}
606 607 608 609
    }
}

static void
Ken Raeburn's avatar
Ken Raeburn committed
610
compute_non_keyboard_wait_mask (fd_set *mask)
611 612 613 614
{
  int fd;

  FD_ZERO (mask);
Tom Tromey's avatar
Tom Tromey committed
615
  for (fd = 0; fd <= max_desc; ++fd)
616
    {
Tom Tromey's avatar
Tom Tromey committed
617 618 619 620 621 622
      if (fd_callback_info[fd].thread != NULL
	  && fd_callback_info[fd].thread != current_thread)
	continue;
      if (fd_callback_info[fd].waiting_thread != NULL
	  && fd_callback_info[fd].waiting_thread != current_thread)
	continue;
623 624
      if ((fd_callback_info[fd].flags & FOR_READ) != 0
	  && (fd_callback_info[fd].flags & KEYBOARD_FD) == 0)
Tom Tromey's avatar
Tom Tromey committed
625 626 627 628
	{
	  FD_SET (fd, mask);
	  fd_callback_info[fd].waiting_thread = current_thread;
	}
629 630 631 632
    }
}

static void
Ken Raeburn's avatar
Ken Raeburn committed
633
compute_write_mask (fd_set *mask)
634 635 636 637
{
  int fd;

  FD_ZERO (mask);
Tom Tromey's avatar
Tom Tromey committed
638
  for (fd = 0; fd <= max_desc; ++fd)
639
    {
Tom Tromey's avatar
Tom Tromey committed
640 641 642 643 644 645
      if (fd_callback_info[fd].thread != NULL
	  && fd_callback_info[fd].thread != current_thread)
	continue;
      if (fd_callback_info[fd].waiting_thread != NULL
	  && fd_callback_info[fd].waiting_thread != current_thread)
	continue;
646
      if ((fd_callback_info[fd].flags & FOR_WRITE) != 0)
Tom Tromey's avatar
Tom Tromey committed
647 648 649 650
	{
	  FD_SET (fd, mask);
	  fd_callback_info[fd].waiting_thread = current_thread;
	}
651 652 653
    }
}

Tom Tromey's avatar
Tom Tromey committed
654 655 656 657
static void
clear_waiting_thread_info (void)
{
  int fd;
658

Tom Tromey's avatar
Tom Tromey committed
659
  for (fd = 0; fd <= max_desc; ++fd)
Tom Tromey's avatar
Tom Tromey committed
660 661 662
    {
      if (fd_callback_info[fd].waiting_thread == current_thread)
	fd_callback_info[fd].waiting_thread = NULL;
663 664 665
    }
}

Jim Blandy's avatar
Jim Blandy committed
666 667 668 669

/* Compute the Lisp form of the process status, p->status, from
   the numeric status that was returned by `wait'.  */

670
static Lisp_Object status_convert (int);
671

672
static void
673
update_status (struct Lisp_Process *p)
Jim Blandy's avatar
Jim Blandy committed
674
{
675
  eassert (p->raw_status_new);
Paul Eggert's avatar
Paul Eggert committed
676
  pset_status (p, status_convert (p->raw_status));
677
  p->raw_status_new = 0;
Jim Blandy's avatar
Jim Blandy committed
678 679
}

680
/*  Convert a process status word in Unix format to
Jim Blandy's avatar
Jim Blandy committed
681 682
    the list that we use internally.  */

683
static Lisp_Object
684
status_convert (int w)
Jim Blandy's avatar
Jim Blandy committed
685 686
{
  if (WIFSTOPPED (w))
687
    return Fcons (Qstop, Fcons (make_fixnum (WSTOPSIG (w)), Qnil));
Jim Blandy's avatar
Jim Blandy committed
688
  else if (WIFEXITED (w))
689
    return Fcons (Qexit, Fcons (make_fixnum (WEXITSTATUS (w)),
Jim Blandy's avatar
Jim Blandy committed
690 691
				WCOREDUMP (w) ? Qt : Qnil));
  else if (WIFSIGNALED (w))
692
    return Fcons (Qsignal, Fcons (make_fixnum (WTERMSIG (w)),
Jim Blandy's avatar
Jim Blandy committed
693 694 695 696 697
				  WCOREDUMP (w) ? Qt : Qnil));
  else
    return Qrun;
}

698 699 700 701 702 703 704 705
/* True if STATUS is that of a process attempting connection.  */

static bool
connecting_status (Lisp_Object status)
{
  return CONSP (status) && EQ (XCAR (status), Qconnect);
}

Jim Blandy's avatar
Jim Blandy committed
706 707 708
/* Given a status-list, extract the three pieces of information
   and store them individually through the three pointers.  */

709
static void
710 711
decode_status (Lisp_Object l, Lisp_Object *symbol, Lisp_Object *code,
	       bool *coredump)
Jim Blandy's avatar
Jim Blandy committed
712 713 714
{
  Lisp_Object tem;

715 716 717
  if (connecting_status (l))
    l = XCAR (l);

718
  if (SYMBOLP (l))
Jim Blandy's avatar
Jim Blandy committed
719 720
    {
      *symbol = l;
721
      *code = make_fixnum (0);
Jim Blandy's avatar
Jim Blandy committed
722 723 724 725
      *coredump = 0;
    }
  else
    {
726 727
      *symbol = XCAR (l);
      tem = XCDR (l);
728
      *code = XCAR (tem);
729
      tem = XCDR (tem);
Jim Blandy's avatar
Jim Blandy committed
730 731 732 733 734 735
      *coredump = !NILP (tem);
    }
}

/* Return a string describing a process status list.  */

736
static Lisp_Object
737
status_message (struct Lisp_Process *p)
Jim Blandy's avatar
Jim Blandy committed
738
{
739
  Lisp_Object status = p->status;
740
  Lisp_Object symbol, code;
741
  bool coredump;
742
  Lisp_Object string;
Jim Blandy's avatar
Jim Blandy committed
743 744 745 746 747

  decode_status (status, &symbol, &code, &coredump);

  if (EQ (symbol, Qsignal) || EQ (symbol, Qstop))
    {
748
      char const *signame;
749
      synchronize_system_messages_locale ();
Tom Tromey's avatar
Tom Tromey committed
750
      signame = strsignal (XFIXNAT (code));
751
      if (signame == 0)
752 753 754 755 756
	string = build_string ("unknown");
      else
	{
	  int c1, c2;

757
	  string = build_unibyte_string (signame);
758 759 760
	  if (! NILP (Vlocale_coding_system))
	    string = (code_convert_string_norecord
		      (string, Vlocale_coding_system, 0));
761
	  c1 = STRING_CHAR (SDATA (string));
762
	  c2 = downcase (c1);
763
	  if (c1 != c2)
764
	    Faset (string, make_fixnum (0), make_fixnum (c2));
765
	}
766 767
      AUTO_STRING (suffix, coredump ? " (core dumped)\n" : "\n");
      return concat2 (string, suffix);
Jim Blandy's avatar
Jim Blandy committed
768 769 770
    }
  else if (EQ (symbol, Qexit))
    {
771
      if (NETCONN1_P (p))
Tom Tromey's avatar
Tom Tromey committed
772
	return build_string (XFIXNAT (code) == 0
773 774
			     ? "deleted\n"
			     : "connection broken by remote peer\n");
Tom Tromey's avatar
Tom Tromey committed
775
      if (XFIXNAT (code) == 0)
Jim Blandy's avatar
Jim Blandy committed
776
	return build_string ("finished\n");
777
      AUTO_STRING (prefix, "exited abnormally with code ");
778
      string = Fnumber_to_string (code);
779 780
      AUTO_STRING (suffix, coredump ? " (core dumped)\n" : "\n");
      return concat3 (prefix, string, suffix);
Jim Blandy's avatar
Jim Blandy committed
781
    }
782 783
  else if (EQ (symbol, Qfailed))
    {
784 785
      AUTO_STRING (format, "failed with code %s\n");
      return CALLN (Fformat, format, code);
786
    }
Jim Blandy's avatar
Jim Blandy committed
787 788 789 790
  else
    return Fcopy_sequence (Fsymbol_name (symbol));
}

791
enum { PTY_NAME_SIZE = 24 };
Dan Nicolaescu's avatar
Dan Nicolaescu committed
792

793
/* Open an available pty, returning a file descriptor.
794 795
   Store into PTY_NAME the file name of the terminal corresponding to the pty.
   Return -1 on failure.  */
796

797
static int
798
allocate_pty (char pty_name[PTY_NAME_SIZE])
Jim Blandy's avatar
Jim Blandy committed
799
{
800
#ifdef HAVE_PTYS
Jim Blandy's avatar
Jim Blandy committed
801 802 803 804 805
  int fd;

#ifdef PTY_ITERATION
  PTY_ITERATION
#else
806
  register int c, i;
Jim Blandy's avatar
Jim Blandy committed
807 808 809 810 811 812 813 814 815 816
  for (c = FIRST_PTY_LETTER; c <= 'z'; c++)
    for (i = 0; i < 16; i++)
#endif
      {
#ifdef PTY_NAME_SPRINTF
	PTY_NAME_SPRINTF
#else
	sprintf (pty_name, "/dev/pty%c%x", c, i);
#endif /* no PTY_NAME_SPRINTF */

817 818 819
#ifdef PTY_OPEN
	PTY_OPEN;
#else /* no PTY_OPEN */
820
	fd = emacs_open (pty_name, O_RDWR | O_NONBLOCK, 0);
821
#endif /* no PTY_OPEN */
Jim Blandy's avatar
Jim Blandy committed
822 823 824

	if (fd >= 0)
	  {
825 826 827 828 829 830
#ifdef PTY_TTY_NAME_SPRINTF
	    PTY_TTY_NAME_SPRINTF
#else
	    sprintf (pty_name, "/dev/tty%c%x", c, i);
#endif /* no PTY_TTY_NAME_SPRINTF */

831 832 833
	    /* 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.
834 835
	       Do this after PTY_TTY_NAME_SPRINTF, which on some platforms
	       doesn't work if the close-on-exec flag is set (Bug#20555).
836 837 838 839
	       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);
840 841 842

	    /* Check to make certain that both sides are available.
	       This avoids a nasty yet stupid bug in rlogins.  */
843
	    if (faccessat (AT_FDCWD, pty_name, R_OK | W_OK, AT_EACCESS) != 0)
Jim Blandy's avatar
Jim Blandy committed
844
	      {
845
		emacs_close (fd);
Jim Blandy's avatar
Jim Blandy committed
846 847 848 849 850 851
		continue;
	      }
	    setup_pty (fd);
	    return fd;
	  }
      }
852
#endif /* HAVE_PTYS */
Jim Blandy's avatar
Jim Blandy committed
853 854
  return -1;
}
855 856 857 858 859 860 861 862 863

/* Allocate basically initialized process.  */

static struct Lisp_Process *
allocate_process (void)
{
  return ALLOCATE_ZEROED_PSEUDOVECTOR (struct Lisp_Process, pid, PVEC_PROCESS);
}

864
static Lisp_Object
865
make_process (Lisp_Object name)
Jim Blandy's avatar
Jim Blandy committed
866
{
867
  struct Lisp_Process *p = allocate_process ();
868 869
  /* Initialize Lisp data.  Note that allocate_process initializes all
     Lisp data to nil, so do it only for slots which should not be nil.  */
Paul Eggert's avatar
Paul Eggert committed
870 871
  pset_status (p, Qrun);
  pset_mark (p, Fmake_marker ());
Tom Tromey's avatar
Tom Tromey committed
872
  pset_thread (p, Fcurrent_thread ());
Jim Blandy's avatar
Jim Blandy committed
873

874 875 876 877
  /* 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;
878
  for (int i = 0; i < PROCESS_OPEN_FDS; i++)
879
    p->open_fd[i] = -1;
Kenichi Handa's avatar
Kenichi Handa committed
880

Ted Zlatanov's avatar
Ted Zlatanov committed
881
#ifdef HAVE_GNUTLS
882 883 884
  verify (GNUTLS_STAGE_EMPTY == 0);
  eassert (p->gnutls_initstage == GNUTLS_STAGE_EMPTY);
  eassert (NILP (p->gnutls_boot_parameters));
Ted Zlatanov's avatar
Ted Zlatanov committed
885 886
#endif

Jim Blandy's avatar
Jim Blandy committed
887 888
  /* If name is already in use, modify it until it is unused.  */

889 890
  Lisp_Object name1 = name;
  for (printmax_t i = 1; ; i++)
Jim Blandy's avatar
Jim Blandy committed
891
    {
892 893 894 895 896 897 898
      Lisp_Object tem = Fget_process (name1);
      if (NILP (tem))
	break;
      char const suffix_fmt[] = "<%"pMd">";
      char suffix[sizeof suffix_fmt + INT_STRLEN_BOUND (printmax_t)];
      AUTO_STRING_WITH_LEN (lsuffix, suffix, sprintf (suffix, suffix_fmt, i));
      name1 = concat2 (name, lsuffix);
Jim Blandy's avatar
Jim Blandy committed
899 900
    }
  name = name1;
Paul Eggert's avatar
Paul Eggert committed
901
  pset_name (p, name);
902 903
  pset_sentinel (p, Qinternal_default_process_sentinel);
  pset_filter (p, Qinternal_default_process_filter);
904
  Lisp_Object val;
905
  XSETPROCESS (val, p);
Jim Blandy's avatar
Jim Blandy committed
906 907 908 909
  Vprocess_alist = Fcons (Fcons (name, val), Vprocess_alist);
  return val;
}

910
static void
911
remove_process (register Lisp_Object proc)
Jim Blandy's avatar
Jim Blandy committed
912 913 914 915 916 917 918 919
{
  register Lisp_Object pair;

  pair = Frassq (proc, Vprocess_alist);
  Vprocess_alist = Fdelq (pair, Vprocess_alist);

  deactivate_process (proc);
}
920

Tom Tromey's avatar
Tom Tromey committed
921 922 923 924 925 926 927 928 929 930 931 932
void
update_processes_for_thread_death (Lisp_Object dying_thread)
{
  Lisp_Object pair;

  for (pair = Vprocess_alist; !NILP (pair); pair = XCDR (pair))
    {
      Lisp_Object process = XCDR (XCAR (pair));
      if (EQ (XPROCESS (process)->thread, dying_thread))
	{
	  struct Lisp_Process *proc = XPROCESS (process);

Eli Zaretskii's avatar
Eli Zaretskii committed
933
	  pset_thread (proc, Qnil);
Tom Tromey's avatar
Tom Tromey committed
934 935 936 937 938 939 940 941
	  if (proc->infd >= 0)
	    fd_callback_info[proc->infd].thread = NULL;
	  if (proc->outfd >= 0)
	    fd_callback_info[proc->outfd].thread = NULL;
	}
    }
}

942 943 944 945 946 947
#ifdef HAVE_GETADDRINFO_A
static void
free_dns_request (Lisp_Object proc)
{
  struct Lisp_Process *p = XPROCESS (proc);

948 949 950 951
  if (p->dns_request->ar_result)
    freeaddrinfo (p->dns_request->ar_result);
  xfree (p->dns_request);
  p->dns_request = NULL;
952 953 954
}
#endif

Jim Blandy's avatar
Jim Blandy committed
955 956

DEFUN ("processp", Fprocessp, Sprocessp, 1, 1, 0,
957
       doc: /* Return t if OBJECT is a process.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
958
  (Lisp_Object object)
Jim Blandy's avatar
Jim Blandy committed
959
{
960
  return PROCESSP (object) ? Qt : Qnil;
Jim Blandy's avatar
Jim Blandy committed
961 962 963
}

DEFUN ("get-process", Fget_process, Sget_process, 1, 1, 0,
964
       doc: /* Return the process named NAME, or nil if there is none.  */)
Dan Nicolaescu's avatar
Dan Nicolaescu committed
965
  (register Lisp_Object name)
Jim Blandy's avatar
Jim Blandy committed
966
{
967
  if (PROCESSP (name))
Jim Blandy's avatar
Jim Blandy committed
968
    return name;
969
  CHECK_STRING (name);
970
  return Fcdr (Fassoc (name, Vprocess_alist, Qnil));
Jim Blandy's avatar
Jim Blandy committed
971 972
}

Jim Blandy's avatar
Jim Blandy committed
973 974 975 976
/* This is how commands for the user decode process arguments.  It
   accepts a process, a process name, a buffer, a buffer name, or nil.
   Buffers denote the first process in the buffer, and nil denotes the
   current buffer.  */
Jim Blandy's avatar
Jim Blandy committed
977

978
static Lisp_Object
979
get_process (register Lisp_Object name)
Jim Blandy's avatar
Jim Blandy committed
980
{
981 982 983 984 985 986 987
  register Lisp_Object proc, obj;
  if (STRINGP (name))
    {
      obj = Fget_process (name);
      if (NILP (obj))
	obj = Fget_buffer (name);
      if (NILP (obj))
988
	error ("Process %s does not exist", SDATA