1 /* Asynchronous subprocess control for GNU Emacs.
3 Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2013 Free Software
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #define PROCESS_INLINE EXTERN_INLINE
28 #include <sys/types.h> /* Some typedefs are used in sys/file.h. */
36 /* Only MS-DOS does not define `subprocesses'. */
39 #include <sys/socket.h>
41 #include <netinet/in.h>
42 #include <arpa/inet.h>
44 /* Are local (unix) sockets supported? */
45 #if defined (HAVE_SYS_UN_H)
46 #if !defined (AF_LOCAL) && defined (AF_UNIX)
47 #define AF_LOCAL AF_UNIX
50 #define HAVE_LOCAL_SOCKETS
55 #include <sys/ioctl.h>
56 #if defined (HAVE_NET_IF_H)
58 #endif /* HAVE_NET_IF_H */
60 #if defined (HAVE_IFADDRS_H)
61 /* Must be after net/if.h */
64 /* We only use structs from this header when we use getifaddrs. */
65 #if defined (HAVE_NET_IF_DL_H)
66 #include <net/if_dl.h>
76 # include <sys/stream.h>
77 # include <sys/stropts.h>
81 #include <netinet/in.h>
82 #include <arpa/nameser.h>
97 #endif /* subprocesses */
103 #include "character.h"
108 #include "termhooks.h"
109 #include "termopts.h"
110 #include "commands.h"
111 #include "keyboard.h"
112 #include "blockinput.h"
113 #include "dispextern.h"
114 #include "composite.h"
116 #include "sysselect.h"
117 #include "syssignal.h"
123 #ifdef HAVE_WINDOW_SYSTEM
125 #endif /* HAVE_WINDOW_SYSTEM */
127 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
128 #include "xgselect.h"
132 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
133 EMACS_TIME
*, void *);
136 /* Work around GCC 4.7.0 bug with strict overflow checking; see
137 <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52904>.
138 These lines can be removed once the GCC bug is fixed. */
139 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
140 # pragma GCC diagnostic ignored "-Wstrict-overflow"
143 Lisp_Object Qeuid
, Qegid
, Qcomm
, Qstate
, Qppid
, Qpgrp
, Qsess
, Qttname
, Qtpgid
;
144 Lisp_Object Qminflt
, Qmajflt
, Qcminflt
, Qcmajflt
, Qutime
, Qstime
, Qcstime
;
145 Lisp_Object Qcutime
, Qpri
, Qnice
, Qthcount
, Qstart
, Qvsize
, Qrss
, Qargs
;
146 Lisp_Object Quser
, Qgroup
, Qetime
, Qpcpu
, Qpmem
, Qtime
, Qctime
;
147 Lisp_Object QCname
, QCtype
;
149 /* True if keyboard input is on hold, zero otherwise. */
151 static bool kbd_is_on_hold
;
153 /* Nonzero means don't run process sentinels. This is used
155 bool inhibit_sentinels
;
159 Lisp_Object Qprocessp
;
160 static Lisp_Object Qrun
, Qstop
, Qsignal
;
161 static Lisp_Object Qopen
, Qclosed
, Qconnect
, Qfailed
, Qlisten
;
163 static Lisp_Object Qipv4
, Qdatagram
, Qseqpacket
;
164 static Lisp_Object Qreal
, Qnetwork
, Qserial
;
166 static Lisp_Object Qipv6
;
168 static Lisp_Object QCport
, QCprocess
;
170 Lisp_Object QCbytesize
, QCstopbits
, QCparity
, Qodd
, Qeven
;
171 Lisp_Object QCflowcontrol
, Qhw
, Qsw
, QCsummary
;
172 static Lisp_Object QCbuffer
, QChost
, QCservice
;
173 static Lisp_Object QClocal
, QCremote
, QCcoding
;
174 static Lisp_Object QCserver
, QCnowait
, QCnoquery
, QCstop
;
175 static Lisp_Object QCsentinel
, QClog
, QCoptions
, QCplist
;
176 static Lisp_Object Qlast_nonmenu_event
;
177 static Lisp_Object Qinternal_default_process_sentinel
;
178 static Lisp_Object Qinternal_default_process_filter
;
180 #define NETCONN_P(p) (EQ (XPROCESS (p)->type, Qnetwork))
181 #define NETCONN1_P(p) (EQ (p->type, Qnetwork))
182 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
183 #define SERIALCONN1_P(p) (EQ (p->type, Qserial))
185 /* Number of events of change of status of a process. */
186 static EMACS_INT process_tick
;
187 /* Number of events for which the user or sentinel has been notified. */
188 static EMACS_INT update_tick
;
190 /* Define NON_BLOCKING_CONNECT if we can support non-blocking connects. */
192 /* Only W32 has this, it really means that select can't take write mask. */
193 #ifdef BROKEN_NON_BLOCKING_CONNECT
194 #undef NON_BLOCKING_CONNECT
195 #define SELECT_CANT_DO_WRITE_MASK
197 #ifndef NON_BLOCKING_CONNECT
199 #if defined (HAVE_GETPEERNAME) || defined (GNU_LINUX)
200 #if defined (EWOULDBLOCK) || defined (EINPROGRESS)
201 #define NON_BLOCKING_CONNECT
202 #endif /* EWOULDBLOCK || EINPROGRESS */
203 #endif /* HAVE_GETPEERNAME || GNU_LINUX */
204 #endif /* HAVE_SELECT */
205 #endif /* NON_BLOCKING_CONNECT */
206 #endif /* BROKEN_NON_BLOCKING_CONNECT */
208 /* Define DATAGRAM_SOCKETS if datagrams can be used safely on
209 this system. We need to read full packets, so we need a
210 "non-destructive" select. So we require either native select,
211 or emulation of select using FIONREAD. */
213 #ifndef BROKEN_DATAGRAM_SOCKETS
214 # if defined HAVE_SELECT || defined USABLE_FIONREAD
215 # if defined HAVE_SENDTO && defined HAVE_RECVFROM && defined EMSGSIZE
216 # define DATAGRAM_SOCKETS
221 #if defined HAVE_LOCAL_SOCKETS && defined DATAGRAM_SOCKETS
222 # define HAVE_SEQPACKET
225 #if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING)
226 #define ADAPTIVE_READ_BUFFERING
229 #ifdef ADAPTIVE_READ_BUFFERING
230 #define READ_OUTPUT_DELAY_INCREMENT (EMACS_TIME_RESOLUTION / 100)
231 #define READ_OUTPUT_DELAY_MAX (READ_OUTPUT_DELAY_INCREMENT * 5)
232 #define READ_OUTPUT_DELAY_MAX_MAX (READ_OUTPUT_DELAY_INCREMENT * 7)
234 /* Number of processes which have a non-zero read_output_delay,
235 and therefore might be delayed for adaptive read buffering. */
237 static int process_output_delay_count
;
239 /* True if any process has non-nil read_output_skip. */
241 static bool process_output_skip
;
244 #define process_output_delay_count 0
247 static void create_process (Lisp_Object
, char **, Lisp_Object
);
249 static bool keyboard_bit_set (SELECT_TYPE
*);
251 static void deactivate_process (Lisp_Object
);
252 static void status_notify (struct Lisp_Process
*);
253 static int read_process_output (Lisp_Object
, int);
254 static void handle_child_signal (int);
255 static void create_pty (Lisp_Object
);
257 /* If we support a window system, turn on the code to poll periodically
258 to detect C-g. It isn't actually used when doing interrupt input. */
259 #ifdef HAVE_WINDOW_SYSTEM
260 #define POLL_FOR_INPUT
263 static Lisp_Object
get_process (register Lisp_Object name
);
264 static void exec_sentinel (Lisp_Object proc
, Lisp_Object reason
);
266 /* Mask of bits indicating the descriptors that we wait for input on. */
268 static SELECT_TYPE input_wait_mask
;
270 /* Mask that excludes keyboard input descriptor(s). */
272 static SELECT_TYPE non_keyboard_wait_mask
;
274 /* Mask that excludes process input descriptor(s). */
276 static SELECT_TYPE non_process_wait_mask
;
278 /* Mask for selecting for write. */
280 static SELECT_TYPE write_mask
;
282 #ifdef NON_BLOCKING_CONNECT
283 /* Mask of bits indicating the descriptors that we wait for connect to
284 complete on. Once they complete, they are removed from this mask
285 and added to the input_wait_mask and non_keyboard_wait_mask. */
287 static SELECT_TYPE connect_wait_mask
;
289 /* Number of bits set in connect_wait_mask. */
290 static int num_pending_connects
;
291 #endif /* NON_BLOCKING_CONNECT */
293 /* The largest descriptor currently in use for a process object. */
294 static int max_process_desc
;
296 /* The largest descriptor currently in use for input. */
297 static int max_input_desc
;
299 /* Indexed by descriptor, gives the process (if any) for that descriptor */
300 static Lisp_Object chan_process
[MAXDESC
];
302 /* Alist of elements (NAME . PROCESS) */
303 static Lisp_Object Vprocess_alist
;
305 /* Buffered-ahead input char from process, indexed by channel.
306 -1 means empty (no char is buffered).
307 Used on sys V where the only way to tell if there is any
308 output from the process is to read at least one char.
309 Always -1 on systems that support FIONREAD. */
311 static int proc_buffered_char
[MAXDESC
];
313 /* Table of `struct coding-system' for each process. */
314 static struct coding_system
*proc_decode_coding_system
[MAXDESC
];
315 static struct coding_system
*proc_encode_coding_system
[MAXDESC
];
317 #ifdef DATAGRAM_SOCKETS
318 /* Table of `partner address' for datagram sockets. */
319 static struct sockaddr_and_len
{
322 } datagram_address
[MAXDESC
];
323 #define DATAGRAM_CHAN_P(chan) (datagram_address[chan].sa != 0)
324 #define DATAGRAM_CONN_P(proc) (PROCESSP (proc) && datagram_address[XPROCESS (proc)->infd].sa != 0)
326 #define DATAGRAM_CHAN_P(chan) (0)
327 #define DATAGRAM_CONN_P(proc) (0)
330 /* These setters are used only in this file, so they can be private. */
332 pset_buffer (struct Lisp_Process
*p
, Lisp_Object val
)
337 pset_command (struct Lisp_Process
*p
, Lisp_Object val
)
342 pset_decode_coding_system (struct Lisp_Process
*p
, Lisp_Object val
)
344 p
->decode_coding_system
= val
;
347 pset_decoding_buf (struct Lisp_Process
*p
, Lisp_Object val
)
349 p
->decoding_buf
= val
;
352 pset_encode_coding_system (struct Lisp_Process
*p
, Lisp_Object val
)
354 p
->encode_coding_system
= val
;
357 pset_encoding_buf (struct Lisp_Process
*p
, Lisp_Object val
)
359 p
->encoding_buf
= val
;
362 pset_filter (struct Lisp_Process
*p
, Lisp_Object val
)
364 p
->filter
= NILP (val
) ? Qinternal_default_process_filter
: val
;
367 pset_log (struct Lisp_Process
*p
, Lisp_Object val
)
372 pset_mark (struct Lisp_Process
*p
, Lisp_Object val
)
377 pset_name (struct Lisp_Process
*p
, Lisp_Object val
)
382 pset_plist (struct Lisp_Process
*p
, Lisp_Object val
)
387 pset_sentinel (struct Lisp_Process
*p
, Lisp_Object val
)
389 p
->sentinel
= NILP (val
) ? Qinternal_default_process_sentinel
: val
;
392 pset_status (struct Lisp_Process
*p
, Lisp_Object val
)
397 pset_tty_name (struct Lisp_Process
*p
, Lisp_Object val
)
402 pset_type (struct Lisp_Process
*p
, Lisp_Object val
)
407 pset_write_queue (struct Lisp_Process
*p
, Lisp_Object val
)
409 p
->write_queue
= val
;
414 static struct fd_callback_data
420 int condition
; /* mask of the defines above. */
421 } fd_callback_info
[MAXDESC
];
424 /* Add a file descriptor FD to be monitored for when read is possible.
425 When read is possible, call FUNC with argument DATA. */
428 add_read_fd (int fd
, fd_callback func
, void *data
)
430 eassert (fd
< MAXDESC
);
431 add_keyboard_wait_descriptor (fd
);
433 fd_callback_info
[fd
].func
= func
;
434 fd_callback_info
[fd
].data
= data
;
435 fd_callback_info
[fd
].condition
|= FOR_READ
;
438 /* Stop monitoring file descriptor FD for when read is possible. */
441 delete_read_fd (int fd
)
443 eassert (fd
< MAXDESC
);
444 delete_keyboard_wait_descriptor (fd
);
446 fd_callback_info
[fd
].condition
&= ~FOR_READ
;
447 if (fd_callback_info
[fd
].condition
== 0)
449 fd_callback_info
[fd
].func
= 0;
450 fd_callback_info
[fd
].data
= 0;
454 /* Add a file descriptor FD to be monitored for when write is possible.
455 When write is possible, call FUNC with argument DATA. */
458 add_write_fd (int fd
, fd_callback func
, void *data
)
460 eassert (fd
< MAXDESC
);
461 FD_SET (fd
, &write_mask
);
462 if (fd
> max_input_desc
)
465 fd_callback_info
[fd
].func
= func
;
466 fd_callback_info
[fd
].data
= data
;
467 fd_callback_info
[fd
].condition
|= FOR_WRITE
;
470 /* Stop monitoring file descriptor FD for when write is possible. */
473 delete_write_fd (int fd
)
475 int lim
= max_input_desc
;
477 eassert (fd
< MAXDESC
);
478 FD_CLR (fd
, &write_mask
);
479 fd_callback_info
[fd
].condition
&= ~FOR_WRITE
;
480 if (fd_callback_info
[fd
].condition
== 0)
482 fd_callback_info
[fd
].func
= 0;
483 fd_callback_info
[fd
].data
= 0;
485 if (fd
== max_input_desc
)
486 for (fd
= lim
; fd
>= 0; fd
--)
487 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
497 /* Compute the Lisp form of the process status, p->status, from
498 the numeric status that was returned by `wait'. */
500 static Lisp_Object
status_convert (int);
503 update_status (struct Lisp_Process
*p
)
505 eassert (p
->raw_status_new
);
506 pset_status (p
, status_convert (p
->raw_status
));
507 p
->raw_status_new
= 0;
510 /* Convert a process status word in Unix format to
511 the list that we use internally. */
514 status_convert (int w
)
517 return Fcons (Qstop
, Fcons (make_number (WSTOPSIG (w
)), Qnil
));
518 else if (WIFEXITED (w
))
519 return Fcons (Qexit
, Fcons (make_number (WEXITSTATUS (w
)),
520 WCOREDUMP (w
) ? Qt
: Qnil
));
521 else if (WIFSIGNALED (w
))
522 return Fcons (Qsignal
, Fcons (make_number (WTERMSIG (w
)),
523 WCOREDUMP (w
) ? Qt
: Qnil
));
528 /* Given a status-list, extract the three pieces of information
529 and store them individually through the three pointers. */
532 decode_status (Lisp_Object l
, Lisp_Object
*symbol
, int *code
, bool *coredump
)
546 *code
= XFASTINT (XCAR (tem
));
548 *coredump
= !NILP (tem
);
552 /* Return a string describing a process status list. */
555 status_message (struct Lisp_Process
*p
)
557 Lisp_Object status
= p
->status
;
561 Lisp_Object string
, string2
;
563 decode_status (status
, &symbol
, &code
, &coredump
);
565 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qstop
))
568 synchronize_system_messages_locale ();
569 signame
= strsignal (code
);
571 string
= build_string ("unknown");
576 string
= build_unibyte_string (signame
);
577 if (! NILP (Vlocale_coding_system
))
578 string
= (code_convert_string_norecord
579 (string
, Vlocale_coding_system
, 0));
580 c1
= STRING_CHAR (SDATA (string
));
583 Faset (string
, make_number (0), make_number (c2
));
585 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
586 return concat2 (string
, string2
);
588 else if (EQ (symbol
, Qexit
))
591 return build_string (code
== 0 ? "deleted\n" : "connection broken by remote peer\n");
593 return build_string ("finished\n");
594 string
= Fnumber_to_string (make_number (code
));
595 string2
= build_string (coredump
? " (core dumped)\n" : "\n");
596 return concat3 (build_string ("exited abnormally with code "),
599 else if (EQ (symbol
, Qfailed
))
601 string
= Fnumber_to_string (make_number (code
));
602 string2
= build_string ("\n");
603 return concat3 (build_string ("failed with code "),
607 return Fcopy_sequence (Fsymbol_name (symbol
));
612 /* The file name of the pty opened by allocate_pty. */
613 static char pty_name
[24];
615 /* Open an available pty, returning a file descriptor.
616 Return -1 on failure.
617 The file name of the terminal corresponding to the pty
618 is left in the variable pty_name. */
629 for (c
= FIRST_PTY_LETTER
; c
<= 'z'; c
++)
630 for (i
= 0; i
< 16; i
++)
633 #ifdef PTY_NAME_SPRINTF
636 sprintf (pty_name
, "/dev/pty%c%x", c
, i
);
637 #endif /* no PTY_NAME_SPRINTF */
641 #else /* no PTY_OPEN */
642 fd
= emacs_open (pty_name
, O_RDWR
| O_NONBLOCK
, 0);
643 #endif /* no PTY_OPEN */
647 /* check to make certain that both sides are available
648 this avoids a nasty yet stupid bug in rlogins */
649 #ifdef PTY_TTY_NAME_SPRINTF
652 sprintf (pty_name
, "/dev/tty%c%x", c
, i
);
653 #endif /* no PTY_TTY_NAME_SPRINTF */
654 if (faccessat (AT_FDCWD
, pty_name
, R_OK
| W_OK
, AT_EACCESS
) != 0)
669 #endif /* HAVE_PTYS */
672 make_process (Lisp_Object name
)
674 register Lisp_Object val
, tem
, name1
;
675 register struct Lisp_Process
*p
;
676 char suffix
[sizeof "<>" + INT_STRLEN_BOUND (printmax_t
)];
679 p
= allocate_process ();
680 /* Initialize Lisp data. Note that allocate_process initializes all
681 Lisp data to nil, so do it only for slots which should not be nil. */
682 pset_status (p
, Qrun
);
683 pset_mark (p
, Fmake_marker ());
685 /* Initialize non-Lisp data. Note that allocate_process zeroes out all
686 non-Lisp data, so do it only for slots which should not be zero. */
691 p
->gnutls_initstage
= GNUTLS_STAGE_EMPTY
;
694 /* If name is already in use, modify it until it is unused. */
699 tem
= Fget_process (name1
);
700 if (NILP (tem
)) break;
701 name1
= concat2 (name
, make_formatted_string (suffix
, "<%"pMd
">", i
));
705 pset_sentinel (p
, Qinternal_default_process_sentinel
);
706 pset_filter (p
, Qinternal_default_process_filter
);
707 XSETPROCESS (val
, p
);
708 Vprocess_alist
= Fcons (Fcons (name
, val
), Vprocess_alist
);
713 remove_process (register Lisp_Object proc
)
715 register Lisp_Object pair
;
717 pair
= Frassq (proc
, Vprocess_alist
);
718 Vprocess_alist
= Fdelq (pair
, Vprocess_alist
);
720 deactivate_process (proc
);
724 DEFUN ("processp", Fprocessp
, Sprocessp
, 1, 1, 0,
725 doc
: /* Return t if OBJECT is a process. */)
728 return PROCESSP (object
) ? Qt
: Qnil
;
731 DEFUN ("get-process", Fget_process
, Sget_process
, 1, 1, 0,
732 doc
: /* Return the process named NAME, or nil if there is none. */)
733 (register Lisp_Object name
)
738 return Fcdr (Fassoc (name
, Vprocess_alist
));
741 /* This is how commands for the user decode process arguments. It
742 accepts a process, a process name, a buffer, a buffer name, or nil.
743 Buffers denote the first process in the buffer, and nil denotes the
747 get_process (register Lisp_Object name
)
749 register Lisp_Object proc
, obj
;
752 obj
= Fget_process (name
);
754 obj
= Fget_buffer (name
);
756 error ("Process %s does not exist", SDATA (name
));
758 else if (NILP (name
))
759 obj
= Fcurrent_buffer ();
763 /* Now obj should be either a buffer object or a process object.
767 proc
= Fget_buffer_process (obj
);
769 error ("Buffer %s has no process", SDATA (BVAR (XBUFFER (obj
), name
)));
780 /* Fdelete_process promises to immediately forget about the process, but in
781 reality, Emacs needs to remember those processes until they have been
782 treated by the SIGCHLD handler and waitpid has been invoked on them;
783 otherwise they might fill up the kernel's process table.
785 Some processes created by call-process are also put onto this list. */
786 static Lisp_Object deleted_pid_list
;
789 record_deleted_pid (pid_t pid
)
791 deleted_pid_list
= Fcons (make_fixnum_or_float (pid
),
792 /* GC treated elements set to nil. */
793 Fdelq (Qnil
, deleted_pid_list
));
797 DEFUN ("delete-process", Fdelete_process
, Sdelete_process
, 1, 1, 0,
798 doc
: /* Delete PROCESS: kill it and forget about it immediately.
799 PROCESS may be a process, a buffer, the name of a process or buffer, or
800 nil, indicating the current buffer's process. */)
801 (register Lisp_Object process
)
803 register struct Lisp_Process
*p
;
805 process
= get_process (process
);
806 p
= XPROCESS (process
);
808 p
->raw_status_new
= 0;
809 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
811 pset_status (p
, Fcons (Qexit
, Fcons (make_number (0), Qnil
)));
812 p
->tick
= ++process_tick
;
814 redisplay_preserve_echo_area (13);
819 record_kill_process (p
);
823 /* Update P's status, since record_kill_process will make the
824 SIGCHLD handler update deleted_pid_list, not *P. */
826 if (p
->raw_status_new
)
828 symbol
= CONSP (p
->status
) ? XCAR (p
->status
) : p
->status
;
829 if (! (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)))
830 pset_status (p
, list2 (Qsignal
, make_number (SIGKILL
)));
832 p
->tick
= ++process_tick
;
834 redisplay_preserve_echo_area (13);
837 remove_process (process
);
841 DEFUN ("process-status", Fprocess_status
, Sprocess_status
, 1, 1, 0,
842 doc
: /* Return the status of PROCESS.
843 The returned value is one of the following symbols:
844 run -- for a process that is running.
845 stop -- for a process stopped but continuable.
846 exit -- for a process that has exited.
847 signal -- for a process that has got a fatal signal.
848 open -- for a network stream connection that is open.
849 listen -- for a network stream server that is listening.
850 closed -- for a network stream connection that is closed.
851 connect -- when waiting for a non-blocking connection to complete.
852 failed -- when a non-blocking connection has failed.
853 nil -- if arg is a process name and no such process exists.
854 PROCESS may be a process, a buffer, the name of a process, or
855 nil, indicating the current buffer's process. */)
856 (register Lisp_Object process
)
858 register struct Lisp_Process
*p
;
859 register Lisp_Object status
;
861 if (STRINGP (process
))
862 process
= Fget_process (process
);
864 process
= get_process (process
);
869 p
= XPROCESS (process
);
870 if (p
->raw_status_new
)
874 status
= XCAR (status
);
875 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
877 if (EQ (status
, Qexit
))
879 else if (EQ (p
->command
, Qt
))
881 else if (EQ (status
, Qrun
))
887 DEFUN ("process-exit-status", Fprocess_exit_status
, Sprocess_exit_status
,
889 doc
: /* Return the exit status of PROCESS or the signal number that killed it.
890 If PROCESS has not yet exited or died, return 0. */)
891 (register Lisp_Object process
)
893 CHECK_PROCESS (process
);
894 if (XPROCESS (process
)->raw_status_new
)
895 update_status (XPROCESS (process
));
896 if (CONSP (XPROCESS (process
)->status
))
897 return XCAR (XCDR (XPROCESS (process
)->status
));
898 return make_number (0);
901 DEFUN ("process-id", Fprocess_id
, Sprocess_id
, 1, 1, 0,
902 doc
: /* Return the process id of PROCESS.
903 This is the pid of the external process which PROCESS uses or talks to.
904 For a network connection, this value is nil. */)
905 (register Lisp_Object process
)
909 CHECK_PROCESS (process
);
910 pid
= XPROCESS (process
)->pid
;
911 return (pid
? make_fixnum_or_float (pid
) : Qnil
);
914 DEFUN ("process-name", Fprocess_name
, Sprocess_name
, 1, 1, 0,
915 doc
: /* Return the name of PROCESS, as a string.
916 This is the name of the program invoked in PROCESS,
917 possibly modified to make it unique among process names. */)
918 (register Lisp_Object process
)
920 CHECK_PROCESS (process
);
921 return XPROCESS (process
)->name
;
924 DEFUN ("process-command", Fprocess_command
, Sprocess_command
, 1, 1, 0,
925 doc
: /* Return the command that was executed to start PROCESS.
926 This is a list of strings, the first string being the program executed
927 and the rest of the strings being the arguments given to it.
928 For a network or serial process, this is nil (process is running) or t
929 \(process is stopped). */)
930 (register Lisp_Object process
)
932 CHECK_PROCESS (process
);
933 return XPROCESS (process
)->command
;
936 DEFUN ("process-tty-name", Fprocess_tty_name
, Sprocess_tty_name
, 1, 1, 0,
937 doc
: /* Return the name of the terminal PROCESS uses, or nil if none.
938 This is the terminal that the process itself reads and writes on,
939 not the name of the pty that Emacs uses to talk with that terminal. */)
940 (register Lisp_Object process
)
942 CHECK_PROCESS (process
);
943 return XPROCESS (process
)->tty_name
;
946 DEFUN ("set-process-buffer", Fset_process_buffer
, Sset_process_buffer
,
948 doc
: /* Set buffer associated with PROCESS to BUFFER (a buffer, or nil).
950 (register Lisp_Object process
, Lisp_Object buffer
)
952 struct Lisp_Process
*p
;
954 CHECK_PROCESS (process
);
956 CHECK_BUFFER (buffer
);
957 p
= XPROCESS (process
);
958 pset_buffer (p
, buffer
);
959 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
960 pset_childp (p
, Fplist_put (p
->childp
, QCbuffer
, buffer
));
961 setup_process_coding_systems (process
);
965 DEFUN ("process-buffer", Fprocess_buffer
, Sprocess_buffer
,
967 doc
: /* Return the buffer PROCESS is associated with.
968 Output from PROCESS is inserted in this buffer unless PROCESS has a filter. */)
969 (register Lisp_Object process
)
971 CHECK_PROCESS (process
);
972 return XPROCESS (process
)->buffer
;
975 DEFUN ("process-mark", Fprocess_mark
, Sprocess_mark
,
977 doc
: /* Return the marker for the end of the last output from PROCESS. */)
978 (register Lisp_Object process
)
980 CHECK_PROCESS (process
);
981 return XPROCESS (process
)->mark
;
984 DEFUN ("set-process-filter", Fset_process_filter
, Sset_process_filter
,
986 doc
: /* Give PROCESS the filter function FILTER; nil means default.
987 A value of t means stop accepting output from the process.
989 When a process has a non-default filter, its buffer is not used for output.
990 Instead, each time it does output, the entire string of output is
991 passed to the filter.
993 The filter gets two arguments: the process and the string of output.
994 The string argument is normally a multibyte string, except:
995 - if the process' input coding system is no-conversion or raw-text,
996 it is a unibyte string (the non-converted input), or else
997 - if `default-enable-multibyte-characters' is nil, it is a unibyte
998 string (the result of converting the decoded input multibyte
999 string to unibyte with `string-make-unibyte'). */)
1000 (register Lisp_Object process
, Lisp_Object filter
)
1002 struct Lisp_Process
*p
;
1004 CHECK_PROCESS (process
);
1005 p
= XPROCESS (process
);
1007 /* Don't signal an error if the process' input file descriptor
1008 is closed. This could make debugging Lisp more difficult,
1009 for example when doing something like
1011 (setq process (start-process ...))
1013 (set-process-filter process ...) */
1016 filter
= Qinternal_default_process_filter
;
1020 if (EQ (filter
, Qt
) && !EQ (p
->status
, Qlisten
))
1022 FD_CLR (p
->infd
, &input_wait_mask
);
1023 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
1025 else if (EQ (p
->filter
, Qt
)
1026 /* Network or serial process not stopped: */
1027 && !EQ (p
->command
, Qt
))
1029 FD_SET (p
->infd
, &input_wait_mask
);
1030 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
1034 pset_filter (p
, filter
);
1035 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
1036 pset_childp (p
, Fplist_put (p
->childp
, QCfilter
, filter
));
1037 setup_process_coding_systems (process
);
1041 DEFUN ("process-filter", Fprocess_filter
, Sprocess_filter
,
1043 doc
: /* Return the filter function of PROCESS.
1044 See `set-process-filter' for more info on filter functions. */)
1045 (register Lisp_Object process
)
1047 CHECK_PROCESS (process
);
1048 return XPROCESS (process
)->filter
;
1051 DEFUN ("set-process-sentinel", Fset_process_sentinel
, Sset_process_sentinel
,
1053 doc
: /* Give PROCESS the sentinel SENTINEL; nil for default.
1054 The sentinel is called as a function when the process changes state.
1055 It gets two arguments: the process, and a string describing the change. */)
1056 (register Lisp_Object process
, Lisp_Object sentinel
)
1058 struct Lisp_Process
*p
;
1060 CHECK_PROCESS (process
);
1061 p
= XPROCESS (process
);
1063 if (NILP (sentinel
))
1064 sentinel
= Qinternal_default_process_sentinel
;
1066 pset_sentinel (p
, sentinel
);
1067 if (NETCONN1_P (p
) || SERIALCONN1_P (p
))
1068 pset_childp (p
, Fplist_put (p
->childp
, QCsentinel
, sentinel
));
1072 DEFUN ("process-sentinel", Fprocess_sentinel
, Sprocess_sentinel
,
1074 doc
: /* Return the sentinel of PROCESS.
1075 See `set-process-sentinel' for more info on sentinels. */)
1076 (register Lisp_Object process
)
1078 CHECK_PROCESS (process
);
1079 return XPROCESS (process
)->sentinel
;
1082 DEFUN ("set-process-window-size", Fset_process_window_size
,
1083 Sset_process_window_size
, 3, 3, 0,
1084 doc
: /* Tell PROCESS that it has logical window size HEIGHT and WIDTH. */)
1085 (register Lisp_Object process
, Lisp_Object height
, Lisp_Object width
)
1087 CHECK_PROCESS (process
);
1088 CHECK_RANGED_INTEGER (height
, 0, INT_MAX
);
1089 CHECK_RANGED_INTEGER (width
, 0, INT_MAX
);
1091 if (XPROCESS (process
)->infd
< 0
1092 || set_window_size (XPROCESS (process
)->infd
,
1093 XINT (height
), XINT (width
)) <= 0)
1099 DEFUN ("set-process-inherit-coding-system-flag",
1100 Fset_process_inherit_coding_system_flag
,
1101 Sset_process_inherit_coding_system_flag
, 2, 2, 0,
1102 doc
: /* Determine whether buffer of PROCESS will inherit coding-system.
1103 If the second argument FLAG is non-nil, then the variable
1104 `buffer-file-coding-system' of the buffer associated with PROCESS
1105 will be bound to the value of the coding system used to decode
1108 This is useful when the coding system specified for the process buffer
1109 leaves either the character code conversion or the end-of-line conversion
1110 unspecified, or if the coding system used to decode the process output
1111 is more appropriate for saving the process buffer.
1113 Binding the variable `inherit-process-coding-system' to non-nil before
1114 starting the process is an alternative way of setting the inherit flag
1115 for the process which will run.
1117 This function returns FLAG. */)
1118 (register Lisp_Object process
, Lisp_Object flag
)
1120 CHECK_PROCESS (process
);
1121 XPROCESS (process
)->inherit_coding_system_flag
= !NILP (flag
);
1125 DEFUN ("set-process-query-on-exit-flag",
1126 Fset_process_query_on_exit_flag
, Sset_process_query_on_exit_flag
,
1128 doc
: /* Specify if query is needed for PROCESS when Emacs is exited.
1129 If the second argument FLAG is non-nil, Emacs will query the user before
1130 exiting or killing a buffer if PROCESS is running. This function
1132 (register Lisp_Object process
, Lisp_Object flag
)
1134 CHECK_PROCESS (process
);
1135 XPROCESS (process
)->kill_without_query
= NILP (flag
);
1139 DEFUN ("process-query-on-exit-flag",
1140 Fprocess_query_on_exit_flag
, Sprocess_query_on_exit_flag
,
1142 doc
: /* Return the current value of query-on-exit flag for PROCESS. */)
1143 (register Lisp_Object process
)
1145 CHECK_PROCESS (process
);
1146 return (XPROCESS (process
)->kill_without_query
? Qnil
: Qt
);
1149 DEFUN ("process-contact", Fprocess_contact
, Sprocess_contact
,
1151 doc
: /* Return the contact info of PROCESS; t for a real child.
1152 For a network or serial connection, the value depends on the optional
1153 KEY arg. If KEY is nil, value is a cons cell of the form (HOST
1154 SERVICE) for a network connection or (PORT SPEED) for a serial
1155 connection. If KEY is t, the complete contact information for the
1156 connection is returned, else the specific value for the keyword KEY is
1157 returned. See `make-network-process' or `make-serial-process' for a
1158 list of keywords. */)
1159 (register Lisp_Object process
, Lisp_Object key
)
1161 Lisp_Object contact
;
1163 CHECK_PROCESS (process
);
1164 contact
= XPROCESS (process
)->childp
;
1166 #ifdef DATAGRAM_SOCKETS
1167 if (DATAGRAM_CONN_P (process
)
1168 && (EQ (key
, Qt
) || EQ (key
, QCremote
)))
1169 contact
= Fplist_put (contact
, QCremote
,
1170 Fprocess_datagram_address (process
));
1173 if ((!NETCONN_P (process
) && !SERIALCONN_P (process
)) || EQ (key
, Qt
))
1175 if (NILP (key
) && NETCONN_P (process
))
1176 return Fcons (Fplist_get (contact
, QChost
),
1177 Fcons (Fplist_get (contact
, QCservice
), Qnil
));
1178 if (NILP (key
) && SERIALCONN_P (process
))
1179 return Fcons (Fplist_get (contact
, QCport
),
1180 Fcons (Fplist_get (contact
, QCspeed
), Qnil
));
1181 return Fplist_get (contact
, key
);
1184 DEFUN ("process-plist", Fprocess_plist
, Sprocess_plist
,
1186 doc
: /* Return the plist of PROCESS. */)
1187 (register Lisp_Object process
)
1189 CHECK_PROCESS (process
);
1190 return XPROCESS (process
)->plist
;
1193 DEFUN ("set-process-plist", Fset_process_plist
, Sset_process_plist
,
1195 doc
: /* Replace the plist of PROCESS with PLIST. Returns PLIST. */)
1196 (register Lisp_Object process
, Lisp_Object plist
)
1198 CHECK_PROCESS (process
);
1201 pset_plist (XPROCESS (process
), plist
);
1205 #if 0 /* Turned off because we don't currently record this info
1206 in the process. Perhaps add it. */
1207 DEFUN ("process-connection", Fprocess_connection
, Sprocess_connection
, 1, 1, 0,
1208 doc
: /* Return the connection type of PROCESS.
1209 The value is nil for a pipe, t or `pty' for a pty, or `stream' for
1210 a socket connection. */)
1211 (Lisp_Object process
)
1213 return XPROCESS (process
)->type
;
1217 DEFUN ("process-type", Fprocess_type
, Sprocess_type
, 1, 1, 0,
1218 doc
: /* Return the connection type of PROCESS.
1219 The value is either the symbol `real', `network', or `serial'.
1220 PROCESS may be a process, a buffer, the name of a process or buffer, or
1221 nil, indicating the current buffer's process. */)
1222 (Lisp_Object process
)
1225 proc
= get_process (process
);
1226 return XPROCESS (proc
)->type
;
1229 DEFUN ("format-network-address", Fformat_network_address
, Sformat_network_address
,
1231 doc
: /* Convert network ADDRESS from internal format to a string.
1232 A 4 or 5 element vector represents an IPv4 address (with port number).
1233 An 8 or 9 element vector represents an IPv6 address (with port number).
1234 If optional second argument OMIT-PORT is non-nil, don't include a port
1235 number in the string, even when present in ADDRESS.
1236 Returns nil if format of ADDRESS is invalid. */)
1237 (Lisp_Object address
, Lisp_Object omit_port
)
1242 if (STRINGP (address
)) /* AF_LOCAL */
1245 if (VECTORP (address
)) /* AF_INET or AF_INET6 */
1247 register struct Lisp_Vector
*p
= XVECTOR (address
);
1248 ptrdiff_t size
= p
->header
.size
;
1249 Lisp_Object args
[10];
1252 if (size
== 4 || (size
== 5 && !NILP (omit_port
)))
1254 args
[0] = build_string ("%d.%d.%d.%d");
1259 args
[0] = build_string ("%d.%d.%d.%d:%d");
1262 else if (size
== 8 || (size
== 9 && !NILP (omit_port
)))
1264 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
1269 args
[0] = build_string ("[%x:%x:%x:%x:%x:%x:%x:%x]:%d");
1275 for (i
= 0; i
< nargs
; i
++)
1277 if (! RANGED_INTEGERP (0, p
->contents
[i
], 65535))
1280 if (nargs
<= 5 /* IPv4 */
1281 && i
< 4 /* host, not port */
1282 && XINT (p
->contents
[i
]) > 255)
1285 args
[i
+1] = p
->contents
[i
];
1288 return Fformat (nargs
+1, args
);
1291 if (CONSP (address
))
1293 Lisp_Object args
[2];
1294 args
[0] = build_string ("<Family %d>");
1295 args
[1] = Fcar (address
);
1296 return Fformat (2, args
);
1302 DEFUN ("process-list", Fprocess_list
, Sprocess_list
, 0, 0, 0,
1303 doc
: /* Return a list of all processes. */)
1306 return Fmapcar (Qcdr
, Vprocess_alist
);
1309 /* Starting asynchronous inferior processes. */
1311 static Lisp_Object
start_process_unwind (Lisp_Object proc
);
1313 DEFUN ("start-process", Fstart_process
, Sstart_process
, 3, MANY
, 0,
1314 doc
: /* Start a program in a subprocess. Return the process object for it.
1315 NAME is name for process. It is modified if necessary to make it unique.
1316 BUFFER is the buffer (or buffer name) to associate with the process.
1318 Process output (both standard output and standard error streams) goes
1319 at end of BUFFER, unless you specify an output stream or filter
1320 function to handle the output. BUFFER may also be nil, meaning that
1321 this process is not associated with any buffer.
1323 PROGRAM is the program file name. It is searched for in `exec-path'
1324 (which see). If nil, just associate a pty with the buffer. Remaining
1325 arguments are strings to give program as arguments.
1327 If you want to separate standard output from standard error, invoke
1328 the command through a shell and redirect one of them using the shell
1331 usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS) */)
1332 (ptrdiff_t nargs
, Lisp_Object
*args
)
1334 Lisp_Object buffer
, name
, program
, proc
, current_dir
, tem
;
1335 register unsigned char **new_argv
;
1337 ptrdiff_t count
= SPECPDL_INDEX ();
1341 buffer
= Fget_buffer_create (buffer
);
1343 /* Make sure that the child will be able to chdir to the current
1344 buffer's current directory, or its unhandled equivalent. We
1345 can't just have the child check for an error when it does the
1346 chdir, since it's in a vfork.
1348 We have to GCPRO around this because Fexpand_file_name and
1349 Funhandled_file_name_directory might call a file name handling
1350 function. The argument list is protected by the caller, so all
1351 we really have to worry about is buffer. */
1353 struct gcpro gcpro1
, gcpro2
;
1355 current_dir
= BVAR (current_buffer
, directory
);
1357 GCPRO2 (buffer
, current_dir
);
1359 current_dir
= Funhandled_file_name_directory (current_dir
);
1360 if (NILP (current_dir
))
1361 /* If the file name handler says that current_dir is unreachable, use
1362 a sensible default. */
1363 current_dir
= build_string ("~/");
1364 current_dir
= expand_and_dir_to_file (current_dir
, Qnil
);
1365 if (NILP (Ffile_accessible_directory_p (current_dir
)))
1366 report_file_error ("Setting current directory",
1367 Fcons (BVAR (current_buffer
, directory
), Qnil
));
1373 CHECK_STRING (name
);
1377 if (!NILP (program
))
1378 CHECK_STRING (program
);
1380 proc
= make_process (name
);
1381 /* If an error occurs and we can't start the process, we want to
1382 remove it from the process list. This means that each error
1383 check in create_process doesn't need to call remove_process
1384 itself; it's all taken care of here. */
1385 record_unwind_protect (start_process_unwind
, proc
);
1387 pset_childp (XPROCESS (proc
), Qt
);
1388 pset_plist (XPROCESS (proc
), Qnil
);
1389 pset_type (XPROCESS (proc
), Qreal
);
1390 pset_buffer (XPROCESS (proc
), buffer
);
1391 pset_sentinel (XPROCESS (proc
), Qinternal_default_process_sentinel
);
1392 pset_filter (XPROCESS (proc
), Qinternal_default_process_filter
);
1393 pset_command (XPROCESS (proc
), Flist (nargs
- 2, args
+ 2));
1396 /* AKA GNUTLS_INITSTAGE(proc). */
1397 XPROCESS (proc
)->gnutls_initstage
= GNUTLS_STAGE_EMPTY
;
1398 pset_gnutls_cred_type (XPROCESS (proc
), Qnil
);
1401 #ifdef ADAPTIVE_READ_BUFFERING
1402 XPROCESS (proc
)->adaptive_read_buffering
1403 = (NILP (Vprocess_adaptive_read_buffering
) ? 0
1404 : EQ (Vprocess_adaptive_read_buffering
, Qt
) ? 1 : 2);
1407 /* Make the process marker point into the process buffer (if any). */
1408 if (BUFFERP (buffer
))
1409 set_marker_both (XPROCESS (proc
)->mark
, buffer
,
1410 BUF_ZV (XBUFFER (buffer
)),
1411 BUF_ZV_BYTE (XBUFFER (buffer
)));
1414 /* Decide coding systems for communicating with the process. Here
1415 we don't setup the structure coding_system nor pay attention to
1416 unibyte mode. They are done in create_process. */
1418 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
1419 Lisp_Object coding_systems
= Qt
;
1420 Lisp_Object val
, *args2
;
1421 struct gcpro gcpro1
, gcpro2
;
1423 val
= Vcoding_system_for_read
;
1426 args2
= alloca ((nargs
+ 1) * sizeof *args2
);
1427 args2
[0] = Qstart_process
;
1428 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1429 GCPRO2 (proc
, current_dir
);
1430 if (!NILP (program
))
1431 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1433 if (CONSP (coding_systems
))
1434 val
= XCAR (coding_systems
);
1435 else if (CONSP (Vdefault_process_coding_system
))
1436 val
= XCAR (Vdefault_process_coding_system
);
1438 pset_decode_coding_system (XPROCESS (proc
), val
);
1440 val
= Vcoding_system_for_write
;
1443 if (EQ (coding_systems
, Qt
))
1445 args2
= alloca ((nargs
+ 1) * sizeof *args2
);
1446 args2
[0] = Qstart_process
;
1447 for (i
= 0; i
< nargs
; i
++) args2
[i
+ 1] = args
[i
];
1448 GCPRO2 (proc
, current_dir
);
1449 if (!NILP (program
))
1450 coding_systems
= Ffind_operation_coding_system (nargs
+ 1, args2
);
1453 if (CONSP (coding_systems
))
1454 val
= XCDR (coding_systems
);
1455 else if (CONSP (Vdefault_process_coding_system
))
1456 val
= XCDR (Vdefault_process_coding_system
);
1458 pset_encode_coding_system (XPROCESS (proc
), val
);
1459 /* Note: At this moment, the above coding system may leave
1460 text-conversion or eol-conversion unspecified. They will be
1461 decided after we read output from the process and decode it by
1462 some coding system, or just before we actually send a text to
1467 pset_decoding_buf (XPROCESS (proc
), empty_unibyte_string
);
1468 XPROCESS (proc
)->decoding_carryover
= 0;
1469 pset_encoding_buf (XPROCESS (proc
), empty_unibyte_string
);
1471 XPROCESS (proc
)->inherit_coding_system_flag
1472 = !(NILP (buffer
) || !inherit_process_coding_system
);
1474 if (!NILP (program
))
1476 /* If program file name is not absolute, search our path for it.
1477 Put the name we will really use in TEM. */
1478 if (!IS_DIRECTORY_SEP (SREF (program
, 0))
1479 && !(SCHARS (program
) > 1
1480 && IS_DEVICE_SEP (SREF (program
, 1))))
1482 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1485 GCPRO4 (name
, program
, buffer
, current_dir
);
1486 openp (Vexec_path
, program
, Vexec_suffixes
, &tem
, make_number (X_OK
));
1489 report_file_error ("Searching for program", Fcons (program
, Qnil
));
1490 tem
= Fexpand_file_name (tem
, Qnil
);
1494 if (!NILP (Ffile_directory_p (program
)))
1495 error ("Specified program for new process is a directory");
1499 /* If program file name starts with /: for quoting a magic name,
1501 if (SBYTES (tem
) > 2 && SREF (tem
, 0) == '/'
1502 && SREF (tem
, 1) == ':')
1503 tem
= Fsubstring (tem
, make_number (2), Qnil
);
1506 Lisp_Object arg_encoding
= Qnil
;
1507 struct gcpro gcpro1
;
1510 /* Encode the file name and put it in NEW_ARGV.
1511 That's where the child will use it to execute the program. */
1512 tem
= Fcons (ENCODE_FILE (tem
), Qnil
);
1514 /* Here we encode arguments by the coding system used for sending
1515 data to the process. We don't support using different coding
1516 systems for encoding arguments and for encoding data sent to the
1519 for (i
= 3; i
< nargs
; i
++)
1521 tem
= Fcons (args
[i
], tem
);
1522 CHECK_STRING (XCAR (tem
));
1523 if (STRING_MULTIBYTE (XCAR (tem
)))
1525 if (NILP (arg_encoding
))
1526 arg_encoding
= (complement_process_encoding_system
1527 (XPROCESS (proc
)->encode_coding_system
));
1529 code_convert_string_norecord
1530 (XCAR (tem
), arg_encoding
, 1));
1537 /* Now that everything is encoded we can collect the strings into
1539 new_argv
= alloca ((nargs
- 1) * sizeof *new_argv
);
1540 new_argv
[nargs
- 2] = 0;
1542 for (i
= nargs
- 2; i
-- != 0; )
1544 new_argv
[i
] = SDATA (XCAR (tem
));
1548 create_process (proc
, (char **) new_argv
, current_dir
);
1553 return unbind_to (count
, proc
);
1556 /* This function is the unwind_protect form for Fstart_process. If
1557 PROC doesn't have its pid set, then we know someone has signaled
1558 an error and the process wasn't started successfully, so we should
1559 remove it from the process list. */
1561 start_process_unwind (Lisp_Object proc
)
1563 if (!PROCESSP (proc
))
1566 /* Was PROC started successfully?
1567 -2 is used for a pty with no process, eg for gdb. */
1568 if (XPROCESS (proc
)->pid
<= 0 && XPROCESS (proc
)->pid
!= -2)
1569 remove_process (proc
);
1575 create_process_1 (struct atimer
*timer
)
1577 /* Nothing to do. */
1582 create_process (Lisp_Object process
, char **new_argv
, Lisp_Object current_dir
)
1584 int inchannel
, outchannel
;
1588 int wait_child_setup
[2];
1591 /* Use volatile to protect variables from being clobbered by vfork. */
1592 volatile int forkin
, forkout
;
1593 volatile bool pty_flag
= 0;
1594 volatile Lisp_Object lisp_pty_name
= Qnil
;
1595 volatile Lisp_Object encoded_current_dir
;
1597 inchannel
= outchannel
= -1;
1600 if (!NILP (Vprocess_connection_type
))
1601 outchannel
= inchannel
= allocate_pty ();
1605 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1606 /* On most USG systems it does not work to open the pty's tty here,
1607 then close it and reopen it in the child. */
1608 /* Don't let this terminal become our controlling terminal
1609 (in case we don't have one). */
1610 forkout
= forkin
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1612 report_file_error ("Opening pty", Qnil
);
1614 forkin
= forkout
= -1;
1615 #endif /* not USG, or USG_SUBTTY_WORKS */
1617 lisp_pty_name
= build_string (pty_name
);
1620 #endif /* HAVE_PTYS */
1625 report_file_error ("Creating pipe", Qnil
);
1631 emacs_close (inchannel
);
1632 emacs_close (forkout
);
1633 report_file_error ("Creating pipe", Qnil
);
1643 tem
= pipe (wait_child_setup
);
1645 report_file_error ("Creating pipe", Qnil
);
1646 tem
= fcntl (wait_child_setup
[1], F_GETFD
, 0);
1648 tem
= fcntl (wait_child_setup
[1], F_SETFD
, tem
| FD_CLOEXEC
);
1651 emacs_close (wait_child_setup
[0]);
1652 emacs_close (wait_child_setup
[1]);
1653 report_file_error ("Setting file descriptor flags", Qnil
);
1658 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1659 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1661 /* Record this as an active process, with its channels.
1662 As a result, child_setup will close Emacs's side of the pipes. */
1663 chan_process
[inchannel
] = process
;
1664 XPROCESS (process
)->infd
= inchannel
;
1665 XPROCESS (process
)->outfd
= outchannel
;
1667 /* Previously we recorded the tty descriptor used in the subprocess.
1668 It was only used for getting the foreground tty process, so now
1669 we just reopen the device (see emacs_get_tty_pgrp) as this is
1670 more portable (see USG_SUBTTY_WORKS above). */
1672 XPROCESS (process
)->pty_flag
= pty_flag
;
1673 pset_status (XPROCESS (process
), Qrun
);
1675 FD_SET (inchannel
, &input_wait_mask
);
1676 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1677 if (inchannel
> max_process_desc
)
1678 max_process_desc
= inchannel
;
1680 /* This may signal an error. */
1681 setup_process_coding_systems (process
);
1683 encoded_current_dir
= ENCODE_FILE (current_dir
);
1687 /* Block SIGCHLD until we have a chance to store the new fork's
1688 pid in its process structure. */
1689 sigemptyset (&blocked
);
1690 sigaddset (&blocked
, SIGCHLD
);
1691 pthread_sigmask (SIG_BLOCK
, &blocked
, 0);
1696 #endif /* not WINDOWSNT */
1698 int xforkin
= forkin
;
1699 int xforkout
= forkout
;
1701 /* Make the pty be the controlling terminal of the process. */
1703 /* First, disconnect its current controlling terminal. */
1704 /* We tried doing setsid only if pty_flag, but it caused
1705 process_set_signal to fail on SGI when using a pipe. */
1707 /* Make the pty's terminal the controlling terminal. */
1708 if (pty_flag
&& xforkin
>= 0)
1711 /* We ignore the return value
1712 because faith@cs.unc.edu says that is necessary on Linux. */
1713 ioctl (xforkin
, TIOCSCTTY
, 0);
1716 #if defined (LDISC1)
1717 if (pty_flag
&& xforkin
>= 0)
1720 tcgetattr (xforkin
, &t
);
1722 if (tcsetattr (xforkin
, TCSANOW
, &t
) < 0)
1723 emacs_write (1, "create_process/tcsetattr LDISC1 failed\n", 39);
1726 #if defined (NTTYDISC) && defined (TIOCSETD)
1727 if (pty_flag
&& xforkin
>= 0)
1729 /* Use new line discipline. */
1730 int ldisc
= NTTYDISC
;
1731 ioctl (xforkin
, TIOCSETD
, &ldisc
);
1736 /* In 4.3BSD, the TIOCSPGRP bug has been fixed, and now you
1737 can do TIOCSPGRP only to the process's controlling tty. */
1740 /* I wonder: would just ioctl (0, TIOCNOTTY, 0) work here?
1741 I can't test it since I don't have 4.3. */
1742 int j
= emacs_open ("/dev/tty", O_RDWR
, 0);
1745 ioctl (j
, TIOCNOTTY
, 0);
1749 #endif /* TIOCNOTTY */
1751 #if !defined (DONT_REOPEN_PTY)
1752 /*** There is a suggestion that this ought to be a
1753 conditional on TIOCSPGRP, or !defined TIOCSCTTY.
1754 Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
1755 that system does seem to need this code, even though
1756 both TIOCSCTTY is defined. */
1757 /* Now close the pty (if we had it open) and reopen it.
1758 This makes the pty the controlling terminal of the subprocess. */
1762 /* I wonder if emacs_close (emacs_open (pty_name, ...))
1765 emacs_close (xforkin
);
1766 xforkout
= xforkin
= emacs_open (pty_name
, O_RDWR
, 0);
1770 emacs_write (1, "Couldn't open the pty terminal ", 31);
1771 emacs_write (1, pty_name
, strlen (pty_name
));
1772 emacs_write (1, "\n", 1);
1777 #endif /* not DONT_REOPEN_PTY */
1779 #ifdef SETUP_SLAVE_PTY
1784 #endif /* SETUP_SLAVE_PTY */
1786 /* On AIX, we've disabled SIGHUP above once we start a child on a pty.
1787 Now reenable it in the child, so it will die when we want it to. */
1789 signal (SIGHUP
, SIG_DFL
);
1791 #endif /* HAVE_PTYS */
1793 signal (SIGINT
, SIG_DFL
);
1794 signal (SIGQUIT
, SIG_DFL
);
1796 /* Emacs ignores SIGPIPE, but the child should not. */
1797 signal (SIGPIPE
, SIG_DFL
);
1799 /* Stop blocking signals in the child. */
1800 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1803 child_setup_tty (xforkout
);
1805 pid
= child_setup (xforkin
, xforkout
, xforkout
,
1806 new_argv
, 1, encoded_current_dir
);
1807 #else /* not WINDOWSNT */
1808 emacs_close (wait_child_setup
[0]);
1809 child_setup (xforkin
, xforkout
, xforkout
,
1810 new_argv
, 1, encoded_current_dir
);
1811 #endif /* not WINDOWSNT */
1814 /* Back in the parent process. */
1816 XPROCESS (process
)->pid
= pid
;
1818 XPROCESS (process
)->alive
= 1;
1820 /* Stop blocking signals in the parent. */
1821 pthread_sigmask (SIG_SETMASK
, &empty_mask
, 0);
1827 emacs_close (forkin
);
1828 if (forkin
!= forkout
&& forkout
>= 0)
1829 emacs_close (forkout
);
1833 /* vfork succeeded. */
1836 register_child (pid
, inchannel
);
1837 #endif /* WINDOWSNT */
1839 /* If the subfork execv fails, and it exits,
1840 this close hangs. I don't know why.
1841 So have an interrupt jar it loose. */
1843 struct atimer
*timer
;
1844 EMACS_TIME offset
= make_emacs_time (1, 0);
1847 timer
= start_atimer (ATIMER_RELATIVE
, offset
, create_process_1
, 0);
1850 emacs_close (forkin
);
1852 cancel_atimer (timer
);
1856 if (forkin
!= forkout
&& forkout
>= 0)
1857 emacs_close (forkout
);
1859 pset_tty_name (XPROCESS (process
), lisp_pty_name
);
1862 /* Wait for child_setup to complete in case that vfork is
1863 actually defined as fork. The descriptor wait_child_setup[1]
1864 of a pipe is closed at the child side either by close-on-exec
1865 on successful execve or the _exit call in child_setup. */
1869 emacs_close (wait_child_setup
[1]);
1870 emacs_read (wait_child_setup
[0], &dummy
, 1);
1871 emacs_close (wait_child_setup
[0]);
1876 /* Now generate the error if vfork failed. */
1878 report_file_error ("Doing vfork", Qnil
);
1882 create_pty (Lisp_Object process
)
1884 int inchannel
, outchannel
;
1887 inchannel
= outchannel
= -1;
1890 if (!NILP (Vprocess_connection_type
))
1891 outchannel
= inchannel
= allocate_pty ();
1895 #if ! defined (USG) || defined (USG_SUBTTY_WORKS)
1896 /* On most USG systems it does not work to open the pty's tty here,
1897 then close it and reopen it in the child. */
1898 /* Don't let this terminal become our controlling terminal
1899 (in case we don't have one). */
1900 int forkout
= emacs_open (pty_name
, O_RDWR
| O_NOCTTY
, 0);
1902 report_file_error ("Opening pty", Qnil
);
1903 #if defined (DONT_REOPEN_PTY)
1904 /* In the case that vfork is defined as fork, the parent process
1905 (Emacs) may send some data before the child process completes
1906 tty options setup. So we setup tty before forking. */
1907 child_setup_tty (forkout
);
1908 #endif /* DONT_REOPEN_PTY */
1909 #endif /* not USG, or USG_SUBTTY_WORKS */
1912 #endif /* HAVE_PTYS */
1914 fcntl (inchannel
, F_SETFL
, O_NONBLOCK
);
1915 fcntl (outchannel
, F_SETFL
, O_NONBLOCK
);
1917 /* Record this as an active process, with its channels.
1918 As a result, child_setup will close Emacs's side of the pipes. */
1919 chan_process
[inchannel
] = process
;
1920 XPROCESS (process
)->infd
= inchannel
;
1921 XPROCESS (process
)->outfd
= outchannel
;
1923 /* Previously we recorded the tty descriptor used in the subprocess.
1924 It was only used for getting the foreground tty process, so now
1925 we just reopen the device (see emacs_get_tty_pgrp) as this is
1926 more portable (see USG_SUBTTY_WORKS above). */
1928 XPROCESS (process
)->pty_flag
= pty_flag
;
1929 pset_status (XPROCESS (process
), Qrun
);
1930 setup_process_coding_systems (process
);
1932 FD_SET (inchannel
, &input_wait_mask
);
1933 FD_SET (inchannel
, &non_keyboard_wait_mask
);
1934 if (inchannel
> max_process_desc
)
1935 max_process_desc
= inchannel
;
1937 XPROCESS (process
)->pid
= -2;
1940 pset_tty_name (XPROCESS (process
), build_string (pty_name
));
1943 pset_tty_name (XPROCESS (process
), Qnil
);
1947 /* Convert an internal struct sockaddr to a lisp object (vector or string).
1948 The address family of sa is not included in the result. */
1951 conv_sockaddr_to_lisp (struct sockaddr
*sa
, int len
)
1953 Lisp_Object address
;
1956 register struct Lisp_Vector
*p
;
1958 /* Workaround for a bug in getsockname on BSD: Names bound to
1959 sockets in the UNIX domain are inaccessible; getsockname returns
1960 a zero length name. */
1961 if (len
< offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
))
1962 return empty_unibyte_string
;
1964 switch (sa
->sa_family
)
1968 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
1969 len
= sizeof (sin
->sin_addr
) + 1;
1970 address
= Fmake_vector (make_number (len
), Qnil
);
1971 p
= XVECTOR (address
);
1972 p
->contents
[--len
] = make_number (ntohs (sin
->sin_port
));
1973 cp
= (unsigned char *) &sin
->sin_addr
;
1979 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
1980 uint16_t *ip6
= (uint16_t *) &sin6
->sin6_addr
;
1981 len
= sizeof (sin6
->sin6_addr
)/2 + 1;
1982 address
= Fmake_vector (make_number (len
), Qnil
);
1983 p
= XVECTOR (address
);
1984 p
->contents
[--len
] = make_number (ntohs (sin6
->sin6_port
));
1985 for (i
= 0; i
< len
; i
++)
1986 p
->contents
[i
] = make_number (ntohs (ip6
[i
]));
1990 #ifdef HAVE_LOCAL_SOCKETS
1993 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
1994 for (i
= 0; i
< sizeof (sockun
->sun_path
); i
++)
1995 if (sockun
->sun_path
[i
] == 0)
1997 return make_unibyte_string (sockun
->sun_path
, i
);
2001 len
-= offsetof (struct sockaddr
, sa_family
) + sizeof (sa
->sa_family
);
2002 address
= Fcons (make_number (sa
->sa_family
),
2003 Fmake_vector (make_number (len
), Qnil
));
2004 p
= XVECTOR (XCDR (address
));
2005 cp
= (unsigned char *) &sa
->sa_family
+ sizeof (sa
->sa_family
);
2011 p
->contents
[i
++] = make_number (*cp
++);
2017 /* Get family and required size for sockaddr structure to hold ADDRESS. */
2020 get_lisp_to_sockaddr_size (Lisp_Object address
, int *familyp
)
2022 register struct Lisp_Vector
*p
;
2024 if (VECTORP (address
))
2026 p
= XVECTOR (address
);
2027 if (p
->header
.size
== 5)
2030 return sizeof (struct sockaddr_in
);
2033 else if (p
->header
.size
== 9)
2035 *familyp
= AF_INET6
;
2036 return sizeof (struct sockaddr_in6
);
2040 #ifdef HAVE_LOCAL_SOCKETS
2041 else if (STRINGP (address
))
2043 *familyp
= AF_LOCAL
;
2044 return sizeof (struct sockaddr_un
);
2047 else if (CONSP (address
) && TYPE_RANGED_INTEGERP (int, XCAR (address
))
2048 && VECTORP (XCDR (address
)))
2050 struct sockaddr
*sa
;
2051 *familyp
= XINT (XCAR (address
));
2052 p
= XVECTOR (XCDR (address
));
2053 return p
->header
.size
+ sizeof (sa
->sa_family
);
2058 /* Convert an address object (vector or string) to an internal sockaddr.
2060 The address format has been basically validated by
2061 get_lisp_to_sockaddr_size, but this does not mean FAMILY is valid;
2062 it could have come from user data. So if FAMILY is not valid,
2063 we return after zeroing *SA. */
2066 conv_lisp_to_sockaddr (int family
, Lisp_Object address
, struct sockaddr
*sa
, int len
)
2068 register struct Lisp_Vector
*p
;
2069 register unsigned char *cp
= NULL
;
2073 memset (sa
, 0, len
);
2075 if (VECTORP (address
))
2077 p
= XVECTOR (address
);
2078 if (family
== AF_INET
)
2080 struct sockaddr_in
*sin
= (struct sockaddr_in
*) sa
;
2081 len
= sizeof (sin
->sin_addr
) + 1;
2082 hostport
= XINT (p
->contents
[--len
]);
2083 sin
->sin_port
= htons (hostport
);
2084 cp
= (unsigned char *)&sin
->sin_addr
;
2085 sa
->sa_family
= family
;
2088 else if (family
== AF_INET6
)
2090 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*) sa
;
2091 uint16_t *ip6
= (uint16_t *)&sin6
->sin6_addr
;
2092 len
= sizeof (sin6
->sin6_addr
) + 1;
2093 hostport
= XINT (p
->contents
[--len
]);
2094 sin6
->sin6_port
= htons (hostport
);
2095 for (i
= 0; i
< len
; i
++)
2096 if (INTEGERP (p
->contents
[i
]))
2098 int j
= XFASTINT (p
->contents
[i
]) & 0xffff;
2101 sa
->sa_family
= family
;
2108 else if (STRINGP (address
))
2110 #ifdef HAVE_LOCAL_SOCKETS
2111 if (family
== AF_LOCAL
)
2113 struct sockaddr_un
*sockun
= (struct sockaddr_un
*) sa
;
2114 cp
= SDATA (address
);
2115 for (i
= 0; i
< sizeof (sockun
->sun_path
) && *cp
; i
++)
2116 sockun
->sun_path
[i
] = *cp
++;
2117 sa
->sa_family
= family
;
2124 p
= XVECTOR (XCDR (address
));
2125 cp
= (unsigned char *)sa
+ sizeof (sa
->sa_family
);
2128 for (i
= 0; i
< len
; i
++)
2129 if (INTEGERP (p
->contents
[i
]))
2130 *cp
++ = XFASTINT (p
->contents
[i
]) & 0xff;
2133 #ifdef DATAGRAM_SOCKETS
2134 DEFUN ("process-datagram-address", Fprocess_datagram_address
, Sprocess_datagram_address
,
2136 doc
: /* Get the current datagram address associated with PROCESS. */)
2137 (Lisp_Object process
)
2141 CHECK_PROCESS (process
);
2143 if (!DATAGRAM_CONN_P (process
))
2146 channel
= XPROCESS (process
)->infd
;
2147 return conv_sockaddr_to_lisp (datagram_address
[channel
].sa
,
2148 datagram_address
[channel
].len
);
2151 DEFUN ("set-process-datagram-address", Fset_process_datagram_address
, Sset_process_datagram_address
,
2153 doc
: /* Set the datagram address for PROCESS to ADDRESS.
2154 Returns nil upon error setting address, ADDRESS otherwise. */)
2155 (Lisp_Object process
, Lisp_Object address
)
2160 CHECK_PROCESS (process
);
2162 if (!DATAGRAM_CONN_P (process
))
2165 channel
= XPROCESS (process
)->infd
;
2167 len
= get_lisp_to_sockaddr_size (address
, &family
);
2168 if (len
== 0 || datagram_address
[channel
].len
!= len
)
2170 conv_lisp_to_sockaddr (family
, address
, datagram_address
[channel
].sa
, len
);
2176 static const struct socket_options
{
2177 /* The name of this option. Should be lowercase version of option
2178 name without SO_ prefix. */
2180 /* Option level SOL_... */
2182 /* Option number SO_... */
2184 enum { SOPT_UNKNOWN
, SOPT_BOOL
, SOPT_INT
, SOPT_IFNAME
, SOPT_LINGER
} opttype
;
2185 enum { OPIX_NONE
=0, OPIX_MISC
=1, OPIX_REUSEADDR
=2 } optbit
;
2186 } socket_options
[] =
2188 #ifdef SO_BINDTODEVICE
2189 { ":bindtodevice", SOL_SOCKET
, SO_BINDTODEVICE
, SOPT_IFNAME
, OPIX_MISC
},
2192 { ":broadcast", SOL_SOCKET
, SO_BROADCAST
, SOPT_BOOL
, OPIX_MISC
},
2195 { ":dontroute", SOL_SOCKET
, SO_DONTROUTE
, SOPT_BOOL
, OPIX_MISC
},
2198 { ":keepalive", SOL_SOCKET
, SO_KEEPALIVE
, SOPT_BOOL
, OPIX_MISC
},
2201 { ":linger", SOL_SOCKET
, SO_LINGER
, SOPT_LINGER
, OPIX_MISC
},
2204 { ":oobinline", SOL_SOCKET
, SO_OOBINLINE
, SOPT_BOOL
, OPIX_MISC
},
2207 { ":priority", SOL_SOCKET
, SO_PRIORITY
, SOPT_INT
, OPIX_MISC
},
2210 { ":reuseaddr", SOL_SOCKET
, SO_REUSEADDR
, SOPT_BOOL
, OPIX_REUSEADDR
},
2212 { 0, 0, 0, SOPT_UNKNOWN
, OPIX_NONE
}
2215 /* Set option OPT to value VAL on socket S.
2217 Returns (1<<socket_options[OPT].optbit) if option is known, 0 otherwise.
2218 Signals an error if setting a known option fails.
2222 set_socket_option (int s
, Lisp_Object opt
, Lisp_Object val
)
2225 const struct socket_options
*sopt
;
2230 name
= SSDATA (SYMBOL_NAME (opt
));
2231 for (sopt
= socket_options
; sopt
->name
; sopt
++)
2232 if (strcmp (name
, sopt
->name
) == 0)
2235 switch (sopt
->opttype
)
2240 optval
= NILP (val
) ? 0 : 1;
2241 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2242 &optval
, sizeof (optval
));
2249 if (TYPE_RANGED_INTEGERP (int, val
))
2250 optval
= XINT (val
);
2252 error ("Bad option value for %s", name
);
2253 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2254 &optval
, sizeof (optval
));
2258 #ifdef SO_BINDTODEVICE
2261 char devname
[IFNAMSIZ
+1];
2263 /* This is broken, at least in the Linux 2.4 kernel.
2264 To unbind, the arg must be a zero integer, not the empty string.
2265 This should work on all systems. KFS. 2003-09-23. */
2266 memset (devname
, 0, sizeof devname
);
2269 char *arg
= SSDATA (val
);
2270 int len
= min (strlen (arg
), IFNAMSIZ
);
2271 memcpy (devname
, arg
, len
);
2273 else if (!NILP (val
))
2274 error ("Bad option value for %s", name
);
2275 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2284 struct linger linger
;
2287 linger
.l_linger
= 0;
2288 if (TYPE_RANGED_INTEGERP (int, val
))
2289 linger
.l_linger
= XINT (val
);
2291 linger
.l_onoff
= NILP (val
) ? 0 : 1;
2292 ret
= setsockopt (s
, sopt
->optlevel
, sopt
->optnum
,
2293 &linger
, sizeof (linger
));
2303 report_file_error ("Cannot set network option",
2304 Fcons (opt
, Fcons (val
, Qnil
)));
2305 return (1 << sopt
->optbit
);
2309 DEFUN ("set-network-process-option",
2310 Fset_network_process_option
, Sset_network_process_option
,
2312 doc
: /* For network process PROCESS set option OPTION to value VALUE.
2313 See `make-network-process' for a list of options and values.
2314 If optional fourth arg NO-ERROR is non-nil, don't signal an error if
2315 OPTION is not a supported option, return nil instead; otherwise return t. */)
2316 (Lisp_Object process
, Lisp_Object option
, Lisp_Object value
, Lisp_Object no_error
)
2319 struct Lisp_Process
*p
;
2321 CHECK_PROCESS (process
);
2322 p
= XPROCESS (process
);
2323 if (!NETCONN1_P (p
))
2324 error ("Process is not a network process");
2328 error ("Process is not running");
2330 if (set_socket_option (s
, option
, value
))
2332 pset_childp (p
, Fplist_put (p
->childp
, option
, value
));
2336 if (NILP (no_error
))
2337 error ("Unknown or unsupported option");
2343 DEFUN ("serial-process-configure",
2344 Fserial_process_configure
,
2345 Sserial_process_configure
,
2347 doc
: /* Configure speed, bytesize, etc. of a serial process.
2349 Arguments are specified as keyword/argument pairs. Attributes that
2350 are not given are re-initialized from the process's current
2351 configuration (available via the function `process-contact') or set to
2352 reasonable default values. The following arguments are defined:
2358 -- Any of these arguments can be given to identify the process that is
2359 to be configured. If none of these arguments is given, the current
2360 buffer's process is used.
2362 :speed SPEED -- SPEED is the speed of the serial port in bits per
2363 second, also called baud rate. Any value can be given for SPEED, but
2364 most serial ports work only at a few defined values between 1200 and
2365 115200, with 9600 being the most common value. If SPEED is nil, the
2366 serial port is not configured any further, i.e., all other arguments
2367 are ignored. This may be useful for special serial ports such as
2368 Bluetooth-to-serial converters which can only be configured through AT
2369 commands. A value of nil for SPEED can be used only when passed
2370 through `make-serial-process' or `serial-term'.
2372 :bytesize BYTESIZE -- BYTESIZE is the number of bits per byte, which
2373 can be 7 or 8. If BYTESIZE is not given or nil, a value of 8 is used.
2375 :parity PARITY -- PARITY can be nil (don't use parity), the symbol
2376 `odd' (use odd parity), or the symbol `even' (use even parity). If
2377 PARITY is not given, no parity is used.
2379 :stopbits STOPBITS -- STOPBITS is the number of stopbits used to
2380 terminate a byte transmission. STOPBITS can be 1 or 2. If STOPBITS
2381 is not given or nil, 1 stopbit is used.
2383 :flowcontrol FLOWCONTROL -- FLOWCONTROL determines the type of
2384 flowcontrol to be used, which is either nil (don't use flowcontrol),
2385 the symbol `hw' (use RTS/CTS hardware flowcontrol), or the symbol `sw'
2386 \(use XON/XOFF software flowcontrol). If FLOWCONTROL is not given, no
2387 flowcontrol is used.
2389 `serial-process-configure' is called by `make-serial-process' for the
2390 initial configuration of the serial port.
2394 \(serial-process-configure :process "/dev/ttyS0" :speed 1200)
2396 \(serial-process-configure
2397 :buffer "COM1" :stopbits 1 :parity 'odd :flowcontrol 'hw)
2399 \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
2401 usage: (serial-process-configure &rest ARGS) */)
2402 (ptrdiff_t nargs
, Lisp_Object
*args
)
2404 struct Lisp_Process
*p
;
2405 Lisp_Object contact
= Qnil
;
2406 Lisp_Object proc
= Qnil
;
2407 struct gcpro gcpro1
;
2409 contact
= Flist (nargs
, args
);
2412 proc
= Fplist_get (contact
, QCprocess
);
2414 proc
= Fplist_get (contact
, QCname
);
2416 proc
= Fplist_get (contact
, QCbuffer
);
2418 proc
= Fplist_get (contact
, QCport
);
2419 proc
= get_process (proc
);
2420 p
= XPROCESS (proc
);
2421 if (!EQ (p
->type
, Qserial
))
2422 error ("Not a serial process");
2424 if (NILP (Fplist_get (p
->childp
, QCspeed
)))
2430 serial_configure (p
, contact
);
2436 /* Used by make-serial-process to recover from errors. */
2438 make_serial_process_unwind (Lisp_Object proc
)
2440 if (!PROCESSP (proc
))
2442 remove_process (proc
);
2446 DEFUN ("make-serial-process", Fmake_serial_process
, Smake_serial_process
,
2448 doc
: /* Create and return a serial port process.
2450 In Emacs, serial port connections are represented by process objects,
2451 so input and output work as for subprocesses, and `delete-process'
2452 closes a serial port connection. However, a serial process has no
2453 process id, it cannot be signaled, and the status codes are different
2454 from normal processes.
2456 `make-serial-process' creates a process and a buffer, on which you
2457 probably want to use `process-send-string'. Try \\[serial-term] for
2458 an interactive terminal. See below for examples.
2460 Arguments are specified as keyword/argument pairs. The following
2461 arguments are defined:
2463 :port PORT -- (mandatory) PORT is the path or name of the serial port.
2464 For example, this could be "/dev/ttyS0" on Unix. On Windows, this
2465 could be "COM1", or "\\\\.\\COM10" for ports higher than COM9 (double
2466 the backslashes in strings).
2468 :speed SPEED -- (mandatory) is handled by `serial-process-configure',
2469 which this function calls.
2471 :name NAME -- NAME is the name of the process. If NAME is not given,
2472 the value of PORT is used.
2474 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2475 with the process. Process output goes at the end of that buffer,
2476 unless you specify an output stream or filter function to handle the
2477 output. If BUFFER is not given, the value of NAME is used.
2479 :coding CODING -- If CODING is a symbol, it specifies the coding
2480 system used for both reading and writing for this process. If CODING
2481 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2482 ENCODING is used for writing.
2484 :noquery BOOL -- When exiting Emacs, query the user if BOOL is nil and
2485 the process is running. If BOOL is not given, query before exiting.
2487 :stop BOOL -- Start process in the `stopped' state if BOOL is non-nil.
2488 In the stopped state, a serial process does not accept incoming data,
2489 but you can send outgoing data. The stopped state is cleared by
2490 `continue-process' and set by `stop-process'.
2492 :filter FILTER -- Install FILTER as the process filter.
2494 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2496 :plist PLIST -- Install PLIST as the initial plist of the process.
2502 -- This function calls `serial-process-configure' to handle these
2505 The original argument list, possibly modified by later configuration,
2506 is available via the function `process-contact'.
2510 \(make-serial-process :port "/dev/ttyS0" :speed 9600)
2512 \(make-serial-process :port "COM1" :speed 115200 :stopbits 2)
2514 \(make-serial-process :port "\\\\.\\COM13" :speed 1200 :bytesize 7 :parity 'odd)
2516 \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
2518 usage: (make-serial-process &rest ARGS) */)
2519 (ptrdiff_t nargs
, Lisp_Object
*args
)
2522 Lisp_Object proc
, contact
, port
;
2523 struct Lisp_Process
*p
;
2524 struct gcpro gcpro1
;
2525 Lisp_Object name
, buffer
;
2526 Lisp_Object tem
, val
;
2527 ptrdiff_t specpdl_count
= -1;
2532 contact
= Flist (nargs
, args
);
2535 port
= Fplist_get (contact
, QCport
);
2537 error ("No port specified");
2538 CHECK_STRING (port
);
2540 if (NILP (Fplist_member (contact
, QCspeed
)))
2541 error (":speed not specified");
2542 if (!NILP (Fplist_get (contact
, QCspeed
)))
2543 CHECK_NUMBER (Fplist_get (contact
, QCspeed
));
2545 name
= Fplist_get (contact
, QCname
);
2548 CHECK_STRING (name
);
2549 proc
= make_process (name
);
2550 specpdl_count
= SPECPDL_INDEX ();
2551 record_unwind_protect (make_serial_process_unwind
, proc
);
2552 p
= XPROCESS (proc
);
2554 fd
= serial_open (SSDATA (port
));
2557 if (fd
> max_process_desc
)
2558 max_process_desc
= fd
;
2559 chan_process
[fd
] = proc
;
2561 buffer
= Fplist_get (contact
, QCbuffer
);
2564 buffer
= Fget_buffer_create (buffer
);
2565 pset_buffer (p
, buffer
);
2567 pset_childp (p
, contact
);
2568 pset_plist (p
, Fcopy_sequence (Fplist_get (contact
, QCplist
)));
2569 pset_type (p
, Qserial
);
2570 pset_sentinel (p
, Fplist_get (contact
, QCsentinel
));
2571 pset_filter (p
, Fplist_get (contact
, QCfilter
));
2573 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
2574 p
->kill_without_query
= 1;
2575 if (tem
= Fplist_get (contact
, QCstop
), !NILP (tem
))
2576 pset_command (p
, Qt
);
2579 if (!EQ (p
->command
, Qt
))
2581 FD_SET (fd
, &input_wait_mask
);
2582 FD_SET (fd
, &non_keyboard_wait_mask
);
2585 if (BUFFERP (buffer
))
2587 set_marker_both (p
->mark
, buffer
,
2588 BUF_ZV (XBUFFER (buffer
)),
2589 BUF_ZV_BYTE (XBUFFER (buffer
)));
2592 tem
= Fplist_member (contact
, QCcoding
);
2593 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
2599 val
= XCAR (XCDR (tem
));
2603 else if (!NILP (Vcoding_system_for_read
))
2604 val
= Vcoding_system_for_read
;
2605 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2606 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2608 pset_decode_coding_system (p
, val
);
2613 val
= XCAR (XCDR (tem
));
2617 else if (!NILP (Vcoding_system_for_write
))
2618 val
= Vcoding_system_for_write
;
2619 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
2620 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
2622 pset_encode_coding_system (p
, val
);
2624 setup_process_coding_systems (proc
);
2625 pset_decoding_buf (p
, empty_unibyte_string
);
2626 p
->decoding_carryover
= 0;
2627 pset_encoding_buf (p
, empty_unibyte_string
);
2628 p
->inherit_coding_system_flag
2629 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
2631 Fserial_process_configure (nargs
, args
);
2633 specpdl_ptr
= specpdl
+ specpdl_count
;
2639 /* Create a network stream/datagram client/server process. Treated
2640 exactly like a normal process when reading and writing. Primary
2641 differences are in status display and process deletion. A network
2642 connection has no PID; you cannot signal it. All you can do is
2643 stop/continue it and deactivate/close it via delete-process */
2645 DEFUN ("make-network-process", Fmake_network_process
, Smake_network_process
,
2647 doc
: /* Create and return a network server or client process.
2649 In Emacs, network connections are represented by process objects, so
2650 input and output work as for subprocesses and `delete-process' closes
2651 a network connection. However, a network process has no process id,
2652 it cannot be signaled, and the status codes are different from normal
2655 Arguments are specified as keyword/argument pairs. The following
2656 arguments are defined:
2658 :name NAME -- NAME is name for process. It is modified if necessary
2661 :buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
2662 with the process. Process output goes at end of that buffer, unless
2663 you specify an output stream or filter function to handle the output.
2664 BUFFER may be also nil, meaning that this process is not associated
2667 :host HOST -- HOST is name of the host to connect to, or its IP
2668 address. The symbol `local' specifies the local host. If specified
2669 for a server process, it must be a valid name or address for the local
2670 host, and only clients connecting to that address will be accepted.
2672 :service SERVICE -- SERVICE is name of the service desired, or an
2673 integer specifying a port number to connect to. If SERVICE is t,
2674 a random port number is selected for the server. (If Emacs was
2675 compiled with getaddrinfo, a port number can also be specified as a
2676 string, e.g. "80", as well as an integer. This is not portable.)
2678 :type TYPE -- TYPE is the type of connection. The default (nil) is a
2679 stream type connection, `datagram' creates a datagram type connection,
2680 `seqpacket' creates a reliable datagram connection.
2682 :family FAMILY -- FAMILY is the address (and protocol) family for the
2683 service specified by HOST and SERVICE. The default (nil) is to use
2684 whatever address family (IPv4 or IPv6) that is defined for the host
2685 and port number specified by HOST and SERVICE. Other address families
2687 local -- for a local (i.e. UNIX) address specified by SERVICE.
2688 ipv4 -- use IPv4 address family only.
2689 ipv6 -- use IPv6 address family only.
2691 :local ADDRESS -- ADDRESS is the local address used for the connection.
2692 This parameter is ignored when opening a client process. When specified
2693 for a server process, the FAMILY, HOST and SERVICE args are ignored.
2695 :remote ADDRESS -- ADDRESS is the remote partner's address for the
2696 connection. This parameter is ignored when opening a stream server
2697 process. For a datagram server process, it specifies the initial
2698 setting of the remote datagram address. When specified for a client
2699 process, the FAMILY, HOST, and SERVICE args are ignored.
2701 The format of ADDRESS depends on the address family:
2702 - An IPv4 address is represented as an vector of integers [A B C D P]
2703 corresponding to numeric IP address A.B.C.D and port number P.
2704 - A local address is represented as a string with the address in the
2705 local address space.
2706 - An "unsupported family" address is represented by a cons (F . AV)
2707 where F is the family number and AV is a vector containing the socket
2708 address data with one element per address data byte. Do not rely on
2709 this format in portable code, as it may depend on implementation
2710 defined constants, data sizes, and data structure alignment.
2712 :coding CODING -- If CODING is a symbol, it specifies the coding
2713 system used for both reading and writing for this process. If CODING
2714 is a cons (DECODING . ENCODING), DECODING is used for reading, and
2715 ENCODING is used for writing.
2717 :nowait BOOL -- If BOOL is non-nil for a stream type client process,
2718 return without waiting for the connection to complete; instead, the
2719 sentinel function will be called with second arg matching "open" (if
2720 successful) or "failed" when the connect completes. Default is to use
2721 a blocking connect (i.e. wait) for stream type connections.
2723 :noquery BOOL -- Query the user unless BOOL is non-nil, and process is
2724 running when Emacs is exited.
2726 :stop BOOL -- Start process in the `stopped' state if BOOL non-nil.
2727 In the stopped state, a server process does not accept new
2728 connections, and a client process does not handle incoming traffic.
2729 The stopped state is cleared by `continue-process' and set by
2732 :filter FILTER -- Install FILTER as the process filter.
2734 :filter-multibyte BOOL -- If BOOL is non-nil, strings given to the
2735 process filter are multibyte, otherwise they are unibyte.
2736 If this keyword is not specified, the strings are multibyte if
2737 the default value of `enable-multibyte-characters' is non-nil.
2739 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
2741 :log LOG -- Install LOG as the server process log function. This
2742 function is called when the server accepts a network connection from a
2743 client. The arguments are SERVER, CLIENT, and MESSAGE, where SERVER
2744 is the server process, CLIENT is the new process for the connection,
2745 and MESSAGE is a string.
2747 :plist PLIST -- Install PLIST as the new process' initial plist.
2749 :server QLEN -- if QLEN is non-nil, create a server process for the
2750 specified FAMILY, SERVICE, and connection type (stream or datagram).
2751 If QLEN is an integer, it is used as the max. length of the server's
2752 pending connection queue (also known as the backlog); the default
2753 queue length is 5. Default is to create a client process.
2755 The following network options can be specified for this connection:
2757 :broadcast BOOL -- Allow send and receive of datagram broadcasts.
2758 :dontroute BOOL -- Only send to directly connected hosts.
2759 :keepalive BOOL -- Send keep-alive messages on network stream.
2760 :linger BOOL or TIMEOUT -- Send queued messages before closing.
2761 :oobinline BOOL -- Place out-of-band data in receive data stream.
2762 :priority INT -- Set protocol defined priority for sent packets.
2763 :reuseaddr BOOL -- Allow reusing a recently used local address
2764 (this is allowed by default for a server process).
2765 :bindtodevice NAME -- bind to interface NAME. Using this may require
2766 special privileges on some systems.
2768 Consult the relevant system programmer's manual pages for more
2769 information on using these options.
2772 A server process will listen for and accept connections from clients.
2773 When a client connection is accepted, a new network process is created
2774 for the connection with the following parameters:
2776 - The client's process name is constructed by concatenating the server
2777 process' NAME and a client identification string.
2778 - If the FILTER argument is non-nil, the client process will not get a
2779 separate process buffer; otherwise, the client's process buffer is a newly
2780 created buffer named after the server process' BUFFER name or process
2781 NAME concatenated with the client identification string.
2782 - The connection type and the process filter and sentinel parameters are
2783 inherited from the server process' TYPE, FILTER and SENTINEL.
2784 - The client process' contact info is set according to the client's
2785 addressing information (typically an IP address and a port number).
2786 - The client process' plist is initialized from the server's plist.
2788 Notice that the FILTER and SENTINEL args are never used directly by
2789 the server process. Also, the BUFFER argument is not used directly by
2790 the server process, but via the optional :log function, accepted (and
2791 failed) connections may be logged in the server process' buffer.
2793 The original argument list, modified with the actual connection
2794 information, is available via the `process-contact' function.
2796 usage: (make-network-process &rest ARGS) */)
2797 (ptrdiff_t nargs
, Lisp_Object
*args
)
2800 Lisp_Object contact
;
2801 struct Lisp_Process
*p
;
2802 #ifdef HAVE_GETADDRINFO
2803 struct addrinfo ai
, *res
, *lres
;
2804 struct addrinfo hints
;
2805 const char *portstring
;
2807 #else /* HAVE_GETADDRINFO */
2808 struct _emacs_addrinfo
2814 struct sockaddr
*ai_addr
;
2815 struct _emacs_addrinfo
*ai_next
;
2817 #endif /* HAVE_GETADDRINFO */
2818 struct sockaddr_in address_in
;
2819 #ifdef HAVE_LOCAL_SOCKETS
2820 struct sockaddr_un address_un
;
2825 int s
= -1, outch
, inch
;
2826 struct gcpro gcpro1
;
2827 ptrdiff_t count
= SPECPDL_INDEX ();
2829 Lisp_Object QCaddress
; /* one of QClocal or QCremote */
2831 Lisp_Object name
, buffer
, host
, service
, address
;
2832 Lisp_Object filter
, sentinel
;
2833 bool is_non_blocking_client
= 0;
2842 /* Save arguments for process-contact and clone-process. */
2843 contact
= Flist (nargs
, args
);
2847 /* Ensure socket support is loaded if available. */
2848 init_winsock (TRUE
);
2851 /* :type TYPE (nil: stream, datagram */
2852 tem
= Fplist_get (contact
, QCtype
);
2854 socktype
= SOCK_STREAM
;
2855 #ifdef DATAGRAM_SOCKETS
2856 else if (EQ (tem
, Qdatagram
))
2857 socktype
= SOCK_DGRAM
;
2859 #ifdef HAVE_SEQPACKET
2860 else if (EQ (tem
, Qseqpacket
))
2861 socktype
= SOCK_SEQPACKET
;
2864 error ("Unsupported connection type");
2867 tem
= Fplist_get (contact
, QCserver
);
2870 /* Don't support network sockets when non-blocking mode is
2871 not available, since a blocked Emacs is not useful. */
2873 if (TYPE_RANGED_INTEGERP (int, tem
))
2874 backlog
= XINT (tem
);
2877 /* Make QCaddress an alias for :local (server) or :remote (client). */
2878 QCaddress
= is_server
? QClocal
: QCremote
;
2881 if (!is_server
&& socktype
!= SOCK_DGRAM
2882 && (tem
= Fplist_get (contact
, QCnowait
), !NILP (tem
)))
2884 #ifndef NON_BLOCKING_CONNECT
2885 error ("Non-blocking connect not supported");
2887 is_non_blocking_client
= 1;
2891 name
= Fplist_get (contact
, QCname
);
2892 buffer
= Fplist_get (contact
, QCbuffer
);
2893 filter
= Fplist_get (contact
, QCfilter
);
2894 sentinel
= Fplist_get (contact
, QCsentinel
);
2896 CHECK_STRING (name
);
2898 /* Initialize addrinfo structure in case we don't use getaddrinfo. */
2899 ai
.ai_socktype
= socktype
;
2904 /* :local ADDRESS or :remote ADDRESS */
2905 address
= Fplist_get (contact
, QCaddress
);
2906 if (!NILP (address
))
2908 host
= service
= Qnil
;
2910 if (!(ai
.ai_addrlen
= get_lisp_to_sockaddr_size (address
, &family
)))
2911 error ("Malformed :address");
2912 ai
.ai_family
= family
;
2913 ai
.ai_addr
= alloca (ai
.ai_addrlen
);
2914 conv_lisp_to_sockaddr (family
, address
, ai
.ai_addr
, ai
.ai_addrlen
);
2918 /* :family FAMILY -- nil (for Inet), local, or integer. */
2919 tem
= Fplist_get (contact
, QCfamily
);
2922 #if defined (HAVE_GETADDRINFO) && defined (AF_INET6)
2928 #ifdef HAVE_LOCAL_SOCKETS
2929 else if (EQ (tem
, Qlocal
))
2933 else if (EQ (tem
, Qipv6
))
2936 else if (EQ (tem
, Qipv4
))
2938 else if (TYPE_RANGED_INTEGERP (int, tem
))
2939 family
= XINT (tem
);
2941 error ("Unknown address family");
2943 ai
.ai_family
= family
;
2945 /* :service SERVICE -- string, integer (port number), or t (random port). */
2946 service
= Fplist_get (contact
, QCservice
);
2948 /* :host HOST -- hostname, ip address, or 'local for localhost. */
2949 host
= Fplist_get (contact
, QChost
);
2952 if (EQ (host
, Qlocal
))
2953 /* Depending on setup, "localhost" may map to different IPv4 and/or
2954 IPv6 addresses, so it's better to be explicit. (Bug#6781) */
2955 host
= build_string ("127.0.0.1");
2956 CHECK_STRING (host
);
2959 #ifdef HAVE_LOCAL_SOCKETS
2960 if (family
== AF_LOCAL
)
2964 message (":family local ignores the :host \"%s\" property",
2966 contact
= Fplist_put (contact
, QChost
, Qnil
);
2969 CHECK_STRING (service
);
2970 memset (&address_un
, 0, sizeof address_un
);
2971 address_un
.sun_family
= AF_LOCAL
;
2972 if (sizeof address_un
.sun_path
<= SBYTES (service
))
2973 error ("Service name too long");
2974 strcpy (address_un
.sun_path
, SSDATA (service
));
2975 ai
.ai_addr
= (struct sockaddr
*) &address_un
;
2976 ai
.ai_addrlen
= sizeof address_un
;
2981 /* Slow down polling to every ten seconds.
2982 Some kernels have a bug which causes retrying connect to fail
2983 after a connect. Polling can interfere with gethostbyname too. */
2984 #ifdef POLL_FOR_INPUT
2985 if (socktype
!= SOCK_DGRAM
)
2987 record_unwind_protect (unwind_stop_other_atimers
, Qnil
);
2988 bind_polling_period (10);
2992 #ifdef HAVE_GETADDRINFO
2993 /* If we have a host, use getaddrinfo to resolve both host and service.
2994 Otherwise, use getservbyname to lookup the service. */
2998 /* SERVICE can either be a string or int.
2999 Convert to a C string for later use by getaddrinfo. */
3000 if (EQ (service
, Qt
))
3002 else if (INTEGERP (service
))
3004 sprintf (portbuf
, "%"pI
"d", XINT (service
));
3005 portstring
= portbuf
;
3009 CHECK_STRING (service
);
3010 portstring
= SSDATA (service
);
3015 memset (&hints
, 0, sizeof (hints
));
3017 hints
.ai_family
= family
;
3018 hints
.ai_socktype
= socktype
;
3019 hints
.ai_protocol
= 0;
3021 #ifdef HAVE_RES_INIT
3025 ret
= getaddrinfo (SSDATA (host
), portstring
, &hints
, &res
);
3027 #ifdef HAVE_GAI_STRERROR
3028 error ("%s/%s %s", SSDATA (host
), portstring
, gai_strerror (ret
));
3030 error ("%s/%s getaddrinfo error %d", SSDATA (host
), portstring
, ret
);
3036 #endif /* HAVE_GETADDRINFO */
3038 /* We end up here if getaddrinfo is not defined, or in case no hostname
3039 has been specified (e.g. for a local server process). */
3041 if (EQ (service
, Qt
))
3043 else if (INTEGERP (service
))
3044 port
= htons ((unsigned short) XINT (service
));
3047 struct servent
*svc_info
;
3048 CHECK_STRING (service
);
3049 svc_info
= getservbyname (SSDATA (service
),
3050 (socktype
== SOCK_DGRAM
? "udp" : "tcp"));
3052 error ("Unknown service: %s", SDATA (service
));
3053 port
= svc_info
->s_port
;
3056 memset (&address_in
, 0, sizeof address_in
);
3057 address_in
.sin_family
= family
;
3058 address_in
.sin_addr
.s_addr
= INADDR_ANY
;
3059 address_in
.sin_port
= port
;
3061 #ifndef HAVE_GETADDRINFO
3064 struct hostent
*host_info_ptr
;
3066 /* gethostbyname may fail with TRY_AGAIN, but we don't honor that,
3067 as it may `hang' Emacs for a very long time. */
3071 #ifdef HAVE_RES_INIT
3075 host_info_ptr
= gethostbyname (SDATA (host
));
3080 memcpy (&address_in
.sin_addr
, host_info_ptr
->h_addr
,
3081 host_info_ptr
->h_length
);
3082 family
= host_info_ptr
->h_addrtype
;
3083 address_in
.sin_family
= family
;
3086 /* Attempt to interpret host as numeric inet address */
3088 unsigned long numeric_addr
;
3089 numeric_addr
= inet_addr (SSDATA (host
));
3090 if (numeric_addr
== -1)
3091 error ("Unknown host \"%s\"", SDATA (host
));
3093 memcpy (&address_in
.sin_addr
, &numeric_addr
,
3094 sizeof (address_in
.sin_addr
));
3098 #endif /* not HAVE_GETADDRINFO */
3100 ai
.ai_family
= family
;
3101 ai
.ai_addr
= (struct sockaddr
*) &address_in
;
3102 ai
.ai_addrlen
= sizeof address_in
;
3106 /* Do this in case we never enter the for-loop below. */
3107 count1
= SPECPDL_INDEX ();
3110 for (lres
= res
; lres
; lres
= lres
->ai_next
)
3119 s
= socket (lres
->ai_family
, lres
->ai_socktype
, lres
->ai_protocol
);
3126 #ifdef DATAGRAM_SOCKETS
3127 if (!is_server
&& socktype
== SOCK_DGRAM
)
3129 #endif /* DATAGRAM_SOCKETS */
3131 #ifdef NON_BLOCKING_CONNECT
3132 if (is_non_blocking_client
)
3134 ret
= fcntl (s
, F_SETFL
, O_NONBLOCK
);
3145 /* Make us close S if quit. */
3146 record_unwind_protect (close_file_unwind
, make_number (s
));
3148 /* Parse network options in the arg list.
3149 We simply ignore anything which isn't a known option (including other keywords).
3150 An error is signaled if setting a known option fails. */
3151 for (optn
= optbits
= 0; optn
< nargs
-1; optn
+= 2)
3152 optbits
|= set_socket_option (s
, args
[optn
], args
[optn
+1]);
3156 /* Configure as a server socket. */
3158 /* SO_REUSEADDR = 1 is default for server sockets; must specify
3159 explicit :reuseaddr key to override this. */
3160 #ifdef HAVE_LOCAL_SOCKETS
3161 if (family
!= AF_LOCAL
)
3163 if (!(optbits
& (1 << OPIX_REUSEADDR
)))
3166 if (setsockopt (s
, SOL_SOCKET
, SO_REUSEADDR
, &optval
, sizeof optval
))
3167 report_file_error ("Cannot set reuse option on server socket", Qnil
);
3170 if (bind (s
, lres
->ai_addr
, lres
->ai_addrlen
))
3171 report_file_error ("Cannot bind server socket", Qnil
);
3173 #ifdef HAVE_GETSOCKNAME
3174 if (EQ (service
, Qt
))
3176 struct sockaddr_in sa1
;
3177 socklen_t len1
= sizeof (sa1
);
3178 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3180 ((struct sockaddr_in
*)(lres
->ai_addr
))->sin_port
= sa1
.sin_port
;
3181 service
= make_number (ntohs (sa1
.sin_port
));
3182 contact
= Fplist_put (contact
, QCservice
, service
);
3187 if (socktype
!= SOCK_DGRAM
&& listen (s
, backlog
))
3188 report_file_error ("Cannot listen on server socket", Qnil
);
3196 ret
= connect (s
, lres
->ai_addr
, lres
->ai_addrlen
);
3199 if (ret
== 0 || xerrno
== EISCONN
)
3201 /* The unwind-protect will be discarded afterwards.
3202 Likewise for immediate_quit. */
3206 #ifdef NON_BLOCKING_CONNECT
3208 if (is_non_blocking_client
&& xerrno
== EINPROGRESS
)
3212 if (is_non_blocking_client
&& xerrno
== EWOULDBLOCK
)
3219 if (xerrno
== EINTR
)
3221 /* Unlike most other syscalls connect() cannot be called
3222 again. (That would return EALREADY.) The proper way to
3223 wait for completion is pselect(). */
3231 sc
= pselect (s
+ 1, NULL
, &fdset
, NULL
, NULL
, NULL
);
3237 report_file_error ("select failed", Qnil
);
3241 len
= sizeof xerrno
;
3242 eassert (FD_ISSET (s
, &fdset
));
3243 if (getsockopt (s
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &len
) == -1)
3244 report_file_error ("getsockopt failed", Qnil
);
3246 errno
= xerrno
, report_file_error ("error during connect", Qnil
);
3250 #endif /* !WINDOWSNT */
3254 /* Discard the unwind protect closing S. */
3255 specpdl_ptr
= specpdl
+ count1
;
3260 if (xerrno
== EINTR
)
3267 #ifdef DATAGRAM_SOCKETS
3268 if (socktype
== SOCK_DGRAM
)
3270 if (datagram_address
[s
].sa
)
3272 datagram_address
[s
].sa
= xmalloc (lres
->ai_addrlen
);
3273 datagram_address
[s
].len
= lres
->ai_addrlen
;
3277 memset (datagram_address
[s
].sa
, 0, lres
->ai_addrlen
);
3278 if (remote
= Fplist_get (contact
, QCremote
), !NILP (remote
))
3281 rlen
= get_lisp_to_sockaddr_size (remote
, &rfamily
);
3282 if (rlen
!= 0 && rfamily
== lres
->ai_family
3283 && rlen
== lres
->ai_addrlen
)
3284 conv_lisp_to_sockaddr (rfamily
, remote
,
3285 datagram_address
[s
].sa
, rlen
);
3289 memcpy (datagram_address
[s
].sa
, lres
->ai_addr
, lres
->ai_addrlen
);
3292 contact
= Fplist_put (contact
, QCaddress
,
3293 conv_sockaddr_to_lisp (lres
->ai_addr
, lres
->ai_addrlen
));
3294 #ifdef HAVE_GETSOCKNAME
3297 struct sockaddr_in sa1
;
3298 socklen_t len1
= sizeof (sa1
);
3299 if (getsockname (s
, (struct sockaddr
*)&sa1
, &len1
) == 0)
3300 contact
= Fplist_put (contact
, QClocal
,
3301 conv_sockaddr_to_lisp ((struct sockaddr
*)&sa1
, len1
));
3308 #ifdef HAVE_GETADDRINFO
3317 /* Discard the unwind protect for closing S, if any. */
3318 specpdl_ptr
= specpdl
+ count1
;
3320 /* Unwind bind_polling_period and request_sigio. */
3321 unbind_to (count
, Qnil
);
3325 /* If non-blocking got this far - and failed - assume non-blocking is
3326 not supported after all. This is probably a wrong assumption, but
3327 the normal blocking calls to open-network-stream handles this error
3329 if (is_non_blocking_client
)
3334 report_file_error ("make server process failed", contact
);
3336 report_file_error ("make client process failed", contact
);
3343 buffer
= Fget_buffer_create (buffer
);
3344 proc
= make_process (name
);
3346 chan_process
[inch
] = proc
;
3348 fcntl (inch
, F_SETFL
, O_NONBLOCK
);
3350 p
= XPROCESS (proc
);
3352 pset_childp (p
, contact
);
3353 pset_plist (p
, Fcopy_sequence (Fplist_get (contact
, QCplist
)));
3354 pset_type (p
, Qnetwork
);
3356 pset_buffer (p
, buffer
);
3357 pset_sentinel (p
, sentinel
);
3358 pset_filter (p
, filter
);
3359 pset_log (p
, Fplist_get (contact
, QClog
));
3360 if (tem
= Fplist_get (contact
, QCnoquery
), !NILP (tem
))
3361 p
->kill_without_query
= 1;
3362 if ((tem
= Fplist_get (contact
, QCstop
), !NILP (tem
)))
3363 pset_command (p
, Qt
);
3367 if (is_server
&& socktype
!= SOCK_DGRAM
)
3368 pset_status (p
, Qlisten
);
3370 /* Make the process marker point into the process buffer (if any). */
3371 if (BUFFERP (buffer
))
3372 set_marker_both (p
->mark
, buffer
,
3373 BUF_ZV (XBUFFER (buffer
)),
3374 BUF_ZV_BYTE (XBUFFER (buffer
)));
3376 #ifdef NON_BLOCKING_CONNECT
3377 if (is_non_blocking_client
)
3379 /* We may get here if connect did succeed immediately. However,
3380 in that case, we still need to signal this like a non-blocking
3382 pset_status (p
, Qconnect
);
3383 if (!FD_ISSET (inch
, &connect_wait_mask
))
3385 FD_SET (inch
, &connect_wait_mask
);
3386 FD_SET (inch
, &write_mask
);
3387 num_pending_connects
++;
3392 /* A server may have a client filter setting of Qt, but it must
3393 still listen for incoming connects unless it is stopped. */
3394 if ((!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
3395 || (EQ (p
->status
, Qlisten
) && NILP (p
->command
)))
3397 FD_SET (inch
, &input_wait_mask
);
3398 FD_SET (inch
, &non_keyboard_wait_mask
);
3401 if (inch
> max_process_desc
)
3402 max_process_desc
= inch
;
3404 tem
= Fplist_member (contact
, QCcoding
);
3405 if (!NILP (tem
) && (!CONSP (tem
) || !CONSP (XCDR (tem
))))
3406 tem
= Qnil
; /* No error message (too late!). */
3409 /* Setup coding systems for communicating with the network stream. */
3410 struct gcpro gcpro1
;
3411 /* Qt denotes we have not yet called Ffind_operation_coding_system. */
3412 Lisp_Object coding_systems
= Qt
;
3413 Lisp_Object fargs
[5], val
;
3417 val
= XCAR (XCDR (tem
));
3421 else if (!NILP (Vcoding_system_for_read
))
3422 val
= Vcoding_system_for_read
;
3423 else if ((!NILP (buffer
) && NILP (BVAR (XBUFFER (buffer
), enable_multibyte_characters
)))
3424 || (NILP (buffer
) && NILP (BVAR (&buffer_defaults
, enable_multibyte_characters
))))
3425 /* We dare not decode end-of-line format by setting VAL to
3426 Qraw_text, because the existing Emacs Lisp libraries
3427 assume that they receive bare code including a sequence of
3432 if (NILP (host
) || NILP (service
))
3433 coding_systems
= Qnil
;
3436 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3437 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3439 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3442 if (CONSP (coding_systems
))
3443 val
= XCAR (coding_systems
);
3444 else if (CONSP (Vdefault_process_coding_system
))
3445 val
= XCAR (Vdefault_process_coding_system
);
3449 pset_decode_coding_system (p
, val
);
3453 val
= XCAR (XCDR (tem
));
3457 else if (!NILP (Vcoding_system_for_write
))
3458 val
= Vcoding_system_for_write
;
3459 else if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
3463 if (EQ (coding_systems
, Qt
))
3465 if (NILP (host
) || NILP (service
))
3466 coding_systems
= Qnil
;
3469 fargs
[0] = Qopen_network_stream
, fargs
[1] = name
,
3470 fargs
[2] = buffer
, fargs
[3] = host
, fargs
[4] = service
;
3472 coding_systems
= Ffind_operation_coding_system (5, fargs
);
3476 if (CONSP (coding_systems
))
3477 val
= XCDR (coding_systems
);
3478 else if (CONSP (Vdefault_process_coding_system
))
3479 val
= XCDR (Vdefault_process_coding_system
);
3483 pset_encode_coding_system (p
, val
);
3485 setup_process_coding_systems (proc
);
3487 pset_decoding_buf (p
, empty_unibyte_string
);
3488 p
->decoding_carryover
= 0;
3489 pset_encoding_buf (p
, empty_unibyte_string
);
3491 p
->inherit_coding_system_flag
3492 = !(!NILP (tem
) || NILP (buffer
) || !inherit_process_coding_system
);
3499 #if defined (HAVE_NET_IF_H)
3502 DEFUN ("network-interface-list", Fnetwork_interface_list
, Snetwork_interface_list
, 0, 0, 0,
3503 doc
: /* Return an alist of all network interfaces and their network address.
3504 Each element is a cons, the car of which is a string containing the
3505 interface name, and the cdr is the network address in internal
3506 format; see the description of ADDRESS in `make-network-process'. */)
3509 struct ifconf ifconf
;
3510 struct ifreq
*ifreq
;
3512 ptrdiff_t buf_size
= 512;
3516 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3522 buf
= xpalloc (buf
, &buf_size
, 1, INT_MAX
, 1);
3523 ifconf
.ifc_buf
= buf
;
3524 ifconf
.ifc_len
= buf_size
;
3525 if (ioctl (s
, SIOCGIFCONF
, &ifconf
))
3532 while (ifconf
.ifc_len
== buf_size
);
3537 ifreq
= ifconf
.ifc_req
;
3538 while ((char *) ifreq
< (char *) ifconf
.ifc_req
+ ifconf
.ifc_len
)
3540 struct ifreq
*ifq
= ifreq
;
3541 #ifdef HAVE_STRUCT_IFREQ_IFR_ADDR_SA_LEN
3542 #define SIZEOF_IFREQ(sif) \
3543 ((sif)->ifr_addr.sa_len < sizeof (struct sockaddr) \
3544 ? sizeof (*(sif)) : sizeof ((sif)->ifr_name) + (sif)->ifr_addr.sa_len)
3546 int len
= SIZEOF_IFREQ (ifq
);
3548 int len
= sizeof (*ifreq
);
3550 char namebuf
[sizeof (ifq
->ifr_name
) + 1];
3551 ifreq
= (struct ifreq
*) ((char *) ifreq
+ len
);
3553 if (ifq
->ifr_addr
.sa_family
!= AF_INET
)
3556 memcpy (namebuf
, ifq
->ifr_name
, sizeof (ifq
->ifr_name
));
3557 namebuf
[sizeof (ifq
->ifr_name
)] = 0;
3558 res
= Fcons (Fcons (build_string (namebuf
),
3559 conv_sockaddr_to_lisp (&ifq
->ifr_addr
,
3560 sizeof (struct sockaddr
))),
3567 #endif /* SIOCGIFCONF */
3569 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
3573 const char *flag_sym
;
3576 static const struct ifflag_def ifflag_table
[] = {
3580 #ifdef IFF_BROADCAST
3581 { IFF_BROADCAST
, "broadcast" },
3584 { IFF_DEBUG
, "debug" },
3587 { IFF_LOOPBACK
, "loopback" },
3589 #ifdef IFF_POINTOPOINT
3590 { IFF_POINTOPOINT
, "pointopoint" },
3593 { IFF_RUNNING
, "running" },
3596 { IFF_NOARP
, "noarp" },
3599 { IFF_PROMISC
, "promisc" },
3601 #ifdef IFF_NOTRAILERS
3602 #ifdef NS_IMPL_COCOA
3603 /* Really means smart, notrailers is obsolete */
3604 { IFF_NOTRAILERS
, "smart" },
3606 { IFF_NOTRAILERS
, "notrailers" },
3610 { IFF_ALLMULTI
, "allmulti" },
3613 { IFF_MASTER
, "master" },
3616 { IFF_SLAVE
, "slave" },
3618 #ifdef IFF_MULTICAST
3619 { IFF_MULTICAST
, "multicast" },
3622 { IFF_PORTSEL
, "portsel" },
3624 #ifdef IFF_AUTOMEDIA
3625 { IFF_AUTOMEDIA
, "automedia" },
3628 { IFF_DYNAMIC
, "dynamic" },
3631 { IFF_OACTIVE
, "oactive" }, /* OpenBSD: transmission in progress */
3634 { IFF_SIMPLEX
, "simplex" }, /* OpenBSD: can't hear own transmissions */
3637 { IFF_LINK0
, "link0" }, /* OpenBSD: per link layer defined bit */
3640 { IFF_LINK1
, "link1" }, /* OpenBSD: per link layer defined bit */
3643 { IFF_LINK2
, "link2" }, /* OpenBSD: per link layer defined bit */
3648 DEFUN ("network-interface-info", Fnetwork_interface_info
, Snetwork_interface_info
, 1, 1, 0,
3649 doc
: /* Return information about network interface named IFNAME.
3650 The return value is a list (ADDR BCAST NETMASK HWADDR FLAGS),
3651 where ADDR is the layer 3 address, BCAST is the layer 3 broadcast address,
3652 NETMASK is the layer 3 network mask, HWADDR is the layer 2 address, and
3653 FLAGS is the current flags of the interface. */)
3654 (Lisp_Object ifname
)
3657 Lisp_Object res
= Qnil
;
3661 #if (! (defined SIOCGIFHWADDR && defined HAVE_STRUCT_IFREQ_IFR_HWADDR) \
3662 && defined HAVE_GETIFADDRS && defined LLADDR)
3663 struct ifaddrs
*ifap
;
3666 CHECK_STRING (ifname
);
3668 if (sizeof rq
.ifr_name
<= SBYTES (ifname
))
3669 error ("interface name too long");
3670 strcpy (rq
.ifr_name
, SSDATA (ifname
));
3672 s
= socket (AF_INET
, SOCK_STREAM
, 0);
3677 #if defined (SIOCGIFFLAGS) && defined (HAVE_STRUCT_IFREQ_IFR_FLAGS)
3678 if (ioctl (s
, SIOCGIFFLAGS
, &rq
) == 0)
3680 int flags
= rq
.ifr_flags
;
3681 const struct ifflag_def
*fp
;
3684 /* If flags is smaller than int (i.e. short) it may have the high bit set
3685 due to IFF_MULTICAST. In that case, sign extending it into
3687 if (flags
< 0 && sizeof (rq
.ifr_flags
) < sizeof (flags
))
3688 flags
= (unsigned short) rq
.ifr_flags
;
3691 for (fp
= ifflag_table
; flags
!= 0 && fp
->flag_sym
; fp
++)
3693 if (flags
& fp
->flag_bit
)
3695 elt
= Fcons (intern (fp
->flag_sym
), elt
);
3696 flags
-= fp
->flag_bit
;
3699 for (fnum
= 0; flags
&& fnum
< 32; flags
>>= 1, fnum
++)
3703 elt
= Fcons (make_number (fnum
), elt
);
3708 res
= Fcons (elt
, res
);
3711 #if defined (SIOCGIFHWADDR) && defined (HAVE_STRUCT_IFREQ_IFR_HWADDR)
3712 if (ioctl (s
, SIOCGIFHWADDR
, &rq
) == 0)
3714 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3715 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3719 for (n
= 0; n
< 6; n
++)
3720 p
->contents
[n
] = make_number (((unsigned char *)&rq
.ifr_hwaddr
.sa_data
[0])[n
]);
3721 elt
= Fcons (make_number (rq
.ifr_hwaddr
.sa_family
), hwaddr
);
3723 #elif defined (HAVE_GETIFADDRS) && defined (LLADDR)
3724 if (getifaddrs (&ifap
) != -1)
3726 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
3727 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
3730 for (it
= ifap
; it
!= NULL
; it
= it
->ifa_next
)
3732 struct sockaddr_dl
*sdl
= (struct sockaddr_dl
*) it
->ifa_addr
;
3733 unsigned char linkaddr
[6];
3736 if (it
->ifa_addr
->sa_family
!= AF_LINK
3737 || strcmp (it
->ifa_name
, SSDATA (ifname
)) != 0
3738 || sdl
->sdl_alen
!= 6)
3741 memcpy (linkaddr
, LLADDR (sdl
), sdl
->sdl_alen
);
3742 for (n
= 0; n
< 6; n
++)
3743 p
->contents
[n
] = make_number (linkaddr
[n
]);
3745 elt
= Fcons (make_number (it
->ifa_addr
->sa_family
), hwaddr
);
3749 #ifdef HAVE_FREEIFADDRS
3753 #endif /* HAVE_GETIFADDRS && LLADDR */
3755 res
= Fcons (elt
, res
);
3758 #if defined (SIOCGIFNETMASK) && (defined (HAVE_STRUCT_IFREQ_IFR_NETMASK) || defined (HAVE_STRUCT_IFREQ_IFR_ADDR))
3759 if (ioctl (s
, SIOCGIFNETMASK
, &rq
) == 0)
3762 #ifdef HAVE_STRUCT_IFREQ_IFR_NETMASK
3763 elt
= conv_sockaddr_to_lisp (&rq
.ifr_netmask
, sizeof (rq
.ifr_netmask
));
3765 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3769 res
= Fcons (elt
, res
);
3772 #if defined (SIOCGIFBRDADDR) && defined (HAVE_STRUCT_IFREQ_IFR_BROADADDR)
3773 if (ioctl (s
, SIOCGIFBRDADDR
, &rq
) == 0)
3776 elt
= conv_sockaddr_to_lisp (&rq
.ifr_broadaddr
, sizeof (rq
.ifr_broadaddr
));
3779 res
= Fcons (elt
, res
);
3782 #if defined (SIOCGIFADDR) && defined (HAVE_STRUCT_IFREQ_IFR_ADDR)
3783 if (ioctl (s
, SIOCGIFADDR
, &rq
) == 0)
3786 elt
= conv_sockaddr_to_lisp (&rq
.ifr_addr
, sizeof (rq
.ifr_addr
));
3789 res
= Fcons (elt
, res
);
3793 return any
? res
: Qnil
;
3796 #endif /* defined (HAVE_NET_IF_H) */
3798 /* Turn off input and output for process PROC. */
3801 deactivate_process (Lisp_Object proc
)
3803 register int inchannel
, outchannel
;
3804 register struct Lisp_Process
*p
= XPROCESS (proc
);
3807 /* Delete GnuTLS structures in PROC, if any. */
3808 emacs_gnutls_deinit (proc
);
3809 #endif /* HAVE_GNUTLS */
3811 inchannel
= p
->infd
;
3812 outchannel
= p
->outfd
;
3814 #ifdef ADAPTIVE_READ_BUFFERING
3815 if (p
->read_output_delay
> 0)
3817 if (--process_output_delay_count
< 0)
3818 process_output_delay_count
= 0;
3819 p
->read_output_delay
= 0;
3820 p
->read_output_skip
= 0;
3826 /* Beware SIGCHLD hereabouts. */
3827 flush_pending_output (inchannel
);
3828 emacs_close (inchannel
);
3829 if (outchannel
>= 0 && outchannel
!= inchannel
)
3830 emacs_close (outchannel
);
3834 #ifdef DATAGRAM_SOCKETS
3835 if (DATAGRAM_CHAN_P (inchannel
))
3837 xfree (datagram_address
[inchannel
].sa
);
3838 datagram_address
[inchannel
].sa
= 0;
3839 datagram_address
[inchannel
].len
= 0;
3842 chan_process
[inchannel
] = Qnil
;
3843 FD_CLR (inchannel
, &input_wait_mask
);
3844 FD_CLR (inchannel
, &non_keyboard_wait_mask
);
3845 #ifdef NON_BLOCKING_CONNECT
3846 if (FD_ISSET (inchannel
, &connect_wait_mask
))
3848 FD_CLR (inchannel
, &connect_wait_mask
);
3849 FD_CLR (inchannel
, &write_mask
);
3850 if (--num_pending_connects
< 0)
3854 if (inchannel
== max_process_desc
)
3857 /* We just closed the highest-numbered process input descriptor,
3858 so recompute the highest-numbered one now. */
3859 max_process_desc
= 0;
3860 for (i
= 0; i
< MAXDESC
; i
++)
3861 if (!NILP (chan_process
[i
]))
3862 max_process_desc
= i
;
3868 DEFUN ("accept-process-output", Faccept_process_output
, Saccept_process_output
,
3870 doc
: /* Allow any pending output from subprocesses to be read by Emacs.
3871 It is read into the process' buffers or given to their filter functions.
3872 Non-nil arg PROCESS means do not return until some output has been received
3875 Non-nil second arg SECONDS and third arg MILLISEC are number of seconds
3876 and milliseconds to wait; return after that much time whether or not
3877 there is any subprocess output. If SECONDS is a floating point number,
3878 it specifies a fractional number of seconds to wait.
3879 The MILLISEC argument is obsolete and should be avoided.
3881 If optional fourth arg JUST-THIS-ONE is non-nil, only accept output
3882 from PROCESS, suspending reading output from other processes.
3883 If JUST-THIS-ONE is an integer, don't run any timers either.
3884 Return non-nil if we received any output before the timeout expired. */)
3885 (register Lisp_Object process
, Lisp_Object seconds
, Lisp_Object millisec
, Lisp_Object just_this_one
)
3890 if (! NILP (process
))
3891 CHECK_PROCESS (process
);
3893 just_this_one
= Qnil
;
3895 if (!NILP (millisec
))
3896 { /* Obsolete calling convention using integers rather than floats. */
3897 CHECK_NUMBER (millisec
);
3899 seconds
= make_float (XINT (millisec
) / 1000.0);
3902 CHECK_NUMBER (seconds
);
3903 seconds
= make_float (XINT (millisec
) / 1000.0 + XINT (seconds
));
3910 if (!NILP (seconds
))
3912 if (INTEGERP (seconds
))
3914 if (XINT (seconds
) > 0)
3916 secs
= XINT (seconds
);
3920 else if (FLOATP (seconds
))
3922 if (XFLOAT_DATA (seconds
) > 0)
3924 EMACS_TIME t
= EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds
));
3925 secs
= min (EMACS_SECS (t
), WAIT_READING_MAX
);
3926 nsecs
= EMACS_NSECS (t
);
3930 wrong_type_argument (Qnumberp
, seconds
);
3932 else if (! NILP (process
))
3936 (wait_reading_process_output (secs
, nsecs
, 0, 0,
3938 !NILP (process
) ? XPROCESS (process
) : NULL
,
3939 NILP (just_this_one
) ? 0 :
3940 !INTEGERP (just_this_one
) ? 1 : -1)
3944 /* Accept a connection for server process SERVER on CHANNEL. */
3946 static EMACS_INT connect_counter
= 0;
3949 server_accept_connection (Lisp_Object server
, int channel
)
3951 Lisp_Object proc
, caller
, name
, buffer
;
3952 Lisp_Object contact
, host
, service
;
3953 struct Lisp_Process
*ps
= XPROCESS (server
);
3954 struct Lisp_Process
*p
;
3958 struct sockaddr_in in
;
3960 struct sockaddr_in6 in6
;
3962 #ifdef HAVE_LOCAL_SOCKETS
3963 struct sockaddr_un un
;
3966 socklen_t len
= sizeof saddr
;
3968 s
= accept (channel
, &saddr
.sa
, &len
);
3977 if (code
== EWOULDBLOCK
)
3981 if (!NILP (ps
->log
))
3982 call3 (ps
->log
, server
, Qnil
,
3983 concat3 (build_string ("accept failed with code"),
3984 Fnumber_to_string (make_number (code
)),
3985 build_string ("\n")));
3991 /* Setup a new process to handle the connection. */
3993 /* Generate a unique identification of the caller, and build contact
3994 information for this process. */
3997 switch (saddr
.sa
.sa_family
)
4001 Lisp_Object args
[5];
4002 unsigned char *ip
= (unsigned char *)&saddr
.in
.sin_addr
.s_addr
;
4003 args
[0] = build_string ("%d.%d.%d.%d");
4004 args
[1] = make_number (*ip
++);
4005 args
[2] = make_number (*ip
++);
4006 args
[3] = make_number (*ip
++);
4007 args
[4] = make_number (*ip
++);
4008 host
= Fformat (5, args
);
4009 service
= make_number (ntohs (saddr
.in
.sin_port
));
4011 args
[0] = build_string (" <%s:%d>");
4014 caller
= Fformat (3, args
);
4021 Lisp_Object args
[9];
4022 uint16_t *ip6
= (uint16_t *)&saddr
.in6
.sin6_addr
;
4024 args
[0] = build_string ("%x:%x:%x:%x:%x:%x:%x:%x");
4025 for (i
= 0; i
< 8; i
++)
4026 args
[i
+1] = make_number (ntohs (ip6
[i
]));
4027 host
= Fformat (9, args
);
4028 service
= make_number (ntohs (saddr
.in
.sin_port
));
4030 args
[0] = build_string (" <[%s]:%d>");
4033 caller
= Fformat (3, args
);
4038 #ifdef HAVE_LOCAL_SOCKETS
4042 caller
= Fnumber_to_string (make_number (connect_counter
));
4043 caller
= concat3 (build_string (" <"), caller
, build_string (">"));
4047 /* Create a new buffer name for this process if it doesn't have a
4048 filter. The new buffer name is based on the buffer name or
4049 process name of the server process concatenated with the caller
4052 if (!(EQ (ps
->filter
, Qinternal_default_process_filter
)
4053 || EQ (ps
->filter
, Qt
)))
4057 buffer
= ps
->buffer
;
4059 buffer
= Fbuffer_name (buffer
);
4064 buffer
= concat2 (buffer
, caller
);
4065 buffer
= Fget_buffer_create (buffer
);
4069 /* Generate a unique name for the new server process. Combine the
4070 server process name with the caller identification. */
4072 name
= concat2 (ps
->name
, caller
);
4073 proc
= make_process (name
);
4075 chan_process
[s
] = proc
;
4077 fcntl (s
, F_SETFL
, O_NONBLOCK
);
4079 p
= XPROCESS (proc
);
4081 /* Build new contact information for this setup. */
4082 contact
= Fcopy_sequence (ps
->childp
);
4083 contact
= Fplist_put (contact
, QCserver
, Qnil
);
4084 contact
= Fplist_put (contact
, QChost
, host
);
4085 if (!NILP (service
))
4086 contact
= Fplist_put (contact
, QCservice
, service
);
4087 contact
= Fplist_put (contact
, QCremote
,
4088 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4089 #ifdef HAVE_GETSOCKNAME
4091 if (getsockname (s
, &saddr
.sa
, &len
) == 0)
4092 contact
= Fplist_put (contact
, QClocal
,
4093 conv_sockaddr_to_lisp (&saddr
.sa
, len
));
4096 pset_childp (p
, contact
);
4097 pset_plist (p
, Fcopy_sequence (ps
->plist
));
4098 pset_type (p
, Qnetwork
);
4100 pset_buffer (p
, buffer
);
4101 pset_sentinel (p
, ps
->sentinel
);
4102 pset_filter (p
, ps
->filter
);
4103 pset_command (p
, Qnil
);
4107 pset_status (p
, Qrun
);
4109 /* Client processes for accepted connections are not stopped initially. */
4110 if (!EQ (p
->filter
, Qt
))
4112 FD_SET (s
, &input_wait_mask
);
4113 FD_SET (s
, &non_keyboard_wait_mask
);
4116 if (s
> max_process_desc
)
4117 max_process_desc
= s
;
4119 /* Setup coding system for new process based on server process.
4120 This seems to be the proper thing to do, as the coding system
4121 of the new process should reflect the settings at the time the
4122 server socket was opened; not the current settings. */
4124 pset_decode_coding_system (p
, ps
->decode_coding_system
);
4125 pset_encode_coding_system (p
, ps
->encode_coding_system
);
4126 setup_process_coding_systems (proc
);
4128 pset_decoding_buf (p
, empty_unibyte_string
);
4129 p
->decoding_carryover
= 0;
4130 pset_encoding_buf (p
, empty_unibyte_string
);
4132 p
->inherit_coding_system_flag
4133 = (NILP (buffer
) ? 0 : ps
->inherit_coding_system_flag
);
4135 if (!NILP (ps
->log
))
4136 call3 (ps
->log
, server
, proc
,
4137 concat3 (build_string ("accept from "),
4138 (STRINGP (host
) ? host
: build_string ("-")),
4139 build_string ("\n")));
4141 exec_sentinel (proc
,
4142 concat3 (build_string ("open from "),
4143 (STRINGP (host
) ? host
: build_string ("-")),
4144 build_string ("\n")));
4147 /* This variable is different from waiting_for_input in keyboard.c.
4148 It is used to communicate to a lisp process-filter/sentinel (via the
4149 function Fwaiting_for_user_input_p below) whether Emacs was waiting
4150 for user-input when that process-filter was called.
4151 waiting_for_input cannot be used as that is by definition 0 when
4152 lisp code is being evalled.
4153 This is also used in record_asynch_buffer_change.
4154 For that purpose, this must be 0
4155 when not inside wait_reading_process_output. */
4156 static int waiting_for_user_input_p
;
4159 wait_reading_process_output_unwind (Lisp_Object data
)
4161 waiting_for_user_input_p
= XINT (data
);
4165 /* This is here so breakpoints can be put on it. */
4167 wait_reading_process_output_1 (void)
4171 /* Read and dispose of subprocess output while waiting for timeout to
4172 elapse and/or keyboard input to be available.
4176 If negative, gobble data immediately available but don't wait for any.
4179 an additional duration to wait, measured in nanoseconds
4180 If TIME_LIMIT is zero, then:
4181 If NSECS == 0, there is no limit.
4182 If NSECS > 0, the timeout consists of NSECS only.
4183 If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
4186 0 to ignore keyboard input, or
4187 1 to return when input is available, or
4188 -1 meaning caller will actually read the input, so don't throw to
4189 the quit handler, or
4191 DO_DISPLAY means redisplay should be done to show subprocess
4192 output that arrives.
4194 If WAIT_FOR_CELL is a cons cell, wait until its car is non-nil
4195 (and gobble terminal input into the buffer if any arrives).
4197 If WAIT_PROC is specified, wait until something arrives from that
4198 process. The return value is true if we read some input from
4201 If JUST_WAIT_PROC is nonzero, handle only output from WAIT_PROC
4202 (suspending output from other processes). A negative value
4203 means don't run any timers either.
4205 If WAIT_PROC is specified, then the function returns true if we
4206 received input from that process before the timeout elapsed.
4207 Otherwise, return true if we received input from any process. */
4210 wait_reading_process_output (intmax_t time_limit
, int nsecs
, int read_kbd
,
4212 Lisp_Object wait_for_cell
,
4213 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
4216 SELECT_TYPE Available
;
4217 SELECT_TYPE Writeok
;
4223 EMACS_TIME timeout
, end_time
;
4224 int wait_channel
= -1;
4225 bool got_some_input
= 0;
4226 ptrdiff_t count
= SPECPDL_INDEX ();
4228 FD_ZERO (&Available
);
4231 if (time_limit
== 0 && nsecs
== 0 && wait_proc
&& !NILP (Vinhibit_quit
)
4232 && !(CONSP (wait_proc
->status
)
4233 && EQ (XCAR (wait_proc
->status
), Qexit
)))
4234 message1 ("Blocking call to accept-process-output with quit inhibited!!");
4236 /* If wait_proc is a process to watch, set wait_channel accordingly. */
4237 if (wait_proc
!= NULL
)
4238 wait_channel
= wait_proc
->infd
;
4240 record_unwind_protect (wait_reading_process_output_unwind
,
4241 make_number (waiting_for_user_input_p
));
4242 waiting_for_user_input_p
= read_kbd
;
4249 else if (TYPE_MAXIMUM (time_t) < time_limit
)
4250 time_limit
= TYPE_MAXIMUM (time_t);
4252 /* Since we may need to wait several times,
4253 compute the absolute time to return at. */
4254 if (time_limit
|| nsecs
> 0)
4256 timeout
= make_emacs_time (time_limit
, nsecs
);
4257 end_time
= add_emacs_time (current_emacs_time (), timeout
);
4262 bool timeout_reduced_for_timers
= 0;
4264 /* If calling from keyboard input, do not quit
4265 since we want to return C-g as an input character.
4266 Otherwise, do pending quit if requested. */
4269 else if (pending_signals
)
4270 process_pending_signals ();
4272 /* Exit now if the cell we're waiting for became non-nil. */
4273 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4276 /* Compute time from now till when time limit is up. */
4277 /* Exit if already run out. */
4280 /* A negative timeout means
4281 gobble output available now
4282 but don't wait at all. */
4284 timeout
= make_emacs_time (0, 0);
4286 else if (time_limit
|| nsecs
> 0)
4288 EMACS_TIME now
= current_emacs_time ();
4289 if (EMACS_TIME_LE (end_time
, now
))
4291 timeout
= sub_emacs_time (end_time
, now
);
4295 timeout
= make_emacs_time (100000, 0);
4298 /* Normally we run timers here.
4299 But not if wait_for_cell; in those cases,
4300 the wait is supposed to be short,
4301 and those callers cannot handle running arbitrary Lisp code here. */
4302 if (NILP (wait_for_cell
)
4303 && just_wait_proc
>= 0)
4305 EMACS_TIME timer_delay
;
4309 unsigned old_timers_run
= timers_run
;
4310 struct buffer
*old_buffer
= current_buffer
;
4311 Lisp_Object old_window
= selected_window
;
4313 timer_delay
= timer_check ();
4315 /* If a timer has run, this might have changed buffers
4316 an alike. Make read_key_sequence aware of that. */
4317 if (timers_run
!= old_timers_run
4318 && (old_buffer
!= current_buffer
4319 || !EQ (old_window
, selected_window
))
4320 && waiting_for_user_input_p
== -1)
4321 record_asynch_buffer_change ();
4323 if (timers_run
!= old_timers_run
&& do_display
)
4324 /* We must retry, since a timer may have requeued itself
4325 and that could alter the time_delay. */
4326 redisplay_preserve_echo_area (9);
4330 while (!detect_input_pending ());
4332 /* If there is unread keyboard input, also return. */
4334 && requeued_events_pending_p ())
4337 /* A negative timeout means do not wait at all. */
4340 if (EMACS_TIME_VALID_P (timer_delay
))
4342 if (EMACS_TIME_LT (timer_delay
, timeout
))
4344 timeout
= timer_delay
;
4345 timeout_reduced_for_timers
= 1;
4350 /* This is so a breakpoint can be put here. */
4351 wait_reading_process_output_1 ();
4356 /* Cause C-g and alarm signals to take immediate action,
4357 and cause input available signals to zero out timeout.
4359 It is important that we do this before checking for process
4360 activity. If we get a SIGCHLD after the explicit checks for
4361 process activity, timeout is the only way we will know. */
4363 set_waiting_for_input (&timeout
);
4365 /* If status of something has changed, and no input is
4366 available, notify the user of the change right away. After
4367 this explicit check, we'll let the SIGCHLD handler zap
4368 timeout to get our attention. */
4369 if (update_tick
!= process_tick
)
4374 if (kbd_on_hold_p ())
4377 Atemp
= input_wait_mask
;
4380 timeout
= make_emacs_time (0, 0);
4381 if ((pselect (max (max_process_desc
, max_input_desc
) + 1,
4383 #ifdef NON_BLOCKING_CONNECT
4384 (num_pending_connects
> 0 ? &Ctemp
: NULL
),
4388 NULL
, &timeout
, NULL
)
4391 /* It's okay for us to do this and then continue with
4392 the loop, since timeout has already been zeroed out. */
4393 clear_waiting_for_input ();
4394 status_notify (NULL
);
4395 if (do_display
) redisplay_preserve_echo_area (13);
4399 /* Don't wait for output from a non-running process. Just
4400 read whatever data has already been received. */
4401 if (wait_proc
&& wait_proc
->raw_status_new
)
4402 update_status (wait_proc
);
4404 && ! EQ (wait_proc
->status
, Qrun
)
4405 && ! EQ (wait_proc
->status
, Qconnect
))
4407 int nread
, total_nread
= 0;
4409 clear_waiting_for_input ();
4410 XSETPROCESS (proc
, wait_proc
);
4412 /* Read data from the process, until we exhaust it. */
4413 while (wait_proc
->infd
>= 0)
4415 nread
= read_process_output (proc
, wait_proc
->infd
);
4422 total_nread
+= nread
;
4425 else if (nread
== -1 && (errno
== EIO
|| errno
== EAGAIN
))
4428 else if (nread
== -1 && EWOULDBLOCK
== errno
)
4432 if (total_nread
> 0 && do_display
)
4433 redisplay_preserve_echo_area (10);
4438 /* Wait till there is something to do */
4440 if (wait_proc
&& just_wait_proc
)
4442 if (wait_proc
->infd
< 0) /* Terminated */
4444 FD_SET (wait_proc
->infd
, &Available
);
4448 else if (!NILP (wait_for_cell
))
4450 Available
= non_process_wait_mask
;
4457 Available
= non_keyboard_wait_mask
;
4459 Available
= input_wait_mask
;
4460 Writeok
= write_mask
;
4461 #ifdef SELECT_CANT_DO_WRITE_MASK
4466 check_delay
= wait_channel
>= 0 ? 0 : process_output_delay_count
;
4469 /* If frame size has changed or the window is newly mapped,
4470 redisplay now, before we start to wait. There is a race
4471 condition here; if a SIGIO arrives between now and the select
4472 and indicates that a frame is trashed, the select may block
4473 displaying a trashed screen. */
4474 if (frame_garbaged
&& do_display
)
4476 clear_waiting_for_input ();
4477 redisplay_preserve_echo_area (11);
4479 set_waiting_for_input (&timeout
);
4482 /* Skip the `select' call if input is available and we're
4483 waiting for keyboard input or a cell change (which can be
4484 triggered by processing X events). In the latter case, set
4485 nfds to 1 to avoid breaking the loop. */
4487 if ((read_kbd
|| !NILP (wait_for_cell
))
4488 && detect_input_pending ())
4490 nfds
= read_kbd
? 0 : 1;
4497 #ifdef ADAPTIVE_READ_BUFFERING
4498 /* Set the timeout for adaptive read buffering if any
4499 process has non-zero read_output_skip and non-zero
4500 read_output_delay, and we are not reading output for a
4501 specific wait_channel. It is not executed if
4502 Vprocess_adaptive_read_buffering is nil. */
4503 if (process_output_skip
&& check_delay
> 0)
4505 int nsecs
= EMACS_NSECS (timeout
);
4506 if (EMACS_SECS (timeout
) > 0 || nsecs
> READ_OUTPUT_DELAY_MAX
)
4507 nsecs
= READ_OUTPUT_DELAY_MAX
;
4508 for (channel
= 0; check_delay
> 0 && channel
<= max_process_desc
; channel
++)
4510 proc
= chan_process
[channel
];
4513 /* Find minimum non-zero read_output_delay among the
4514 processes with non-zero read_output_skip. */
4515 if (XPROCESS (proc
)->read_output_delay
> 0)
4518 if (!XPROCESS (proc
)->read_output_skip
)
4520 FD_CLR (channel
, &Available
);
4521 XPROCESS (proc
)->read_output_skip
= 0;
4522 if (XPROCESS (proc
)->read_output_delay
< nsecs
)
4523 nsecs
= XPROCESS (proc
)->read_output_delay
;
4526 timeout
= make_emacs_time (0, nsecs
);
4527 process_output_skip
= 0;
4531 #if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
4533 #elif defined (HAVE_NS)
4538 (max (max_process_desc
, max_input_desc
) + 1,
4540 (check_write
? &Writeok
: (SELECT_TYPE
*)0),
4541 NULL
, &timeout
, NULL
);
4544 /* GnuTLS buffers data internally. In lowat mode it leaves
4545 some data in the TCP buffers so that select works, but
4546 with custom pull/push functions we need to check if some
4547 data is available in the buffers manually. */
4552 /* We're not waiting on a specific process, so loop
4553 through all the channels and check for data.
4554 This is a workaround needed for some versions of
4555 the gnutls library -- 2.12.14 has been confirmed
4557 http://comments.gmane.org/gmane.emacs.devel/145074 */
4558 for (channel
= 0; channel
< MAXDESC
; ++channel
)
4559 if (! NILP (chan_process
[channel
]))
4561 struct Lisp_Process
*p
=
4562 XPROCESS (chan_process
[channel
]);
4563 if (p
&& p
->gnutls_p
&& p
->infd
4564 && ((emacs_gnutls_record_check_pending
4569 FD_SET (p
->infd
, &Available
);
4575 /* Check this specific channel. */
4576 if (wait_proc
->gnutls_p
/* Check for valid process. */
4577 /* Do we have pending data? */
4578 && ((emacs_gnutls_record_check_pending
4579 (wait_proc
->gnutls_state
))
4583 /* Set to Available. */
4584 FD_SET (wait_proc
->infd
, &Available
);
4593 /* Make C-g and alarm signals set flags again */
4594 clear_waiting_for_input ();
4596 /* If we woke up due to SIGWINCH, actually change size now. */
4597 do_pending_window_change (0);
4599 if ((time_limit
|| nsecs
) && nfds
== 0 && ! timeout_reduced_for_timers
)
4600 /* We waited the full specified time, so return now. */
4604 if (xerrno
== EINTR
)
4606 else if (xerrno
== EBADF
)
4609 /* AIX doesn't handle PTY closure the same way BSD does. On AIX,
4610 the child's closure of the pts gives the parent a SIGHUP, and
4611 the ptc file descriptor is automatically closed,
4612 yielding EBADF here or at select() call above.
4613 So, SIGHUP is ignored (see def of PTY_TTY_NAME_SPRINTF
4614 in m/ibmrt-aix.h), and here we just ignore the select error.
4615 Cleanup occurs c/o status_notify after SIGCHLD. */
4616 no_avail
= 1; /* Cannot depend on values returned */
4622 error ("select error: %s", emacs_strerror (xerrno
));
4627 FD_ZERO (&Available
);
4631 /* Check for keyboard input */
4632 /* If there is any, return immediately
4633 to give it higher priority than subprocesses */
4637 unsigned old_timers_run
= timers_run
;
4638 struct buffer
*old_buffer
= current_buffer
;
4639 Lisp_Object old_window
= selected_window
;
4642 if (detect_input_pending_run_timers (do_display
))
4644 swallow_events (do_display
);
4645 if (detect_input_pending_run_timers (do_display
))
4649 /* If a timer has run, this might have changed buffers
4650 an alike. Make read_key_sequence aware of that. */
4651 if (timers_run
!= old_timers_run
4652 && waiting_for_user_input_p
== -1
4653 && (old_buffer
!= current_buffer
4654 || !EQ (old_window
, selected_window
)))
4655 record_asynch_buffer_change ();
4661 /* If there is unread keyboard input, also return. */
4663 && requeued_events_pending_p ())
4666 /* If we are not checking for keyboard input now,
4667 do process events (but don't run any timers).
4668 This is so that X events will be processed.
4669 Otherwise they may have to wait until polling takes place.
4670 That would causes delays in pasting selections, for example.
4672 (We used to do this only if wait_for_cell.) */
4673 if (read_kbd
== 0 && detect_input_pending ())
4675 swallow_events (do_display
);
4676 #if 0 /* Exiting when read_kbd doesn't request that seems wrong, though. */
4677 if (detect_input_pending ())
4682 /* Exit now if the cell we're waiting for became non-nil. */
4683 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
4687 /* If we think we have keyboard input waiting, but didn't get SIGIO,
4688 go read it. This can happen with X on BSD after logging out.
4689 In that case, there really is no input and no SIGIO,
4690 but select says there is input. */
4692 if (read_kbd
&& interrupt_input
4693 && keyboard_bit_set (&Available
) && ! noninteractive
)
4694 handle_input_available_signal (SIGIO
);
4698 got_some_input
|= nfds
> 0;
4700 /* If checking input just got us a size-change event from X,
4701 obey it now if we should. */
4702 if (read_kbd
|| ! NILP (wait_for_cell
))
4703 do_pending_window_change (0);
4705 /* Check for data from a process. */
4706 if (no_avail
|| nfds
== 0)
4709 for (channel
= 0; channel
<= max_input_desc
; ++channel
)
4711 struct fd_callback_data
*d
= &fd_callback_info
[channel
];
4713 && ((d
->condition
& FOR_READ
4714 && FD_ISSET (channel
, &Available
))
4715 || (d
->condition
& FOR_WRITE
4716 && FD_ISSET (channel
, &write_mask
))))
4717 d
->func (channel
, d
->data
);
4720 for (channel
= 0; channel
<= max_process_desc
; channel
++)
4722 if (FD_ISSET (channel
, &Available
)
4723 && FD_ISSET (channel
, &non_keyboard_wait_mask
)
4724 && !FD_ISSET (channel
, &non_process_wait_mask
))
4728 /* If waiting for this channel, arrange to return as
4729 soon as no more input to be processed. No more
4731 if (wait_channel
== channel
)
4737 proc
= chan_process
[channel
];
4741 /* If this is a server stream socket, accept connection. */
4742 if (EQ (XPROCESS (proc
)->status
, Qlisten
))
4744 server_accept_connection (proc
, channel
);
4748 /* Read data from the process, starting with our
4749 buffered-ahead character if we have one. */
4751 nread
= read_process_output (proc
, channel
);
4754 /* Since read_process_output can run a filter,
4755 which can call accept-process-output,
4756 don't try to read from any other processes
4757 before doing the select again. */
4758 FD_ZERO (&Available
);
4761 redisplay_preserve_echo_area (12);
4764 else if (nread
== -1 && errno
== EWOULDBLOCK
)
4767 else if (nread
== -1 && errno
== EAGAIN
)
4770 /* FIXME: Is this special case still needed? */
4771 /* Note that we cannot distinguish between no input
4772 available now and a closed pipe.
4773 With luck, a closed pipe will be accompanied by
4774 subprocess termination and SIGCHLD. */
4775 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4779 /* On some OSs with ptys, when the process on one end of
4780 a pty exits, the other end gets an error reading with
4781 errno = EIO instead of getting an EOF (0 bytes read).
4782 Therefore, if we get an error reading and errno =
4783 EIO, just continue, because the child process has
4784 exited and should clean itself up soon (e.g. when we
4786 else if (nread
== -1 && errno
== EIO
)
4788 struct Lisp_Process
*p
= XPROCESS (proc
);
4790 /* Clear the descriptor now, so we only raise the
4792 FD_CLR (channel
, &input_wait_mask
);
4793 FD_CLR (channel
, &non_keyboard_wait_mask
);
4797 /* If the EIO occurs on a pty, the SIGCHLD handler's
4798 waitpid call will not find the process object to
4799 delete. Do it here. */
4800 p
->tick
= ++process_tick
;
4801 pset_status (p
, Qfailed
);
4804 #endif /* HAVE_PTYS */
4805 /* If we can detect process termination, don't consider the
4806 process gone just because its pipe is closed. */
4807 else if (nread
== 0 && !NETCONN_P (proc
) && !SERIALCONN_P (proc
))
4811 /* Preserve status of processes already terminated. */
4812 XPROCESS (proc
)->tick
= ++process_tick
;
4813 deactivate_process (proc
);
4814 if (XPROCESS (proc
)->raw_status_new
)
4815 update_status (XPROCESS (proc
));
4816 if (EQ (XPROCESS (proc
)->status
, Qrun
))
4817 pset_status (XPROCESS (proc
),
4818 list2 (Qexit
, make_number (256)));
4821 #ifdef NON_BLOCKING_CONNECT
4822 if (FD_ISSET (channel
, &Writeok
)
4823 && FD_ISSET (channel
, &connect_wait_mask
))
4825 struct Lisp_Process
*p
;
4827 FD_CLR (channel
, &connect_wait_mask
);
4828 FD_CLR (channel
, &write_mask
);
4829 if (--num_pending_connects
< 0)
4832 proc
= chan_process
[channel
];
4836 p
= XPROCESS (proc
);
4839 /* getsockopt(,,SO_ERROR,,) is said to hang on some systems.
4840 So only use it on systems where it is known to work. */
4842 socklen_t xlen
= sizeof (xerrno
);
4843 if (getsockopt (channel
, SOL_SOCKET
, SO_ERROR
, &xerrno
, &xlen
))
4848 struct sockaddr pname
;
4849 int pnamelen
= sizeof (pname
);
4851 /* If connection failed, getpeername will fail. */
4853 if (getpeername (channel
, &pname
, &pnamelen
) < 0)
4855 /* Obtain connect failure code through error slippage. */
4858 if (errno
== ENOTCONN
&& read (channel
, &dummy
, 1) < 0)
4865 p
->tick
= ++process_tick
;
4866 pset_status (p
, list2 (Qfailed
, make_number (xerrno
)));
4867 deactivate_process (proc
);
4871 pset_status (p
, Qrun
);
4872 /* Execute the sentinel here. If we had relied on
4873 status_notify to do it later, it will read input
4874 from the process before calling the sentinel. */
4875 exec_sentinel (proc
, build_string ("open\n"));
4876 if (!EQ (p
->filter
, Qt
) && !EQ (p
->command
, Qt
))
4878 FD_SET (p
->infd
, &input_wait_mask
);
4879 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
4883 #endif /* NON_BLOCKING_CONNECT */
4884 } /* End for each file descriptor. */
4885 } /* End while exit conditions not met. */
4887 unbind_to (count
, Qnil
);
4889 /* If calling from keyboard input, do not quit
4890 since we want to return C-g as an input character.
4891 Otherwise, do pending quit if requested. */
4894 /* Prevent input_pending from remaining set if we quit. */
4895 clear_input_pending ();
4899 return got_some_input
;
4902 /* Given a list (FUNCTION ARGS...), apply FUNCTION to the ARGS. */
4905 read_process_output_call (Lisp_Object fun_and_args
)
4907 return apply1 (XCAR (fun_and_args
), XCDR (fun_and_args
));
4911 read_process_output_error_handler (Lisp_Object error_val
)
4913 cmd_error_internal (error_val
, "error in process filter: ");
4915 update_echo_area ();
4916 Fsleep_for (make_number (2), Qnil
);
4921 read_and_dispose_of_process_output (struct Lisp_Process
*p
, char *chars
,
4923 struct coding_system
*coding
);
4925 /* Read pending output from the process channel,
4926 starting with our buffered-ahead character if we have one.
4927 Yield number of decoded characters read.
4929 This function reads at most 4096 characters.
4930 If you want to read all available subprocess output,
4931 you must call it repeatedly until it returns zero.
4933 The characters read are decoded according to PROC's coding-system
4937 read_process_output (Lisp_Object proc
, register int channel
)
4939 register ssize_t nbytes
;
4941 register struct Lisp_Process
*p
= XPROCESS (proc
);
4942 struct coding_system
*coding
= proc_decode_coding_system
[channel
];
4943 int carryover
= p
->decoding_carryover
;
4945 ptrdiff_t count
= SPECPDL_INDEX ();
4946 Lisp_Object odeactivate
;
4948 chars
= alloca (carryover
+ readmax
);
4950 /* See the comment above. */
4951 memcpy (chars
, SDATA (p
->decoding_buf
), carryover
);
4953 #ifdef DATAGRAM_SOCKETS
4954 /* We have a working select, so proc_buffered_char is always -1. */
4955 if (DATAGRAM_CHAN_P (channel
))
4957 socklen_t len
= datagram_address
[channel
].len
;
4958 nbytes
= recvfrom (channel
, chars
+ carryover
, readmax
,
4959 0, datagram_address
[channel
].sa
, &len
);
4964 bool buffered
= proc_buffered_char
[channel
] >= 0;
4967 chars
[carryover
] = proc_buffered_char
[channel
];
4968 proc_buffered_char
[channel
] = -1;
4972 nbytes
= emacs_gnutls_read (p
, chars
+ carryover
+ buffered
,
4973 readmax
- buffered
);
4976 nbytes
= emacs_read (channel
, chars
+ carryover
+ buffered
,
4977 readmax
- buffered
);
4978 #ifdef ADAPTIVE_READ_BUFFERING
4979 if (nbytes
> 0 && p
->adaptive_read_buffering
)
4981 int delay
= p
->read_output_delay
;
4984 if (delay
< READ_OUTPUT_DELAY_MAX_MAX
)
4987 process_output_delay_count
++;
4988 delay
+= READ_OUTPUT_DELAY_INCREMENT
* 2;
4991 else if (delay
> 0 && nbytes
== readmax
- buffered
)
4993 delay
-= READ_OUTPUT_DELAY_INCREMENT
;
4995 process_output_delay_count
--;
4997 p
->read_output_delay
= delay
;
5000 p
->read_output_skip
= 1;
5001 process_output_skip
= 1;
5006 nbytes
+= buffered
&& nbytes
<= 0;
5009 p
->decoding_carryover
= 0;
5011 /* At this point, NBYTES holds number of bytes just received
5012 (including the one in proc_buffered_char[channel]). */
5015 if (nbytes
< 0 || coding
->mode
& CODING_MODE_LAST_BLOCK
)
5017 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5020 /* Now set NBYTES how many bytes we must decode. */
5021 nbytes
+= carryover
;
5023 odeactivate
= Vdeactivate_mark
;
5024 /* There's no good reason to let process filters change the current
5025 buffer, and many callers of accept-process-output, sit-for, and
5026 friends don't expect current-buffer to be changed from under them. */
5027 record_unwind_current_buffer ();
5029 read_and_dispose_of_process_output (p
, chars
, nbytes
, coding
);
5031 /* Handling the process output should not deactivate the mark. */
5032 Vdeactivate_mark
= odeactivate
;
5034 unbind_to (count
, Qnil
);
5039 read_and_dispose_of_process_output (struct Lisp_Process
*p
, char *chars
,
5041 struct coding_system
*coding
)
5043 Lisp_Object outstream
= p
->filter
;
5045 bool outer_running_asynch_code
= running_asynch_code
;
5046 int waiting
= waiting_for_user_input_p
;
5048 /* No need to gcpro these, because all we do with them later
5049 is test them for EQness, and none of them should be a string. */
5051 Lisp_Object obuffer
, okeymap
;
5052 XSETBUFFER (obuffer
, current_buffer
);
5053 okeymap
= BVAR (current_buffer
, keymap
);
5056 /* We inhibit quit here instead of just catching it so that
5057 hitting ^G when a filter happens to be running won't screw
5059 specbind (Qinhibit_quit
, Qt
);
5060 specbind (Qlast_nonmenu_event
, Qt
);
5062 /* In case we get recursively called,
5063 and we already saved the match data nonrecursively,
5064 save the same match data in safely recursive fashion. */
5065 if (outer_running_asynch_code
)
5068 /* Don't clobber the CURRENT match data, either! */
5069 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
5070 restore_search_regs ();
5071 record_unwind_save_match_data ();
5072 Fset_match_data (tem
, Qt
);
5075 /* For speed, if a search happens within this code,
5076 save the match data in a special nonrecursive fashion. */
5077 running_asynch_code
= 1;
5079 decode_coding_c_string (coding
, (unsigned char *) chars
, nbytes
, Qt
);
5080 text
= coding
->dst_object
;
5081 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5082 /* A new coding system might be found. */
5083 if (!EQ (p
->decode_coding_system
, Vlast_coding_system_used
))
5085 pset_decode_coding_system (p
, Vlast_coding_system_used
);
5087 /* Don't call setup_coding_system for
5088 proc_decode_coding_system[channel] here. It is done in
5089 detect_coding called via decode_coding above. */
5091 /* If a coding system for encoding is not yet decided, we set
5092 it as the same as coding-system for decoding.
5094 But, before doing that we must check if
5095 proc_encode_coding_system[p->outfd] surely points to a
5096 valid memory because p->outfd will be changed once EOF is
5097 sent to the process. */
5098 if (NILP (p
->encode_coding_system
)
5099 && proc_encode_coding_system
[p
->outfd
])
5101 pset_encode_coding_system
5102 (p
, coding_inherit_eol_type (Vlast_coding_system_used
, Qnil
));
5103 setup_coding_system (p
->encode_coding_system
,
5104 proc_encode_coding_system
[p
->outfd
]);
5108 if (coding
->carryover_bytes
> 0)
5110 if (SCHARS (p
->decoding_buf
) < coding
->carryover_bytes
)
5111 pset_decoding_buf (p
, make_uninit_string (coding
->carryover_bytes
));
5112 memcpy (SDATA (p
->decoding_buf
), coding
->carryover
,
5113 coding
->carryover_bytes
);
5114 p
->decoding_carryover
= coding
->carryover_bytes
;
5116 if (SBYTES (text
) > 0)
5117 /* FIXME: It's wrong to wrap or not based on debug-on-error, and
5118 sometimes it's simply wrong to wrap (e.g. when called from
5119 accept-process-output). */
5120 internal_condition_case_1 (read_process_output_call
,
5122 Fcons (make_lisp_proc (p
),
5123 Fcons (text
, Qnil
))),
5124 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
5125 read_process_output_error_handler
);
5127 /* If we saved the match data nonrecursively, restore it now. */
5128 restore_search_regs ();
5129 running_asynch_code
= outer_running_asynch_code
;
5131 /* Restore waiting_for_user_input_p as it was
5132 when we were called, in case the filter clobbered it. */
5133 waiting_for_user_input_p
= waiting
;
5135 #if 0 /* Call record_asynch_buffer_change unconditionally,
5136 because we might have changed minor modes or other things
5137 that affect key bindings. */
5138 if (! EQ (Fcurrent_buffer (), obuffer
)
5139 || ! EQ (current_buffer
->keymap
, okeymap
))
5141 /* But do it only if the caller is actually going to read events.
5142 Otherwise there's no need to make him wake up, and it could
5143 cause trouble (for example it would make sit_for return). */
5144 if (waiting_for_user_input_p
== -1)
5145 record_asynch_buffer_change ();
5148 DEFUN ("internal-default-process-filter", Finternal_default_process_filter
,
5149 Sinternal_default_process_filter
, 2, 2, 0,
5150 doc
: /* Function used as default process filter. */)
5151 (Lisp_Object proc
, Lisp_Object text
)
5153 struct Lisp_Process
*p
;
5156 CHECK_PROCESS (proc
);
5157 p
= XPROCESS (proc
);
5158 CHECK_STRING (text
);
5160 if (!NILP (p
->buffer
) && BUFFER_LIVE_P (XBUFFER (p
->buffer
)))
5162 Lisp_Object old_read_only
;
5163 ptrdiff_t old_begv
, old_zv
;
5164 ptrdiff_t old_begv_byte
, old_zv_byte
;
5165 ptrdiff_t before
, before_byte
;
5166 ptrdiff_t opoint_byte
;
5169 Fset_buffer (p
->buffer
);
5171 opoint_byte
= PT_BYTE
;
5172 old_read_only
= BVAR (current_buffer
, read_only
);
5175 old_begv_byte
= BEGV_BYTE
;
5176 old_zv_byte
= ZV_BYTE
;
5178 bset_read_only (current_buffer
, Qnil
);
5180 /* Insert new output into buffer
5181 at the current end-of-output marker,
5182 thus preserving logical ordering of input and output. */
5183 if (XMARKER (p
->mark
)->buffer
)
5184 SET_PT_BOTH (clip_to_bounds (BEGV
,
5185 marker_position (p
->mark
), ZV
),
5186 clip_to_bounds (BEGV_BYTE
,
5187 marker_byte_position (p
->mark
),
5190 SET_PT_BOTH (ZV
, ZV_BYTE
);
5192 before_byte
= PT_BYTE
;
5194 /* If the output marker is outside of the visible region, save
5195 the restriction and widen. */
5196 if (! (BEGV
<= PT
&& PT
<= ZV
))
5199 /* Adjust the multibyteness of TEXT to that of the buffer. */
5200 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
))
5201 != ! STRING_MULTIBYTE (text
))
5202 text
= (STRING_MULTIBYTE (text
)
5203 ? Fstring_as_unibyte (text
)
5204 : Fstring_to_multibyte (text
));
5205 /* Insert before markers in case we are inserting where
5206 the buffer's mark is, and the user's next command is Meta-y. */
5207 insert_from_string_before_markers (text
, 0, 0,
5208 SCHARS (text
), SBYTES (text
), 0);
5210 /* Make sure the process marker's position is valid when the
5211 process buffer is changed in the signal_after_change above.
5212 W3 is known to do that. */
5213 if (BUFFERP (p
->buffer
)
5214 && (b
= XBUFFER (p
->buffer
), b
!= current_buffer
))
5215 set_marker_both (p
->mark
, p
->buffer
, BUF_PT (b
), BUF_PT_BYTE (b
));
5217 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
5219 update_mode_lines
++;
5221 /* Make sure opoint and the old restrictions
5222 float ahead of any new text just as point would. */
5223 if (opoint
>= before
)
5225 opoint
+= PT
- before
;
5226 opoint_byte
+= PT_BYTE
- before_byte
;
5228 if (old_begv
> before
)
5230 old_begv
+= PT
- before
;
5231 old_begv_byte
+= PT_BYTE
- before_byte
;
5233 if (old_zv
>= before
)
5235 old_zv
+= PT
- before
;
5236 old_zv_byte
+= PT_BYTE
- before_byte
;
5239 /* If the restriction isn't what it should be, set it. */
5240 if (old_begv
!= BEGV
|| old_zv
!= ZV
)
5241 Fnarrow_to_region (make_number (old_begv
), make_number (old_zv
));
5243 bset_read_only (current_buffer
, old_read_only
);
5244 SET_PT_BOTH (opoint
, opoint_byte
);
5249 /* Sending data to subprocess. */
5251 /* In send_process, when a write fails temporarily,
5252 wait_reading_process_output is called. It may execute user code,
5253 e.g. timers, that attempts to write new data to the same process.
5254 We must ensure that data is sent in the right order, and not
5255 interspersed half-completed with other writes (Bug#10815). This is
5256 handled by the write_queue element of struct process. It is a list
5257 with each entry having the form
5259 (string . (offset . length))
5261 where STRING is a lisp string, OFFSET is the offset into the
5262 string's byte sequence from which we should begin to send, and
5263 LENGTH is the number of bytes left to send. */
5265 /* Create a new entry in write_queue.
5266 INPUT_OBJ should be a buffer, string Qt, or Qnil.
5267 BUF is a pointer to the string sequence of the input_obj or a C
5268 string in case of Qt or Qnil. */
5271 write_queue_push (struct Lisp_Process
*p
, Lisp_Object input_obj
,
5272 const char *buf
, ptrdiff_t len
, bool front
)
5275 Lisp_Object entry
, obj
;
5277 if (STRINGP (input_obj
))
5279 offset
= buf
- SSDATA (input_obj
);
5285 obj
= make_unibyte_string (buf
, len
);
5288 entry
= Fcons (obj
, Fcons (make_number (offset
), make_number (len
)));
5291 pset_write_queue (p
, Fcons (entry
, p
->write_queue
));
5293 pset_write_queue (p
, nconc2 (p
->write_queue
, Fcons (entry
, Qnil
)));
5296 /* Remove the first element in the write_queue of process P, put its
5297 contents in OBJ, BUF and LEN, and return true. If the
5298 write_queue is empty, return false. */
5301 write_queue_pop (struct Lisp_Process
*p
, Lisp_Object
*obj
,
5302 const char **buf
, ptrdiff_t *len
)
5304 Lisp_Object entry
, offset_length
;
5307 if (NILP (p
->write_queue
))
5310 entry
= XCAR (p
->write_queue
);
5311 pset_write_queue (p
, XCDR (p
->write_queue
));
5313 *obj
= XCAR (entry
);
5314 offset_length
= XCDR (entry
);
5316 *len
= XINT (XCDR (offset_length
));
5317 offset
= XINT (XCAR (offset_length
));
5318 *buf
= SSDATA (*obj
) + offset
;
5323 /* Send some data to process PROC.
5324 BUF is the beginning of the data; LEN is the number of characters.
5325 OBJECT is the Lisp object that the data comes from. If OBJECT is
5326 nil or t, it means that the data comes from C string.
5328 If OBJECT is not nil, the data is encoded by PROC's coding-system
5329 for encoding before it is sent.
5331 This function can evaluate Lisp code and can garbage collect. */
5334 send_process (Lisp_Object proc
, const char *buf
, ptrdiff_t len
,
5337 struct Lisp_Process
*p
= XPROCESS (proc
);
5339 struct coding_system
*coding
;
5341 if (p
->raw_status_new
)
5343 if (! EQ (p
->status
, Qrun
))
5344 error ("Process %s not running", SDATA (p
->name
));
5346 error ("Output file descriptor of %s is closed", SDATA (p
->name
));
5348 coding
= proc_encode_coding_system
[p
->outfd
];
5349 Vlast_coding_system_used
= CODING_ID_NAME (coding
->id
);
5351 if ((STRINGP (object
) && STRING_MULTIBYTE (object
))
5352 || (BUFFERP (object
)
5353 && !NILP (BVAR (XBUFFER (object
), enable_multibyte_characters
)))
5356 pset_encode_coding_system
5357 (p
, complement_process_encoding_system (p
->encode_coding_system
));
5358 if (!EQ (Vlast_coding_system_used
, p
->encode_coding_system
))
5360 /* The coding system for encoding was changed to raw-text
5361 because we sent a unibyte text previously. Now we are
5362 sending a multibyte text, thus we must encode it by the
5363 original coding system specified for the current process.
5365 Another reason we come here is that the coding system
5366 was just complemented and a new one was returned by
5367 complement_process_encoding_system. */
5368 setup_coding_system (p
->encode_coding_system
, coding
);
5369 Vlast_coding_system_used
= p
->encode_coding_system
;
5371 coding
->src_multibyte
= 1;
5375 coding
->src_multibyte
= 0;
5376 /* For sending a unibyte text, character code conversion should
5377 not take place but EOL conversion should. So, setup raw-text
5378 or one of the subsidiary if we have not yet done it. */
5379 if (CODING_REQUIRE_ENCODING (coding
))
5381 if (CODING_REQUIRE_FLUSHING (coding
))
5383 /* But, before changing the coding, we must flush out data. */
5384 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
5385 send_process (proc
, "", 0, Qt
);
5386 coding
->mode
&= CODING_MODE_LAST_BLOCK
;
5388 setup_coding_system (raw_text_coding_system
5389 (Vlast_coding_system_used
),
5391 coding
->src_multibyte
= 0;
5394 coding
->dst_multibyte
= 0;
5396 if (CODING_REQUIRE_ENCODING (coding
))
5398 coding
->dst_object
= Qt
;
5399 if (BUFFERP (object
))
5401 ptrdiff_t from_byte
, from
, to
;
5402 ptrdiff_t save_pt
, save_pt_byte
;
5403 struct buffer
*cur
= current_buffer
;
5405 set_buffer_internal (XBUFFER (object
));
5406 save_pt
= PT
, save_pt_byte
= PT_BYTE
;
5408 from_byte
= PTR_BYTE_POS ((unsigned char *) buf
);
5409 from
= BYTE_TO_CHAR (from_byte
);
5410 to
= BYTE_TO_CHAR (from_byte
+ len
);
5411 TEMP_SET_PT_BOTH (from
, from_byte
);
5412 encode_coding_object (coding
, object
, from
, from_byte
,
5413 to
, from_byte
+ len
, Qt
);
5414 TEMP_SET_PT_BOTH (save_pt
, save_pt_byte
);
5415 set_buffer_internal (cur
);
5417 else if (STRINGP (object
))
5419 encode_coding_object (coding
, object
, 0, 0, SCHARS (object
),
5420 SBYTES (object
), Qt
);
5424 coding
->dst_object
= make_unibyte_string (buf
, len
);
5425 coding
->produced
= len
;
5428 len
= coding
->produced
;
5429 object
= coding
->dst_object
;
5430 buf
= SSDATA (object
);
5433 /* If there is already data in the write_queue, put the new data
5434 in the back of queue. Otherwise, ignore it. */
5435 if (!NILP (p
->write_queue
))
5436 write_queue_push (p
, object
, buf
, len
, 0);
5438 do /* while !NILP (p->write_queue) */
5440 ptrdiff_t cur_len
= -1;
5441 const char *cur_buf
;
5442 Lisp_Object cur_object
;
5444 /* If write_queue is empty, ignore it. */
5445 if (!write_queue_pop (p
, &cur_object
, &cur_buf
, &cur_len
))
5449 cur_object
= object
;
5454 /* Send this batch, using one or more write calls. */
5455 ptrdiff_t written
= 0;
5456 int outfd
= p
->outfd
;
5457 #ifdef DATAGRAM_SOCKETS
5458 if (DATAGRAM_CHAN_P (outfd
))
5460 rv
= sendto (outfd
, cur_buf
, cur_len
,
5461 0, datagram_address
[outfd
].sa
,
5462 datagram_address
[outfd
].len
);
5465 else if (errno
== EMSGSIZE
)
5466 report_file_error ("sending datagram", Fcons (proc
, Qnil
));
5473 written
= emacs_gnutls_write (p
, cur_buf
, cur_len
);
5476 written
= emacs_write (outfd
, cur_buf
, cur_len
);
5477 rv
= (written
? 0 : -1);
5478 #ifdef ADAPTIVE_READ_BUFFERING
5479 if (p
->read_output_delay
> 0
5480 && p
->adaptive_read_buffering
== 1)
5482 p
->read_output_delay
= 0;
5483 process_output_delay_count
--;
5484 p
->read_output_skip
= 0;
5493 || errno
== EWOULDBLOCK
5496 /* Buffer is full. Wait, accepting input;
5497 that may allow the program
5498 to finish doing output and read more. */
5500 #ifdef BROKEN_PTY_READ_AFTER_EAGAIN
5501 /* A gross hack to work around a bug in FreeBSD.
5502 In the following sequence, read(2) returns
5506 write(2) 954 bytes, get EAGAIN
5507 read(2) 1024 bytes in process_read_output
5508 read(2) 11 bytes in process_read_output
5510 That is, read(2) returns more bytes than have
5511 ever been written successfully. The 1033 bytes
5512 read are the 1022 bytes written successfully
5513 after processing (for example with CRs added if
5514 the terminal is set up that way which it is
5515 here). The same bytes will be seen again in a
5516 later read(2), without the CRs. */
5518 if (errno
== EAGAIN
)
5521 ioctl (p
->outfd
, TIOCFLUSH
, &flags
);
5523 #endif /* BROKEN_PTY_READ_AFTER_EAGAIN */
5525 /* Put what we should have written in wait_queue. */
5526 write_queue_push (p
, cur_object
, cur_buf
, cur_len
, 1);
5527 wait_reading_process_output (0, 20 * 1000 * 1000,
5528 0, 0, Qnil
, NULL
, 0);
5529 /* Reread queue, to see what is left. */
5532 else if (errno
== EPIPE
)
5534 p
->raw_status_new
= 0;
5535 pset_status (p
, list2 (Qexit
, make_number (256)));
5536 p
->tick
= ++process_tick
;
5537 deactivate_process (proc
);
5538 error ("process %s no longer connected to pipe; closed it",
5542 /* This is a real error. */
5543 report_file_error ("writing to process", Fcons (proc
, Qnil
));
5549 while (!NILP (p
->write_queue
));
5552 DEFUN ("process-send-region", Fprocess_send_region
, Sprocess_send_region
,
5554 doc
: /* Send current contents of region as input to PROCESS.
5555 PROCESS may be a process, a buffer, the name of a process or buffer, or
5556 nil, indicating the current buffer's process.
5557 Called from program, takes three arguments, PROCESS, START and END.
5558 If the region is more than 500 characters long,
5559 it is sent in several bunches. This may happen even for shorter regions.
5560 Output from processes can arrive in between bunches. */)
5561 (Lisp_Object process
, Lisp_Object start
, Lisp_Object end
)
5563 Lisp_Object proc
= get_process (process
);
5564 ptrdiff_t start_byte
, end_byte
;
5566 validate_region (&start
, &end
);
5568 start_byte
= CHAR_TO_BYTE (XINT (start
));
5569 end_byte
= CHAR_TO_BYTE (XINT (end
));
5571 if (XINT (start
) < GPT
&& XINT (end
) > GPT
)
5572 move_gap_both (XINT (start
), start_byte
);
5574 send_process (proc
, (char *) BYTE_POS_ADDR (start_byte
),
5575 end_byte
- start_byte
, Fcurrent_buffer ());
5580 DEFUN ("process-send-string", Fprocess_send_string
, Sprocess_send_string
,
5582 doc
: /* Send PROCESS the contents of STRING as input.
5583 PROCESS may be a process, a buffer, the name of a process or buffer, or
5584 nil, indicating the current buffer's process.
5585 If STRING is more than 500 characters long,
5586 it is sent in several bunches. This may happen even for shorter strings.
5587 Output from processes can arrive in between bunches. */)
5588 (Lisp_Object process
, Lisp_Object string
)
5591 CHECK_STRING (string
);
5592 proc
= get_process (process
);
5593 send_process (proc
, SSDATA (string
),
5594 SBYTES (string
), string
);
5598 /* Return the foreground process group for the tty/pty that
5599 the process P uses. */
5601 emacs_get_tty_pgrp (struct Lisp_Process
*p
)
5606 if (ioctl (p
->infd
, TIOCGPGRP
, &gid
) == -1 && ! NILP (p
->tty_name
))
5609 /* Some OS:es (Solaris 8/9) does not allow TIOCGPGRP from the
5610 master side. Try the slave side. */
5611 fd
= emacs_open (SSDATA (p
->tty_name
), O_RDONLY
, 0);
5615 ioctl (fd
, TIOCGPGRP
, &gid
);
5619 #endif /* defined (TIOCGPGRP ) */
5624 DEFUN ("process-running-child-p", Fprocess_running_child_p
,
5625 Sprocess_running_child_p
, 0, 1, 0,
5626 doc
: /* Return t if PROCESS has given the terminal to a child.
5627 If the operating system does not make it possible to find out,
5628 return t unconditionally. */)
5629 (Lisp_Object process
)
5631 /* Initialize in case ioctl doesn't exist or gives an error,
5632 in a way that will cause returning t. */
5635 struct Lisp_Process
*p
;
5637 proc
= get_process (process
);
5638 p
= XPROCESS (proc
);
5640 if (!EQ (p
->type
, Qreal
))
5641 error ("Process %s is not a subprocess",
5644 error ("Process %s is not active",
5647 gid
= emacs_get_tty_pgrp (p
);
5654 /* send a signal number SIGNO to PROCESS.
5655 If CURRENT_GROUP is t, that means send to the process group
5656 that currently owns the terminal being used to communicate with PROCESS.
5657 This is used for various commands in shell mode.
5658 If CURRENT_GROUP is lambda, that means send to the process group
5659 that currently owns the terminal, but only if it is NOT the shell itself.
5661 If NOMSG is false, insert signal-announcements into process's buffers
5664 If we can, we try to signal PROCESS by sending control characters
5665 down the pty. This allows us to signal inferiors who have changed
5666 their uid, for which kill would return an EPERM error. */
5669 process_send_signal (Lisp_Object process
, int signo
, Lisp_Object current_group
,
5673 struct Lisp_Process
*p
;
5677 proc
= get_process (process
);
5678 p
= XPROCESS (proc
);
5680 if (!EQ (p
->type
, Qreal
))
5681 error ("Process %s is not a subprocess",
5684 error ("Process %s is not active",
5688 current_group
= Qnil
;
5690 /* If we are using pgrps, get a pgrp number and make it negative. */
5691 if (NILP (current_group
))
5692 /* Send the signal to the shell's process group. */
5696 #ifdef SIGNALS_VIA_CHARACTERS
5697 /* If possible, send signals to the entire pgrp
5698 by sending an input character to it. */
5701 cc_t
*sig_char
= NULL
;
5703 tcgetattr (p
->infd
, &t
);
5708 sig_char
= &t
.c_cc
[VINTR
];
5712 sig_char
= &t
.c_cc
[VQUIT
];
5716 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
5717 sig_char
= &t
.c_cc
[VSWTCH
];
5719 sig_char
= &t
.c_cc
[VSUSP
];
5724 if (sig_char
&& *sig_char
!= CDISABLE
)
5726 send_process (proc
, (char *) sig_char
, 1, Qnil
);
5729 /* If we can't send the signal with a character,
5730 fall through and send it another way. */
5732 /* The code above may fall through if it can't
5733 handle the signal. */
5734 #endif /* defined (SIGNALS_VIA_CHARACTERS) */
5737 /* Get the current pgrp using the tty itself, if we have that.
5738 Otherwise, use the pty to get the pgrp.
5739 On pfa systems, saka@pfu.fujitsu.co.JP writes:
5740 "TIOCGPGRP symbol defined in sys/ioctl.h at E50.
5741 But, TIOCGPGRP does not work on E50 ;-P works fine on E60"
5742 His patch indicates that if TIOCGPGRP returns an error, then
5743 we should just assume that p->pid is also the process group id. */
5745 gid
= emacs_get_tty_pgrp (p
);
5748 /* If we can't get the information, assume
5749 the shell owns the tty. */
5752 /* It is not clear whether anything really can set GID to -1.
5753 Perhaps on some system one of those ioctls can or could do so.
5754 Or perhaps this is vestigial. */
5757 #else /* ! defined (TIOCGPGRP ) */
5758 /* Can't select pgrps on this system, so we know that
5759 the child itself heads the pgrp. */
5761 #endif /* ! defined (TIOCGPGRP ) */
5763 /* If current_group is lambda, and the shell owns the terminal,
5764 don't send any signal. */
5765 if (EQ (current_group
, Qlambda
) && gid
== p
->pid
)
5773 p
->raw_status_new
= 0;
5774 pset_status (p
, Qrun
);
5775 p
->tick
= ++process_tick
;
5778 status_notify (NULL
);
5779 redisplay_preserve_echo_area (13);
5782 #endif /* ! defined (SIGCONT) */
5786 flush_pending_output (p
->infd
);
5790 /* If we don't have process groups, send the signal to the immediate
5791 subprocess. That isn't really right, but it's better than any
5792 obvious alternative. */
5795 kill (p
->pid
, signo
);
5799 /* gid may be a pid, or minus a pgrp's number */
5801 if (!NILP (current_group
))
5803 if (ioctl (p
->infd
, TIOCSIGSEND
, signo
) == -1)
5811 #else /* ! defined (TIOCSIGSEND) */
5813 #endif /* ! defined (TIOCSIGSEND) */
5816 DEFUN ("interrupt-process", Finterrupt_process
, Sinterrupt_process
, 0, 2, 0,
5817 doc
: /* Interrupt process PROCESS.
5818 PROCESS may be a process, a buffer, or the name of a process or buffer.
5819 No arg or nil means current buffer's process.
5820 Second arg CURRENT-GROUP non-nil means send signal to
5821 the current process-group of the process's controlling terminal
5822 rather than to the process's own process group.
5823 If the process is a shell, this means interrupt current subjob
5824 rather than the shell.
5826 If CURRENT-GROUP is `lambda', and if the shell owns the terminal,
5827 don't send the signal. */)
5828 (Lisp_Object process
, Lisp_Object current_group
)
5830 process_send_signal (process
, SIGINT
, current_group
, 0);
5834 DEFUN ("kill-process", Fkill_process
, Skill_process
, 0, 2, 0,
5835 doc
: /* Kill process PROCESS. May be process or name of one.
5836 See function `interrupt-process' for more details on usage. */)
5837 (Lisp_Object process
, Lisp_Object current_group
)
5839 process_send_signal (process
, SIGKILL
, current_group
, 0);
5843 DEFUN ("quit-process", Fquit_process
, Squit_process
, 0, 2, 0,
5844 doc
: /* Send QUIT signal to process PROCESS. May be process or name of one.
5845 See function `interrupt-process' for more details on usage. */)
5846 (Lisp_Object process
, Lisp_Object current_group
)
5848 process_send_signal (process
, SIGQUIT
, current_group
, 0);
5852 DEFUN ("stop-process", Fstop_process
, Sstop_process
, 0, 2, 0,
5853 doc
: /* Stop process PROCESS. May be process or name of one.
5854 See function `interrupt-process' for more details on usage.
5855 If PROCESS is a network or serial process, inhibit handling of incoming
5857 (Lisp_Object process
, Lisp_Object current_group
)
5859 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
5861 struct Lisp_Process
*p
;
5863 p
= XPROCESS (process
);
5864 if (NILP (p
->command
)
5867 FD_CLR (p
->infd
, &input_wait_mask
);
5868 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
5870 pset_command (p
, Qt
);
5874 error ("No SIGTSTP support");
5876 process_send_signal (process
, SIGTSTP
, current_group
, 0);
5881 DEFUN ("continue-process", Fcontinue_process
, Scontinue_process
, 0, 2, 0,
5882 doc
: /* Continue process PROCESS. May be process or name of one.
5883 See function `interrupt-process' for more details on usage.
5884 If PROCESS is a network or serial process, resume handling of incoming
5886 (Lisp_Object process
, Lisp_Object current_group
)
5888 if (PROCESSP (process
) && (NETCONN_P (process
) || SERIALCONN_P (process
)))
5890 struct Lisp_Process
*p
;
5892 p
= XPROCESS (process
);
5893 if (EQ (p
->command
, Qt
)
5895 && (!EQ (p
->filter
, Qt
) || EQ (p
->status
, Qlisten
)))
5897 FD_SET (p
->infd
, &input_wait_mask
);
5898 FD_SET (p
->infd
, &non_keyboard_wait_mask
);
5900 if (fd_info
[ p
->infd
].flags
& FILE_SERIAL
)
5901 PurgeComm (fd_info
[ p
->infd
].hnd
, PURGE_RXABORT
| PURGE_RXCLEAR
);
5902 #else /* not WINDOWSNT */
5903 tcflush (p
->infd
, TCIFLUSH
);
5904 #endif /* not WINDOWSNT */
5906 pset_command (p
, Qnil
);
5910 process_send_signal (process
, SIGCONT
, current_group
, 0);
5912 error ("No SIGCONT support");
5917 /* Return the integer value of the signal whose abbreviation is ABBR,
5918 or a negative number if there is no such signal. */
5920 abbr_to_signal (char const *name
)
5923 char sigbuf
[20]; /* Large enough for all valid signal abbreviations. */
5925 if (!strncmp (name
, "SIG", 3) || !strncmp (name
, "sig", 3))
5928 for (i
= 0; i
< sizeof sigbuf
; i
++)
5930 sigbuf
[i
] = c_toupper (name
[i
]);
5932 return str2sig (sigbuf
, &signo
) == 0 ? signo
: -1;
5938 DEFUN ("signal-process", Fsignal_process
, Ssignal_process
,
5939 2, 2, "sProcess (name or number): \nnSignal code: ",
5940 doc
: /* Send PROCESS the signal with code SIGCODE.
5941 PROCESS may also be a number specifying the process id of the
5942 process to signal; in this case, the process need not be a child of
5944 SIGCODE may be an integer, or a symbol whose name is a signal name. */)
5945 (Lisp_Object process
, Lisp_Object sigcode
)
5950 if (STRINGP (process
))
5952 Lisp_Object tem
= Fget_process (process
);
5955 Lisp_Object process_number
=
5956 string_to_number (SSDATA (process
), 10, 1);
5957 if (INTEGERP (process_number
) || FLOATP (process_number
))
5958 tem
= process_number
;
5962 else if (!NUMBERP (process
))
5963 process
= get_process (process
);
5968 if (NUMBERP (process
))
5969 CONS_TO_INTEGER (process
, pid_t
, pid
);
5972 CHECK_PROCESS (process
);
5973 pid
= XPROCESS (process
)->pid
;
5975 error ("Cannot signal process %s", SDATA (XPROCESS (process
)->name
));
5978 if (INTEGERP (sigcode
))
5980 CHECK_TYPE_RANGED_INTEGER (int, sigcode
);
5981 signo
= XINT (sigcode
);
5987 CHECK_SYMBOL (sigcode
);
5988 name
= SSDATA (SYMBOL_NAME (sigcode
));
5990 signo
= abbr_to_signal (name
);
5992 error ("Undefined signal name %s", name
);
5995 return make_number (kill (pid
, signo
));
5998 DEFUN ("process-send-eof", Fprocess_send_eof
, Sprocess_send_eof
, 0, 1, 0,
5999 doc
: /* Make PROCESS see end-of-file in its input.
6000 EOF comes after any text already sent to it.
6001 PROCESS may be a process, a buffer, the name of a process or buffer, or
6002 nil, indicating the current buffer's process.
6003 If PROCESS is a network connection, or is a process communicating
6004 through a pipe (as opposed to a pty), then you cannot send any more
6005 text to PROCESS after you call this function.
6006 If PROCESS is a serial process, wait until all output written to the
6007 process has been transmitted to the serial port. */)
6008 (Lisp_Object process
)
6011 struct coding_system
*coding
;
6013 if (DATAGRAM_CONN_P (process
))
6016 proc
= get_process (process
);
6017 coding
= proc_encode_coding_system
[XPROCESS (proc
)->outfd
];
6019 /* Make sure the process is really alive. */
6020 if (XPROCESS (proc
)->raw_status_new
)
6021 update_status (XPROCESS (proc
));
6022 if (! EQ (XPROCESS (proc
)->status
, Qrun
))
6023 error ("Process %s not running", SDATA (XPROCESS (proc
)->name
));
6025 if (CODING_REQUIRE_FLUSHING (coding
))
6027 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
6028 send_process (proc
, "", 0, Qnil
);
6031 if (XPROCESS (proc
)->pty_flag
)
6032 send_process (proc
, "\004", 1, Qnil
);
6033 else if (EQ (XPROCESS (proc
)->type
, Qserial
))
6036 if (tcdrain (XPROCESS (proc
)->outfd
) != 0)
6037 error ("tcdrain() failed: %s", emacs_strerror (errno
));
6038 #endif /* not WINDOWSNT */
6039 /* Do nothing on Windows because writes are blocking. */
6043 int old_outfd
, new_outfd
;
6045 #ifdef HAVE_SHUTDOWN
6046 /* If this is a network connection, or socketpair is used
6047 for communication with the subprocess, call shutdown to cause EOF.
6048 (In some old system, shutdown to socketpair doesn't work.
6049 Then we just can't win.) */
6050 if (EQ (XPROCESS (proc
)->type
, Qnetwork
)
6051 || XPROCESS (proc
)->outfd
== XPROCESS (proc
)->infd
)
6052 shutdown (XPROCESS (proc
)->outfd
, 1);
6053 /* In case of socketpair, outfd == infd, so don't close it. */
6054 if (XPROCESS (proc
)->outfd
!= XPROCESS (proc
)->infd
)
6055 emacs_close (XPROCESS (proc
)->outfd
);
6056 #else /* not HAVE_SHUTDOWN */
6057 emacs_close (XPROCESS (proc
)->outfd
);
6058 #endif /* not HAVE_SHUTDOWN */
6059 new_outfd
= emacs_open (NULL_DEVICE
, O_WRONLY
, 0);
6062 old_outfd
= XPROCESS (proc
)->outfd
;
6064 if (!proc_encode_coding_system
[new_outfd
])
6065 proc_encode_coding_system
[new_outfd
]
6066 = xmalloc (sizeof (struct coding_system
));
6067 *proc_encode_coding_system
[new_outfd
]
6068 = *proc_encode_coding_system
[old_outfd
];
6069 memset (proc_encode_coding_system
[old_outfd
], 0,
6070 sizeof (struct coding_system
));
6072 XPROCESS (proc
)->outfd
= new_outfd
;
6077 /* The main Emacs thread records child processes in three places:
6079 - Vprocess_alist, for asynchronous subprocesses, which are child
6080 processes visible to Lisp.
6082 - deleted_pid_list, for child processes invisible to Lisp,
6083 typically because of delete-process. These are recorded so that
6084 the processes can be reaped when they exit, so that the operating
6085 system's process table is not cluttered by zombies.
6087 - the local variable PID in Fcall_process, call_process_cleanup and
6088 call_process_kill, for synchronous subprocesses.
6089 record_unwind_protect is used to make sure this process is not
6090 forgotten: if the user interrupts call-process and the child
6091 process refuses to exit immediately even with two C-g's,
6092 call_process_kill adds PID's contents to deleted_pid_list before
6095 The main Emacs thread invokes waitpid only on child processes that
6096 it creates and that have not been reaped. This avoid races on
6097 platforms such as GTK, where other threads create their own
6098 subprocesses which the main thread should not reap. For example,
6099 if the main thread attempted to reap an already-reaped child, it
6100 might inadvertently reap a GTK-created process that happened to
6101 have the same process ID. */
6103 /* Handle a SIGCHLD signal by looking for known child processes of
6104 Emacs whose status have changed. For each one found, record its
6107 All we do is change the status; we do not run sentinels or print
6108 notifications. That is saved for the next time keyboard input is
6109 done, in order to avoid timing errors.
6111 ** WARNING: this can be called during garbage collection.
6112 Therefore, it must not be fooled by the presence of mark bits in
6115 ** USG WARNING: Although it is not obvious from the documentation
6116 in signal(2), on a USG system the SIGCLD handler MUST NOT call
6117 signal() before executing at least one wait(), otherwise the
6118 handler will be called again, resulting in an infinite loop. The
6119 relevant portion of the documentation reads "SIGCLD signals will be
6120 queued and the signal-catching function will be continually
6121 reentered until the queue is empty". Invoking signal() causes the
6122 kernel to reexamine the SIGCLD queue. Fred Fish, UniSoft Systems
6125 ** Malloc WARNING: This should never call malloc either directly or
6126 indirectly; if it does, that is a bug */
6129 handle_child_signal (int sig
)
6133 /* Find the process that signaled us, and record its status. */
6135 /* The process can have been deleted by Fdelete_process, or have
6136 been started asynchronously by Fcall_process. */
6137 for (tail
= deleted_pid_list
; CONSP (tail
); tail
= XCDR (tail
))
6139 bool all_pids_are_fixnums
6140 = (MOST_NEGATIVE_FIXNUM
<= TYPE_MINIMUM (pid_t
)
6141 && TYPE_MAXIMUM (pid_t
) <= MOST_POSITIVE_FIXNUM
);
6142 Lisp_Object xpid
= XCAR (tail
);
6143 if (all_pids_are_fixnums
? INTEGERP (xpid
) : NUMBERP (xpid
))
6146 if (INTEGERP (xpid
))
6147 deleted_pid
= XINT (xpid
);
6149 deleted_pid
= XFLOAT_DATA (xpid
);
6150 if (child_status_changed (deleted_pid
, 0, 0))
6151 XSETCAR (tail
, Qnil
);
6155 /* Otherwise, if it is asynchronous, it is in Vprocess_alist. */
6156 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6158 Lisp_Object proc
= XCDR (XCAR (tail
));
6159 struct Lisp_Process
*p
= XPROCESS (proc
);
6163 && child_status_changed (p
->pid
, &status
, WUNTRACED
| WCONTINUED
))
6165 /* Change the status of the process that was found. */
6166 p
->tick
= ++process_tick
;
6167 p
->raw_status
= status
;
6168 p
->raw_status_new
= 1;
6170 /* If process has terminated, stop waiting for its output. */
6171 if (WIFSIGNALED (status
) || WIFEXITED (status
))
6173 bool clear_desc_flag
= 0;
6176 clear_desc_flag
= 1;
6178 /* clear_desc_flag avoids a compiler bug in Microsoft C. */
6179 if (clear_desc_flag
)
6181 FD_CLR (p
->infd
, &input_wait_mask
);
6182 FD_CLR (p
->infd
, &non_keyboard_wait_mask
);
6190 deliver_child_signal (int sig
)
6192 deliver_process_signal (sig
, handle_child_signal
);
6197 exec_sentinel_error_handler (Lisp_Object error_val
)
6199 cmd_error_internal (error_val
, "error in process sentinel: ");
6201 update_echo_area ();
6202 Fsleep_for (make_number (2), Qnil
);
6207 exec_sentinel (Lisp_Object proc
, Lisp_Object reason
)
6209 Lisp_Object sentinel
, odeactivate
;
6210 struct Lisp_Process
*p
= XPROCESS (proc
);
6211 ptrdiff_t count
= SPECPDL_INDEX ();
6212 bool outer_running_asynch_code
= running_asynch_code
;
6213 int waiting
= waiting_for_user_input_p
;
6215 if (inhibit_sentinels
)
6218 /* No need to gcpro these, because all we do with them later
6219 is test them for EQness, and none of them should be a string. */
6220 odeactivate
= Vdeactivate_mark
;
6222 Lisp_Object obuffer
, okeymap
;
6223 XSETBUFFER (obuffer
, current_buffer
);
6224 okeymap
= BVAR (current_buffer
, keymap
);
6227 /* There's no good reason to let sentinels change the current
6228 buffer, and many callers of accept-process-output, sit-for, and
6229 friends don't expect current-buffer to be changed from under them. */
6230 record_unwind_current_buffer ();
6232 sentinel
= p
->sentinel
;
6234 /* Inhibit quit so that random quits don't screw up a running filter. */
6235 specbind (Qinhibit_quit
, Qt
);
6236 specbind (Qlast_nonmenu_event
, Qt
); /* Why? --Stef */
6238 /* In case we get recursively called,
6239 and we already saved the match data nonrecursively,
6240 save the same match data in safely recursive fashion. */
6241 if (outer_running_asynch_code
)
6244 tem
= Fmatch_data (Qnil
, Qnil
, Qnil
);
6245 restore_search_regs ();
6246 record_unwind_save_match_data ();
6247 Fset_match_data (tem
, Qt
);
6250 /* For speed, if a search happens within this code,
6251 save the match data in a special nonrecursive fashion. */
6252 running_asynch_code
= 1;
6254 internal_condition_case_1 (read_process_output_call
,
6256 Fcons (proc
, Fcons (reason
, Qnil
))),
6257 !NILP (Vdebug_on_error
) ? Qnil
: Qerror
,
6258 exec_sentinel_error_handler
);
6260 /* If we saved the match data nonrecursively, restore it now. */
6261 restore_search_regs ();
6262 running_asynch_code
= outer_running_asynch_code
;
6264 Vdeactivate_mark
= odeactivate
;
6266 /* Restore waiting_for_user_input_p as it was
6267 when we were called, in case the filter clobbered it. */
6268 waiting_for_user_input_p
= waiting
;
6271 if (! EQ (Fcurrent_buffer (), obuffer
)
6272 || ! EQ (current_buffer
->keymap
, okeymap
))
6274 /* But do it only if the caller is actually going to read events.
6275 Otherwise there's no need to make him wake up, and it could
6276 cause trouble (for example it would make sit_for return). */
6277 if (waiting_for_user_input_p
== -1)
6278 record_asynch_buffer_change ();
6280 unbind_to (count
, Qnil
);
6283 /* Report all recent events of a change in process status
6284 (either run the sentinel or output a message).
6285 This is usually done while Emacs is waiting for keyboard input
6286 but can be done at other times. */
6289 status_notify (struct Lisp_Process
*deleting_process
)
6291 register Lisp_Object proc
;
6292 Lisp_Object tail
, msg
;
6293 struct gcpro gcpro1
, gcpro2
;
6297 /* We need to gcpro tail; if read_process_output calls a filter
6298 which deletes a process and removes the cons to which tail points
6299 from Vprocess_alist, and then causes a GC, tail is an unprotected
6303 /* Set this now, so that if new processes are created by sentinels
6304 that we run, we get called again to handle their status changes. */
6305 update_tick
= process_tick
;
6307 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6310 register struct Lisp_Process
*p
;
6312 proc
= Fcdr (XCAR (tail
));
6313 p
= XPROCESS (proc
);
6315 if (p
->tick
!= p
->update_tick
)
6317 p
->update_tick
= p
->tick
;
6319 /* If process is still active, read any output that remains. */
6320 while (! EQ (p
->filter
, Qt
)
6321 && ! EQ (p
->status
, Qconnect
)
6322 && ! EQ (p
->status
, Qlisten
)
6323 /* Network or serial process not stopped: */
6324 && ! EQ (p
->command
, Qt
)
6326 && p
!= deleting_process
6327 && read_process_output (proc
, p
->infd
) > 0);
6329 /* Get the text to use for the message. */
6330 if (p
->raw_status_new
)
6332 msg
= status_message (p
);
6334 /* If process is terminated, deactivate it or delete it. */
6336 if (CONSP (p
->status
))
6337 symbol
= XCAR (p
->status
);
6339 if (EQ (symbol
, Qsignal
) || EQ (symbol
, Qexit
)
6340 || EQ (symbol
, Qclosed
))
6342 if (delete_exited_processes
)
6343 remove_process (proc
);
6345 deactivate_process (proc
);
6348 /* The actions above may have further incremented p->tick.
6349 So set p->update_tick again so that an error in the sentinel will
6350 not cause this code to be run again. */
6351 p
->update_tick
= p
->tick
;
6352 /* Now output the message suitably. */
6353 exec_sentinel (proc
, msg
);
6357 update_mode_lines
++; /* In case buffers use %s in mode-line-format. */
6361 DEFUN ("internal-default-process-sentinel", Finternal_default_process_sentinel
,
6362 Sinternal_default_process_sentinel
, 2, 2, 0,
6363 doc
: /* Function used as default sentinel for processes. */)
6364 (Lisp_Object proc
, Lisp_Object msg
)
6366 Lisp_Object buffer
, symbol
;
6367 struct Lisp_Process
*p
;
6368 CHECK_PROCESS (proc
);
6369 p
= XPROCESS (proc
);
6373 symbol
= XCAR (symbol
);
6375 if (!EQ (symbol
, Qrun
) && !NILP (buffer
))
6378 struct buffer
*old
= current_buffer
;
6379 ptrdiff_t opoint
, opoint_byte
;
6380 ptrdiff_t before
, before_byte
;
6382 /* Avoid error if buffer is deleted
6383 (probably that's why the process is dead, too). */
6384 if (!BUFFER_LIVE_P (XBUFFER (buffer
)))
6386 Fset_buffer (buffer
);
6388 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
6389 msg
= (code_convert_string_norecord
6390 (msg
, Vlocale_coding_system
, 1));
6393 opoint_byte
= PT_BYTE
;
6394 /* Insert new output into buffer
6395 at the current end-of-output marker,
6396 thus preserving logical ordering of input and output. */
6397 if (XMARKER (p
->mark
)->buffer
)
6398 Fgoto_char (p
->mark
);
6400 SET_PT_BOTH (ZV
, ZV_BYTE
);
6403 before_byte
= PT_BYTE
;
6405 tem
= BVAR (current_buffer
, read_only
);
6406 bset_read_only (current_buffer
, Qnil
);
6407 insert_string ("\nProcess ");
6408 { /* FIXME: temporary kludge. */
6409 Lisp_Object tem2
= p
->name
; Finsert (1, &tem2
); }
6410 insert_string (" ");
6412 bset_read_only (current_buffer
, tem
);
6413 set_marker_both (p
->mark
, p
->buffer
, PT
, PT_BYTE
);
6415 if (opoint
>= before
)
6416 SET_PT_BOTH (opoint
+ (PT
- before
),
6417 opoint_byte
+ (PT_BYTE
- before_byte
));
6419 SET_PT_BOTH (opoint
, opoint_byte
);
6421 set_buffer_internal (old
);
6427 DEFUN ("set-process-coding-system", Fset_process_coding_system
,
6428 Sset_process_coding_system
, 1, 3, 0,
6429 doc
: /* Set coding systems of PROCESS to DECODING and ENCODING.
6430 DECODING will be used to decode subprocess output and ENCODING to
6431 encode subprocess input. */)
6432 (register Lisp_Object process
, Lisp_Object decoding
, Lisp_Object encoding
)
6434 register struct Lisp_Process
*p
;
6436 CHECK_PROCESS (process
);
6437 p
= XPROCESS (process
);
6439 error ("Input file descriptor of %s closed", SDATA (p
->name
));
6441 error ("Output file descriptor of %s closed", SDATA (p
->name
));
6442 Fcheck_coding_system (decoding
);
6443 Fcheck_coding_system (encoding
);
6444 encoding
= coding_inherit_eol_type (encoding
, Qnil
);
6445 pset_decode_coding_system (p
, decoding
);
6446 pset_encode_coding_system (p
, encoding
);
6447 setup_process_coding_systems (process
);
6452 DEFUN ("process-coding-system",
6453 Fprocess_coding_system
, Sprocess_coding_system
, 1, 1, 0,
6454 doc
: /* Return a cons of coding systems for decoding and encoding of PROCESS. */)
6455 (register Lisp_Object process
)
6457 CHECK_PROCESS (process
);
6458 return Fcons (XPROCESS (process
)->decode_coding_system
,
6459 XPROCESS (process
)->encode_coding_system
);
6462 DEFUN ("set-process-filter-multibyte", Fset_process_filter_multibyte
,
6463 Sset_process_filter_multibyte
, 2, 2, 0,
6464 doc
: /* Set multibyteness of the strings given to PROCESS's filter.
6465 If FLAG is non-nil, the filter is given multibyte strings.
6466 If FLAG is nil, the filter is given unibyte strings. In this case,
6467 all character code conversion except for end-of-line conversion is
6469 (Lisp_Object process
, Lisp_Object flag
)
6471 register struct Lisp_Process
*p
;
6473 CHECK_PROCESS (process
);
6474 p
= XPROCESS (process
);
6476 pset_decode_coding_system
6477 (p
, raw_text_coding_system (p
->decode_coding_system
));
6478 setup_process_coding_systems (process
);
6483 DEFUN ("process-filter-multibyte-p", Fprocess_filter_multibyte_p
,
6484 Sprocess_filter_multibyte_p
, 1, 1, 0,
6485 doc
: /* Return t if a multibyte string is given to PROCESS's filter.*/)
6486 (Lisp_Object process
)
6488 register struct Lisp_Process
*p
;
6489 struct coding_system
*coding
;
6491 CHECK_PROCESS (process
);
6492 p
= XPROCESS (process
);
6493 coding
= proc_decode_coding_system
[p
->infd
];
6494 return (CODING_FOR_UNIBYTE (coding
) ? Qnil
: Qt
);
6503 add_gpm_wait_descriptor (int desc
)
6505 add_keyboard_wait_descriptor (desc
);
6509 delete_gpm_wait_descriptor (int desc
)
6511 delete_keyboard_wait_descriptor (desc
);
6516 # ifdef USABLE_SIGIO
6518 /* Return true if *MASK has a bit set
6519 that corresponds to one of the keyboard input descriptors. */
6522 keyboard_bit_set (fd_set
*mask
)
6526 for (fd
= 0; fd
<= max_input_desc
; fd
++)
6527 if (FD_ISSET (fd
, mask
) && FD_ISSET (fd
, &input_wait_mask
)
6528 && !FD_ISSET (fd
, &non_keyboard_wait_mask
))
6535 #else /* not subprocesses */
6537 /* Defined on msdos.c. */
6538 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
6539 EMACS_TIME
*, void *);
6541 /* Implementation of wait_reading_process_output, assuming that there
6542 are no subprocesses. Used only by the MS-DOS build.
6544 Wait for timeout to elapse and/or keyboard input to be available.
6548 If negative, gobble data immediately available but don't wait for any.
6551 an additional duration to wait, measured in nanoseconds
6552 If TIME_LIMIT is zero, then:
6553 If NSECS == 0, there is no limit.
6554 If NSECS > 0, the timeout consists of NSECS only.
6555 If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative.
6558 0 to ignore keyboard input, or
6559 1 to return when input is available, or
6560 -1 means caller will actually read the input, so don't throw to
6563 see full version for other parameters. We know that wait_proc will
6564 always be NULL, since `subprocesses' isn't defined.
6566 DO_DISPLAY means redisplay should be done to show subprocess
6567 output that arrives.
6569 Return true if we received input from any process. */
6572 wait_reading_process_output (intmax_t time_limit
, int nsecs
, int read_kbd
,
6574 Lisp_Object wait_for_cell
,
6575 struct Lisp_Process
*wait_proc
, int just_wait_proc
)
6578 EMACS_TIME end_time
, timeout
;
6585 else if (TYPE_MAXIMUM (time_t) < time_limit
)
6586 time_limit
= TYPE_MAXIMUM (time_t);
6588 /* What does time_limit really mean? */
6589 if (time_limit
|| nsecs
> 0)
6591 timeout
= make_emacs_time (time_limit
, nsecs
);
6592 end_time
= add_emacs_time (current_emacs_time (), timeout
);
6595 /* Turn off periodic alarms (in case they are in use)
6596 and then turn off any other atimers,
6597 because the select emulator uses alarms. */
6599 turn_on_atimers (0);
6603 bool timeout_reduced_for_timers
= 0;
6604 SELECT_TYPE waitchannels
;
6607 /* If calling from keyboard input, do not quit
6608 since we want to return C-g as an input character.
6609 Otherwise, do pending quit if requested. */
6613 /* Exit now if the cell we're waiting for became non-nil. */
6614 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
6617 /* Compute time from now till when time limit is up. */
6618 /* Exit if already run out. */
6621 /* A negative timeout means
6622 gobble output available now
6623 but don't wait at all. */
6625 timeout
= make_emacs_time (0, 0);
6627 else if (time_limit
|| nsecs
> 0)
6629 EMACS_TIME now
= current_emacs_time ();
6630 if (EMACS_TIME_LE (end_time
, now
))
6632 timeout
= sub_emacs_time (end_time
, now
);
6636 timeout
= make_emacs_time (100000, 0);
6639 /* If our caller will not immediately handle keyboard events,
6640 run timer events directly.
6641 (Callers that will immediately read keyboard events
6642 call timer_delay on their own.) */
6643 if (NILP (wait_for_cell
))
6645 EMACS_TIME timer_delay
;
6649 unsigned old_timers_run
= timers_run
;
6650 timer_delay
= timer_check ();
6651 if (timers_run
!= old_timers_run
&& do_display
)
6652 /* We must retry, since a timer may have requeued itself
6653 and that could alter the time delay. */
6654 redisplay_preserve_echo_area (14);
6658 while (!detect_input_pending ());
6660 /* If there is unread keyboard input, also return. */
6662 && requeued_events_pending_p ())
6665 if (EMACS_TIME_VALID_P (timer_delay
) && nsecs
>= 0)
6667 if (EMACS_TIME_LT (timer_delay
, timeout
))
6669 timeout
= timer_delay
;
6670 timeout_reduced_for_timers
= 1;
6675 /* Cause C-g and alarm signals to take immediate action,
6676 and cause input available signals to zero out timeout. */
6678 set_waiting_for_input (&timeout
);
6680 /* If a frame has been newly mapped and needs updating,
6681 reprocess its display stuff. */
6682 if (frame_garbaged
&& do_display
)
6684 clear_waiting_for_input ();
6685 redisplay_preserve_echo_area (15);
6687 set_waiting_for_input (&timeout
);
6690 /* Wait till there is something to do. */
6691 FD_ZERO (&waitchannels
);
6692 if (read_kbd
&& detect_input_pending ())
6696 if (read_kbd
|| !NILP (wait_for_cell
))
6697 FD_SET (0, &waitchannels
);
6698 nfds
= pselect (1, &waitchannels
, NULL
, NULL
, &timeout
, NULL
);
6703 /* Make C-g and alarm signals set flags again */
6704 clear_waiting_for_input ();
6706 /* If we woke up due to SIGWINCH, actually change size now. */
6707 do_pending_window_change (0);
6709 if ((time_limit
|| nsecs
) && nfds
== 0 && ! timeout_reduced_for_timers
)
6710 /* We waited the full specified time, so return now. */
6715 /* If the system call was interrupted, then go around the
6717 if (xerrno
== EINTR
)
6718 FD_ZERO (&waitchannels
);
6720 error ("select error: %s", emacs_strerror (xerrno
));
6723 /* Check for keyboard input */
6726 && detect_input_pending_run_timers (do_display
))
6728 swallow_events (do_display
);
6729 if (detect_input_pending_run_timers (do_display
))
6733 /* If there is unread keyboard input, also return. */
6735 && requeued_events_pending_p ())
6738 /* If wait_for_cell. check for keyboard input
6739 but don't run any timers.
6740 ??? (It seems wrong to me to check for keyboard
6741 input at all when wait_for_cell, but the code
6742 has been this way since July 1994.
6743 Try changing this after version 19.31.) */
6744 if (! NILP (wait_for_cell
)
6745 && detect_input_pending ())
6747 swallow_events (do_display
);
6748 if (detect_input_pending ())
6752 /* Exit now if the cell we're waiting for became non-nil. */
6753 if (! NILP (wait_for_cell
) && ! NILP (XCAR (wait_for_cell
)))
6762 #endif /* not subprocesses */
6764 /* The following functions are needed even if async subprocesses are
6765 not supported. Some of them are no-op stubs in that case. */
6767 /* Add DESC to the set of keyboard input descriptors. */
6770 add_keyboard_wait_descriptor (int desc
)
6772 #ifdef subprocesses /* actually means "not MSDOS" */
6773 FD_SET (desc
, &input_wait_mask
);
6774 FD_SET (desc
, &non_process_wait_mask
);
6775 if (desc
> max_input_desc
)
6776 max_input_desc
= desc
;
6780 /* From now on, do not expect DESC to give keyboard input. */
6783 delete_keyboard_wait_descriptor (int desc
)
6787 int lim
= max_input_desc
;
6789 FD_CLR (desc
, &input_wait_mask
);
6790 FD_CLR (desc
, &non_process_wait_mask
);
6792 if (desc
== max_input_desc
)
6793 for (fd
= 0; fd
< lim
; fd
++)
6794 if (FD_ISSET (fd
, &input_wait_mask
) || FD_ISSET (fd
, &write_mask
))
6795 max_input_desc
= fd
;
6799 /* Setup coding systems of PROCESS. */
6802 setup_process_coding_systems (Lisp_Object process
)
6805 struct Lisp_Process
*p
= XPROCESS (process
);
6807 int outch
= p
->outfd
;
6808 Lisp_Object coding_system
;
6810 if (inch
< 0 || outch
< 0)
6813 if (!proc_decode_coding_system
[inch
])
6814 proc_decode_coding_system
[inch
] = xmalloc (sizeof (struct coding_system
));
6815 coding_system
= p
->decode_coding_system
;
6816 if (EQ (p
->filter
, Qinternal_default_process_filter
)
6817 && BUFFERP (p
->buffer
))
6819 if (NILP (BVAR (XBUFFER (p
->buffer
), enable_multibyte_characters
)))
6820 coding_system
= raw_text_coding_system (coding_system
);
6822 setup_coding_system (coding_system
, proc_decode_coding_system
[inch
]);
6824 if (!proc_encode_coding_system
[outch
])
6825 proc_encode_coding_system
[outch
] = xmalloc (sizeof (struct coding_system
));
6826 setup_coding_system (p
->encode_coding_system
,
6827 proc_encode_coding_system
[outch
]);
6831 /* Close all descriptors currently in use for communication
6832 with subprocess. This is used in a newly-forked subprocess
6833 to get rid of irrelevant descriptors. */
6836 close_process_descs (void)
6840 for (i
= 0; i
< MAXDESC
; i
++)
6842 Lisp_Object process
;
6843 process
= chan_process
[i
];
6844 if (!NILP (process
))
6846 int in
= XPROCESS (process
)->infd
;
6847 int out
= XPROCESS (process
)->outfd
;
6850 if (out
>= 0 && in
!= out
)
6857 DEFUN ("get-buffer-process", Fget_buffer_process
, Sget_buffer_process
, 1, 1, 0,
6858 doc
: /* Return the (or a) process associated with BUFFER.
6859 BUFFER may be a buffer or the name of one. */)
6860 (register Lisp_Object buffer
)
6863 register Lisp_Object buf
, tail
, proc
;
6865 if (NILP (buffer
)) return Qnil
;
6866 buf
= Fget_buffer (buffer
);
6867 if (NILP (buf
)) return Qnil
;
6869 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6871 proc
= Fcdr (XCAR (tail
));
6872 if (PROCESSP (proc
) && EQ (XPROCESS (proc
)->buffer
, buf
))
6875 #endif /* subprocesses */
6879 DEFUN ("process-inherit-coding-system-flag",
6880 Fprocess_inherit_coding_system_flag
, Sprocess_inherit_coding_system_flag
,
6882 doc
: /* Return the value of inherit-coding-system flag for PROCESS.
6883 If this flag is t, `buffer-file-coding-system' of the buffer
6884 associated with PROCESS will inherit the coding system used to decode
6885 the process output. */)
6886 (register Lisp_Object process
)
6889 CHECK_PROCESS (process
);
6890 return XPROCESS (process
)->inherit_coding_system_flag
? Qt
: Qnil
;
6892 /* Ignore the argument and return the value of
6893 inherit-process-coding-system. */
6894 return inherit_process_coding_system
? Qt
: Qnil
;
6898 /* Kill all processes associated with `buffer'.
6899 If `buffer' is nil, kill all processes */
6902 kill_buffer_processes (Lisp_Object buffer
)
6905 Lisp_Object tail
, proc
;
6907 for (tail
= Vprocess_alist
; CONSP (tail
); tail
= XCDR (tail
))
6909 proc
= XCDR (XCAR (tail
));
6911 && (NILP (buffer
) || EQ (XPROCESS (proc
)->buffer
, buffer
)))
6913 if (NETCONN_P (proc
) || SERIALCONN_P (proc
))
6914 Fdelete_process (proc
);
6915 else if (XPROCESS (proc
)->infd
>= 0)
6916 process_send_signal (proc
, SIGHUP
, Qnil
, 1);
6919 #else /* subprocesses */
6920 /* Since we have no subprocesses, this does nothing. */
6921 #endif /* subprocesses */
6924 DEFUN ("waiting-for-user-input-p", Fwaiting_for_user_input_p
,
6925 Swaiting_for_user_input_p
, 0, 0, 0,
6926 doc
: /* Return non-nil if Emacs is waiting for input from the user.
6927 This is intended for use by asynchronous process output filters and sentinels. */)
6931 return (waiting_for_user_input_p
? Qt
: Qnil
);
6937 /* Stop reading input from keyboard sources. */
6940 hold_keyboard_input (void)
6945 /* Resume reading input from keyboard sources. */
6948 unhold_keyboard_input (void)
6953 /* Return true if keyboard input is on hold, zero otherwise. */
6956 kbd_on_hold_p (void)
6958 return kbd_is_on_hold
;
6962 /* Enumeration of and access to system processes a-la ps(1). */
6964 DEFUN ("list-system-processes", Flist_system_processes
, Slist_system_processes
,
6966 doc
: /* Return a list of numerical process IDs of all running processes.
6967 If this functionality is unsupported, return nil.
6969 See `process-attributes' for getting attributes of a process given its ID. */)
6972 return list_system_processes ();
6975 DEFUN ("process-attributes", Fprocess_attributes
,
6976 Sprocess_attributes
, 1, 1, 0,
6977 doc
: /* Return attributes of the process given by its PID, a number.
6979 Value is an alist where each element is a cons cell of the form
6983 If this functionality is unsupported, the value is nil.
6985 See `list-system-processes' for getting a list of all process IDs.
6987 The KEYs of the attributes that this function may return are listed
6988 below, together with the type of the associated VALUE (in parentheses).
6989 Not all platforms support all of these attributes; unsupported
6990 attributes will not appear in the returned alist.
6991 Unless explicitly indicated otherwise, numbers can have either
6992 integer or floating point values.
6994 euid -- Effective user User ID of the process (number)
6995 user -- User name corresponding to euid (string)
6996 egid -- Effective user Group ID of the process (number)
6997 group -- Group name corresponding to egid (string)
6998 comm -- Command name (executable name only) (string)
6999 state -- Process state code, such as "S", "R", or "T" (string)
7000 ppid -- Parent process ID (number)
7001 pgrp -- Process group ID (number)
7002 sess -- Session ID, i.e. process ID of session leader (number)
7003 ttname -- Controlling tty name (string)
7004 tpgid -- ID of foreground process group on the process's tty (number)
7005 minflt -- number of minor page faults (number)
7006 majflt -- number of major page faults (number)
7007 cminflt -- cumulative number of minor page faults (number)
7008 cmajflt -- cumulative number of major page faults (number)
7009 utime -- user time used by the process, in (current-time) format,
7010 which is a list of integers (HIGH LOW USEC PSEC)
7011 stime -- system time used by the process (current-time)
7012 time -- sum of utime and stime (current-time)
7013 cutime -- user time used by the process and its children (current-time)
7014 cstime -- system time used by the process and its children (current-time)
7015 ctime -- sum of cutime and cstime (current-time)
7016 pri -- priority of the process (number)
7017 nice -- nice value of the process (number)
7018 thcount -- process thread count (number)
7019 start -- time the process started (current-time)
7020 vsize -- virtual memory size of the process in KB's (number)
7021 rss -- resident set size of the process in KB's (number)
7022 etime -- elapsed time the process is running, in (HIGH LOW USEC PSEC) format
7023 pcpu -- percents of CPU time used by the process (floating-point number)
7024 pmem -- percents of total physical memory used by process's resident set
7025 (floating-point number)
7026 args -- command line which invoked the process (string). */)
7029 return system_process_attributes (pid
);
7033 /* This is not called "init_process" because that is the name of a
7034 Mach system call, so it would cause problems on Darwin systems. */
7036 init_process_emacs (void)
7041 inhibit_sentinels
= 0;
7044 if (! noninteractive
|| initialized
)
7047 struct sigaction action
;
7048 emacs_sigaction_init (&action
, deliver_child_signal
);
7049 sigaction (SIGCHLD
, &action
, 0);
7052 FD_ZERO (&input_wait_mask
);
7053 FD_ZERO (&non_keyboard_wait_mask
);
7054 FD_ZERO (&non_process_wait_mask
);
7055 FD_ZERO (&write_mask
);
7056 max_process_desc
= 0;
7057 memset (fd_callback_info
, 0, sizeof (fd_callback_info
));
7059 #ifdef NON_BLOCKING_CONNECT
7060 FD_ZERO (&connect_wait_mask
);
7061 num_pending_connects
= 0;
7064 #ifdef ADAPTIVE_READ_BUFFERING
7065 process_output_delay_count
= 0;
7066 process_output_skip
= 0;
7069 /* Don't do this, it caused infinite select loops. The display
7070 method should call add_keyboard_wait_descriptor on stdin if it
7073 FD_SET (0, &input_wait_mask
);
7076 Vprocess_alist
= Qnil
;
7077 deleted_pid_list
= Qnil
;
7078 for (i
= 0; i
< MAXDESC
; i
++)
7080 chan_process
[i
] = Qnil
;
7081 proc_buffered_char
[i
] = -1;
7083 memset (proc_decode_coding_system
, 0, sizeof proc_decode_coding_system
);
7084 memset (proc_encode_coding_system
, 0, sizeof proc_encode_coding_system
);
7085 #ifdef DATAGRAM_SOCKETS
7086 memset (datagram_address
, 0, sizeof datagram_address
);
7090 Lisp_Object subfeatures
= Qnil
;
7091 const struct socket_options
*sopt
;
7093 #define ADD_SUBFEATURE(key, val) \
7094 subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
7096 #ifdef NON_BLOCKING_CONNECT
7097 ADD_SUBFEATURE (QCnowait
, Qt
);
7099 #ifdef DATAGRAM_SOCKETS
7100 ADD_SUBFEATURE (QCtype
, Qdatagram
);
7102 #ifdef HAVE_SEQPACKET
7103 ADD_SUBFEATURE (QCtype
, Qseqpacket
);
7105 #ifdef HAVE_LOCAL_SOCKETS
7106 ADD_SUBFEATURE (QCfamily
, Qlocal
);
7108 ADD_SUBFEATURE (QCfamily
, Qipv4
);
7110 ADD_SUBFEATURE (QCfamily
, Qipv6
);
7112 #ifdef HAVE_GETSOCKNAME
7113 ADD_SUBFEATURE (QCservice
, Qt
);
7115 ADD_SUBFEATURE (QCserver
, Qt
);
7117 for (sopt
= socket_options
; sopt
->name
; sopt
++)
7118 subfeatures
= pure_cons (intern_c_string (sopt
->name
), subfeatures
);
7120 Fprovide (intern_c_string ("make-network-process"), subfeatures
);
7123 #if defined (DARWIN_OS)
7124 /* PTYs are broken on Darwin < 6, but are sometimes useful for interactive
7125 processes. As such, we only change the default value. */
7128 char const *release
= (STRINGP (Voperating_system_release
)
7129 ? SSDATA (Voperating_system_release
)
7131 if (!release
|| !release
[0] || (release
[0] < '7' && release
[1] == '.')) {
7132 Vprocess_connection_type
= Qnil
;
7136 #endif /* subprocesses */
7141 syms_of_process (void)
7145 DEFSYM (Qprocessp
, "processp");
7146 DEFSYM (Qrun
, "run");
7147 DEFSYM (Qstop
, "stop");
7148 DEFSYM (Qsignal
, "signal");
7150 /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
7153 Qexit = intern_c_string ("exit");
7154 staticpro (&Qexit); */
7156 DEFSYM (Qopen
, "open");
7157 DEFSYM (Qclosed
, "closed");
7158 DEFSYM (Qconnect
, "connect");
7159 DEFSYM (Qfailed
, "failed");
7160 DEFSYM (Qlisten
, "listen");
7161 DEFSYM (Qlocal
, "local");
7162 DEFSYM (Qipv4
, "ipv4");
7164 DEFSYM (Qipv6
, "ipv6");
7166 DEFSYM (Qdatagram
, "datagram");
7167 DEFSYM (Qseqpacket
, "seqpacket");
7169 DEFSYM (QCport
, ":port");
7170 DEFSYM (QCspeed
, ":speed");
7171 DEFSYM (QCprocess
, ":process");
7173 DEFSYM (QCbytesize
, ":bytesize");
7174 DEFSYM (QCstopbits
, ":stopbits");
7175 DEFSYM (QCparity
, ":parity");
7176 DEFSYM (Qodd
, "odd");
7177 DEFSYM (Qeven
, "even");
7178 DEFSYM (QCflowcontrol
, ":flowcontrol");
7181 DEFSYM (QCsummary
, ":summary");
7183 DEFSYM (Qreal
, "real");
7184 DEFSYM (Qnetwork
, "network");
7185 DEFSYM (Qserial
, "serial");
7186 DEFSYM (QCbuffer
, ":buffer");
7187 DEFSYM (QChost
, ":host");
7188 DEFSYM (QCservice
, ":service");
7189 DEFSYM (QClocal
, ":local");
7190 DEFSYM (QCremote
, ":remote");
7191 DEFSYM (QCcoding
, ":coding");
7192 DEFSYM (QCserver
, ":server");
7193 DEFSYM (QCnowait
, ":nowait");
7194 DEFSYM (QCsentinel
, ":sentinel");
7195 DEFSYM (QClog
, ":log");
7196 DEFSYM (QCnoquery
, ":noquery");
7197 DEFSYM (QCstop
, ":stop");
7198 DEFSYM (QCoptions
, ":options");
7199 DEFSYM (QCplist
, ":plist");
7201 DEFSYM (Qlast_nonmenu_event
, "last-nonmenu-event");
7203 staticpro (&Vprocess_alist
);
7204 staticpro (&deleted_pid_list
);
7206 #endif /* subprocesses */
7208 DEFSYM (QCname
, ":name");
7209 DEFSYM (QCtype
, ":type");
7211 DEFSYM (Qeuid
, "euid");
7212 DEFSYM (Qegid
, "egid");
7213 DEFSYM (Quser
, "user");
7214 DEFSYM (Qgroup
, "group");
7215 DEFSYM (Qcomm
, "comm");
7216 DEFSYM (Qstate
, "state");
7217 DEFSYM (Qppid
, "ppid");
7218 DEFSYM (Qpgrp
, "pgrp");
7219 DEFSYM (Qsess
, "sess");
7220 DEFSYM (Qttname
, "ttname");
7221 DEFSYM (Qtpgid
, "tpgid");
7222 DEFSYM (Qminflt
, "minflt");
7223 DEFSYM (Qmajflt
, "majflt");
7224 DEFSYM (Qcminflt
, "cminflt");
7225 DEFSYM (Qcmajflt
, "cmajflt");
7226 DEFSYM (Qutime
, "utime");
7227 DEFSYM (Qstime
, "stime");
7228 DEFSYM (Qtime
, "time");
7229 DEFSYM (Qcutime
, "cutime");
7230 DEFSYM (Qcstime
, "cstime");
7231 DEFSYM (Qctime
, "ctime");
7232 DEFSYM (Qinternal_default_process_sentinel
,
7233 "internal-default-process-sentinel");
7234 DEFSYM (Qinternal_default_process_filter
,
7235 "internal-default-process-filter");
7236 DEFSYM (Qpri
, "pri");
7237 DEFSYM (Qnice
, "nice");
7238 DEFSYM (Qthcount
, "thcount");
7239 DEFSYM (Qstart
, "start");
7240 DEFSYM (Qvsize
, "vsize");
7241 DEFSYM (Qrss
, "rss");
7242 DEFSYM (Qetime
, "etime");
7243 DEFSYM (Qpcpu
, "pcpu");
7244 DEFSYM (Qpmem
, "pmem");
7245 DEFSYM (Qargs
, "args");
7247 DEFVAR_BOOL ("delete-exited-processes", delete_exited_processes
,
7248 doc
: /* Non-nil means delete processes immediately when they exit.
7249 A value of nil means don't delete them until `list-processes' is run. */);
7251 delete_exited_processes
= 1;
7254 DEFVAR_LISP ("process-connection-type", Vprocess_connection_type
,
7255 doc
: /* Control type of device used to communicate with subprocesses.
7256 Values are nil to use a pipe, or t or `pty' to use a pty.
7257 The value has no effect if the system has no ptys or if all ptys are busy:
7258 then a pipe is used in any case.
7259 The value takes effect when `start-process' is called. */);
7260 Vprocess_connection_type
= Qt
;
7262 #ifdef ADAPTIVE_READ_BUFFERING
7263 DEFVAR_LISP ("process-adaptive-read-buffering", Vprocess_adaptive_read_buffering
,
7264 doc
: /* If non-nil, improve receive buffering by delaying after short reads.
7265 On some systems, when Emacs reads the output from a subprocess, the output data
7266 is read in very small blocks, potentially resulting in very poor performance.
7267 This behavior can be remedied to some extent by setting this variable to a
7268 non-nil value, as it will automatically delay reading from such processes, to
7269 allow them to produce more output before Emacs tries to read it.
7270 If the value is t, the delay is reset after each write to the process; any other
7271 non-nil value means that the delay is not reset on write.
7272 The variable takes effect when `start-process' is called. */);
7273 Vprocess_adaptive_read_buffering
= Qt
;
7276 defsubr (&Sprocessp
);
7277 defsubr (&Sget_process
);
7278 defsubr (&Sdelete_process
);
7279 defsubr (&Sprocess_status
);
7280 defsubr (&Sprocess_exit_status
);
7281 defsubr (&Sprocess_id
);
7282 defsubr (&Sprocess_name
);
7283 defsubr (&Sprocess_tty_name
);
7284 defsubr (&Sprocess_command
);
7285 defsubr (&Sset_process_buffer
);
7286 defsubr (&Sprocess_buffer
);
7287 defsubr (&Sprocess_mark
);
7288 defsubr (&Sset_process_filter
);
7289 defsubr (&Sprocess_filter
);
7290 defsubr (&Sset_process_sentinel
);
7291 defsubr (&Sprocess_sentinel
);
7292 defsubr (&Sset_process_window_size
);
7293 defsubr (&Sset_process_inherit_coding_system_flag
);
7294 defsubr (&Sset_process_query_on_exit_flag
);
7295 defsubr (&Sprocess_query_on_exit_flag
);
7296 defsubr (&Sprocess_contact
);
7297 defsubr (&Sprocess_plist
);
7298 defsubr (&Sset_process_plist
);
7299 defsubr (&Sprocess_list
);
7300 defsubr (&Sstart_process
);
7301 defsubr (&Sserial_process_configure
);
7302 defsubr (&Smake_serial_process
);
7303 defsubr (&Sset_network_process_option
);
7304 defsubr (&Smake_network_process
);
7305 defsubr (&Sformat_network_address
);
7306 #if defined (HAVE_NET_IF_H)
7308 defsubr (&Snetwork_interface_list
);
7310 #if defined (SIOCGIFADDR) || defined (SIOCGIFHWADDR) || defined (SIOCGIFFLAGS)
7311 defsubr (&Snetwork_interface_info
);
7313 #endif /* defined (HAVE_NET_IF_H) */
7314 #ifdef DATAGRAM_SOCKETS
7315 defsubr (&Sprocess_datagram_address
);
7316 defsubr (&Sset_process_datagram_address
);
7318 defsubr (&Saccept_process_output
);
7319 defsubr (&Sprocess_send_region
);
7320 defsubr (&Sprocess_send_string
);
7321 defsubr (&Sinterrupt_process
);
7322 defsubr (&Skill_process
);
7323 defsubr (&Squit_process
);
7324 defsubr (&Sstop_process
);
7325 defsubr (&Scontinue_process
);
7326 defsubr (&Sprocess_running_child_p
);
7327 defsubr (&Sprocess_send_eof
);
7328 defsubr (&Ssignal_process
);
7329 defsubr (&Swaiting_for_user_input_p
);
7330 defsubr (&Sprocess_type
);
7331 defsubr (&Sinternal_default_process_sentinel
);
7332 defsubr (&Sinternal_default_process_filter
);
7333 defsubr (&Sset_process_coding_system
);
7334 defsubr (&Sprocess_coding_system
);
7335 defsubr (&Sset_process_filter_multibyte
);
7336 defsubr (&Sprocess_filter_multibyte_p
);
7338 #endif /* subprocesses */
7340 defsubr (&Sget_buffer_process
);
7341 defsubr (&Sprocess_inherit_coding_system_flag
);
7342 defsubr (&Slist_system_processes
);
7343 defsubr (&Sprocess_attributes
);